Feature/extract stereo filters

CMakeLists.txt

@@ -188,7 +188,7 @@ set(THIRDPARTY_OPENCV_LIBRARIES "" CACHE STRING "Optional libraries to link Open
 set(TARGET_OPENCV_NAME ${PROJECT_NAME}-opencv)
 set(TARGET_OPENCV_ALIAS opencv)
 if(DEPTHAI_OPENCV_SUPPORT)
-    set(REQUIRED_OPENCV_LIBRARIES "opencv_core" "opencv_imgproc" "opencv_videoio" "opencv_highgui")
+    set(REQUIRED_OPENCV_LIBRARIES "opencv_core" "opencv_imgproc" "opencv_videoio" "opencv_highgui" "opencv_calib3d")
     set(OPENCV_SUPPORT_AVAILABLE ${OpenCV_FOUND})
     foreach(lib ${REQUIRED_OPENCV_LIBRARIES})
         if(NOT (lib IN_LIST OpenCV_LIBS))
@@ -367,6 +367,7 @@ set(TARGET_OPENCV_SOURCES
     src/pipeline/node/host/HostCamera.cpp
     src/pipeline/node/host/Record.cpp
     src/pipeline/node/host/Replay.cpp
+    src/pipeline/node/ImageFilters.cpp
     src/opencv/RecordReplay.cpp
     src/opencv/HolisticRecordReplay.cpp
 )

bindings/js/bindings.cpp

@@ -76,7 +76,8 @@ EMSCRIPTEN_BINDINGS(depthai_js) {
         .value("ToFConfig", dai::DatatypeEnum::ToFConfig)
         .value("TrackedFeatures", dai::DatatypeEnum::TrackedFeatures)
         .value("BenchmarkReport", dai::DatatypeEnum::BenchmarkReport)
-        .value("MessageGroup", dai::DatatypeEnum::MessageGroup);
+        .value("MessageGroup", dai::DatatypeEnum::MessageGroup)
+        .value("ImageFiltersConfig", dai::DatatypeEnum::ImageFiltersConfig);
 
     // structs
     value_object<MessageHeader>("MessageHeader")

bindings/python/CMakeLists.txt

@@ -106,6 +106,8 @@ set(SOURCE_LIST
     src/pipeline/node/ReplayBindings.cpp
     src/pipeline/node/ImageAlignBindings.cpp
     src/pipeline/node/RGBDBindings.cpp
+    src/pipeline/node/ImageFiltersBindings.cpp
+    src/pipeline/FilterParamsBindings.cpp
 
     src/pipeline/datatype/ADatatypeBindings.cpp
     src/pipeline/datatype/AprilTagConfigBindings.cpp

bindings/python/src/pipeline/FilterParamsBindings.cpp

@@ -0,0 +1,87 @@
+#include "FilterParamsBindings.hpp"
+#include "depthai/pipeline/FilterParams.hpp"
+
+void FilterParamsBindings::bind(pybind11::module& m, void* pCallstack) {
+    // dai.filters.params
+    py::module_ filters = m.def_submodule("filters", "Parameters for filters");
+    py::module_ params = filters.def_submodule("params", "Parameters for filters");
+
+    // -- Median Filter --
+    py::enum_<dai::filters::params::MedianFilter> medianFilter(params, "MedianFilter");
+    medianFilter.value("MEDIAN_OFF", dai::filters::params::MedianFilter::MEDIAN_OFF)
+        .value("KERNEL_3x3", dai::filters::params::MedianFilter::KERNEL_3x3)
+        .value("KERNEL_5x5", dai::filters::params::MedianFilter::KERNEL_5x5)
+        .value("KERNEL_7x7", dai::filters::params::MedianFilter::KERNEL_7x7);
+
+    // -- Spatial Filter --
+    py::class_<dai::filters::params::SpatialFilter> spatialFilter(params, "SpatialFilter");
+    spatialFilter.def(py::init<>())
+        .def_readwrite("enable", &dai::filters::params::SpatialFilter::enable, DOC(dai, filters, params, SpatialFilter, enable))
+        .def_readwrite(
+            "holeFillingRadius", &dai::filters::params::SpatialFilter::holeFillingRadius, DOC(dai, filters, params, SpatialFilter, holeFillingRadius))
+        .def_readwrite("alpha", &dai::filters::params::SpatialFilter::alpha, DOC(dai, filters, params, SpatialFilter, alpha))
+        .def_readwrite("delta", &dai::filters::params::SpatialFilter::delta, DOC(dai, filters, params, SpatialFilter, delta))
+        .def_readwrite("numIterations", &dai::filters::params::SpatialFilter::numIterations, DOC(dai, filters, params, SpatialFilter, numIterations));
+
+    // -- Temporal Filter --
+    py::class_<dai::filters::params::TemporalFilter> temporalFilter(
+        params, "TemporalFilter", DOC(dai, filters, params, TemporalFilter));
+    temporalFilter.def(py::init<>())
+        .def_readwrite("enable", &dai::filters::params::TemporalFilter::enable, DOC(dai, filters, params, TemporalFilter, enable))
+        .def_readwrite(
+            "persistencyMode", &dai::filters::params::TemporalFilter::persistencyMode, DOC(dai, filters, params, TemporalFilter, persistencyMode))
+        .def_readwrite("alpha", &dai::filters::params::TemporalFilter::alpha, DOC(dai, filters, params, TemporalFilter, alpha))
+        .def_readwrite("delta", &dai::filters::params::TemporalFilter::delta, DOC(dai, filters, params, TemporalFilter, delta));
+
+    py::enum_<dai::filters::params::TemporalFilter::PersistencyMode> persistencyMode(
+        temporalFilter, "PersistencyMode", DOC(dai, filters, params, TemporalFilter, PersistencyMode));
+    persistencyMode
+        .value("PERSISTENCY_OFF",
+               dai::filters::params::TemporalFilter::PersistencyMode::PERSISTENCY_OFF,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, PERSISTENCY_OFF))
+        .value("VALID_8_OUT_OF_8",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_8_OUT_OF_8,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_8_OUT_OF_8))
+        .value("VALID_2_IN_LAST_3",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_2_IN_LAST_3,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_2_IN_LAST_3))
+        .value("VALID_2_IN_LAST_4",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_2_IN_LAST_4,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_2_IN_LAST_4))
+        .value("VALID_2_OUT_OF_8",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_2_OUT_OF_8,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_2_OUT_OF_8))
+        .value("VALID_1_IN_LAST_2",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_2,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_2))
+        .value("VALID_1_IN_LAST_5",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_5,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_5))
+        .value("VALID_1_IN_LAST_8",
+               dai::filters::params::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_8,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_8))
+        .value("PERSISTENCY_INDEFINITELY",
+               dai::filters::params::TemporalFilter::PersistencyMode::PERSISTENCY_INDEFINITELY,
+               DOC(dai, filters, params, TemporalFilter, PersistencyMode, PERSISTENCY_INDEFINITELY));
+
+    // -- Speckle filter --
+    py::class_<dai::filters::params::SpeckleFilter> speckleFilter(params, "SpeckleFilter");
+    speckleFilter.def(py::init<>())
+        .def_readwrite("enable", &dai::filters::params::SpeckleFilter::enable, DOC(dai, filters, params, SpeckleFilter, enable))
+        .def_readwrite("speckleRange", &dai::filters::params::SpeckleFilter::speckleRange, DOC(dai, filters, params, SpeckleFilter, speckleRange))
+        .def_readwrite("differenceThreshold",
+                       &dai::filters::params::SpeckleFilter::differenceThreshold,
+                       DOC(dai, filters, params, SpeckleFilter, differenceThreshold));
+
+    // Aliases for backward compatibility
+    m.attr("MedianFilter") = medianFilter;
+    m.attr("StereoDepthConfig").attr("MedianFilter") = medianFilter;
+    m.attr("StereoDepthConfig").attr("PostProcessing").attr("SpatialFilter") = spatialFilter;
+    m.attr("StereoDepthConfig").attr("PostProcessing").attr("TemporalFilter") = temporalFilter;
+    m.attr("StereoDepthConfig").attr("PostProcessing").attr("SpeckleFilter") = speckleFilter;
+
+    Callstack* callstack = (Callstack*)pCallstack;
+    auto cb = callstack->top();
+    callstack->pop();
+    cb(m, pCallstack);
+}

bindings/python/src/pipeline/FilterParamsBindings.hpp

@@ -0,0 +1,6 @@
+#pragma once
+#include "pybind11_common.hpp"
+
+struct FilterParamsBindings {
+    static void bind(pybind11::module& m, void* pCallstack);
+};

bindings/python/src/pipeline/datatype/StereoDepthConfigBindings.cpp

@@ -20,26 +20,17 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
     // RawStereoDepthConfig));
     py::class_<StereoDepthConfig, Py<StereoDepthConfig>, Buffer, std::shared_ptr<StereoDepthConfig>> stereoDepthConfig(
         m, "StereoDepthConfig", DOC(dai, StereoDepthConfig));
-    py::enum_<StereoDepthConfig::MedianFilter> medianFilter(m, "MedianFilter", DOC(dai, MedianFilter));
     py::class_<StereoDepthConfig::ConfidenceMetrics> _ConfidenceMetrics(stereoDepthConfig, "ConfidenceMetrics", DOC(dai, StereoDepthConfig, ConfidenceMetrics));
     py::class_<StereoDepthConfig::AlgorithmControl> algorithmControl(stereoDepthConfig, "AlgorithmControl", DOC(dai, StereoDepthConfig, AlgorithmControl));
     py::enum_<StereoDepthConfig::AlgorithmControl::DepthAlign> depthAlign(
         algorithmControl, "DepthAlign", DOC(dai, StereoDepthConfig, AlgorithmControl, DepthAlign));
     py::enum_<StereoDepthConfig::AlgorithmControl::DepthUnit> depthUnit(
         algorithmControl, "DepthUnit", DOC(dai, StereoDepthConfig, AlgorithmControl, DepthUnit));
     py::class_<StereoDepthConfig::PostProcessing> postProcessing(stereoDepthConfig, "PostProcessing", DOC(dai, StereoDepthConfig, PostProcessing));
-    py::class_<StereoDepthConfig::PostProcessing::SpatialFilter> spatialFilter(
-        postProcessing, "SpatialFilter", DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter));
-    py::class_<StereoDepthConfig::PostProcessing::TemporalFilter> temporalFilter(
-        postProcessing, "TemporalFilter", DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter));
-    py::enum_<StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode> persistencyMode(
-        temporalFilter, "PersistencyMode", DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode));
     py::class_<StereoDepthConfig::PostProcessing::ThresholdFilter> thresholdFilter(
         postProcessing, "ThresholdFilter", DOC(dai, StereoDepthConfig, PostProcessing, ThresholdFilter));
     py::class_<StereoDepthConfig::PostProcessing::BrightnessFilter> brightnessFilter(
         postProcessing, "BrightnessFilter", DOC(dai, StereoDepthConfig, PostProcessing, BrightnessFilter));
-    py::class_<StereoDepthConfig::PostProcessing::SpeckleFilter> speckleFilter(
-        postProcessing, "SpeckleFilter", DOC(dai, StereoDepthConfig, PostProcessing, SpeckleFilter));
     py::class_<StereoDepthConfig::PostProcessing::DecimationFilter> decimationFilter(
         postProcessing, "DecimationFilter", DOC(dai, StereoDepthConfig, PostProcessing, DecimationFilter));
     py::enum_<StereoDepthConfig::PostProcessing::DecimationFilter::DecimationMode> decimationMode(
@@ -73,13 +64,6 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
     ///////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////
 
-    // Metadata / raw
-    medianFilter.value("MEDIAN_OFF", StereoDepthConfig::MedianFilter::MEDIAN_OFF)
-        .value("KERNEL_3x3", StereoDepthConfig::MedianFilter::KERNEL_3x3)
-        .value("KERNEL_5x5", StereoDepthConfig::MedianFilter::KERNEL_5x5)
-        .value("KERNEL_7x7", StereoDepthConfig::MedianFilter::KERNEL_7x7);
-    // m.attr("StereoDepthProperties").attr("MedianFilter") = medianFilter;
-
     depthAlign
         .value("RECTIFIED_RIGHT",
                StereoDepthConfig::AlgorithmControl::DepthAlign::RECTIFIED_RIGHT,
@@ -145,55 +129,6 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
         .def_readwrite(
             "flatnessOverride", &StereoDepthConfig::ConfidenceMetrics::flatnessOverride, DOC(dai, StereoDepthConfig, ConfidenceMetrics, flatnessOverride));
 
-    spatialFilter.def(py::init<>())
-        .def_readwrite("enable", &StereoDepthConfig::PostProcessing::SpatialFilter::enable, DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter, enable))
-        .def_readwrite("holeFillingRadius",
-                       &StereoDepthConfig::PostProcessing::SpatialFilter::holeFillingRadius,
-                       DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter, holeFillingRadius))
-        .def_readwrite("alpha", &StereoDepthConfig::PostProcessing::SpatialFilter::alpha, DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter, alpha))
-        .def_readwrite("delta", &StereoDepthConfig::PostProcessing::SpatialFilter::delta, DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter, delta))
-        .def_readwrite("numIterations",
-                       &StereoDepthConfig::PostProcessing::SpatialFilter::numIterations,
-                       DOC(dai, StereoDepthConfig, PostProcessing, SpatialFilter, numIterations));
-
-    persistencyMode
-        .value("PERSISTENCY_OFF",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::PERSISTENCY_OFF,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, PERSISTENCY_OFF))
-        .value("VALID_8_OUT_OF_8",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_8_OUT_OF_8,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_8_OUT_OF_8))
-        .value("VALID_2_IN_LAST_3",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_2_IN_LAST_3,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_2_IN_LAST_3))
-        .value("VALID_2_IN_LAST_4",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_2_IN_LAST_4,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_2_IN_LAST_4))
-        .value("VALID_2_OUT_OF_8",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_2_OUT_OF_8,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_2_OUT_OF_8))
-        .value("VALID_1_IN_LAST_2",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_2,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_2))
-        .value("VALID_1_IN_LAST_5",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_5,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_5))
-        .value("VALID_1_IN_LAST_8",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::VALID_1_IN_LAST_8,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, VALID_1_IN_LAST_8))
-        .value("PERSISTENCY_INDEFINITELY",
-               StereoDepthConfig::PostProcessing::TemporalFilter::PersistencyMode::PERSISTENCY_INDEFINITELY,
-               DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, PersistencyMode, PERSISTENCY_INDEFINITELY));
-
-    temporalFilter.def(py::init<>())
-        .def_readwrite(
-            "enable", &StereoDepthConfig::PostProcessing::TemporalFilter::enable, DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, enable))
-        .def_readwrite("persistencyMode",
-                       &StereoDepthConfig::PostProcessing::TemporalFilter::persistencyMode,
-                       DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, persistencyMode))
-        .def_readwrite("alpha", &StereoDepthConfig::PostProcessing::TemporalFilter::alpha, DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, alpha))
-        .def_readwrite("delta", &StereoDepthConfig::PostProcessing::TemporalFilter::delta, DOC(dai, StereoDepthConfig, PostProcessing, TemporalFilter, delta));
-
     thresholdFilter.def(py::init<>())
         .def_readwrite(
             "minRange", &StereoDepthConfig::PostProcessing::ThresholdFilter::minRange, DOC(dai, StereoDepthConfig, PostProcessing, ThresholdFilter, minRange))
@@ -208,15 +143,6 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
                        &StereoDepthConfig::PostProcessing::BrightnessFilter::maxBrightness,
                        DOC(dai, StereoDepthConfig, PostProcessing, BrightnessFilter, maxBrightness));
 
-    speckleFilter.def(py::init<>())
-        .def_readwrite("enable", &StereoDepthConfig::PostProcessing::SpeckleFilter::enable, DOC(dai, StereoDepthConfig, PostProcessing, SpeckleFilter, enable))
-        .def_readwrite("speckleRange",
-                       &StereoDepthConfig::PostProcessing::SpeckleFilter::speckleRange,
-                       DOC(dai, StereoDepthConfig, PostProcessing, SpeckleFilter, speckleRange))
-        .def_readwrite("differenceThreshold",
-                       &StereoDepthConfig::PostProcessing::SpeckleFilter::differenceThreshold,
-                       DOC(dai, StereoDepthConfig, PostProcessing, SpeckleFilter, differenceThreshold));
-
     decimationMode
         .value("PIXEL_SKIPPING",
                StereoDepthConfig::PostProcessing::DecimationFilter::DecimationMode::PIXEL_SKIPPING,
@@ -375,8 +301,6 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
         .def_readwrite("costMatching", &StereoDepthConfig::costMatching, DOC(dai, StereoDepthConfig, costMatching))
         .def_readwrite("costAggregation", &StereoDepthConfig::costAggregation, DOC(dai, StereoDepthConfig, costAggregation))
         .def_readwrite("confidenceMetrics", &StereoDepthConfig::confidenceMetrics, DOC(dai, StereoDepthConfig, confidenceMetrics));
-    // legacy
-    m.attr("StereoDepthConfig").attr("MedianFilter") = medianFilter;
 
     // Message
     stereoDepthConfig.def(py::init<>())
@@ -416,7 +340,6 @@ void bind_stereodepthconfig(pybind11::module& m, void* pCallstack) {
              py::arg("filtersBackend"),
              DOC(dai, StereoDepthConfig, setFiltersComputeBackend))
         .def("getFiltersComputeBackend", &StereoDepthConfig::getFiltersComputeBackend, DOC(dai, StereoDepthConfig, getFiltersComputeBackend));
-    m.attr("StereoDepthConfig").attr("MedianFilter") = medianFilter;
     m.attr("StereoDepthConfig").attr("AlgorithmControl") = algorithmControl;
     m.attr("StereoDepthConfig").attr("PostProcessing") = postProcessing;
     m.attr("StereoDepthConfig").attr("CensusTransform") = censusTransform;