V3 dcl mode implementation

CMakeLists.txt

@@ -69,6 +69,15 @@ set(DEPTHAI_PRE_RELEASE_VERSION "2")
 # Set DEPTHAI_VERSION universally, not conditionally
 set(DEPTHAI_VERSION ${PROJECT_VERSION}-${DEPTHAI_PRE_RELEASE_TYPE}.${DEPTHAI_PRE_RELEASE_VERSION})
 
+# Default for dynamic calibration support (turn on x64 Liunux, but off for others)
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64" AND UNIX)
+    message(STATUS "Dynamic Calibration support enabled by default for x64 Linux")
+    option(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT "Enable Dynamic Calibration support" ON)
+else()
+    message(STATUS "Dynamic Calibration support disabled by default")
+    option(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT "Enable Dynamic Calibration support" OFF)
+endif()
+
 get_directory_property(has_parent PARENT_DIRECTORY)
 if(has_parent)
     set(DEPTHAI_VERSION ${DEPTHAI_VERSION} PARENT_SCOPE)  # Set in parent scope if there's a parent
@@ -190,7 +199,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))
@@ -363,6 +372,12 @@ if(DEPTHAI_ENABLE_PROTOBUF)
     )
 endif()
 
+if(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT)
+    list(APPEND TARGET_CORE_SOURCES
+        src/pipeline/node/DynamicCalibration.cpp
+    )
+endif()
+
 set(TARGET_OPENCV_SOURCES
     src/opencv/ImgFrame.cpp
     src/pipeline/node/host/Display.cpp
@@ -500,6 +515,45 @@ if(NOT BUILD_SHARED_LIBS)
     target_compile_definitions(${TARGET_CORE_NAME} PUBLIC MCAP_STATIC)
 endif()
 
+if(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT)
+    include(FetchContent)
+    set(DEPTHAI_DYNAMIC_CALIBRATION_PATH "" CACHE FILEPATH "Override path to local dynamic_calibration .zip file")
+
+    if(DEPTHAI_DYNAMIC_CALIBRATION_PATH AND EXISTS "${DEPTHAI_DYNAMIC_CALIBRATION_PATH}")
+        message(STATUS "Using local dynamic_calibration zip: ${DEPTHAI_DYNAMIC_CALIBRATION_PATH}")
+        FetchContent_Declare(
+            dynamic_calibration
+            URL "file://${DEPTHAI_DYNAMIC_CALIBRATION_PATH}"
+        )
+    else()
+        message(STATUS "Using remote dynamic_calibration zip")
+        FetchContent_Declare(
+            dynamic_calibration
+            URL https://artifacts.luxonis.com/artifactory/list/luxonis-depthai-helper-binaries/dynamic_calibration/510f107f671bbba2e353c5d5a4ac9a03f1715dea/dynamic_calibration_manylinux.zip
+            URL_HASH MD5=8d179385a633b979fe81a3ca91c6cca6
+        )
+    endif()
+    FetchContent_MakeAvailable(dynamic_calibration)
+    message(STATUS "Dynamic calibration extracted to ${dynamic_calibration_SOURCE_DIR}")
+    set(DYNAMIC_CALIBRATION_DIR ${dynamic_calibration_SOURCE_DIR})
+    target_include_directories(
+        ${TARGET_CORE_NAME} PUBLIC
+        $<BUILD_INTERFACE:${DYNAMIC_CALIBRATION_DIR}/include>
+    )
+
+    find_library(DYNAMIC_CALIBRATION dynamic_calibration
+        PATHS ${DYNAMIC_CALIBRATION_DIR}/lib
+        NO_DEFAULT_PATH
+    )
+    target_compile_definitions(${TARGET_CORE_NAME} PUBLIC DEPTHAI_HAVE_DYNAMIC_CALIBRATION_SUPPORT)
+    if(DYNAMIC_CALIBRATION)
+        message(STATUS "Dynamic Calibration library found: ${DYNAMIC_CALIBRATION}")
+        target_link_libraries(${TARGET_CORE_NAME} PUBLIC ${DYNAMIC_CALIBRATION})
+    else()
+        message(FATAL_ERROR "Dynamic Calibration library not found, disable support by setting DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT to OFF")
+    endif()
+endif()
+
 # Set constant
 set(DEPTHAI_RESOURCES_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/resources")
 

bindings/python/CMakeLists.txt

@@ -167,6 +167,14 @@ if(DEPTHAI_RTABMAP_SUPPORT)
     )
 endif()
 
+if(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT)
+    list(APPEND SOURCE_LIST
+        src/pipeline/node/DynamicCalibrationBindings.cpp
+        src/pipeline/datatype/DynamicCalibrationResultsBindings.cpp
+        src/pipeline/datatype/DynamicCalibrationConfigBindings.cpp
+    )
+endif()
+
 # Add files for python module
 if(DEPTHAI_PYTHON_EMBEDDED_MODULE)
     add_library(${TARGET_NAME} ${SOURCE_LIST})

bindings/python/src/DatatypeBindings.cpp

@@ -34,6 +34,8 @@ void bind_transformdata(pybind11::module& m, void* pCallstack);
 void bind_rgbddata(pybind11::module& m, void* pCallstack);
 void bind_imagealignconfig(pybind11::module& m, void* pCallstack);
 void bind_imageannotations(pybind11::module& m, void* pCallstack);
+void bind_dynamic_calibration_results(pybind11::module& m, void* pCallstack);
+void bind_dynamic_calibration_config(pybind11::module& m, void* pCallstack);
 
 void DatatypeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     // Bind common datatypebindings
@@ -71,6 +73,8 @@ void DatatypeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     callstack.push_front(bind_imagealignconfig);
     callstack.push_front(bind_imageannotations);
     callstack.push_front(bind_rgbddata);
+    callstack.push_front(bind_dynamic_calibration_results);
+    callstack.push_front(bind_dynamic_calibration_config);
 }
 
 void DatatypeBindings::bind(pybind11::module& m, void* pCallstack) {

bindings/python/src/DeviceBindings.cpp

@@ -779,6 +779,13 @@ void DeviceBindings::bind(pybind11::module& m, void* pCallstack) {
                 return d.factoryResetCalibration();
             },
             DOC(dai, DeviceBase, factoryResetCalibration))
+        .def(
+            "setCalibration",
+            [](DeviceBase& d, CalibrationHandler ch) {
+                py::gil_scoped_release release;
+                return d.setCalibration(ch);
+            },
+            DOC(dai, DeviceBase, setCalibration))
         .def(
             "flashFactoryCalibration",
             [](DeviceBase& d, CalibrationHandler ch) {

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

@@ -0,0 +1,73 @@
+#include <memory>
+#include <unordered_map>
+
+#include "DatatypeBindings.hpp"
+#include "pipeline/CommonBindings.hpp"
+
+// depthai
+#include "depthai/pipeline/datatype/DynamicCalibrationConfig.hpp"
+
+void bind_dynamic_calibration_config(pybind11::module& m, void* pCallstack) {
+    using namespace dai;
+
+    py::class_<DynamicCalibrationConfig, Py<DynamicCalibrationConfig>, Buffer, std::shared_ptr<DynamicCalibrationConfig>> _DynamicCalibrationResults(
+        m, "DynamicCalibrationConfig", DOC(dai, DynamicCalibrationConfig));
+
+    py::class_<DynamicCalibrationConfig::AlgorithmControl> _AlgorithmControl(
+        _DynamicCalibrationResults, "AlgorithmControl", DOC(dai, DynamicCalibrationConfig, AlgorithmControl));
+
+    py::enum_<DynamicCalibrationConfig::CalibrationCommand> _CalibrationCommand(_DynamicCalibrationResults, "CalibrationCommand", DOC(dai, DynamicCalibrationConfig, CalibrationCommand));
+
+    py::enum_<DynamicCalibrationConfig::AlgorithmControl::PerformanceMode>(_AlgorithmControl, "PerformanceMode")
+        .value("SKIP_CHECKS", DynamicCalibrationConfig::AlgorithmControl::PerformanceMode::SKIP_CHECKS)
+        .value("STATIC_SCENERY", DynamicCalibrationConfig::AlgorithmControl::PerformanceMode::STATIC_SCENERY)
+        .value("OPTIMIZE_SPEED", DynamicCalibrationConfig::AlgorithmControl::PerformanceMode::OPTIMIZE_SPEED)
+        .value("OPTIMIZE_PERFORMANCE", DynamicCalibrationConfig::AlgorithmControl::PerformanceMode::OPTIMIZE_PERFORMANCE)
+        .value("DEFAULT", DynamicCalibrationConfig::AlgorithmControl::PerformanceMode::DEFAULT)
+        .export_values();
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // Call the rest of the type defines, then perform the actual bindings
+    Callstack* callstack = (Callstack*)pCallstack;
+    auto cb = callstack->top();
+    callstack->pop();
+    cb(m, pCallstack);
+    // Actual bindings
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+
+    // Metadata / raw
+    _AlgorithmControl.def(py::init<>())
+        .def_readwrite("recalibrationMode",
+                       &DynamicCalibrationConfig::AlgorithmControl::recalibrationMode,
+                       DOC(dai, DynamicCalibrationConfig, AlgorithmControl, recalibrationMode))
+        .def_readwrite("performanceMode",
+                       &DynamicCalibrationConfig::AlgorithmControl::performanceMode,
+                       DOC(dai, DynamicCalibrationConfig, AlgorithmControl, performanceMode ))
+        .def_readwrite("timeFrequency",
+                       &DynamicCalibrationConfig::AlgorithmControl::timeFrequency,
+                       DOC(dai, DynamicCalibrationConfig, AlgorithmControl, timeFrequency))
+    ;
+
+
+    _CalibrationCommand
+        .value("START_CALIBRATION_QUALITY_CHECK", DynamicCalibrationConfig::CalibrationCommand::START_CALIBRATION_QUALITY_CHECK)
+        .value("START_FORCE_CALIBRATION_QUALITY_CHECK", DynamicCalibrationConfig::CalibrationCommand::START_FORCE_CALIBRATION_QUALITY_CHECK)
+        .value("START_RECALIBRATION", DynamicCalibrationConfig::CalibrationCommand::START_RECALIBRATION)
+        .value("START_FORCE_RECALIBRATION", DynamicCalibrationConfig::CalibrationCommand::START_FORCE_RECALIBRATION)
+    ;
+
+    // Message
+    _DynamicCalibrationResults.def(py::init<>())
+        .def("__repr__", &DynamicCalibrationConfig::str)
+
+        .def_readwrite("algorithmControl",
+                       &DynamicCalibrationConfig::algorithmControl,
+                       DOC(dai, DynamicCalibrationConfig, algorithmControl))
+        .def_readwrite("calibrationCommand",
+                       &DynamicCalibrationConfig::calibrationCommand,
+                       DOC(dai, DynamicCalibrationConfig, calibrationCommand))
+        ;
+}

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

@@ -0,0 +1,90 @@
+#include <memory>
+#include <unordered_map>
+
+#include "DatatypeBindings.hpp"
+#include "pipeline/CommonBindings.hpp"
+
+// depthai
+#include "depthai/pipeline/datatype/DynamicCalibrationResults.hpp"
+
+void bind_dynamic_calibration_results(pybind11::module& m, void* pCallstack) {
+    using namespace dai;
+
+
+    py::class_<DynamicCalibrationResults, Py<DynamicCalibrationResults>, Buffer, std::shared_ptr<DynamicCalibrationResults>> _DynamicCalibrationResults(
+        m, "DynamicCalibrationResults", DOC(dai, DynamicCalibrationResults));
+
+    py::class_<DynamicCalibrationResults::CalibrationResult> _CalibrationResult(
+        _DynamicCalibrationResults, "CalibrationResult", DOC(dai, DynamicCalibrationResults, CalibrationResult));
+
+    py::class_<DynamicCalibrationResults::CalibrationData> _CalibrationData(
+        _DynamicCalibrationResults, "CalibrationData", DOC(dai, DynamicCalibrationResults, CalibrationData));
+
+    py::class_<DynamicCalibrationResults::CoverageData> _CoverageData(
+        _DynamicCalibrationResults, "CoverageData", DOC(dai, DynamicCalibrationResults, CoverageData));
+
+    py::class_<DynamicCalibrationResults::CalibrationQuality> _CalibrationQuality(
+        _DynamicCalibrationResults, "CalibrationQuality", DOC(dai, DynamicCalibrationResults, CalibrationQuality));
+
+    py::class_<DynamicCalibrationResults::CalibrationQualityResult> _CalibrationQualityResult(
+        _DynamicCalibrationResults, "CalibrationQualityResult", DOC(dai, DynamicCalibrationResults, CalibrationQualityResult));
+
+
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // Call the rest of the type defines, then perform the actual bindings
+    Callstack* callstack = (Callstack*)pCallstack;
+    auto cb = callstack->top();
+    callstack->pop();
+    cb(m, pCallstack);
+    // Actual bindings
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+
+    // Metadata / raw
+    _CalibrationResult
+        .def(py::init<>())
+        .def_readwrite("calibHandler", &DynamicCalibrationResults::CalibrationResult::calibHandler,
+                       DOC(dai, DynamicCalibrationResults, CalibrationResult, calibHandler));
+
+    // Bind CalibrationData
+    _CalibrationData
+        .def(py::init<>())
+        .def_readwrite("rotationChange", &DynamicCalibrationResults::CalibrationData::rotationChange)
+        .def_readwrite("epipolarErrorChange", &DynamicCalibrationResults::CalibrationData::epipolarErrorChange)
+        .def_readwrite("depthErrorDifference", &DynamicCalibrationResults::CalibrationData::depthErrorDifference);
+
+    // Bind CoverageData
+    _CoverageData
+        .def(py::init<>())
+        .def_readwrite("coveragePerCellA", &DynamicCalibrationResults::CoverageData::coveragePerCellA)
+        .def_readwrite("coveragePerCellB", &DynamicCalibrationResults::CoverageData::coveragePerCellB)
+        .def_readwrite("meanCoverage", &DynamicCalibrationResults::CoverageData::meanCoverage);
+
+    // Bind CalibrationQuality
+    _CalibrationQuality
+        .def(py::init<>())
+        .def_readwrite("dataAquired", &DynamicCalibrationResults::CalibrationQuality::dataAquired)
+        .def_readwrite("coverageQuality", &DynamicCalibrationResults::CalibrationQuality::coverageQuality)
+        .def_readwrite("calibrationQuality", &DynamicCalibrationResults::CalibrationQuality::calibrationQuality);
+
+    // Bind CalibrationQualityResult
+    _CalibrationQualityResult
+        .def(py::init<>())
+        .def_readwrite("report", &DynamicCalibrationResults::CalibrationQualityResult::report);
+
+
+    // Message
+    _DynamicCalibrationResults
+        .def(py::init<>())
+        .def("reset", &DynamicCalibrationResults::reset)
+        .def_readwrite("newCalibration", &DynamicCalibrationResults::newCalibration,
+                       DOC(dai, DynamicCalibrationResults, newCalibration))
+        .def_readwrite("calibOverallQuality", &DynamicCalibrationResults::calibOverallQuality,
+                       DOC(dai, DynamicCalibrationResults, calibOverallQuality))
+        .def_readwrite("info", &DynamicCalibrationResults::info,
+                       DOC(dai, DynamicCalibrationResults, info));
+        ;
+}

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

@@ -17,7 +17,8 @@ void bind_objecttrackerconfig(pybind11::module& m, void* pCallstack) {
     using namespace dai;
 
     // py::class_<RawPointCloudConfig, RawBuffer, std::shared_ptr<RawPointCloudConfig>> rawConfig(m, "RawPointCloudConfig", DOC(dai, RawPointCloudConfig));
-    py::class_<ObjectTrackerConfig, Py<ObjectTrackerConfig>, Buffer, std::shared_ptr<ObjectTrackerConfig>> config(m, "ObjectTrackerConfig", DOC(dai, ObjectTrackerConfig));
+    py::class_<ObjectTrackerConfig, Py<ObjectTrackerConfig>, Buffer, std::shared_ptr<ObjectTrackerConfig>> config(
+        m, "ObjectTrackerConfig", DOC(dai, ObjectTrackerConfig));
 
     ///////////////////////////////////////////////////////////////////////
     ///////////////////////////////////////////////////////////////////////
@@ -46,7 +47,6 @@ void bind_objecttrackerconfig(pybind11::module& m, void* pCallstack) {
         // .def("set", &ObjectTrackerConfig::set, py::arg("config"), DOC(dai, ObjectTrackerConfig, set))
         // .def("get", &ObjectTrackerConfig::get, DOC(dai, ObjectTrackerConfig, get))
         .def("forceRemoveID", &ObjectTrackerConfig::forceRemoveID, DOC(dai, ObjectTrackerConfig, forceRemoveID))
-        .def("forceRemoveIDs", &ObjectTrackerConfig::forceRemoveIDs, DOC(dai, ObjectTrackerConfig, forceRemoveIDs))
-    ;
+        .def("forceRemoveIDs", &ObjectTrackerConfig::forceRemoveIDs, DOC(dai, ObjectTrackerConfig, forceRemoveIDs));
     // add aliases
 }

bindings/python/src/pipeline/node/DynamicCalibrationBindings.cpp

@@ -0,0 +1,40 @@
+#include "Common.hpp"
+#include "NodeBindings.hpp"
+#include "depthai/pipeline/Node.hpp"
+#include "depthai/pipeline/Pipeline.hpp"
+#include "depthai/pipeline/node/DynamicCalibration.hpp"
+
+void bind_dynamic_calibration(pybind11::module& m, void* pCallstack) {
+    using namespace dai;
+    using namespace dai::node;
+
+    // Node and Properties declare upfront
+    py::class_<DynamicCalibrationProperties> DynamicCalibrationProperties(m, "DynamicCalibrationProperties", DOC(dai, DynamicCalibrationProperties));
+    auto dynamicCalibration = ADD_NODE(DynamicCalibration);
+
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // Call the rest of the type defines, then perform the actual bindings
+    Callstack* callstack = (Callstack*)pCallstack;
+    auto cb = callstack->top();
+    callstack->pop();
+    cb(m, pCallstack);
+    // Actual bindings
+    ///////////////////////////////////////////////////////////////////////
+    // Node
+    dynamicCalibration
+        .def_property_readonly(
+                  "left", [](DynamicCalibration& node) { return &node.left; }, py::return_value_policy::reference_internal)
+        .def_property_readonly(
+            "right", [](DynamicCalibration& node) { return &node.right; }, py::return_value_policy::reference_internal)
+        .def_readonly("inputConfig", &DynamicCalibration::inputConfig, DOC(dai, node, DynamicCalibration, inputConfig))
+        .def_readonly("outputCalibrationResults", &DynamicCalibration::outputCalibrationResults, DOC(dai, node, DynamicCalibration, outputCalibrationResults))
+        .def("setRunOnHost", &DynamicCalibration::setRunOnHost, py::arg("runOnHost"), DOC(dai, node, DynamicCalibration, setRunOnHost))
+        .def("runOnHost", &DynamicCalibration::runOnHost, DOC(dai, node, DynamicCalibration, runOnHost))
+        .def("setPerformanceMode", &DynamicCalibration::setPerformanceMode, py::arg("mode"), DOC(dai, node, DynamicCalibration, setPerformanceMode))
+        .def("setContiniousMode", &DynamicCalibration::setContiniousMode, DOC(dai, node, DynamicCalibration, setContiniousMode))
+        .def("setTimeFrequency", &DynamicCalibration::setTimeFrequency, py::arg("int"), DOC(dai, node, DynamicCalibration, setTimeFrequency))
+    ;
+    daiNodeModule.attr("DynamicCalibration").attr("Properties") = DynamicCalibrationProperties;
+}

bindings/python/src/pipeline/node/NodeBindings.cpp

@@ -167,6 +167,9 @@ void bind_basaltnode(pybind11::module& m, void* pCallstack);
 void bind_rtabmapvionode(pybind11::module& m, void* pCallstack);
 void bind_rtabmapslamnode(pybind11::module& m, void* pCallstack);
 #endif
+#ifdef DEPTHAI_HAVE_DYNAMIC_CALIBRATION_SUPPORT
+void bind_dynamic_calibration(pybind11::module& m, void* pCallstack);
+#endif
 void NodeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     // Bind Node et al
     callstack.push_front(NodeBindings::bind);
@@ -212,6 +215,9 @@ void NodeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     callstack.push_front(bind_rtabmapvionode);
     callstack.push_front(bind_rtabmapslamnode);
 #endif
+#ifdef DEPTHAI_HAVE_DYNAMIC_CALIBRATION_SUPPORT
+    callstack.push_front(bind_dynamic_calibration);
+#endif
 }
 
 void NodeBindings::bind(pybind11::module& m, void* pCallstack) {

bindings/python/src/pybind11_common.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#if(_MSC_VER >= 1910) || !defined(_MSC_VER)
+#if (_MSC_VER >= 1910) || !defined(_MSC_VER)
     #ifndef HAVE_SNPRINTF
         #define HAVE_SNPRINTF
     #endif

examples/cpp/CMakeLists.txt

@@ -130,6 +130,11 @@ add_subdirectory(AprilTags)
 add_subdirectory(Benchmark)
 add_subdirectory(Camera)
 add_subdirectory(DetectionNetwork)
+
+if(DEPTHAI_DYNAMIC_CALIBRATION_SUPPORT)
+    add_subdirectory(DynamicCalibration)
+endif()
+
 add_subdirectory(Events)
 add_subdirectory(FeatureTracker)
 add_subdirectory(HostNodes)