TrackedObjectBBox.h

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#ifndef OPENSHOT_TRACKEDOBJECTBBOX_H
#define OPENSHOT_TRACKEDOBJECTBBOX_H
 
#include "TrackedObjectBase.h"
 
#include "Color.h"
#include "Exceptions.h"
#include "Fraction.h"
#include "Json.h"
#include "KeyFrame.h"
 
namespace openshot
{
    struct ObjectMaskData
    {
        int width = 0;
        int height = 0;
        std::vector<uint32_t> rle;
 
        bool HasData() const { return width > 0 && height > 0 && !rle.empty(); }
    };
 
    struct BBox
    {
        float cx = -1; 
        float cy = -1; 
        float width = -1; 
        float height = -1; 
        float angle = -1; 
 
        BBox() {}
 
        BBox(float _cx, float _cy, float _width, float _height, float _angle)
        {
            cx = _cx;
            cy = _cy;
            width = _width;
            height = _height;
            angle = _angle;
        }
 
 
        std::string Json() const
        {
            return JsonValue().toStyledString();
        }
 
        Json::Value JsonValue() const
        {
            Json::Value root;
            root["cx"] = cx;
            root["cy"] = cy;
            root["width"] = width;
            root["height"] = height;
            root["angle"] = angle;
 
            return root;
        }
 
        void SetJson(const std::string value)
        {
            // Parse JSON string into JSON objects
            try
            {
                const Json::Value root = openshot::stringToJson(value);
                // Set all values that match
                SetJsonValue(root);
            }
            catch (const std::exception &e)
            {
                // Error parsing JSON (or missing keys)
                throw InvalidJSON("JSON is invalid (missing keys or invalid data types)");
            }
        }
 
        void SetJsonValue(const Json::Value root)
        {
 
            // Set data from Json (if key is found)
            if (!root["cx"].isNull())
                cx = root["cx"].asDouble();
            if (!root["cy"].isNull())
                cy = root["cy"].asDouble();
            if (!root["width"].isNull())
                width = root["width"].asDouble();
            if (!root["height"].isNull())
                height = root["height"].asDouble();
            if (!root["angle"].isNull())
                angle = root["angle"].asDouble();
        }
    };
 
    class TrackedObjectBBox : public TrackedObjectBase
    {
    private:
        Fraction BaseFps;
        double TimeScale;
 
    public:
        std::map<double, BBox> BoxVec; 
        std::map<double, ObjectMaskData> MaskVec; 
        Keyframe delta_x; 
        Keyframe delta_y; 
        Keyframe scale_x; 
        Keyframe scale_y; 
        Keyframe background_alpha; 
        Keyframe background_corner; 
        Keyframe mask_alpha; 
        Keyframe stroke_width; 
        Keyframe stroke_alpha; 
        Color stroke; 
        Color background; 
        Color mask_color; 
 
        std::string protobufDataPath; 
 
        TrackedObjectBBox();
        TrackedObjectBBox(int Red, int Green, int Blue, int Alfa);
 
        void AddBox(int64_t _frame_num, float _cx, float _cy, float _width, float _height, float _angle) override;
        void AddMask(int64_t frame_num, const ObjectMaskData& mask);
        bool HasMask(int64_t frame_number, int64_t max_frame_gap = 0) const;
        bool HasMaskData() const;
        ObjectMaskData GetMask(int64_t frame_number, int64_t max_frame_gap = 0) const;
 
        void SetBaseFPS(Fraction fps);
 
        Fraction GetBaseFPS();
 
        void ScalePoints(double scale) override;
 
        bool Contains(int64_t frame_number) const;
        bool ExactlyContains(int64_t frame_number) const override;
 
        int64_t GetLength() const;
 
        void RemoveBox(int64_t frame_number);
 
        BBox GetBox(int64_t frame_number);
        BBox GetBox(int64_t frame_number) const
        {
            return const_cast<TrackedObjectBBox *>(this)->GetBox(frame_number);
        }
 
        double ScaledStrokeWidth(int64_t frame_number, int image_width, int image_height) const;
 
        bool LoadBoxData(std::string inputFilePath);
 
        double FrameNToTime(int64_t frame_number, double time_scale) const;
 
        BBox InterpolateBoxes(double t1, double t2, BBox left, BBox right, double target);
 
        void clear();
 
        std::string Json() const override;                
        Json::Value JsonValue() const override;          
        void SetJson(const std::string value) override;  
        void SetJsonValue(const Json::Value root) override; 
 
        Json::Value PropertiesJSON(int64_t requested_frame) const override;
 
        // Generate JSON for a property
        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;
 
        std::map<std::string, float> GetBoxValues(int64_t frame_number) const override;
    };
} // namespace openshot
 
#endif