RawFeatureTrackerConfig.hpp

Go to the documentation of this file.

#pragma once
#include <cstdint>
#include <vector>
 
#include "depthai-shared/datatype/DatatypeEnum.hpp"
#include "depthai-shared/datatype/RawBuffer.hpp"
#include "depthai-shared/utility/Serialization.hpp"
 
namespace dai {
 
struct RawFeatureTrackerConfig : public RawBuffer {
    static constexpr const std::int32_t AUTO = 0;
 
    struct CornerDetector {
        enum class Type : std::int32_t {
            HARRIS,
            SHI_THOMASI
        };
        Type type = Type::HARRIS;
 
        std::int32_t cellGridDimension = 4;
 
        std::int32_t numTargetFeatures = 320;
 
        std::int32_t numMaxFeatures = AUTO;
 
        bool enableSobel = true;
 
        bool enableSorting = true;
 
        struct Thresholds {
            float initialValue = AUTO;
 
            float min = AUTO;
 
            float max = AUTO;
 
            float decreaseFactor = 0.9f;
 
            float increaseFactor = 1.1f;
            DEPTHAI_SERIALIZE(Thresholds, initialValue, min, max, decreaseFactor, increaseFactor);
        };
 
        Thresholds thresholds;
 
        DEPTHAI_SERIALIZE(CornerDetector, type, cellGridDimension, numTargetFeatures, numMaxFeatures, thresholds, enableSobel, enableSorting);
    };
 
    struct MotionEstimator {
        bool enable = true;
 
        enum class Type : std::int32_t {
            LUCAS_KANADE_OPTICAL_FLOW,
            HW_MOTION_ESTIMATION
        };
        Type type = Type::LUCAS_KANADE_OPTICAL_FLOW;
 
        struct OpticalFlow {
            std::int32_t pyramidLevels = AUTO;
 
            std::int32_t searchWindowWidth = 5;
            std::int32_t searchWindowHeight = 5;
 
            float epsilon = 0.01f;
 
            std::int32_t maxIterations = 9;
 
            DEPTHAI_SERIALIZE(OpticalFlow, pyramidLevels, searchWindowWidth, searchWindowHeight, epsilon, maxIterations);
        };
 
        OpticalFlow opticalFlow;
 
        DEPTHAI_SERIALIZE(MotionEstimator, enable, type, opticalFlow);
    };
 
    struct FeatureMaintainer {
        bool enable = true;
 
        float minimumDistanceBetweenFeatures = 50;
 
        float lostFeatureErrorThreshold = 50000;
 
        float trackedFeatureThreshold = 200000;
 
        DEPTHAI_SERIALIZE(FeatureMaintainer, enable, minimumDistanceBetweenFeatures, lostFeatureErrorThreshold, trackedFeatureThreshold);
    };
 
    CornerDetector cornerDetector;
 
    MotionEstimator motionEstimator;
 
    FeatureMaintainer featureMaintainer;
 
    void serialize(std::vector<std::uint8_t>& metadata, DatatypeEnum& datatype) const override {
        metadata = utility::serialize(*this);
        datatype = DatatypeEnum::FeatureTrackerConfig;
    };
 
    DatatypeEnum getType() const override {
        return DatatypeEnum::FeatureTrackerConfig;
    }
 
    DEPTHAI_SERIALIZE(RawFeatureTrackerConfig, cornerDetector, motionEstimator, featureMaintainer);
};
 
}  // namespace dai