Merge pull request #5648 from WenmuZhou/fix_cpp_lite_android

update db postprocess params

deploy/cpp_infer/include/ocr_det.h

@@ -45,8 +45,9 @@ public:
                       const double &det_db_thresh,
                       const double &det_db_box_thresh,
                       const double &det_db_unclip_ratio,
-                      const bool &use_polygon_score, const bool &visualize,
-                      const bool &use_tensorrt, const std::string &precision) {
+                      const bool &use_polygon_score, const bool &use_dilation,
+                      const bool &visualize, const bool &use_tensorrt,
+                      const std::string &precision) {
     this->use_gpu_ = use_gpu;
     this->gpu_id_ = gpu_id;
     this->gpu_mem_ = gpu_mem;
@@ -59,6 +60,7 @@ public:
     this->det_db_box_thresh_ = det_db_box_thresh;
     this->det_db_unclip_ratio_ = det_db_unclip_ratio;
     this->use_polygon_score_ = use_polygon_score;
+    this->use_dilation_ = use_dilation;
 
     this->visualize_ = visualize;
     this->use_tensorrt_ = use_tensorrt;
@@ -71,7 +73,8 @@ public:
   void LoadModel(const std::string &model_dir);
 
   // Run predictor
-  void Run(cv::Mat &img, std::vector<std::vector<std::vector<int>>> &boxes, std::vector<double> *times);
+  void Run(cv::Mat &img, std::vector<std::vector<std::vector<int>>> &boxes,
+           std::vector<double> *times);
 
 private:
   std::shared_ptr<Predictor> predictor_;
@@ -88,6 +91,7 @@ private:
   double det_db_box_thresh_ = 0.5;
   double det_db_unclip_ratio_ = 2.0;
   bool use_polygon_score_ = false;
+  bool use_dilation_ = false;
 
   bool visualize_ = true;
   bool use_tensorrt_ = false;

deploy/cpp_infer/readme.md

@@ -4,16 +4,20 @@
 C++在性能计算上优于python，因此，在大多数CPU、GPU部署场景，多采用C++的部署方式，本节将介绍如何在Linux\Windows (CPU\GPU)环境下配置C++环境并完成
 PaddleOCR模型部署。
 
-* [1. 准备环境](#1)
-  + [1.0 运行准备](#10)
-  + [1.1 编译opencv库](#11)
-  + [1.2 下载或者编译Paddle预测库](#12)
-    - [1.2.1 直接下载安装](#121)
-    - [1.2.2 预测库源码编译](#122)
-* [2 开始运行](#2)
-  + [2.1 将模型导出为inference model](#21)
-  + [2.2 编译PaddleOCR C++预测demo](#22)
-  + [2.3运行demo](#23)
+- [服务器端C++预测](#服务器端c预测)
+  - [1. 准备环境](#1-准备环境)
+    - [1.0 运行准备](#10-运行准备)
+    - [1.1 编译opencv库](#11-编译opencv库)
+    - [1.2 下载或者编译Paddle预测库](#12-下载或者编译paddle预测库)
+      - [1.2.1 直接下载安装](#121-直接下载安装)
+      - [1.2.2 预测库源码编译](#122-预测库源码编译)
+  - [2 开始运行](#2-开始运行)
+    - [2.1 将模型导出为inference model](#21-将模型导出为inference-model)
+    - [2.2 编译PaddleOCR C++预测demo](#22-编译paddleocr-c预测demo)
+    - [2.3 运行demo](#23-运行demo)
+        - [1. 只调用检测：](#1-只调用检测)
+        - [2. 只调用识别：](#2-只调用识别)
+        - [3. 调用串联：](#3-调用串联)
 
 <a name="1"></a>
 
@@ -103,7 +107,7 @@ opencv3/
 
 #### 1.2.1 直接下载安装
 
-* [Paddle预测库官网](https://paddle-inference.readthedocs.io/en/latest/user_guides/download_lib.html) 上提供了不同cuda版本的Linux预测库，可以在官网查看并选择合适的预测库版本（*建议选择paddle版本>=2.0.1版本的预测库* ）。
+* [Paddle预测库官网](https://paddleinference.paddlepaddle.org.cn/user_guides/download_lib.html#linux) 上提供了不同cuda版本的Linux预测库，可以在官网查看并选择合适的预测库版本（*建议选择paddle版本>=2.0.1版本的预测库* ）。
 
 * 下载之后使用下面的方法解压。
 
@@ -249,7 +253,7 @@ CUDNN_LIB_DIR=/your_cudnn_lib_dir
 |gpu_id|int|0|GPU id，使用GPU时有效|
 |gpu_mem|int|4000|申请的GPU内存|
 |cpu_math_library_num_threads|int|10|CPU预测时的线程数，在机器核数充足的情况下，该值越大，预测速度越快|
-|use_mkldnn|bool|true|是否使用mkldnn库|
+|enable_mkldnn|bool|true|是否使用mkldnn库|
 
 - 检测模型相关
 

deploy/cpp_infer/readme_en.md

@@ -78,7 +78,7 @@ opencv3/
 
 #### 1.2.1 Direct download and installation
 
-[Paddle inference library official website](https://paddle-inference.readthedocs.io/en/latest/user_guides/download_lib.html). You can review and select the appropriate version of the inference library on the official website.
+[Paddle inference library official website](https://paddleinference.paddlepaddle.org.cn/user_guides/download_lib.html#linux). You can review and select the appropriate version of the inference library on the official website.
 
 
 * After downloading, use the following command to extract files.
@@ -231,7 +231,7 @@ More parameters are as follows,
 |gpu_id|int|0|GPU id when use_gpu is true|
 |gpu_mem|int|4000|GPU memory requested|
 |cpu_math_library_num_threads|int|10|Number of threads when using CPU inference. When machine cores is enough, the large the value, the faster the inference speed|
-|use_mkldnn|bool|true|Whether to use mkdlnn library|
+|enable_mkldnn|bool|true|Whether to use mkdlnn library|
 
 - Detection related parameters
 

deploy/cpp_infer/src/main.cpp

@@ -28,14 +28,14 @@
 #include <numeric>
 
 #include <glog/logging.h>
-#include <include/ocr_det.h>
 #include <include/ocr_cls.h>
+#include <include/ocr_det.h>
 #include <include/ocr_rec.h>
 #include <include/utility.h>
 #include <sys/stat.h>
 
-#include <gflags/gflags.h>
 #include "auto_log/autolog.h"
+#include <gflags/gflags.h>
 
 DEFINE_bool(use_gpu, false, "Infering with GPU or CPU.");
 DEFINE_int32(gpu_id, 0, "Device id of GPU to execute.");
@@ -51,9 +51,10 @@ DEFINE_string(image_dir, "", "Dir of input image.");
 DEFINE_string(det_model_dir, "", "Path of det inference model.");
 DEFINE_int32(max_side_len, 960, "max_side_len of input image.");
 DEFINE_double(det_db_thresh, 0.3, "Threshold of det_db_thresh.");
-DEFINE_double(det_db_box_thresh, 0.5, "Threshold of det_db_box_thresh.");
-DEFINE_double(det_db_unclip_ratio, 1.6, "Threshold of det_db_unclip_ratio.");
+DEFINE_double(det_db_box_thresh, 0.6, "Threshold of det_db_box_thresh.");
+DEFINE_double(det_db_unclip_ratio, 1.5, "Threshold of det_db_unclip_ratio.");
 DEFINE_bool(use_polygon_score, false, "Whether use polygon score.");
+DEFINE_bool(use_dilation, false, "Whether use the dilation on output map.");
 DEFINE_bool(visualize, true, "Whether show the detection results.");
 // classification related
 DEFINE_bool(use_angle_cls, false, "Whether use use_angle_cls.");
@@ -62,281 +63,260 @@ DEFINE_double(cls_thresh, 0.9, "Threshold of cls_thresh.");
 // recognition related
 DEFINE_string(rec_model_dir, "", "Path of rec inference model.");
 DEFINE_int32(rec_batch_num, 6, "rec_batch_num.");
-DEFINE_string(char_list_file, "../../ppocr/utils/ppocr_keys_v1.txt", "Path of dictionary.");
-
+DEFINE_string(char_list_file, "../../ppocr/utils/ppocr_keys_v1.txt",
+              "Path of dictionary.");
 
 using namespace std;
 using namespace cv;
 using namespace PaddleOCR;
 
-
-static bool PathExists(const std::string& path){
+static bool PathExists(const std::string &path) {
 #ifdef _WIN32
   struct _stat buffer;
   return (_stat(path.c_str(), &buffer) == 0);
 #else
   struct stat buffer;
   return (stat(path.c_str(), &buffer) == 0);
-#endif  // !_WIN32
+#endif // !_WIN32
 }
 
-
 int main_det(std::vector<cv::String> cv_all_img_names) {
-    std::vector<double> time_info = {0, 0, 0};
-    DBDetector det(FLAGS_det_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
-                   FLAGS_gpu_mem, FLAGS_cpu_threads, 
-                   FLAGS_enable_mkldnn, FLAGS_max_side_len, FLAGS_det_db_thresh,
-                   FLAGS_det_db_box_thresh, FLAGS_det_db_unclip_ratio,
-                   FLAGS_use_polygon_score, FLAGS_visualize,
-                   FLAGS_use_tensorrt, FLAGS_precision);
-    
-    for (int i = 0; i < cv_all_img_names.size(); ++i) {
-//       LOG(INFO) << "The predict img: " << cv_all_img_names[i];
-
-      cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
-      if (!srcimg.data) {
-        std::cerr << "[ERROR] image read failed! image path: " << cv_all_img_names[i] << endl;
-        exit(1);
-      }
-      std::vector<std::vector<std::vector<int>>> boxes;
-      std::vector<double> det_times;
-
-      det.Run(srcimg, boxes, &det_times);
-  
-      time_info[0] += det_times[0];
-      time_info[1] += det_times[1];
-      time_info[2] += det_times[2];
-    
-      if (FLAGS_benchmark) {
-          cout << cv_all_img_names[i] << '\t';
-          for (int n = 0; n < boxes.size(); n++) {
-            for (int m = 0; m < boxes[n].size(); m++) {
-              cout << boxes[n][m][0] << ' ' << boxes[n][m][1] << ' ';
-            }
-          }
-          cout << endl;
-      }        
+  std::vector<double> time_info = {0, 0, 0};
+  DBDetector det(FLAGS_det_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
+                 FLAGS_gpu_mem, FLAGS_cpu_threads, FLAGS_enable_mkldnn,
+                 FLAGS_max_side_len, FLAGS_det_db_thresh,
+                 FLAGS_det_db_box_thresh, FLAGS_det_db_unclip_ratio,
+                 FLAGS_use_polygon_score, FLAGS_use_dilation, FLAGS_visualize,
+                 FLAGS_use_tensorrt, FLAGS_precision);
+
+  for (int i = 0; i < cv_all_img_names.size(); ++i) {
+    //       LOG(INFO) << "The predict img: " << cv_all_img_names[i];
+
+    cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
+    if (!srcimg.data) {
+      std::cerr << "[ERROR] image read failed! image path: "
+                << cv_all_img_names[i] << endl;
+      exit(1);
     }
-    
+    std::vector<std::vector<std::vector<int>>> boxes;
+    std::vector<double> det_times;
+
+    det.Run(srcimg, boxes, &det_times);
+
+    time_info[0] += det_times[0];
+    time_info[1] += det_times[1];
+    time_info[2] += det_times[2];
+
     if (FLAGS_benchmark) {
-        AutoLogger autolog("ocr_det", 
-                           FLAGS_use_gpu,
-                           FLAGS_use_tensorrt,
-                           FLAGS_enable_mkldnn,
-                           FLAGS_cpu_threads,
-                           1, 
-                           "dynamic", 
-                           FLAGS_precision, 
-                           time_info, 
-                           cv_all_img_names.size());
-        autolog.report();
+      cout << cv_all_img_names[i] << '\t';
+      for (int n = 0; n < boxes.size(); n++) {
+        for (int m = 0; m < boxes[n].size(); m++) {
+          cout << boxes[n][m][0] << ' ' << boxes[n][m][1] << ' ';
+        }
+      }
+      cout << endl;
     }
-    return 0;
-}
+  }
 
+  if (FLAGS_benchmark) {
+    AutoLogger autolog("ocr_det", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                       FLAGS_enable_mkldnn, FLAGS_cpu_threads, 1, "dynamic",
+                       FLAGS_precision, time_info, cv_all_img_names.size());
+    autolog.report();
+  }
+  return 0;
+}
 
 int main_rec(std::vector<cv::String> cv_all_img_names) {
-    std::vector<double> time_info = {0, 0, 0};
-    
-    std::string char_list_file = FLAGS_char_list_file;
-    if (FLAGS_benchmark) 
-        char_list_file = FLAGS_char_list_file.substr(6);
-    cout << "label file: " << char_list_file << endl;
-        
-    CRNNRecognizer rec(FLAGS_rec_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
-                       FLAGS_gpu_mem, FLAGS_cpu_threads,
-                       FLAGS_enable_mkldnn, char_list_file,
-                       FLAGS_use_tensorrt, FLAGS_precision, FLAGS_rec_batch_num);
+  std::vector<double> time_info = {0, 0, 0};
 
-    std::vector<cv::Mat> img_list;
-    for (int i = 0; i < cv_all_img_names.size(); ++i) {
-      LOG(INFO) << "The predict img: " << cv_all_img_names[i];
+  std::string char_list_file = FLAGS_char_list_file;
+  if (FLAGS_benchmark)
+    char_list_file = FLAGS_char_list_file.substr(6);
+  cout << "label file: " << char_list_file << endl;
 
-      cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
-      if (!srcimg.data) {
-        std::cerr << "[ERROR] image read failed! image path: " << cv_all_img_names[i] << endl;
-        exit(1);
-      }
-      img_list.push_back(srcimg);
-    }
-    std::vector<double> rec_times;
-    rec.Run(img_list, &rec_times);
-    time_info[0] += rec_times[0];
-    time_info[1] += rec_times[1];
-    time_info[2] += rec_times[2];
-    
-    if (FLAGS_benchmark) {
-        AutoLogger autolog("ocr_rec", 
-                           FLAGS_use_gpu,
-                           FLAGS_use_tensorrt,
-                           FLAGS_enable_mkldnn,
-                           FLAGS_cpu_threads,
-                           FLAGS_rec_batch_num, 
-                           "dynamic", 
-                           FLAGS_precision, 
-                           time_info, 
-                           cv_all_img_names.size());
-        autolog.report();
+  CRNNRecognizer rec(FLAGS_rec_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
+                     FLAGS_gpu_mem, FLAGS_cpu_threads, FLAGS_enable_mkldnn,
+                     char_list_file, FLAGS_use_tensorrt, FLAGS_precision,
+                     FLAGS_rec_batch_num);
+
+  std::vector<cv::Mat> img_list;
+  for (int i = 0; i < cv_all_img_names.size(); ++i) {
+    LOG(INFO) << "The predict img: " << cv_all_img_names[i];
+
+    cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
+    if (!srcimg.data) {
+      std::cerr << "[ERROR] image read failed! image path: "
+                << cv_all_img_names[i] << endl;
+      exit(1);
     }
-    return 0;
-}
+    img_list.push_back(srcimg);
+  }
+  std::vector<double> rec_times;
+  rec.Run(img_list, &rec_times);
+  time_info[0] += rec_times[0];
+  time_info[1] += rec_times[1];
+  time_info[2] += rec_times[2];
 
+  if (FLAGS_benchmark) {
+    AutoLogger autolog("ocr_rec", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                       FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                       FLAGS_rec_batch_num, "dynamic", FLAGS_precision,
+                       time_info, cv_all_img_names.size());
+    autolog.report();
+  }
+  return 0;
+}
 
 int main_system(std::vector<cv::String> cv_all_img_names) {
-    std::vector<double> time_info_det = {0, 0, 0};
-    std::vector<double> time_info_rec = {0, 0, 0};
-
-    DBDetector det(FLAGS_det_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
-                   FLAGS_gpu_mem, FLAGS_cpu_threads, 
-                   FLAGS_enable_mkldnn, FLAGS_max_side_len, FLAGS_det_db_thresh,
-                   FLAGS_det_db_box_thresh, FLAGS_det_db_unclip_ratio,
-                   FLAGS_use_polygon_score, FLAGS_visualize,
-                   FLAGS_use_tensorrt, FLAGS_precision);
-
-    Classifier *cls = nullptr;
-    if (FLAGS_use_angle_cls) {
-      cls = new Classifier(FLAGS_cls_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
-                           FLAGS_gpu_mem, FLAGS_cpu_threads,
-                           FLAGS_enable_mkldnn, FLAGS_cls_thresh,
-                           FLAGS_use_tensorrt, FLAGS_precision);
-    }
+  std::vector<double> time_info_det = {0, 0, 0};
+  std::vector<double> time_info_rec = {0, 0, 0};
 
-    std::string char_list_file = FLAGS_char_list_file;
-    if (FLAGS_benchmark) 
-        char_list_file = FLAGS_char_list_file.substr(6);
-    cout << "label file: " << char_list_file << endl;
-        
-    CRNNRecognizer rec(FLAGS_rec_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
-                       FLAGS_gpu_mem, FLAGS_cpu_threads,
-                       FLAGS_enable_mkldnn, char_list_file,
-                       FLAGS_use_tensorrt, FLAGS_precision, FLAGS_rec_batch_num);
-
-    for (int i = 0; i < cv_all_img_names.size(); ++i) {
-      LOG(INFO) << "The predict img: " << cv_all_img_names[i];
-
-      cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
-      if (!srcimg.data) {
-        std::cerr << "[ERROR] image read failed! image path: " << cv_all_img_names[i] << endl;
-        exit(1);
-      }
-      std::vector<std::vector<std::vector<int>>> boxes;
-      std::vector<double> det_times;
-      std::vector<double> rec_times;
-        
-      det.Run(srcimg, boxes, &det_times);
-      time_info_det[0] += det_times[0];
-      time_info_det[1] += det_times[1];
-      time_info_det[2] += det_times[2];
-        
-      std::vector<cv::Mat> img_list;
-      for (int j = 0; j < boxes.size(); j++) {
-          cv::Mat crop_img;
-          crop_img = Utility::GetRotateCropImage(srcimg, boxes[j]);
-          if (cls != nullptr) {
-              crop_img = cls->Run(crop_img);
-          }
-          img_list.push_back(crop_img);
-      }
+  DBDetector det(FLAGS_det_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
+                 FLAGS_gpu_mem, FLAGS_cpu_threads, FLAGS_enable_mkldnn,
+                 FLAGS_max_side_len, FLAGS_det_db_thresh,
+                 FLAGS_det_db_box_thresh, FLAGS_det_db_unclip_ratio,
+                 FLAGS_use_polygon_score, FLAGS_use_dilation, FLAGS_visualize,
+                 FLAGS_use_tensorrt, FLAGS_precision);
+
+  Classifier *cls = nullptr;
+  if (FLAGS_use_angle_cls) {
+    cls = new Classifier(FLAGS_cls_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
+                         FLAGS_gpu_mem, FLAGS_cpu_threads, FLAGS_enable_mkldnn,
+                         FLAGS_cls_thresh, FLAGS_use_tensorrt, FLAGS_precision);
+  }
+
+  std::string char_list_file = FLAGS_char_list_file;
+  if (FLAGS_benchmark)
+    char_list_file = FLAGS_char_list_file.substr(6);
+  cout << "label file: " << char_list_file << endl;
+
+  CRNNRecognizer rec(FLAGS_rec_model_dir, FLAGS_use_gpu, FLAGS_gpu_id,
+                     FLAGS_gpu_mem, FLAGS_cpu_threads, FLAGS_enable_mkldnn,
+                     char_list_file, FLAGS_use_tensorrt, FLAGS_precision,
+                     FLAGS_rec_batch_num);
+
+  for (int i = 0; i < cv_all_img_names.size(); ++i) {
+    LOG(INFO) << "The predict img: " << cv_all_img_names[i];
 
-      rec.Run(img_list, &rec_times);
-      time_info_rec[0] += rec_times[0];
-      time_info_rec[1] += rec_times[1];
-      time_info_rec[2] += rec_times[2];
+    cv::Mat srcimg = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
+    if (!srcimg.data) {
+      std::cerr << "[ERROR] image read failed! image path: "
+                << cv_all_img_names[i] << endl;
+      exit(1);
     }
-    
-    if (FLAGS_benchmark) {
-        AutoLogger autolog_det("ocr_det", 
-                            FLAGS_use_gpu,
-                            FLAGS_use_tensorrt,
-                            FLAGS_enable_mkldnn,
-                            FLAGS_cpu_threads,
-                            1, 
-                            "dynamic", 
-                            FLAGS_precision, 
-                            time_info_det, 
-                            cv_all_img_names.size());
-        AutoLogger autolog_rec("ocr_rec", 
-                            FLAGS_use_gpu,
-                            FLAGS_use_tensorrt,
-                            FLAGS_enable_mkldnn,
-                            FLAGS_cpu_threads,
-                            FLAGS_rec_batch_num, 
-                            "dynamic", 
-                            FLAGS_precision, 
-                            time_info_rec, 
-                            cv_all_img_names.size());
-        autolog_det.report();
-        std::cout << endl;
-        autolog_rec.report();
-    }  
-    return 0;
-}
+    std::vector<std::vector<std::vector<int>>> boxes;
+    std::vector<double> det_times;
+    std::vector<double> rec_times;
 
+    det.Run(srcimg, boxes, &det_times);
+    time_info_det[0] += det_times[0];
+    time_info_det[1] += det_times[1];
+    time_info_det[2] += det_times[2];
 
-void check_params(char* mode) {
-    if (strcmp(mode, "det")==0) {
-        if (FLAGS_det_model_dir.empty() || FLAGS_image_dir.empty()) {
-            std::cout << "Usage[det]: ./ppocr --det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
-                      << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;      
-            exit(1);      
-        }
+    std::vector<cv::Mat> img_list;
+    for (int j = 0; j < boxes.size(); j++) {
+      cv::Mat crop_img;
+      crop_img = Utility::GetRotateCropImage(srcimg, boxes[j]);
+      if (cls != nullptr) {
+        crop_img = cls->Run(crop_img);
+      }
+      img_list.push_back(crop_img);
     }
-    if (strcmp(mode, "rec")==0) {
-        if (FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) {
-            std::cout << "Usage[rec]: ./ppocr --rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
-                      << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;      
-            exit(1);
-        }
+
+    rec.Run(img_list, &rec_times);
+    time_info_rec[0] += rec_times[0];
+    time_info_rec[1] += rec_times[1];
+    time_info_rec[2] += rec_times[2];
+  }
+
+  if (FLAGS_benchmark) {
+    AutoLogger autolog_det("ocr_det", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads, 1, "dynamic",
+                           FLAGS_precision, time_info_det,
+                           cv_all_img_names.size());
+    AutoLogger autolog_rec("ocr_rec", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                           FLAGS_rec_batch_num, "dynamic", FLAGS_precision,
+                           time_info_rec, cv_all_img_names.size());
+    autolog_det.report();
+    std::cout << endl;
+    autolog_rec.report();
+  }
+  return 0;
+}
+
+void check_params(char *mode) {
+  if (strcmp(mode, "det") == 0) {
+    if (FLAGS_det_model_dir.empty() || FLAGS_image_dir.empty()) {
+      std::cout << "Usage[det]: ./ppocr "
+                   "--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
     }
-    if (strcmp(mode, "system")==0) {
-        if ((FLAGS_det_model_dir.empty() || FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) ||
-           (FLAGS_use_angle_cls && FLAGS_cls_model_dir.empty())) {
-            std::cout << "Usage[system without angle cls]: ./ppocr --det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
-                        << "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
-                        << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
-            std::cout << "Usage[system with angle cls]: ./ppocr --det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
-                        << "--use_angle_cls=true "
-                        << "--cls_model_dir=/PATH/TO/CLS_INFERENCE_MODEL/ "
-                        << "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
-                        << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
-            exit(1);      
-        }
+  }
+  if (strcmp(mode, "rec") == 0) {
+    if (FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) {
+      std::cout << "Usage[rec]: ./ppocr "
+                   "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
     }
-    if (FLAGS_precision != "fp32" && FLAGS_precision != "fp16" && FLAGS_precision != "int8") {
-        cout << "precison should be 'fp32'(default), 'fp16' or 'int8'. " << endl;
-        exit(1);
+  }
+  if (strcmp(mode, "system") == 0) {
+    if ((FLAGS_det_model_dir.empty() || FLAGS_rec_model_dir.empty() ||
+         FLAGS_image_dir.empty()) ||
+        (FLAGS_use_angle_cls && FLAGS_cls_model_dir.empty())) {
+      std::cout << "Usage[system without angle cls]: ./ppocr "
+                   "--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
+                << "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      std::cout << "Usage[system with angle cls]: ./ppocr "
+                   "--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
+                << "--use_angle_cls=true "
+                << "--cls_model_dir=/PATH/TO/CLS_INFERENCE_MODEL/ "
+                << "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
     }
+  }
+  if (FLAGS_precision != "fp32" && FLAGS_precision != "fp16" &&
+      FLAGS_precision != "int8") {
+    cout << "precison should be 'fp32'(default), 'fp16' or 'int8'. " << endl;
+    exit(1);
+  }
 }
 
-
 int main(int argc, char **argv) {
-    if (argc<=1 || (strcmp(argv[1], "det")!=0 && strcmp(argv[1], "rec")!=0 && strcmp(argv[1], "system")!=0)) {
-        std::cout << "Please choose one mode of [det, rec, system] !" << std::endl;
-        return -1;
-    }
-    std::cout << "mode: " << argv[1] << endl;
-
-    // Parsing command-line
-    google::ParseCommandLineFlags(&argc, &argv, true);
-    check_params(argv[1]);
-        
-    if (!PathExists(FLAGS_image_dir)) {
-        std::cerr << "[ERROR] image path not exist! image_dir: " << FLAGS_image_dir << endl;
-        exit(1);      
-    }
-    
-    std::vector<cv::String> cv_all_img_names;
-    cv::glob(FLAGS_image_dir, cv_all_img_names);
-    std::cout << "total images num: " << cv_all_img_names.size() << endl;
-    
-    if (strcmp(argv[1], "det")==0) {
-        return main_det(cv_all_img_names);
-    }
-    if (strcmp(argv[1], "rec")==0) {
-        return main_rec(cv_all_img_names);
-    }    
-    if (strcmp(argv[1], "system")==0) {
-        return main_system(cv_all_img_names);
-    } 
+  if (argc <= 1 ||
+      (strcmp(argv[1], "det") != 0 && strcmp(argv[1], "rec") != 0 &&
+       strcmp(argv[1], "system") != 0)) {
+    std::cout << "Please choose one mode of [det, rec, system] !" << std::endl;
+    return -1;
+  }
+  std::cout << "mode: " << argv[1] << endl;
+
+  // Parsing command-line
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  check_params(argv[1]);
+
+  if (!PathExists(FLAGS_image_dir)) {
+    std::cerr << "[ERROR] image path not exist! image_dir: " << FLAGS_image_dir
+              << endl;
+    exit(1);
+  }
+
+  std::vector<cv::String> cv_all_img_names;
+  cv::glob(FLAGS_image_dir, cv_all_img_names);
+  std::cout << "total images num: " << cv_all_img_names.size() << endl;
 
+  if (strcmp(argv[1], "det") == 0) {
+    return main_det(cv_all_img_names);
+  }
+  if (strcmp(argv[1], "rec") == 0) {
+    return main_rec(cv_all_img_names);
+  }
+  if (strcmp(argv[1], "system") == 0) {
+    return main_system(cv_all_img_names);
+  }
 }

deploy/cpp_infer/src/ocr_det.cpp

@@ -14,7 +14,6 @@
 
 #include <include/ocr_det.h>
 
-
 namespace PaddleOCR {
 
 void DBDetector::LoadModel(const std::string &model_dir) {
@@ -30,13 +29,10 @@ void DBDetector::LoadModel(const std::string &model_dir) {
       if (this->precision_ == "fp16") {
         precision = paddle_infer::Config::Precision::kHalf;
       }
-     if (this->precision_ == "int8") {
+      if (this->precision_ == "int8") {
         precision = paddle_infer::Config::Precision::kInt8;
-      } 
-      config.EnableTensorRtEngine(
-          1 << 20, 10, 3,
-          precision,
-          false, false);
+      }
+      config.EnableTensorRtEngine(1 << 20, 10, 3, precision, false, false);
       std::map<std::string, std::vector<int>> min_input_shape = {
           {"x", {1, 3, 50, 50}},
           {"conv2d_92.tmp_0", {1, 96, 20, 20}},
@@ -105,7 +101,7 @@ void DBDetector::Run(cv::Mat &img,
   cv::Mat srcimg;
   cv::Mat resize_img;
   img.copyTo(srcimg);
-  
+
   auto preprocess_start = std::chrono::steady_clock::now();
   this->resize_op_.Run(img, resize_img, this->max_side_len_, ratio_h, ratio_w,
                        this->use_tensorrt_);
@@ -116,16 +112,16 @@ void DBDetector::Run(cv::Mat &img,
   std::vector<float> input(1 * 3 * resize_img.rows * resize_img.cols, 0.0f);
   this->permute_op_.Run(&resize_img, input.data());
   auto preprocess_end = std::chrono::steady_clock::now();
-    
+
   // Inference.
   auto input_names = this->predictor_->GetInputNames();
   auto input_t = this->predictor_->GetInputHandle(input_names[0]);
   input_t->Reshape({1, 3, resize_img.rows, resize_img.cols});
   auto inference_start = std::chrono::steady_clock::now();
   input_t->CopyFromCpu(input.data());
-  
+
   this->predictor_->Run();
-    
+
   std::vector<float> out_data;
   auto output_names = this->predictor_->GetOutputNames();
   auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
@@ -136,7 +132,7 @@ void DBDetector::Run(cv::Mat &img,
   out_data.resize(out_num);
   output_t->CopyToCpu(out_data.data());
   auto inference_end = std::chrono::steady_clock::now();
-  
+
   auto postprocess_start = std::chrono::steady_clock::now();
   int n2 = output_shape[2];
   int n3 = output_shape[3];
@@ -157,24 +153,29 @@ void DBDetector::Run(cv::Mat &img,
   const double maxvalue = 255;
   cv::Mat bit_map;
   cv::threshold(cbuf_map, bit_map, threshold, maxvalue, cv::THRESH_BINARY);
-  cv::Mat dilation_map;
-  cv::Mat dila_ele = cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
-  cv::dilate(bit_map, dilation_map, dila_ele);
+  if (this->use_dilation_) {
+    cv::Mat dila_ele =
+        cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
+    cv::dilate(bit_map, bit_map, dila_ele);
+  }
+
   boxes = post_processor_.BoxesFromBitmap(
-      pred_map, dilation_map, this->det_db_box_thresh_,
-      this->det_db_unclip_ratio_, this->use_polygon_score_);
+      pred_map, bit_map, this->det_db_box_thresh_, this->det_db_unclip_ratio_,
+      this->use_polygon_score_);
 
   boxes = post_processor_.FilterTagDetRes(boxes, ratio_h, ratio_w, srcimg);
   auto postprocess_end = std::chrono::steady_clock::now();
   std::cout << "Detected boxes num: " << boxes.size() << endl;
 
-  std::chrono::duration<float> preprocess_diff = preprocess_end - preprocess_start;
+  std::chrono::duration<float> preprocess_diff =
+      preprocess_end - preprocess_start;
   times->push_back(double(preprocess_diff.count() * 1000));
   std::chrono::duration<float> inference_diff = inference_end - inference_start;
   times->push_back(double(inference_diff.count() * 1000));
-  std::chrono::duration<float> postprocess_diff = postprocess_end - postprocess_start;
+  std::chrono::duration<float> postprocess_diff =
+      postprocess_end - postprocess_start;
   times->push_back(double(postprocess_diff.count() * 1000));
-    
+
   //// visualization
   if (this->visualize_) {
     Utility::VisualizeBboxes(srcimg, boxes);