Merge pull request #3418 from ivikhrev/style-fix

Fix code style for gapi demos

Author: Wovchena

demos/background_subtraction_demo/cpp_gapi/background_subtraction_demo_gapi.hpp

@@ -4,8 +4,10 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma once
+#include <iostream>
 
 #include <gflags/gflags.h>
+
 #include <utils/default_flags.hpp>
 
 DEFINE_INPUT_FLAGS
@@ -15,17 +17,21 @@ static const char help_message[] = "Print a usage message.";
 static const char camera_resolution_message[] = "Optional. Set camera resolution in format WxH.";
 static const char at_message[] = "Required. Architecture type: maskrcnn, background-matting.";
 static const char model_message[] = "Required. Path to an .xml file with a trained model.";
-static const char kernel_package_message[] = "Optional. G-API kernel package type: opencv, fluid (by default opencv is used).";
-static const char device_message[] = "Optional. Target device for network (the list of available devices is shown below). "
-                                            "The demo will look for a suitable plugin for a specified device. Default value is \"CPU\".";
-static const char nireq_message[] = "Optional. Number of infer requests. If this option is omitted, number of infer requests is determined automatically.";
+static const char kernel_package_message[] =
+    "Optional. G-API kernel package type: opencv, fluid (by default opencv is used).";
+static const char device_message[] =
+    "Optional. Target device for network (the list of available devices is shown below). "
+    "The demo will look for a suitable plugin for a specified device. Default value is \"CPU\".";
+static const char nireq_message[] = "Optional. Number of infer requests. If this option is omitted, number of infer "
+                                    "requests is determined automatically.";
 static const char num_threads_message[] = "Optional. Number of threads.";
 static const char num_streams_message[] = "Optional. Number of streams to use for inference on the CPU or/and GPU in "
-"throughput mode (for HETERO and MULTI device cases use format "
-"<device1>:<nstreams1>,<device2>:<nstreams2> or just <nstreams>)";
+                                          "throughput mode (for HETERO and MULTI device cases use format "
+                                          "<device1>:<nstreams1>,<device2>:<nstreams2> or just <nstreams>)";
 static const char no_show_message[] = "Optional. Don't show output.";
 static const char blur_bgr_message[] = "Optional. Blur background.";
-static const char target_bgr_message[] = "Optional. Background onto which to composite the output (by default to green field).";
+static const char target_bgr_message[] =
+    "Optional. Background onto which to composite the output (by default to green field).";
 static const char utilization_monitors_message[] = "Optional. List of monitors to show initially.";
 
 DEFINE_bool(h, false, help_message);
@@ -43,8 +49,8 @@ DEFINE_uint32(blur_bgr, 0, blur_bgr_message);
 DEFINE_string(u, "", utilization_monitors_message);
 
 /**
-* \brief This function shows a help message
-*/
+ * \brief This function shows a help message
+ */
 
 static void showUsage() {
     std::cout << std::endl;

demos/background_subtraction_demo/cpp_gapi/include/custom_kernels.hpp

@@ -4,14 +4,21 @@
 
 #pragma once
 
-#include <opencv2/gapi/gkernel.hpp>
-#include <opencv2/gapi/infer/ie.hpp>
+#include <string>
+#include <vector>
 
-#include <inference_engine.hpp>
+#include <cpp/ie_cnn_network.h>
+#include <ie_allocator.hpp>
+#include <ie_common.h>
+#include <ie_input_info.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/gmat.hpp>
 
 namespace IE = InferenceEngine;
 
 namespace custom {
+// clang-format off
 G_API_OP(GTensorToImg, <cv::GMat(cv::GMat)>, "custom.tensorToImg") {
     static cv::GMatDesc outMeta(const cv::GMatDesc& in) {
         // NB: Input is ND mat.
@@ -30,19 +37,21 @@ G_API_OP(GCalculateMaskRCNNBGMask,
         return cv::GMatDesc{CV_8U, 1, in_sz};
     }
 };
-
+// clang-format on
 class NNBGReplacer {
 public:
     NNBGReplacer() = default;
     virtual ~NNBGReplacer() = default;
     NNBGReplacer(const std::string& model_path);
     virtual cv::GMat replace(cv::GMat, const cv::Size&, cv::GMat) = 0;
-    const std::string& getName() { return m_tag; }
+    const std::string& getName() {
+        return m_tag;
+    }
 
 protected:
-    IE::CNNNetwork     m_cnn_network;
-    std::string        m_tag;
-    IE::InputsDataMap  m_inputs;
+    IE::CNNNetwork m_cnn_network;
+    std::string m_tag;
+    IE::InputsDataMap m_inputs;
     IE::OutputsDataMap m_outputs;
 };
 
@@ -70,4 +79,4 @@ class BGMattingReplacer : public NNBGReplacer {
 
 cv::gapi::GKernelPackage kernels();
 
-} // namespace custom
+}  // namespace custom

demos/background_subtraction_demo/cpp_gapi/main.cpp

@@ -2,34 +2,58 @@
 // SPDX-License-Identifier: Apache-2.0
 //
 
+#include <stddef.h>
+
+#include <algorithm>
 #include <chrono>
+#include <exception>
+#include <iomanip>
+#include <limits>
+#include <memory>
+#include <stdexcept>
 #include <string>
+#include <utility>
 #include <vector>
 
-#include <opencv2/gapi/streaming/cap.hpp>
-#include <opencv2/gapi/imgproc.hpp>
+#include <gflags/gflags.h>
+#include <opencv2/core.hpp>
 #include <opencv2/gapi/core.hpp>
-
-#include <opencv2/gapi/fluid/core.hpp>
-#include <opencv2/gapi/fluid/imgproc.hpp>
 #include <opencv2/gapi/cpu/core.hpp>
 #include <opencv2/gapi/cpu/imgproc.hpp>
+#include <opencv2/gapi/fluid/core.hpp>
+#include <opencv2/gapi/fluid/imgproc.hpp>
+#include <opencv2/gapi/garg.hpp>
+#include <opencv2/gapi/gcommon.hpp>
+#include <opencv2/gapi/gcomputation.hpp>
+#include <opencv2/gapi/gkernel.hpp>
+#include <opencv2/gapi/gmat.hpp>
+#include <opencv2/gapi/gproto.hpp>
+#include <opencv2/gapi/gstreaming.hpp>
+#include <opencv2/gapi/imgproc.hpp>
+#include <opencv2/gapi/infer.hpp>
+#include <opencv2/gapi/infer/ie.hpp>
+#include <opencv2/gapi/own/assert.hpp>
+#include <opencv2/gapi/streaming/source.hpp>
+#include <opencv2/gapi/util/optional.hpp>
 #include <opencv2/highgui.hpp>
-
+#include <opencv2/imgproc.hpp>
 #include <openvino/openvino.hpp>
 
 #include <monitors/presenter.h>
-#include <utils_gapi/stream_source.hpp>
 #include <utils/args_helper.hpp>
+#include <utils/common.hpp>
 #include <utils/config_factory.h>
+#include <utils/images_capture.h>
 #include <utils/ocv_common.hpp>
+#include <utils/performance_metrics.hpp>
+#include <utils/slog.hpp>
+#include <utils_gapi/stream_source.hpp>
 
 #include "background_subtraction_demo_gapi.hpp"
 #include "custom_kernels.hpp"
 
-
 namespace util {
-bool ParseAndCheckCommandLine(int argc, char *argv[]) {
+bool ParseAndCheckCommandLine(int argc, char* argv[]) {
     /** ---------- Parsing and validating input arguments ----------**/
     gflags::ParseCommandLineNonHelpFlags(&argc, &argv, true);
     if (FLAGS_h) {
@@ -49,20 +73,18 @@ bool ParseAndCheckCommandLine(int argc, char *argv[]) {
 
 static cv::gapi::GKernelPackage getKernelPackage(const std::string& type) {
     if (type == "opencv") {
-        return cv::gapi::combine(cv::gapi::core::cpu::kernels(),
-                                 cv::gapi::imgproc::cpu::kernels());
+        return cv::gapi::combine(cv::gapi::core::cpu::kernels(), cv::gapi::imgproc::cpu::kernels());
     } else if (type == "fluid") {
-        return cv::gapi::combine(cv::gapi::core::fluid::kernels(),
-                                 cv::gapi::imgproc::fluid::kernels());
+        return cv::gapi::combine(cv::gapi::core::fluid::kernels(), cv::gapi::imgproc::fluid::kernels());
     } else {
         throw std::logic_error("Unsupported kernel package type: " + type);
     }
     GAPI_Assert(false && "Unreachable code!");
 }
 
-} // namespace util
+}  // namespace util
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     try {
         PerformanceMetrics metrics;
 
@@ -87,12 +109,16 @@ int main(int argc, char *argv[]) {
         }
 
         /** Get information about frame **/
-        std::shared_ptr<ImagesCapture> cap = openImagesCapture(FLAGS_i, FLAGS_loop, read_type::safe, 0,
-            std::numeric_limits<size_t>::max(), stringToSize(FLAGS_res));
+        std::shared_ptr<ImagesCapture> cap = openImagesCapture(FLAGS_i,
+                                                               FLAGS_loop,
+                                                               read_type::safe,
+                                                               0,
+                                                               std::numeric_limits<size_t>::max(),
+                                                               stringToSize(FLAGS_res));
         const auto tmp = cap->read();
         cv::Size frame_size = cv::Size{tmp.cols, tmp.rows};
 
-        cv::GComputation comp([&]{
+        cv::GComputation comp([&] {
             cv::GMat in;
             // NB: target_bgr is optional second input which implies a background
             // that will change user video background. If user don't specify
@@ -108,9 +134,8 @@ int main(int argc, char *argv[]) {
                 bgr_resized = cv::gapi::resize(target_bgr.value(), frame_size);
             }
 
-            auto background = is_blur
-                ? cv::gapi::blur(bgr_resized, cv::Size(FLAGS_blur_bgr, FLAGS_blur_bgr))
-                : bgr_resized;
+            auto background =
+                is_blur ? cv::gapi::blur(bgr_resized, cv::Size(FLAGS_blur_bgr, FLAGS_blur_bgr)) : bgr_resized;
 
             auto result = model->replace(in, frame_size, background);
 
@@ -123,35 +148,41 @@ int main(int argc, char *argv[]) {
         });
 
         /** Configure network **/
-        auto config = ConfigFactory::getUserConfig(FLAGS_d, FLAGS_nireq,
-                                                   FLAGS_nstreams, FLAGS_nthreads);
-        const auto net = cv::gapi::ie::Params<cv::gapi::Generic> {
-            model->getName(),
-            FLAGS_m,                           // path to topology IR
-            fileNameNoExt(FLAGS_m) + ".bin",   // path to weights
-            FLAGS_d                            // device specifier
-        }.cfgNumRequests(config.maxAsyncRequests)
-         .pluginConfig(config.getLegacyConfig());
-        slog::info << "The background matting model " << FLAGS_m << " is loaded to " << FLAGS_d << " device." << slog::endl;
-
-        auto kernels = cv::gapi::combine(custom::kernels(),
-                                         util::getKernelPackage(FLAGS_kernel_package));
-        auto pipeline = comp.compileStreaming(cv::compile_args(kernels,
-                                                               cv::gapi::networks(net)));
+        auto config = ConfigFactory::getUserConfig(FLAGS_d, FLAGS_nireq, FLAGS_nstreams, FLAGS_nthreads);
+        // clang-format off
+        const auto net =
+            cv::gapi::ie::Params<cv::gapi::Generic>{
+                model->getName(),
+                FLAGS_m,  // path to topology IR
+                fileNameNoExt(FLAGS_m) + ".bin",  // path to weights
+                FLAGS_d  // device specifier
+            }.cfgNumRequests(config.maxAsyncRequests)
+             .pluginConfig(config.getLegacyConfig());
+        // clang-format on
+
+        slog::info << "The background matting model " << FLAGS_m << " is loaded to " << FLAGS_d << " device."
+                   << slog::endl;
+
+        auto kernels = cv::gapi::combine(custom::kernels(), util::getKernelPackage(FLAGS_kernel_package));
+        auto pipeline = comp.compileStreaming(cv::compile_args(kernels, cv::gapi::networks(net)));
 
         /** Output container for result **/
         cv::Mat output;
 
         /** ---------------- The execution part ---------------- **/
-        cap = openImagesCapture(FLAGS_i, FLAGS_loop, read_type::safe, 0,
-            std::numeric_limits<size_t>::max(), stringToSize(FLAGS_res));
+        cap = openImagesCapture(FLAGS_i,
+                                FLAGS_loop,
+                                read_type::safe,
+                                0,
+                                std::numeric_limits<size_t>::max(),
+                                stringToSize(FLAGS_res));
         auto pipeline_inputs = cv::gin(cv::gapi::wip::make_src<custom::CommonCapSrc>(cap));
         if (!is_blur && FLAGS_target_bgr.empty()) {
             cv::Scalar default_color(155, 255, 120);
             pipeline_inputs += cv::gin(cv::Mat(frame_size, CV_8UC3, default_color));
         } else if (!FLAGS_target_bgr.empty()) {
-            std::shared_ptr<ImagesCapture> target_bgr_cap = openImagesCapture(FLAGS_target_bgr, true, read_type::safe, 0,
-                std::numeric_limits<size_t>::max());
+            std::shared_ptr<ImagesCapture> target_bgr_cap =
+                openImagesCapture(FLAGS_target_bgr, true, read_type::safe, 0, std::numeric_limits<size_t>::max());
             pipeline_inputs += cv::gin(cv::gapi::wip::make_src<custom::CommonCapSrc>(target_bgr_cap));
         }
 
@@ -168,16 +199,27 @@ int main(int argc, char *argv[]) {
         const auto startTime = std::chrono::steady_clock::now();
         pipeline.start();
 
-        while(pipeline.pull(cv::gout(output))) {
+        while (pipeline.pull(cv::gout(output))) {
             presenter.drawGraphs(output);
             if (isStart) {
-                metrics.update(startTime, output, { 10, 22 }, cv::FONT_HERSHEY_COMPLEX,
-                    0.65, { 200, 10, 10 }, 2, PerformanceMetrics::MetricTypes::FPS);
+                metrics.update(startTime,
+                               output,
+                               {10, 22},
+                               cv::FONT_HERSHEY_COMPLEX,
+                               0.65,
+                               {200, 10, 10},
+                               2,
+                               PerformanceMetrics::MetricTypes::FPS);
                 isStart = false;
-            }
-            else {
-                metrics.update({}, output, { 10, 22 }, cv::FONT_HERSHEY_COMPLEX,
-                    0.65, { 200, 10, 10 }, 2, PerformanceMetrics::MetricTypes::FPS);
+            } else {
+                metrics.update({},
+                               output,
+                               {10, 22},
+                               cv::FONT_HERSHEY_COMPLEX,
+                               0.65,
+                               {200, 10, 10},
+                               2,
+                               PerformanceMetrics::MetricTypes::FPS);
             }
 
             videoWriter.write(output);
@@ -196,12 +238,10 @@ int main(int argc, char *argv[]) {
         slog::info << "Metrics report:" << slog::endl;
         slog::info << "\tFPS: " << std::fixed << std::setprecision(1) << metrics.getTotal().fps << slog::endl;
         slog::info << presenter.reportMeans() << slog::endl;
-    }
-    catch (const std::exception& error) {
+    } catch (const std::exception& error) {
         slog::err << error.what() << slog::endl;
         return 1;
-    }
-    catch (...) {
+    } catch (...) {
         slog::err << "Unknown/internal exception happened." << slog::endl;
         return 1;
     }