upd pedestrian trakcer demo

Author: ivikhrev

demos/pedestrian_tracker_demo/cpp/include/cnn.hpp

@@ -4,21 +4,20 @@
 
 #pragma once
 
-#include <map>
-#include <memory>
+#include <stddef.h>
+
+#include <functional>
 #include <string>
 #include <vector>
-#include <functional>
-#include <opencv2/opencv.hpp>
+
+#include <opencv2/core.hpp>
 #include <openvino/openvino.hpp>
-#include <utils/ocv_common.hpp>
 
 /**
  * @brief Base class of config for model
  */
 struct ModelConfigTracker {
-    explicit ModelConfigTracker(const std::string& path_to_model)
-        : path_to_model(path_to_model) {}
+    explicit ModelConfigTracker(const std::string& path_to_model) : path_to_model(path_to_model) {}
 
     /** @brief Path to model description */
     std::string path_to_model;
@@ -36,9 +35,7 @@ class BaseModel {
     /**
      * @brief Constructor
      */
-    BaseModel(const Config& config,
-            const ov::Core& core,
-            const std::string & deviceName);
+    BaseModel(const Config& config, const ov::Core& core, const std::string& deviceName);
 
     /**
      * @brief Descructor
@@ -68,7 +65,7 @@ class BaseModel {
     ov::Core core;
     /** @brief device */
     std::string device_name;
-     /** @brief Model input layout */
+    /** @brief Model input layout */
     ov::Layout input_layout;
     /** @brief Compiled model */
     ov::CompiledModel compiled_model;
@@ -86,16 +83,16 @@ class BaseModel {
 
 class VectorCNN : public BaseModel {
 public:
-    VectorCNN(const ModelConfigTracker& config,
-              const ov::Core & core,
-              const std::string & deviceName);
+    VectorCNN(const ModelConfigTracker& config, const ov::Core& core, const std::string& deviceName);
 
-    void Compute(const cv::Mat& image,
-                 cv::Mat* vector, cv::Size outp_shape = cv::Size()) const;
+    void Compute(const cv::Mat& image, 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;
+                 std::vector<cv::Mat>* vectors,
+                 cv::Size outp_shape = cv::Size()) const;
 
-    int size() const { return result_size; }
+    int size() const {
+        return result_size;
+    }
 
 private:
     int result_size;  // Length of result

demos/pedestrian_tracker_demo/cpp/include/core.hpp

@@ -4,31 +4,27 @@
 
 #pragma once
 
-#include <opencv2/core.hpp>
-
 #include <deque>
 #include <iostream>
 #include <string>
 #include <unordered_map>
 
+#include <opencv2/core.hpp>
+
 ///
 /// \brief The TrackedObject struct defines properties of detected object.
 ///
 struct TrackedObject {
-    cv::Rect rect;       ///< Detected object ROI (zero area if N/A).
-    double confidence;   ///< Detection confidence level (-1 if N/A).
-    int64_t frame_idx;       ///< Frame index where object was detected (-1 if N/A).
-    int object_id;       ///< Unique object identifier (-1 if N/A).
+    cv::Rect rect;  ///< Detected object ROI (zero area if N/A).
+    double confidence;  ///< Detection confidence level (-1 if N/A).
+    int64_t frame_idx;  ///< Frame index where object was detected (-1 if N/A).
+    int object_id;  ///< Unique object identifier (-1 if N/A).
     uint64_t timestamp;  ///< Timestamp in milliseconds.
 
     ///
     /// \brief Default constructor.
     ///
-    TrackedObject()
-        : confidence(-1),
-        frame_idx(-1),
-        object_id(-1),
-        timestamp(0) {}
+    TrackedObject() : confidence(-1), frame_idx(-1), object_id(-1), timestamp(0) {}
 
     ///
     /// \brief Constructor with parameters.
@@ -37,13 +33,12 @@ struct TrackedObject {
     /// \param frame_idx Index of frame.
     /// \param object_id Object ID.
     ///
-    TrackedObject(const cv::Rect &rect, float confidence, int64_t frame_idx,
-                  int object_id)
+    TrackedObject(const cv::Rect& rect, float confidence, int64_t frame_idx, int object_id)
         : rect(rect),
-        confidence(confidence),
-        frame_idx(frame_idx),
-        object_id(object_id),
-        timestamp(0) {}
+          confidence(confidence),
+          frame_idx(frame_idx),
+          object_id(object_id),
+          timestamp(0) {}
 };
 
 using TrackedObjects = std::deque<TrackedObject>;

demos/pedestrian_tracker_demo/cpp/include/descriptor.hpp

@@ -6,8 +6,10 @@
 #include <memory>
 #include <string>
 #include <vector>
+
 #include <opencv2/opencv.hpp>
 #include <openvino/openvino.hpp>
+
 #include "cnn.hpp"
 #include "core.hpp"
 #include "logging.hpp"
@@ -29,20 +31,18 @@ class IImageDescriptor {
     /// \param[in] mat Color image.
     /// \param[out] descr Computed descriptor.
     ///
-    virtual void Compute(const cv::Mat &mat, cv::Mat *descr) = 0;
+    virtual void Compute(const cv::Mat& mat, cv::Mat* descr) = 0;
 
     ///
     /// \brief Computes image descriptors in batches.
     /// \param[in] mats Images of interest.
     /// \param[out] descrs Matrices to store the computed descriptors.
     ///
-    virtual void Compute(const std::vector<cv::Mat> &mats,
-                         std::vector<cv::Mat> *descrs) = 0;
+    virtual void Compute(const std::vector<cv::Mat>& mats, std::vector<cv::Mat>* descrs) = 0;
 
     virtual ~IImageDescriptor() {}
 };
 
-
 ///
 /// \brief Uses resized image as descriptor.
 ///
@@ -53,25 +53,27 @@ class ResizedImageDescriptor : public IImageDescriptor {
     /// \param[in] descr_size Size of the descriptor (resized image).
     /// \param[in] interpolation Interpolation algorithm.
     ///
-    explicit ResizedImageDescriptor(const cv::Size &descr_size,
-                                    const cv::InterpolationFlags interpolation)
-        : descr_size_(descr_size), interpolation_(interpolation) {
-            PT_CHECK_GT(descr_size.width, 0);
-            PT_CHECK_GT(descr_size.height, 0);
-        }
+    explicit ResizedImageDescriptor(const cv::Size& descr_size, const cv::InterpolationFlags interpolation)
+        : descr_size_(descr_size),
+          interpolation_(interpolation) {
+        PT_CHECK_GT(descr_size.width, 0);
+        PT_CHECK_GT(descr_size.height, 0);
+    }
 
     ///
     /// \brief Returns descriptor size.
     /// \return Number of elements in the descriptor.
     ///
-    cv::Size size() const override { return descr_size_; }
+    cv::Size size() const override {
+        return descr_size_;
+    }
 
     ///
     /// \brief Computes image descriptor.
     /// \param[in] mat Frame containing the image of interest.
     /// \param[out] descr Matrix to store the computed descriptor.
     ///
-    void Compute(const cv::Mat &mat, cv::Mat *descr) override {
+    void Compute(const cv::Mat& mat, cv::Mat* descr) override {
         PT_CHECK(descr != nullptr);
         PT_CHECK(!mat.empty());
         cv::resize(mat, *descr, descr_size_, 0, 0, interpolation_);
@@ -82,11 +84,10 @@ class ResizedImageDescriptor : public IImageDescriptor {
     /// \param[in] mats Frames containing images of interest.
     /// \param[out] descrs Matrices to store the computed descriptors.
     //
-    void Compute(const std::vector<cv::Mat> &mats,
-                 std::vector<cv::Mat> *descrs) override  {
+    void Compute(const std::vector<cv::Mat>& mats, std::vector<cv::Mat>* descrs) override {
         PT_CHECK(descrs != nullptr);
         descrs->resize(mats.size());
-        for (size_t i = 0; i < mats.size(); i++)  {
+        for (size_t i = 0; i < mats.size(); i++) {
             Compute(mats[i], &(descrs[i]));
         }
     }
@@ -97,16 +98,13 @@ class ResizedImageDescriptor : public IImageDescriptor {
     cv::InterpolationFlags interpolation_;
 };
 
-
 class Descriptor : public IImageDescriptor {
 private:
     VectorCNN handler;
 
 public:
-    Descriptor(const ModelConfigTracker& config,
-                 const ov::Core& core,
-                 const std::string& deviceName):
-        handler(config, core, deviceName) {}
+    Descriptor(const ModelConfigTracker& config, const ov::Core& core, const std::string& deviceName)
+        : handler(config, core, deviceName) {}
 
     ///
     /// \brief Descriptor size getter.
@@ -121,7 +119,7 @@ class Descriptor : public IImageDescriptor {
     /// \param[in] mat Color image.
     /// \param[out] descr Computed descriptor.
     ///
-    void Compute(const cv::Mat &mat, cv::Mat *descr) override {
+    void Compute(const cv::Mat& mat, cv::Mat* descr) override {
         handler.Compute(mat, descr);
     }
 
@@ -130,8 +128,7 @@ class Descriptor : public IImageDescriptor {
     /// \param[in] mats Images of interest.
     /// \param[out] descrs Matrices to store the computed descriptors.
     ///
-    void Compute(const std::vector<cv::Mat> &mats,
-                 std::vector<cv::Mat> *descrs) override {
+    void Compute(const std::vector<cv::Mat>& mats, std::vector<cv::Mat>* descrs) override {
         handler.Compute(mats, descrs);
     }
 };

demos/pedestrian_tracker_demo/cpp/include/distance.hpp

@@ -4,9 +4,9 @@
 
 #pragma once
 
-#include <memory>
 #include <vector>
-#include <opencv2/core/core.hpp>
+
+#include <opencv2/core.hpp>
 #include <opencv2/imgproc.hpp>
 
 ///
@@ -21,16 +21,15 @@ class IDescriptorDistance {
     /// \param[in] descr2 Second descriptor.
     /// \return Distance between two descriptors.
     ///
-    virtual float Compute(const cv::Mat &descr1, const cv::Mat &descr2) = 0;
+    virtual float Compute(const cv::Mat& descr1, const cv::Mat& descr2) = 0;
 
     ///
     /// \brief Computes distances between two descriptors in batches.
     /// \param[in] descrs1 Batch of first descriptors.
     /// \param[in] descrs2 Batch of second descriptors.
     /// \return Distances between descriptors.
     ///
-    virtual std::vector<float> Compute(const std::vector<cv::Mat> &descrs1,
-                                       const std::vector<cv::Mat> &descrs2) = 0;
+    virtual std::vector<float> Compute(const std::vector<cv::Mat>& descrs1, const std::vector<cv::Mat>& descrs2) = 0;
 
     virtual ~IDescriptorDistance() {}
 };
@@ -45,31 +44,28 @@ class CosDistance : public IDescriptorDistance {
     /// \brief CosDistance constructor.
     /// \param[in] descriptor_size Descriptor size.
     ///
-    explicit CosDistance(const cv::Size &descriptor_size);
+    explicit CosDistance(const cv::Size& descriptor_size);
 
     ///
     /// \brief Computes distance between two descriptors.
     /// \param descr1 First descriptor.
     /// \param descr2 Second descriptor.
     /// \return Distance between two descriptors.
     ///
-    float Compute(const cv::Mat &descr1, const cv::Mat &descr2) override;
+    float Compute(const cv::Mat& descr1, const cv::Mat& descr2) override;
 
     ///
     /// \brief Computes distances between two descriptors in batches.
     /// \param[in] descrs1 Batch of first descriptors.
     /// \param[in] descrs2 Batch of second descriptors.
     /// \return Distances between descriptors.
     ///
-    std::vector<float> Compute(
-        const std::vector<cv::Mat> &descrs1,
-        const std::vector<cv::Mat> &descrs2) override;
+    std::vector<float> Compute(const std::vector<cv::Mat>& descrs1, const std::vector<cv::Mat>& descrs2) override;
 
 private:
     cv::Size descriptor_size_;
 };
 
-
 ///
 /// \brief Computes distance between images
 ///        using MatchTemplate function from OpenCV library
@@ -88,30 +84,30 @@ class MatchTemplateDistance : public IDescriptorDistance {
     ///            Final distance is computed as:
     ///            scale * distance + offset.
     ///
-    MatchTemplateDistance(int type = cv::TemplateMatchModes::TM_CCORR_NORMED,
-                          float scale = -1, float offset = 1)
-        : type_(type), scale_(scale), offset_(offset) {}
+    MatchTemplateDistance(int type = cv::TemplateMatchModes::TM_CCORR_NORMED, float scale = -1, float offset = 1)
+        : type_(type),
+          scale_(scale),
+          offset_(offset) {}
     ///
     /// \brief Computes distance between image descriptors.
     /// \param[in] descr1 First image descriptor.
     /// \param[in] descr2 Second image descriptor.
     /// \return Distance between image descriptors.
     ///
-    float Compute(const cv::Mat &descr1, const cv::Mat &descr2) override;
+    float Compute(const cv::Mat& descr1, const cv::Mat& descr2) override;
     ///
     /// \brief Computes distances between two descriptors in batches.
     /// \param[in] descrs1 Batch of first descriptors.
     /// \param[in] descrs2 Batch of second descriptors.
     /// \return Distances between descriptors.
     ///
-    std::vector<float> Compute(const std::vector<cv::Mat> &descrs1,
-                               const std::vector<cv::Mat> &descrs2) override;
+    std::vector<float> Compute(const std::vector<cv::Mat>& descrs1, const std::vector<cv::Mat>& descrs2) override;
     virtual ~MatchTemplateDistance() {}
 
 private:
-    int type_;      ///< Method of MatchTemplate function computation.
-    float scale_;   ///< Scale parameter for the distance. Final distance is
-                    /// computed as: scale * distance + offset.
+    int type_;  ///< Method of MatchTemplate function computation.
+    float scale_;  ///< Scale parameter for the distance. Final distance is
+                   /// computed as: scale * distance + offset.
     float offset_;  ///< Offset parameter for the distance. Final distance is
                     /// computed as: scale * distance + offset.
 };

demos/pedestrian_tracker_demo/cpp/include/logging.hpp

@@ -9,8 +9,7 @@
 #define PT_CHECK(cond) IE_ASSERT(cond) << " "
 
 #define PT_CHECK_BINARY(actual, expected, op) \
-    IE_ASSERT(actual op expected) << ". " \
-        << actual << " vs " << expected << ".  "
+    IE_ASSERT(actual op expected) << ". " << actual << " vs " << expected << ".  "
 
 #define PT_CHECK_EQ(actual, expected) PT_CHECK_BINARY(actual, expected, ==)
 #define PT_CHECK_NE(actual, expected) PT_CHECK_BINARY(actual, expected, !=)