Merge branch 'colormono_deprecation' into v3_develop

Author: Matevz Morato

bindings/python/src/pipeline/PipelineBindings.cpp

@@ -177,6 +177,19 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack) {
                 // so we create in the same manner as device nodes.
                 auto isFromBindings = class_.attr("__module__").cast<std::string>() == "depthai.node";
                 // Create a copy from kwargs and add autoAddToPipeline to false
+
+                // Check if the node is a ColorCamera or a MonoCamera node and issue a deprecation warning
+                py::object colorCameraClass = py::module::import("depthai").attr("node").attr("ColorCamera");
+                py::object monoCameraClass = py::module::import("depthai").attr("node").attr("MonoCamera");
+                if(class_.is(colorCameraClass)){
+                    PyErr_WarnEx(PyExc_DeprecationWarning,
+                                 "ColorCamera node is deprecated. Use Camera node instead.", 1);
+                }
+
+                if(class_.is(monoCameraClass)){
+                    PyErr_WarnEx(PyExc_DeprecationWarning,
+                                 "MonoCamera node is deprecated. Use Camera node instead.", 1);
+                }
                 if(isSubclass && !isFromBindings) {
                     setImplicitPipeline(&p);
                     std::shared_ptr<Node> hostNode = py::cast<std::shared_ptr<node::ThreadedHostNode>>(class_(*args, **kwargs));
@@ -204,34 +217,6 @@ void PipelineBindings::bind(pybind11::module& m, void* pCallstack) {
                 return node;
             },
             py::keep_alive<1, 0>())
-        // TODO(themarpe) DEPRECATE, use pipeline.create([class name])
-        // templated create<NODE> function
-        .def("createXLinkIn", &Pipeline::create<node::XLinkIn>)
-        .def("createXLinkOut", &Pipeline::create<node::XLinkOut>)
-        .def("createNeuralNetwork", &Pipeline::create<node::NeuralNetwork>)
-        .def("createColorCamera", &Pipeline::create<node::ColorCamera>)
-        .def("createVideoEncoder", &Pipeline::create<node::VideoEncoder>)
-        .def("createScript", &Pipeline::create<node::Script>)
-        .def("createSPIOut", &Pipeline::create<node::SPIOut>)
-        .def("createSPIIn", &Pipeline::create<node::SPIIn>)
-        .def("createImageManip", &Pipeline::create<node::ImageManip>)
-        .def("createMonoCamera", &Pipeline::create<node::MonoCamera>)
-        .def("createStereoDepth", &Pipeline::create<node::StereoDepth>)
-        .def("createMobileNetDetectionNetwork", &Pipeline::create<node::MobileNetDetectionNetwork>)
-        .def("createYoloDetectionNetwork", &Pipeline::create<node::YoloDetectionNetwork>)
-        .def("createSystemLogger", &Pipeline::create<node::SystemLogger>)
-        .def("createSpatialLocationCalculator", &Pipeline::create<node::SpatialLocationCalculator>)
-        .def("createMobileNetSpatialDetectionNetwork", &Pipeline::create<node::MobileNetSpatialDetectionNetwork>)
-        .def("createYoloSpatialDetectionNetwork", &Pipeline::create<node::YoloSpatialDetectionNetwork>)
-        .def("createObjectTracker", &Pipeline::create<node::ObjectTracker>)
-        .def("createIMU", &Pipeline::create<node::IMU>)
-        .def("createEdgeDetector", &Pipeline::create<node::EdgeDetector>)
-        .def("createFeatureTracker", &Pipeline::create<node::FeatureTracker>)
-        .def("createAprilTag", &Pipeline::create<node::AprilTag>)
-        .def("createDetectionParser", &Pipeline::create<node::DetectionParser>)
-        .def("createUVC", &Pipeline::create<node::UVC>)
-        .def("createCamera", &Pipeline::create<node::Camera>)
-        .def("createWarp", &Pipeline::create<node::Warp>)
         .def("start", &Pipeline::start)
         .def("wait",
              [](Pipeline& p) {

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

@@ -5,6 +5,7 @@
 #include "depthai/pipeline/node/ColorCamera.hpp"
 #include "depthai/utility/CompilerWarnings.hpp"
 
+DEPTHAI_BEGIN_SUPPRESS_DEPRECATION_WARNING
 void bind_colorcamera(pybind11::module& m, void* pCallstack) {
     using namespace dai;
     using namespace dai::node;
@@ -89,7 +90,6 @@ void bind_colorcamera(pybind11::module& m, void* pCallstack) {
         .def_readwrite("warpMeshStepWidth", &ColorCameraProperties::warpMeshStepWidth)
         .def_readwrite("warpMeshStepHeight", &ColorCameraProperties::warpMeshStepHeight)
         .def_readwrite("eventFilter", &ColorCameraProperties::eventFilter);
-    DEPTHAI_BEGIN_SUPPRESS_DEPRECATION_WARNING
     // ColorCamera node
     colorCamera
         .def(py::init([]() {

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

@@ -3,11 +3,13 @@
 #include "depthai/pipeline/Node.hpp"
 #include "depthai/pipeline/Pipeline.hpp"
 #include "depthai/pipeline/node/MonoCamera.hpp"
+#include "depthai/utility/CompilerWarnings.hpp"
 
 void bind_monocamera(pybind11::module& m, void* pCallstack) {
     using namespace dai;
     using namespace dai::node;
 
+    DEPTHAI_BEGIN_SUPPRESS_DEPRECATION_WARNING
     // Node and Properties declare upfront
     py::class_<MonoCameraProperties> monoCameraProperties(m, "MonoCameraProperties", DOC(dai, MonoCameraProperties));
     py::enum_<MonoCameraProperties::SensorResolution> monoCameraPropertiesSensorResolution(
@@ -93,4 +95,5 @@ void bind_monocamera(pybind11::module& m, void* pCallstack) {
         .def("setRawOutputPacked", &MonoCamera::setRawOutputPacked, py::arg("packed"), DOC(dai, node, MonoCamera, setRawOutputPacked));
     // ALIAS
     daiNodeModule.attr("MonoCamera").attr("Properties") = monoCameraProperties;
+    DEPTHAI_END_SUPPRESS_DEPRECATION_WARNING
 }

examples/cpp/CMakeLists.txt

@@ -306,8 +306,6 @@ dai_set_example_test_labels(stereo ondevice rvc2_all rvc4 ci)
 dai_add_example(thermal RVC2/Thermal/thermal.cpp OFF OFF)
 
 # Host nodes
-dai_add_example(rgb_video RVC2/ColorCamera/rgb_video.cpp OFF OFF)
-dai_add_example(rgb_video_camera RVC2/Camera/rgb_video_camera.cpp OFF OFF)
 dai_add_example(host_node HostNodes/host_node.cpp OFF OFF)
 dai_add_example(threaded_host_node HostNodes/threaded_host_node.cpp OFF OFF)
 

examples/cpp/HostNodes/host_node.cpp

@@ -59,16 +59,13 @@ class StreamMerger : public dai::NodeCRTP<dai::node::HostNode, StreamMerger> {
 
 int main() {
     // Create pipeline
-    dai::Pipeline pipeline(true);
+    dai::Pipeline pipeline;
 
-    auto camRgb = pipeline.create<dai::node::ColorCamera>();
-    camRgb->setBoardSocket(dai::CameraBoardSocket::CAM_A);
-    camRgb->setVideoSize(640, 480);
+    auto camRgb = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_A);
+    auto camMono = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_B);
 
-    auto camMono = pipeline.create<dai::node::MonoCamera>();
-    camMono->setBoardSocket(dai::CameraBoardSocket::CAM_B);
-
-    auto streamMerger = pipeline.create<StreamMerger>()->build(camRgb->video, camMono->out);
+    auto streamMerger = pipeline.create<StreamMerger>()->build(*camRgb->requestOutput(std::make_pair(640, 480)), 
+                                                                *camMono->requestOutput(std::make_pair(640, 480)));
     auto display = pipeline.create<Display>()->build(streamMerger->out);
 
     pipeline.start();

examples/cpp/ImageManip/image_manip_v2_resize.cpp

@@ -16,24 +16,18 @@ int main(int argc, char** argv) {
     }
     dai::Pipeline pipeline(device);
 
-    auto camRgb = pipeline.create<dai::node::ColorCamera>();
+    auto camRgb = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_A);
     auto display = pipeline.create<dai::node::Display>();
     auto manip = pipeline.create<dai::node::ImageManipV2>();
 
-    camRgb->setBoardSocket(dai::CameraBoardSocket::CAM_A);
-    camRgb->setResolution(dai::ColorCameraProperties::SensorResolution::THE_1080_P);
 
     // Resize to 400x400 and avoid stretching by cropping from the center
     manip->initialConfig.setOutputSize(400, 400, dai::ImageManipConfigV2::ResizeMode::CENTER_CROP);
     // Set output frame type
     manip->initialConfig.setFrameType(dai::ImgFrame::Type::RGB888i);
 
-    camRgb->video.link(manip->inputImage);
+    camRgb->requestOutput((std::make_pair(1920, 1080)))->link(manip->inputImage);
     manip->out.link(display->input);
 
-    pipeline.start();
-
-    std::this_thread::sleep_for(std::chrono::seconds(30));
-
-    pipeline.stop();
+    pipeline.run();
 }

examples/cpp/RVC2/Camera/rgb_video_camera.cpp

@@ -2,17 +2,11 @@
 #include <opencv2/opencv.hpp>
 #include <queue>
 
+#include "depthai/common/CameraBoardSocket.hpp"
 #include "depthai/depthai.hpp"
 
 constexpr auto FPS = 30.0;
 
-constexpr auto RGB_SOCKET = dai::CameraBoardSocket::CAM_A;
-constexpr auto LEFT_SOCKET = dai::CameraBoardSocket::CAM_B;
-constexpr auto ALIGN_SOCKET = LEFT_SOCKET;
-
-constexpr auto COLOR_RESOLUTION = dai::ColorCameraProperties::SensorResolution::THE_1080_P;
-constexpr auto LEFT_RIGHT_RESOLUTION = dai::MonoCameraProperties::SensorResolution::THE_720_P;
-
 class FPSCounter {
    public:
     void tick() {
@@ -48,26 +42,18 @@ void updateDepthPlane(int depth, void*) {
 
 int main() {
     dai::Pipeline pipeline;
-    auto camRgb = pipeline.create<dai::node::ColorCamera>();
-    auto left = pipeline.create<dai::node::MonoCamera>();
+    auto camRgb = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_A, std::nullopt, FPS);
+    auto left = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_B, std::nullopt, FPS);
     auto sync = pipeline.create<dai::node::Sync>();
     auto align = pipeline.create<dai::node::ImageAlign>();
 
-    left->setResolution(LEFT_RIGHT_RESOLUTION);
-    left->setBoardSocket(LEFT_SOCKET);
-    left->setFps(FPS);
-
-    camRgb->setBoardSocket(RGB_SOCKET);
-    camRgb->setResolution(COLOR_RESOLUTION);
-    camRgb->setFps(FPS);
-    camRgb->setIspScale(1, 3);
-
     sync->setSyncThreshold(std::chrono::milliseconds(static_cast<int>((1 / FPS) * 1000.0 * 0.5)));
 
     align->outputAligned.link(sync->inputs["aligned"]);
-    camRgb->isp.link(sync->inputs["rgb"]);
-    camRgb->isp.link(align->inputAlignTo);
-    left->out.link(align->input);
+    auto* RGBOutput = camRgb->requestOutput(std::make_pair(640, 400));
+    RGBOutput->link(align->inputAlignTo);
+    RGBOutput->link(sync->inputs["rgb"]);
+    left->requestOutput(std::make_pair(640, 400))->link(align->input);
     auto queue = sync->out.createOutputQueue();
 
     auto alignQ = align->inputConfig.createInputQueue();

examples/cpp/RVC2/ColorCamera/rgb_video.cpp

@@ -10,8 +10,8 @@ int main() {
     int width = 640;
     int height = 400;
     // Define sources and outputs
-    auto left = pipeline.create<dai::node::MonoCamera>();
-    auto right = pipeline.create<dai::node::MonoCamera>();
+    auto left = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_B, std::nullopt, fps);
+    auto right = pipeline.create<dai::node::Camera>()->build(dai::CameraBoardSocket::CAM_C, std::nullopt, fps);
     auto imu = pipeline.create<dai::node::IMU>();
     auto odom = pipeline.create<dai::node::BasaltVIO>();
 
@@ -20,17 +20,9 @@ int main() {
     imu->setBatchReportThreshold(1);
     imu->setMaxBatchReports(10);
 
-    left->setCamera("left");
-    left->setResolution(dai::MonoCameraProperties::SensorResolution::THE_400_P);
-    left->setFps(fps);
-    right->setCamera("right");
-    right->setResolution(dai::MonoCameraProperties::SensorResolution::THE_400_P);
-    right->setFps(fps);
-
     // Linking
-
-    left->out.link(odom->left);
-    right->out.link(odom->right);
+    left->requestOutput(std::make_pair(width, height))->link(odom->left);
+    right->requestOutput(std::make_pair(width, height))->link(odom->right);
     imu->out.link(odom->imu);
     odom->transform.link(rerun->inputTrans);
     odom->passthrough.link(rerun->inputImg);