CPP Scene Refactor

.github/workflows/test_accuracy.yml

@@ -46,4 +46,4 @@ jobs:
           make -j
       - name: Run CPP Test
         run: |
-          build/test_accuracy -d data -p tests/python/accuracy/public_scope.json
+          build/test_accuracy -d data -p tests/cpp/accuracy/public_scope.json

examples/cpp/asynchronous_api/main.cpp

@@ -53,24 +53,23 @@ int main(int argc, char* argv[]) try {
 
     std::cout << "Batch mode inference results:\n";
     for (const auto& result : results) {
-        for (auto& obj : result->objects) {
-            std::cout << " " << std::left << std::setw(9) << obj.confidence << " " << obj.label << "\n";
+        for (auto& obj : result->boxes) {
+            std::cout << obj << std::endl;
         }
         std::cout << std::string(10, '-') << "\n";
     }
     std::cout << "Batch mode inference done\n";
     std::cout << "Async mode inference results:\n";
 
     // Set callback to grab results once the inference is done
-    model->setCallback([](std::unique_ptr<ResultBase> result, const ov::AnyMap& callback_args) {
-        auto det_result = std::unique_ptr<DetectionResult>(static_cast<DetectionResult*>(result.release()));
+    model->setCallback([](std::unique_ptr<Scene> result, const ov::AnyMap& callback_args) {
 
         // callback_args can contain arbitrary data
         size_t id = callback_args.find("id")->second.as<size_t>();
 
         std::cout << "Request with id " << id << " is finished\n";
-        for (auto& obj : det_result->objects) {
-            std::cout << " " << std::left << std::setw(9) << obj.confidence << " " << obj.label << "\n";
+        for (auto& obj : result->boxes) {
+            std::cout << " " << obj << std::endl;
         }
         std::cout << std::string(10, '-') << "\n";
     });

examples/cpp/synchronous_api/main.cpp

@@ -6,11 +6,7 @@
 #include <models/detection_model.h>
 #include <models/input_data.h>
 #include <models/results.h>
-#include <stddef.h>
-
-#include <cstdint>
 #include <exception>
-#include <iomanip>
 #include <iostream>
 #include <opencv2/core.hpp>
 #include <opencv2/imgcodecs.hpp>
@@ -37,10 +33,8 @@ int main(int argc, char* argv[]) try {
     auto result = model->infer(image);
 
     // Process detections
-    for (auto& obj : result->objects) {
-        std::cout << " " << std::left << std::setw(9) << obj.label << " | " << std::setw(10) << obj.confidence << " | "
-                  << std::setw(4) << int(obj.x) << " | " << std::setw(4) << int(obj.y) << " | " << std::setw(4)
-                  << int(obj.x + obj.width) << " | " << std::setw(4) << int(obj.y + obj.height) << "\n";
+    for (auto& obj : result->boxes) {
+        std::cout << obj << std::endl;
     }
 } catch (const std::exception& error) {
     std::cerr << error.what() << '\n';

src/cpp/models/include/models/anomaly_model.h

@@ -23,9 +23,9 @@ class AnomalyModel : public BaseModel {
                                                       const std::string& device = "AUTO");
     static std::unique_ptr<AnomalyModel> create_model(std::shared_ptr<InferenceAdapter>& adapter);
 
-    virtual std::unique_ptr<AnomalyResult> infer(const ImageInputData& inputData);
-    virtual std::vector<std::unique_ptr<AnomalyResult>> inferBatch(const std::vector<ImageInputData>& inputImgs);
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    virtual std::unique_ptr<Scene> infer(const ImageInputData& inputData);
+    virtual std::vector<std::unique_ptr<Scene>> inferBatch(const std::vector<ImageInputData>& inputImgs);
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
 
     friend std::ostream& operator<<(std::ostream& os, std::unique_ptr<AnomalyModel>& model);
 

src/cpp/models/include/models/base_model.h

@@ -38,7 +38,7 @@ class BaseModel {
     BaseModel(std::shared_ptr<InferenceAdapter>& adapter, const ov::AnyMap& configuration = {});
 
     virtual std::shared_ptr<InternalModelData> preprocess(const InputData& inputData, InferenceInput& input);
-    virtual std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) = 0;
+    virtual std::unique_ptr<Scene> postprocess(InferenceResult& infResult) = 0;
 
     void load(ov::Core& core, const std::string& device, size_t num_infer_requests = 1);
 
@@ -49,7 +49,7 @@ class BaseModel {
     virtual void awaitAll();
     virtual void awaitAny();
     virtual void setCallback(
-        std::function<void(std::unique_ptr<ResultBase>, const ov::AnyMap& callback_args)> callback);
+        std::function<void(std::unique_ptr<Scene>, const ov::AnyMap& callback_args)> callback);
 
     std::shared_ptr<ov::Model> getModel();
     std::shared_ptr<InferenceAdapter> getInferenceAdapter();
@@ -67,8 +67,8 @@ class BaseModel {
                                                const std::vector<float>& scale,
                                                const std::type_info& dtype = typeid(int));
     virtual void inferAsync(const ImageInputData& inputData, const ov::AnyMap& callback_args = {});
-    std::unique_ptr<ResultBase> inferImage(const ImageInputData& inputData);
-    std::vector<std::unique_ptr<ResultBase>> inferBatchImage(const std::vector<ImageInputData>& inputData);
+    std::unique_ptr<Scene> inferImage(const ImageInputData& inputData);
+    std::vector<std::unique_ptr<Scene>> inferBatchImage(const std::vector<ImageInputData>& inputData);
 
 protected:
     RESIZE_MODE selectResizeMode(const std::string& resize_type);
@@ -104,5 +104,5 @@ class BaseModel {
     std::shared_ptr<InferenceAdapter> inferenceAdapter;
     std::map<std::string, ov::Layout> inputsLayouts;
     ov::Layout getInputLayout(const ov::Output<ov::Node>& input);
-    std::function<void(std::unique_ptr<ResultBase>, const ov::AnyMap&)> lastCallback;
+    std::function<void(std::unique_ptr<Scene>, const ov::AnyMap&)> lastCallback;
 };

src/cpp/models/include/models/classification_model.h

@@ -99,10 +99,10 @@ class ClassificationModel : public BaseModel {
                                                              const std::string& device = "AUTO");
     static std::unique_ptr<ClassificationModel> create_model(std::shared_ptr<InferenceAdapter>& adapter);
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
 
-    virtual std::unique_ptr<ClassificationResult> infer(const ImageInputData& inputData);
-    virtual std::vector<std::unique_ptr<ClassificationResult>> inferBatch(const std::vector<ImageInputData>& inputImgs);
+    virtual std::unique_ptr<Scene> infer(const ImageInputData& inputData);
+    virtual std::vector<std::unique_ptr<Scene>> inferBatch(const std::vector<ImageInputData>& inputImgs);
     static std::string ModelType;
 
 protected:
@@ -119,8 +119,8 @@ class ClassificationModel : public BaseModel {
     void init_from_config(const ov::AnyMap& top_priority, const ov::AnyMap& mid_priority);
     void prepareInputsOutputs(std::shared_ptr<ov::Model>& model) override;
     void updateModelInfo() override;
-    std::unique_ptr<ResultBase> get_multilabel_predictions(InferenceResult& infResult, bool add_raw_scores);
-    std::unique_ptr<ResultBase> get_multiclass_predictions(InferenceResult& infResult, bool add_raw_scores);
-    std::unique_ptr<ResultBase> get_hierarchical_predictions(InferenceResult& infResult, bool add_raw_scores);
+    std::unique_ptr<Scene> get_multilabel_predictions(InferenceResult& infResult, bool add_raw_scores);
+    std::unique_ptr<Scene> get_multiclass_predictions(InferenceResult& infResult, bool add_raw_scores);
+    std::unique_ptr<Scene> get_hierarchical_predictions(InferenceResult& infResult, bool add_raw_scores);
     ov::Tensor reorder_saliency_maps(const ov::Tensor&);
 };

src/cpp/models/include/models/detection_model.h

@@ -25,8 +25,8 @@ class DetectionModel : public BaseModel {
                                                         const std::string& device = "AUTO");
     static std::unique_ptr<DetectionModel> create_model(std::shared_ptr<InferenceAdapter>& adapter);
 
-    virtual std::unique_ptr<DetectionResult> infer(const ImageInputData& inputData);
-    virtual std::vector<std::unique_ptr<DetectionResult>> inferBatch(const std::vector<ImageInputData>& inputImgs);
+    virtual std::unique_ptr<Scene> infer(const ImageInputData& inputData);
+    virtual std::vector<std::unique_ptr<Scene>> inferBatch(const std::vector<ImageInputData>& inputImgs);
 
 protected:
     float confidence_threshold = 0.5f;

src/cpp/models/include/models/detection_model_ssd.h

@@ -25,12 +25,12 @@ class ModelSSD : public DetectionModel {
 public:
     using DetectionModel::DetectionModel;
     std::shared_ptr<InternalModelData> preprocess(const InputData& inputData, InferenceInput& input) override;
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
     static std::string ModelType;
 
 protected:
-    std::unique_ptr<ResultBase> postprocessSingleOutput(InferenceResult& infResult);
-    std::unique_ptr<ResultBase> postprocessMultipleOutputs(InferenceResult& infResult);
+    std::unique_ptr<Scene> postprocessSingleOutput(InferenceResult& infResult);
+    std::unique_ptr<Scene> postprocessMultipleOutputs(InferenceResult& infResult);
     void prepareInputsOutputs(std::shared_ptr<ov::Model>& model) override;
     void prepareSingleOutput(std::shared_ptr<ov::Model>& model);
     void prepareMultipleOutputs(std::shared_ptr<ov::Model>& model);

src/cpp/models/include/models/detection_model_yolo.h

@@ -16,9 +16,7 @@
 
 #include "models/detection_model_ext.h"
 
-struct DetectedObject;
 struct InferenceResult;
-struct ResultBase;
 
 class ModelYolo : public DetectionModelExt {
 protected:
@@ -46,7 +44,7 @@ class ModelYolo : public DetectionModelExt {
     ModelYolo(std::shared_ptr<ov::Model>& model, const ov::AnyMap& configuration);
     ModelYolo(std::shared_ptr<InferenceAdapter>& adapter);
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
 
 protected:
     void prepareInputsOutputs(std::shared_ptr<ov::Model>& model) override;
@@ -57,10 +55,10 @@ class ModelYolo : public DetectionModelExt {
                          const unsigned long resized_im_w,
                          const unsigned long original_im_h,
                          const unsigned long original_im_w,
-                         std::vector<DetectedObject>& objects);
+                         std::vector<Box>& objects);
 
     static int calculateEntryIndex(int entriesNum, int lcoords, size_t lclasses, int location, int entry);
-    static double intersectionOverUnion(const DetectedObject& o1, const DetectedObject& o2);
+    static double intersectionOverUnion(const Box& o1, const Box& o2);
 
     std::map<std::string, Region> regions;
     float iou_threshold;
@@ -82,7 +80,7 @@ class YOLOv5 : public DetectionModelExt {
 public:
     YOLOv5(std::shared_ptr<ov::Model>& model, const ov::AnyMap& configuration);
     YOLOv5(std::shared_ptr<InferenceAdapter>& adapter);
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
     static std::string ModelType;
 };
 

src/cpp/models/include/models/detection_model_yolov3_onnx.h

@@ -17,7 +17,7 @@ class ModelYoloV3ONNX : public DetectionModel {
     ModelYoloV3ONNX(std::shared_ptr<InferenceAdapter>& adapter);
     using DetectionModel::DetectionModel;
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
     std::shared_ptr<InternalModelData> preprocess(const InputData& inputData, InferenceInput& input) override;
 
 protected:

src/cpp/models/include/models/detection_model_yolox.h

@@ -17,7 +17,7 @@ class ModelYoloX : public DetectionModelExt {
     ModelYoloX(std::shared_ptr<InferenceAdapter>& adapter);
     using DetectionModelExt::DetectionModelExt;
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
     std::shared_ptr<InternalModelData> preprocess(const InputData& inputData, InferenceInput& input) override;
     static std::string ModelType;
 

src/cpp/models/include/models/instance_segmentation.h

@@ -30,10 +30,10 @@ class MaskRCNNModel : public BaseModel {
                                                        const std::string& device = "AUTO");
     static std::unique_ptr<MaskRCNNModel> create_model(std::shared_ptr<InferenceAdapter>& adapter);
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
 
-    virtual std::unique_ptr<InstanceSegmentationResult> infer(const ImageInputData& inputData);
-    virtual std::vector<std::unique_ptr<InstanceSegmentationResult>> inferBatch(
+    virtual std::unique_ptr<Scene> infer(const ImageInputData& inputData);
+    virtual std::vector<std::unique_ptr<Scene>> inferBatch(
         const std::vector<ImageInputData>& inputImgs);
     static std::string ModelType;
     bool postprocess_semantic_masks = true;
@@ -49,4 +49,4 @@ class MaskRCNNModel : public BaseModel {
     float confidence_threshold = 0.5f;
 };
 
-cv::Mat segm_postprocess(const SegmentedObject& box, const cv::Mat& unpadded, int im_h, int im_w);
+cv::Mat segm_postprocess(const Mask& box, const cv::Mat& unpadded, int im_h, int im_w);

src/cpp/models/include/models/keypoint_detection.h

@@ -29,10 +29,10 @@ class KeypointDetectionModel : public BaseModel {
                                                                 const std::string& device = "AUTO");
     static std::unique_ptr<KeypointDetectionModel> create_model(std::shared_ptr<InferenceAdapter>& adapter);
 
-    std::unique_ptr<ResultBase> postprocess(InferenceResult& infResult) override;
+    std::unique_ptr<Scene> postprocess(InferenceResult& infResult) override;
 
-    virtual std::unique_ptr<KeypointDetectionResult> infer(const ImageInputData& inputData);
-    virtual std::vector<std::unique_ptr<KeypointDetectionResult>> inferBatch(
+    virtual std::unique_ptr<Scene> infer(const ImageInputData& inputData);
+    virtual std::vector<std::unique_ptr<Scene>> inferBatch(
         const std::vector<ImageInputData>& inputImgs);
 
     static std::string ModelType;