first commit

deploy/cpp_infer/src/args.cpp

@@ -0,0 +1,76 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <gflags/gflags.h>
+
+// common args
+DEFINE_bool(use_gpu, false, "Inferring with GPU or CPU.");
+DEFINE_bool(use_tensorrt, false, "Whether use tensorrt.");
+DEFINE_int32(gpu_id, 0, "Device id of GPU to execute.");
+DEFINE_int32(gpu_mem, 4000, "GPU memory size (MB) to use.");
+DEFINE_int32(cpu_threads, 10, "Num of threads with CPU.");
+DEFINE_bool(enable_mkldnn, false, "Whether use mkldnn with CPU.");
+DEFINE_string(precision, "fp32", "Precision be one of fp32/fp16/int8");
+DEFINE_bool(benchmark, false, "Whether use benchmark.");
+DEFINE_string(output, "./output/", "Save benchmark log path.");
+DEFINE_string(image_dir, "", "Dir of input image.");
+DEFINE_string(
+    type, "ocr",
+    "Perform ocr or structure, the value is selected in ['ocr','structure'].");
+// detection related
+DEFINE_string(det_model_dir, "", "Path of det inference model.");
+DEFINE_string(limit_type, "max", "limit_type of input image.");
+DEFINE_int32(limit_side_len, 960, "limit_side_len of input image.");
+DEFINE_double(det_db_thresh, 0.3, "Threshold of det_db_thresh.");
+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_dilation, false, "Whether use the dilation on output map.");
+DEFINE_string(det_db_score_mode, "slow", "Whether use polygon score.");
+DEFINE_bool(visualize, true, "Whether show the detection results.");
+// classification related
+DEFINE_bool(use_angle_cls, false, "Whether use use_angle_cls.");
+DEFINE_string(cls_model_dir, "", "Path of cls inference model.");
+DEFINE_double(cls_thresh, 0.9, "Threshold of cls_thresh.");
+DEFINE_int32(cls_batch_num, 1, "cls_batch_num.");
+// recognition related
+DEFINE_string(rec_model_dir, "", "Path of rec inference model.");
+DEFINE_int32(rec_batch_num, 6, "rec_batch_num.");
+DEFINE_string(rec_char_dict_path, "../../ppocr/utils/ppocr_keys_v1.txt",
+              "Path of dictionary.");
+DEFINE_int32(rec_img_h, 48, "rec image height");
+DEFINE_int32(rec_img_w, 320, "rec image width");
+
+// layout model related
+DEFINE_string(layout_model_dir, "", "Path of table layout inference model.");
+DEFINE_string(layout_dict_path,
+              "../../ppocr/utils/dict/layout_dict/layout_publaynet_dict.txt",
+              "Path of dictionary.");
+DEFINE_double(layout_score_threshold, 0.5, "Threshold of score.");
+DEFINE_double(layout_nms_threshold, 0.5, "Threshold of nms.");
+// structure model related
+DEFINE_string(table_model_dir, "", "Path of table structure inference model.");
+DEFINE_int32(table_max_len, 488, "max len size of input image.");
+DEFINE_int32(table_batch_num, 1, "table_batch_num.");
+DEFINE_bool(merge_no_span_structure, true,
+            "Whether merge <td> and </td> to <td></td>");
+DEFINE_string(table_char_dict_path,
+              "../../ppocr/utils/dict/table_structure_dict_ch.txt",
+              "Path of dictionary.");
+
+// ocr forward related
+DEFINE_bool(det, true, "Whether use det in forward.");
+DEFINE_bool(rec, true, "Whether use rec in forward.");
+DEFINE_bool(cls, false, "Whether use cls in forward.");
+DEFINE_bool(table, false, "Whether use table structure in forward.");
+DEFINE_bool(layout, false, "Whether use layout analysis in forward.");

deploy/cpp_infer/src/main.cpp

@@ -0,0 +1,201 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <opencv2/imgcodecs.hpp>
+
+#include <include/args.h>
+#include <include/paddlestructure.h>
+
+#include <iostream>
+#include <vector>
+
+using namespace PaddleOCR;
+
+void check_params() {
+  if (FLAGS_det) {
+    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 (FLAGS_rec) {
+    std::cout
+        << "In PP-OCRv3, rec_image_shape parameter defaults to '3, 48, 320',"
+           "if you are using recognition model with PP-OCRv2 or an older "
+           "version, "
+           "please set --rec_image_shape='3,32,320"
+        << std::endl;
+    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_cls && FLAGS_use_angle_cls) {
+    if (FLAGS_cls_model_dir.empty() || FLAGS_image_dir.empty()) {
+      std::cout << "Usage[cls]: ./ppocr "
+                << "--cls_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
+    }
+  }
+  if (FLAGS_table) {
+    if (FLAGS_table_model_dir.empty() || FLAGS_det_model_dir.empty() ||
+        FLAGS_rec_model_dir.empty() || FLAGS_image_dir.empty()) {
+      std::cout << "Usage[table]: ./ppocr "
+                << "--det_model_dir=/PATH/TO/DET_INFERENCE_MODEL/ "
+                << "--rec_model_dir=/PATH/TO/REC_INFERENCE_MODEL/ "
+                << "--table_model_dir=/PATH/TO/TABLE_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
+    }
+  }
+  if (FLAGS_layout) {
+    if (FLAGS_layout_model_dir.empty() || FLAGS_image_dir.empty()) {
+      std::cout << "Usage[layout]: ./ppocr "
+                << "--layout_model_dir=/PATH/TO/LAYOUT_INFERENCE_MODEL/ "
+                << "--image_dir=/PATH/TO/INPUT/IMAGE/" << std::endl;
+      exit(1);
+    }
+  }
+  if (FLAGS_precision != "fp32" && FLAGS_precision != "fp16" &&
+      FLAGS_precision != "int8") {
+    std::cout << "precision should be 'fp32'(default), 'fp16' or 'int8'. "
+              << std::endl;
+    exit(1);
+  }
+}
+
+void ocr(std::vector<cv::String> &cv_all_img_names) {
+  PPOCR ocr;
+
+  if (FLAGS_benchmark) {
+    ocr.reset_timer();
+  }
+
+  std::vector<cv::Mat> img_list;
+  std::vector<cv::String> img_names;
+  for (int i = 0; i < cv_all_img_names.size(); ++i) {
+    cv::Mat img = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
+    if (!img.data) {
+      std::cerr << "[ERROR] image read failed! image path: "
+                << cv_all_img_names[i] << std::endl;
+      continue;
+    }
+    img_list.emplace_back(std::move(img));
+    img_names.emplace_back(cv_all_img_names[i]);
+  }
+
+  std::vector<std::vector<OCRPredictResult>> ocr_results =
+      ocr.ocr(img_list, FLAGS_det, FLAGS_rec, FLAGS_cls);
+
+  for (int i = 0; i < img_names.size(); ++i) {
+    std::cout << "predict img: " << cv_all_img_names[i] << std::endl;
+    Utility::print_result(ocr_results[i]);
+    if (FLAGS_visualize && FLAGS_det) {
+      std::string file_name = Utility::basename(img_names[i]);
+      cv::Mat srcimg = img_list[i];
+      Utility::VisualizeBboxes(srcimg, ocr_results[i],
+                               FLAGS_output + "/" + file_name);
+    }
+  }
+  if (FLAGS_benchmark) {
+    ocr.benchmark_log(cv_all_img_names.size());
+  }
+}
+
+void structure(std::vector<cv::String> &cv_all_img_names) {
+  PaddleOCR::PaddleStructure engine;
+
+  if (FLAGS_benchmark) {
+    engine.reset_timer();
+  }
+
+  for (int i = 0; i < cv_all_img_names.size(); ++i) {
+    std::cout << "predict img: " << cv_all_img_names[i] << std::endl;
+    cv::Mat img = cv::imread(cv_all_img_names[i], cv::IMREAD_COLOR);
+    if (!img.data) {
+      std::cerr << "[ERROR] image read failed! image path: "
+                << cv_all_img_names[i] << std::endl;
+      continue;
+    }
+
+    std::vector<StructurePredictResult> structure_results = engine.structure(
+        img, FLAGS_layout, FLAGS_table, FLAGS_det && FLAGS_rec);
+
+    for (size_t j = 0; j < structure_results.size(); ++j) {
+      std::cout << j << "\ttype: " << structure_results[j].type
+                << ", region: [";
+      std::cout << structure_results[j].box[0] << ","
+                << structure_results[j].box[1] << ","
+                << structure_results[j].box[2] << ","
+                << structure_results[j].box[3] << "], score: ";
+      std::cout << structure_results[j].confidence << ", res: ";
+
+      if (structure_results[j].type == "table") {
+        std::cout << structure_results[j].html << std::endl;
+        if (structure_results[j].cell_box.size() > 0 && FLAGS_visualize) {
+          std::string file_name = Utility::basename(cv_all_img_names[i]);
+
+          Utility::VisualizeBboxes(img, structure_results[j],
+                                   FLAGS_output + "/" + std::to_string(j) +
+                                       "_" + file_name);
+        }
+      } else {
+        std::cout << "count of ocr result is : "
+                  << structure_results[j].text_res.size() << std::endl;
+        if (structure_results[j].text_res.size() > 0) {
+          std::cout << "********** print ocr result "
+                    << "**********" << std::endl;
+          Utility::print_result(structure_results[j].text_res);
+          std::cout << "********** end print ocr result "
+                    << "**********" << std::endl;
+        }
+      }
+    }
+  }
+  if (FLAGS_benchmark) {
+    engine.benchmark_log(cv_all_img_names.size());
+  }
+}
+
+int main(int argc, char **argv) {
+  // Parsing command-line
+  google::ParseCommandLineFlags(&argc, &argv, true);
+  check_params();
+
+  if (!Utility::PathExists(FLAGS_image_dir)) {
+    std::cerr << "[ERROR] image path not exist! image_dir: " << FLAGS_image_dir
+              << std::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() << std::endl;
+
+  if (!Utility::PathExists(FLAGS_output)) {
+    Utility::CreateDir(FLAGS_output);
+  }
+  if (FLAGS_type == "ocr") {
+    ocr(cv_all_img_names);
+  } else if (FLAGS_type == "structure") {
+    structure(cv_all_img_names);
+  } else {
+    std::cout << "only value in ['ocr','structure'] is supported" << std::endl;
+  }
+}

deploy/cpp_infer/src/ocr_cls.cpp

@@ -0,0 +1,174 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/ocr_cls.h>
+#include <paddle_inference_api.h>
+
+#include <chrono>
+#include <numeric>
+
+namespace PaddleOCR {
+
+void Classifier::Run(const std::vector<cv::Mat> &img_list,
+                     std::vector<int> &cls_labels,
+                     std::vector<float> &cls_scores,
+                     std::vector<double> &times) noexcept {
+  std::chrono::duration<float> preprocess_diff =
+      std::chrono::duration<float>::zero();
+  std::chrono::duration<float> inference_diff =
+      std::chrono::duration<float>::zero();
+  std::chrono::duration<float> postprocess_diff =
+      std::chrono::duration<float>::zero();
+
+  int img_num = img_list.size();
+  std::vector<int> cls_image_shape = {3, 48, 192};
+  for (int beg_img_no = 0; beg_img_no < img_num;
+       beg_img_no += this->cls_batch_num_) {
+    auto preprocess_start = std::chrono::steady_clock::now();
+    int end_img_no = std::min(img_num, beg_img_no + this->cls_batch_num_);
+    int batch_num = end_img_no - beg_img_no;
+    // preprocess
+    std::vector<cv::Mat> norm_img_batch;
+    for (int ino = beg_img_no; ino < end_img_no; ++ino) {
+      cv::Mat srcimg;
+      img_list[ino].copyTo(srcimg);
+      cv::Mat resize_img;
+      this->resize_op_.Run(srcimg, resize_img, this->use_tensorrt_,
+                           cls_image_shape);
+
+      this->normalize_op_.Run(resize_img, this->mean_, this->scale_,
+                              this->is_scale_);
+      if (resize_img.cols < cls_image_shape[2]) {
+        cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0,
+                           cls_image_shape[2] - resize_img.cols,
+                           cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
+      }
+      norm_img_batch.emplace_back(std::move(resize_img));
+    }
+    std::vector<float> input(batch_num * cls_image_shape[0] *
+                                 cls_image_shape[1] * cls_image_shape[2],
+                             0.0f);
+    this->permute_op_.Run(norm_img_batch, input.data());
+    auto preprocess_end = std::chrono::steady_clock::now();
+    preprocess_diff += preprocess_end - preprocess_start;
+
+    // inference.
+    auto input_names = this->predictor_->GetInputNames();
+    auto input_t = this->predictor_->GetInputHandle(input_names[0]);
+    input_t->Reshape({batch_num, cls_image_shape[0], cls_image_shape[1],
+                      cls_image_shape[2]});
+    auto inference_start = std::chrono::steady_clock::now();
+    input_t->CopyFromCpu(input.data());
+    this->predictor_->Run();
+
+    std::vector<float> predict_batch;
+    auto output_names = this->predictor_->GetOutputNames();
+    auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
+    auto predict_shape = output_t->shape();
+
+    int out_num = std::accumulate(predict_shape.begin(), predict_shape.end(), 1,
+                                  std::multiplies<int>());
+    predict_batch.resize(out_num);
+
+    output_t->CopyToCpu(predict_batch.data());
+    auto inference_end = std::chrono::steady_clock::now();
+    inference_diff += inference_end - inference_start;
+
+    // postprocess
+    auto postprocess_start = std::chrono::steady_clock::now();
+    for (int batch_idx = 0; batch_idx < predict_shape[0]; ++batch_idx) {
+      int label = int(
+          Utility::argmax(&predict_batch[batch_idx * predict_shape[1]],
+                          &predict_batch[(batch_idx + 1) * predict_shape[1]]));
+      float score = float(*std::max_element(
+          &predict_batch[batch_idx * predict_shape[1]],
+          &predict_batch[(batch_idx + 1) * predict_shape[1]]));
+      cls_labels[beg_img_no + batch_idx] = label;
+      cls_scores[beg_img_no + batch_idx] = score;
+    }
+    auto postprocess_end = std::chrono::steady_clock::now();
+    postprocess_diff += postprocess_end - postprocess_start;
+  }
+  times.emplace_back(preprocess_diff.count() * 1000);
+  times.emplace_back(inference_diff.count() * 1000);
+  times.emplace_back(postprocess_diff.count() * 1000);
+}
+
+void Classifier::LoadModel(const std::string &model_dir) noexcept {
+  paddle_infer::Config config;
+  bool json_model = false;
+  std::string model_file_path, param_file_path;
+  std::vector<std::pair<std::string, std::string>> model_variants = {
+      {"/inference.json", "/inference.pdiparams"},
+      {"/model.json", "/model.pdiparams"},
+      {"/inference.pdmodel", "/inference.pdiparams"},
+      {"/model.pdmodel", "/model.pdiparams"}};
+  for (const auto &variant : model_variants) {
+    if (Utility::PathExists(model_dir + variant.first)) {
+      model_file_path = model_dir + variant.first;
+      param_file_path = model_dir + variant.second;
+      json_model = (variant.first.find(".json") != std::string::npos);
+      break;
+    }
+  }
+  if (model_file_path.empty()) {
+    std::cerr << "[ERROR] No valid model file found in " << model_dir
+              << std::endl;
+    exit(1);
+  }
+  config.SetModel(model_file_path, param_file_path);
+  if (this->use_gpu_) {
+    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+      if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      }
+      config.EnableTensorRtEngine(1 << 20, 10, 3, precision, false, false);
+      if (!Utility::PathExists("./trt_cls_shape.txt")) {
+        config.CollectShapeRangeInfo("./trt_cls_shape.txt");
+      } else {
+        config.EnableTunedTensorRtDynamicShape("./trt_cls_shape.txt", true);
+      }
+    }
+  } else {
+    config.DisableGpu();
+    if (this->use_mkldnn_) {
+      config.EnableMKLDNN();
+    } else {
+      config.DisableMKLDNN();
+    }
+    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+    if (json_model) {
+      config.EnableNewIR();
+      config.EnableNewExecutor();
+    }
+  }
+
+  // false for zero copy tensor
+  config.SwitchUseFeedFetchOps(false);
+  // true for multiple input
+  config.SwitchSpecifyInputNames(true);
+
+  config.SwitchIrOptim(true);
+
+  config.EnableMemoryOptim();
+  config.DisableGlogInfo();
+
+  this->predictor_ = paddle_infer::CreatePredictor(config);
+}
+} // namespace PaddleOCR

deploy/cpp_infer/src/ocr_det.cpp

@@ -0,0 +1,177 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/ocr_det.h>
+#include <paddle_inference_api.h>
+
+#include <chrono>
+#include <numeric>
+
+namespace PaddleOCR {
+
+void DBDetector::LoadModel(const std::string &model_dir) noexcept {
+  //   AnalysisConfig config;
+  paddle_infer::Config config;
+  bool json_model = false;
+  std::string model_file_path, param_file_path;
+  std::vector<std::pair<std::string, std::string>> model_variants = {
+      {"/inference.json", "/inference.pdiparams"},
+      {"/model.json", "/model.pdiparams"},
+      {"/inference.pdmodel", "/inference.pdiparams"},
+      {"/model.pdmodel", "/model.pdiparams"}};
+  for (const auto &variant : model_variants) {
+    if (Utility::PathExists(model_dir + variant.first)) {
+      model_file_path = model_dir + variant.first;
+      param_file_path = model_dir + variant.second;
+      json_model = (variant.first.find(".json") != std::string::npos);
+      break;
+    }
+  }
+  if (model_file_path.empty()) {
+    std::cerr << "[ERROR] No valid model file found in " << model_dir
+              << std::endl;
+    exit(1);
+  }
+  config.SetModel(model_file_path, param_file_path);
+  if (this->use_gpu_) {
+    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+      if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      }
+      config.EnableTensorRtEngine(1 << 30, 1, 20, precision, false, false);
+      if (!Utility::PathExists("./trt_det_shape.txt")) {
+        config.CollectShapeRangeInfo("./trt_det_shape.txt");
+      } else {
+        config.EnableTunedTensorRtDynamicShape("./trt_det_shape.txt", true);
+      }
+    }
+  } else {
+    config.DisableGpu();
+    if (this->use_mkldnn_) {
+      config.EnableMKLDNN();
+      // cache 10 different shapes for mkldnn to avoid memory leak
+      config.SetMkldnnCacheCapacity(10);
+    } else {
+      config.DisableMKLDNN();
+    }
+    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+    if (json_model) {
+      config.EnableNewIR();
+      config.EnableNewExecutor();
+    }
+  }
+  // use zero_copy_run as default
+  config.SwitchUseFeedFetchOps(false);
+  // true for multiple input
+  config.SwitchSpecifyInputNames(true);
+
+  config.SwitchIrOptim(true);
+
+  config.EnableMemoryOptim();
+  // config.DisableGlogInfo();
+
+  this->predictor_ = paddle_infer::CreatePredictor(config);
+}
+
+void DBDetector::Run(const cv::Mat &img,
+                     std::vector<std::vector<std::vector<int>>> &boxes,
+                     std::vector<double> &times) noexcept {
+  float ratio_h{};
+  float ratio_w{};
+
+  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->limit_type_,
+                       this->limit_side_len_, ratio_h, ratio_w,
+                       this->use_tensorrt_);
+
+  this->normalize_op_.Run(resize_img, this->mean_, this->scale_,
+                          this->is_scale_);
+
+  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]);
+  std::vector<int> output_shape = output_t->shape();
+  int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1,
+                                std::multiplies<int>());
+
+  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];
+  int n = n2 * n3;
+
+  std::vector<float> pred(n, 0.0);
+  std::vector<unsigned char> cbuf(n, ' ');
+
+  for (int i = 0; i < n; ++i) {
+    pred[i] = float(out_data[i]);
+    cbuf[i] = (unsigned char)((out_data[i]) * 255);
+  }
+
+  cv::Mat cbuf_map(n2, n3, CV_8UC1, (unsigned char *)cbuf.data());
+  cv::Mat pred_map(n2, n3, CV_32F, (float *)pred.data());
+
+  const double threshold = this->det_db_thresh_ * 255;
+  const double maxvalue = 255;
+  cv::Mat bit_map;
+  cv::threshold(cbuf_map, bit_map, threshold, maxvalue, cv::THRESH_BINARY);
+  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 = std::move(post_processor_.BoxesFromBitmap(
+      pred_map, bit_map, this->det_db_box_thresh_, this->det_db_unclip_ratio_,
+      this->det_db_score_mode_));
+
+  post_processor_.FilterTagDetRes(boxes, ratio_h, ratio_w, srcimg);
+  auto postprocess_end = std::chrono::steady_clock::now();
+
+  std::chrono::duration<float> preprocess_diff =
+      preprocess_end - preprocess_start;
+  times.emplace_back(preprocess_diff.count() * 1000);
+  std::chrono::duration<float> inference_diff = inference_end - inference_start;
+  times.emplace_back(inference_diff.count() * 1000);
+  std::chrono::duration<float> postprocess_diff =
+      postprocess_end - postprocess_start;
+  times.emplace_back(postprocess_diff.count() * 1000);
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/ocr_rec.cpp

@@ -0,0 +1,211 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/ocr_rec.h>
+#include <paddle_inference_api.h>
+
+#include <chrono>
+#include <iostream>
+#include <numeric>
+
+namespace PaddleOCR {
+
+void CRNNRecognizer::Run(const std::vector<cv::Mat> &img_list,
+                         std::vector<std::string> &rec_texts,
+                         std::vector<float> &rec_text_scores,
+                         std::vector<double> &times) noexcept {
+  std::chrono::duration<float> preprocess_diff =
+      std::chrono::duration<float>::zero();
+  std::chrono::duration<float> inference_diff =
+      std::chrono::duration<float>::zero();
+  std::chrono::duration<float> postprocess_diff =
+      std::chrono::duration<float>::zero();
+
+  size_t img_num = img_list.size();
+  std::vector<float> width_list;
+  for (size_t i = 0; i < img_num; ++i) {
+    width_list.emplace_back(float(img_list[i].cols) / img_list[i].rows);
+  }
+  std::vector<size_t> indices = std::move(Utility::argsort(width_list));
+
+  for (size_t beg_img_no = 0; beg_img_no < img_num;
+       beg_img_no += this->rec_batch_num_) {
+    auto preprocess_start = std::chrono::steady_clock::now();
+    size_t end_img_no = std::min(img_num, beg_img_no + this->rec_batch_num_);
+    int batch_num = end_img_no - beg_img_no;
+    int imgH = this->rec_image_shape_[1];
+    int imgW = this->rec_image_shape_[2];
+    float max_wh_ratio = imgW * 1.0 / imgH;
+    for (size_t ino = beg_img_no; ino < end_img_no; ++ino) {
+      int h = img_list[indices[ino]].rows;
+      int w = img_list[indices[ino]].cols;
+      float wh_ratio = w * 1.0 / h;
+      max_wh_ratio = std::max(max_wh_ratio, wh_ratio);
+    }
+
+    int batch_width = imgW;
+    std::vector<cv::Mat> norm_img_batch;
+    for (size_t ino = beg_img_no; ino < end_img_no; ++ino) {
+      cv::Mat srcimg;
+      img_list[indices[ino]].copyTo(srcimg);
+      cv::Mat resize_img;
+      this->resize_op_.Run(srcimg, resize_img, max_wh_ratio,
+                           this->use_tensorrt_, this->rec_image_shape_);
+      this->normalize_op_.Run(resize_img, this->mean_, this->scale_,
+                              this->is_scale_);
+      batch_width = std::max(resize_img.cols, batch_width);
+      norm_img_batch.emplace_back(std::move(resize_img));
+    }
+
+    std::vector<float> input(batch_num * 3 * imgH * batch_width, 0.0f);
+    this->permute_op_.Run(norm_img_batch, input.data());
+    auto preprocess_end = std::chrono::steady_clock::now();
+    preprocess_diff += preprocess_end - preprocess_start;
+    // Inference.
+    auto input_names = this->predictor_->GetInputNames();
+    auto input_t = this->predictor_->GetInputHandle(input_names[0]);
+    input_t->Reshape({batch_num, 3, imgH, batch_width});
+    auto inference_start = std::chrono::steady_clock::now();
+    input_t->CopyFromCpu(input.data());
+    this->predictor_->Run();
+
+    std::vector<float> predict_batch;
+    auto output_names = this->predictor_->GetOutputNames();
+    auto output_t = this->predictor_->GetOutputHandle(output_names[0]);
+    auto predict_shape = output_t->shape();
+
+    size_t out_num = std::accumulate(predict_shape.begin(), predict_shape.end(),
+                                     1, std::multiplies<int>());
+    predict_batch.resize(out_num);
+    // predict_batch is the result of Last FC with softmax
+    output_t->CopyToCpu(predict_batch.data());
+    auto inference_end = std::chrono::steady_clock::now();
+    inference_diff += inference_end - inference_start;
+    // ctc decode
+    auto postprocess_start = std::chrono::steady_clock::now();
+    for (int m = 0; m < predict_shape[0]; ++m) {
+      std::string str_res;
+      int argmax_idx;
+      int last_index = 0;
+      float score = 0.f;
+      int count = 0;
+      float max_value = 0.0f;
+
+      for (int n = 0; n < predict_shape[1]; ++n) {
+        // get idx
+        argmax_idx = int(Utility::argmax(
+            &predict_batch[(m * predict_shape[1] + n) * predict_shape[2]],
+            &predict_batch[(m * predict_shape[1] + n + 1) * predict_shape[2]]));
+        // get score
+        max_value = float(*std::max_element(
+            &predict_batch[(m * predict_shape[1] + n) * predict_shape[2]],
+            &predict_batch[(m * predict_shape[1] + n + 1) * predict_shape[2]]));
+
+        if (argmax_idx > 0 && (!(n > 0 && argmax_idx == last_index))) {
+          score += max_value;
+          count += 1;
+          str_res += label_list_[argmax_idx];
+        }
+        last_index = argmax_idx;
+      }
+      score /= count;
+      if (std::isnan(score)) {
+        continue;
+      }
+      rec_texts[indices[beg_img_no + m]] = std::move(str_res);
+      rec_text_scores[indices[beg_img_no + m]] = score;
+    }
+    auto postprocess_end = std::chrono::steady_clock::now();
+    postprocess_diff += postprocess_end - postprocess_start;
+  }
+  times.emplace_back(preprocess_diff.count() * 1000);
+  times.emplace_back(inference_diff.count() * 1000);
+  times.emplace_back(postprocess_diff.count() * 1000);
+}
+
+void CRNNRecognizer::LoadModel(const std::string &model_dir) noexcept {
+  paddle_infer::Config config;
+  bool json_model = false;
+  std::string model_file_path, param_file_path;
+  std::vector<std::pair<std::string, std::string>> model_variants = {
+      {"/inference.json", "/inference.pdiparams"},
+      {"/model.json", "/model.pdiparams"},
+      {"/inference.pdmodel", "/inference.pdiparams"},
+      {"/model.pdmodel", "/model.pdiparams"}};
+  for (const auto &variant : model_variants) {
+    if (Utility::PathExists(model_dir + variant.first)) {
+      model_file_path = model_dir + variant.first;
+      param_file_path = model_dir + variant.second;
+      json_model = (variant.first.find(".json") != std::string::npos);
+      break;
+    }
+  }
+  if (model_file_path.empty()) {
+    std::cerr << "[ERROR] No valid model file found in " << model_dir
+              << std::endl;
+    exit(1);
+  }
+  config.SetModel(model_file_path, param_file_path);
+  std::cout << "In PP-OCRv3, default rec_img_h is 48,"
+            << "if you use other model, you should set the param rec_img_h=32"
+            << std::endl;
+  if (this->use_gpu_) {
+    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+      if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      }
+      if (!Utility::PathExists("./trt_rec_shape.txt")) {
+        config.CollectShapeRangeInfo("./trt_rec_shape.txt");
+      } else {
+        config.EnableTunedTensorRtDynamicShape("./trt_rec_shape.txt", true);
+      }
+    }
+  } else {
+    config.DisableGpu();
+    if (this->use_mkldnn_) {
+      config.EnableMKLDNN();
+      // cache 10 different shapes for mkldnn to avoid memory leak
+      config.SetMkldnnCacheCapacity(10);
+    } else {
+      config.DisableMKLDNN();
+    }
+    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+    if (json_model) {
+      config.EnableNewIR();
+      config.EnableNewExecutor();
+    }
+  }
+
+  // get pass_builder object
+  auto pass_builder = config.pass_builder();
+  // delete "matmul_transpose_reshape_fuse_pass"
+  pass_builder->DeletePass("matmul_transpose_reshape_fuse_pass");
+  config.SwitchUseFeedFetchOps(false);
+  // true for multiple input
+  config.SwitchSpecifyInputNames(true);
+
+  config.SwitchIrOptim(true);
+
+  config.EnableMemoryOptim();
+  //   config.DisableGlogInfo();
+
+  this->predictor_ = paddle_infer::CreatePredictor(config);
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/paddleocr.cpp

@@ -0,0 +1,203 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/args.h>
+#include <include/ocr_cls.h>
+#include <include/ocr_det.h>
+#include <include/ocr_rec.h>
+#include <include/paddleocr.h>
+
+#include <auto_log/autolog.h>
+
+namespace PaddleOCR {
+
+struct PPOCR::PPOCR_PRIVATE {
+  std::unique_ptr<DBDetector> detector_;
+  std::unique_ptr<Classifier> classifier_;
+  std::unique_ptr<CRNNRecognizer> recognizer_;
+};
+
+PPOCR::PPOCR() noexcept : pri_(new PPOCR_PRIVATE) {
+  if (FLAGS_det) {
+    this->pri_->detector_.reset(new DBDetector(
+        FLAGS_det_model_dir, FLAGS_use_gpu, FLAGS_gpu_id, FLAGS_gpu_mem,
+        FLAGS_cpu_threads, FLAGS_enable_mkldnn, FLAGS_limit_type,
+        FLAGS_limit_side_len, FLAGS_det_db_thresh, FLAGS_det_db_box_thresh,
+        FLAGS_det_db_unclip_ratio, FLAGS_det_db_score_mode, FLAGS_use_dilation,
+        FLAGS_use_tensorrt, FLAGS_precision));
+  }
+
+  if (FLAGS_cls && FLAGS_use_angle_cls) {
+    this->pri_->classifier_.reset(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, FLAGS_cls_batch_num));
+  }
+  if (FLAGS_rec) {
+    this->pri_->recognizer_.reset(new CRNNRecognizer(
+        FLAGS_rec_model_dir, FLAGS_use_gpu, FLAGS_gpu_id, FLAGS_gpu_mem,
+        FLAGS_cpu_threads, FLAGS_enable_mkldnn, FLAGS_rec_char_dict_path,
+        FLAGS_use_tensorrt, FLAGS_precision, FLAGS_rec_batch_num,
+        FLAGS_rec_img_h, FLAGS_rec_img_w));
+  }
+}
+
+PPOCR::~PPOCR() { delete this->pri_; }
+
+std::vector<std::vector<OCRPredictResult>>
+PPOCR::ocr(const std::vector<cv::Mat> &img_list, bool det, bool rec,
+           bool cls) noexcept {
+  std::vector<std::vector<OCRPredictResult>> ocr_results;
+
+  if (!det) {
+    std::vector<OCRPredictResult> ocr_result;
+    ocr_result.resize(img_list.size());
+    if (cls && this->pri_->classifier_) {
+      this->cls(img_list, ocr_result);
+      for (size_t i = 0; i < img_list.size(); ++i) {
+        if (ocr_result[i].cls_label % 2 == 1 &&
+            ocr_result[i].cls_score > this->pri_->classifier_->cls_thresh) {
+          cv::rotate(img_list[i], img_list[i], 1);
+        }
+      }
+    }
+    if (rec) {
+      this->rec(img_list, ocr_result);
+    }
+    for (size_t i = 0; i < ocr_result.size(); ++i) {
+      ocr_results.emplace_back(1, std::move(ocr_result[i]));
+    }
+  } else {
+    for (size_t i = 0; i < img_list.size(); ++i) {
+      std::vector<OCRPredictResult> ocr_result =
+          this->ocr(img_list[i], true, rec, cls);
+      ocr_results.emplace_back(std::move(ocr_result));
+    }
+  }
+  return ocr_results;
+}
+
+std::vector<OCRPredictResult> PPOCR::ocr(const cv::Mat &img, bool det, bool rec,
+                                         bool cls) noexcept {
+
+  std::vector<OCRPredictResult> ocr_result;
+  // det
+  this->det(img, ocr_result);
+  // crop image
+  std::vector<cv::Mat> img_list;
+  for (size_t j = 0; j < ocr_result.size(); ++j) {
+    cv::Mat crop_img = Utility::GetRotateCropImage(img, ocr_result[j].box);
+    img_list.emplace_back(std::move(crop_img));
+  }
+  // cls
+  if (cls && this->pri_->classifier_) {
+    this->cls(img_list, ocr_result);
+    for (size_t i = 0; i < img_list.size(); ++i) {
+      if (ocr_result[i].cls_label % 2 == 1 &&
+          ocr_result[i].cls_score > this->pri_->classifier_->cls_thresh) {
+        cv::rotate(img_list[i], img_list[i], 1);
+      }
+    }
+  }
+  // rec
+  if (rec) {
+    this->rec(img_list, ocr_result);
+  }
+  return ocr_result;
+}
+
+void PPOCR::det(const cv::Mat &img,
+                std::vector<OCRPredictResult> &ocr_results) noexcept {
+  std::vector<std::vector<std::vector<int>>> boxes;
+  std::vector<double> det_times;
+
+  this->pri_->detector_->Run(img, boxes, det_times);
+
+  for (size_t i = 0; i < boxes.size(); ++i) {
+    OCRPredictResult res;
+    res.box = std::move(boxes[i]);
+    ocr_results.emplace_back(std::move(res));
+  }
+  // sort boex from top to bottom, from left to right
+  Utility::sort_boxes(ocr_results);
+  this->time_info_det[0] += det_times[0];
+  this->time_info_det[1] += det_times[1];
+  this->time_info_det[2] += det_times[2];
+}
+
+void PPOCR::rec(const std::vector<cv::Mat> &img_list,
+                std::vector<OCRPredictResult> &ocr_results) noexcept {
+  std::vector<std::string> rec_texts(img_list.size(), std::string());
+  std::vector<float> rec_text_scores(img_list.size(), 0);
+  std::vector<double> rec_times;
+  this->pri_->recognizer_->Run(img_list, rec_texts, rec_text_scores, rec_times);
+  // output rec results
+  for (size_t i = 0; i < rec_texts.size(); ++i) {
+    ocr_results[i].text = std::move(rec_texts[i]);
+    ocr_results[i].score = rec_text_scores[i];
+  }
+  this->time_info_rec[0] += rec_times[0];
+  this->time_info_rec[1] += rec_times[1];
+  this->time_info_rec[2] += rec_times[2];
+}
+
+void PPOCR::cls(const std::vector<cv::Mat> &img_list,
+                std::vector<OCRPredictResult> &ocr_results) noexcept {
+  std::vector<int> cls_labels(img_list.size(), 0);
+  std::vector<float> cls_scores(img_list.size(), 0);
+  std::vector<double> cls_times;
+  this->pri_->classifier_->Run(img_list, cls_labels, cls_scores, cls_times);
+  // output cls results
+  for (size_t i = 0; i < cls_labels.size(); ++i) {
+    ocr_results[i].cls_label = cls_labels[i];
+    ocr_results[i].cls_score = cls_scores[i];
+  }
+  this->time_info_cls[0] += cls_times[0];
+  this->time_info_cls[1] += cls_times[1];
+  this->time_info_cls[2] += cls_times[2];
+}
+
+void PPOCR::reset_timer() noexcept {
+  this->time_info_det = {0, 0, 0};
+  this->time_info_rec = {0, 0, 0};
+  this->time_info_cls = {0, 0, 0};
+}
+
+void PPOCR::benchmark_log(int img_num) noexcept {
+  if (this->time_info_det[0] + this->time_info_det[1] + this->time_info_det[2] >
+      0) {
+    AutoLogger autolog_det("ocr_det", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads, 1, "dynamic",
+                           FLAGS_precision, this->time_info_det, img_num);
+    autolog_det.report();
+  }
+  if (this->time_info_rec[0] + this->time_info_rec[1] + this->time_info_rec[2] >
+      0) {
+    AutoLogger autolog_rec("ocr_rec", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                           FLAGS_rec_batch_num, "dynamic", FLAGS_precision,
+                           this->time_info_rec, img_num);
+    autolog_rec.report();
+  }
+  if (this->time_info_cls[0] + this->time_info_cls[1] + this->time_info_cls[2] >
+      0) {
+    AutoLogger autolog_cls("ocr_cls", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                           FLAGS_cls_batch_num, "dynamic", FLAGS_precision,
+                           this->time_info_cls, img_num);
+    autolog_cls.report();
+  }
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/paddlestructure.cpp

@@ -0,0 +1,299 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/args.h>
+#include <include/paddlestructure.h>
+#include <include/structure_layout.h>
+#include <include/structure_table.h>
+
+#include <auto_log/autolog.h>
+
+namespace PaddleOCR {
+
+struct PaddleStructure::STRUCTURE_PRIVATE {
+  std::unique_ptr<StructureTableRecognizer> table_model_;
+  std::unique_ptr<StructureLayoutRecognizer> layout_model_;
+};
+
+PaddleStructure::PaddleStructure() noexcept : pri_(new STRUCTURE_PRIVATE) {
+  if (FLAGS_layout) {
+    this->pri_->layout_model_.reset(new StructureLayoutRecognizer(
+        FLAGS_layout_model_dir, FLAGS_use_gpu, FLAGS_gpu_id, FLAGS_gpu_mem,
+        FLAGS_cpu_threads, FLAGS_enable_mkldnn, FLAGS_layout_dict_path,
+        FLAGS_use_tensorrt, FLAGS_precision, FLAGS_layout_score_threshold,
+        FLAGS_layout_nms_threshold));
+  }
+  if (FLAGS_table) {
+    this->pri_->table_model_.reset(new StructureTableRecognizer(
+        FLAGS_table_model_dir, FLAGS_use_gpu, FLAGS_gpu_id, FLAGS_gpu_mem,
+        FLAGS_cpu_threads, FLAGS_enable_mkldnn, FLAGS_table_char_dict_path,
+        FLAGS_use_tensorrt, FLAGS_precision, FLAGS_table_batch_num,
+        FLAGS_table_max_len, FLAGS_merge_no_span_structure));
+  }
+}
+
+PaddleStructure::~PaddleStructure() { delete this->pri_; }
+
+std::vector<StructurePredictResult>
+PaddleStructure::structure(const cv::Mat &srcimg, bool layout, bool table,
+                           bool ocr) noexcept {
+  cv::Mat img;
+  srcimg.copyTo(img);
+
+  std::vector<StructurePredictResult> structure_results;
+
+  if (layout) {
+    this->layout(img, structure_results);
+  } else {
+    StructurePredictResult res;
+    res.type = "table";
+    res.box.resize(4, 0.0);
+    res.box[2] = img.cols;
+    res.box[3] = img.rows;
+    structure_results.emplace_back(std::move(res));
+  }
+  cv::Mat roi_img;
+  for (size_t i = 0; i < structure_results.size(); ++i) {
+    // crop image
+    roi_img = std::move(Utility::crop_image(img, structure_results[i].box));
+    if (structure_results[i].type == "table" && table) {
+      this->table(roi_img, structure_results[i]);
+    } else if (ocr) {
+      structure_results[i].text_res =
+          std::move(this->ocr(roi_img, true, true, false));
+    }
+  }
+
+  return structure_results;
+}
+
+void PaddleStructure::layout(
+    const cv::Mat &img,
+    std::vector<StructurePredictResult> &structure_result) noexcept {
+  std::vector<double> layout_times;
+  this->pri_->layout_model_->Run(img, structure_result, layout_times);
+
+  this->time_info_layout[0] += layout_times[0];
+  this->time_info_layout[1] += layout_times[1];
+  this->time_info_layout[2] += layout_times[2];
+}
+
+void PaddleStructure::table(const cv::Mat &img,
+                            StructurePredictResult &structure_result) noexcept {
+  // predict structure
+  std::vector<std::vector<std::string>> structure_html_tags;
+  std::vector<float> structure_scores(1, 0);
+  std::vector<std::vector<std::vector<int>>> structure_boxes;
+  std::vector<double> structure_times;
+  std::vector<cv::Mat> img_list(1, img);
+
+  this->pri_->table_model_->Run(img_list, structure_html_tags, structure_scores,
+                                structure_boxes, structure_times);
+
+  this->time_info_table[0] += structure_times[0];
+  this->time_info_table[1] += structure_times[1];
+  this->time_info_table[2] += structure_times[2];
+
+  std::vector<OCRPredictResult> ocr_result;
+  int expand_pixel = 3;
+
+  for (size_t i = 0; i < img_list.size(); ++i) {
+    // det
+    this->det(img_list[i], ocr_result);
+    // crop image
+    std::vector<cv::Mat> rec_img_list;
+    std::vector<int> ocr_box;
+    for (size_t j = 0; j < ocr_result.size(); ++j) {
+      ocr_box = std::move(Utility::xyxyxyxy2xyxy(ocr_result[j].box));
+      ocr_box[0] = std::max(0, ocr_box[0] - expand_pixel);
+      ocr_box[1] = std::max(0, ocr_box[1] - expand_pixel),
+      ocr_box[2] = std::min(img_list[i].cols, ocr_box[2] + expand_pixel);
+      ocr_box[3] = std::min(img_list[i].rows, ocr_box[3] + expand_pixel);
+
+      cv::Mat crop_img = Utility::crop_image(img_list[i], ocr_box);
+      rec_img_list.emplace_back(std::move(crop_img));
+    }
+    // rec
+    this->rec(rec_img_list, ocr_result);
+    // rebuild table
+    structure_result.html = std::move(this->rebuild_table(
+        structure_html_tags[i], structure_boxes[i], ocr_result));
+    structure_result.cell_box = std::move(structure_boxes[i]);
+    structure_result.html_score = structure_scores[i];
+  }
+}
+
+std::string PaddleStructure::rebuild_table(
+    const std::vector<std::string> &structure_html_tags,
+    const std::vector<std::vector<int>> &structure_boxes,
+    std::vector<OCRPredictResult> &ocr_result) noexcept {
+  // match text in same cell
+  std::vector<std::vector<std::string>> matched(structure_boxes.size(),
+                                                std::vector<std::string>());
+
+  std::vector<int> ocr_box;
+  std::vector<int> structure_box;
+  for (size_t i = 0; i < ocr_result.size(); ++i) {
+    ocr_box = std::move(Utility::xyxyxyxy2xyxy(ocr_result[i].box));
+    ocr_box[0] -= 1;
+    ocr_box[1] -= 1;
+    ocr_box[2] += 1;
+    ocr_box[3] += 1;
+    std::vector<std::vector<float>> dis_list(structure_boxes.size(),
+                                             std::vector<float>(3, 100000.0));
+    for (size_t j = 0; j < structure_boxes.size(); ++j) {
+      if (structure_boxes[j].size() == 8) {
+        structure_box = std::move(Utility::xyxyxyxy2xyxy(structure_boxes[j]));
+      } else {
+        structure_box = structure_boxes[j];
+      }
+      dis_list[j][0] = this->dis(ocr_box, structure_box);
+      dis_list[j][1] = 1 - Utility::iou(ocr_box, structure_box);
+      dis_list[j][2] = j;
+    }
+    // find min dis idx
+    std::sort(dis_list.begin(), dis_list.end(),
+              PaddleStructure::comparison_dis);
+    matched[dis_list[0][2]].emplace_back(ocr_result[i].text);
+  }
+
+  // get pred html
+  std::string html_str = "";
+  int td_tag_idx = 0;
+  for (size_t i = 0; i < structure_html_tags.size(); ++i) {
+    if (structure_html_tags[i].find("</td>") != std::string::npos) {
+      if (structure_html_tags[i].find("<td></td>") != std::string::npos) {
+        html_str += "<td>";
+      }
+      if (matched[td_tag_idx].size() > 0) {
+        bool b_with = false;
+        if (matched[td_tag_idx][0].find("<b>") != std::string::npos &&
+            matched[td_tag_idx].size() > 1) {
+          b_with = true;
+          html_str += "<b>";
+        }
+        for (size_t j = 0; j < matched[td_tag_idx].size(); ++j) {
+          std::string content = matched[td_tag_idx][j];
+          if (matched[td_tag_idx].size() > 1) {
+            // remove blank, <b> and </b>
+            if (content.length() > 0 && content.at(0) == ' ') {
+              content = content.substr(0);
+            }
+            if (content.length() > 2 && content.substr(0, 3) == "<b>") {
+              content = content.substr(3);
+            }
+            if (content.length() > 4 &&
+                content.substr(content.length() - 4) == "</b>") {
+              content = content.substr(0, content.length() - 4);
+            }
+            if (content.empty()) {
+              continue;
+            }
+            // add blank
+            if (j != matched[td_tag_idx].size() - 1 &&
+                content.at(content.length() - 1) != ' ') {
+              content += ' ';
+            }
+          }
+          html_str += content;
+        }
+        if (b_with) {
+          html_str += "</b>";
+        }
+      }
+      if (structure_html_tags[i].find("<td></td>") != std::string::npos) {
+        html_str += "</td>";
+      } else {
+        html_str += structure_html_tags[i];
+      }
+      td_tag_idx += 1;
+    } else {
+      html_str += structure_html_tags[i];
+    }
+  }
+  return html_str;
+}
+
+float PaddleStructure::dis(const std::vector<int> &box1,
+                           const std::vector<int> &box2) noexcept {
+  int x1_1 = box1[0];
+  int y1_1 = box1[1];
+  int x2_1 = box1[2];
+  int y2_1 = box1[3];
+
+  int x1_2 = box2[0];
+  int y1_2 = box2[1];
+  int x2_2 = box2[2];
+  int y2_2 = box2[3];
+
+  float dis =
+      abs(x1_2 - x1_1) + abs(y1_2 - y1_1) + abs(x2_2 - x2_1) + abs(y2_2 - y2_1);
+  float dis_2 = abs(x1_2 - x1_1) + abs(y1_2 - y1_1);
+  float dis_3 = abs(x2_2 - x2_1) + abs(y2_2 - y2_1);
+  return dis + std::min(dis_2, dis_3);
+}
+
+void PaddleStructure::reset_timer() noexcept {
+  this->time_info_det = {0, 0, 0};
+  this->time_info_rec = {0, 0, 0};
+  this->time_info_cls = {0, 0, 0};
+  this->time_info_table = {0, 0, 0};
+  this->time_info_layout = {0, 0, 0};
+}
+
+void PaddleStructure::benchmark_log(int img_num) noexcept {
+  if (this->time_info_det[0] + this->time_info_det[1] + this->time_info_det[2] >
+      0) {
+    AutoLogger autolog_det("ocr_det", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads, 1, "dynamic",
+                           FLAGS_precision, this->time_info_det, img_num);
+    autolog_det.report();
+  }
+  if (this->time_info_rec[0] + this->time_info_rec[1] + this->time_info_rec[2] >
+      0) {
+    AutoLogger autolog_rec("ocr_rec", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                           FLAGS_rec_batch_num, "dynamic", FLAGS_precision,
+                           this->time_info_rec, img_num);
+    autolog_rec.report();
+  }
+  if (this->time_info_cls[0] + this->time_info_cls[1] + this->time_info_cls[2] >
+      0) {
+    AutoLogger autolog_cls("ocr_cls", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                           FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                           FLAGS_cls_batch_num, "dynamic", FLAGS_precision,
+                           this->time_info_cls, img_num);
+    autolog_cls.report();
+  }
+  if (this->time_info_table[0] + this->time_info_table[1] +
+          this->time_info_table[2] >
+      0) {
+    AutoLogger autolog_table("table", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                             FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                             FLAGS_cls_batch_num, "dynamic", FLAGS_precision,
+                             this->time_info_table, img_num);
+    autolog_table.report();
+  }
+  if (this->time_info_layout[0] + this->time_info_layout[1] +
+          this->time_info_layout[2] >
+      0) {
+    AutoLogger autolog_layout("layout", FLAGS_use_gpu, FLAGS_use_tensorrt,
+                              FLAGS_enable_mkldnn, FLAGS_cpu_threads,
+                              FLAGS_cls_batch_num, "dynamic", FLAGS_precision,
+                              this->time_info_layout, img_num);
+    autolog_layout.report();
+  }
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/postprocess_op.cpp

@@ -0,0 +1,590 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/clipper.h>
+#include <include/postprocess_op.h>
+
+namespace PaddleOCR {
+
+void DBPostProcessor::GetContourArea(const std::vector<std::vector<float>> &box,
+                                     float unclip_ratio,
+                                     float &distance) noexcept {
+  int pts_num = 4;
+  float area = 0.0f;
+  float dist = 0.0f;
+  for (int i = 0; i < pts_num; ++i) {
+    area += box[i][0] * box[(i + 1) % pts_num][1] -
+            box[i][1] * box[(i + 1) % pts_num][0];
+    dist += sqrtf((box[i][0] - box[(i + 1) % pts_num][0]) *
+                      (box[i][0] - box[(i + 1) % pts_num][0]) +
+                  (box[i][1] - box[(i + 1) % pts_num][1]) *
+                      (box[i][1] - box[(i + 1) % pts_num][1]));
+  }
+  area = fabs(float(area / 2.0));
+
+  distance = area * unclip_ratio / dist;
+}
+
+cv::RotatedRect
+DBPostProcessor::UnClip(const std::vector<std::vector<float>> &box,
+                        const float &unclip_ratio) noexcept {
+  float distance = 1.0;
+
+  GetContourArea(box, unclip_ratio, distance);
+
+  ClipperLib::ClipperOffset offset;
+  ClipperLib::Path p;
+  p.emplace_back(int(box[0][0]), int(box[0][1]));
+  p.emplace_back(int(box[1][0]), int(box[1][1]));
+  p.emplace_back(int(box[2][0]), int(box[2][1]));
+  p.emplace_back(int(box[3][0]), int(box[3][1]));
+  offset.AddPath(p, ClipperLib::jtRound, ClipperLib::etClosedPolygon);
+
+  ClipperLib::Paths soln;
+  if (!offset.Execute(soln, distance))
+    return cv::RotatedRect();
+
+  std::vector<cv::Point2f> points;
+
+  for (size_t j = 0; j < soln.size(); ++j) {
+    for (size_t i = 0; i < soln[soln.size() - 1].size(); ++i) {
+      points.emplace_back(soln[j][i].X, soln[j][i].Y);
+    }
+  }
+  cv::RotatedRect res;
+  if (points.size() <= 0) {
+    res = cv::RotatedRect(cv::Point2f(0, 0), cv::Size2f(1, 1), 0);
+  } else {
+    res = cv::minAreaRect(points);
+  }
+  return res;
+}
+
+float **DBPostProcessor::Mat2Vec(const cv::Mat &mat) noexcept {
+  auto **array = new float *[mat.rows];
+  for (int i = 0; i < mat.rows; ++i)
+    array[i] = new float[mat.cols];
+  for (int i = 0; i < mat.rows; ++i) {
+    for (int j = 0; j < mat.cols; ++j) {
+      array[i][j] = mat.at<float>(i, j);
+    }
+  }
+
+  return array;
+}
+
+std::vector<std::vector<int>> DBPostProcessor::OrderPointsClockwise(
+    const std::vector<std::vector<int>> &pts) noexcept {
+  std::vector<std::vector<int>> box = pts;
+  std::sort(box.begin(), box.end(), XsortInt);
+
+  std::vector<std::vector<int>> leftmost = {box[0], box[1]};
+  std::vector<std::vector<int>> rightmost = {box[2], box[3]};
+
+  if (leftmost[0][1] > leftmost[1][1])
+    std::swap(leftmost[0], leftmost[1]);
+
+  if (rightmost[0][1] > rightmost[1][1])
+    std::swap(rightmost[0], rightmost[1]);
+
+  std::vector<std::vector<int>> rect = {leftmost[0], rightmost[0], rightmost[1],
+                                        leftmost[1]};
+  return rect;
+}
+
+std::vector<std::vector<float>>
+DBPostProcessor::Mat2Vector(const cv::Mat &mat) noexcept {
+  std::vector<std::vector<float>> img_vec;
+
+  for (int i = 0; i < mat.rows; ++i) {
+    std::vector<float> tmp;
+    for (int j = 0; j < mat.cols; ++j) {
+      tmp.emplace_back(mat.at<float>(i, j));
+    }
+    img_vec.emplace_back(std::move(tmp));
+  }
+  return img_vec;
+}
+
+bool DBPostProcessor::XsortFp32(const std::vector<float> &a,
+                                const std::vector<float> &b) noexcept {
+  if (a[0] != b[0])
+    return a[0] < b[0];
+  return false;
+}
+
+bool DBPostProcessor::XsortInt(const std::vector<int> &a,
+                               const std::vector<int> &b) noexcept {
+  if (a[0] != b[0])
+    return a[0] < b[0];
+  return false;
+}
+
+std::vector<std::vector<float>>
+DBPostProcessor::GetMiniBoxes(const cv::RotatedRect &box,
+                              float &ssid) noexcept {
+  ssid = std::max(box.size.width, box.size.height);
+
+  cv::Mat points;
+  cv::boxPoints(box, points);
+
+  auto array = Mat2Vector(points);
+  std::sort(array.begin(), array.end(), XsortFp32);
+
+  std::vector<float> idx1 = array[0], idx2 = array[1], idx3 = array[2],
+                     idx4 = array[3];
+  if (array[3][1] <= array[2][1]) {
+    idx2 = array[3];
+    idx3 = array[2];
+  } else {
+    idx2 = array[2];
+    idx3 = array[3];
+  }
+  if (array[1][1] <= array[0][1]) {
+    idx1 = array[1];
+    idx4 = array[0];
+  } else {
+    idx1 = array[0];
+    idx4 = array[1];
+  }
+
+  array[0] = idx1;
+  array[1] = idx2;
+  array[2] = idx3;
+  array[3] = idx4;
+
+  return array;
+}
+
+float DBPostProcessor::PolygonScoreAcc(const std::vector<cv::Point> &contour,
+                                       const cv::Mat &pred) noexcept {
+  int width = pred.cols;
+  int height = pred.rows;
+  std::vector<float> box_x;
+  std::vector<float> box_y;
+  for (size_t i = 0; i < contour.size(); ++i) {
+    box_x.emplace_back(contour[i].x);
+    box_y.emplace_back(contour[i].y);
+  }
+
+  int xmin =
+      clamp(int(std::floor(*(std::min_element(box_x.begin(), box_x.end())))), 0,
+            width - 1);
+  int xmax =
+      clamp(int(std::ceil(*(std::max_element(box_x.begin(), box_x.end())))), 0,
+            width - 1);
+  int ymin =
+      clamp(int(std::floor(*(std::min_element(box_y.begin(), box_y.end())))), 0,
+            height - 1);
+  int ymax =
+      clamp(int(std::ceil(*(std::max_element(box_y.begin(), box_y.end())))), 0,
+            height - 1);
+
+  cv::Mat mask;
+  mask = cv::Mat::zeros(ymax - ymin + 1, xmax - xmin + 1, CV_8UC1);
+
+  cv::Point *rook_point = new cv::Point[contour.size()];
+
+  for (size_t i = 0; i < contour.size(); ++i) {
+    rook_point[i] = cv::Point(int(box_x[i]) - xmin, int(box_y[i]) - ymin);
+  }
+  const cv::Point *ppt[1] = {rook_point};
+  int npt[] = {int(contour.size())};
+
+  cv::fillPoly(mask, ppt, npt, 1, cv::Scalar(1));
+
+  cv::Mat croppedImg;
+  pred(cv::Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
+      .copyTo(croppedImg);
+  float score = cv::mean(croppedImg, mask)[0];
+
+  delete[] rook_point;
+  return score;
+}
+
+float DBPostProcessor::BoxScoreFast(
+    const std::vector<std::vector<float>> &box_array,
+    const cv::Mat &pred) noexcept {
+  const auto &array = box_array;
+  int width = pred.cols;
+  int height = pred.rows;
+
+  float box_x[4] = {array[0][0], array[1][0], array[2][0], array[3][0]};
+  float box_y[4] = {array[0][1], array[1][1], array[2][1], array[3][1]};
+
+  int xmin = clamp(int(std::floor(*(std::min_element(box_x, box_x + 4)))), 0,
+                   width - 1);
+  int xmax = clamp(int(std::ceil(*(std::max_element(box_x, box_x + 4)))), 0,
+                   width - 1);
+  int ymin = clamp(int(std::floor(*(std::min_element(box_y, box_y + 4)))), 0,
+                   height - 1);
+  int ymax = clamp(int(std::ceil(*(std::max_element(box_y, box_y + 4)))), 0,
+                   height - 1);
+
+  cv::Mat mask;
+  mask = cv::Mat::zeros(ymax - ymin + 1, xmax - xmin + 1, CV_8UC1);
+
+  cv::Point root_point[4];
+  root_point[0] = cv::Point(int(array[0][0]) - xmin, int(array[0][1]) - ymin);
+  root_point[1] = cv::Point(int(array[1][0]) - xmin, int(array[1][1]) - ymin);
+  root_point[2] = cv::Point(int(array[2][0]) - xmin, int(array[2][1]) - ymin);
+  root_point[3] = cv::Point(int(array[3][0]) - xmin, int(array[3][1]) - ymin);
+  const cv::Point *ppt[1] = {root_point};
+  int npt[] = {4};
+  cv::fillPoly(mask, ppt, npt, 1, cv::Scalar(1));
+
+  cv::Mat croppedImg;
+  pred(cv::Rect(xmin, ymin, xmax - xmin + 1, ymax - ymin + 1))
+      .copyTo(croppedImg);
+
+  auto score = cv::mean(croppedImg, mask)[0];
+  return score;
+}
+
+std::vector<std::vector<std::vector<int>>> DBPostProcessor::BoxesFromBitmap(
+    const cv::Mat &pred, const cv::Mat &bitmap, const float &box_thresh,
+    const float &det_db_unclip_ratio,
+    const std::string &det_db_score_mode) noexcept {
+  const int min_size = 3;
+  const int max_candidates = 1000;
+
+  int width = bitmap.cols;
+  int height = bitmap.rows;
+
+  std::vector<std::vector<cv::Point>> contours;
+  std::vector<cv::Vec4i> hierarchy;
+
+  cv::findContours(bitmap, contours, hierarchy, cv::RETR_LIST,
+                   cv::CHAIN_APPROX_SIMPLE);
+
+  int num_contours =
+      contours.size() >= max_candidates ? max_candidates : contours.size();
+
+  std::vector<std::vector<std::vector<int>>> boxes;
+
+  for (int _i = 0; _i < num_contours; ++_i) {
+    if (contours[_i].size() <= 2) {
+      continue;
+    }
+    float ssid;
+    cv::RotatedRect box = cv::minAreaRect(contours[_i]);
+    auto array = GetMiniBoxes(box, ssid);
+
+    auto box_for_unclip = array;
+    // end get_mini_box
+
+    if (ssid < min_size) {
+      continue;
+    }
+
+    float score;
+    if (det_db_score_mode == "slow")
+      /* compute using polygon*/
+      score = PolygonScoreAcc(contours[_i], pred);
+    else
+      score = BoxScoreFast(array, pred);
+
+    if (score < box_thresh)
+      continue;
+
+    // start for unclip
+    cv::RotatedRect points = UnClip(box_for_unclip, det_db_unclip_ratio);
+    if (points.size.height < 1.001 && points.size.width < 1.001) {
+      continue;
+    }
+    // end for unclip
+
+    cv::RotatedRect clipbox = points;
+    auto cliparray = GetMiniBoxes(clipbox, ssid);
+
+    if (ssid < min_size + 2)
+      continue;
+
+    int dest_width = pred.cols;
+    int dest_height = pred.rows;
+    std::vector<std::vector<int>> intcliparray;
+
+    for (int num_pt = 0; num_pt < 4; ++num_pt) {
+      std::vector<int> a{int(clampf(roundf(cliparray[num_pt][0] / float(width) *
+                                           float(dest_width)),
+                                    0, float(dest_width))),
+                         int(clampf(roundf(cliparray[num_pt][1] /
+                                           float(height) * float(dest_height)),
+                                    0, float(dest_height)))};
+      intcliparray.emplace_back(std::move(a));
+    }
+    boxes.emplace_back(std::move(intcliparray));
+
+  } // end for
+  return boxes;
+}
+
+void DBPostProcessor::FilterTagDetRes(
+    std::vector<std::vector<std::vector<int>>> &boxes, float ratio_h,
+    float ratio_w, const cv::Mat &srcimg) noexcept {
+  int oriimg_h = srcimg.rows;
+  int oriimg_w = srcimg.cols;
+
+  std::vector<std::vector<std::vector<int>>> root_points;
+  for (size_t n = 0; n < boxes.size(); ++n) {
+    boxes[n] = OrderPointsClockwise(boxes[n]);
+    for (size_t m = 0; m < boxes[0].size(); ++m) {
+      boxes[n][m][0] /= ratio_w;
+      boxes[n][m][1] /= ratio_h;
+
+      boxes[n][m][0] = int(_min(_max(boxes[n][m][0], 0), oriimg_w - 1));
+      boxes[n][m][1] = int(_min(_max(boxes[n][m][1], 0), oriimg_h - 1));
+    }
+  }
+
+  for (size_t n = 0; n < boxes.size(); ++n) {
+    int rect_width, rect_height;
+    rect_width = int(sqrt(pow(boxes[n][0][0] - boxes[n][1][0], 2) +
+                          pow(boxes[n][0][1] - boxes[n][1][1], 2)));
+    rect_height = int(sqrt(pow(boxes[n][0][0] - boxes[n][3][0], 2) +
+                           pow(boxes[n][0][1] - boxes[n][3][1], 2)));
+    if (rect_width <= 4 || rect_height <= 4)
+      continue;
+    root_points.emplace_back(boxes[n]);
+  }
+  boxes = std::move(root_points);
+}
+
+void TablePostProcessor::init(const std::string &label_path,
+                              bool merge_no_span_structure) noexcept {
+  this->label_list_ = Utility::ReadDict(label_path);
+  if (merge_no_span_structure) {
+    this->label_list_.emplace_back("<td></td>");
+    std::vector<std::string>::iterator it;
+    for (it = this->label_list_.begin(); it != this->label_list_.end();) {
+      if (*it == "<td>") {
+        it = this->label_list_.erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+  // add_special_char
+  this->label_list_.emplace(this->label_list_.begin(), this->beg);
+  this->label_list_.emplace_back(this->end);
+}
+
+void TablePostProcessor::Run(
+    const std::vector<float> &loc_preds,
+    const std::vector<float> &structure_probs, std::vector<float> &rec_scores,
+    const std::vector<int> &loc_preds_shape,
+    const std::vector<int> &structure_probs_shape,
+    std::vector<std::vector<std::string>> &rec_html_tag_batch,
+    std::vector<std::vector<std::vector<int>>> &rec_boxes_batch,
+    const std::vector<int> &width_list,
+    const std::vector<int> &height_list) noexcept {
+  for (int batch_idx = 0; batch_idx < structure_probs_shape[0]; ++batch_idx) {
+    // image tags and boxes
+    std::vector<std::string> rec_html_tags;
+    std::vector<std::vector<int>> rec_boxes;
+
+    float score = 0.f;
+    int count = 0;
+    float char_score = 0.f;
+    int char_idx = 0;
+
+    // step
+    for (int step_idx = 0; step_idx < structure_probs_shape[1]; ++step_idx) {
+      std::string html_tag;
+      std::vector<int> rec_box;
+      // html tag
+      int step_start_idx = (batch_idx * structure_probs_shape[1] + step_idx) *
+                           structure_probs_shape[2];
+      char_idx = int(Utility::argmax(
+          &structure_probs[step_start_idx],
+          &structure_probs[step_start_idx + structure_probs_shape[2]]));
+      char_score = float(*std::max_element(
+          &structure_probs[step_start_idx],
+          &structure_probs[step_start_idx + structure_probs_shape[2]]));
+      html_tag = this->label_list_[char_idx];
+
+      if (step_idx > 0 && html_tag == this->end) {
+        break;
+      }
+      if (html_tag == this->beg) {
+        continue;
+      }
+      count += 1;
+      score += char_score;
+      rec_html_tags.emplace_back(html_tag);
+
+      // box
+      if (html_tag == "<td>" || html_tag == "<td" || html_tag == "<td></td>") {
+        for (int point_idx = 0; point_idx < loc_preds_shape[2]; ++point_idx) {
+          step_start_idx = (batch_idx * structure_probs_shape[1] + step_idx) *
+                               loc_preds_shape[2] +
+                           point_idx;
+          float point = loc_preds[step_start_idx];
+          if (point_idx % 2 == 0) {
+            point = int(point * width_list[batch_idx]);
+          } else {
+            point = int(point * height_list[batch_idx]);
+          }
+          rec_box.emplace_back(point);
+        }
+        rec_boxes.emplace_back(std::move(rec_box));
+      }
+    }
+    score /= count;
+    if (std::isnan(score) || rec_boxes.size() == 0) {
+      score = -1;
+    }
+    rec_scores.emplace_back(score);
+    rec_boxes_batch.emplace_back(std::move(rec_boxes));
+    rec_html_tag_batch.emplace_back(std::move(rec_html_tags));
+  }
+}
+
+void PicodetPostProcessor::init(const std::string &label_path,
+                                const double score_threshold,
+                                const double nms_threshold,
+                                const std::vector<int> &fpn_stride) noexcept {
+  this->label_list_ = Utility::ReadDict(label_path);
+  this->score_threshold_ = score_threshold;
+  this->nms_threshold_ = nms_threshold;
+  this->num_class_ = label_list_.size();
+  this->fpn_stride_ = fpn_stride;
+}
+
+void PicodetPostProcessor::Run(std::vector<StructurePredictResult> &results,
+                               const std::vector<std::vector<float>> &outs,
+                               const std::vector<int> &ori_shape,
+                               const std::vector<int> &resize_shape,
+                               int reg_max) noexcept {
+  int in_h = resize_shape[0];
+  int in_w = resize_shape[1];
+  float scale_factor_h = resize_shape[0] / float(ori_shape[0]);
+  float scale_factor_w = resize_shape[1] / float(ori_shape[1]);
+
+  std::vector<std::vector<StructurePredictResult>> bbox_results;
+  bbox_results.resize(this->num_class_);
+  for (size_t i = 0; i < this->fpn_stride_.size(); ++i) {
+    const int feature_h = std::ceil((float)in_h / this->fpn_stride_[i]);
+    const int feature_w = std::ceil((float)in_w / this->fpn_stride_[i]);
+    const size_t hxw = feature_h * feature_w;
+    for (size_t idx = 0; idx < hxw; ++idx) {
+      // score and label
+      float score = 0;
+      int cur_label = 0;
+      for (size_t label = 0; label < this->label_list_.size(); ++label) {
+        float osc = outs[i][idx * this->label_list_.size() + label];
+        if (osc > score) {
+          score = osc;
+          cur_label = label;
+        }
+      }
+      // bbox
+      if (score > this->score_threshold_) {
+        int row = idx / feature_w;
+        int col = idx % feature_w;
+        std::vector<float>::const_iterator itemp =
+            outs[i + this->fpn_stride_.size()].begin() + idx * 4 * reg_max;
+        std::vector<float> bbox_pred(itemp, itemp + 4 * reg_max);
+        bbox_results[cur_label].emplace_back(std::move(
+            this->disPred2Bbox(bbox_pred, cur_label, score, col, row,
+                               this->fpn_stride_[i], resize_shape, reg_max)));
+      }
+    }
+  }
+#if 0
+  for (size_t i = 0; i < bbox_results.size(); ++i) {
+    bool flag = bbox_results[i].size() <= 0;
+  }
+#endif
+  for (size_t i = 0; i < bbox_results.size(); ++i) {
+    // bool flag = bbox_results[i].size() <= 0;
+    if (bbox_results[i].size() <= 0) {
+      continue;
+    }
+    this->nms(bbox_results[i], this->nms_threshold_);
+    for (auto &box : bbox_results[i]) {
+      box.box[0] = box.box[0] / scale_factor_w;
+      box.box[2] = box.box[2] / scale_factor_w;
+      box.box[1] = box.box[1] / scale_factor_h;
+      box.box[3] = box.box[3] / scale_factor_h;
+      results.emplace_back(std::move(box));
+    }
+  }
+}
+
+StructurePredictResult PicodetPostProcessor::disPred2Bbox(
+    const std::vector<float> &bbox_pred, int label, float score, int x, int y,
+    int stride, const std::vector<int> &im_shape, int reg_max) noexcept {
+  float ct_x = (x + 0.5) * stride;
+  float ct_y = (y + 0.5) * stride;
+  std::vector<float> dis_pred;
+  dis_pred.resize(4);
+  for (int i = 0; i < 4; ++i) {
+    float dis = 0;
+    std::vector<float>::const_iterator itemp = bbox_pred.begin() + i * reg_max;
+    std::vector<float> bbox_pred_i(itemp, itemp + reg_max);
+    std::vector<float> dis_after_sm(
+        std::move(Utility::activation_function_softmax(bbox_pred_i)));
+    for (int j = 0; j < reg_max; ++j) {
+      dis += j * dis_after_sm[j];
+    }
+    dis *= stride;
+    dis_pred[i] = dis;
+  }
+
+  float xmin = (std::max)(ct_x - dis_pred[0], .0f);
+  float ymin = (std::max)(ct_y - dis_pred[1], .0f);
+  float xmax = (std::min)(ct_x + dis_pred[2], (float)im_shape[1]);
+  float ymax = (std::min)(ct_y + dis_pred[3], (float)im_shape[0]);
+
+  StructurePredictResult result_item;
+  result_item.box = {xmin, ymin, xmax, ymax};
+  result_item.type = this->label_list_[label];
+  result_item.confidence = score;
+
+  return result_item;
+}
+
+void PicodetPostProcessor::nms(std::vector<StructurePredictResult> &input_boxes,
+                               float nms_threshold) noexcept {
+  std::sort(input_boxes.begin(), input_boxes.end(),
+            [](StructurePredictResult a, StructurePredictResult b) noexcept {
+              return a.confidence > b.confidence;
+            });
+  std::vector<int> picked(input_boxes.size(), 1);
+
+  for (size_t i = 0; i < input_boxes.size(); ++i) {
+    if (picked[i] == 0) {
+      continue;
+    }
+    for (size_t j = i + 1; j < input_boxes.size(); ++j) {
+      if (picked[j] == 0) {
+        continue;
+      }
+      float iou = Utility::iou(input_boxes[i].box, input_boxes[j].box);
+      if (iou > nms_threshold) {
+        picked[j] = 0;
+      }
+    }
+  }
+  std::vector<StructurePredictResult> input_boxes_nms;
+  for (size_t i = 0; i < input_boxes.size(); ++i) {
+    if (picked[i] == 1) {
+      input_boxes_nms.emplace_back(input_boxes[i]);
+    }
+  }
+  input_boxes = std::move(input_boxes_nms);
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/preprocess_op.cpp

@@ -0,0 +1,166 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/preprocess_op.h>
+
+namespace PaddleOCR {
+
+void Permute::Run(const cv::Mat &im, float *data) noexcept {
+  int rh = im.rows;
+  int rw = im.cols;
+  int rc = im.channels();
+  for (int i = 0; i < rc; ++i) {
+    cv::extractChannel(im, cv::Mat(rh, rw, CV_32FC1, data + i * rh * rw), i);
+  }
+}
+
+void PermuteBatch::Run(const std::vector<cv::Mat> &imgs, float *data) noexcept {
+  for (size_t j = 0; j < imgs.size(); ++j) {
+    int rh = imgs[j].rows;
+    int rw = imgs[j].cols;
+    int rc = imgs[j].channels();
+    for (int i = 0; i < rc; ++i) {
+      cv::extractChannel(
+          imgs[j], cv::Mat(rh, rw, CV_32FC1, data + (j * rc + i) * rh * rw), i);
+    }
+  }
+}
+
+void Normalize::Run(cv::Mat &im, const std::vector<float> &mean,
+                    const std::vector<float> &scale,
+                    const bool is_scale) noexcept {
+  double e = 1.0;
+  if (is_scale) {
+    e /= 255.0;
+  }
+  im.convertTo(im, CV_32FC3, e);
+  std::vector<cv::Mat> bgr_channels(3);
+  cv::split(im, bgr_channels);
+  for (size_t i = 0; i < bgr_channels.size(); ++i) {
+    bgr_channels[i].convertTo(bgr_channels[i], CV_32FC1, 1.0 * scale[i],
+                              (0.0 - mean[i]) * scale[i]);
+  }
+  cv::merge(bgr_channels, im);
+}
+
+void ResizeImgType0::Run(const cv::Mat &img, cv::Mat &resize_img,
+                         const std::string &limit_type, int limit_side_len,
+                         float &ratio_h, float &ratio_w,
+                         bool use_tensorrt) noexcept {
+  int w = img.cols;
+  int h = img.rows;
+  float ratio = 1.f;
+  if (limit_type == "min") {
+    int min_wh = std::min(h, w);
+    if (min_wh < limit_side_len) {
+      if (h < w) {
+        ratio = float(limit_side_len) / float(h);
+      } else {
+        ratio = float(limit_side_len) / float(w);
+      }
+    }
+  } else {
+    int max_wh = std::max(h, w);
+    if (max_wh > limit_side_len) {
+      if (h > w) {
+        ratio = float(limit_side_len) / float(h);
+      } else {
+        ratio = float(limit_side_len) / float(w);
+      }
+    }
+  }
+
+  int resize_h = int(float(h) * ratio);
+  int resize_w = int(float(w) * ratio);
+
+  resize_h = std::max(int(round(float(resize_h) / 32) * 32), 32);
+  resize_w = std::max(int(round(float(resize_w) / 32) * 32), 32);
+
+  cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
+  ratio_h = float(resize_h) / float(h);
+  ratio_w = float(resize_w) / float(w);
+}
+
+void CrnnResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img, float wh_ratio,
+                        bool use_tensorrt,
+                        const std::vector<int> &rec_image_shape) noexcept {
+  int imgC, imgH, imgW;
+  imgC = rec_image_shape[0];
+  imgH = rec_image_shape[1];
+  imgW = rec_image_shape[2];
+
+  imgW = int(imgH * wh_ratio);
+
+  float ratio = float(img.cols) / float(img.rows);
+  int resize_w, resize_h;
+
+  if (ceilf(imgH * ratio) > imgW)
+    resize_w = imgW;
+  else
+    resize_w = int(ceilf(imgH * ratio));
+
+  cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
+             cv::INTER_LINEAR);
+  cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0,
+                     int(imgW - resize_img.cols), cv::BORDER_CONSTANT,
+                     {128, 128, 128});
+}
+
+void ClsResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img,
+                       bool use_tensorrt,
+                       const std::vector<int> &rec_image_shape) noexcept {
+  int imgC, imgH, imgW;
+  imgC = rec_image_shape[0];
+  imgH = rec_image_shape[1];
+  imgW = rec_image_shape[2];
+
+  float ratio = float(img.cols) / float(img.rows);
+  int resize_w, resize_h;
+  if (ceilf(imgH * ratio) > imgW)
+    resize_w = imgW;
+  else
+    resize_w = int(ceilf(imgH * ratio));
+
+  cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
+             cv::INTER_LINEAR);
+}
+
+void TableResizeImg::Run(const cv::Mat &img, cv::Mat &resize_img,
+                         const int max_len) noexcept {
+  int w = img.cols;
+  int h = img.rows;
+
+  int max_wh = w >= h ? w : h;
+  float ratio = w >= h ? float(max_len) / float(w) : float(max_len) / float(h);
+
+  int resize_h = int(float(h) * ratio);
+  int resize_w = int(float(w) * ratio);
+
+  cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
+}
+
+void TablePadImg::Run(const cv::Mat &img, cv::Mat &resize_img,
+                      const int max_len) noexcept {
+  int w = img.cols;
+  int h = img.rows;
+  cv::copyMakeBorder(img, resize_img, 0, max_len - h, 0, max_len - w,
+                     cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
+}
+
+void Resize::Run(const cv::Mat &img, cv::Mat &resize_img, const int h,
+                 const int w) noexcept {
+  cv::resize(img, resize_img, cv::Size(w, h));
+}
+
+} // namespace PaddleOCR

deploy/cpp_infer/src/structure_layout.cpp

@@ -0,0 +1,169 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/structure_layout.h>
+#include <paddle_inference_api.h>
+
+#include <chrono>
+#include <iostream>
+#include <numeric>
+
+namespace PaddleOCR {
+
+void StructureLayoutRecognizer::Run(const cv::Mat &img,
+                                    std::vector<StructurePredictResult> &result,
+                                    std::vector<double> &times) noexcept {
+  std::chrono::duration<float> preprocess_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+  std::chrono::duration<float> inference_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+  std::chrono::duration<float> postprocess_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+
+  // preprocess
+  auto preprocess_start = std::chrono::steady_clock::now();
+
+  cv::Mat srcimg;
+  img.copyTo(srcimg);
+  cv::Mat resize_img;
+  this->resize_op_.Run(srcimg, resize_img, 800, 608);
+  this->normalize_op_.Run(resize_img, this->mean_, this->scale_,
+                          this->is_scale_);
+
+  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();
+  preprocess_diff += preprocess_end - preprocess_start;
+
+  // 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();
+
+  // Get output tensor
+  std::vector<std::vector<float>> out_tensor_list;
+  std::vector<std::vector<int>> output_shape_list;
+  auto output_names = this->predictor_->GetOutputNames();
+  for (size_t j = 0; j < output_names.size(); ++j) {
+    auto output_tensor = this->predictor_->GetOutputHandle(output_names[j]);
+    std::vector<int> output_shape = output_tensor->shape();
+    int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1,
+                                  std::multiplies<int>());
+    output_shape_list.emplace_back(std::move(output_shape));
+
+    std::vector<float> out_data;
+    out_data.resize(out_num);
+    output_tensor->CopyToCpu(out_data.data());
+    out_tensor_list.emplace_back(std::move(out_data));
+  }
+  auto inference_end = std::chrono::steady_clock::now();
+  inference_diff += inference_end - inference_start;
+
+  // postprocess
+  auto postprocess_start = std::chrono::steady_clock::now();
+
+  std::vector<int> bbox_num;
+  int reg_max = 0;
+  for (size_t i = 0; i < out_tensor_list.size(); ++i) {
+    if (i == this->post_processor_.fpn_stride_size()) {
+      reg_max = output_shape_list[i][2] / 4;
+      break;
+    }
+  }
+  std::vector<int> ori_shape = {srcimg.rows, srcimg.cols};
+  std::vector<int> resize_shape = {resize_img.rows, resize_img.cols};
+  this->post_processor_.Run(result, out_tensor_list, ori_shape, resize_shape,
+                            reg_max);
+  bbox_num.emplace_back(result.size());
+
+  auto postprocess_end = std::chrono::steady_clock::now();
+  postprocess_diff += postprocess_end - postprocess_start;
+  times.emplace_back(preprocess_diff.count() * 1000);
+  times.emplace_back(inference_diff.count() * 1000);
+  times.emplace_back(postprocess_diff.count() * 1000);
+}
+
+void StructureLayoutRecognizer::LoadModel(
+    const std::string &model_dir) noexcept {
+  paddle_infer::Config config;
+  bool json_model = false;
+  std::string model_file_path, param_file_path;
+  std::vector<std::pair<std::string, std::string>> model_variants = {
+      {"/inference.json", "/inference.pdiparams"},
+      {"/model.json", "/model.pdiparams"},
+      {"/inference.pdmodel", "/inference.pdiparams"},
+      {"/model.pdmodel", "/model.pdiparams"}};
+  for (const auto &variant : model_variants) {
+    if (Utility::PathExists(model_dir + variant.first)) {
+      model_file_path = model_dir + variant.first;
+      param_file_path = model_dir + variant.second;
+      json_model = (variant.first.find(".json") != std::string::npos);
+      break;
+    }
+  }
+  if (model_file_path.empty()) {
+    std::cerr << "[ERROR] No valid model file found in " << model_dir
+              << std::endl;
+    exit(1);
+  }
+  config.SetModel(model_file_path, param_file_path);
+
+  if (this->use_gpu_) {
+    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+      if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      }
+      config.EnableTensorRtEngine(1 << 20, 10, 3, precision, false, false);
+      if (!Utility::PathExists("./trt_layout_shape.txt")) {
+        config.CollectShapeRangeInfo("./trt_layout_shape.txt");
+      } else {
+        config.EnableTunedTensorRtDynamicShape("./trt_layout_shape.txt", true);
+      }
+    }
+  } else {
+    config.DisableGpu();
+    if (this->use_mkldnn_) {
+      config.EnableMKLDNN();
+    } else {
+      config.DisableMKLDNN();
+    }
+    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+    if (json_model) {
+      config.EnableNewIR();
+      config.EnableNewExecutor();
+    }
+  }
+
+  // false for zero copy tensor
+  config.SwitchUseFeedFetchOps(false);
+  // true for multiple input
+  config.SwitchSpecifyInputNames(true);
+
+  config.SwitchIrOptim(true);
+
+  config.EnableMemoryOptim();
+  config.DisableGlogInfo();
+
+  this->predictor_ = paddle_infer::CreatePredictor(config);
+}
+} // namespace PaddleOCR

deploy/cpp_infer/src/structure_table.cpp

@@ -0,0 +1,192 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <include/structure_table.h>
+#include <paddle_inference_api.h>
+
+#include <chrono>
+#include <numeric>
+
+namespace PaddleOCR {
+
+void StructureTableRecognizer::Run(
+    const std::vector<cv::Mat> &img_list,
+    std::vector<std::vector<std::string>> &structure_html_tags,
+    std::vector<float> &structure_scores,
+    std::vector<std::vector<std::vector<int>>> &structure_boxes,
+    std::vector<double> &times) noexcept {
+  std::chrono::duration<float> preprocess_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+  std::chrono::duration<float> inference_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+  std::chrono::duration<float> postprocess_diff =
+      std::chrono::steady_clock::now() - std::chrono::steady_clock::now();
+
+  size_t img_num = img_list.size();
+  for (size_t beg_img_no = 0; beg_img_no < img_num;
+       beg_img_no += this->table_batch_num_) {
+    // preprocess
+    auto preprocess_start = std::chrono::steady_clock::now();
+    size_t end_img_no = std::min(img_num, beg_img_no + this->table_batch_num_);
+    int batch_num = end_img_no - beg_img_no;
+    std::vector<cv::Mat> norm_img_batch;
+    std::vector<int> width_list;
+    std::vector<int> height_list;
+    for (size_t ino = beg_img_no; ino < end_img_no; ++ino) {
+      cv::Mat srcimg;
+      img_list[ino].copyTo(srcimg);
+      cv::Mat resize_img;
+      cv::Mat pad_img;
+      this->resize_op_.Run(srcimg, resize_img, this->table_max_len_);
+      this->normalize_op_.Run(resize_img, this->mean_, this->scale_,
+                              this->is_scale_);
+      this->pad_op_.Run(resize_img, pad_img, this->table_max_len_);
+      norm_img_batch.emplace_back(std::move(pad_img));
+      width_list.emplace_back(srcimg.cols);
+      height_list.emplace_back(srcimg.rows);
+    }
+
+    std::vector<float> input(
+        batch_num * 3 * this->table_max_len_ * this->table_max_len_, 0.0f);
+    this->permute_op_.Run(norm_img_batch, input.data());
+    auto preprocess_end = std::chrono::steady_clock::now();
+    preprocess_diff += preprocess_end - preprocess_start;
+    // inference.
+    auto input_names = this->predictor_->GetInputNames();
+    auto input_t = this->predictor_->GetInputHandle(input_names[0]);
+    input_t->Reshape(
+        {batch_num, 3, this->table_max_len_, this->table_max_len_});
+    auto inference_start = std::chrono::steady_clock::now();
+    input_t->CopyFromCpu(input.data());
+    this->predictor_->Run();
+    auto output_names = this->predictor_->GetOutputNames();
+    auto output_tensor0 = this->predictor_->GetOutputHandle(output_names[0]);
+    auto output_tensor1 = this->predictor_->GetOutputHandle(output_names[1]);
+    std::vector<int> predict_shape0 = output_tensor0->shape();
+    std::vector<int> predict_shape1 = output_tensor1->shape();
+
+    int out_num0 = std::accumulate(predict_shape0.begin(), predict_shape0.end(),
+                                   1, std::multiplies<int>());
+    int out_num1 = std::accumulate(predict_shape1.begin(), predict_shape1.end(),
+                                   1, std::multiplies<int>());
+    std::vector<float> loc_preds;
+    std::vector<float> structure_probs;
+    loc_preds.resize(out_num0);
+    structure_probs.resize(out_num1);
+
+    output_tensor0->CopyToCpu(loc_preds.data());
+    output_tensor1->CopyToCpu(structure_probs.data());
+    auto inference_end = std::chrono::steady_clock::now();
+    inference_diff += inference_end - inference_start;
+    // postprocess
+    auto postprocess_start = std::chrono::steady_clock::now();
+    std::vector<std::vector<std::string>> structure_html_tag_batch;
+    std::vector<float> structure_score_batch;
+    std::vector<std::vector<std::vector<int>>> structure_boxes_batch;
+    this->post_processor_.Run(loc_preds, structure_probs, structure_score_batch,
+                              predict_shape0, predict_shape1,
+                              structure_html_tag_batch, structure_boxes_batch,
+                              width_list, height_list);
+    for (int m = 0; m < predict_shape0[0]; ++m) {
+
+      structure_html_tag_batch[m].emplace(structure_html_tag_batch[m].begin(),
+                                          "<table>");
+      structure_html_tag_batch[m].emplace(structure_html_tag_batch[m].begin(),
+                                          "<body>");
+      structure_html_tag_batch[m].emplace(structure_html_tag_batch[m].begin(),
+                                          "<html>");
+      structure_html_tag_batch[m].emplace_back("</table>");
+      structure_html_tag_batch[m].emplace_back("</body>");
+      structure_html_tag_batch[m].emplace_back("</html>");
+      structure_html_tags.emplace_back(std::move(structure_html_tag_batch[m]));
+      structure_scores.emplace_back(structure_score_batch[m]);
+      structure_boxes.emplace_back(std::move(structure_boxes_batch[m]));
+    }
+    auto postprocess_end = std::chrono::steady_clock::now();
+    postprocess_diff += postprocess_end - postprocess_start;
+    times.emplace_back(preprocess_diff.count() * 1000);
+    times.emplace_back(inference_diff.count() * 1000);
+    times.emplace_back(postprocess_diff.count() * 1000);
+  }
+}
+
+void StructureTableRecognizer::LoadModel(
+    const std::string &model_dir) noexcept {
+  paddle_infer::Config config;
+  bool json_model = false;
+  std::string model_file_path, param_file_path;
+  std::vector<std::pair<std::string, std::string>> model_variants = {
+      {"/inference.json", "/inference.pdiparams"},
+      {"/model.json", "/model.pdiparams"},
+      {"/inference.pdmodel", "/inference.pdiparams"},
+      {"/model.pdmodel", "/model.pdiparams"}};
+  for (const auto &variant : model_variants) {
+    if (Utility::PathExists(model_dir + variant.first)) {
+      model_file_path = model_dir + variant.first;
+      param_file_path = model_dir + variant.second;
+      json_model = (variant.first.find(".json") != std::string::npos);
+      break;
+    }
+  }
+  if (model_file_path.empty()) {
+    std::cerr << "[ERROR] No valid model file found in " << model_dir
+              << std::endl;
+    exit(1);
+  }
+  config.SetModel(model_file_path, param_file_path);
+
+  if (this->use_gpu_) {
+    config.EnableUseGpu(this->gpu_mem_, this->gpu_id_);
+    if (this->use_tensorrt_) {
+      auto precision = paddle_infer::Config::Precision::kFloat32;
+      if (this->precision_ == "fp16") {
+        precision = paddle_infer::Config::Precision::kHalf;
+      }
+      if (this->precision_ == "int8") {
+        precision = paddle_infer::Config::Precision::kInt8;
+      }
+      config.EnableTensorRtEngine(1 << 20, 10, 3, precision, false, false);
+      if (!Utility::PathExists("./trt_table_shape.txt")) {
+        config.CollectShapeRangeInfo("./trt_table_shape.txt");
+      } else {
+        config.EnableTunedTensorRtDynamicShape("./trt_table_shape.txt", true);
+      }
+    }
+  } else {
+    config.DisableGpu();
+    if (this->use_mkldnn_) {
+      config.EnableMKLDNN();
+    } else {
+      config.DisableMKLDNN();
+    }
+    config.SetCpuMathLibraryNumThreads(this->cpu_math_library_num_threads_);
+    if (json_model) {
+      config.EnableNewIR();
+      config.EnableNewExecutor();
+    }
+  }
+
+  // false for zero copy tensor
+  config.SwitchUseFeedFetchOps(false);
+  // true for multiple input
+  config.SwitchSpecifyInputNames(true);
+
+  config.SwitchIrOptim(true);
+
+  config.EnableMemoryOptim();
+  config.DisableGlogInfo();
+
+  this->predictor_ = paddle_infer::CreatePredictor(config);
+}
+} // namespace PaddleOCR

deploy/cpp_infer/src/utility.cpp

@@ -0,0 +1,426 @@
+// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <dirent.h>
+#include <include/utility.h>
+#include <opencv2/imgcodecs.hpp>
+
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#ifdef _MSC_VER
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+namespace PaddleOCR {
+
+std::vector<std::string> Utility::ReadDict(const std::string &path) noexcept {
+  std::vector<std::string> m_vec;
+  std::ifstream in(path);
+  if (in) {
+    for (;;) {
+      std::string line;
+      if (!getline(in, line))
+        break;
+      m_vec.emplace_back(std::move(line));
+    }
+  } else {
+    std::cout << "no such label file: " << path << ", exit the program..."
+              << std::endl;
+    exit(1);
+  }
+  return m_vec;
+}
+
+void Utility::VisualizeBboxes(const cv::Mat &srcimg,
+                              const std::vector<OCRPredictResult> &ocr_result,
+                              const std::string &save_path) noexcept {
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  for (size_t n = 0; n < ocr_result.size(); ++n) {
+    cv::Point rook_points[4];
+    for (size_t m = 0; m < ocr_result[n].box.size(); ++m) {
+      rook_points[m] =
+          cv::Point(int(ocr_result[n].box[m][0]), int(ocr_result[n].box[m][1]));
+    }
+
+    const cv::Point *ppt[1] = {rook_points};
+    int npt[] = {4};
+    cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+  }
+
+  cv::imwrite(save_path, img_vis);
+  std::cout << "The detection visualized image saved in " + save_path
+            << std::endl;
+}
+
+void Utility::VisualizeBboxes(const cv::Mat &srcimg,
+                              const StructurePredictResult &structure_result,
+                              const std::string &save_path) noexcept {
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  img_vis = crop_image(img_vis, structure_result.box);
+  for (size_t n = 0; n < structure_result.cell_box.size(); ++n) {
+    if (structure_result.cell_box[n].size() == 8) {
+      cv::Point rook_points[4];
+      for (size_t m = 0; m < structure_result.cell_box[n].size(); m += 2) {
+        rook_points[m / 2] =
+            cv::Point(int(structure_result.cell_box[n][m]),
+                      int(structure_result.cell_box[n][m + 1]));
+      }
+      const cv::Point *ppt[1] = {rook_points};
+      int npt[] = {4};
+      cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+    } else if (structure_result.cell_box[n].size() == 4) {
+      cv::Point rook_points[2] = {
+          cv::Point(int(structure_result.cell_box[n][0]),
+                    int(structure_result.cell_box[n][1])),
+          cv::Point(int(structure_result.cell_box[n][2]),
+                    int(structure_result.cell_box[n][3]))};
+      cv::rectangle(img_vis, rook_points[0], rook_points[1], CV_RGB(0, 255, 0),
+                    2, 8, 0);
+    }
+  }
+
+  cv::imwrite(save_path, img_vis);
+  std::cout << "The table visualized image saved in " + save_path << std::endl;
+}
+
+// list all files under a directory
+void Utility::GetAllFiles(const char *dir_name,
+                          std::vector<std::string> &all_inputs) noexcept {
+  if (NULL == dir_name) {
+    std::cout << " dir_name is null ! " << std::endl;
+    return;
+  }
+  struct stat s;
+  stat(dir_name, &s);
+  if (!S_ISDIR(s.st_mode)) {
+    std::cout << "dir_name is not a valid directory !" << std::endl;
+    all_inputs.emplace_back(dir_name);
+    return;
+  } else {
+    struct dirent *filename; // return value for readdir()
+    DIR *dir;                // return value for opendir()
+    dir = opendir(dir_name);
+    if (NULL == dir) {
+      std::cout << "Can not open dir " << dir_name << std::endl;
+      return;
+    }
+    std::cout << "Successfully opened the dir !" << std::endl;
+    while ((filename = readdir(dir)) != NULL) {
+      if (strcmp(filename->d_name, ".") == 0 ||
+          strcmp(filename->d_name, "..") == 0)
+        continue;
+      // img_dir + std::string("/") + all_inputs[0];
+      all_inputs.emplace_back(dir_name + std::string("/") +
+                              std::string(filename->d_name));
+    }
+  }
+}
+
+cv::Mat
+Utility::GetRotateCropImage(const cv::Mat &srcimage,
+                            const std::vector<std::vector<int>> &box) noexcept {
+  cv::Mat image;
+  srcimage.copyTo(image);
+  std::vector<std::vector<int>> points = box;
+
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+
+  cv::Mat img_crop;
+  image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
+
+  for (size_t i = 0; i < points.size(); ++i) {
+    points[i][0] -= left;
+    points[i][1] -= top;
+  }
+
+  int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
+                                pow(points[0][1] - points[1][1], 2)));
+  int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
+                                 pow(points[0][1] - points[3][1], 2)));
+
+  const cv::Point2f pts_std[4] = {
+      {0., 0.},
+      {(float)img_crop_width, 0.},
+      {(float)img_crop_width, (float)img_crop_height},
+      {0.f, (float)img_crop_height}};
+
+  const cv::Point2f pointsf[4] = {{(float)points[0][0], (float)points[0][1]},
+                                  {(float)points[1][0], (float)points[1][1]},
+                                  {(float)points[2][0], (float)points[2][1]},
+                                  {(float)points[3][0], (float)points[3][1]}};
+
+  cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
+
+  cv::Mat dst_img;
+  cv::warpPerspective(img_crop, dst_img, M,
+                      cv::Size(img_crop_width, img_crop_height),
+                      cv::BORDER_REPLICATE);
+
+  if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
+    cv::Mat srcCopy(dst_img.rows, dst_img.cols, dst_img.depth());
+    cv::transpose(dst_img, srcCopy);
+    cv::flip(srcCopy, srcCopy, 0);
+    return srcCopy;
+  } else {
+    return dst_img;
+  }
+}
+
+std::vector<size_t> Utility::argsort(const std::vector<float> &array) noexcept {
+  std::vector<size_t> array_index(array.size(), 0);
+  for (size_t i = 0; i < array.size(); ++i)
+    array_index[i] = i;
+
+  std::sort(array_index.begin(), array_index.end(),
+            [&array](size_t pos1, size_t pos2) noexcept {
+              return (array[pos1] < array[pos2]);
+            });
+
+  return array_index;
+}
+
+std::string Utility::basename(const std::string &filename) noexcept {
+  if (filename.empty()) {
+    return "";
+  }
+
+  auto len = filename.length();
+  auto index = filename.find_last_of("/\\");
+
+  if (index == std::string::npos) {
+    return filename;
+  }
+
+  if (index + 1 >= len) {
+
+    --len;
+    index = filename.substr(0, len).find_last_of("/\\");
+
+    if (len == 0) {
+      return filename;
+    }
+
+    if (index == 0) {
+      return filename.substr(1, len - 1);
+    }
+
+    if (index == std::string::npos) {
+      return filename.substr(0, len);
+    }
+
+    return filename.substr(index + 1, len - index - 1);
+  }
+
+  return filename.substr(index + 1, len - index);
+}
+
+bool Utility::PathExists(const char *path) noexcept {
+#ifdef _WIN32
+  struct _stat buffer;
+  return (_stat(path, &buffer) == 0);
+#else
+  struct stat buffer;
+  return (stat(path, &buffer) == 0);
+#endif // !_WIN32
+}
+
+void Utility::CreateDir(const char *path) noexcept {
+#ifdef _MSC_VER
+  _mkdir(path);
+#elif defined __MINGW32__
+  mkdir(path);
+#else
+  mkdir(path, 0777);
+#endif // !_WIN32
+}
+
+void Utility::print_result(
+    const std::vector<OCRPredictResult> &ocr_result) noexcept {
+  for (size_t i = 0; i < ocr_result.size(); ++i) {
+    std::cout << i << "\t";
+    // det
+    const std::vector<std::vector<int>> &boxes = ocr_result[i].box;
+    if (boxes.size() > 0) {
+      std::cout << "det boxes: [";
+      for (size_t n = 0; n < boxes.size(); ++n) {
+        std::cout << '[' << boxes[n][0] << ',' << boxes[n][1] << "]";
+        if (n != boxes.size() - 1) {
+          std::cout << ',';
+        }
+      }
+      std::cout << "] ";
+    }
+    // rec
+    if (ocr_result[i].score != -1.0) {
+      std::cout << "rec text: " << ocr_result[i].text
+                << " rec score: " << ocr_result[i].score << " ";
+    }
+
+    // cls
+    if (ocr_result[i].cls_label != -1) {
+      std::cout << "cls label: " << ocr_result[i].cls_label
+                << " cls score: " << ocr_result[i].cls_score;
+    }
+    std::cout << std::endl;
+  }
+}
+
+cv::Mat Utility::crop_image(const cv::Mat &img,
+                            const std::vector<int> &box) noexcept {
+  cv::Mat crop_im = cv::Mat::zeros(box[3] - box[1], box[2] - box[0], 16);
+  int crop_x1 = std::max(0, box[0]);
+  int crop_y1 = std::max(0, box[1]);
+  int crop_x2 = std::min(img.cols - 1, box[2] - 1);
+  int crop_y2 = std::min(img.rows - 1, box[3] - 1);
+
+  cv::Mat crop_im_window =
+      crop_im(cv::Range(crop_y1 - box[1], crop_y2 + 1 - box[1]),
+              cv::Range(crop_x1 - box[0], crop_x2 + 1 - box[0]));
+  cv::Mat roi_img =
+      img(cv::Range(crop_y1, crop_y2 + 1), cv::Range(crop_x1, crop_x2 + 1));
+  crop_im_window += roi_img;
+  return crop_im;
+}
+
+cv::Mat Utility::crop_image(const cv::Mat &img,
+                            const std::vector<float> &box) noexcept {
+  std::vector<int> box_int = {(int)box[0], (int)box[1], (int)box[2],
+                              (int)box[3]};
+  return crop_image(img, box_int);
+}
+
+void Utility::sort_boxes(std::vector<OCRPredictResult> &ocr_result) noexcept {
+  std::sort(ocr_result.begin(), ocr_result.end(), Utility::comparison_box);
+  if (ocr_result.size() > 1) {
+    for (size_t i = 0; i < ocr_result.size() - 1; ++i) {
+      for (size_t j = i; j != size_t(-1); --j) {
+        if (abs(ocr_result[j + 1].box[0][1] - ocr_result[j].box[0][1]) < 10 &&
+            (ocr_result[j + 1].box[0][0] < ocr_result[j].box[0][0])) {
+          std::swap(ocr_result[i], ocr_result[i + 1]);
+        }
+      }
+    }
+  }
+}
+
+std::vector<int>
+Utility::xyxyxyxy2xyxy(const std::vector<std::vector<int>> &box) noexcept {
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+  return {left, top, right, bottom};
+}
+
+std::vector<int> Utility::xyxyxyxy2xyxy(const std::vector<int> &box) noexcept {
+  int x_collect[4] = {box[0], box[2], box[4], box[6]};
+  int y_collect[4] = {box[1], box[3], box[5], box[7]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+  return {left, top, right, bottom};
+}
+
+float Utility::fast_exp(float x) noexcept {
+  union {
+    uint32_t i;
+    float f;
+  } v{};
+  v.i = (1 << 23) * (1.4426950409 * x + 126.93490512f);
+  return v.f;
+}
+
+std::vector<float>
+Utility::activation_function_softmax(const std::vector<float> &src) noexcept {
+  size_t length = src.size();
+  std::vector<float> dst;
+  dst.resize(length);
+  const float alpha = float(*std::max_element(&src[0], &src[length]));
+  float denominator{0};
+
+  for (size_t i = 0; i < length; ++i) {
+    dst[i] = fast_exp(src[i] - alpha);
+    denominator += dst[i];
+  }
+
+  for (size_t i = 0; i < length; ++i) {
+    dst[i] /= denominator;
+  }
+  return dst;
+}
+
+float Utility::iou(const std::vector<int> &box1,
+                   const std::vector<int> &box2) noexcept {
+  int area1 = std::max(0, box1[2] - box1[0]) * std::max(0, box1[3] - box1[1]);
+  int area2 = std::max(0, box2[2] - box2[0]) * std::max(0, box2[3] - box2[1]);
+
+  // computing the sum_area
+  int sum_area = area1 + area2;
+
+  // find the each point of intersect rectangle
+  int x1 = std::max(box1[0], box2[0]);
+  int y1 = std::max(box1[1], box2[1]);
+  int x2 = std::min(box1[2], box2[2]);
+  int y2 = std::min(box1[3], box2[3]);
+
+  // judge if there is an intersect
+  if (y1 >= y2 || x1 >= x2) {
+    return 0.0;
+  } else {
+    int intersect = (x2 - x1) * (y2 - y1);
+    return intersect / (sum_area - intersect + 0.00000001);
+  }
+}
+
+float Utility::iou(const std::vector<float> &box1,
+                   const std::vector<float> &box2) noexcept {
+  float area1 = std::max((float)0.0, box1[2] - box1[0]) *
+                std::max((float)0.0, box1[3] - box1[1]);
+  float area2 = std::max((float)0.0, box2[2] - box2[0]) *
+                std::max((float)0.0, box2[3] - box2[1]);
+
+  // computing the sum_area
+  float sum_area = area1 + area2;
+
+  // find the each point of intersect rectangle
+  float x1 = std::max(box1[0], box2[0]);
+  float y1 = std::max(box1[1], box2[1]);
+  float x2 = std::min(box1[2], box2[2]);
+  float y2 = std::min(box1[3], box2[3]);
+
+  // judge if there is an intersect
+  if (y1 >= y2 || x1 >= x2) {
+    return 0.0;
+  } else {
+    float intersect = (x2 - x1) * (y2 - y1);
+    return intersect / (sum_area - intersect + 0.00000001);
+  }
+}
+
+} // namespace PaddleOCR