Feature/snaps events v2 integration

README.md

@@ -217,6 +217,7 @@ The following environment variables can be set to alter default behavior of the
 | DEPTHAI_CRASHDUMP_TIMEOUT | Specifies the duration in milliseconds to wait for device reboot when obtaining a crash dump. Crash dump retrieval disabled if 0. |
 | DEPTHAI_ENABLE_ANALYTICS_COLLECTION | Enables automatic analytics collection (pipeline schemas) used to improve the library |
 | DEPTHAI_DISABLE_CRASHDUMP_COLLECTION | Disables automatic crash dump collection used to improve the library |
+| DEPTHAI_HUB_EVENTS_BASE_URL | URL for the Luxonis Hub |
 | DEPTHAI_HUB_API_KEY | API key for the Luxonis Hub |
 | DEPTHAI_ZOO_INTERNET_CHECK | (Default) 1 - perform internet check, if available, download the newest model version 0 - skip internet check and use cached model |
 | DEPTHAI_ZOO_INTERNET_CHECK_TIMEOUT | (Default) 1000 - timeout in milliseconds for the internet check |

bindings/python/src/utility/EventsManagerBindings.cpp

@@ -21,53 +21,112 @@ void EventsManagerBindings::bind(pybind11::module& m, void* pCallstack) {
 
 #ifdef DEPTHAI_ENABLE_EVENTS_MANAGER
     using namespace dai::utility;
-    py::class_<EventData, std::shared_ptr<utility::EventData>>(m, "EventData")
-        .def(py::init<const std::string&, const std::string&, const std::string&>(), py::arg("data"), py::arg("fileName"), py::arg("mimeType"))
-        .def(py::init<std::string>(), py::arg("fileUrl"))
-        .def(py::init<const std::shared_ptr<ImgFrame>&, std::string>(), py::arg("imgFrame"), py::arg("fileName"))
-        .def(py::init<const std::shared_ptr<EncodedFrame>&, std::string>(), py::arg("encodedFrame"), py::arg("fileName"))
-        .def(py::init<const std::shared_ptr<NNData>&, std::string>(), py::arg("nnData"), py::arg("fileName"));
+    py::class_<FileGroup, std::shared_ptr<utility::FileGroup>>(m, "FileGroup")
+        .def(py::init<>())
+        .def("addFile",
+             static_cast<void (FileGroup::*)(std::string, std::string, std::string)>(&FileGroup::addFile),
+             py::arg("fileName"),
+             py::arg("data"),
+             py::arg("mimeType"),
+             DOC(dai, utility, FileGroup, addFile))
+        .def("addFile",
+             static_cast<void (FileGroup::*)(std::string, std::filesystem::path)>(&FileGroup::addFile),
+             py::arg("fileName"),
+             py::arg("filePath"),
+             DOC(dai, utility, FileGroup, addFile))
+        .def("addFile",
+             static_cast<void (FileGroup::*)(const std::optional<std::string>&, const std::shared_ptr<ImgFrame>&)>(&FileGroup::addFile),
+             py::arg("fileName"),
+             py::arg("imgFrame"),
+             DOC(dai, utility, FileGroup, addFile))
+        .def("addFile",
+             static_cast<void (FileGroup::*)(const std::optional<std::string>&, const std::shared_ptr<EncodedFrame>&)>(&FileGroup::addFile),
+             py::arg("fileName"),
+             py::arg("encodedFrame"),
+             DOC(dai, utility, FileGroup, addFile))
+        //.def("addFile",
+        //     static_cast<void (FileGroup::*)(std::string, const std::shared_ptr<NNData>&)>(&FileGroup::addFile),
+        //     py::arg("fileName"),
+        //     py::arg("nnData"),
+        //     DOC(dai, utility, FileGroup, addFile))
+        .def("addFile",
+             static_cast<void (FileGroup::*)(const std::optional<std::string>&, const std::shared_ptr<ImgDetections>&)>(&FileGroup::addFile),
+             py::arg("fileName"),
+             py::arg("imgDetections"),
+             DOC(dai, utility, FileGroup, addFile))
+        .def("addImageDetectionsPair",
+             static_cast<void (FileGroup::*)(const std::optional<std::string>&, const std::shared_ptr<ImgFrame>&, const std::shared_ptr<ImgDetections>&)>(
+                 &FileGroup::addImageDetectionsPair),
+             py::arg("fileName"),
+             py::arg("imgFrame"),
+             py::arg("imgDetections"),
+             DOC(dai, utility, FileGroup, addImageDetectionsPair))
+        .def("addImageDetectionsPair",
+             static_cast<void (FileGroup::*)(const std::optional<std::string>&, const std::shared_ptr<EncodedFrame>&, const std::shared_ptr<ImgDetections>&)>(
+                 &FileGroup::addImageDetectionsPair),
+             py::arg("fileName"),
+             py::arg("encodedFrame"),
+             py::arg("imgDetections"),
+             DOC(dai, utility, FileGroup, addImageDetectionsPair));
+    //.def("addImageNNDataPair",
+    //     static_cast<void (FileGroup::*)(std::string, const std::shared_ptr<ImgFrame>&, const std::shared_ptr<NNData>&)>(&FileGroup::addImageNNDataPair),
+    //     py::arg("fileName"),
+    //     py::arg("imgFrame"),
+    //     py::arg("nnData"),
+    //     DOC(dai, utility, FileGroup, addImageNNDataPair))
+    //.def(
+    //    "addImageNNDataPair",
+    //    static_cast<void (FileGroup::*)(std::string, const std::shared_ptr<EncodedFrame>&, const std::shared_ptr<NNData>&)>(&FileGroup::addImageNNDataPair),
+    //    py::arg("fileName"),
+    //    py::arg("encodedFrame"),
+    //    py::arg("nnData"),
+    //    DOC(dai, utility, FileGroup, addImageNNDataPair));
 
     py::class_<EventsManager>(m, "EventsManager")
         .def(py::init<>())
-        .def(py::init<std::string, bool, float>(), py::arg("url"), py::arg("uploadCachedOnStart") = false, py::arg("publishInterval") = 10.0)
-        .def("setUrl", &EventsManager::setUrl, py::arg("url"), DOC(dai, utility, EventsManager, setUrl))
-        .def("setSourceAppId", &EventsManager::setSourceAppId, py::arg("sourceAppId"), DOC(dai, utility, EventsManager, setSourceAppId))
-        .def("setSourceAppIdentifier",
-             &EventsManager::setSourceAppIdentifier,
-             py::arg("sourceAppIdentifier"),
-             DOC(dai, utility, EventsManager, setSourceAppIdentifier))
+        .def(py::init<bool>(), py::arg("uploadCachedOnStart") = false)
         .def("setToken", &EventsManager::setToken, py::arg("token"), DOC(dai, utility, EventsManager, setToken))
-        .def("setQueueSize", &EventsManager::setQueueSize, py::arg("queueSize"), DOC(dai, utility, EventsManager, setQueueSize))
         .def("setLogResponse", &EventsManager::setLogResponse, py::arg("logResponse"), DOC(dai, utility, EventsManager, setLogResponse))
-        .def("setDeviceSerialNumber",
-             &EventsManager::setDeviceSerialNumber,
-             py::arg("deviceSerialNumber"),
-             DOC(dai, utility, EventsManager, setDeviceSerialNumber))
         .def("setVerifySsl", &EventsManager::setVerifySsl, py::arg("verifySsl"), DOC(dai, utility, EventsManager, setVerifySsl))
         .def("setCacheDir", &EventsManager::setCacheDir, py::arg("cacheDir"), DOC(dai, utility, EventsManager, setCacheDir))
         .def("setCacheIfCannotSend",
              &EventsManager::setCacheIfCannotSend,
              py::arg("cacheIfCannotUpload"),
              DOC(dai, utility, EventsManager, setCacheIfCannotSend))
-        .def("checkConnection", &EventsManager::checkConnection, DOC(dai, utility, EventsManager, checkConnection))
-        .def("uploadCachedData", &EventsManager::uploadCachedData, DOC(dai, utility, EventsManager, uploadCachedData))
         .def("sendEvent",
              &EventsManager::sendEvent,
              py::arg("name"),
-             py::arg("imgFrame").none(true) = nullptr,
-             py::arg("data") = std::vector<std::shared_ptr<EventData>>(),
              py::arg("tags") = std::vector<std::string>(),
-             py::arg("extraData") = std::unordered_map<std::string, std::string>(),
+             py::arg("extras") = std::unordered_map<std::string, std::string>(),
              py::arg("deviceSerialNo") = "",
+             py::arg("associateFiles") = std::vector<std::string>(),
              DOC(dai, utility, EventsManager, sendEvent))
         .def("sendSnap",
-             &EventsManager::sendSnap,
+             static_cast<bool (EventsManager::*)(const std::string&,
+                                                 const std::shared_ptr<FileGroup>,
+                                                 const std::vector<std::string>&,
+                                                 const std::unordered_map<std::string, std::string>&,
+                                                 const std::string&)>(&EventsManager::sendSnap),
+             py::arg("name"),
+             py::arg("fileGroup") = std::shared_ptr<FileGroup>(),
+             py::arg("tags") = std::vector<std::string>(),
+             py::arg("extras") = std::unordered_map<std::string, std::string>(),
+             py::arg("deviceSerialNo") = "",
+             DOC(dai, utility, EventsManager, sendSnap))
+        .def("sendSnap",
+             static_cast<bool (EventsManager::*)(const std::string&,
+                                                 const std::optional<std::string>&,
+                                                 const std::shared_ptr<ImgFrame>,
+                                                 const std::optional<std::shared_ptr<ImgDetections>>&,
+                                                 const std::vector<std::string>&,
+                                                 const std::unordered_map<std::string, std::string>&,
+                                                 const std::string&)>(&EventsManager::sendSnap),
              py::arg("name"),
-             py::arg("imgFrame").none(true) = nullptr,
-             py::arg("data") = std::vector<std::shared_ptr<EventData>>(),
+             py::arg("fileName"),
+             py::arg("imgFrame"),
+             py::arg("imgDetections"),
              py::arg("tags") = std::vector<std::string>(),
-             py::arg("extraData") = std::unordered_map<std::string, std::string>(),
+             py::arg("extras") = std::unordered_map<std::string, std::string>(),
              py::arg("deviceSerialNo") = "",
              DOC(dai, utility, EventsManager, sendSnap));
 #endif

examples/cpp/Events/CMakeLists.txt

@@ -6,4 +6,5 @@ cmake_minimum_required(VERSION 3.10)
 
 if(DEPTHAI_ENABLE_EVENTS_MANAGER)
     dai_add_example(events events.cpp OFF OFF)
+    dai_add_example(events_file_group events_file_group.cpp OFF OFF)
 endif()

examples/cpp/Events/events.cpp

@@ -1,43 +1,80 @@
 #include <chrono>
 #include <iostream>
+#include <opencv2/opencv.hpp>
 #include <string>
 
 #include "depthai/depthai.hpp"
 #include "depthai/utility/EventsManager.hpp"
 
-int main(int argc, char* argv[]) {
+// Helper function to normalize frame coordinates
+cv::Rect frameNorm(const cv::Mat& frame, const dai::Point2f& topLeft, const dai::Point2f& bottomRight) {
+    float width = frame.cols, height = frame.rows;
+    return cv::Rect(cv::Point(topLeft.x * width, topLeft.y * height), cv::Point(bottomRight.x * width, bottomRight.y * height));
+}
+
+int main() {
     dai::Pipeline pipeline(true);
 
+    // Enter you hub team's api-key
     auto eventsManager = std::make_shared<dai::utility::EventsManager>();
-    eventsManager->setLogResponse(true);
-    // Color camera node
+    eventsManager->setToken("");
+
     auto camRgb = pipeline.create<dai::node::Camera>()->build();
-    auto* preview = camRgb->requestOutput(std::make_pair(256, 256));
+    auto detectionNetwork = pipeline.create<dai::node::DetectionNetwork>();
 
-    auto previewQ = preview->createOutputQueue();
+    dai::NNModelDescription modelDescription;
+    modelDescription.model = "yolov6-nano";
+    detectionNetwork->build(camRgb, modelDescription);
+    auto labelMap = detectionNetwork->getClasses();
 
-    pipeline.start();
-    bool sent = false;
-    eventsManager->sendEvent("test", nullptr, {}, {"tag1", "tag2"}, {{"key1", "value1"}});
+    // Create output queues
+    auto qRgb = detectionNetwork->passthrough.createOutputQueue();
+    auto qDet = detectionNetwork->out.createOutputQueue();
 
-    std::this_thread::sleep_for(std::chrono::milliseconds(7000));
+    pipeline.start();
 
-    auto fileData = std::make_shared<dai::utility::EventData>("abc", "test_bin.txt", "text/plain");
-    std::vector<std::shared_ptr<dai::utility::EventData>> data;
-    data.emplace_back(fileData);
-    eventsManager->sendEvent("testdata", nullptr, data, {"tag3", "tag4"}, {{"key8", "value8"}});
     while(pipeline.isRunning()) {
-        auto rgb = previewQ->get<dai::ImgFrame>();
+        if(cv::waitKey(1) == 'q') {
+            break;
+        }
 
-        // Do something with the data
-        // ...
+        auto inRgb = qRgb->get<dai::ImgFrame>();
+        auto inDet = qDet->get<dai::ImgDetections>();
+        if(inRgb == nullptr || inDet == nullptr) {
+            continue;
+        }
+
+        // Display the video stream and detections
+        cv::Mat frame = inRgb->getCvFrame();
+        if(!frame.empty()) {
+            // Display detections
+            for(const auto& detection : inDet->detections) {
+                auto bbox = frameNorm(frame, dai::Point2f(detection.xmin, detection.ymin), dai::Point2f(detection.xmax, detection.ymax));
+
+                // Draw label
+                cv::putText(
+                    frame, labelMap.value()[detection.label], cv::Point(bbox.x + 10, bbox.y + 20), cv::FONT_HERSHEY_TRIPLEX, 0.5, cv::Scalar(255, 255, 255));
+
+                // Draw confidence
+                cv::putText(frame,
+                            std::to_string(static_cast<int>(detection.confidence * 100)) + "%",
+                            cv::Point(bbox.x + 10, bbox.y + 40),
+                            cv::FONT_HERSHEY_TRIPLEX,
+                            0.5,
+                            cv::Scalar(255, 255, 255));
+
+                // Draw rectangle
+                cv::rectangle(frame, bbox, cv::Scalar(255, 0, 0), 2);
+            }
+
+            // Show the frame
+            cv::imshow("rgb", frame);
+        }
 
-        if(!sent) {
-            eventsManager->sendSnap("rgb", rgb, {}, {"tag11", "tag12"}, {{"key", "value"}});
-            sent = true;
+        // Trigger sendSnap()
+        if(cv::waitKey(1) == 's') {
+            eventsManager->sendSnap("ImageDetection", std::nullopt, inRgb, inDet, {"EventsExample", "C++"}, {{"key_0", "value_0"}, {"key_1", "value_1"}});
         }
-        //
-        std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
 
     return EXIT_SUCCESS;

examples/cpp/Events/events_file_group.cpp

@@ -0,0 +1,98 @@
+#include <chrono>
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <string>
+
+#include "depthai/depthai.hpp"
+#include "depthai/utility/EventsManager.hpp"
+
+// Helper function to normalize frame coordinates
+cv::Rect frameNorm(const cv::Mat& frame, const dai::Point2f& topLeft, const dai::Point2f& bottomRight) {
+    float width = frame.cols, height = frame.rows;
+    return cv::Rect(cv::Point(topLeft.x * width, topLeft.y * height), cv::Point(bottomRight.x * width, bottomRight.y * height));
+}
+
+int main() {
+    dai::Pipeline pipeline(true);
+
+    // Enter you hub team's api-key
+    auto eventsManager = std::make_shared<dai::utility::EventsManager>();
+    eventsManager->setToken("");
+
+    auto camRgb = pipeline.create<dai::node::Camera>()->build();
+    auto detectionNetwork = pipeline.create<dai::node::DetectionNetwork>();
+
+    dai::NNModelDescription modelDescription;
+    modelDescription.model = "yolov6-nano";
+    detectionNetwork->build(camRgb, modelDescription);
+    auto labelMap = detectionNetwork->getClasses();
+
+    // Create output queues
+    auto qRgb = detectionNetwork->passthrough.createOutputQueue();
+    auto qDet = detectionNetwork->out.createOutputQueue();
+
+    pipeline.start();
+
+    int counter = 0;
+    while(pipeline.isRunning()) {
+        if(cv::waitKey(1) == 'q') {
+            break;
+        }
+
+        auto inRgb = qRgb->get<dai::ImgFrame>();
+        auto inDet = qDet->get<dai::ImgDetections>();
+        if(inRgb == nullptr || inDet == nullptr) {
+            continue;
+        }
+
+        // Display the video stream and detections
+        cv::Mat frame = inRgb->getCvFrame();
+        if(!frame.empty()) {
+            // Display detections
+            for(const auto& detection : inDet->detections) {
+                auto bbox = frameNorm(frame, dai::Point2f(detection.xmin, detection.ymin), dai::Point2f(detection.xmax, detection.ymax));
+
+                // Draw label
+                cv::putText(
+                    frame, labelMap.value()[detection.label], cv::Point(bbox.x + 10, bbox.y + 20), cv::FONT_HERSHEY_TRIPLEX, 0.5, cv::Scalar(255, 255, 255));
+
+                // Draw confidence
+                cv::putText(frame,
+                            std::to_string(static_cast<int>(detection.confidence * 100)) + "%",
+                            cv::Point(bbox.x + 10, bbox.y + 40),
+                            cv::FONT_HERSHEY_TRIPLEX,
+                            0.5,
+                            cv::Scalar(255, 255, 255));
+
+                // Draw rectangle
+                cv::rectangle(frame, bbox, cv::Scalar(255, 0, 0), 2);
+            }
+
+            // Show the frame
+            cv::imshow("rgb", frame);
+        }
+
+        // Suppose we are only interested in the detections with confidence between 50% and 60%
+        auto borderDetections = std::make_shared<dai::ImgDetections>();
+        for(const auto& detection : inDet->detections) {
+            if(detection.confidence > 0.5f && detection.confidence < 0.6f) {
+                borderDetections->detections.emplace_back(detection);
+            }
+        }
+
+        // Are there any border detections
+        if(borderDetections->detections.size() > 0) {
+            std::string fileName = "ImageDetection_";
+            std::stringstream ss;
+            ss << fileName << counter;
+
+            auto fileGroup = std::make_shared<dai::utility::FileGroup>();
+            fileGroup->addImageDetectionsPair(ss.str(), inRgb, borderDetections);
+            eventsManager->sendSnap("LowConfidenceDetection", fileGroup, {"EventsExample", "C++"}, {{"key_0", "value_0"}, {"key_1", "value_1"}});
+
+            counter++;
+        }
+    }
+
+    return EXIT_SUCCESS;
+}