use google style

deploy/cpp/demo/classifier.cpp

@@ -13,18 +13,18 @@
 // limitations under the License.
 
 #include <glog/logging.h>
+#include <omp.h>
 
 #include <algorithm>
-#include <chrono>
+#include <chrono>  // NOLINT
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <utility>
-#include <omp.h>
 #include "include/paddlex/paddlex.h"
 
-using namespace std::chrono;
+using namespace std::chrono;  // NOLINT
 
 DEFINE_string(model_dir, "", "Path of inference model");
 DEFINE_bool(use_gpu, false, "Infering with GPU or CPU");
@@ -34,7 +34,9 @@ DEFINE_string(key, "", "key of encryption");
 DEFINE_string(image, "", "Path of test image file");
 DEFINE_string(image_list, "", "Path of test image list file");
 DEFINE_int32(batch_size, 1, "Batch size of infering");
-DEFINE_int32(thread_num, omp_get_num_procs(), "Number of preprocessing threads");
+DEFINE_int32(thread_num,
+             omp_get_num_procs(),
+             "Number of preprocessing threads");
 
 int main(int argc, char** argv) {
   // Parsing command-line
@@ -51,7 +53,12 @@ int main(int argc, char** argv) {
 
   // 加载模型
   PaddleX::Model model;
-  model.Init(FLAGS_model_dir, FLAGS_use_gpu, FLAGS_use_trt, FLAGS_gpu_id, FLAGS_key, FLAGS_batch_size);
+  model.Init(FLAGS_model_dir,
+             FLAGS_use_gpu,
+             FLAGS_use_trt,
+             FLAGS_gpu_id,
+             FLAGS_key,
+             FLAGS_batch_size);
 
   // 进行预测
   double total_running_time_s = 0.0;
@@ -70,27 +77,33 @@ int main(int argc, char** argv) {
       image_paths.push_back(image_path);
     }
     imgs = image_paths.size();
-    for(int i = 0; i < image_paths.size(); i += FLAGS_batch_size) {
+    for (int i = 0; i < image_paths.size(); i += FLAGS_batch_size) {
       auto start = system_clock::now();
       // 读图像
-      int im_vec_size = std::min((int)image_paths.size(), i + FLAGS_batch_size);      
+      int im_vec_size =
+          std::min(static_cat<int>(image_paths.size()), i + FLAGS_batch_size);
       std::vector<cv::Mat> im_vec(im_vec_size - i);
-      std::vector<PaddleX::ClsResult> results(im_vec_size - i, PaddleX::ClsResult());
+      std::vector<PaddleX::ClsResult> results(im_vec_size - i,
+                                              PaddleX::ClsResult());
       int thread_num = std::min(FLAGS_thread_num, im_vec_size - i);
       #pragma omp parallel for num_threads(thread_num)
-      for(int j = i; j < im_vec_size; ++j){
+      for (int j = i; j < im_vec_size; ++j) {
         im_vec[j - i] = std::move(cv::imread(image_paths[j], 1));
       }
       auto imread_end = system_clock::now();
-      model.predict(im_vec, results, thread_num);
+      model.predict(im_vec, &results, thread_num);
 
       auto imread_duration = duration_cast<microseconds>(imread_end - start);
-      total_imread_time_s += double(imread_duration.count()) * microseconds::period::num / microseconds::period::den;
+      total_imread_time_s += static_cast<double>(imread_duration.count()) *
+                             microseconds::period::num /
+                             microseconds::period::den;
 
       auto end = system_clock::now();
       auto duration = duration_cast<microseconds>(end - start);
-      total_running_time_s += double(duration.count()) * microseconds::period::num / microseconds::period::den;
-      for(int j = i; j < im_vec_size; ++j) {
+      total_running_time_s += static_cast<double>(duration.count()) *
+                              microseconds::period::num /
+                              microseconds::period::den;
+      for (int j = i; j < im_vec_size; ++j) {
         std::cout << "Path:" << image_paths[j]
                   << ", predict label: " << results[j - i].category
                   << ", label_id:" << results[j - i].category_id
@@ -104,21 +117,17 @@ int main(int argc, char** argv) {
     model.predict(im, &result);
     auto end = system_clock::now();
     auto duration = duration_cast<microseconds>(end - start);
-    total_running_time_s += double(duration.count()) * microseconds::period::num / microseconds::period::den;
+    total_running_time_s += static_cast<double>(duration.count()) *
+                            microseconds::period::num /
+                            microseconds::period::den;
     std::cout << "Predict label: " << result.category
               << ", label_id:" << result.category_id
               << ", score: " << result.score << std::endl;
   }
-  std::cout << "Total running time: " 
-            << total_running_time_s
-            << " s, average running time: "
-            << total_running_time_s / imgs 
-            << " s/img, total read img time: " 
-            << total_imread_time_s
-            << " s, average read time: "
-            << total_imread_time_s / imgs  
-            << " s/img, batch_size = " 
-            << FLAGS_batch_size 
-            << std::endl;
+  std::cout << "Total running time: " << total_running_time_s
+            << " s, average running time: " << total_running_time_s / imgs
+            << " s/img, total read img time: " << total_imread_time_s
+            << " s, average read time: " << total_imread_time_s / imgs
+            << " s/img, batch_size = " << FLAGS_batch_size << std::endl;
   return 0;
 }

deploy/cpp/demo/detector.cpp

@@ -13,20 +13,20 @@
 // limitations under the License.
 
 #include <glog/logging.h>
+#include <omp.h>
 
 #include <algorithm>
-#include <chrono>
+#include <chrono>  // NOLINT
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <utility>
-#include <omp.h>
 
 #include "include/paddlex/paddlex.h"
 #include "include/paddlex/visualize.h"
 
-using namespace std::chrono;
+using namespace std::chrono;  // NOLINT
 
 DEFINE_string(model_dir, "", "Path of inference model");
 DEFINE_bool(use_gpu, false, "Infering with GPU or CPU");
@@ -37,8 +37,12 @@ DEFINE_string(image, "", "Path of test image file");
 DEFINE_string(image_list, "", "Path of test image list file");
 DEFINE_string(save_dir, "output", "Path to save visualized image");
 DEFINE_int32(batch_size, 1, "Batch size of infering");
-DEFINE_double(threshold, 0.5, "The minimum scores of target boxes which are shown");
-DEFINE_int32(thread_num, omp_get_num_procs(), "Number of preprocessing threads");
+DEFINE_double(threshold,
+              0.5,
+              "The minimum scores of target boxes which are shown");
+DEFINE_int32(thread_num,
+             omp_get_num_procs(),
+             "Number of preprocessing threads");
 
 int main(int argc, char** argv) {
   // 解析命令行参数
@@ -55,7 +59,12 @@ int main(int argc, char** argv) {
   std::cout << "Thread num: " << FLAGS_thread_num << std::endl;
   // 加载模型
   PaddleX::Model model;
-  model.Init(FLAGS_model_dir, FLAGS_use_gpu, FLAGS_use_trt, FLAGS_gpu_id, FLAGS_key, FLAGS_batch_size);
+  model.Init(FLAGS_model_dir,
+             FLAGS_use_gpu,
+             FLAGS_use_trt,
+             FLAGS_gpu_id,
+             FLAGS_key,
+             FLAGS_batch_size);
 
   double total_running_time_s = 0.0;
   double total_imread_time_s = 0.0;
@@ -75,41 +84,47 @@ int main(int argc, char** argv) {
       image_paths.push_back(image_path);
     }
     imgs = image_paths.size();
-    for(int i = 0; i < image_paths.size(); i += FLAGS_batch_size) {
+    for (int i = 0; i < image_paths.size(); i += FLAGS_batch_size) {
       auto start = system_clock::now();
-      int im_vec_size = std::min((int)image_paths.size(), i + FLAGS_batch_size);
+      int im_vec_size =
+          std::min(static_cast<int>(image_paths.size()), i + FLAGS_batch_size);
       std::vector<cv::Mat> im_vec(im_vec_size - i);
-      std::vector<PaddleX::DetResult> results(im_vec_size - i, PaddleX::DetResult());
+      std::vector<PaddleX::DetResult> results(im_vec_size - i,
+                                              PaddleX::DetResult());
       int thread_num = std::min(FLAGS_thread_num, im_vec_size - i);
       #pragma omp parallel for num_threads(thread_num)
-      for(int j = i; j < im_vec_size; ++j){
+      for (int j = i; j < im_vec_size; ++j) {
         im_vec[j - i] = std::move(cv::imread(image_paths[j], 1));
       }
       auto imread_end = system_clock::now();
-      model.predict(im_vec, results, thread_num);
+      model.predict(im_vec, &results, thread_num);
       auto imread_duration = duration_cast<microseconds>(imread_end - start);
-      total_imread_time_s += double(imread_duration.count()) * microseconds::period::num / microseconds::period::den;
+      total_imread_time_s += static_cast<double>(imread_duration.count()) *
+                             microseconds::period::num /
+                             microseconds::period::den;
       auto end = system_clock::now();
       auto duration = duration_cast<microseconds>(end - start);
-      total_running_time_s += double(duration.count()) * microseconds::period::num / microseconds::period::den;
-      //输出结果目标框
-      for(int j = 0; j < im_vec_size - i; ++j) {
-        for(int k = 0; k < results[j].boxes.size(); ++k) {
-          std::cout << "image file: " << image_paths[i + j] << ", ";// << std::endl;          
+      total_running_time_s += static_cast<double>(duration.count()) *
+                              microseconds::period::num /
+                              microseconds::period::den;
+      // 输出结果目标框
+      for (int j = 0; j < im_vec_size - i; ++j) {
+        for (int k = 0; k < results[j].boxes.size(); ++k) {
+          std::cout << "image file: " << image_paths[i + j] << ", ";
           std::cout << "predict label: " << results[j].boxes[k].category
                     << ", label_id:" << results[j].boxes[k].category_id
-                    << ", score: " << results[j].boxes[k].score << ", box(xmin, ymin, w, h):("
+                    << ", score: " << results[j].boxes[k].score
+                    << ", box(xmin, ymin, w, h):("
                     << results[j].boxes[k].coordinate[0] << ", "
                     << results[j].boxes[k].coordinate[1] << ", "
                     << results[j].boxes[k].coordinate[2] << ", "
                     << results[j].boxes[k].coordinate[3] << ")" << std::endl;
-          
         }
       }
       // 可视化
-      for(int j = 0; j < im_vec_size - i; ++j) {
-        cv::Mat vis_img =
-            PaddleX::Visualize(im_vec[j], results[j], model.labels, colormap, FLAGS_threshold);
+      for (int j = 0; j < im_vec_size - i; ++j) {
+        cv::Mat vis_img = PaddleX::Visualize(
+            im_vec[j], results[j], model.labels, colormap, FLAGS_threshold);
         std::string save_path =
             PaddleX::generate_save_path(FLAGS_save_dir, image_paths[i + j]);
         cv::imwrite(save_path, vis_img);
@@ -124,9 +139,9 @@ int main(int argc, char** argv) {
       std::cout << "image file: " << FLAGS_image << std::endl;
       std::cout << ", predict label: " << result.boxes[i].category
                 << ", label_id:" << result.boxes[i].category_id
-                << ", score: " << result.boxes[i].score << ", box(xmin, ymin, w, h):("
-                << result.boxes[i].coordinate[0] << ", "
-                << result.boxes[i].coordinate[1] << ", "
+                << ", score: " << result.boxes[i].score
+                << ", box(xmin, ymin, w, h):(" << result.boxes[i].coordinate[0]
+                << ", " << result.boxes[i].coordinate[1] << ", "
                 << result.boxes[i].coordinate[2] << ", "
                 << result.boxes[i].coordinate[3] << ")" << std::endl;
     }
@@ -141,17 +156,11 @@ int main(int argc, char** argv) {
     std::cout << "Visualized output saved as " << save_path << std::endl;
   }
 
-  std::cout << "Total running time: " 
-            << total_running_time_s
-            << " s, average running time: "
-            << total_running_time_s / imgs
-            << " s/img, total read img time: " 
-            << total_imread_time_s
-            << " s, average read img time: "
-            << total_imread_time_s / imgs
-            << " s, batch_size = " 
-            << FLAGS_batch_size 
-            << std::endl;
+  std::cout << "Total running time: " << total_running_time_s
+            << " s, average running time: " << total_running_time_s / imgs
+            << " s/img, total read img time: " << total_imread_time_s
+            << " s, average read img time: " << total_imread_time_s / imgs
+            << " s, batch_size = " << FLAGS_batch_size << std::endl;
 
   return 0;
 }

deploy/cpp/demo/segmenter.cpp

@@ -13,19 +13,19 @@
 // limitations under the License.
 
 #include <glog/logging.h>
+#include <omp.h>
 
 #include <algorithm>
-#include <chrono>
+#include <chrono>  // NOLINT
 #include <fstream>
 #include <iostream>
 #include <string>
 #include <vector>
 #include <utility>
-#include <omp.h>
 #include "include/paddlex/paddlex.h"
 #include "include/paddlex/visualize.h"
 
-using namespace std::chrono;
+using namespace std::chrono;  // NOLINT
 
 DEFINE_string(model_dir, "", "Path of inference model");
 DEFINE_bool(use_gpu, false, "Infering with GPU or CPU");
@@ -36,7 +36,9 @@ DEFINE_string(image, "", "Path of test image file");
 DEFINE_string(image_list, "", "Path of test image list file");
 DEFINE_string(save_dir, "output", "Path to save visualized image");
 DEFINE_int32(batch_size, 1, "Batch size of infering");
-DEFINE_int32(thread_num, omp_get_num_procs(), "Number of preprocessing threads");
+DEFINE_int32(thread_num,
+             omp_get_num_procs(),
+             "Number of preprocessing threads");
 
 int main(int argc, char** argv) {
   // 解析命令行参数
@@ -53,7 +55,12 @@ int main(int argc, char** argv) {
 
   // 加载模型
   PaddleX::Model model;
-  model.Init(FLAGS_model_dir, FLAGS_use_gpu, FLAGS_use_trt, FLAGS_gpu_id, FLAGS_key, FLAGS_batch_size);
+  model.Init(FLAGS_model_dir,
+             FLAGS_use_gpu,
+             FLAGS_use_trt,
+             FLAGS_gpu_id,
+             FLAGS_key,
+             FLAGS_batch_size);
 
   double total_running_time_s = 0.0;
   double total_imread_time_s = 0.0;
@@ -72,25 +79,31 @@ int main(int argc, char** argv) {
       image_paths.push_back(image_path);
     }
     imgs = image_paths.size();
-    for(int i = 0; i < image_paths.size(); i += FLAGS_batch_size){
+    for (int i = 0; i < image_paths.size(); i += FLAGS_batch_size) {
       auto start = system_clock::now();
-      int im_vec_size = std::min((int)image_paths.size(), i + FLAGS_batch_size);
+      int im_vec_size =
+          std::min(static_cast<int>(image_paths.size()), i + FLAGS_batch_size);
       std::vector<cv::Mat> im_vec(im_vec_size - i);
-      std::vector<PaddleX::SegResult> results(im_vec_size - i, PaddleX::SegResult());
+      std::vector<PaddleX::SegResult> results(im_vec_size - i,
+                                              PaddleX::SegResult());
       int thread_num = std::min(FLAGS_thread_num, im_vec_size - i);
       #pragma omp parallel for num_threads(thread_num)
-      for(int j = i; j < im_vec_size; ++j){
+      for (int j = i; j < im_vec_size; ++j) {
         im_vec[j - i] = std::move(cv::imread(image_paths[j], 1));
       }
       auto imread_end = system_clock::now();
-      model.predict(im_vec, results, thread_num);
+      model.predict(im_vec, &results, thread_num);
       auto imread_duration = duration_cast<microseconds>(imread_end - start);
-      total_imread_time_s += double(imread_duration.count()) * microseconds::period::num / microseconds::period::den;
+      total_imread_time_s += static_cast<double>(imread_duration.count()) *
+                             microseconds::period::num /
+                             microseconds::period::den;
       auto end = system_clock::now();
       auto duration = duration_cast<microseconds>(end - start);
-      total_running_time_s += double(duration.count()) * microseconds::period::num / microseconds::period::den;
+      total_running_time_s += static_cast<double>(duration.count()) *
+                              microseconds::period::num /
+                              microseconds::period::den;
       // 可视化
-      for(int j = 0; j < im_vec_size - i; ++j) {
+      for (int j = 0; j < im_vec_size - i; ++j) {
         cv::Mat vis_img =
             PaddleX::Visualize(im_vec[j], results[j], model.labels, colormap);
         std::string save_path =
@@ -106,7 +119,9 @@ int main(int argc, char** argv) {
     model.predict(im, &result);
     auto end = system_clock::now();
     auto duration = duration_cast<microseconds>(end - start);
-    total_running_time_s += double(duration.count()) * microseconds::period::num / microseconds::period::den;
+    total_running_time_s += static_cast<double>(duration.count()) *
+                            microseconds::period::num /
+                            microseconds::period::den;
     // 可视化
     cv::Mat vis_img = PaddleX::Visualize(im, result, model.labels, colormap);
     std::string save_path =
@@ -115,17 +130,11 @@ int main(int argc, char** argv) {
     result.clear();
     std::cout << "Visualized output saved as " << save_path << std::endl;
   }
-  std::cout << "Total running time: " 
-            << total_running_time_s
-            << " s, average running time: "
-            << total_running_time_s / imgs
-            << " s/img, total read img time: " 
-            << total_imread_time_s
-            << " s, average read img time: "
-            << total_imread_time_s / imgs
-            << " s, batch_size = " 
-            << FLAGS_batch_size
-            << std::endl;
+  std::cout << "Total running time: " << total_running_time_s
+            << " s, average running time: " << total_running_time_s / imgs
+            << " s/img, total read img time: " << total_imread_time_s
+            << " s, average read img time: " << total_imread_time_s / imgs
+            << " s, batch_size = " << FLAGS_batch_size << std::endl;
 
   return 0;
 }

deploy/cpp/include/paddlex/config_parser.h

@@ -54,4 +54,4 @@ class ConfigPaser {
   YAML::Node Transforms_;
 };
 
-}  // namespace PaddleDetection
+}  // namespace PaddleX

deploy/cpp/include/paddlex/paddlex.h

@@ -16,8 +16,11 @@
 
 #include <functional>
 #include <iostream>
+#include <map>
+#include <memory>
 #include <numeric>
-
+#include <string>
+#include <vector>
 #include "yaml-cpp/yaml.h"
 
 #ifdef _WIN32
@@ -28,13 +31,13 @@
 
 #include "paddle_inference_api.h"  // NOLINT
 
-#include "config_parser.h"
-#include "results.h"
-#include "transforms.h"
+#include "config_parser.h"  // NOLINT
+#include "results.h"  // NOLINT
+#include "transforms.h"  // NOLINT
 
 #ifdef WITH_ENCRYPTION
-#include "paddle_model_decrypt.h"
-#include "model_code.h"
+#include "paddle_model_decrypt.h"  // NOLINT
+#include "model_code.h"  // NOLINT
 #endif
 
 namespace PaddleX {
@@ -119,7 +122,9 @@ class Model {
    *                    each thread run preprocess on single image matrix
    * @return true if preprocess a batch of image matrixs successfully
    * */
-  bool preprocess(const std::vector<cv::Mat> &input_im_batch, std::vector<ImageBlob> &blob_batch, int thread_num = 1);
+  bool preprocess(const std::vector<cv::Mat> &input_im_batch,
+                  std::vector<ImageBlob> *blob_batch,
+                  int thread_num = 1);
 
   /*
    * @brief
@@ -143,7 +148,9 @@ class Model {
    *                    on single image matrix
    * @return true if predict successfully
    * */
-  bool predict(const std::vector<cv::Mat> &im_batch, std::vector<ClsResult> &results, int thread_num = 1);
+  bool predict(const std::vector<cv::Mat> &im_batch,
+               std::vector<ClsResult> *results,
+               int thread_num = 1);
 
   /*
    * @brief
@@ -167,7 +174,9 @@ class Model {
    *                    on single image matrix
    * @return true if predict successfully
    * */
-  bool predict(const std::vector<cv::Mat> &im_batch, std::vector<DetResult> &result, int thread_num = 1);
+  bool predict(const std::vector<cv::Mat> &im_batch,
+               std::vector<DetResult> *result,
+               int thread_num = 1);
 
   /*
    * @brief
@@ -191,7 +200,9 @@ class Model {
    *                    on single image matrix
    * @return true if predict successfully
    * */
-  bool predict(const std::vector<cv::Mat> &im_batch, std::vector<SegResult> &result, int thread_num = 1);
+  bool predict(const std::vector<cv::Mat> &im_batch,
+               std::vector<SegResult> *result,
+               int thread_num = 1);
 
   // model type, include 3 type: classifier, detector, segmenter
   std::string type;
@@ -209,4 +220,4 @@ class Model {
   // a predictor which run the model predicting
   std::unique_ptr<paddle::PaddlePredictor> predictor_;
 };
-}  // namespce of PaddleX
+}  // namespace PaddleX

deploy/cpp/include/paddlex/transforms.h

@@ -214,6 +214,7 @@ class Padding : public Transform {
     }
   }
   virtual bool Run(cv::Mat* im, ImageBlob* data);
+
  private:
   int coarsest_stride_ = -1;
   int width_ = 0;
@@ -229,6 +230,7 @@ class Transforms {
   void Init(const YAML::Node& node, bool to_rgb = true);
   std::shared_ptr<Transform> CreateTransform(const std::string& name);
   bool Run(cv::Mat* im, ImageBlob* data);
+
  private:
   std::vector<std::shared_ptr<Transform>> transforms_;
   bool to_rgb_ = true;

deploy/cpp/include/paddlex/visualize.h

@@ -94,4 +94,4 @@ cv::Mat Visualize(const cv::Mat& img,
  * */
 std::string generate_save_path(const std::string& save_dir,
                                const std::string& file_path);
-}  // namespce of PaddleX
+}  // namespace PaddleX

deploy/cpp/src/visualize.cpp

@@ -145,4 +145,4 @@ std::string generate_save_path(const std::string& save_dir,
   std::string image_name(file_path.substr(pos + 1));
   return save_dir + OS_PATH_SEP + image_name;
 }
-}  // namespace of PaddleX
+}  // namespace PaddleX