Filter.hpp

Go to the documentation of this file.

// Copyright (c) Orbbec Inc. All Rights Reserved.
// Licensed under the MIT License.

#pragma once
 
#include "Types.hpp"
#include "Error.hpp"
#include "Frame.hpp"
#include "libobsensor/h/Filter.h"
#include "libobsensor/h/Frame.h"
#include <functional>
#include <memory>
#include <map>
#include <string>
#include <iostream>
#include <vector>
#include <typeinfo>
#include <typeindex>
#include <unordered_map>
#include <vector>
#include <cstring>
 
namespace ob {

typedef std::function<void(std::shared_ptr<Frame>)> FilterCallback;

template <typename T> struct RangeTraits {
    using valueType = void;
};
 
template <> struct RangeTraits<OBUint8PropertyRange> {
    using valueType = uint8_t;
};
 
template <> struct RangeTraits<OBUint16PropertyRange> {
    using valueType = uint16_t;
};
 
template <> struct RangeTraits<OBIntPropertyRange> {
    using valueType = uint32_t;
};
 
template <> struct RangeTraits<OBFloatPropertyRange> {
    using valueType = float;
};

template <typename T> T getPropertyRange(const OBFilterConfigSchemaItem &item, const double cur) {
    // If T type is illegal, T will be void
    using valueType = typename RangeTraits<T>::valueType;
    T range{};
    // Compilate error will be reported here if T is void
    range.cur  = static_cast<valueType>(cur);
    range.def  = static_cast<valueType>(item.def);
    range.max  = static_cast<valueType>(item.max);
    range.min  = static_cast<valueType>(item.min);
    range.step = static_cast<valueType>(item.step);
    return range;
}

class Filter : public std::enable_shared_from_this<Filter> {
protected:
    ob_filter                            *impl_ = nullptr;
    std::string                           name_;
    FilterCallback                        callback_;
    std::vector<OBFilterConfigSchemaItem> configSchemaVec_;
 
protected:
    Filter() = default;
 
    virtual void init(ob_filter *impl) {
        impl_           = impl;
        ob_error *error = nullptr;
        name_           = ob_filter_get_name(impl_, &error);
        Error::handle(&error);
 
        auto configSchemaList = ob_filter_get_config_schema_list(impl_, &error);
        Error::handle(&error);
 
        auto count = ob_filter_config_schema_list_get_count(configSchemaList, &error);
        Error::handle(&error);
 
        for(uint32_t i = 0; i < count; i++) {
            auto item = ob_filter_config_schema_list_get_item(configSchemaList, i, &error);
            Error::handle(&error);
            configSchemaVec_.emplace_back(item);
        }
 
        ob_delete_filter_config_schema_list(configSchemaList, &error);
        Error::handle(&error);
    }
 
public:
    explicit Filter(ob_filter *impl) {
        init(impl);
    }
 
    virtual ~Filter() noexcept {
        if(impl_ != nullptr) {
            ob_error *error = nullptr;
            ob_delete_filter(impl_, &error);
            Error::handle(&error, false);
        }
    }

    ob_filter *getImpl() const {
        return impl_;
    }

    virtual const std::string &getName() const {
        return name_;
    }

    virtual void reset() const {
        ob_error *error = nullptr;
        ob_filter_reset(impl_, &error);
        Error::handle(&error);
    }

    virtual void enable(bool enable) const {
        ob_error *error = nullptr;
        ob_filter_enable(impl_, enable, &error);
        Error::handle(&error);
    }

    virtual bool isEnabled() const {
        ob_error *error  = nullptr;
        bool      enable = ob_filter_is_enabled(impl_, &error);
        Error::handle(&error);
        return enable;
    }

    virtual std::shared_ptr<Frame> process(std::shared_ptr<const Frame> frame) const {
        const ob_frame *frameImpl = nullptr;
        if(frame) {
            frameImpl = frame->getImpl();
        }
        ob_error *error  = nullptr;
        auto      result = ob_filter_process(impl_, frameImpl, &error);
        Error::handle(&error);
        if(!result) {
            return nullptr;
        }
        return std::make_shared<Frame>(result);
    }

    virtual void pushFrame(std::shared_ptr<Frame> frame) const {
        const ob_frame *frameImpl = nullptr;
        if(frame) {
            frameImpl = frame->getImpl();
        }
        ob_error *error = nullptr;
        ob_filter_push_frame(impl_, frameImpl, &error);
        Error::handle(&error);
    }

    virtual void setCallBack(FilterCallback callback) {
        callback_       = callback;
        ob_error *error = nullptr;
        ob_filter_set_callback(impl_, &Filter::filterCallback, this, &error);
        Error::handle(&error);
    }

    virtual std::string getConfigSchema() const {
        ob_error *error  = nullptr;
        auto      schema = ob_filter_get_config_schema(impl_, &error);
        Error::handle(&error);
        return schema;
    }

    virtual std::vector<OBFilterConfigSchemaItem> getConfigSchemaVec() const {
        return configSchemaVec_;
    }

    virtual void setConfigValue(const std::string &configName, double value) const {
        ob_error *error = nullptr;
        ob_filter_set_config_value(impl_, configName.c_str(), value, &error);
        Error::handle(&error);
    }

    virtual double getConfigValue(const std::string &configName) const {
        ob_error *error = nullptr;
        double    value = ob_filter_get_config_value(impl_, configName.c_str(), &error);
        Error::handle(&error);
        return value;
    }
 
private:
    static void filterCallback(ob_frame *frame, void *userData) {
        auto filter = static_cast<Filter *>(userData);
        filter->callback_(std::make_shared<Frame>(frame));
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    virtual const char *type() {
        return getName().c_str();
    }

    template <typename T> bool is();
 
    template <typename T> std::shared_ptr<T> as() {
        if(!is<T>()) {
            throw std::runtime_error("unsupported operation, object's type is not require type");
        }
 
        return std::static_pointer_cast<T>(shared_from_this());
    }
};

class FilterFactory {
public:
    static std::shared_ptr<Filter> createFilter(const std::string &name) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter(name.c_str(), &error);
        Error::handle(&error);
        return std::make_shared<Filter>(impl);
    }

    static std::shared_ptr<Filter> createPrivateFilter(const std::string &name, const std::string &activationKey) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter(name.c_str(), activationKey.c_str(), &error);
        Error::handle(&error);
        return std::make_shared<Filter>(impl);
    }

    static std::string getFilterVendorSpecificCode(const std::string &name) {
        ob_error *error = nullptr;
        auto      code  = ob_filter_get_vendor_specific_code(name.c_str(), &error);
        Error::handle(&error);
        return code;
    }
};

class PointCloudFilter : public Filter {
public:
    PointCloudFilter() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("PointCloudFilter", &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~PointCloudFilter() noexcept override = default;

    void setCreatePointFormat(OBFormat format) {
        setConfigValue("pointFormat", static_cast<double>(format));
    }

    void setCoordinateDataScaled(float factor) {
        setConfigValue("coordinateDataScale", factor);
    }

    void setColorDataNormalization(bool state) {
        setConfigValue("colorDataNormalization", state);
    }

    void setCoordinateSystem(OBCoordinateSystemType type) {
        setConfigValue("coordinateSystemType", static_cast<double>(type));
    }

    void setDecimationFactor(int value) {
        setConfigValue("decimate", value);
    }

    OBIntPropertyRange getDecimationFactorRange() {
        OBIntPropertyRange scaleRange{};
        if(configSchemaVec_.size() != 0) {
            const auto &item = configSchemaVec_[5];
            scaleRange       = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("decimate"));
        }
        return scaleRange;
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    void setPositionDataScaled(float scale) {
        setCoordinateDataScaled(scale);
    }
 
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    void setFrameAlignState(bool state) {
        (void)state;  // to complie
    }
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    void setCameraParam(OBCameraParam param) {
        (void)param;
    }
};

class Align : public Filter {
public:
    Align(OBStreamType alignToStreamType) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("Align", &error);
        Error::handle(&error);
        init(impl);
 
        setConfigValue("AlignType", static_cast<double>(alignToStreamType));
    }
 
    virtual ~Align() noexcept override = default;
 
    OBStreamType getAlignToStreamType() {
        return static_cast<OBStreamType>(static_cast<int>(getConfigValue("AlignType")));
    }

    void setMatchTargetResolution(bool state) {
        setConfigValue("MatchTargetRes", state);
    }

    void setAlignToStreamProfile(std::shared_ptr<const StreamProfile> profile) {
        ob_error *error = nullptr;
        ob_align_filter_set_align_to_stream_profile(impl_, profile->getImpl(), &error);
        Error::handle(&error);
    }
};

class UnDistortionFilter : public Filter {
public:
    explicit UnDistortionFilter(OBStreamType streamType = OB_STREAM_COLOR) {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("UnDistortionFilter", &error);
        Error::handle(&error);
        init(impl);
        setConfigValue("StreamType", static_cast<double>(streamType));
    }
 
    virtual ~UnDistortionFilter() noexcept override = default;

    void setStreamType(OBStreamType streamType) {
        setConfigValue("StreamType", static_cast<double>(streamType));
    }
 
    OBStreamType getStreamType() const {
        return static_cast<OBStreamType>(static_cast<int>(getConfigValue("StreamType")));
    }

    void setNewCameraMatrix(OBCameraIntrinsic depthIntrinsic) {
        setConfigValue("NewCameraFx", static_cast<double>(depthIntrinsic.fx));
        setConfigValue("NewCameraFy", static_cast<double>(depthIntrinsic.fy));
        setConfigValue("NewCameraCx", static_cast<double>(depthIntrinsic.cx));
        setConfigValue("NewCameraCy", static_cast<double>(depthIntrinsic.cy));
        setConfigValue("NewCameraWidth", static_cast<double>(depthIntrinsic.width));
        setConfigValue("NewCameraHeight", static_cast<double>(depthIntrinsic.height));
    }

    void clearNewCameraMatrix() {
        setConfigValue("NewCameraWidth", 0.0);
    }
};

class FormatConvertFilter : public Filter {
public:
    FormatConvertFilter() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("FormatConverter", &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~FormatConvertFilter() noexcept override = default;

    void setFormatConvertType(OBConvertFormat type) {
        setConfigValue("convertType", static_cast<double>(type));
    }
};

class HdrMerge : public Filter {
public:
    HdrMerge() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("HDRMerge", &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~HdrMerge() noexcept override = default;
};

class SequenceIdFilter : public Filter {
private:
    std::map<float, std::string> sequenceIdList_{ { 0.f, "all" }, { 1.f, "1" } };
    OBSequenceIdItem            *outputSequenceIdList_ = nullptr;
 
    void initSequenceIdList() {
        outputSequenceIdList_ = new OBSequenceIdItem[sequenceIdList_.size()];
 
        int i = 0;
        for(const auto &pair: sequenceIdList_) {
            outputSequenceIdList_[i].sequenceSelectId = static_cast<int>(pair.first);
            strncpy(outputSequenceIdList_[i].name, pair.second.c_str(), sizeof(outputSequenceIdList_[i].name) - 1);
            outputSequenceIdList_[i].name[sizeof(outputSequenceIdList_[i].name) - 1] = '\0';
            ++i;
        }
    }
 
public:
    SequenceIdFilter() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("SequenceIdFilter", &error);
        Error::handle(&error);
        init(impl);
        initSequenceIdList();
    }
 
    virtual ~SequenceIdFilter() noexcept override {
        if(outputSequenceIdList_) {
            delete[] outputSequenceIdList_;
            outputSequenceIdList_ = nullptr;
        }
    }

    void selectSequenceId(int sequence_id) {
        setConfigValue("sequenceid", static_cast<double>(sequence_id));
    }

    int getSelectSequenceId() {
        return static_cast<int>(getConfigValue("sequenceid"));
    }
 
    OBSequenceIdItem *getSequenceIdList() {
        return outputSequenceIdList_;
    }

    int getSequenceIdListSize() {
        return static_cast<int>(sequenceIdList_.size());
    }
};

class DecimationFilter : public Filter {
public:
    DecimationFilter() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("DecimationFilter", &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~DecimationFilter() noexcept override = default;

    void setScaleValue(uint8_t value) {
        setConfigValue("decimate", static_cast<double>(value));
    }

    uint8_t getScaleValue() {
        return static_cast<uint8_t>(getConfigValue("decimate"));
    }

    OBUint8PropertyRange getScaleRange() {
        OBUint8PropertyRange scaleRange{};
        if(configSchemaVec_.size() != 0) {
            const auto &item = configSchemaVec_[0];
            scaleRange       = getPropertyRange<OBUint8PropertyRange>(item, getConfigValue("decimate"));
        }
        return scaleRange;
    }
};

class ThresholdFilter : public Filter {
public:
    ThresholdFilter() {
        ob_error *error = nullptr;
        auto      impl  = ob_create_filter("ThresholdFilter", &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~ThresholdFilter() noexcept override = default;

    OBIntPropertyRange getMinRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "min") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("min"));
                break;
            }
        }
        return range;
    }

    OBIntPropertyRange getMaxRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "max") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("max"));
                break;
            }
        }
        return range;
    }

    bool setValueRange(uint16_t min, uint16_t max) {
        if(min >= max) {
            return false;
        }
        setConfigValue("min", min);
        setConfigValue("max", max);
        return true;
    }
};

class SpatialAdvancedFilter : public Filter {
public:
    SpatialAdvancedFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("SpatialAdvancedFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~SpatialAdvancedFilter() noexcept override = default;

    OBFloatPropertyRange getAlphaRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "alpha") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("alpha"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getDispDiffRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "disp_diff") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("disp_diff"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getRadiusRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "radius") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("radius"));
                break;
            }
        }
        return range;
    }

    OBIntPropertyRange getMagnitudeRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "magnitude") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("magnitude"));
                break;
            }
        }
        return range;
    }

    OBSpatialAdvancedFilterParams getFilterParams() {
        OBSpatialAdvancedFilterParams params{};
        params.alpha     = static_cast<float>(getConfigValue("alpha"));
        params.disp_diff = static_cast<uint16_t>(getConfigValue("disp_diff"));
        params.magnitude = static_cast<uint8_t>(getConfigValue("magnitude"));
        params.radius    = static_cast<uint16_t>(getConfigValue("radius"));
        return params;
    }

    void setFilterParams(OBSpatialAdvancedFilterParams params) {
        setConfigValue("alpha", params.alpha);
        setConfigValue("disp_diff", params.disp_diff);
        setConfigValue("magnitude", params.magnitude);
        setConfigValue("radius", params.radius);
    }
};

class SpatialFastFilter : public Filter {
public:
    SpatialFastFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("SpatialFastFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~SpatialFastFilter() noexcept override = default;

    OBIntPropertyRange getRadiusRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "radius") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("radius"));
                break;
            }
        }
        return range;
    }

    OBSpatialFastFilterParams getFilterParams() {
        OBSpatialFastFilterParams params{};
        params.radius = static_cast<uint8_t>(getConfigValue("radius"));
        return params;
    }

    void setFilterParams(OBSpatialFastFilterParams params) {
        setConfigValue("radius", params.radius);
    }
};

class SpatialModerateFilter : public Filter {
public:
    SpatialModerateFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("SpatialModerateFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~SpatialModerateFilter() noexcept override = default;

    OBIntPropertyRange getMagnitudeRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "magnitude") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("magnitude"));
                break;
            }
        }
        return range;
    }

    OBIntPropertyRange getRadiusRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "radius") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("radius"));
                break;
            }
        }
        return range;
    }

    OBIntPropertyRange getDispDiffRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "disp_diff") == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue("disp_diff"));
                break;
            }
        }
        return range;
    }

    OBSpatialModerateFilterParams getFilterParams() {
        OBSpatialModerateFilterParams params{};
        params.magnitude = static_cast<uint8_t>(getConfigValue("magnitude"));
        params.radius    = static_cast<uint8_t>(getConfigValue("radius"));
        params.disp_diff = static_cast<uint16_t>(getConfigValue("disp_diff"));
        return params;
    }

    void setFilterParams(OBSpatialModerateFilterParams params) {
        setConfigValue("magnitude", params.magnitude);
        setConfigValue("radius", params.radius);
        setConfigValue("disp_diff", params.disp_diff);
    }
};

class HoleFillingFilter : public Filter {
public:
    HoleFillingFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("HoleFillingFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~HoleFillingFilter() noexcept override = default;

    void setFilterMode(OBHoleFillingMode mode) {
        setConfigValue("hole_filling_mode", static_cast<double>(mode));
    }

    OBHoleFillingMode getFilterMode() {
        return static_cast<OBHoleFillingMode>(static_cast<int>(getConfigValue("hole_filling_mode")));
    }
};

class NoiseRemovalFilter : public Filter {
public:
    NoiseRemovalFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("NoiseRemovalFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~NoiseRemovalFilter() noexcept override = default;

    void setFilterParams(OBNoiseRemovalFilterParams filterParams) {
        setConfigValue("max_size", static_cast<double>(filterParams.max_size));
        setConfigValue("min_diff", static_cast<double>(filterParams.disp_diff));
        // todo:set noise remove type
    }

    OBNoiseRemovalFilterParams getFilterParams() {
        OBNoiseRemovalFilterParams param{};
        param.max_size  = static_cast<uint16_t>(getConfigValue("max_size"));
        param.disp_diff = static_cast<uint16_t>(getConfigValue("min_diff"));
        // todo: type is not set
        return param;
    }

    OBUint16PropertyRange getDispDiffRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "min_diff") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("min_diff"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMaxSizeRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "max_size") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("max_size"));
                break;
            }
        }
        return range;
    }
};

class TemporalFilter : public Filter {
public:
    TemporalFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("TemporalFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~TemporalFilter() noexcept override = default;

    OBFloatPropertyRange getDiffScaleRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "diff_scale") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("diff_scale"));
                break;
            }
        }
        return range;
    }

    void setDiffScale(float value) {
        setConfigValue("diff_scale", static_cast<double>(value));
    }

    OBFloatPropertyRange getWeightRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "weight") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("weight"));
                break;
            }
        }
        return range;
    }

    void setWeight(float value) {
        setConfigValue("weight", static_cast<double>(value));
    }
};

class EdgeNoiseRemovalFilter : public Filter {
public:
    EdgeNoiseRemovalFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("EdgeNoiseRemovalFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~EdgeNoiseRemovalFilter() noexcept override = default;

    OBUint16PropertyRange getMarginXthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "margin_x_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("margin_x_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMarginYthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "margin_y_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("margin_y_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getLimitXthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "limit_x_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("limit_x_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getLimitYthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "limit_y_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("limit_y_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getVerticalDirectionEnableRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "enable_vertical_direction") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("enable_vertical_direction"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getWidthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "width") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("width"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getHeightRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "height") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("height"));
                break;
            }
        }
        return range;
    }

    void setFilterParams(OBEdgeNoiseRemovalFilterParams filterParams) {
        setConfigValue("margin_x_th", static_cast<double>(filterParams.margin_x_th));
        setConfigValue("margin_y_th", static_cast<double>(filterParams.margin_y_th));
        setConfigValue("limit_x_th", static_cast<double>(filterParams.limit_x_th));
        setConfigValue("limit_y_th", static_cast<double>(filterParams.limit_y_th));
        setConfigValue("enable_vertical_direction", static_cast<double>(filterParams.enable_direction));
        setConfigValue("width", static_cast<double>(filterParams.width));
        setConfigValue("height", static_cast<double>(filterParams.height));
    }

    OBEdgeNoiseRemovalFilterParams getFilterParams() {
        OBEdgeNoiseRemovalFilterParams param{};
        param.margin_x_th      = static_cast<uint16_t>(getConfigValue("margin_x_th"));
        param.margin_y_th      = static_cast<uint16_t>(getConfigValue("margin_y_th"));
        param.limit_x_th       = static_cast<uint16_t>(getConfigValue("limit_x_th"));
        param.limit_y_th       = static_cast<uint16_t>(getConfigValue("limit_y_th"));
        param.enable_direction = static_cast<uint16_t>(getConfigValue("enable_vertical_direction"));
        param.width            = static_cast<uint16_t>(getConfigValue("width"));
        param.height           = static_cast<uint16_t>(getConfigValue("height"));
        return param;
    }
};

class FalsePositiveFilter : public Filter {
public:
    FalsePositiveFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("FalsePositiveFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    virtual ~FalsePositiveFilter() noexcept override = default;

    OBUint8PropertyRange getfpEdgeBleedFilterEnableRange() {
        OBUint8PropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpEdgeBleedFilterEnable") == 0) {
                range = getPropertyRange<OBUint8PropertyRange>(item, getConfigValue("fpEdgeBleedFilterEnable"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfpebfROIMinXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpebfROIMinXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fpebfROIMinXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfpebfROIMaxXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpebfROIMaxXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fpebfROIMaxXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfpebfROIMinYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpebfROIMinYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fpebfROIMinYRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfpebfROIMaxYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpebfROIMaxYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fpebfROIMaxYRatio"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfpebfMinBleedLengthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpebfMinBleedLength") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fpebfMinBleedLength"));
                break;
            }
        }
        return range;
    }

    OBUint8PropertyRange getfpTextureSparsityFilterEnableRange() {
        OBUint8PropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpTextureSparsityFilterEnable") == 0) {
                range = getPropertyRange<OBUint8PropertyRange>(item, getConfigValue("fpTextureSparsityFilterEnable"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfptsfROIMinXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfROIMinXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fptsfROIMinXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfptsfROIMaxXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfROIMaxXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fptsfROIMaxXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfptsfROIMinYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfROIMinYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fptsfROIMinYRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfptsfROIMaxYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfROIMaxYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fptsfROIMaxYRatio"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfptsfMaxNoiseLevelRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfMaxNoiseLevel") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fptsfMaxNoiseLevel"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfptsfMaxSpeckleSizeRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fptsfMaxSpeckleSize") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fptsfMaxSpeckleSize"));
                break;
            }
        }
        return range;
    }

    OBUint8PropertyRange getfpPatternAmbiguityFilterEnableRange() {
        OBUint8PropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fpPatternAmbiguityFilterEnable") == 0) {
                range = getPropertyRange<OBUint8PropertyRange>(item, getConfigValue("fpPatternAmbiguityFilterEnable"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafROIMinXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafROIMinXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafROIMinXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafROIMaxXRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafROIMaxXRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafROIMaxXRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafROIMinYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafROIMinYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafROIMinYRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafROIMaxYRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafROIMaxYRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafROIMaxYRatio"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfppafMaxNoiseLevelRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafMaxNoiseLevel") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fppafMaxNoiseLevel"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfppafMaxSpeckleSizeRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafMaxSpeckleSize") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fppafMaxSpeckleSize"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafMaxWidthRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafMaxWidthRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafMaxWidthRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafMaxHeightRatioRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafMaxHeightRatio") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafMaxHeightRatio"));
                break;
            }
        }
        return range;
    }

    OBFloatPropertyRange getfppafToleranceRange() {
        OBFloatPropertyRange range{};
        const auto          &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafTolerance") == 0) {
                range = getPropertyRange<OBFloatPropertyRange>(item, getConfigValue("fppafTolerance"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getfppafScoreRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "fppafScore") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("fppafScore"));
                break;
            }
        }
        return range;
    }
};

class MgcNoiseRemovalFilter : public Filter {
public:
    MgcNoiseRemovalFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("MgcNoiseRemovalFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~MgcNoiseRemovalFilter() noexcept override = default;

    void setFilterParams(OBMgcNoiseRemovalFilterParams filterParams) {
        setConfigValue("max_width_left", static_cast<double>(filterParams.max_width_left));
        setConfigValue("max_width_right", static_cast<double>(filterParams.max_width_right));
        setConfigValue("max_radius", static_cast<double>(filterParams.max_radius));
        setConfigValue("margin_x_th", static_cast<double>(filterParams.margin_x_th));
        setConfigValue("margin_y_th", static_cast<double>(filterParams.margin_y_th));
        setConfigValue("limit_x_th", static_cast<double>(filterParams.limit_x_th));
        setConfigValue("limit_y_th", static_cast<double>(filterParams.limit_y_th));
        setConfigValue("width", static_cast<double>(filterParams.width));
        setConfigValue("height", static_cast<double>(filterParams.height));
    }

    OBMgcNoiseRemovalFilterParams getFilterParams() {
        OBMgcNoiseRemovalFilterParams params{};
        params.max_width_left  = static_cast<int>(getConfigValue("max_width_left"));
        params.max_width_right = static_cast<int>(getConfigValue("max_width_right"));
        params.max_radius      = static_cast<int>(getConfigValue("max_radius"));
        params.margin_x_th     = static_cast<int>(getConfigValue("margin_x_th"));
        params.margin_y_th     = static_cast<int>(getConfigValue("margin_y_th"));
        params.limit_x_th      = static_cast<int>(getConfigValue("limit_x_th"));
        params.limit_y_th      = static_cast<int>(getConfigValue("limit_y_th"));
        params.width           = static_cast<uint32_t>(getConfigValue("width"));
        params.height          = static_cast<uint32_t>(getConfigValue("height"));
        return params;
    }

    OBUint16PropertyRange getMaxWidthLeftRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "max_width_left") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("max_width_left"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMaxWidthRightRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "max_width_right") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("max_width_right"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMaxRadiusRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "max_radius") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("max_radius"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMarginXthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "margin_x_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("margin_x_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMarginYthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "margin_y_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("margin_y_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getLimitXthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "limit_x_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("limit_x_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getLimitYthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "limit_y_th") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("limit_y_th"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getWidthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "width") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("width"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getHeightRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "height") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("height"));
                break;
            }
        }
        return range;
    }
};

class LutNoiseRemovalFilter : public Filter {
public:
    LutNoiseRemovalFilter(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("LutNoiseRemovalFilter", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~LutNoiseRemovalFilter() noexcept override = default;

    void setFilterParams(OBLutNoiseRemovalFilterParams filterParams) {
        for(int i = 0; i < 16; ++i) {
            setConfigValue("max_lut_" + std::to_string(i), static_cast<double>(filterParams.max_lut[i]));
        }
        setConfigValue("min_diff", static_cast<double>(filterParams.min_diff));
        setConfigValue("width", static_cast<double>(filterParams.width));
        setConfigValue("height", static_cast<double>(filterParams.height));
    }

    OBLutNoiseRemovalFilterParams getFilterParams() {
        OBLutNoiseRemovalFilterParams params{};
        for(int i = 0; i < 16; ++i) {
            params.max_lut[i] = static_cast<uint16_t>(getConfigValue("max_lut_" + std::to_string(i)));
        }
        params.min_diff = static_cast<uint16_t>(getConfigValue("min_diff"));
        params.width    = static_cast<uint32_t>(getConfigValue("width"));
        params.height   = static_cast<uint32_t>(getConfigValue("height"));
        return params;
    }

    OBUint16PropertyRange getMaxLutRange(int index) {
        OBUint16PropertyRange range{};
        if(index < 0 || index >= 16) {
            return range;
        }
        std::string name      = "max_lut_" + std::to_string(index);
        const auto &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, name.c_str()) == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue(name));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getMinDiffRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "min_diff") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("min_diff"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getWidthRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "width") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("width"));
                break;
            }
        }
        return range;
    }

    OBUint16PropertyRange getHeightRange() {
        OBUint16PropertyRange range{};
        const auto           &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            if(strcmp(item.name, "height") == 0) {
                range = getPropertyRange<OBUint16PropertyRange>(item, getConfigValue("height"));
                break;
            }
        }
        return range;
    }
};

class DisparityTransform : public Filter {
public:
    DisparityTransform(const std::string &activationKey = "") {
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("DisparityTransform", activationKey.c_str(), &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~DisparityTransform() noexcept override = default;
};

class EnhancedDepthFilter : public Filter {
public:
    template <typename T> explicit EnhancedDepthFilter(std::shared_ptr<T> device, const std::string &modelPath = "") {
        if(!device) {
            throw std::invalid_argument("device is null");
        }
        ob_error *error = nullptr;
        auto      impl  = ob_create_private_filter("EnhancedDepthFilter", "", &error);
        Error::handle(&error);
 
        // Only pass options when a model path is provided; otherwise hand down nullptr so the filter uses its default.
        ob_priv_filter_activate_options  options{};
        ob_priv_filter_activate_options *optionsPtr = nullptr;
        if(!modelPath.empty()) {
            options.struct_size = sizeof(options);
            options.model_path  = modelPath.c_str();
            optionsPtr          = &options;
        }
        ob_filter_activate_private_ex(impl, device->getImpl(), optionsPtr, &error);
        Error::handle(&error);
        init(impl);
    }
 
    ~EnhancedDepthFilter() noexcept override = default;

    static const std::vector<std::pair<uint32_t, uint32_t>> &getSupportedResolutions() {
        static const std::vector<std::pair<uint32_t, uint32_t>> supportedResolutions = {
            { 640, 480 },
            { 1280, 720 },
            { 1280, 800 },
        };
        return supportedResolutions;
    }

    static std::vector<OBFormat> getSupportedFormats(OBStreamType streamType) {
        if(streamType == OB_STREAM_COLOR) {
            return { OB_FORMAT_RGB };
        }
        if(streamType == OB_STREAM_DEPTH) {
            return { OB_FORMAT_Y10, OB_FORMAT_Y11, OB_FORMAT_Y12, OB_FORMAT_Y14, OB_FORMAT_Y16, OB_FORMAT_Z16 };
        }
        return {};
    }

    static bool isSupportedResolution(OBStreamType sourceStreamType, OBStreamType alignToStreamType, uint32_t width, uint32_t height) {
        if(sourceStreamType != alignToStreamType) {
            // If the source and target stream types are different, any resolution is supported.
            return true;
        }
 
        for(const auto &res: getSupportedResolutions()) {
            if(res.first == width && res.second == height) {
                return true;
            }
        }
        return false;
    }

    static bool isSupportedFormat(OBStreamType streamType, OBFormat format) {
        for(const auto &supported: getSupportedFormats(streamType)) {
            if(supported == format) {
                return true;
            }
        }
        return false;
    }

    void setResolution(uint32_t width, uint32_t height) {
        setConfigValue("width", static_cast<double>(width));
        setConfigValue("height", static_cast<double>(height));
    }

    uint32_t getCurrentWidth() const {
        return static_cast<uint32_t>(getConfigValue("width"));
    }

    uint32_t getCurrentHeight() const {
        return static_cast<uint32_t>(getConfigValue("height"));
    }

    void setConfidenceThreshold(uint32_t value) {
        setConfigValue("confidence_threshold", static_cast<double>(value));
    }

    OBIntPropertyRange getConfidenceThresholdRange() {
        OBIntPropertyRange range{};
        const auto        &schemaVec = getConfigSchemaVec();
        for(const auto &item: schemaVec) {
            const char *name = "confidence_threshold";
            if(std::strcmp(item.name, name) == 0) {
                range = getPropertyRange<OBIntPropertyRange>(item, getConfigValue(name));
                break;
            }
        }
        return range;
    }
};
 
class OBFilterList {
private:
    ob_filter_list_t *impl_;
 
public:
    explicit OBFilterList(ob_filter_list_t *impl) : impl_(impl) {}
 
    ~OBFilterList() noexcept {
        ob_error *error = nullptr;
        ob_delete_filter_list(impl_, &error);
        Error::handle(&error, false);
    }

    uint32_t getCount() const {
        ob_error *error = nullptr;
        auto      count = ob_filter_list_get_count(impl_, &error);
        Error::handle(&error);
        return count;
    }

    std::shared_ptr<Filter> getFilter(uint32_t index) {
        ob_error *error  = nullptr;
        auto      filter = ob_filter_list_get_filter(impl_, index, &error);
        Error::handle(&error);
        return std::make_shared<Filter>(filter);
    }
 
public:
    // The following interfaces are deprecated and are retained here for compatibility purposes.
    uint32_t count() const {
        return getCount();
    }
};

inline const std::unordered_map<std::string, std::type_index> &getFilterTypeMap() {
    static const std::unordered_map<std::string, std::type_index> filterTypeMap = {
        { "PointCloudFilter", typeid(PointCloudFilter) },
        { "Align", typeid(Align) },
        { "FormatConverter", typeid(FormatConvertFilter) },
        { "HDRMerge", typeid(HdrMerge) },
        { "SequenceIdFilter", typeid(SequenceIdFilter) },
        { "DecimationFilter", typeid(DecimationFilter) },
        { "ThresholdFilter", typeid(ThresholdFilter) },
        { "SpatialAdvancedFilter", typeid(SpatialAdvancedFilter) },
        { "HoleFillingFilter", typeid(HoleFillingFilter) },
        { "NoiseRemovalFilter", typeid(NoiseRemovalFilter) },
        { "TemporalFilter", typeid(TemporalFilter) },
        { "DisparityTransform", typeid(DisparityTransform) },
        { "SpatialFastFilter", typeid(SpatialFastFilter) },
        { "SpatialModerateFilter", typeid(SpatialModerateFilter) },
        { "EdgeNoiseRemovalFilter", typeid(EdgeNoiseRemovalFilter) },
        { "FalsePositiveFilter", typeid(FalsePositiveFilter) },
        { "MgcNoiseRemovalFilter", typeid(MgcNoiseRemovalFilter) },
        { "LutNoiseRemovalFilter", typeid(LutNoiseRemovalFilter) },
        { "UnDistortionFilter", typeid(UnDistortionFilter) },
        { "EnhancedDepthFilter", typeid(EnhancedDepthFilter) },
    };
    return filterTypeMap;
}

template <typename T> bool Filter::is() {
    std::string name = type();
 
    const auto &filterTypeMap = getFilterTypeMap();
    auto        it            = filterTypeMap.find(name);
    if(it != filterTypeMap.end()) {
        return std::type_index(typeid(T)) == it->second;
    }
    return false;
}
 
}  // namespace ob