demos/cpp: support OpenCV3 (#3513)

Wovchena · web-flow · commit 545094008ba6 · 2022-08-04T11:13:25.000+04:00
diff --git a/demos/CMakeLists.txt b/demos/CMakeLists.txt
@@ -137,12 +137,16 @@ macro(add_demo)
     endif()
 endmacro()
 
-find_package(OpenCV REQUIRED COMPONENTS core highgui videoio imgproc imgcodecs gapi)
+find_package(OpenCV REQUIRED COMPONENTS core highgui videoio imgproc imgcodecs)
 find_package(OpenVINO REQUIRED COMPONENTS Runtime)
 
 add_subdirectory(thirdparty/gflags)
 add_subdirectory(common/cpp)
-add_subdirectory(common/cpp_gapi)
+# TODO: remove wrapping if after OpenCV3 is dropped
+if(OpenCV_VERSION VERSION_GREATER_EQUAL 4.5.3)
+    find_package(OpenCV REQUIRED COMPONENTS gapi)
+    add_subdirectory(common/cpp_gapi)
+endif()
 add_subdirectory(multi_channel_common/cpp)
 
 # collect all samples subdirectories
diff --git a/demos/README.md b/demos/README.md
@@ -80,9 +80,7 @@ The Open Model Zoo demo applications are console applications that provide robus
 Source code of the demos can be obtained from the Open Model Zoo [GitHub repository](https://github.com/openvinotoolkit/open_model_zoo/).
 
 ```sh
-git clone https://github.com/openvinotoolkit/open_model_zoo.git
-cd open_model_zoo
-git submodule update --init --recursive
+git clone --recurse-submodules https://github.com/openvinotoolkit/open_model_zoo.git
 ```
 
 C++, C++ G-API and Python\* versions are located in the `cpp`, `cpp_gapi` and `python` subdirectories respectively.
@@ -166,11 +164,10 @@ You can download the [Intel pre-trained models](../models/intel/index.md) or [pu
 
 ## Build the Demo Applications
 
-To build the demos, you need to source OpenVINO™ and OpenCV environment. You can install the OpenVINO™ toolkit using the installation package for [Intel® Distribution of OpenVINO™ toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit-download.html) or build the open-source version available in the [OpenVINO GitHub repository](https://github.com/openvinotoolkit/openvino) using the [build instructions](https://github.com/openvinotoolkit/openvino/wiki/BuildingCode).
+To build the demos, you need to source OpenVINO™ environment and [get OpenCV](https://github.com/opencv/opencv/wiki/BuildOpenCV4OpenVINO). You can install the OpenVINO™ toolkit using the installation package for [Intel® Distribution of OpenVINO™ toolkit](https://www.intel.com/content/www/us/en/developer/tools/openvino-toolkit-download.html) or build the open-source version available in the [OpenVINO GitHub repository](https://github.com/openvinotoolkit/openvino) using the [build instructions](https://github.com/openvinotoolkit/openvino/wiki/BuildingCode).
 For the Intel® Distribution of OpenVINO™ toolkit installed to the `<INSTALL_DIR>` directory on your machine, run the following commands to download prebuilt OpenCV and set environment variables before building the demos:
 
 ```sh
-<INSTALL_DIR>/extras/scripts/download_opencv.sh
 source <INSTALL_DIR>/setupvars.sh
 ```
 
diff --git a/demos/common/cpp/monitors/include/monitors/presenter.h b/demos/common/cpp/monitors/include/monitors/presenter.h
@@ -28,7 +28,7 @@ class Presenter {
         std::size_t historySize = 20);
     void addRemoveMonitor(MonitorType monitor);
     void handleKey(int key); // handles C, D, M, H keys
-    void drawGraphs(const cv::Mat& frame);
+    void drawGraphs(cv::Mat& frame);
     std::vector<std::string> reportMeans() const;
 
     const int yPos;
diff --git a/demos/common/cpp/monitors/src/presenter.cpp b/demos/common/cpp/monitors/src/presenter.cpp
@@ -117,7 +117,7 @@ void Presenter::handleKey(int key) {
     }
 }
 
-void Presenter::drawGraphs(const cv::Mat& frame) {
+void Presenter::drawGraphs(cv::Mat& frame) {
     const std::chrono::steady_clock::time_point curTimeStamp = std::chrono::steady_clock::now();
     if (curTimeStamp - prevTimeStamp >= std::chrono::milliseconds{1000}) {
         prevTimeStamp = curTimeStamp;
diff --git a/demos/common/cpp/utils/include/utils/ocv_common.hpp b/demos/common/cpp/utils/include/utils/ocv_common.hpp
@@ -150,6 +150,16 @@ inline void putHighlightedText(const cv::Mat& frame,
     cv::putText(frame, message, position, fontFace, fontScale, color, thickness);
 }
 
+// TODO: replace with Size::empty() after OpenCV3 is dropped
+static inline bool isSizeEmpty(const cv::Size& size) {
+    return size.width <= 0 || size.height <= 0;
+}
+
+// TODO: replace with Rect::empty() after OpenCV3 is dropped
+static inline bool isRectEmpty(const cv::Rect& rect) {
+    return rect.width <= 0 || rect.height <= 0;
+}
+
 class OutputTransform {
 public:
     OutputTransform() : doResize(false), scaleFactor(1) {}
@@ -240,7 +250,10 @@ class InputTransform {
         if (reverseInputChannels) {
             cv::cvtColor(result, result, cv::COLOR_BGR2RGB);
         }
-        return (result - means) / stdScales;
+        // TODO: merge the two following lines after OpenCV3 is droppped
+        result -= means;
+        result /= cv::Mat{stdScales};
+        return result;
     }
 
 private:
@@ -260,7 +273,7 @@ class LazyVideoWriter {
 
     LazyVideoWriter(const std::string& filenames, double fps, unsigned lim) :
         nwritten{1}, filenames{filenames}, fps{fps}, lim{lim} {}
-    void write(cv::InputArray im) {
+    void write(const cv::Mat& im) {
         if (writer.isOpened() && (nwritten < lim || 0 == lim)) {
             writer.write(im);
             ++nwritten;
diff --git a/demos/crossroad_camera_demo/cpp/main.cpp b/demos/crossroad_camera_demo/cpp/main.cpp
@@ -179,9 +179,9 @@ int main(int argc, char* argv[]) {
 
                             bc_rect = bc_rect & person_rect;
 
-                            if (!tc_rect.empty())
+                            if (!isRectEmpty(tc_rect))
                                 resPersAttrAndColor.top_color = PersonAttribsDetection::GetAvgColor(person(tc_rect));
-                            if (!bc_rect.empty())
+                            if (!isRectEmpty(bc_rect))
                                 resPersAttrAndColor.bottom_color = PersonAttribsDetection::GetAvgColor(person(bc_rect));
                         }
                     }
diff --git a/demos/mri_reconstruction_demo/cpp/main.cpp b/demos/mri_reconstruction_demo/cpp/main.cpp
@@ -91,7 +91,9 @@ int main(int argc, char** argv) {
         cv::Mat kspace = cv::Mat(height, width, CV_64FC2, mri.data.ptr<double>(i)).clone();
 
         kspace.setTo(0, mri.samplingMask);
-        kspace = (kspace - cv::Scalar(mri.stats[0], mri.stats[0])) / cv::Scalar(mri.stats[1], mri.stats[1]);
+        // TODO: merge the two following lines after OpenCV3 is droppped
+        kspace -= cv::Scalar(mri.stats[0], mri.stats[0]);
+        kspace /= cv::Mat{cv::Scalar(mri.stats[1], mri.stats[1])};
         kspace.reshape(1, 1).convertTo(inputBlob.reshape(1, 1), CV_32F);
         // Forward pass
         infReq.infer();
@@ -145,18 +147,18 @@ void callback(int sliceId, void* userdata) {
     cv::hconcat(std::vector<cv::Mat>({img, masked, rec}), render);
     cv::copyMakeBorder(render, render, kBorderSize, 0, 0, 0, cv::BORDER_CONSTANT, 255);
     cv::putText(render, "Original", cv::Point(0, 15), cv::FONT_HERSHEY_SIMPLEX, 0.5, 0);
-    cv::putText(render, cv::format("Sampled (PSNR %.1f)", cv::PSNR(img, masked, 255)),
+    cv::putText(render, cv::format("Sampled (PSNR %.1f)", cv::PSNR(img, masked)),
                 cv::Point(width, 15), cv::FONT_HERSHEY_SIMPLEX, 0.5, 0);
-    cv::putText(render, cv::format("Reconstructed (PSNR %.1f)", cv::PSNR(img, rec, 255)),
+    cv::putText(render, cv::format("Reconstructed (PSNR %.1f)", cv::PSNR(img, rec)),
                 cv::Point(width*2, 15), cv::FONT_HERSHEY_SIMPLEX, 0.5, 0);
 
     cv::imshow(kWinName, render);
     cv::waitKey(1);
 }
 
 cv::Mat kspaceToImage(const cv::Mat& kspace) {
-    CV_CheckEQ(kspace.dims, 2, "");
-    CV_CheckEQ(kspace.channels(), 2, "");
+    assert(kspace.dims == 2);
+    assert(kspace.channels() == 2);
 
     cv::Mat img;
 
diff --git a/demos/pedestrian_tracker_demo/cpp/include/cnn.hpp b/demos/pedestrian_tracker_demo/cpp/include/cnn.hpp
@@ -85,10 +85,9 @@ class VectorCNN : public BaseModel {
 public:
     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) 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) const;
 
     int size() const {
         return result_size;
diff --git a/demos/pedestrian_tracker_demo/cpp/src/cnn.cpp b/demos/pedestrian_tracker_demo/cpp/src/cnn.cpp
@@ -86,18 +86,18 @@ VectorCNN::VectorCNN(const Config& config, const ov::Core& core, const std::stri
     result_size = std::accumulate(std::next(output_shape.begin(), 1), output_shape.end(), 1, std::multiplies<int>());
 }
 
-void VectorCNN::Compute(const cv::Mat& frame, cv::Mat* vector, cv::Size out_shape) const {
+void VectorCNN::Compute(const cv::Mat& frame, cv::Mat* vector) const {
     std::vector<cv::Mat> output;
-    Compute({frame}, &output, out_shape);
+    Compute({frame}, &output);
     *vector = output[0];
 }
 
-void VectorCNN::Compute(const std::vector<cv::Mat>& images, std::vector<cv::Mat>* vectors, cv::Size out_shape) const {
+void VectorCNN::Compute(const std::vector<cv::Mat>& images, std::vector<cv::Mat>* vectors) const {
     if (images.empty()) {
         return;
     }
     vectors->clear();
-    auto results_fetcher = [vectors, out_shape](const ov::Tensor& tensor, size_t batch_size) {
+    auto results_fetcher = [vectors](const ov::Tensor& tensor, size_t batch_size) {
         ov::Shape shape = tensor.get_shape();
         std::vector<int> tensor_sizes(shape.size(), 0);
         for (size_t i = 0; i < tensor_sizes.size(); ++i) {
@@ -110,9 +110,6 @@ void VectorCNN::Compute(const std::vector<cv::Mat>& images, std::vector<cv::Mat>
                                    CV_32F,
                                    reinterpret_cast<void*>((out_tensor.ptr<float>(0) + b * out_tensor.size[1])));
             vectors->emplace_back();
-            if (out_shape != cv::Size()) {
-                tensor_wrapper = tensor_wrapper.reshape(1, {out_shape.height, out_shape.width});
-            }
             tensor_wrapper.copyTo(vectors->back());
         }
     };
diff --git a/demos/pedestrian_tracker_demo/cpp/src/tracker.cpp b/demos/pedestrian_tracker_demo/cpp/src/tracker.cpp
@@ -337,7 +337,7 @@ bool PedestrianTracker::EraseTrackIfBBoxIsOutOfFrame(size_t track_id) {
     if (tracks_.find(track_id) == tracks_.end())
         return true;
     auto c = Center(tracks_.at(track_id).predicted_rect);
-    if (!prev_frame_size_.empty() &&
+    if (!isSizeEmpty(prev_frame_size_) &&
         (c.x < 0 || c.y < 0 || c.x > prev_frame_size_.width || c.y > prev_frame_size_.height)) {
         tracks_.at(track_id).lost = params_.forget_delay + 1;
         for (auto id : active_track_ids()) {
diff --git a/demos/segmentation_demo/cpp/main.cpp b/demos/segmentation_demo/cpp/main.cpp
@@ -143,13 +143,67 @@ bool ParseAndCheckCommandLine(int argc, char* argv[]) {
     return true;
 }
 
-static const Color PASCAL_VOC_COLORS[] = {
-    {0, 0, 0},       {128, 0, 0},     {0, 128, 0}, {128, 128, 0}, {0, 0, 128},   {128, 0, 128}, {0, 128, 128},
-    {128, 128, 128}, {64, 0, 0},      {192, 0, 0}, {64, 128, 0},  {192, 128, 0}, {64, 0, 128},  {192, 0, 128},
-    {64, 128, 128},  {192, 128, 128}, {0, 64, 0},  {128, 64, 0},  {0, 192, 0},   {128, 192, 0}, {0, 64, 128}};
+// TODO: replace with cv::applyColorMap() after OpenCV3 is dropped
+class ParallelLoopBodyLambda : public cv::ParallelLoopBody {
+    std::function<void(const cv::Range &)> f;
+public:
+    explicit ParallelLoopBodyLambda(std::function<void(const cv::Range &)> f): f{f} {}
+    void operator()(const cv::Range& range) const override {f(range);}
+};
+
+void applyColorMapOpenCV(const cv::Mat& src, cv::Mat& dstMat, const cv::Mat& _lut) {
+    const int lut_type = _lut.type();
+
+    cv::Mat srcGray;
+    if (src.channels() == 1)
+        srcGray = src;
+    else
+        cv::cvtColor(src, srcGray, cv::COLOR_BGR2GRAY);//BGR because of historical cv::LUT() usage
+
+    dstMat.create(src.size(), lut_type);
+
+    //we do not use cv::LUT() which requires src.channels() == dst.channels()
+    const int rows = srcGray.rows;
+    const int cols = srcGray.cols;
+    const int minimalPixelsPerPacket = 1<<12;
+    const int rowsPerPacket = std::max(1, minimalPixelsPerPacket/cols);
+    const int rowsPacketsCount = (rows+rowsPerPacket-1)/rowsPerPacket;
+    const cv::Range all(0, rows);
+
+    if (lut_type == CV_8UC1) {
+        typedef unsigned char lut_pixel_t;
+        const lut_pixel_t* srcLUT = _lut.ptr<lut_pixel_t>(0);
+        ParallelLoopBodyLambda body([&, cols](const cv::Range& range) -> void {
+            for(int row = range.start ; row<range.end ; ++row)  {
+                const unsigned char* srcRow = srcGray.ptr<unsigned char>(row);
+                lut_pixel_t* dstRow = dstMat.ptr<lut_pixel_t>(row);
+                for(int col = 0 ; col<cols ; ++col)
+                    *dstRow++ = srcLUT[*srcRow++];
+            }
+        });
+        cv::parallel_for_(all, body, rowsPacketsCount);
+    }
+    else if (lut_type == CV_8UC3) {
+        typedef cv::Vec3b lut_pixel_t;
+        const lut_pixel_t* srcLUT = _lut.ptr<lut_pixel_t>(0);
+        ParallelLoopBodyLambda body([&, cols](const cv::Range& range) -> void {
+            for(int row = range.start ; row<range.end ; ++row)  {
+                const unsigned char* srcRow = srcGray.ptr<unsigned char>(row);
+                lut_pixel_t* dstRow = dstMat.ptr<lut_pixel_t>(row);
+                for(int col = 0 ; col<cols ; ++col)
+                    *dstRow++ = srcLUT[*srcRow++];
+            }
+        });
+        cv::parallel_for_(all, body, rowsPacketsCount);
+    }
+}
 
 cv::Mat applyColorMap(cv::Mat input) {
     // Initializing colors array if needed
+    static const Color PASCAL_VOC_COLORS[] = {
+        {0, 0, 0},       {128, 0, 0},     {0, 128, 0}, {128, 128, 0}, {0, 0, 128},   {128, 0, 128}, {0, 128, 128},
+        {128, 128, 128}, {64, 0, 0},      {192, 0, 0}, {64, 128, 0},  {192, 128, 0}, {64, 0, 128},  {192, 0, 128},
+        {64, 128, 128},  {192, 128, 128}, {0, 64, 0},  {128, 64, 0},  {0, 192, 0},   {128, 192, 0}, {0, 64, 128}};
     static cv::Mat colors;
     static std::mt19937 rng;
     static std::uniform_int_distribution<int> distr(0, 255);
@@ -169,7 +223,7 @@ cv::Mat applyColorMap(cv::Mat input) {
 
     // Converting class to color
     cv::Mat out;
-    cv::applyColorMap(input, out, colors);
+    applyColorMapOpenCV(input, out, colors);
     return out;
 }
 
diff --git a/demos/smart_classroom_demo/cpp/src/cnn.cpp b/demos/smart_classroom_demo/cpp/src/cnn.cpp
@@ -129,8 +129,8 @@ void VectorCNN::Compute(const std::vector<cv::Mat>& images, std::vector<cv::Mat>
                 cv::Mat tensor_wrapper(out_tensor.size[1], 1, CV_32F,
                                      reinterpret_cast<void*>((out_tensor.ptr<float>(0) + b * out_tensor.size[1])));
                 vectors->emplace_back();
-                if (outp_shape != cv::Size())
-                    tensor_wrapper = tensor_wrapper.reshape(1, {outp_shape.height, outp_shape.width});
+                if (!isSizeEmpty(outp_shape))
+                    tensor_wrapper = tensor_wrapper.reshape(1, outp_shape.height);
                 tensor_wrapper.copyTo(vectors->back());
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ void Presenter::handleKey(int key) {`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`
`120`		`-void Presenter::drawGraphs(const cv::Mat& frame) {`
	`120`	`+void Presenter::drawGraphs(cv::Mat& frame) {`
`121`	`121`	`const std::chrono::steady_clock::time_point curTimeStamp = std::chrono::steady_clock::now();`
`122`	`122`	`if (curTimeStamp - prevTimeStamp >= std::chrono::milliseconds{1000}) {`
`123`	`123`	`prevTimeStamp = curTimeStamp;`
Original file line number	Diff line number	Diff line change
`@@ -179,9 +179,9 @@ int main(int argc, char* argv[]) {`
`179`	`179`
`180`	`180`	`bc_rect = bc_rect & person_rect;`
`181`	`181`
`182`		`- if (!tc_rect.empty())`
	`182`	`+ if (!isRectEmpty(tc_rect))`
`183`	`183`	`resPersAttrAndColor.top_color = PersonAttribsDetection::GetAvgColor(person(tc_rect));`
`184`		`- if (!bc_rect.empty())`
	`184`	`+ if (!isRectEmpty(bc_rect))`
`185`	`185`	`resPersAttrAndColor.bottom_color = PersonAttribsDetection::GetAvgColor(person(bc_rect));`
`186`	`186`	`}`
`187`	`187`	`}`