OpenShot Library | libopenshot  0.3.0
TrackedObjectBBox.h
Go to the documentation of this file.
1 
10 // Copyright (c) 2008-2019 OpenShot Studios, LLC
11 //
12 // SPDX-License-Identifier: LGPL-3.0-or-later
13 
14 #ifndef OPENSHOT_TRACKEDOBJECTBBOX_H
15 #define OPENSHOT_TRACKEDOBJECTBBOX_H
16 
17 #include "TrackedObjectBase.h"
18 
19 #include "Color.h"
20 #include "Exceptions.h"
21 #include "Fraction.h"
22 #include "Json.h"
23 #include "KeyFrame.h"
24 
25 namespace openshot
26 {
37  struct BBox
38  {
39  float cx = -1;
40  float cy = -1;
41  float width = -1;
42  float height = -1;
43  float angle = -1;
44 
46  BBox() {}
47 
54  BBox(float _cx, float _cy, float _width, float _height, float _angle)
55  {
56  cx = _cx;
57  cy = _cy;
58  width = _width;
59  height = _height;
60  angle = _angle;
61  }
62 
63 
65  std::string Json() const
66  {
67  return JsonValue().toStyledString();
68  }
69 
71  Json::Value JsonValue() const
72  {
73  Json::Value root;
74  root["cx"] = cx;
75  root["cy"] = cy;
76  root["width"] = width;
77  root["height"] = height;
78  root["angle"] = angle;
79 
80  return root;
81  }
82 
84  void SetJson(const std::string value)
85  {
86  // Parse JSON string into JSON objects
87  try
88  {
89  const Json::Value root = openshot::stringToJson(value);
90  // Set all values that match
91  SetJsonValue(root);
92  }
93  catch (const std::exception &e)
94  {
95  // Error parsing JSON (or missing keys)
96  throw InvalidJSON("JSON is invalid (missing keys or invalid data types)");
97  }
98  }
99 
101  void SetJsonValue(const Json::Value root)
102  {
103 
104  // Set data from Json (if key is found)
105  if (!root["cx"].isNull())
106  cx = root["cx"].asDouble();
107  if (!root["cy"].isNull())
108  cy = root["cy"].asDouble();
109  if (!root["width"].isNull())
110  width = root["width"].asDouble();
111  if (!root["height"].isNull())
112  height = root["height"].asDouble();
113  if (!root["angle"].isNull())
114  angle = root["angle"].asDouble();
115  }
116  };
117 
131  {
132  private:
133  Fraction BaseFps;
134  double TimeScale;
135 
136  public:
137  std::map<double, BBox> BoxVec;
149 
150  std::string protobufDataPath;
151 
154  TrackedObjectBBox(int Red, int Green, int Blue, int Alfa);
155 
157  void AddBox(int64_t _frame_num, float _cx, float _cy, float _width, float _height, float _angle) override;
158 
160  void SetBaseFPS(Fraction fps);
161 
163  Fraction GetBaseFPS();
164 
166  void ScalePoints(double scale) override;
167 
169  bool Contains(int64_t frame_number) const;
171  bool ExactlyContains(int64_t frame_number) const override;
172 
174  int64_t GetLength() const;
175 
177  void RemoveBox(int64_t frame_number);
178 
180  BBox GetBox(int64_t frame_number);
182  BBox GetBox(int64_t frame_number) const
183  {
184  return const_cast<TrackedObjectBBox *>(this)->GetBox(frame_number);
185  }
186 
188  bool LoadBoxData(std::string inputFilePath);
189 
191  double FrameNToTime(int64_t frame_number, double time_scale) const;
192 
194  BBox InterpolateBoxes(double t1, double t2, BBox left, BBox right, double target);
195 
197  void clear();
198 
200  std::string Json() const override;
201  Json::Value JsonValue() const override;
202  void SetJson(const std::string value) override;
203  void SetJsonValue(const Json::Value root) override;
204 
207  Json::Value PropertiesJSON(int64_t requested_frame) const override;
208 
209  // Generate JSON for a property
210  Json::Value add_property_json(std::string name, float value, std::string type, std::string memo, const Keyframe* keyframe, float min_value, float max_value, bool readonly, int64_t requested_frame) const;
211 
213  std::map<std::string, float> GetBoxValues(int64_t frame_number) const override;
215  std::map<std::string, float> GetParentClipProperties(int64_t frame_number) const override;
216 
217  };
218 } // namespace openshot
219 
220 #endif
Header file for Fraction class.
float cy
y-coordinate of the bounding box center
Keyframe background_alpha
Background box opacity.
BBox()
Blank constructor.
Json::Value JsonValue() const
Generate Json::Value for this object.
float height
bounding box height
Keyframe stroke_alpha
Stroke box opacity.
Keyframe delta_y
Y-direction displacement Keyframe.
This abstract class is the base class of all Tracked Objects.
const Json::Value stringToJson(const std::string value)
Definition: Json.cpp:16
Header file for the Keyframe class.
float angle
bounding box rotation angle [degrees]
void SetJsonValue(const Json::Value root)
Load Json::Value into this object.
Keyframe stroke_width
Thickness of border line.
Header file for all Exception classes.
Color background
Background fill color.
std::string protobufDataPath
Path to the protobuf file that holds the bounding box points across the frames.
Color stroke
Border line color.
Keyframe delta_x
X-direction displacement Keyframe.
Header file for JSON class.
float width
bounding box width
This class represents a fraction.
Definition: Fraction.h:30
std::map< double, BBox > BoxVec
Index the bounding-box by time of each frame.
BBox(float _cx, float _cy, float _width, float _height, float _angle)
This struct holds the information of a bounding-box.
Keyframe scale_y
Y-direction scale Keyframe.
BBox GetBox(int64_t frame_number) const
Const-cast of the GetBox function, so that it can be called inside other cont function.
Header file for Color class.
This class represents a color (used on the timeline and clips)
Definition: Color.h:27
Keyframe rotation
Rotation Keyframe.
This namespace is the default namespace for all code in the openshot library.
Definition: Compressor.h:28
Keyframe scale_x
X-direction scale Keyframe.
float cx
x-coordinate of the bounding box center
Exception for invalid JSON.
Definition: Exceptions.h:217
void SetJson(const std::string value)
Load JSON string into this object.
Header file for the TrackedObjectBase class.
std::string Json() const
Generate JSON string of this object.
A Keyframe is a collection of Point instances, which is used to vary a number or property over time...
Definition: KeyFrame.h:54
Keyframe background_corner
Radius of rounded corners.
This class contains the properties of a tracked object and functions to manipulate it...