Pipeline debugging

CMakeLists.txt

@@ -273,6 +273,7 @@ set(TARGET_CORE_SOURCES
     src/device/CalibrationHandler.cpp
     src/device/Version.cpp
     src/pipeline/Pipeline.cpp
+    src/pipeline/PipelineStateApi.cpp
     src/pipeline/AssetManager.cpp
     src/pipeline/MessageQueue.cpp
     src/pipeline/Node.cpp
@@ -281,6 +282,8 @@ set(TARGET_CORE_SOURCES
     src/pipeline/ThreadedHostNode.cpp
     src/pipeline/DeviceNode.cpp
     src/pipeline/DeviceNodeGroup.cpp
+    src/pipeline/node/internal/PipelineEventAggregation.cpp
+    src/pipeline/node/internal/PipelineStateMerge.cpp
     src/pipeline/node/internal/XLinkIn.cpp
     src/pipeline/node/internal/XLinkOut.cpp
     src/pipeline/node/ColorCamera.cpp
@@ -351,6 +354,9 @@ set(TARGET_CORE_SOURCES
     src/pipeline/datatype/PointCloudConfig.cpp
     src/pipeline/datatype/ObjectTrackerConfig.cpp
     src/pipeline/datatype/PointCloudData.cpp
+    src/pipeline/datatype/PipelineEvent.cpp
+    src/pipeline/datatype/PipelineState.cpp
+    src/pipeline/datatype/PipelineEventAggregationConfig.cpp
     src/pipeline/datatype/RGBDData.cpp
     src/pipeline/datatype/MessageGroup.cpp
     src/pipeline/datatype/ThermalConfig.cpp
@@ -367,6 +373,7 @@ set(TARGET_CORE_SOURCES
     src/utility/Initialization.cpp
     src/utility/Resources.cpp
     src/utility/Platform.cpp
+    src/utility/PipelineEventDispatcher.cpp
     src/utility/RecordReplay.cpp
     src/utility/McapImpl.cpp
     src/utility/Environment.cpp

bindings/python/CMakeLists.txt

@@ -98,7 +98,7 @@ set(SOURCE_LIST
     src/pipeline/node/UVCBindings.cpp
     src/pipeline/node/ToFBindings.cpp
     src/pipeline/node/PointCloudBindings.cpp
-    src/pipeline/node/SyncBindings.cpp
+    src/pipeline/node/PipelineEventAggregationBindings.cpp
     src/pipeline/node/MessageDemuxBindings.cpp
     src/pipeline/node/HostNodeBindings.cpp
     src/pipeline/node/RecordBindings.cpp
@@ -136,6 +136,8 @@ set(SOURCE_LIST
     src/pipeline/datatype/PointCloudConfigBindings.cpp
     src/pipeline/datatype/ObjectTrackerConfigBindings.cpp
     src/pipeline/datatype/PointCloudDataBindings.cpp
+    src/pipeline/datatype/PipelineEventBindings.cpp
+    src/pipeline/datatype/PipelineStateBindings.cpp
     src/pipeline/datatype/TransformDataBindings.cpp
     src/pipeline/datatype/ImageAlignConfigBindings.cpp
     src/pipeline/datatype/ImgAnnotationsBindings.cpp
@@ -149,6 +151,7 @@ set(SOURCE_LIST
 
     src/remote_connection/RemoteConnectionBindings.cpp
     src/utility/EventsManagerBindings.cpp
+    src/utility/PipelineEventDispatcherBindings.cpp
 )
 if(DEPTHAI_MERGED_TARGET)
     list(APPEND SOURCE_LIST
@@ -412,4 +415,4 @@ endif()
 ########################
 if (DEPTHAI_PYTHON_ENABLE_EXAMPLES)
     add_subdirectory(../../examples/python ${CMAKE_BINARY_DIR}/examples/python)
-endif()
+endif()

bindings/python/setup.py

@@ -273,6 +273,7 @@ def build_extension(self, ext):
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
         "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
         "Programming Language :: C++",
         "Programming Language :: Python :: Implementation :: CPython",
         "Topic :: Scientific/Engineering",

bindings/python/src/DatatypeBindings.cpp

@@ -30,6 +30,8 @@ void bind_tracklets(pybind11::module& m, void* pCallstack);
 void bind_benchmarkreport(pybind11::module& m, void* pCallstack);
 void bind_pointcloudconfig(pybind11::module& m, void* pCallstack);
 void bind_pointclouddata(pybind11::module& m, void* pCallstack);
+void bind_pipelineevent(pybind11::module& m, void* pCallstack);
+void bind_pipelinestate(pybind11::module& m, void* pCallstack);
 void bind_transformdata(pybind11::module& m, void* pCallstack);
 void bind_rgbddata(pybind11::module& m, void* pCallstack);
 void bind_imagealignconfig(pybind11::module& m, void* pCallstack);
@@ -71,6 +73,8 @@ void DatatypeBindings::addToCallstack(std::deque<StackFunction>& callstack) {
     callstack.push_front(bind_benchmarkreport);
     callstack.push_front(bind_pointcloudconfig);
     callstack.push_front(bind_pointclouddata);
+    callstack.push_front(bind_pipelineevent);
+    callstack.push_front(bind_pipelinestate);
     callstack.push_front(bind_transformdata);
     callstack.push_front(bind_imagealignconfig);
     callstack.push_front(bind_imageannotations);
@@ -132,6 +136,8 @@ void DatatypeBindings::bind(pybind11::module& m, void* pCallstack) {
         .value("ImageAlignConfig", DatatypeEnum::ImageAlignConfig)
         .value("ImgAnnotations", DatatypeEnum::ImgAnnotations)
         .value("RGBDData", DatatypeEnum::RGBDData)
+        .value("PipelineEvent", DatatypeEnum::PipelineEvent)
+        .value("PipelineState", DatatypeEnum::PipelineState)
         .value("ImageFiltersConfig", DatatypeEnum::ImageFiltersConfig)
         .value("ToFDepthConfidenceFilterConfig", DatatypeEnum::ToFDepthConfidenceFilterConfig)
         .value("DynamicCalibrationControl", DatatypeEnum::DynamicCalibrationControl)

bindings/python/src/pipeline/PipelineBindings.cpp

@@ -1,4 +1,3 @@
-
 #include "PipelineBindings.hpp"
 
 #include <pybind11/attr.h>
@@ -64,6 +63,9 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack) {
     py::class_<GlobalProperties> globalProperties(m, "GlobalProperties", DOC(dai, GlobalProperties));
     py::class_<RecordConfig> recordConfig(m, "RecordConfig", DOC(dai, RecordConfig));
     py::class_<RecordConfig::VideoEncoding> recordVideoConfig(recordConfig, "VideoEncoding", DOC(dai, RecordConfig, VideoEncoding));
+    py::class_<PipelineStateApi> pipelineStateApi(m, "PipelineStateApi", DOC(dai, PipelineStateApi));
+    py::class_<NodesStateApi> nodesStateApi(m, "NodesStateApi", DOC(dai, NodesStateApi));
+    py::class_<NodeStateApi> nodeStateApi(m, "NodeStateApi", DOC(dai, NodeStateApi));
     py::class_<Pipeline> pipeline(m, "Pipeline", DOC(dai, Pipeline, 2));
 
     ///////////////////////////////////////////////////////////////////////
@@ -102,6 +104,59 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack) {
         .def_readwrite("videoEncoding", &RecordConfig::videoEncoding, DOC(dai, RecordConfig, videoEncoding))
         .def_readwrite("compressionLevel", &RecordConfig::compressionLevel, DOC(dai, RecordConfig, compressionLevel));
 
+    pipelineStateApi.def("nodes", static_cast<NodesStateApi (PipelineStateApi::*)()>(&PipelineStateApi::nodes), DOC(dai, PipelineStateApi, nodes))
+        .def("nodes",
+             static_cast<NodesStateApi (PipelineStateApi::*)(const std::vector<Node::Id>&)>(&PipelineStateApi::nodes),
+             py::arg("nodeIds"),
+             DOC(dai, PipelineStateApi, nodes, 2))
+        .def("nodes",
+             static_cast<NodeStateApi (PipelineStateApi::*)(Node::Id)>(&PipelineStateApi::nodes),
+             py::arg("nodeId"),
+             DOC(dai, PipelineStateApi, nodes, 3));
+
+    nodesStateApi.def("summary", &NodesStateApi::summary, DOC(dai, NodesStateApi, summary))
+        .def("detailed", &NodesStateApi::detailed, DOC(dai, NodesStateApi, detailed))
+        .def("outputs", &NodesStateApi::outputs, DOC(dai, NodesStateApi, outputs))
+        .def("inputs", &NodesStateApi::inputs, DOC(dai, NodesStateApi, inputs))
+        .def("otherTimings", &NodesStateApi::otherTimings, DOC(dai, NodesStateApi, otherTimings));
+
+    nodeStateApi.def("summary", &NodeStateApi::summary, DOC(dai, NodeStateApi, summary))
+        .def("detailed", &NodeStateApi::detailed, DOC(dai, NodeStateApi, detailed))
+        .def("outputs",
+             static_cast<std::unordered_map<std::string, NodeState::OutputQueueState> (NodeStateApi::*)()>(&NodeStateApi::outputs),
+             DOC(dai, NodeStateApi, outputs))
+        .def("outputs",
+             static_cast<std::unordered_map<std::string, NodeState::OutputQueueState> (NodeStateApi::*)(const std::vector<std::string>&)>(
+                 &NodeStateApi::outputs),
+             py::arg("outputNames"),
+             DOC(dai, NodeStateApi, outputs, 2))
+        .def("outputs",
+             static_cast<NodeState::OutputQueueState (NodeStateApi::*)(const std::string&)>(&NodeStateApi::outputs),
+             py::arg("outputName"),
+             DOC(dai, NodeStateApi, outputs, 3))
+        .def("inputs",
+             static_cast<std::unordered_map<std::string, NodeState::InputQueueState> (NodeStateApi::*)()>(&NodeStateApi::inputs),
+             DOC(dai, NodeStateApi, inputs))
+        .def("inputs",
+             static_cast<std::unordered_map<std::string, NodeState::InputQueueState> (NodeStateApi::*)(const std::vector<std::string>&)>(&NodeStateApi::inputs),
+             py::arg("inputNames"),
+             DOC(dai, NodeStateApi, inputs, 2))
+        .def("inputs",
+             static_cast<NodeState::InputQueueState (NodeStateApi::*)(const std::string&)>(&NodeStateApi::inputs),
+             py::arg("inputName"),
+             DOC(dai, NodeStateApi, inputs, 3))
+        .def("otherTimings",
+             static_cast<std::unordered_map<std::string, NodeState::Timing> (NodeStateApi::*)()>(&NodeStateApi::otherTimings),
+             DOC(dai, NodeStateApi, otherTimings))
+        .def("otherTimings",
+             static_cast<std::unordered_map<std::string, NodeState::Timing> (NodeStateApi::*)(const std::vector<std::string>&)>(&NodeStateApi::otherTimings),
+             py::arg("statNames"),
+             DOC(dai, NodeStateApi, otherTimings, 2))
+        .def("otherStats",
+             static_cast<NodeState::Timing (NodeStateApi::*)(const std::string&)>(&NodeStateApi::otherStats),
+             py::arg("statName"),
+             DOC(dai, NodeStateApi, otherStats));
+
     // bind pipeline
     pipeline
         .def(py::init([](bool createImplicitDevice) {
@@ -255,6 +310,8 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack) {
         .def("isRunning", &Pipeline::isRunning)
         .def("processTasks", &Pipeline::processTasks, py::arg("waitForTasks") = false, py::arg("timeoutSeconds") = -1.0)
         .def("enableHolisticRecord", &Pipeline::enableHolisticRecord, py::arg("recordConfig"), DOC(dai, Pipeline, enableHolisticRecord))
-        .def("enableHolisticReplay", &Pipeline::enableHolisticReplay, py::arg("recordingPath"), DOC(dai, Pipeline, enableHolisticReplay));
+        .def("enableHolisticReplay", &Pipeline::enableHolisticReplay, py::arg("recordingPath"), DOC(dai, Pipeline, enableHolisticReplay))
+        .def("enablePipelineDebugging", &Pipeline::enablePipelineDebugging, py::arg("enable") = true, DOC(dai, Pipeline, enablePipelineDebugging))
+        .def("getPipelineState", &Pipeline::getPipelineState, DOC(dai, Pipeline, getPipelineState));
     ;
 }

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

@@ -0,0 +1,59 @@
+#include <memory>
+#include <unordered_map>
+
+#include "DatatypeBindings.hpp"
+#include "pipeline/CommonBindings.hpp"
+
+// depthai
+#include "depthai/pipeline/datatype/PipelineEvent.hpp"
+
+// pybind
+#include <pybind11/chrono.h>
+#include <pybind11/numpy.h>
+
+// #include "spdlog/spdlog.h"
+
+void bind_pipelineevent(pybind11::module& m, void* pCallstack) {
+    using namespace dai;
+
+    py::class_<PipelineEvent, Py<PipelineEvent>, Buffer, std::shared_ptr<PipelineEvent>> pipelineEvent(m, "PipelineEvent", DOC(dai, PipelineEvent));
+    py::enum_<PipelineEvent::Type> pipelineEventType(pipelineEvent, "Type", DOC(dai, PipelineEvent, Type));
+    py::enum_<PipelineEvent::Interval> pipelineEventInterval(pipelineEvent, "Interval", DOC(dai, PipelineEvent, Interval));
+
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    // 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
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+    ///////////////////////////////////////////////////////////////////////
+
+    pipelineEventType.value("CUSTOM", PipelineEvent::Type::CUSTOM)
+        .value("LOOP", PipelineEvent::Type::LOOP)
+        .value("INPUT", PipelineEvent::Type::INPUT)
+        .value("OUTPUT", PipelineEvent::Type::OUTPUT);
+    pipelineEventInterval.value("NONE", PipelineEvent::Interval::NONE)
+        .value("START", PipelineEvent::Interval::START)
+        .value("END", PipelineEvent::Interval::END);
+
+    // Message
+    pipelineEvent.def(py::init<>())
+        .def("__repr__", &PipelineEvent::str)
+        .def_readwrite("nodeId", &PipelineEvent::nodeId, DOC(dai, PipelineEvent, nodeId))
+        .def_readwrite("status", &PipelineEvent::status, DOC(dai, PipelineEvent, status))
+        .def_readwrite("queueSize", &PipelineEvent::queueSize, DOC(dai, PipelineEvent, queueSize))
+        .def_readwrite("interval", &PipelineEvent::interval, DOC(dai, PipelineEvent, interval))
+        .def_readwrite("type", &PipelineEvent::type, DOC(dai, PipelineEvent, type))
+        .def_readwrite("source", &PipelineEvent::source, DOC(dai, PipelineEvent, source))
+        .def("getTimestamp", &PipelineEvent::Buffer::getTimestamp, DOC(dai, Buffer, getTimestamp))
+        .def("getTimestampDevice", &PipelineEvent::Buffer::getTimestampDevice, DOC(dai, Buffer, getTimestampDevice))
+        .def("getSequenceNum", &PipelineEvent::Buffer::getSequenceNum, DOC(dai, Buffer, getSequenceNum))
+        .def("setTimestamp", &PipelineEvent::setTimestamp, DOC(dai, Buffer, setTimestamp))
+        .def("setTimestampDevice", &PipelineEvent::setTimestampDevice, DOC(dai, Buffer, setTimestampDevice))
+        .def("setSequenceNum", &PipelineEvent::setSequenceNum, DOC(dai, Buffer, setSequenceNum));
+}