RawStereoDepthConfig.hpp

Go to the documentation of this file.

#pragma once
#include <array>
#include <cstdint>
#include <depthai-shared/common/optional.hpp>
 
#include "depthai-shared/common/MedianFilter.hpp"
#include "depthai-shared/datatype/DatatypeEnum.hpp"
#include "depthai-shared/datatype/RawBuffer.hpp"
#include "depthai-shared/utility/Serialization.hpp"
 
namespace dai {
 
struct RawStereoDepthConfig : public RawBuffer {
    using MedianFilter = dai::MedianFilter;
 
    struct AlgorithmControl {
        enum class DepthAlign : int32_t { RECTIFIED_RIGHT, RECTIFIED_LEFT, CENTER };
 
        enum class DepthUnit : int32_t { METER, CENTIMETER, MILLIMETER, INCH, FOOT, CUSTOM };
 
        DepthAlign depthAlign = DepthAlign::RECTIFIED_RIGHT;
 
        DepthUnit depthUnit = DepthUnit::MILLIMETER;
 
        float customDepthUnitMultiplier = 1000.f;
 
        bool enableLeftRightCheck = true;
 
        bool enableExtended = false;
 
        bool enableSubpixel = false;
 
        std::int32_t leftRightCheckThreshold = 10;
 
        std::int32_t subpixelFractionalBits = 3;
 
        std::int32_t disparityShift = 0;
 
        tl::optional<float> centerAlignmentShiftFactor;
 
        std::int32_t numInvalidateEdgePixels = 0;
 
        DEPTHAI_SERIALIZE(AlgorithmControl,
                          depthAlign,
                          depthUnit,
                          customDepthUnitMultiplier,
                          enableLeftRightCheck,
                          enableExtended,
                          enableSubpixel,
                          leftRightCheckThreshold,
                          subpixelFractionalBits,
                          disparityShift,
                          centerAlignmentShiftFactor,
                          numInvalidateEdgePixels);
    };
 
    AlgorithmControl algorithmControl;
 
    struct PostProcessing {
        enum class Filter : int32_t { NONE = 0, DECIMATION, SPECKLE, MEDIAN, SPATIAL, TEMPORAL, FILTER_COUNT = TEMPORAL };
 
        std::array<Filter, 5> filteringOrder = {Filter::MEDIAN, Filter::DECIMATION, Filter::SPECKLE, Filter::SPATIAL, Filter::TEMPORAL};
 
        MedianFilter median = MedianFilter::KERNEL_5x5;
 
        std::int16_t bilateralSigmaValue = 0;
 
        struct SpatialFilter {
            static constexpr const std::int32_t DEFAULT_DELTA_VALUE = 3;
 
            bool enable = false;
 
            std::uint8_t holeFillingRadius = 2;
 
            float alpha = 0.5f;
 
            std::int32_t delta = 0;
 
            std::int32_t numIterations = 1;
 
            DEPTHAI_SERIALIZE(SpatialFilter, enable, holeFillingRadius, alpha, delta, numIterations);
        };
 
        SpatialFilter spatialFilter;
 
        struct TemporalFilter {
            static constexpr const std::int32_t DEFAULT_DELTA_VALUE = 3;
 
            bool enable = false;
 
            enum class PersistencyMode : int32_t {
                PERSISTENCY_OFF = 0,
                VALID_8_OUT_OF_8 = 1,
                VALID_2_IN_LAST_3 = 2,
                VALID_2_IN_LAST_4 = 3,
                VALID_2_OUT_OF_8 = 4,
                VALID_1_IN_LAST_2 = 5,
                VALID_1_IN_LAST_5 = 6,
                VALID_1_IN_LAST_8 = 7,
                PERSISTENCY_INDEFINITELY = 8,
            };
 
            PersistencyMode persistencyMode = PersistencyMode::VALID_2_IN_LAST_4;
 
            float alpha = 0.4f;
 
            std::int32_t delta = 0;
 
            DEPTHAI_SERIALIZE(TemporalFilter, enable, persistencyMode, alpha, delta);
        };
 
        TemporalFilter temporalFilter;
 
        struct ThresholdFilter {
            std::int32_t minRange = 0;
            std::int32_t maxRange = 65535;
 
            DEPTHAI_SERIALIZE(ThresholdFilter, minRange, maxRange);
        };
 
        ThresholdFilter thresholdFilter;
 
        struct BrightnessFilter {
            std::int32_t minBrightness = 0;
            std::int32_t maxBrightness = 256;
 
            DEPTHAI_SERIALIZE(BrightnessFilter, minBrightness, maxBrightness);
        };
 
        BrightnessFilter brightnessFilter;
 
        struct SpeckleFilter {
            bool enable = false;
            std::uint32_t speckleRange = 50;
 
            std::uint32_t differenceThreshold = 2;
 
            DEPTHAI_SERIALIZE(SpeckleFilter, enable, speckleRange, differenceThreshold);
        };
 
        SpeckleFilter speckleFilter;
 
        struct DecimationFilter {
            std::uint32_t decimationFactor = 1;
            enum class DecimationMode : int32_t {
                PIXEL_SKIPPING = 0,
                NON_ZERO_MEDIAN = 1,
                NON_ZERO_MEAN = 2,
            };
            DecimationMode decimationMode = DecimationMode::PIXEL_SKIPPING;
 
            DEPTHAI_SERIALIZE(DecimationFilter, decimationFactor, decimationMode);
        };
 
        DecimationFilter decimationFilter;
 
        DEPTHAI_SERIALIZE(PostProcessing,
                          filteringOrder,
                          median,
                          bilateralSigmaValue,
                          spatialFilter,
                          temporalFilter,
                          thresholdFilter,
                          brightnessFilter,
                          speckleFilter,
                          decimationFilter);
    };
 
    PostProcessing postProcessing;
 
    struct CensusTransform {
        enum class KernelSize : std::int32_t { AUTO = -1, KERNEL_5x5 = 0, KERNEL_7x7, KERNEL_7x9 };
 
        KernelSize kernelSize = KernelSize::AUTO;
 
        uint64_t kernelMask = 0;
 
        bool enableMeanMode = true;
 
        uint32_t threshold = 0;
 
        DEPTHAI_SERIALIZE(CensusTransform, kernelSize, kernelMask, enableMeanMode, threshold);
    };
 
    CensusTransform censusTransform;
 
    struct CostMatching {
        enum class DisparityWidth : std::uint32_t { DISPARITY_64, DISPARITY_96 };
 
        DisparityWidth disparityWidth = DisparityWidth::DISPARITY_96;
 
        bool enableCompanding = false;
 
        uint8_t invalidDisparityValue = 0;
 
        uint8_t confidenceThreshold = 245;
 
        struct LinearEquationParameters {
            uint8_t alpha = 0;
            uint8_t beta = 2;
            uint8_t threshold = 127;
 
            DEPTHAI_SERIALIZE(LinearEquationParameters, alpha, beta, threshold);
        };
 
        LinearEquationParameters linearEquationParameters;
 
        DEPTHAI_SERIALIZE(CostMatching, disparityWidth, enableCompanding, invalidDisparityValue, confidenceThreshold, linearEquationParameters);
    };
 
    CostMatching costMatching;
 
    struct CostAggregation {
        static constexpr const int defaultPenaltyP1 = 250;
        static constexpr const int defaultPenaltyP2 = 500;
 
        uint8_t divisionFactor = 1;
 
        uint16_t horizontalPenaltyCostP1 = defaultPenaltyP1;
        uint16_t horizontalPenaltyCostP2 = defaultPenaltyP2;
 
        uint16_t verticalPenaltyCostP1 = defaultPenaltyP1;
        uint16_t verticalPenaltyCostP2 = defaultPenaltyP2;
 
        DEPTHAI_SERIALIZE(CostAggregation, divisionFactor, horizontalPenaltyCostP1, horizontalPenaltyCostP2, verticalPenaltyCostP1, verticalPenaltyCostP2);
    };
 
    CostAggregation costAggregation;
 
    void serialize(std::vector<std::uint8_t>& metadata, DatatypeEnum& datatype) const override {
        metadata = utility::serialize(*this);
        datatype = DatatypeEnum::StereoDepthConfig;
    };
 
    DatatypeEnum getType() const override {
        return DatatypeEnum::StereoDepthConfig;
    }
 
    DEPTHAI_SERIALIZE(RawStereoDepthConfig, algorithmControl, postProcessing, censusTransform, costMatching, costAggregation);
};
 
}  // namespace dai