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 <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 {
        ob_error *error  = nullptr;
        auto      result = ob_filter_process(impl_, frame->getImpl(), &error);
        Error::handle(&error);
        if(!result) {
            return nullptr;
        }
        return std::make_shared<Frame>(result);
    }

    virtual void pushFrame(std::shared_ptr<Frame> frame) const {
        ob_error *error = nullptr;
        ob_filter_push_frame(impl_, frame->getImpl(), &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));
    }
 
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 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 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 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) },
    };
    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