Satisfy pre-commit checks

Author: RHeckerIntel

.github/workflows/test_accuracy.yml

@@ -44,15 +44,6 @@ jobs:
           pip install typing_extensions==4.12.2
           cmake ../tests/cpp/accuracy/
           make -j
-      - name: Build CPP-PY Bindings
-        run: |
-          source venv/bin/activate
-          pip install src/cpp/py_bindings
       - name: Run CPP Test
         run: |
           build/test_accuracy -d data -p tests/python/accuracy/public_scope.json
-      - name: Run CPP-PY Bindings Test
-        run: |
-          source venv/bin/activate
-          pip list
-          pytest --data=./data --config=./tests/python/accuracy/public_scope.json tests/cpp/accuracy/test_bindings.py

examples/cpp/asynchronous_api/main.cpp

@@ -3,9 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 #include <adapters/openvino_adapter.h>
+#include <stddef.h>
 #include <tasks/detection.h>
 #include <tasks/results.h>
-#include <stddef.h>
 
 #include <cstdint>
 #include <exception>
@@ -31,20 +31,7 @@ int main(int argc, char* argv[]) try {
 
     // Instantiate Object Detection model
     auto model = DetectionModel::load(argv[1], {});  // works with SSD models. Download it using Python Model API
-    //// Define number of parallel infer requests. Is this number is set to 0, OpenVINO will determine it automatically to
-    //// obtain optimal performance.
-    //size_t num_requests = 0;
-    //static ov::Core core;
-    //model->load(core, "CPU", num_requests);
-
-    //std::cout << "Async inference will be carried out by " << model->getNumAsyncExecutors() << " parallel executors\n";
-    //// Prepare batch data
     std::vector<cv::Mat> data = {image};
-    //for (size_t i = 0; i < 3; i++) {
-    //    data.push_back(ImageInputData(image));
-    //}
-
-    // Batch inference is done by processing batch with num_requests parallel infer requests
     std::cout << "Starting batch inference\n";
     auto results = model.inferBatch(data);
 

examples/cpp/synchronous_api/main.cpp

@@ -3,9 +3,9 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+#include <stddef.h>
 #include <tasks/detection.h>
 #include <tasks/results.h>
-#include <stddef.h>
 
 #include <cstdint>
 #include <exception>

src/cpp/include/tasks/detection.h

@@ -1,44 +1,66 @@
 #pragma once
 
-#include <string>
 #include <opencv2/opencv.hpp>
 #include <openvino/openvino.hpp>
+#include <string>
+
 #include "adapters/inference_adapter.h"
 #include "tasks/detection/ssd.h"
 #include "tasks/results.h"
-#include "utils/vision_pipeline.h"
 #include "utils/tiling.h"
+#include "utils/vision_pipeline.h"
 
 class DetectionModel {
 public:
     std::unique_ptr<Pipeline<DetectionResult>> pipeline;
 
-    DetectionModel(std::unique_ptr<SSD> algorithm, const ov::AnyMap& configuration): algorithm(std::move(algorithm)) {
+    DetectionModel(std::unique_ptr<SSD> algorithm, const ov::AnyMap& configuration) : algorithm(std::move(algorithm)) {
         auto config = this->algorithm->adapter->getModelConfig();
         if (configuration.count("tiling") && configuration.at("tiling").as<bool>()) {
             if (!utils::config_contains_tiling_info(config)) {
                 throw std::runtime_error("Model config does not contain tiling properties.");
             }
-            pipeline = std::make_unique<TilingPipeline<DetectionResult>>(this->algorithm->adapter, 
+            pipeline = std::make_unique<TilingPipeline<DetectionResult>>(
+                this->algorithm->adapter,
                 utils::get_tiling_info_from_config(config),
-                [&](cv::Mat image) { return preprocess(image);},
-                [&](InferenceResult result) { return postprocess(result);},
-                [&](DetectionResult& result, const cv::Rect& coord) { return postprocess_tile(result, coord);},
-                [&](const std::vector<DetectionResult>& tiles_results, const cv::Size& image_size, const std::vector<cv::Rect>& tile_coords, const utils::TilingInfo& tiling_info) { return merge_tiling_results(tiles_results, image_size, tile_coords, tiling_info);}
-            );
+                [&](cv::Mat image) {
+                    return preprocess(image);
+                },
+                [&](InferenceResult result) {
+                    return postprocess(result);
+                },
+                [&](DetectionResult& result, const cv::Rect& coord) {
+                    return postprocess_tile(result, coord);
+                },
+                [&](const std::vector<DetectionResult>& tiles_results,
+                    const cv::Size& image_size,
+                    const std::vector<cv::Rect>& tile_coords,
+                    const utils::TilingInfo& tiling_info) {
+                    return merge_tiling_results(tiles_results, image_size, tile_coords, tiling_info);
+                });
         } else {
-            pipeline = std::make_unique<VisionPipeline<DetectionResult>>(this->algorithm->adapter, 
-                [&](cv::Mat image) { return preprocess(image);},
-                [&](InferenceResult result) { return postprocess(result);}
-            );
+            pipeline = std::make_unique<VisionPipeline<DetectionResult>>(
+                this->algorithm->adapter,
+                [&](cv::Mat image) {
+                    return preprocess(image);
+                },
+                [&](InferenceResult result) {
+                    return postprocess(result);
+                });
         }
     }
 
     InferenceInput preprocess(cv::Mat);
     DetectionResult postprocess(InferenceResult);
     DetectionResult postprocess_tile(DetectionResult& result, const cv::Rect& coord);
-    DetectionResult merge_tiling_results(const std::vector<DetectionResult>& tiles_results, const cv::Size& image_size, const std::vector<cv::Rect>& tile_coords, const utils::TilingInfo& tiling_info);
-    ov::Tensor merge_saliency_maps(const std::vector<DetectionResult>& tiles_results, const cv::Size& image_size, const std::vector<cv::Rect>& tile_coords, const utils::TilingInfo& tiling_info);
+    DetectionResult merge_tiling_results(const std::vector<DetectionResult>& tiles_results,
+                                         const cv::Size& image_size,
+                                         const std::vector<cv::Rect>& tile_coords,
+                                         const utils::TilingInfo& tiling_info);
+    ov::Tensor merge_saliency_maps(const std::vector<DetectionResult>& tiles_results,
+                                   const cv::Size& image_size,
+                                   const std::vector<cv::Rect>& tile_coords,
+                                   const utils::TilingInfo& tiling_info);
 
     static DetectionModel load(const std::string& model_path, const ov::AnyMap& configuration = {});
 

src/cpp/include/tasks/detection/ssd.h

@@ -1,14 +1,12 @@
 #pragma once
 
 #include <openvino/openvino.hpp>
+
 #include "adapters/inference_adapter.h"
-#include "utils/preprocessing.h"
 #include "tasks/results.h"
+#include "utils/preprocessing.h"
 
-enum SSDOutputMode { 
-    single,
-    multi
-};
+enum SSDOutputMode { single, multi };
 
 class NumAndStep {
 public:
@@ -24,7 +22,7 @@ class SSD {
 public:
     std::shared_ptr<InferenceAdapter> adapter;
 
-    SSD(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape): adapter(adapter), input_shape(input_shape) {
+    SSD(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape) : adapter(adapter), input_shape(input_shape) {
         auto config = adapter->getModelConfig();
         {
             auto iter = config.find("labels");
@@ -47,6 +45,7 @@ class SSD {
     static cv::Size serialize(std::shared_ptr<ov::Model> ov_model);
 
     SSDOutputMode output_mode;
+
 private:
     static void prepareSingleOutput(std::shared_ptr<ov::Model> ov_model);
     static void prepareMultipleOutputs(std::shared_ptr<ov::Model> ov_model);
@@ -64,4 +63,4 @@ class SSD {
     ov::Layout layout;
     cv::InterpolationFlags interpolation_mode;
     cv::Size input_shape;
-};
+};

src/cpp/include/tasks/instance_segmentation.h

@@ -1,21 +1,28 @@
 #pragma once
 
-#include <openvino/openvino.hpp>
 #include <opencv2/opencv.hpp>
-#include "tasks/results.h"
+#include <openvino/openvino.hpp>
+
 #include "adapters/inference_adapter.h"
+#include "tasks/results.h"
 #include "utils/vision_pipeline.h"
 
 class InstanceSegmentation {
 public:
     std::shared_ptr<InferenceAdapter> adapter;
     VisionPipeline<InstanceSegmentationResult> pipeline;
 
-    InstanceSegmentation(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape): adapter(adapter), input_shape(input_shape) {
-        pipeline = VisionPipeline<InstanceSegmentationResult>(adapter, 
-            [&](cv::Mat image) { return preprocess(image);},
-            [&](InferenceResult result) { return postprocess(result);}
-        );
+    InstanceSegmentation(std::shared_ptr<InferenceAdapter> adapter, cv::Size input_shape)
+        : adapter(adapter),
+          input_shape(input_shape) {
+        pipeline = VisionPipeline<InstanceSegmentationResult>(
+            adapter,
+            [&](cv::Mat image) {
+                return preprocess(image);
+            },
+            [&](InferenceResult result) {
+                return postprocess(result);
+            });
 
         auto config = adapter->getModelConfig();
         auto iter = config.find("labels");
@@ -56,4 +63,4 @@ class InstanceSegmentation {
 
     cv::Size input_shape;
     float confidence_threshold = 0.5f;
-};
+};

src/cpp/include/tasks/results.h

@@ -1,13 +1,12 @@
 #pragma once
 
-#include <openvino/openvino.hpp>
 #include <opencv2/opencv.hpp>
+#include <openvino/openvino.hpp>
 
 class InferenceResult {
 public:
     std::map<std::string, ov::Tensor> data;
     cv::Size inputImageSize;
- 
 };
 
 struct DetectedObject : public cv::Rect2f {
@@ -62,7 +61,6 @@ struct Contour {
     }
 };
 
-
 struct SemanticSegmentationResult {
     SemanticSegmentationResult() {}
     cv::Mat resultImage;
@@ -108,7 +106,6 @@ struct SemanticSegmentationResult {
             os << "[0]";
         }
         return os;
-
     }
     explicit operator std::string() {
         std::stringstream ss;
@@ -139,7 +136,6 @@ struct SegmentedObjectWithRects : SegmentedObject {
     }
 };
 
-
 struct InstanceSegmentationResult {
     std::vector<SegmentedObject> segmentedObjects;
     std::vector<cv::Mat_<std::uint8_t>> saliency_map;

src/cpp/include/tasks/semantic_segmentation.h

@@ -1,6 +1,6 @@
 #pragma once
-#include <openvino/openvino.hpp>
 #include <opencv2/opencv.hpp>
+#include <openvino/openvino.hpp>
 
 #include "adapters/inference_adapter.h"
 #include "tasks/results.h"
@@ -11,11 +11,15 @@ class SemanticSegmentation {
 public:
     VisionPipeline<SemanticSegmentationResult> pipeline;
     std::shared_ptr<InferenceAdapter> adapter;
-    SemanticSegmentation(std::shared_ptr<InferenceAdapter> adapter): adapter(adapter) {
-        pipeline = VisionPipeline<SemanticSegmentationResult>(adapter, 
-            [&](cv::Mat image) { return preprocess(image);},
-            [&](InferenceResult result) { return postprocess(result);}
-        );
+    SemanticSegmentation(std::shared_ptr<InferenceAdapter> adapter) : adapter(adapter) {
+        pipeline = VisionPipeline<SemanticSegmentationResult>(
+            adapter,
+            [&](cv::Mat image) {
+                return preprocess(image);
+            },
+            [&](InferenceResult result) {
+                return postprocess(result);
+            });
 
         auto config = adapter->getModelConfig();
         auto iter = config.find("labels");
@@ -38,7 +42,6 @@ class SemanticSegmentation {
                 blur_strength = iter->second.as<int>();
             }
         }
-
     }
 
     static cv::Size serialize(std::shared_ptr<ov::Model>& ov_model);
@@ -52,10 +55,11 @@ class SemanticSegmentation {
     void inferAsync(cv::Mat image, ov::AnyMap user_data);
     void setCallback(std::function<void(SemanticSegmentationResult, ov::AnyMap)>);
     std::vector<SemanticSegmentationResult> inferBatch(std::vector<cv::Mat> image);
+
 private:
     cv::Mat create_hard_prediction_from_soft_prediction(cv::Mat, float threshold, int blur_strength);
 
-    //from config
+    // from config
     int blur_strength = -1;
     float soft_threshold = -std::numeric_limits<float>::infinity();
     bool return_soft_prediction = true;
@@ -65,4 +69,4 @@ class SemanticSegmentation {
     std::string getLabelName(size_t labelID) {
         return labelID < labels.size() ? labels[labelID] : std::string("Label #") + std::to_string(labelID);
     }
-};
+};

src/cpp/include/utils/config.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <openvino/openvino.hpp>
 #include <opencv2/opencv.hpp>
+#include <openvino/openvino.hpp>
 namespace utils {
 template <typename Type>
 Type get_from_any_maps(const std::string& key,
@@ -76,7 +76,6 @@ IntervalCondition makeCond(Args&&... args) {
 }
 using LayoutCondition = std::tuple<size_t /*dim index*/, IntervalCondition, std::string>;
 
-
 static inline std::tuple<bool, ov::Layout> makeGuesLayoutFrom4DShape(const ov::PartialShape& shape) {
     // at the moment we make assumption about NCHW & NHCW only
     // if hypothetical C value is less than hypothetical H and W - then
@@ -129,4 +128,4 @@ static inline ov::Layout getLayoutFromShape(const ov::PartialShape& shape) {
     throw std::runtime_error("Usupported " + std::to_string(shape.size()) + "D shape");
 }
 
-}
+}  // namespace utils

src/cpp/include/utils/math.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 
 inline float clamp_and_round(float val, float min, float max) {
     return std::round(std::max(min, std::min(max, val)));
@@ -15,4 +15,4 @@ constexpr std::size_t arraySize(const T (&)[N]) noexcept {
 template <typename T>
 T clamp(T value, T low, T high) {
     return value < low ? low : (value > high ? high : value);
-}
+}