Merge branch 'openvinotoolkit:master' into master

Author: ieliz

demos/common/cpp/utils/include/utils/kuhn_munkres.hpp

@@ -31,7 +31,7 @@ class KuhnMunkres {
     /// \return Optimal column index for each row. -1 means that there is no
     /// column for row.
     ///
-    std::vector<size_t> Solve(const cv::Mat &dissimilarity_matrix);
+    std::vector<int> Solve(const cv::Mat &dissimilarity_matrix);
 
 private:
     static constexpr int kStar = 1;

demos/common/cpp/utils/src/kuhn_munkres.cpp

@@ -10,7 +10,7 @@
 
 KuhnMunkres::KuhnMunkres(bool greedy) : n_(), greedy_(greedy) {}
 
-std::vector<size_t> KuhnMunkres::Solve(const cv::Mat& dissimilarity_matrix) {
+std::vector<int> KuhnMunkres::Solve(const cv::Mat& dissimilarity_matrix) {
     CV_Assert(dissimilarity_matrix.type() == CV_32F);
     double min_val;
     cv::minMaxLoc(dissimilarity_matrix, &min_val);
@@ -28,7 +28,7 @@ std::vector<size_t> KuhnMunkres::Solve(const cv::Mat& dissimilarity_matrix) {
 
     Run();
 
-    std::vector<size_t> results(dissimilarity_matrix.rows, -1);
+    std::vector<int> results(dissimilarity_matrix.rows, -1);
     for (int i = 0; i < dissimilarity_matrix.rows; i++) {
         const auto ptr = marked_.ptr<char>(i);
         for (int j = 0; j < dissimilarity_matrix.cols; j++) {

demos/smart_classroom_demo/cpp/README.md

@@ -82,9 +82,6 @@ Options:
     -m_fd '<path>'                 Required. Path to the Face Detection model (.xml) file.
     -m_lm '<path>'                 Optional. Path to the Facial Landmarks Regression Retail model (.xml) file.
     -m_reid '<path>'               Optional. Path to the Face Reidentification Retail model (.xml) file.
-    -l '<absolute_path>'           Optional. For CPU custom layers, if any. Absolute path to a shared library with the kernels implementation.
-          Or
-    -c '<absolute_path>'           Optional. For GPU custom kernels, if any. Absolute path to an .xml file with the kernels description.
     -d_act '<device>'              Optional. Specify the target device for Person/Action Detection Retail (the list of available devices is shown below). Default value is CPU. Use "-d HETERO:<comma-separated_devices_list>" format to specify HETERO plugin. The application looks for a suitable plugin for the specified device.
     -d_fd '<device>'               Optional. Specify the target device for Face Detection Retail (the list of available devices is shown below). Default value is CPU. Use "-d HETERO:<comma-separated_devices_list>" format to specify HETERO plugin. The application looks for a suitable plugin for the specified device.
     -d_lm '<device>'               Optional. Specify the target device for Landmarks Regression Retail (the list of available devices is shown below). Default value is CPU. Use "-d HETERO:<comma-separated_devices_list>" format to specify HETERO plugin. The application looks for a suitable plugin for the specified device.

demos/smart_classroom_demo/cpp/include/action_detector.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2019 Intel Corporation
+// Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -12,6 +12,8 @@
 
 #include "cnn.hpp"
 
+#include "openvino/openvino.hpp"
+
 /**
 * @brief Class for detection with action info
 */
@@ -113,29 +115,30 @@ class ActionDetection : public AsyncDetection<DetectedAction>, public BaseCnnDet
     explicit ActionDetection(const ActionDetectorConfig& config);
 
     void submitRequest() override;
-    void enqueue(const cv::Mat &frame) override;
+    void enqueue(const cv::Mat& frame) override;
     void wait() override { BaseCnnDetection::wait(); }
     DetectedActions fetchResults() override;
 
 private:
-    ActionDetectorConfig config_;
-    InferenceEngine::ExecutableNetwork net_;
-    std::string input_name_;
-    InferenceEngine::BlobMap outputs_;
-
-    int enqueued_frames_ = 0;
-    float width_ = 0;
-    float height_ = 0;
-    bool new_network_ = false;
-    std::vector<int> head_ranges_;
-    std::vector<int> head_step_sizes_;
-    std::vector<cv::Size> head_blob_sizes_;
-    std::vector<std::vector<int>> glob_anchor_map_;
-    std::vector<std::string> glob_anchor_names_;
-    int num_glob_anchors_ = 0;
-    cv::Size network_input_size_;
-    int num_candidates_;
-    bool binary_task_;
+    ActionDetectorConfig m_config;
+    ov::CompiledModel m_model;
+    ov::Layout m_modelLayout;
+    std::string m_input_name;
+    std::map<std::string, ov::Tensor> m_outputs;
+
+    int m_enqueued_frames = 0;
+    float m_width = 0;
+    float m_height = 0;
+    bool m_new_model = false;
+    std::vector<int> m_head_ranges;
+    std::vector<int> m_head_step_sizes;
+    std::vector<cv::Size> m_head_blob_sizes;
+    std::vector<std::vector<int>> m_glob_anchor_map;
+    std::vector<std::string> m_glob_anchor_names;
+    int m_num_glob_anchors = 0;
+    cv::Size m_network_input_size;
+    int m_num_candidates;
+    bool m_binary_task;
 
     /**
     * @brief BBox in normalized form (each coordinate is in range [0;1]).

demos/smart_classroom_demo/cpp/include/cnn.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2019 Intel Corporation
+// Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -10,31 +10,31 @@
 #include <vector>
 #include <functional>
 
-#include <utils/ocv_common.hpp>
+#include "openvino/openvino.hpp"
 
-#include <inference_engine.hpp>
+#include "utils/ocv_common.hpp"
 
 /**
 * @brief Base class of config for network
 */
 struct CnnConfig {
-    explicit CnnConfig(const std::string& path_to_model, const std::string& model_type = "")
-        : path_to_model(path_to_model), model_type(model_type) {}
+    explicit CnnConfig(const std::string& path_to_model, const std::string& model_type = "") :
+        m_path_to_model(path_to_model), m_model_type(model_type) {}
     /** @brief Path to model description */
-    std::string path_to_model;
+    std::string m_path_to_model;
     /** @brief Model type*/
-    std::string model_type;
+    std::string m_model_type;
     /** @brief Maximal size of batch */
-    int max_batch_size{1};
+    int m_max_batch_size{1};
 
     /** @brief Inference Engine */
-    InferenceEngine::Core ie;
+    ov::Core m_core;
     /** @brief Device name */
-    std::string deviceName;
+    std::string m_deviceName;
 };
 
 /**
-* @brief Base class of network
+* @brief Base class of model
 */
 class CnnDLSDKBase {
 public:
@@ -57,37 +57,32 @@ class CnnDLSDKBase {
 
 protected:
     /**
-   * @brief Run network
-   *
-   * @param frame Input image
-   * @param results_fetcher Callback to fetch inference results
-   */
-    void Infer(const cv::Mat& frame,
-               const std::function<void(const InferenceEngine::BlobMap&, size_t)>& results_fetcher) const;
-
-    /**
-   * @brief Run network in batch mode
+   * @brief Run model in batch mode
    *
    * @param frames Vector of input images
    * @param results_fetcher Callback to fetch inference results
    */
     void InferBatch(const std::vector<cv::Mat>& frames,
-                    const std::function<void(const InferenceEngine::BlobMap&, size_t)>& results_fetcher) const;
+                    const std::function<void(const std::map<std::string, ov::Tensor>&, size_t)>& results_fetcher) const;
 
     /** @brief Config */
-    Config config_;
-    /** @brief Net inputs info */
-    InferenceEngine::InputsDataMap inInfo_;
-    /** @brief Net outputs info */
-    InferenceEngine::OutputsDataMap outInfo_;
-    /** @brief IE network */
-    InferenceEngine::ExecutableNetwork executable_network_;
-    /** @brief IE InferRequest */
-    mutable InferenceEngine::InferRequest infer_request_;
-    /** @brief Name of the input blob input blob */
-    std::string input_blob_name_;
-    /** @brief Names of output blobs */
-    std::vector<std::string> output_blobs_names_;
+    Config m_config;
+    /** @brief Model inputs info */
+    ov::OutputVector m_inInfo;
+    /** @brief Model outputs info */
+    ov::OutputVector m_outInfo_;
+    /** @brief Model layout */
+    ov::Layout m_modelLayout;
+    /** @brief Model input shape */
+    ov::Shape m_modelShape;
+    /** @brief Compled model */
+    ov::CompiledModel m_compiled_model;
+    /** @brief Inference request */
+    mutable ov::InferRequest m_infer_request;
+    /** @brief Name of the input tensor */
+    std::string m_input_tensor_name;
+    /** @brief Names of output tensors */
+    std::vector<std::string> m_output_tensors_names;
 };
 
 class VectorCNN : public CnnDLSDKBase {
@@ -98,12 +93,13 @@ class VectorCNN : public CnnDLSDKBase {
                  cv::Mat* vector, cv::Size outp_shape = cv::Size()) const;
     void Compute(const std::vector<cv::Mat>& images,
                  std::vector<cv::Mat>* vectors, cv::Size outp_shape = cv::Size()) const;
+    int maxBatchSize() const;
 };
 
 class AsyncAlgorithm {
 public:
     virtual ~AsyncAlgorithm() {}
-    virtual void enqueue(const cv::Mat &frame) = 0;
+    virtual void enqueue(const cv::Mat& frame) = 0;
     virtual void submitRequest() = 0;
     virtual void wait() = 0;
 };
@@ -117,33 +113,34 @@ class AsyncDetection : public AsyncAlgorithm {
 template <typename T>
 class NullDetection : public AsyncDetection<T> {
 public:
-    void enqueue(const cv::Mat &) override {}
+    void enqueue(const cv::Mat&) override {}
     void submitRequest() override {}
     void wait() override {}
     std::vector<T> fetchResults() override { return {}; }
 };
 
 class BaseCnnDetection : public AsyncAlgorithm {
 protected:
-    InferenceEngine::InferRequest::Ptr request;
-    const bool isAsync;
-    std::string topoName;
+    std::shared_ptr<ov::InferRequest> m_request;
+    const bool m_isAsync;
+    std::string m_detectorName;
 
 public:
-    explicit BaseCnnDetection(bool isAsync = false) :
-                              isAsync(isAsync) {}
+    explicit BaseCnnDetection(bool isAsync = false) : m_isAsync(isAsync) {}
 
     void submitRequest() override {
-        if (request == nullptr) return;
-        if (isAsync) {
-            request->StartAsync();
+        if (m_request == nullptr)
+            return;
+        if (m_isAsync) {
+            m_request->start_async();
         } else {
-            request->Infer();
+            m_request->infer();
         }
     }
 
     void wait() override {
-        if (!request || !isAsync) return;
-        request->Wait(InferenceEngine::InferRequest::WaitMode::RESULT_READY);
+        if (!m_request || !m_isAsync)
+            return;
+        m_request->wait();
     }
 };

demos/smart_classroom_demo/cpp/include/detector.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2019 Intel Corporation
+// Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -10,6 +10,8 @@
 
 #include <opencv2/core/core.hpp>
 
+#include "openvino/openvino.hpp"
+
 #include "cnn.hpp"
 
 namespace detection {
@@ -18,15 +20,15 @@ struct DetectedObject {
     cv::Rect rect;
     float confidence;
 
-    explicit DetectedObject(const cv::Rect& rect = cv::Rect(), float confidence = -1.0f)
-        : rect(rect), confidence(confidence) {}
+    explicit DetectedObject(const cv::Rect& rect = cv::Rect(), float confidence = -1.0f) :
+        rect(rect), confidence(confidence) {}
 };
 
 using DetectedObjects = std::vector<DetectedObject>;
 
 struct DetectorConfig : public CnnConfig {
-    explicit DetectorConfig(const std::string& path_to_model)
-        : CnnConfig(path_to_model) {}
+    explicit DetectorConfig(const std::string& path_to_model) :
+        CnnConfig(path_to_model) {}
 
     float confidence_threshold{0.6f};
     float increase_scale_x{1.15f};
@@ -38,21 +40,21 @@ struct DetectorConfig : public CnnConfig {
 
 class FaceDetection : public AsyncDetection<DetectedObject>, public BaseCnnDetection {
 private:
-    DetectorConfig config_;
-    InferenceEngine::ExecutableNetwork net_;
-    std::string input_name_;
-    std::string output_name_;
-    int max_detections_count_ = 0;
-    int object_size_ = 0;
-    int enqueued_frames_ = 0;
-    float width_ = 0;
-    float height_ = 0;
+    DetectorConfig m_config;
+    ov::CompiledModel m_model;
+    std::string m_input_name;
+    std::string m_output_name;
+    int m_max_detections_count = 0;
+    int m_object_size = 0;
+    int m_enqueued_frames = 0;
+    float m_width = 0;
+    float m_height = 0;
 
 public:
     explicit FaceDetection(const DetectorConfig& config);
 
     void submitRequest() override;
-    void enqueue(const cv::Mat &frame) override;
+    void enqueue(const cv::Mat& frame) override;
     void wait() override { BaseCnnDetection::wait(); }
 
     DetectedObjects fetchResults() override;

demos/smart_classroom_demo/cpp/include/face_reid.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2019 Intel Corporation
+// Copyright (C) 2018-2022 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 //
 
@@ -25,16 +25,16 @@ struct GalleryObject {
     int id;
 
     GalleryObject(const std::vector<cv::Mat>& embeddings,
-                  const std::string& label, int id)
-        : embeddings(embeddings), label(label), id(id) {}
+                  const std::string& label, int id) :
+        embeddings(embeddings), label(label), id(id) {}
 };
 
 class EmbeddingsGallery {
 public:
     static const char unknown_label[];
     static const int unknown_id;
     EmbeddingsGallery(const std::string& ids_list, double threshold, int min_size_fr,
-                      bool crop_gallery, const detection::DetectorConfig &detector_config,
+                      bool crop_gallery, const detection::DetectorConfig& detector_config,
                       const VectorCNN& landmarks_det,
                       const VectorCNN& image_reid,
                       bool use_greedy_matcher=false);
@@ -52,7 +52,7 @@ class EmbeddingsGallery {
                                         detection::FaceDetection& detector,
                                         const VectorCNN& landmarks_det,
                                         const VectorCNN& image_reid,
-                                        cv::Mat & embedding);
+                                        cv::Mat& embedding);
     std::vector<int> idx_to_id;
     double reid_threshold;
     std::vector<GalleryObject> identities;