Filter.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Types.hpp"
#include <functional>
#include <memory>
#include <map>
#include <string>
#include <iostream>
 
namespace ob {
class Frame;
class OBFilterList;
 
typedef std::function<void(std::shared_ptr<Frame>)> FilterCallback;
 
class OB_EXTENSION_API Filter : public std::enable_shared_from_this<Filter> {
public:
    Filter();
 
    Filter(std::shared_ptr<FilterImpl> impl);
 
    virtual ~Filter() = default;
 
    virtual void reset();
 
    void enable(bool enable);
 
    bool isEnabled();
 
    virtual std::shared_ptr<Frame> process(std::shared_ptr<Frame> frame);
 
    virtual void pushFrame(std::shared_ptr<Frame> frame);
 
    virtual void setCallBack(FilterCallback callback);
 
    virtual const char *type();
 
    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());
    }
 
protected:
    std::shared_ptr<FilterImpl> impl_;
    std::string                 type_;
 
    friend class OBFilterList;
};
 
class OB_EXTENSION_API PointCloudFilter : public Filter {
public:
    PointCloudFilter();
 
    void setCreatePointFormat(OBFormat type);
 
    void setCameraParam(OBCameraParam param);
 
    void setFrameAlignState(bool state);
 
    void setPositionDataScaled(float scale);
 
    void setColorDataNormalization(bool state);
 
    void setCoordinateSystem(OBCoordinateSystemType type);
};
 
class OB_EXTENSION_API FormatConvertFilter : public Filter {
public:
    FormatConvertFilter();
 
    void setFormatConvertType(OBConvertFormat type);
};
 
class OB_EXTENSION_API CompressionFilter : public Filter {
public:
    CompressionFilter();
 
    void setCompressionParams(OBCompressionMode mode, void *params);
};
 
class OB_EXTENSION_API DecompressionFilter : public Filter {
public:
    DecompressionFilter();
};
 
class OB_EXTENSION_API HoleFillingFilter : public Filter {
public:
    HoleFillingFilter();
 
    void setFilterMode(OBHoleFillingMode mode);
 
    OBHoleFillingMode getFilterMode();
};
 
class OB_EXTENSION_API TemporalFilter : public Filter {
public:
    TemporalFilter();
 
    OBFloatPropertyRange getDiffScaleRange();
 
    void setDiffScale(float value);
 
    OBFloatPropertyRange getWeightRange();
 
    void setWeight(float value);
};
 
class OB_EXTENSION_API SpatialAdvancedFilter : public Filter {
public:
    SpatialAdvancedFilter();
 
    OBFloatPropertyRange getAlphaRange();
 
    OBUint16PropertyRange getDispDiffRange();
 
    OBUint16PropertyRange getRadiusRange();
 
    OBIntPropertyRange getMagnitudeRange();
 
    OBSpatialAdvancedFilterParams getFilterParams();
 
    void setFilterParams(OBSpatialAdvancedFilterParams params);
};
 
class OB_EXTENSION_API SpatialFastFilter : public Filter {
public:
    SpatialFastFilter();
    OBUint8PropertyRange getSizeRange();
 
    OBSpatialFastFilterParams getFilterParams();
    void setFilterParams(OBSpatialFastFilterParams params);
};
 
class OB_EXTENSION_API SpatialModerateFilter : public Filter {
public:
    SpatialModerateFilter();
    OBUint8PropertyRange          getSizeRange();
 
    OBUint8PropertyRange getMagnitudeRange();
    OBUint16PropertyRange getDispDiffRange();
 
    OBSpatialModerateFilterParams getFilterParams();
    void setFilterParams(OBSpatialModerateFilterParams params);
};
 
class OB_EXTENSION_API DisparityTransform : public Filter {
public:
 
    DisparityTransform(bool depth_to_disparity);
};
 
class OB_EXTENSION_API HdrMerge : public Filter {
public:
    HdrMerge();
};
 
class OB_EXTENSION_API Align : public Filter {
public:
    Align(OBStreamType align_to_stream);
 
    OBStreamType getAlignToStreamType();
};
 
class OB_EXTENSION_API ThresholdFilter : public Filter {
public:
    ThresholdFilter();
 
    OBIntPropertyRange getMinRange();
 
    OBIntPropertyRange getMaxRange();
 
    bool setValueRange(uint16_t min, uint16_t max);
};
 
class OB_EXTENSION_API SequenceIdFilter : public Filter {
public:
    SequenceIdFilter();
 
    void selectSequenceId(int sequence_id);
 
    int getSelectSequenceId();
 
    OBSequenceIdItem *getSequenceIdList();
 
    int getSequenceIdListSize();
};
 
class OB_EXTENSION_API NoiseRemovalFilter : public Filter {
public:
    NoiseRemovalFilter();
 
    void setFilterParams(OBNoiseRemovalFilterParams filterParams);
 
    OBNoiseRemovalFilterParams getFilterParams();
 
    OBUint16PropertyRange getDispDiffRange();
 
    OBUint16PropertyRange getMaxSizeRange();
};
 
class OB_EXTENSION_API DecimationFilter : public Filter {
public:
    DecimationFilter();
 
    void setScaleValue(uint8_t value);
 
    uint8_t getScaleValue();
 
    OBUint8PropertyRange getScaleRange();
};
 
class OB_EXTENSION_API EdgeNoiseRemovalFilter : public Filter {
public:
    EdgeNoiseRemovalFilter();
 
    void setFilterParams(OBEdgeNoiseRemovalFilterParams filterParams);
 
    OBEdgeNoiseRemovalFilterParams getFilterParams();
 
    OBUint16PropertyRange getMarginLeftThRange();
 
    OBUint16PropertyRange getMarginRightThRange();
 
    OBUint16PropertyRange getMarginTopThRange();
 
    OBUint16PropertyRange getMarginBottomThRange();
};
 
 
// Define the is() template function for the Filter class
template <typename T> bool Filter::is() {
    std::string name = type();
    if(name == "HDRMerge") {
        return typeid(T) == typeid(HdrMerge);
    }
    if(name == "SequenceIdFilter") {
        return typeid(T) == typeid(SequenceIdFilter);
    }
    if(name == "ThresholdFilter") {
        return typeid(T) == typeid(ThresholdFilter);
    }
    if(name == "DisparityTransform") {
        return typeid(T) == typeid(DisparityTransform);
    }
    if(name == "NoiseRemovalFilter") {
        return typeid(T) == typeid(NoiseRemovalFilter);
    }
    if(name == "SpatialAdvancedFilter") {
        return typeid(T) == typeid(SpatialAdvancedFilter);
    }
 
    if(name == "SpatialFastFilter") {
        return typeid(T) == typeid(SpatialFastFilter);
    }
 
    if(name == "SpatialModerateFilter") {
        return typeid(T) == typeid(SpatialModerateFilter);
    }
 
    if(name == "TemporalFilter") {
        return typeid(T) == typeid(TemporalFilter);
    }
    if(name == "HoleFillingFilter") {
        return typeid(T) == typeid(HoleFillingFilter);
    }
    if(name == "DecimationFilter") {
        return typeid(T) == typeid(DecimationFilter);
    }
    if(name == "PointCloudFilter") {
        return typeid(T) == typeid(PointCloudFilter);
    }
    if(name == "CompressionFilter") {
        return typeid(T) == typeid(CompressionFilter);
    }
    if(name == "DecompressionFilter") {
        return typeid(T) == typeid(DecompressionFilter);
    }
    if(name == "FormatConverter") {
        return typeid(T) == typeid(FormatConvertFilter);
    }
    if(name == "Align") {
        return typeid(T) == typeid(Align);
    }
    if(name == "EdgeNoiseRemovalFilter") {
        return typeid(T) == typeid(EdgeNoiseRemovalFilter);
    }
    return false;
}
 
}  // namespace ob