Initial commit

deploy/cpp_infer/include/paddlestructure.h

+// Copyright (c) 2022 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.
+
+#pragma once
+
+#include <include/paddleocr.h>
+
+namespace PaddleOCR {
+
+class PaddleStructure : public PPOCR {
+public:
+  explicit PaddleStructure() noexcept;
+  ~PaddleStructure();
+
+  std::vector<StructurePredictResult> structure(const cv::Mat &img,
+                                                bool layout = false,
+                                                bool table = true,
+                                                bool ocr = false) noexcept;
+
+  void reset_timer() noexcept;
+  void benchmark_log(int img_num) noexcept;
+
+private:
+  struct STRUCTURE_PRIVATE;
+  STRUCTURE_PRIVATE *pri_;
+
+  std::vector<double> time_info_table = {0, 0, 0};
+  std::vector<double> time_info_layout = {0, 0, 0};
+
+  void layout(const cv::Mat &img,
+              std::vector<StructurePredictResult> &structure_result) noexcept;
+
+  void table(const cv::Mat &img,
+             StructurePredictResult &structure_result) noexcept;
+
+  std::string rebuild_table(const std::vector<std::string> &rec_html_tags,
+                            const std::vector<std::vector<int>> &rec_boxes,
+                            std::vector<OCRPredictResult> &ocr_result) noexcept;
+
+  float dis(const std::vector<int> &box1,
+            const std::vector<int> &box2) noexcept;
+
+  static bool comparison_dis(const std::vector<float> &dis1,
+                             const std::vector<float> &dis2) noexcept {
+    if (dis1[1] < dis2[1]) {
+      return true;
+    } else if (dis1[1] == dis2[1]) {
+      return dis1[0] < dis2[0];
+    } else {
+      return false;
+    }
+  }
+};
+
+} // namespace PaddleOCR

deploy/cpp_infer/include/postprocess_op.h

+// 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.
+
+#pragma once
+
+#include <include/utility.h>
+
+namespace PaddleOCR {
+
+class DBPostProcessor {
+public:
+  void GetContourArea(const std::vector<std::vector<float>> &box,
+                      float unclip_ratio, float &distance) noexcept;
+
+  cv::RotatedRect UnClip(const std::vector<std::vector<float>> &box,
+                         const float &unclip_ratio) noexcept;
+
+  float **Mat2Vec(const cv::Mat &mat) noexcept;
+
+  std::vector<std::vector<int>>
+  OrderPointsClockwise(const std::vector<std::vector<int>> &pts) noexcept;
+
+  std::vector<std::vector<float>> GetMiniBoxes(const cv::RotatedRect &box,
+                                               float &ssid) noexcept;
+
+  float BoxScoreFast(const std::vector<std::vector<float>> &box_array,
+                     const cv::Mat &pred) noexcept;
+  float PolygonScoreAcc(const std::vector<cv::Point> &contour,
+                        const cv::Mat &pred) noexcept;
+
+  std::vector<std::vector<std::vector<int>>>
+  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;
+
+  void FilterTagDetRes(std::vector<std::vector<std::vector<int>>> &boxes,
+                       float ratio_h, float ratio_w,
+                       const cv::Mat &srcimg) noexcept;
+
+private:
+  static bool XsortInt(const std::vector<int> &a,
+                       const std::vector<int> &b) noexcept;
+
+  static bool XsortFp32(const std::vector<float> &a,
+                        const std::vector<float> &b) noexcept;
+
+  std::vector<std::vector<float>> Mat2Vector(const cv::Mat &mat) noexcept;
+
+  inline int _max(int a, int b) const noexcept { return a >= b ? a : b; }
+
+  inline int _min(int a, int b) const noexcept { return a >= b ? b : a; }
+
+  template <class T> inline T clamp(T x, T min, T max) const noexcept {
+    if (x > max)
+      return max;
+    if (x < min)
+      return min;
+    return x;
+  }
+
+  inline float clampf(float x, float min, float max) const noexcept {
+    if (x > max)
+      return max;
+    if (x < min)
+      return min;
+    return x;
+  }
+};
+
+class TablePostProcessor {
+public:
+  void init(const std::string &label_path,
+            bool merge_no_span_structure = true) noexcept;
+  void 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;
+
+private:
+  std::vector<std::string> label_list_;
+  const std::string end = "eos";
+  const std::string beg = "sos";
+};
+
+class PicodetPostProcessor {
+public:
+  void init(const std::string &label_path, const double score_threshold = 0.4,
+            const double nms_threshold = 0.5,
+            const std::vector<int> &fpn_stride = {8, 16, 32, 64}) noexcept;
+  void 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 eg_max) noexcept;
+  inline size_t fpn_stride_size() const noexcept { return fpn_stride_.size(); }
+
+private:
+  StructurePredictResult 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;
+  void nms(std::vector<StructurePredictResult> &input_boxes,
+           float nms_threshold) noexcept;
+
+  std::vector<int> fpn_stride_ = {8, 16, 32, 64};
+
+  std::vector<std::string> label_list_;
+  double score_threshold_ = 0.4;
+  double nms_threshold_ = 0.5;
+  int num_class_ = 5;
+};
+
+} // namespace PaddleOCR

deploy/cpp_infer/include/preprocess_op.h

+// 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.
+
+#pragma once
+
+#include <opencv2/imgproc.hpp>
+
+namespace PaddleOCR {
+
+class Normalize {
+public:
+  virtual void Run(cv::Mat &im, const std::vector<float> &mean,
+                   const std::vector<float> &scale,
+                   const bool is_scale = true) noexcept;
+};
+
+// RGB -> CHW
+class Permute {
+public:
+  virtual void Run(const cv::Mat &im, float *data) noexcept;
+};
+
+class PermuteBatch {
+public:
+  virtual void Run(const std::vector<cv::Mat> &imgs, float *data) noexcept;
+};
+
+class ResizeImgType0 {
+public:
+  virtual void 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;
+};
+
+class CrnnResizeImg {
+public:
+  virtual void Run(const cv::Mat &img, cv::Mat &resize_img, float wh_ratio,
+                   bool use_tensorrt = false,
+                   const std::vector<int> &rec_image_shape = {3, 32,
+                                                              320}) noexcept;
+};
+
+class ClsResizeImg {
+public:
+  virtual void
+  Run(const cv::Mat &img, cv::Mat &resize_img, bool use_tensorrt = false,
+      const std::vector<int> &rec_image_shape = {3, 48, 192}) noexcept;
+};
+
+class TableResizeImg {
+public:
+  virtual void Run(const cv::Mat &img, cv::Mat &resize_img,
+                   const int max_len = 488) noexcept;
+};
+
+class TablePadImg {
+public:
+  virtual void Run(const cv::Mat &img, cv::Mat &resize_img,
+                   const int max_len = 488) noexcept;
+};
+
+class Resize {
+public:
+  virtual void Run(const cv::Mat &img, cv::Mat &resize_img, const int h,
+                   const int w) noexcept;
+};
+
+} // namespace PaddleOCR

deploy/cpp_infer/include/structure_layout.h

+// 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.
+
+#pragma once
+
+#include <include/postprocess_op.h>
+#include <include/preprocess_op.h>
+#include <memory>
+
+namespace paddle_infer {
+class Predictor;
+}
+
+namespace PaddleOCR {
+
+class StructureLayoutRecognizer {
+public:
+  explicit StructureLayoutRecognizer(
+      const std::string &model_dir, const bool &use_gpu, const int &gpu_id,
+      const int &gpu_mem, const int &cpu_math_library_num_threads,
+      const bool &use_mkldnn, const std::string &label_path,
+      const bool &use_tensorrt, const std::string &precision,
+      const double &layout_score_threshold,
+      const double &layout_nms_threshold) noexcept {
+    this->use_gpu_ = use_gpu;
+    this->gpu_id_ = gpu_id;
+    this->gpu_mem_ = gpu_mem;
+    this->cpu_math_library_num_threads_ = cpu_math_library_num_threads;
+    this->use_mkldnn_ = use_mkldnn;
+    this->use_tensorrt_ = use_tensorrt;
+    this->precision_ = precision;
+
+    this->post_processor_.init(label_path, layout_score_threshold,
+                               layout_nms_threshold);
+    LoadModel(model_dir);
+  }
+
+  // Load Paddle inference model
+  void LoadModel(const std::string &model_dir) noexcept;
+
+  void Run(const cv::Mat &img, std::vector<StructurePredictResult> &result,
+           std::vector<double> &times) noexcept;
+
+private:
+  std::shared_ptr<paddle_infer::Predictor> predictor_;
+
+  bool use_gpu_ = false;
+  int gpu_id_ = 0;
+  int gpu_mem_ = 4000;
+  int cpu_math_library_num_threads_ = 4;
+  bool use_mkldnn_ = false;
+
+  std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
+  std::vector<float> scale_ = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
+  bool is_scale_ = true;
+
+  bool use_tensorrt_ = false;
+  std::string precision_ = "fp32";
+
+  // pre-process
+  Resize resize_op_;
+  Normalize normalize_op_;
+  Permute permute_op_;
+
+  // post-process
+  PicodetPostProcessor post_processor_;
+};
+
+} // namespace PaddleOCR

deploy/cpp_infer/include/structure_table.h

+// 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.
+
+#pragma once
+
+#include <include/postprocess_op.h>
+#include <include/preprocess_op.h>
+#include <memory>
+
+namespace paddle_infer {
+class Predictor;
+}
+
+namespace PaddleOCR {
+
+class StructureTableRecognizer {
+public:
+  explicit StructureTableRecognizer(
+      const std::string &model_dir, const bool &use_gpu, const int &gpu_id,
+      const int &gpu_mem, const int &cpu_math_library_num_threads,
+      const bool &use_mkldnn, const std::string &label_path,
+      const bool &use_tensorrt, const std::string &precision,
+      const int &table_batch_num, const int &table_max_len,
+      const bool &merge_no_span_structure) noexcept {
+    this->use_gpu_ = use_gpu;
+    this->gpu_id_ = gpu_id;
+    this->gpu_mem_ = gpu_mem;
+    this->cpu_math_library_num_threads_ = cpu_math_library_num_threads;
+    this->use_mkldnn_ = use_mkldnn;
+    this->use_tensorrt_ = use_tensorrt;
+    this->precision_ = precision;
+    this->table_batch_num_ = table_batch_num;
+    this->table_max_len_ = table_max_len;
+
+    this->post_processor_.init(label_path, merge_no_span_structure);
+    LoadModel(model_dir);
+  }
+
+  // Load Paddle inference model
+  void LoadModel(const std::string &model_dir) noexcept;
+
+  void Run(const std::vector<cv::Mat> &img_list,
+           std::vector<std::vector<std::string>> &rec_html_tags,
+           std::vector<float> &rec_scores,
+           std::vector<std::vector<std::vector<int>>> &rec_boxes,
+           std::vector<double> &times) noexcept;
+
+private:
+  std::shared_ptr<paddle_infer::Predictor> predictor_;
+
+  bool use_gpu_ = false;
+  int gpu_id_ = 0;
+  int gpu_mem_ = 4000;
+  int cpu_math_library_num_threads_ = 4;
+  bool use_mkldnn_ = false;
+  int table_max_len_ = 488;
+
+  std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
+  std::vector<float> scale_ = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
+  bool is_scale_ = true;
+
+  bool use_tensorrt_ = false;
+  std::string precision_ = "fp32";
+  int table_batch_num_ = 1;
+
+  // pre-process
+  TableResizeImg resize_op_;
+  Normalize normalize_op_;
+  PermuteBatch permute_op_;
+  TablePadImg pad_op_;
+
+  // post-process
+  TablePostProcessor post_processor_;
+
+}; // class StructureTableRecognizer
+
+} // namespace PaddleOCR

deploy/cpp_infer/include/utility.h

+// 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.
+
+#pragma once
+
+#include <opencv2/imgproc.hpp>
+
+namespace PaddleOCR {
+
+struct OCRPredictResult {
+  std::vector<std::vector<int>> box;
+  std::string text;
+  float score = -1.0;
+  float cls_score;
+  int cls_label = -1;
+};
+
+struct StructurePredictResult {
+  std::vector<float> box;
+  std::vector<std::vector<int>> cell_box;
+  std::string type;
+  std::vector<OCRPredictResult> text_res;
+  std::string html;
+  float html_score = -1;
+  float confidence;
+};
+
+class Utility {
+public:
+  static std::vector<std::string> ReadDict(const std::string &path) noexcept;
+
+  static void VisualizeBboxes(const cv::Mat &srcimg,
+                              const std::vector<OCRPredictResult> &ocr_result,
+                              const std::string &save_path) noexcept;
+
+  static void VisualizeBboxes(const cv::Mat &srcimg,
+                              const StructurePredictResult &structure_result,
+                              const std::string &save_path) noexcept;
+
+  template <class ForwardIterator>
+  inline static size_t argmax(ForwardIterator first,
+                              ForwardIterator last) noexcept {
+    return std::distance(first, std::max_element(first, last));
+  }
+
+  static void GetAllFiles(const char *dir_name,
+                          std::vector<std::string> &all_inputs) noexcept;
+
+  static cv::Mat
+  GetRotateCropImage(const cv::Mat &srcimage,
+                     const std::vector<std::vector<int>> &box) noexcept;
+
+  static std::vector<size_t> argsort(const std::vector<float> &array) noexcept;
+
+  static std::string basename(const std::string &filename) noexcept;
+
+  static bool PathExists(const char *path) noexcept;
+  static inline bool PathExists(const std::string &path) noexcept {
+    return PathExists(path.c_str());
+  }
+
+  static void CreateDir(const char *path) noexcept;
+  static inline void CreateDir(const std::string &path) noexcept {
+    CreateDir(path.c_str());
+  }
+
+  static void
+  print_result(const std::vector<OCRPredictResult> &ocr_result) noexcept;
+
+  static cv::Mat crop_image(const cv::Mat &img,
+                            const std::vector<int> &area) noexcept;
+  static cv::Mat crop_image(const cv::Mat &img,
+                            const std::vector<float> &area) noexcept;
+
+  static void sort_boxes(std::vector<OCRPredictResult> &ocr_result) noexcept;
+
+  static std::vector<int>
+  xyxyxyxy2xyxy(const std::vector<std::vector<int>> &box) noexcept;
+  static std::vector<int> xyxyxyxy2xyxy(const std::vector<int> &box) noexcept;
+
+  static float fast_exp(float x) noexcept;
+  static std::vector<float>
+  activation_function_softmax(const std::vector<float> &src) noexcept;
+  static float iou(const std::vector<int> &box1,
+                   const std::vector<int> &box2) noexcept;
+  static float iou(const std::vector<float> &box1,
+                   const std::vector<float> &box2) noexcept;
+
+private:
+  static bool comparison_box(const OCRPredictResult &result1,
+                             const OCRPredictResult &result2) noexcept {
+    if (result1.box[0][1] < result2.box[0][1]) {
+      return true;
+    } else if (result1.box[0][1] == result2.box[0][1]) {
+      return result1.box[0][0] < result2.box[0][0];
+    } else {
+      return false;
+    }
+  }
+};
+
+} // namespace PaddleOCR

deploy/cpp_infer/readme.md

+English | [简体中文](readme_ch.md)
+
+# Server-side C++ Inference
+
+- [1. Prepare the Environment](#1)
+    - [1.1 Environment](#11)
+    - [1.2 Compile OpenCV](#12)
+    - [1.3 Compile or Download or the Paddle Inference Library](#13)
+- [2. Compile and Run the Demo](#2)
+    - [2.1 Export the inference model](#21)
+    - [2.2 Compile PaddleOCR C++ inference demo](#22)
+    - [2.3 Run the demo](#23)
+- [3. FAQ](#3)
+
+
+This chapter introduces the C++ deployment steps of the PaddleOCR model. C++ is better than Python in terms of performance. Therefore, in CPU and GPU deployment scenarios, C++ deployment is mostly used.
+This section will introduce how to configure the C++ environment and deploy PaddleOCR in Linux (CPU\GPU) environment. For Windows deployment please refer to [Windows](./docs/windows_vs2022_build.md) compilation guidelines.
+
+
+<a name="1"></a>
+## 1. Prepare the Environment
+
+<a name="11"></a>
+### 1.1 Environment
+
+- Linux, docker is recommended.
+- Windows.
+
+
+<a name="12"></a>
+### 1.2 Compile OpenCV
+
+* First of all, you need to download the source code compiled package in the Linux environment from the OpenCV official website. Taking OpenCV 3.4.7 as an example, the download command is as follows.
+
+```bash
+cd deploy/cpp_infer
+wget https://paddleocr.bj.bcebos.com/libs/opencv/opencv-3.4.7.tar.gz
+tar -xf opencv-3.4.7.tar.gz
+```
+
+Finally, you will see the folder of `opencv-3.4.7/` in the current directory.
+
+* Compile OpenCV, the OpenCV source path (`root_path`) and installation path (`install_path`) should be set by yourself. Enter the OpenCV source code path and compile it in the following way.
+
+
+```shell
+root_path=your_opencv_root_path
+install_path=${root_path}/opencv3
+
+rm -rf build
+mkdir build
+cd build
+
+cmake .. \
+    -DCMAKE_INSTALL_PREFIX=${install_path} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DWITH_IPP=OFF \
+    -DBUILD_IPP_IW=OFF \
+    -DWITH_LAPACK=OFF \
+    -DWITH_EIGEN=OFF \
+    -DCMAKE_INSTALL_LIBDIR=lib64 \
+    -DWITH_ZLIB=ON \
+    -DBUILD_ZLIB=ON \
+    -DWITH_JPEG=ON \
+    -DBUILD_JPEG=ON \
+    -DWITH_PNG=ON \
+    -DBUILD_PNG=ON \
+    -DWITH_TIFF=ON \
+    -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+In the above commands, `root_path` is the downloaded OpenCV source code path, and `install_path` is the installation path of OpenCV. After `make install` is completed, the OpenCV header file and library file will be generated in this folder for later OCR source code compilation.
+
+
+
+The final file structure under the OpenCV installation path is as follows.
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib
+|-- lib64
+|-- share
+```
+
+<a name="13"></a>
+### 1.3 Compile or Download or the Paddle Inference Library
+
+* There are 2 ways to obtain the Paddle inference library, described in detail below.
+
+#### 1.3.1 Direct download and installation
+
+[Paddle inference library official website](https://www.paddlepaddle.org.cn/inference/master/guides/install/download_lib.html#linux). You can review and select the appropriate version of the inference library on the official website.
+
+
+* After downloading, use the following command to extract files.
+
+```
+tar -xf paddle_inference.tgz
+```
+
+Finally you will see the folder of `paddle_inference/` in the current path.
+
+#### 1.3.2 Compile the inference source code
+* If you want to get the latest Paddle inference library features, you can download the latest code from Paddle GitHub repository and compile the inference library from the source code. It is recommended to download the inference library with paddle version greater than or equal to 2.0.1.
+* You can refer to [Paddle inference library] (https://www.paddlepaddle.org.cn/documentation/docs/en/advanced_guide/inference_deployment/inference/build_and_install_lib_en.html) to get the Paddle source code from GitHub, and then compile To generate the latest inference library. The method of using git to access the code is as follows.
+
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+git checkout develop
+```
+
+* Enter the Paddle directory and run the following commands to compile the paddle inference library.
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake  .. \
+    -DWITH_CONTRIB=OFF \
+    -DWITH_MKL=ON \
+    -DWITH_MKLDNN=ON  \
+    -DWITH_TESTING=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWITH_INFERENCE_API_TEST=OFF \
+    -DON_INFER=ON \
+    -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+For more compilation parameter options, please refer to the [document](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#congyuanmabianyi).
+
+
+* After the compilation process, you can see the following files in the folder of `build/paddle_inference_install_dir/`.
+
+```
+build/paddle_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+`paddle` is the Paddle library required for C++ prediction later, and `version.txt` contains the version information of the current inference library.
+
+
+<a name="2"></a>
+## 2. Compile and Run the Demo
+
+<a name="21"></a>
+### 2.1 Export the inference model
+
+* You can refer to [Model inference](../../doc/doc_ch/inference.md) and export the inference model. After the model is exported, assuming it is placed in the `inference` directory, the directory structure is as follows.
+
+```
+inference/
+|-- det_db
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- rec_rcnn
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- cls
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- table
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- layout
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+```
+
+
+<a name="22"></a>
+### 2.2 Compile PaddleOCR C++ inference demo
+
+* The compilation commands are as follows. The addresses of Paddle C++ inference library, opencv and other Dependencies need to be replaced with the actual addresses on your own machines.
+
+```shell
+sh tools/build.sh
+```
+
+Specifically, you should modify the paths in `tools/build.sh`. The related content is as follows.
+
+```shell
+OPENCV_DIR=your_opencv_dir
+LIB_DIR=your_paddle_inference_dir
+CUDA_LIB_DIR=your_cuda_lib_dir
+CUDNN_LIB_DIR=your_cudnn_lib_dir
+```
+
+`OPENCV_DIR` is the OpenCV installation path; `LIB_DIR` is the download (`paddle_inference` folder)
+or the generated Paddle inference library path (`build/paddle_inference_install_dir` folder);
+`CUDA_LIB_DIR` is the CUDA library file path, in docker; it is `/usr/local/cuda/lib64`; `CUDNN_LIB_DIR` is the cuDNN library file path, in docker it is `/usr/lib/x86_64-linux-gnu/`.
+
+
+* After the compilation is completed, an executable file named `ppocr` will be generated in the `build` folder.
+
+
+<a name="23"></a>
+### 2.3 Run the demo
+
+Execute the built executable file:
+```shell
+./build/ppocr [--param1] [--param2] [...]
+```
+
+**Note**:ppocr uses the `PP-OCRv3` model by default, and the input shape used by the recognition model is `3, 48, 320`, if you want to use the old version model, you should add the parameter `--rec_img_h=32`.
+
+Specifically,
+
+##### 1. det+cls+rec：
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs/12.jpg \
+    --use_angle_cls=true \
+    --det=true \
+    --rec=true \
+    --cls=true \
+```
+
+##### 2. det+rec：
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --image_dir=../../doc/imgs/12.jpg \
+    --use_angle_cls=false \
+    --det=true \
+    --rec=true \
+    --cls=false \
+```
+
+##### 3. det
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --image_dir=../../doc/imgs/12.jpg \
+    --det=true \
+    --rec=false
+```
+
+##### 4. cls+rec：
+```shell
+./build/ppocr --rec_model_dir=inference/rec_rcnn \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=true \
+    --det=false \
+    --rec=true \
+    --cls=true \
+```
+
+##### 5. rec
+```shell
+./build/ppocr --rec_model_dir=inference/rec_rcnn \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=false \
+    --det=false \
+    --rec=true \
+    --cls=false \
+```
+
+##### 6. cls
+```shell
+./build/ppocr --cls_model_dir=inference/cls \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=true \
+    --det=false \
+    --rec=false \
+    --cls=true \
+```
+
+##### 7. layout+table
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --table_model_dir=inference/table \
+    --image_dir=../../ppstructure/docs/table/table.jpg \
+    --layout_model_dir=inference/layout \
+    --type=structure \
+    --table=true \
+    --layout=true
+```
+
+##### 8. layout
+```shell
+./build/ppocr --layout_model_dir=inference/layout \
+    --image_dir=../../ppstructure/docs/table/1.png \
+    --type=structure \
+    --table=false \
+    --layout=true \
+    --det=false \
+    --rec=false
+```
+
+##### 9. table
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --table_model_dir=inference/table \
+    --image_dir=../../ppstructure/docs/table/table.jpg \
+    --type=structure \
+    --table=true
+```
+
+More parameters are as follows,
+
+- Common parameters
+
+|parameter|data type|default|meaning|
+| --- | --- | --- | --- |
+|use_gpu|bool|false|Whether to use GPU|
+|gpu_id|int|0|GPU id when use_gpu is true|
+|gpu_mem|int|4000|GPU memory requested|
+|cpu_math_library_num_threads|int|10|Number of threads when using CPU inference. When machine cores is enough, the large the value, the faster the inference speed|
+|enable_mkldnn|bool|true|Whether to use mkdlnn library|
+|output|str|./output|Path where visualization results are saved|
+
+
+- forward
+
+|parameter|data type|default|meaning|
+| :---: | :---: | :---: | :---: |
+|det|bool|true|Whether to perform text detection in the forward direction|
+|rec|bool|true|Whether to perform text recognition in the forward direction|
+|cls|bool|false|Whether to perform text direction classification in the forward direction|
+
+
+- Detection related parameters
+
+|parameter|data type|default|meaning|
+| --- | --- | --- | --- |
+|det_model_dir|string|-|Address of detection inference model|
+|max_side_len|int|960|Limit the maximum image height and width to 960|
+|det_db_thresh|float|0.3|Used to filter the binarized image of DB prediction, setting 0.-0.3 has no obvious effect on the result|
+|det_db_box_thresh|float|0.5|DB post-processing filter box threshold, if there is a missing box detected, it can be reduced as appropriate|
+|det_db_unclip_ratio|float|1.6|Indicates the compactness of the text box, the smaller the value, the closer the text box to the text|
+|det_db_score_mode|string|slow| slow: use polygon box to calculate bbox score, fast: use rectangle box to calculate. Use rectangular box to calculate faster, and polygonal box more accurate for curved text area.|
+|visualize|bool|true|Whether to visualize the results，when it is set as true, the prediction results will be saved in the folder specified by the `output` field on an image with the same name as the input image.|
+
+- Classifier related parameters
+
+|parameter|data type|default|meaning|
+| --- | --- | --- | --- |
+|use_angle_cls|bool|false|Whether to use the direction classifier|
+|cls_model_dir|string|-|Address of direction classifier inference model|
+|cls_thresh|float|0.9|Score threshold of the  direction classifier|
+|cls_batch_num|int|1|batch size of classifier|
+
+- Recognition related parameters
+
+|parameter|data type|default|meaning|
+| --- | --- | --- | --- |
+|rec_model_dir|string|-|Address of recognition inference model|
+|rec_char_dict_path|string|../../ppocr/utils/ppocr_keys_v1.txt|dictionary file|
+|rec_batch_num|int|6|batch size of recognition|
+|rec_img_h|int|48|image height of recognition|
+|rec_img_w|int|320|image width of recognition|
+
+- Layout related parameters
+
+|parameter|data type|default|meaning|
+| :---: | :---: | :---: | :---: |
+|layout_model_dir|string|-| Address of layout inference model|
+|layout_dict_path|string|../../ppocr/utils/dict/layout_dict/layout_publaynet_dict.txt|dictionary file|
+|layout_score_threshold|float|0.5|Threshold of score.|
+|layout_nms_threshold|float|0.5|Threshold of nms.|
+
+
+- Table recognition related parameters
+
+|parameter|data type|default|meaning|
+| :---: | :---: | :---: | :---: |
+|table_model_dir|string|-|Address of table recognition inference model|
+|table_char_dict_path|string|../../ppocr/utils/dict/table_structure_dict.txt|dictionary file|
+|table_max_len|int|488|The size of the long side of the input image of the table recognition model, the final input image size of the network is（table_max_len，table_max_len）|
+|merge_no_span_structure|bool|true|Whether to merge <td> and </td> to <td></td|
+
+
+* Multi-language inference is also supported in PaddleOCR, you can refer to [recognition tutorial](../../doc/doc_en/recognition_en.md) for more supported languages and models in PaddleOCR. Specifically, if you want to infer using multi-language models, you just need to modify values of `rec_char_dict_path` and `rec_model_dir`.
+
+
+The detection results will be shown on the screen, which is as follows.
+
+```bash
+predict img: ../../doc/imgs/12.jpg
+../../doc/imgs/12.jpg
+0       det boxes: [[74,553],[427,542],[428,571],[75,582]] rec text: 打浦路252935号 rec score: 0.947724
+1       det boxes: [[23,507],[513,488],[515,529],[24,548]] rec text: 绿洲仕格维花园公寓 rec score: 0.993728
+2       det boxes: [[187,456],[399,448],[400,480],[188,488]] rec text: 打浦路15号 rec score: 0.964994
+3       det boxes: [[42,413],[483,391],[484,428],[43,450]] rec text: 上海斯格威铂尔大酒店 rec score: 0.980086
+The detection visualized image saved in ./output//12.jpg
+```
+
+- layout+table
+
+```bash
+predict img: ../../ppstructure/docs/table/1.png
+0       type: text, region: [12,729,410,848], score: 0.781044, res: count of ocr result is : 7
+********** print ocr result **********
+0       det boxes: [[4,1],[79,1],[79,12],[4,12]] rec text: CTW1500. rec score: 0.769472
+...
+6       det boxes: [[4,99],[391,99],[391,112],[4,112]] rec text: sate-of-the-artmethods[12.34.36l.ourapproachachieves rec score: 0.90414
+********** end print ocr result **********
+1       type: text, region: [69,342,342,359], score: 0.703666, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[8,2],[269,2],[269,13],[8,13]] rec text: Table6.Experimentalresults on CTW-1500 rec score: 0.890454
+********** end print ocr result **********
+2       type: text, region: [70,316,706,332], score: 0.659738, res: count of ocr result is : 2
+********** print ocr result **********
+0       det boxes: [[373,2],[630,2],[630,11],[373,11]] rec text: oroposals.andthegreencontoursarefinal rec score: 0.919729
+1       det boxes: [[8,3],[357,3],[357,11],[8,11]] rec text: Visualexperimentalresultshebluecontoursareboundar rec score: 0.915963
+********** end print ocr result **********
+3       type: text, region: [489,342,789,359], score: 0.630538, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[8,2],[294,2],[294,14],[8,14]] rec text: Table7.Experimentalresults onMSRA-TD500 rec score: 0.942251
+********** end print ocr result **********
+4       type: text, region: [444,751,841,848], score: 0.607345, res: count of ocr result is : 5
+********** print ocr result **********
+0       det boxes: [[19,3],[389,3],[389,17],[19,17]] rec text: Inthispaper,weproposeanovel adaptivebound rec score: 0.941031
+1       det boxes: [[4,22],[390,22],[390,36],[4,36]] rec text: aryproposalnetworkforarbitraryshapetextdetection rec score: 0.960172
+2       det boxes: [[4,42],[392,42],[392,56],[4,56]] rec text: whichadoptanboundaryproposalmodeltogeneratecoarse rec score: 0.934647
+3       det boxes: [[4,61],[389,61],[389,75],[4,75]] rec text: ooundaryproposals,andthenadoptanadaptiveboundary rec score: 0.946296
+4       det boxes: [[5,80],[387,80],[387,93],[5,93]] rec text: leformationmodelcombinedwithGCNandRNNtoper rec score: 0.952401
+********** end print ocr result **********
+5       type: title, region: [444,705,564,724], score: 0.785429, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[6,2],[113,2],[113,14],[6,14]] rec text: 5.Conclusion rec score: 0.856903
+********** end print ocr result **********
+6       type: table, region: [14,360,402,711], score: 0.963643, res: <html><body><table><thead><tr><td>Methods</td><td>Ext</td><td>R</td><td>P</td><td>F</td><td>FPS</td></tr></thead><tbody><tr><td>TextSnake [18]</td><td>Syn</td><td>85.3</td><td>67.9</td><td>75.6</td><td></td></tr><tr><td>CSE [17]</td><td>MiLT</td><td>76.1</td><td>78.7</td><td>77.4</td><td>0.38</td></tr><tr><td>LOMO[40]</td><td>Syn</td><td>76.5</td><td>85.7</td><td>80.8</td><td>4.4</td></tr><tr><td>ATRR[35]</td><td>Sy-</td><td>80.2</td><td>80.1</td><td>80.1</td><td>-</td></tr><tr><td>SegLink++ [28]</td><td>Syn</td><td>79.8</td><td>82.8</td><td>81.3</td><td>-</td></tr><tr><td>TextField [37]</td><td>Syn</td><td>79.8</td><td>83.0</td><td>81.4</td><td>6.0</td></tr><tr><td>MSR[38]</td><td>Syn</td><td>79.0</td><td>84.1</td><td>81.5</td><td>4.3</td></tr><tr><td>PSENet-1s [33]</td><td>MLT</td><td>79.7</td><td>84.8</td><td>82.2</td><td>3.9</td></tr><tr><td>DB [12]</td><td>Syn</td><td>80.2</td><td>86.9</td><td>83.4</td><td>22.0</td></tr><tr><td>CRAFT [2]</td><td>Syn</td><td>81.1</td><td>86.0</td><td>83.5</td><td>-</td></tr><tr><td>TextDragon [5]</td><td>MLT+</td><td>82.8</td><td>84.5</td><td>83.6</td><td></td></tr><tr><td>PAN [34]</td><td>Syn</td><td>81.2</td><td>86.4</td><td>83.7</td><td>39.8</td></tr><tr><td>ContourNet [36]</td><td></td><td>84.1</td><td>83.7</td><td>83.9</td><td>4.5</td></tr><tr><td>DRRG [41]</td><td>MLT</td><td>83.02</td><td>85.93</td><td>84.45</td><td>-</td></tr><tr><td>TextPerception[23]</td><td>Syn</td><td>81.9</td><td>87.5</td><td>84.6</td><td></td></tr><tr><td>Ours</td><td> Syn</td><td>80.57</td><td>87.66</td><td>83.97</td><td>12.08</td></tr><tr><td>Ours</td><td></td><td>81.45</td><td>87.81</td><td>84.51</td><td>12.15</td></tr><tr><td>Ours</td><td>MLT</td><td>83.60</td><td>86.45</td><td>85.00</td><td>12.21</td></tr></tbody></table></body></html>
+The table visualized image saved in ./output//6_1.png
+7       type: table, region: [462,359,820,657], score: 0.953917, res: <html><body><table><thead><tr><td>Methods</td><td>R</td><td>P</td><td>F</td><td>FPS</td></tr></thead><tbody><tr><td>SegLink [26]</td><td>70.0</td><td>86.0</td><td>77.0</td><td>8.9</td></tr><tr><td>PixelLink [4]</td><td>73.2</td><td>83.0</td><td>77.8</td><td>-</td></tr><tr><td>TextSnake [18]</td><td>73.9</td><td>83.2</td><td>78.3</td><td>1.1</td></tr><tr><td>TextField [37]</td><td>75.9</td><td>87.4</td><td>81.3</td><td>5.2 </td></tr><tr><td>MSR[38]</td><td>76.7</td><td>87.4</td><td>81.7</td><td>-</td></tr><tr><td>FTSN[3]</td><td>77.1</td><td>87.6</td><td>82.0</td><td>:</td></tr><tr><td>LSE[30]</td><td>81.7</td><td>84.2</td><td>82.9</td><td></td></tr><tr><td>CRAFT [2]</td><td>78.2</td><td>88.2</td><td>82.9</td><td>8.6</td></tr><tr><td>MCN [16]</td><td>79</td><td>88</td><td>83</td><td>-</td></tr><tr><td>ATRR[35]</td><td>82.1</td><td>85.2</td><td>83.6</td><td>-</td></tr><tr><td>PAN [34]</td><td>83.8</td><td>84.4</td><td>84.1</td><td>30.2</td></tr><tr><td>DB[12]</td><td>79.2</td><td>91.5</td><td>84.9</td><td>32.0</td></tr><tr><td>DRRG [41]</td><td>82.30</td><td>88.05</td><td>85.08</td><td>-</td></tr><tr><td>Ours (SynText)</td><td>80.68</td><td>85.40</td><td>82.97</td><td>12.68</td></tr><tr><td>Ours (MLT-17)</td><td>84.54</td><td>86.62</td><td>85.57</td><td>12.31</td></tr></tbody></table></body></html>
+The table visualized image saved in ./output//7_1.png
+8       type: figure, region: [14,3,836,310], score: 0.969443, res: count of ocr result is : 26
+********** print ocr result **********
+0       det boxes: [[506,14],[539,15],[539,22],[506,21]] rec text: E rec score: 0.318073
+...
+25      det boxes: [[680,290],[759,288],[759,303],[680,305]] rec text: (d) CTW1500 rec score: 0.95911
+********** end print ocr result **********
+```
+
+<a name="3"></a>
+## 3. FAQ
+
+ 1.  Encountered the error `unable to access 'https://github.com/LDOUBLEV/AutoLog.git/': gnutls_handshake() failed: The TLS connection was non-properly terminated.`, change the github address in `deploy/cpp_infer/external-cmake/auto-log.cmake` to the https://gitee.com/Double_V/AutoLog address.

deploy/cpp_infer/readme_ch.md

+[English](readme.md) | 简体中文
+
+# 服务器端C++预测
+
+- [1. 准备环境](#1)
+    - [1.1 运行准备](#11)
+    - [1.2 编译opencv库](#12)
+    - [1.3 下载或者编译Paddle预测库](#13)
+- [2 开始运行](#2)
+    - [2.1 准备模型](#21)
+    - [2.2 编译PaddleOCR C++预测demo](#22)
+    - [2.3 运行demo](#23)
+- [3. FAQ](#3)
+
+本章节介绍PaddleOCR 模型的C++部署方法。C++在性能计算上优于Python，因此，在大多数CPU、GPU部署场景，多采用C++的部署方式，本节将介绍如何在Linux\Windows (CPU\GPU)环境下配置C++环境并完成PaddleOCR模型部署。
+
+
+<a name="1"></a>
+
+## 1. 准备环境
+
+<a name="11"></a>
+
+### 1.1 运行准备
+
+- Linux环境，推荐使用docker。
+- Windows环境。
+
+* 该文档主要介绍基于Linux环境的PaddleOCR C++预测流程，如果需要在Windows下基于预测库进行C++预测，具体编译方法请参考[Windows下编译教程](./docs/windows_vs2019_build.md)
+
+<a name="12"></a>
+
+### 1.2 编译opencv库
+
+* 首先需要从opencv官网上下载在Linux环境下源码编译的包，以opencv3.4.7为例，下载命令如下。
+
+```bash
+cd deploy/cpp_infer
+wget https://paddleocr.bj.bcebos.com/libs/opencv/opencv-3.4.7.tar.gz
+tar -xf opencv-3.4.7.tar.gz
+```
+
+最终可以在当前目录下看到`opencv-3.4.7/`的文件夹。
+
+* 编译opencv，设置opencv源码路径(`root_path`)以及安装路径(`install_path`)。进入opencv源码路径下，按照下面的方式进行编译。
+
+```shell
+root_path="your_opencv_root_path"
+install_path=${root_path}/opencv3
+build_dir=${root_path}/build
+
+rm -rf ${build_dir}
+mkdir ${build_dir}
+cd ${build_dir}
+
+cmake .. \
+    -DCMAKE_INSTALL_PREFIX=${install_path} \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DBUILD_SHARED_LIBS=OFF \
+    -DWITH_IPP=OFF \
+    -DBUILD_IPP_IW=OFF \
+    -DWITH_LAPACK=OFF \
+    -DWITH_EIGEN=OFF \
+    -DCMAKE_INSTALL_LIBDIR=lib64 \
+    -DWITH_ZLIB=ON \
+    -DBUILD_ZLIB=ON \
+    -DWITH_JPEG=ON \
+    -DBUILD_JPEG=ON \
+    -DWITH_PNG=ON \
+    -DBUILD_PNG=ON \
+    -DWITH_TIFF=ON \
+    -DBUILD_TIFF=ON
+
+make -j
+make install
+```
+
+也可以直接修改`tools/build_opencv.sh`的内容，然后直接运行下面的命令进行编译。
+
+```shell
+sh tools/build_opencv.sh
+```
+
+其中`root_path`为下载的opencv源码路径，`install_path`为opencv的安装路径，`make install`完成之后，会在该文件夹下生成opencv头文件和库文件，用于后面的OCR代码编译。
+
+最终在安装路径下的文件结构如下所示。
+
+```
+opencv3/
+|-- bin
+|-- include
+|-- lib
+|-- lib64
+|-- share
+```
+
+<a name="13"></a>
+
+### 1.3 下载或者编译Paddle预测库
+
+可以选择直接下载安装或者从源码编译，下文分别进行具体说明。
+
+<a name="131"></a>
+#### 1.3.1 直接下载安装
+
+[Paddle预测库官网](https://www.paddlepaddle.org.cn/inference/master/guides/install/download_lib.html#linux) 上提供了不同cuda版本的Linux预测库，可以在官网查看并选择合适的预测库版本（*建议选择paddle版本>=2.0.1版本的预测库* ）。
+
+下载之后解压:
+
+```shell
+tar -xf paddle_inference.tgz
+```
+
+最终会在当前的文件夹中生成`paddle_inference/`的子文件夹。
+
+<a name="132"></a>
+#### 1.3.2 预测库源码编译
+
+如果希望获取最新预测库特性，可以从github上克隆最新Paddle代码进行编译，生成最新的预测库。
+
+* 使用git获取代码:
+
+```shell
+git clone https://github.com/PaddlePaddle/Paddle.git
+git checkout develop
+```
+
+* 进入Paddle目录，进行编译:
+
+```shell
+rm -rf build
+mkdir build
+cd build
+
+cmake  .. \
+    -DWITH_CONTRIB=OFF \
+    -DWITH_MKL=ON \
+    -DWITH_MKLDNN=ON  \
+    -DWITH_TESTING=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DWITH_INFERENCE_API_TEST=OFF \
+    -DON_INFER=ON \
+    -DWITH_PYTHON=ON
+make -j
+make inference_lib_dist
+```
+
+更多编译参数选项介绍可以参考[Paddle预测库编译文档](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0/guides/05_inference_deployment/inference/build_and_install_lib_cn.html#congyuanmabianyi)。
+
+
+* 编译完成之后，可以在`build/paddle_inference_install_dir/`文件下看到生成了以下文件及文件夹。
+
+```
+build/paddle_inference_install_dir/
+|-- CMakeCache.txt
+|-- paddle
+|-- third_party
+|-- version.txt
+```
+
+其中`paddle`就是C++预测所需的Paddle库，`version.txt`中包含当前预测库的版本信息。
+
+<a name="2"></a>
+
+## 2. 开始运行
+
+<a name="21"></a>
+
+### 2.1 准备模型
+
+直接下载PaddleOCR提供的推理模型，或者参考[模型预测章节](../../doc/doc_ch/inference_ppocr.md)，将训练好的模型导出为推理模型。模型导出之后，假设放在`inference`目录下，则目录结构如下。
+
+```
+inference/
+|-- det_db
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- rec_rcnn
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- cls
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- table
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+|-- layout
+|   |--inference.pdiparams
+|   |--inference.pdmodel
+```
+
+<a name="22"></a>
+
+### 2.2 编译PaddleOCR C++预测demo
+
+编译命令如下，其中Paddle C++预测库、opencv等其他依赖库的地址需要换成自己机器上的实际地址。
+
+```shell
+sh tools/build.sh
+```
+
+具体的，需要修改`tools/build.sh`中环境路径，相关内容如下：
+
+```shell
+OPENCV_DIR=your_opencv_dir
+LIB_DIR=your_paddle_inference_dir
+CUDA_LIB_DIR=your_cuda_lib_dir
+CUDNN_LIB_DIR=/your_cudnn_lib_dir
+```
+
+其中，`OPENCV_DIR`为opencv编译安装的地址；`LIB_DIR`为下载(`paddle_inference`文件夹)或者编译生成的Paddle预测库地址(`build/paddle_inference_install_dir`文件夹)；`CUDA_LIB_DIR`为cuda库文件地址，在docker中为`/usr/local/cuda/lib64`；`CUDNN_LIB_DIR`为cudnn库文件地址，在docker中为`/usr/lib/x86_64-linux-gnu/`。**注意：以上路径都写绝对路径，不要写相对路径。**
+
+
+编译完成之后，会在`build`文件夹下生成一个名为`ppocr`的可执行文件。
+
+<a name="23"></a>
+
+### 2.3 运行demo
+
+本demo支持系统串联调用，也支持单个功能的调用，如，只使用检测或识别功能。
+
+**注意** ppocr默认使用`PP-OCRv3`模型，识别模型使用的输入shape为`3,48,320`, 如需使用旧版本的PP-OCR模型，则需要设置参数`--rec_img_h=32`。
+
+
+运行方式：
+```shell
+./build/ppocr [--param1] [--param2] [...]
+```
+具体命令如下：
+
+##### 1. 检测+分类+识别：
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs/12.jpg \
+    --use_angle_cls=true \
+    --det=true \
+    --rec=true \
+    --cls=true \
+```
+
+##### 2. 检测+识别：
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --image_dir=../../doc/imgs/12.jpg \
+    --use_angle_cls=false \
+    --det=true \
+    --rec=true \
+    --cls=false \
+```
+
+##### 3. 检测：
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --image_dir=../../doc/imgs/12.jpg \
+    --det=true \
+    --rec=false
+```
+
+##### 4. 分类+识别：
+```shell
+./build/ppocr --rec_model_dir=inference/rec_rcnn \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=true \
+    --det=false \
+    --rec=true \
+    --cls=true \
+```
+
+##### 5. 识别：
+```shell
+./build/ppocr --rec_model_dir=inference/rec_rcnn \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=false \
+    --det=false \
+    --rec=true \
+    --cls=false \
+```
+
+##### 6. 分类：
+```shell
+./build/ppocr --cls_model_dir=inference/cls \
+    --cls_model_dir=inference/cls \
+    --image_dir=../../doc/imgs_words/ch/word_1.jpg \
+    --use_angle_cls=true \
+    --det=false \
+    --rec=false \
+    --cls=true \
+```
+
+##### 7. 版面分析+表格识别
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --table_model_dir=inference/table \
+    --image_dir=../../ppstructure/docs/table/table.jpg \
+    --layout_model_dir=inference/layout \
+    --type=structure \
+    --table=true \
+    --layout=true
+```
+
+##### 8. 版面分析
+```shell
+./build/ppocr --layout_model_dir=inference/layout \
+    --image_dir=../../ppstructure/docs/table/1.png \
+    --type=structure \
+    --table=false \
+    --layout=true \
+    --det=false \
+    --rec=false
+```
+
+##### 9. 表格识别
+```shell
+./build/ppocr --det_model_dir=inference/det_db \
+    --rec_model_dir=inference/rec_rcnn \
+    --table_model_dir=inference/table \
+    --image_dir=../../ppstructure/docs/table/table.jpg \
+    --type=structure \
+    --table=true
+```
+
+更多支持的可调节参数解释如下：
+
+- 通用参数
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|use_gpu|bool|false|是否使用GPU|
+|gpu_id|int|0|GPU id，使用GPU时有效|
+|gpu_mem|int|4000|申请的GPU内存|
+|cpu_math_library_num_threads|int|10|CPU预测时的线程数，在机器核数充足的情况下，该值越大，预测速度越快|
+|enable_mkldnn|bool|true|是否使用mkldnn库|
+|output|str|./output|可视化结果保存的路径|
+
+- 前向相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|det|bool|true|前向是否执行文字检测|
+|rec|bool|true|前向是否执行文字识别|
+|cls|bool|false|前向是否执行文字方向分类|
+
+
+- 检测模型相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|det_model_dir|string|-|检测模型inference model地址|
+|max_side_len|int|960|输入图像长宽大于960时，等比例缩放图像，使得图像最长边为960|
+|det_db_thresh|float|0.3|用于过滤DB预测的二值化图像，设置为0.-0.3对结果影响不明显|
+|det_db_box_thresh|float|0.5|DB后处理过滤box的阈值，如果检测存在漏框情况，可酌情减小|
+|det_db_unclip_ratio|float|1.6|表示文本框的紧致程度，越小则文本框更靠近文本|
+|det_db_score_mode|string|slow|slow:使用多边形框计算bbox score，fast:使用矩形框计算。矩形框计算速度更快，多边形框对弯曲文本区域计算更准确。|
+|visualize|bool|true|是否对结果进行可视化，为1时，预测结果会保存在`output`字段指定的文件夹下和输入图像同名的图像上。|
+
+- 方向分类器相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|use_angle_cls|bool|false|是否使用方向分类器|
+|cls_model_dir|string|-|方向分类器inference model地址|
+|cls_thresh|float|0.9|方向分类器的得分阈值|
+|cls_batch_num|int|1|方向分类器batchsize|
+
+- 文字识别模型相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|rec_model_dir|string|-|文字识别模型inference model地址|
+|rec_char_dict_path|string|../../ppocr/utils/ppocr_keys_v1.txt|字典文件|
+|rec_batch_num|int|6|文字识别模型batchsize|
+|rec_img_h|int|48|文字识别模型输入图像高度|
+|rec_img_w|int|320|文字识别模型输入图像宽度|
+
+
+- 版面分析模型相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|layout_model_dir|string|-|版面分析模型inference model地址|
+|layout_dict_path|string|../../ppocr/utils/dict/layout_dict/layout_publaynet_dict.txt|字典文件|
+|layout_score_threshold|float|0.5|检测框的分数阈值|
+|layout_nms_threshold|float|0.5|nms的阈值|
+
+
+- 表格识别模型相关
+
+|参数名称|类型|默认参数|意义|
+| :---: | :---: | :---: | :---: |
+|table_model_dir|string|-|表格识别模型inference model地址|
+|table_char_dict_path|string|../../ppocr/utils/dict/table_structure_dict_ch.txt|字典文件|
+|table_max_len|int|488|表格识别模型输入图像长边大小，最终网络输入图像大小为（table_max_len，table_max_len）|
+|merge_no_span_structure|bool|true|是否合并<td> 和 </td> 为<td></td>|
+
+
+* PaddleOCR也支持多语言的预测，更多支持的语言和模型可以参考[识别文档](../../doc/doc_ch/recognition.md)中的多语言字典与模型部分，如果希望进行多语言预测，只需将修改`rec_char_dict_path`（字典文件路径）以及`rec_model_dir`（inference模型路径）字段即可。
+
+最终屏幕上会输出检测结果如下。
+
+- ocr
+
+```bash
+predict img: ../../doc/imgs/12.jpg
+../../doc/imgs/12.jpg
+0       det boxes: [[74,553],[427,542],[428,571],[75,582]] rec text: 打浦路252935号 rec score: 0.947724
+1       det boxes: [[23,507],[513,488],[515,529],[24,548]] rec text: 绿洲仕格维花园公寓 rec score: 0.993728
+2       det boxes: [[187,456],[399,448],[400,480],[188,488]] rec text: 打浦路15号 rec score: 0.964994
+3       det boxes: [[42,413],[483,391],[484,428],[43,450]] rec text: 上海斯格威铂尔大酒店 rec score: 0.980086
+The detection visualized image saved in ./output//12.jpg
+```
+
+- layout+table
+
+```bash
+predict img: ../../ppstructure/docs/table/1.png
+0       type: text, region: [12,729,410,848], score: 0.781044, res: count of ocr result is : 7
+********** print ocr result **********
+0       det boxes: [[4,1],[79,1],[79,12],[4,12]] rec text: CTW1500. rec score: 0.769472
+...
+6       det boxes: [[4,99],[391,99],[391,112],[4,112]] rec text: sate-of-the-artmethods[12.34.36l.ourapproachachieves rec score: 0.90414
+********** end print ocr result **********
+1       type: text, region: [69,342,342,359], score: 0.703666, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[8,2],[269,2],[269,13],[8,13]] rec text: Table6.Experimentalresults on CTW-1500 rec score: 0.890454
+********** end print ocr result **********
+2       type: text, region: [70,316,706,332], score: 0.659738, res: count of ocr result is : 2
+********** print ocr result **********
+0       det boxes: [[373,2],[630,2],[630,11],[373,11]] rec text: oroposals.andthegreencontoursarefinal rec score: 0.919729
+1       det boxes: [[8,3],[357,3],[357,11],[8,11]] rec text: Visualexperimentalresultshebluecontoursareboundar rec score: 0.915963
+********** end print ocr result **********
+3       type: text, region: [489,342,789,359], score: 0.630538, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[8,2],[294,2],[294,14],[8,14]] rec text: Table7.Experimentalresults onMSRA-TD500 rec score: 0.942251
+********** end print ocr result **********
+4       type: text, region: [444,751,841,848], score: 0.607345, res: count of ocr result is : 5
+********** print ocr result **********
+0       det boxes: [[19,3],[389,3],[389,17],[19,17]] rec text: Inthispaper,weproposeanovel adaptivebound rec score: 0.941031
+1       det boxes: [[4,22],[390,22],[390,36],[4,36]] rec text: aryproposalnetworkforarbitraryshapetextdetection rec score: 0.960172
+2       det boxes: [[4,42],[392,42],[392,56],[4,56]] rec text: whichadoptanboundaryproposalmodeltogeneratecoarse rec score: 0.934647
+3       det boxes: [[4,61],[389,61],[389,75],[4,75]] rec text: ooundaryproposals,andthenadoptanadaptiveboundary rec score: 0.946296
+4       det boxes: [[5,80],[387,80],[387,93],[5,93]] rec text: leformationmodelcombinedwithGCNandRNNtoper rec score: 0.952401
+********** end print ocr result **********
+5       type: title, region: [444,705,564,724], score: 0.785429, res: count of ocr result is : 1
+********** print ocr result **********
+0       det boxes: [[6,2],[113,2],[113,14],[6,14]] rec text: 5.Conclusion rec score: 0.856903
+********** end print ocr result **********
+6       type: table, region: [14,360,402,711], score: 0.963643, res: <html><body><table><thead><tr><td>Methods</td><td>Ext</td><td>R</td><td>P</td><td>F</td><td>FPS</td></tr></thead><tbody><tr><td>TextSnake [18]</td><td>Syn</td><td>85.3</td><td>67.9</td><td>75.6</td><td></td></tr><tr><td>CSE [17]</td><td>MiLT</td><td>76.1</td><td>78.7</td><td>77.4</td><td>0.38</td></tr><tr><td>LOMO[40]</td><td>Syn</td><td>76.5</td><td>85.7</td><td>80.8</td><td>4.4</td></tr><tr><td>ATRR[35]</td><td>Sy-</td><td>80.2</td><td>80.1</td><td>80.1</td><td>-</td></tr><tr><td>SegLink++ [28]</td><td>Syn</td><td>79.8</td><td>82.8</td><td>81.3</td><td>-</td></tr><tr><td>TextField [37]</td><td>Syn</td><td>79.8</td><td>83.0</td><td>81.4</td><td>6.0</td></tr><tr><td>MSR[38]</td><td>Syn</td><td>79.0</td><td>84.1</td><td>81.5</td><td>4.3</td></tr><tr><td>PSENet-1s [33]</td><td>MLT</td><td>79.7</td><td>84.8</td><td>82.2</td><td>3.9</td></tr><tr><td>DB [12]</td><td>Syn</td><td>80.2</td><td>86.9</td><td>83.4</td><td>22.0</td></tr><tr><td>CRAFT [2]</td><td>Syn</td><td>81.1</td><td>86.0</td><td>83.5</td><td>-</td></tr><tr><td>TextDragon [5]</td><td>MLT+</td><td>82.8</td><td>84.5</td><td>83.6</td><td></td></tr><tr><td>PAN [34]</td><td>Syn</td><td>81.2</td><td>86.4</td><td>83.7</td><td>39.8</td></tr><tr><td>ContourNet [36]</td><td></td><td>84.1</td><td>83.7</td><td>83.9</td><td>4.5</td></tr><tr><td>DRRG [41]</td><td>MLT</td><td>83.02</td><td>85.93</td><td>84.45</td><td>-</td></tr><tr><td>TextPerception[23]</td><td>Syn</td><td>81.9</td><td>87.5</td><td>84.6</td><td></td></tr><tr><td>Ours</td><td> Syn</td><td>80.57</td><td>87.66</td><td>83.97</td><td>12.08</td></tr><tr><td>Ours</td><td></td><td>81.45</td><td>87.81</td><td>84.51</td><td>12.15</td></tr><tr><td>Ours</td><td>MLT</td><td>83.60</td><td>86.45</td><td>85.00</td><td>12.21</td></tr></tbody></table></body></html>
+The table visualized image saved in ./output//6_1.png
+7       type: table, region: [462,359,820,657], score: 0.953917, res: <html><body><table><thead><tr><td>Methods</td><td>R</td><td>P</td><td>F</td><td>FPS</td></tr></thead><tbody><tr><td>SegLink [26]</td><td>70.0</td><td>86.0</td><td>77.0</td><td>8.9</td></tr><tr><td>PixelLink [4]</td><td>73.2</td><td>83.0</td><td>77.8</td><td>-</td></tr><tr><td>TextSnake [18]</td><td>73.9</td><td>83.2</td><td>78.3</td><td>1.1</td></tr><tr><td>TextField [37]</td><td>75.9</td><td>87.4</td><td>81.3</td><td>5.2 </td></tr><tr><td>MSR[38]</td><td>76.7</td><td>87.4</td><td>81.7</td><td>-</td></tr><tr><td>FTSN[3]</td><td>77.1</td><td>87.6</td><td>82.0</td><td>:</td></tr><tr><td>LSE[30]</td><td>81.7</td><td>84.2</td><td>82.9</td><td></td></tr><tr><td>CRAFT [2]</td><td>78.2</td><td>88.2</td><td>82.9</td><td>8.6</td></tr><tr><td>MCN [16]</td><td>79</td><td>88</td><td>83</td><td>-</td></tr><tr><td>ATRR[35]</td><td>82.1</td><td>85.2</td><td>83.6</td><td>-</td></tr><tr><td>PAN [34]</td><td>83.8</td><td>84.4</td><td>84.1</td><td>30.2</td></tr><tr><td>DB[12]</td><td>79.2</td><td>91.5</td><td>84.9</td><td>32.0</td></tr><tr><td>DRRG [41]</td><td>82.30</td><td>88.05</td><td>85.08</td><td>-</td></tr><tr><td>Ours (SynText)</td><td>80.68</td><td>85.40</td><td>82.97</td><td>12.68</td></tr><tr><td>Ours (MLT-17)</td><td>84.54</td><td>86.62</td><td>85.57</td><td>12.31</td></tr></tbody></table></body></html>
+The table visualized image saved in ./output//7_1.png
+8       type: figure, region: [14,3,836,310], score: 0.969443, res: count of ocr result is : 26
+********** print ocr result **********
+0       det boxes: [[506,14],[539,15],[539,22],[506,21]] rec text: E rec score: 0.318073
+...
+25      det boxes: [[680,290],[759,288],[759,303],[680,305]] rec text: (d) CTW1500 rec score: 0.95911
+********** end print ocr result **********
+```
+
+<a name="3"></a>
+## 3. FAQ
+
+ 1.  遇到报错 `unable to access 'https://github.com/LDOUBLEV/AutoLog.git/': gnutls_handshake() failed: The TLS connection was non-properly terminated.`， 将 `deploy/cpp_infer/external-cmake/auto-log.cmake` 中的github地址改为 https://gitee.com/Double_V/AutoLog 地址即可。

deploy/cpp_infer/src/args.cpp

+// 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 id when inferring with GPU.");
+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/clipper.cpp

+/*******************************************************************************
+ *                                                                              *
+ * Author    :  Angus Johnson * Version   :  6.4.2 * Date      :  27 February
+ *2017                                                * Website   :
+ *http://www.angusj.com                                           * Copyright :
+ *Angus Johnson 2010-2017                                         *
+ *                                                                              *
+ * License: * Use, modification & distribution is subject to Boost Software
+ *License Ver 1. * http://www.boost.org/LICENSE_1_0.txt *
+ *                                                                              *
+ * Attributions: * The code in this library is an extension of Bala Vatti's
+ *clipping algorithm: * "A generic solution to polygon clipping" *
+ * Communications of the ACM, Vol 35, Issue 7 (July 1992) pp 56-63. *
+ * http://portal.acm.org/citation.cfm?id=129906 *
+ *                                                                              *
+ * Computer graphics and geometric modeling: implementation and algorithms * By
+ *Max K. Agoston                                                            *
+ * Springer; 1 edition (January 4, 2005) *
+ * http://books.google.com/books?q=vatti+clipping+agoston *
+ *                                                                              *
+ * See also: * "Polygon Offsetting by Computing Winding Numbers" * Paper no.
+ *DETC2005-85513 pp. 565-575                                         * ASME 2005
+ *International Design Engineering Technical Conferences             * and
+ *Computers and Information in Engineering Conference (IDETC/CIE2005)      *
+ * September 24-28, 2005 , Long Beach, California, USA *
+ * http://www.me.berkeley.edu/~mcmains/pubs/DAC05OffsetPolygon.pdf *
+ *                                                                              *
+ *******************************************************************************/
+
+/*******************************************************************************
+ *                                                                              *
+ * This is a translation of the Delphi Clipper library and the naming style *
+ * used has retained a Delphi flavour. *
+ *                                                                              *
+ *******************************************************************************/
+
+#include <include/clipper.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+#include <ostream>
+
+namespace ClipperLib {
+
+static double const pi = 3.141592653589793238;
+static double const two_pi = pi * 2;
+static double const def_arc_tolerance = 0.25;
+
+enum Direction { dRightToLeft, dLeftToRight };
+
+static int const Unassigned = -1; // edge not currently 'owning' a solution
+static int const Skip = -2;       // edge that would otherwise close a path
+
+#define HORIZONTAL (-1.0E+40)
+#define TOLERANCE (1.0e-20)
+#define NEAR_ZERO(val) (((val) > -TOLERANCE) && ((val) < TOLERANCE))
+
+struct TEdge {
+  IntPoint Bot;
+  IntPoint Curr; // current (updated for every new scanbeam)
+  IntPoint Top;
+  double Dx;
+  PolyType PolyTyp;
+  EdgeSide Side; // side only refers to current side of solution poly
+  int WindDelta; // 1 or -1 depending on winding direction
+  int WindCnt;
+  int WindCnt2; // winding count of the opposite polytype
+  int OutIdx;
+  TEdge *Next;
+  TEdge *Prev;
+  TEdge *NextInLML;
+  TEdge *NextInAEL;
+  TEdge *PrevInAEL;
+  TEdge *NextInSEL;
+  TEdge *PrevInSEL;
+};
+
+struct IntersectNode {
+  TEdge *Edge1;
+  TEdge *Edge2;
+  IntPoint Pt;
+};
+
+struct LocalMinimum {
+  cInt Y;
+  TEdge *LeftBound;
+  TEdge *RightBound;
+};
+
+struct OutPt;
+
+// OutRec: contains a path in the clipping solution. Edges in the AEL will
+// carry a pointer to an OutRec when they are part of the clipping solution.
+struct OutRec {
+  int Idx;
+  bool IsHole;
+  bool IsOpen;
+  OutRec *FirstLeft; // see comments in clipper.pas
+  PolyNode *PolyNd;
+  OutPt *Pts;
+  OutPt *BottomPt;
+};
+
+struct OutPt {
+  int Idx;
+  IntPoint Pt;
+  OutPt *Next;
+  OutPt *Prev;
+};
+
+struct Join {
+  OutPt *OutPt1;
+  OutPt *OutPt2;
+  IntPoint OffPt;
+};
+
+struct LocMinSorter {
+  inline bool operator()(const LocalMinimum &locMin1,
+                         const LocalMinimum &locMin2) noexcept {
+    return locMin2.Y < locMin1.Y;
+  }
+};
+
+//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
+
+inline cInt Round(double val) noexcept {
+  if ((val < 0))
+    return static_cast<cInt>(val - 0.5);
+  else
+    return static_cast<cInt>(val + 0.5);
+}
+//------------------------------------------------------------------------------
+
+inline cInt Abs(cInt val) noexcept { return val < 0 ? -val : val; }
+
+//------------------------------------------------------------------------------
+// PolyTree methods ...
+//------------------------------------------------------------------------------
+
+void PolyTree::Clear() noexcept {
+  for (PolyNodes::size_type i = 0; i < AllNodes.size(); ++i)
+    delete AllNodes[i];
+  AllNodes.resize(0);
+  Children.resize(0);
+}
+//------------------------------------------------------------------------------
+
+PolyNode *PolyTree::GetFirst() const noexcept {
+  if (!Children.empty())
+    return Children[0];
+  else
+    return 0;
+}
+//------------------------------------------------------------------------------
+
+int PolyTree::Total() const noexcept {
+  int result = (int)AllNodes.size();
+  // with negative offsets, ignore the hidden outer polygon ...
+  if (result > 0 && Children[0] != AllNodes[0])
+    result--;
+  return result;
+}
+
+//------------------------------------------------------------------------------
+// PolyNode methods ...
+//------------------------------------------------------------------------------
+
+PolyNode::PolyNode() noexcept : Parent(0), Index(0), m_IsOpen(false) {}
+//------------------------------------------------------------------------------
+
+int PolyNode::ChildCount() const noexcept { return (int)Children.size(); }
+//------------------------------------------------------------------------------
+
+void PolyNode::AddChild(PolyNode &child) noexcept {
+  unsigned cnt = (unsigned)Children.size();
+  Children.emplace_back(&child);
+  child.Parent = this;
+  child.Index = cnt;
+}
+//------------------------------------------------------------------------------
+
+PolyNode *PolyNode::GetNext() const noexcept {
+  if (!Children.empty())
+    return Children[0];
+  else
+    return GetNextSiblingUp();
+}
+//------------------------------------------------------------------------------
+
+PolyNode *PolyNode::GetNextSiblingUp() const noexcept {
+  if (!Parent) // protects against PolyTree.GetNextSiblingUp()
+    return 0;
+  else if (Index == Parent->Children.size() - 1)
+    return Parent->GetNextSiblingUp();
+  else
+    return Parent->Children[Index + 1];
+}
+//------------------------------------------------------------------------------
+
+bool PolyNode::IsHole() const noexcept {
+  bool result = true;
+  PolyNode *node = Parent;
+  while (node) {
+    result = !result;
+    node = node->Parent;
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+bool PolyNode::IsOpen() const noexcept { return m_IsOpen; }
+//------------------------------------------------------------------------------
+
+#ifndef use_int32
+
+//------------------------------------------------------------------------------
+// Int128 class (enables safe math on signed 64bit integers)
+// eg Int128 val1((long64)9223372036854775807); //ie 2^63 -1
+//    Int128 val2((long64)9223372036854775807);
+//    Int128 val3 = val1 * val2;
+//    val3.AsString => "85070591730234615847396907784232501249" (8.5e+37)
+//------------------------------------------------------------------------------
+
+class Int128 {
+public:
+  ulong64 lo;
+  long64 hi;
+
+  Int128(long64 _lo = 0) noexcept {
+    lo = (ulong64)_lo;
+    if (_lo < 0)
+      hi = -1;
+    else
+      hi = 0;
+  }
+
+  Int128(const Int128 &val) noexcept : lo(val.lo), hi(val.hi) {}
+
+  Int128(const long64 &_hi, const ulong64 &_lo) noexcept : lo(_lo), hi(_hi) {}
+
+  Int128 &operator=(const long64 &val) noexcept {
+    lo = (ulong64)val;
+    if (val < 0)
+      hi = -1;
+    else
+      hi = 0;
+    return *this;
+  }
+
+  bool operator==(const Int128 &val) const noexcept {
+    return (hi == val.hi && lo == val.lo);
+  }
+
+  bool operator!=(const Int128 &val) const noexcept { return !(*this == val); }
+
+  bool operator>(const Int128 &val) const noexcept {
+    if (hi != val.hi)
+      return hi > val.hi;
+    else
+      return lo > val.lo;
+  }
+
+  bool operator<(const Int128 &val) const noexcept {
+    if (hi != val.hi)
+      return hi < val.hi;
+    else
+      return lo < val.lo;
+  }
+
+  bool operator>=(const Int128 &val) const noexcept { return !(*this < val); }
+
+  bool operator<=(const Int128 &val) const noexcept { return !(*this > val); }
+
+  Int128 &operator+=(const Int128 &rhs) noexcept {
+    hi += rhs.hi;
+    lo += rhs.lo;
+    if (lo < rhs.lo)
+      hi++;
+    return *this;
+  }
+
+  Int128 operator+(const Int128 &rhs) const noexcept {
+    Int128 result(*this);
+    result += rhs;
+    return result;
+  }
+
+  Int128 &operator-=(const Int128 &rhs) noexcept {
+    *this += -rhs;
+    return *this;
+  }
+
+  Int128 operator-(const Int128 &rhs) const noexcept {
+    Int128 result(*this);
+    result -= rhs;
+    return result;
+  }
+
+  Int128 operator-() const noexcept // unary negation
+  {
+    if (lo == 0)
+      return Int128(-hi, 0);
+    else
+      return Int128(~hi, ~lo + 1);
+  }
+
+  operator double() const noexcept {
+    const double shift64 = 18446744073709551616.0; // 2^64
+    if (hi < 0) {
+      if (lo == 0)
+        return (double)hi * shift64;
+      else
+        return -(double)(~lo + ~hi * shift64);
+    } else
+      return (double)(lo + hi * shift64);
+  }
+};
+//------------------------------------------------------------------------------
+
+Int128 Int128Mul(long64 lhs, long64 rhs) noexcept {
+  bool negate = (lhs < 0) != (rhs < 0);
+
+  if (lhs < 0)
+    lhs = -lhs;
+  ulong64 int1Hi = ulong64(lhs) >> 32;
+  ulong64 int1Lo = ulong64(lhs & 0xFFFFFFFF);
+
+  if (rhs < 0)
+    rhs = -rhs;
+  ulong64 int2Hi = ulong64(rhs) >> 32;
+  ulong64 int2Lo = ulong64(rhs & 0xFFFFFFFF);
+
+  // nb: see comments in clipper.pas
+  ulong64 a = int1Hi * int2Hi;
+  ulong64 b = int1Lo * int2Lo;
+  ulong64 c = int1Hi * int2Lo + int1Lo * int2Hi;
+
+  Int128 tmp;
+  tmp.hi = long64(a + (c >> 32));
+  tmp.lo = long64(c << 32);
+  tmp.lo += long64(b);
+  if (tmp.lo < b)
+    tmp.hi++;
+  if (negate)
+    tmp = -tmp;
+  return tmp;
+};
+#endif
+
+//------------------------------------------------------------------------------
+// Miscellaneous global functions
+//------------------------------------------------------------------------------
+
+bool Orientation(const Path &poly) noexcept { return Area(poly) >= 0; }
+//------------------------------------------------------------------------------
+
+double Area(const Path &poly) noexcept {
+  int size = (int)poly.size();
+  if (size < 3)
+    return 0;
+
+  double a = 0;
+  for (int i = 0, j = size - 1; i < size; ++i) {
+    a += ((double)poly[j].X + poly[i].X) * ((double)poly[j].Y - poly[i].Y);
+    j = i;
+  }
+  return -a * 0.5;
+}
+//------------------------------------------------------------------------------
+
+double Area(const OutPt *op) noexcept {
+  const OutPt *startOp = op;
+  if (!op)
+    return 0;
+  double a = 0;
+  do {
+    a += (double)(op->Prev->Pt.X + op->Pt.X) *
+         (double)(op->Prev->Pt.Y - op->Pt.Y);
+    op = op->Next;
+  } while (op != startOp);
+  return a * 0.5;
+}
+//------------------------------------------------------------------------------
+
+double Area(const OutRec &outRec) noexcept { return Area(outRec.Pts); }
+//------------------------------------------------------------------------------
+
+bool PointIsVertex(const IntPoint &Pt, OutPt *pp) noexcept {
+  OutPt *pp2 = pp;
+  do {
+    if (pp2->Pt == Pt)
+      return true;
+    pp2 = pp2->Next;
+  } while (pp2 != pp);
+  return false;
+}
+//------------------------------------------------------------------------------
+
+// See "The Point in Polygon Problem for Arbitrary Polygons" by Hormann &
+// Agathos
+// http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf
+int PointInPolygon(const IntPoint &pt, const Path &path) noexcept {
+  // returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+  int result = 0;
+  size_t cnt = path.size();
+  if (cnt < 3)
+    return 0;
+  IntPoint ip = path[0];
+  for (size_t i = 1; i <= cnt; ++i) {
+    IntPoint ipNext = (i == cnt ? path[0] : path[i]);
+    if (ipNext.Y == pt.Y) {
+      if ((ipNext.X == pt.X) ||
+          (ip.Y == pt.Y && ((ipNext.X > pt.X) == (ip.X < pt.X))))
+        return -1;
+    }
+    if ((ip.Y < pt.Y) != (ipNext.Y < pt.Y)) {
+      if (ip.X >= pt.X) {
+        if (ipNext.X > pt.X)
+          result = 1 - result;
+        else {
+          double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                     (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+          if (!d)
+            return -1;
+          if ((d > 0) == (ipNext.Y > ip.Y))
+            result = 1 - result;
+        }
+      } else {
+        if (ipNext.X > pt.X) {
+          double d = (double)(ip.X - pt.X) * (ipNext.Y - pt.Y) -
+                     (double)(ipNext.X - pt.X) * (ip.Y - pt.Y);
+          if (!d)
+            return -1;
+          if ((d > 0) == (ipNext.Y > ip.Y))
+            result = 1 - result;
+        }
+      }
+    }
+    ip = ipNext;
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+int PointInPolygon(const IntPoint &pt, OutPt *op) noexcept {
+  // returns 0 if false, +1 if true, -1 if pt ON polygon boundary
+  int result = 0;
+  OutPt *startOp = op;
+  for (;;) {
+    if (op->Next->Pt.Y == pt.Y) {
+      if ((op->Next->Pt.X == pt.X) ||
+          (op->Pt.Y == pt.Y && ((op->Next->Pt.X > pt.X) == (op->Pt.X < pt.X))))
+        return -1;
+    }
+    if ((op->Pt.Y < pt.Y) != (op->Next->Pt.Y < pt.Y)) {
+      if (op->Pt.X >= pt.X) {
+        if (op->Next->Pt.X > pt.X)
+          result = 1 - result;
+        else {
+          double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) -
+                     (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y);
+          if (!d)
+            return -1;
+          if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y))
+            result = 1 - result;
+        }
+      } else {
+        if (op->Next->Pt.X > pt.X) {
+          double d = (double)(op->Pt.X - pt.X) * (op->Next->Pt.Y - pt.Y) -
+                     (double)(op->Next->Pt.X - pt.X) * (op->Pt.Y - pt.Y);
+          if (!d)
+            return -1;
+          if ((d > 0) == (op->Next->Pt.Y > op->Pt.Y))
+            result = 1 - result;
+        }
+      }
+    }
+    op = op->Next;
+    if (startOp == op)
+      break;
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+bool Poly2ContainsPoly1(OutPt *OutPt1, OutPt *OutPt2) noexcept {
+  OutPt *op = OutPt1;
+  do {
+    // nb: PointInPolygon returns 0 if false, +1 if true, -1 if pt on polygon
+    int res = PointInPolygon(op->Pt, OutPt2);
+    if (res >= 0)
+      return res > 0;
+    op = op->Next;
+  } while (op != OutPt1);
+  return true;
+}
+//----------------------------------------------------------------------
+
+bool SlopesEqual(const TEdge &e1, const TEdge &e2,
+                 bool UseFullInt64Range) noexcept {
+#ifndef use_int32
+  if (UseFullInt64Range)
+    return Int128Mul(e1.Top.Y - e1.Bot.Y, e2.Top.X - e2.Bot.X) ==
+           Int128Mul(e1.Top.X - e1.Bot.X, e2.Top.Y - e2.Bot.Y);
+  else
+#endif
+    return (e1.Top.Y - e1.Bot.Y) * (e2.Top.X - e2.Bot.X) ==
+           (e1.Top.X - e1.Bot.X) * (e2.Top.Y - e2.Bot.Y);
+}
+//------------------------------------------------------------------------------
+
+bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3,
+                 bool UseFullInt64Range) noexcept {
+#ifndef use_int32
+  if (UseFullInt64Range)
+    return Int128Mul(pt1.Y - pt2.Y, pt2.X - pt3.X) ==
+           Int128Mul(pt1.X - pt2.X, pt2.Y - pt3.Y);
+  else
+#endif
+    return (pt1.Y - pt2.Y) * (pt2.X - pt3.X) ==
+           (pt1.X - pt2.X) * (pt2.Y - pt3.Y);
+}
+//------------------------------------------------------------------------------
+
+bool SlopesEqual(const IntPoint &pt1, const IntPoint &pt2, const IntPoint &pt3,
+                 const IntPoint &pt4, bool UseFullInt64Range) noexcept {
+#ifndef use_int32
+  if (UseFullInt64Range)
+    return Int128Mul(pt1.Y - pt2.Y, pt3.X - pt4.X) ==
+           Int128Mul(pt1.X - pt2.X, pt3.Y - pt4.Y);
+  else
+#endif
+    return (pt1.Y - pt2.Y) * (pt3.X - pt4.X) ==
+           (pt1.X - pt2.X) * (pt3.Y - pt4.Y);
+}
+//------------------------------------------------------------------------------
+
+inline bool IsHorizontal(TEdge &e) noexcept { return e.Dx == HORIZONTAL; }
+//------------------------------------------------------------------------------
+
+inline double GetDx(const IntPoint &pt1, const IntPoint &pt2) noexcept {
+  return (pt1.Y == pt2.Y) ? HORIZONTAL
+                          : (double)(pt2.X - pt1.X) / (pt2.Y - pt1.Y);
+}
+//---------------------------------------------------------------------------
+
+inline void SetDx(TEdge &e) noexcept {
+  cInt dy = (e.Top.Y - e.Bot.Y);
+  if (dy == 0)
+    e.Dx = HORIZONTAL;
+  else
+    e.Dx = (double)(e.Top.X - e.Bot.X) / dy;
+}
+//---------------------------------------------------------------------------
+
+inline void SwapSides(TEdge &Edge1, TEdge &Edge2) noexcept {
+  EdgeSide Side = Edge1.Side;
+  Edge1.Side = Edge2.Side;
+  Edge2.Side = Side;
+}
+//------------------------------------------------------------------------------
+
+inline void SwapPolyIndexes(TEdge &Edge1, TEdge &Edge2) noexcept {
+  int OutIdx = Edge1.OutIdx;
+  Edge1.OutIdx = Edge2.OutIdx;
+  Edge2.OutIdx = OutIdx;
+}
+//------------------------------------------------------------------------------
+
+inline cInt TopX(TEdge &edge, const cInt currentY) noexcept {
+  return (currentY == edge.Top.Y)
+             ? edge.Top.X
+             : edge.Bot.X + Round(edge.Dx * (currentY - edge.Bot.Y));
+}
+//------------------------------------------------------------------------------
+
+void IntersectPoint(TEdge &Edge1, TEdge &Edge2, IntPoint &ip) noexcept {
+#ifdef use_xyz
+  ip.Z = 0;
+#endif
+
+  double b1, b2;
+  if (Edge1.Dx == Edge2.Dx) {
+    ip.Y = Edge1.Curr.Y;
+    ip.X = TopX(Edge1, ip.Y);
+    return;
+  } else if (Edge1.Dx == 0) {
+    ip.X = Edge1.Bot.X;
+    if (IsHorizontal(Edge2))
+      ip.Y = Edge2.Bot.Y;
+    else {
+      b2 = Edge2.Bot.Y - (Edge2.Bot.X / Edge2.Dx);
+      ip.Y = Round(ip.X / Edge2.Dx + b2);
+    }
+  } else if (Edge2.Dx == 0) {
+    ip.X = Edge2.Bot.X;
+    if (IsHorizontal(Edge1))
+      ip.Y = Edge1.Bot.Y;
+    else {
+      b1 = Edge1.Bot.Y - (Edge1.Bot.X / Edge1.Dx);
+      ip.Y = Round(ip.X / Edge1.Dx + b1);
+    }
+  } else {
+    b1 = Edge1.Bot.X - Edge1.Bot.Y * Edge1.Dx;
+    b2 = Edge2.Bot.X - Edge2.Bot.Y * Edge2.Dx;
+    double q = (b2 - b1) / (Edge1.Dx - Edge2.Dx);
+    ip.Y = Round(q);
+    if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx))
+      ip.X = Round(Edge1.Dx * q + b1);
+    else
+      ip.X = Round(Edge2.Dx * q + b2);
+  }
+
+  if (ip.Y < Edge1.Top.Y || ip.Y < Edge2.Top.Y) {
+    if (Edge1.Top.Y > Edge2.Top.Y)
+      ip.Y = Edge1.Top.Y;
+    else
+      ip.Y = Edge2.Top.Y;
+    if (std::fabs(Edge1.Dx) < std::fabs(Edge2.Dx))
+      ip.X = TopX(Edge1, ip.Y);
+    else
+      ip.X = TopX(Edge2, ip.Y);
+  }
+  // finally, don't allow 'ip' to be BELOW curr.Y (ie bottom of scanbeam) ...
+  if (ip.Y > Edge1.Curr.Y) {
+    ip.Y = Edge1.Curr.Y;
+    // use the more vertical edge to derive X ...
+    if (std::fabs(Edge1.Dx) > std::fabs(Edge2.Dx))
+      ip.X = TopX(Edge2, ip.Y);
+    else
+      ip.X = TopX(Edge1, ip.Y);
+  }
+}
+//------------------------------------------------------------------------------
+
+void ReversePolyPtLinks(OutPt *pp) noexcept {
+  if (!pp)
+    return;
+  OutPt *pp1, *pp2;
+  pp1 = pp;
+  do {
+    pp2 = pp1->Next;
+    pp1->Next = pp1->Prev;
+    pp1->Prev = pp2;
+    pp1 = pp2;
+  } while (pp1 != pp);
+}
+//------------------------------------------------------------------------------
+
+void DisposeOutPts(OutPt *&pp) noexcept {
+  if (pp == 0)
+    return;
+  pp->Prev->Next = 0;
+  while (pp) {
+    OutPt *tmpPp = pp;
+    pp = pp->Next;
+    delete tmpPp;
+  }
+}
+//------------------------------------------------------------------------------
+
+inline void InitEdge(TEdge *e, TEdge *eNext, TEdge *ePrev,
+                     const IntPoint &Pt) noexcept {
+  std::memset(e, int(0), sizeof(TEdge));
+  e->Next = eNext;
+  e->Prev = ePrev;
+  e->Curr = Pt;
+  e->OutIdx = Unassigned;
+}
+//------------------------------------------------------------------------------
+
+void InitEdge2(TEdge &e, PolyType Pt) noexcept {
+  if (e.Curr.Y >= e.Next->Curr.Y) {
+    e.Bot = e.Curr;
+    e.Top = e.Next->Curr;
+  } else {
+    e.Top = e.Curr;
+    e.Bot = e.Next->Curr;
+  }
+  SetDx(e);
+  e.PolyTyp = Pt;
+}
+//------------------------------------------------------------------------------
+
+TEdge *RemoveEdge(TEdge *e) noexcept {
+  // removes e from double_linked_list (but without removing from memory)
+  e->Prev->Next = e->Next;
+  e->Next->Prev = e->Prev;
+  TEdge *result = e->Next;
+  e->Prev = 0; // flag as removed (see ClipperBase.Clear)
+  return result;
+}
+//------------------------------------------------------------------------------
+
+inline void ReverseHorizontal(TEdge &e) noexcept {
+  // swap horizontal edges' Top and Bottom x's so they follow the natural
+  // progression of the bounds - ie so their xbots will align with the
+  // adjoining lower edge. [Helpful in the ProcessHorizontal() method.]
+  std::swap(e.Top.X, e.Bot.X);
+#ifdef use_xyz
+  std::swap(e.Top.Z, e.Bot.Z);
+#endif
+}
+//------------------------------------------------------------------------------
+
+void SwapPoints(IntPoint &pt1, IntPoint &pt2) noexcept {
+  IntPoint tmp = pt1;
+  pt1 = pt2;
+  pt2 = tmp;
+}
+//------------------------------------------------------------------------------
+
+bool GetOverlapSegment(IntPoint pt1a, IntPoint pt1b, IntPoint pt2a,
+                       IntPoint pt2b, IntPoint &pt1, IntPoint &pt2) noexcept {
+  // precondition: segments are Collinear.
+  if (Abs(pt1a.X - pt1b.X) > Abs(pt1a.Y - pt1b.Y)) {
+    if (pt1a.X > pt1b.X)
+      SwapPoints(pt1a, pt1b);
+    if (pt2a.X > pt2b.X)
+      SwapPoints(pt2a, pt2b);
+    if (pt1a.X > pt2a.X)
+      pt1 = pt1a;
+    else
+      pt1 = pt2a;
+    if (pt1b.X < pt2b.X)
+      pt2 = pt1b;
+    else
+      pt2 = pt2b;
+    return pt1.X < pt2.X;
+  } else {
+    if (pt1a.Y < pt1b.Y)
+      SwapPoints(pt1a, pt1b);
+    if (pt2a.Y < pt2b.Y)
+      SwapPoints(pt2a, pt2b);
+    if (pt1a.Y < pt2a.Y)
+      pt1 = pt1a;
+    else
+      pt1 = pt2a;
+    if (pt1b.Y > pt2b.Y)
+      pt2 = pt1b;
+    else
+      pt2 = pt2b;
+    return pt1.Y > pt2.Y;
+  }
+}
+//------------------------------------------------------------------------------
+
+bool FirstIsBottomPt(const OutPt *btmPt1, const OutPt *btmPt2) noexcept {
+  OutPt *p = btmPt1->Prev;
+  while ((p->Pt == btmPt1->Pt) && (p != btmPt1))
+    p = p->Prev;
+  double dx1p = std::fabs(GetDx(btmPt1->Pt, p->Pt));
+  p = btmPt1->Next;
+  while ((p->Pt == btmPt1->Pt) && (p != btmPt1))
+    p = p->Next;
+  double dx1n = std::fabs(GetDx(btmPt1->Pt, p->Pt));
+
+  p = btmPt2->Prev;
+  while ((p->Pt == btmPt2->Pt) && (p != btmPt2))
+    p = p->Prev;
+  double dx2p = std::fabs(GetDx(btmPt2->Pt, p->Pt));
+  p = btmPt2->Next;
+  while ((p->Pt == btmPt2->Pt) && (p != btmPt2))
+    p = p->Next;
+  double dx2n = std::fabs(GetDx(btmPt2->Pt, p->Pt));
+
+  if (std::max(dx1p, dx1n) == std::max(dx2p, dx2n) &&
+      std::min(dx1p, dx1n) == std::min(dx2p, dx2n))
+    return Area(btmPt1) > 0; // if otherwise identical use orientation
+  else
+    return (dx1p >= dx2p && dx1p >= dx2n) || (dx1n >= dx2p && dx1n >= dx2n);
+}
+//------------------------------------------------------------------------------
+
+OutPt *GetBottomPt(OutPt *pp) noexcept {
+  OutPt *dups = 0;
+  OutPt *p = pp->Next;
+  while (p != pp) {
+    if (p->Pt.Y > pp->Pt.Y) {
+      pp = p;
+      dups = 0;
+    } else if (p->Pt.Y == pp->Pt.Y && p->Pt.X <= pp->Pt.X) {
+      if (p->Pt.X < pp->Pt.X) {
+        dups = 0;
+        pp = p;
+      } else {
+        if (p->Next != pp && p->Prev != pp)
+          dups = p;
+      }
+    }
+    p = p->Next;
+  }
+  if (dups) {
+    // there appears to be at least 2 vertices at BottomPt so ...
+    while (dups != p) {
+      if (!FirstIsBottomPt(p, dups))
+        pp = dups;
+      dups = dups->Next;
+      while (dups->Pt != pp->Pt)
+        dups = dups->Next;
+    }
+  }
+  return pp;
+}
+//------------------------------------------------------------------------------
+
+bool Pt2IsBetweenPt1AndPt3(const IntPoint pt1, const IntPoint pt2,
+                           const IntPoint pt3) noexcept {
+  if ((pt1 == pt3) || (pt1 == pt2) || (pt3 == pt2))
+    return false;
+  else if (pt1.X != pt3.X)
+    return (pt2.X > pt1.X) == (pt2.X < pt3.X);
+  else
+    return (pt2.Y > pt1.Y) == (pt2.Y < pt3.Y);
+}
+//------------------------------------------------------------------------------
+
+bool HorzSegmentsOverlap(cInt seg1a, cInt seg1b, cInt seg2a,
+                         cInt seg2b) noexcept {
+  if (seg1a > seg1b)
+    std::swap(seg1a, seg1b);
+  if (seg2a > seg2b)
+    std::swap(seg2a, seg2b);
+  return (seg1a < seg2b) && (seg2a < seg1b);
+}
+
+//------------------------------------------------------------------------------
+// ClipperBase class methods ...
+//------------------------------------------------------------------------------
+
+ClipperBase::ClipperBase() noexcept // constructor
+{
+  m_CurrentLM = m_MinimaList.begin(); // begin() == end() here
+  m_UseFullRange = false;
+}
+//------------------------------------------------------------------------------
+
+ClipperBase::~ClipperBase() // destructor
+{
+  Clear();
+}
+//------------------------------------------------------------------------------
+
+void RangeTest(const IntPoint &Pt, bool &useFullRange) {
+  if (useFullRange) {
+    if (Pt.X > hiRange || Pt.Y > hiRange || -Pt.X > hiRange || -Pt.Y > hiRange)
+      throw clipperException("Coordinate outside allowed range");
+  } else if (Pt.X > loRange || Pt.Y > loRange || -Pt.X > loRange ||
+             -Pt.Y > loRange) {
+    useFullRange = true;
+    RangeTest(Pt, useFullRange);
+  }
+}
+//------------------------------------------------------------------------------
+
+TEdge *FindNextLocMin(TEdge *E) noexcept {
+  for (;;) {
+    while (E->Bot != E->Prev->Bot || E->Curr == E->Top)
+      E = E->Next;
+    if (!IsHorizontal(*E) && !IsHorizontal(*E->Prev))
+      break;
+    while (IsHorizontal(*E->Prev))
+      E = E->Prev;
+    TEdge *E2 = E;
+    while (IsHorizontal(*E))
+      E = E->Next;
+    if (E->Top.Y == E->Prev->Bot.Y)
+      continue; // ie just an intermediate horz.
+    if (E2->Prev->Bot.X < E->Bot.X)
+      E = E2;
+    break;
+  }
+  return E;
+}
+//------------------------------------------------------------------------------
+
+TEdge *ClipperBase::ProcessBound(TEdge *E, bool NextIsForward) noexcept {
+  TEdge *Result = E;
+  TEdge *Horz = 0;
+
+  if (E->OutIdx == Skip) {
+    // if edges still remain in the current bound beyond the skip edge then
+    // create another LocMin and call ProcessBound once more
+    if (NextIsForward) {
+      while (E->Top.Y == E->Next->Bot.Y)
+        E = E->Next;
+      // don't include top horizontals when parsing a bound a second time,
+      // they will be contained in the opposite bound ...
+      while (E != Result && IsHorizontal(*E))
+        E = E->Prev;
+    } else {
+      while (E->Top.Y == E->Prev->Bot.Y)
+        E = E->Prev;
+      while (E != Result && IsHorizontal(*E))
+        E = E->Next;
+    }
+
+    if (E == Result) {
+      if (NextIsForward)
+        Result = E->Next;
+      else
+        Result = E->Prev;
+    } else {
+      // there are more edges in the bound beyond result starting with E
+      if (NextIsForward)
+        E = Result->Next;
+      else
+        E = Result->Prev;
+      MinimaList::value_type locMin;
+      locMin.Y = E->Bot.Y;
+      locMin.LeftBound = 0;
+      locMin.RightBound = E;
+      E->WindDelta = 0;
+      Result = ProcessBound(E, NextIsForward);
+      m_MinimaList.emplace_back(std::move(locMin));
+    }
+    return Result;
+  }
+
+  TEdge *EStart;
+
+  if (IsHorizontal(*E)) {
+    // We need to be careful with open paths because this may not be a
+    // true local minima (ie E may be following a skip edge).
+    // Also, consecutive horz. edges may start heading left before going right.
+    if (NextIsForward)
+      EStart = E->Prev;
+    else
+      EStart = E->Next;
+    if (IsHorizontal(*EStart)) // ie an adjoining horizontal skip edge
+    {
+      if (EStart->Bot.X != E->Bot.X && EStart->Top.X != E->Bot.X)
+        ReverseHorizontal(*E);
+    } else if (EStart->Bot.X != E->Bot.X)
+      ReverseHorizontal(*E);
+  }
+
+  EStart = E;
+  if (NextIsForward) {
+    while (Result->Top.Y == Result->Next->Bot.Y && Result->Next->OutIdx != Skip)
+      Result = Result->Next;
+    if (IsHorizontal(*Result) && Result->Next->OutIdx != Skip) {
+      // nb: at the top of a bound, horizontals are added to the bound
+      // only when the preceding edge attaches to the horizontal's left vertex
+      // unless a Skip edge is encountered when that becomes the top divide
+      Horz = Result;
+      while (IsHorizontal(*Horz->Prev))
+        Horz = Horz->Prev;
+      if (Horz->Prev->Top.X > Result->Next->Top.X)
+        Result = Horz->Prev;
+    }
+    while (E != Result) {
+      E->NextInLML = E->Next;
+      if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X)
+        ReverseHorizontal(*E);
+      E = E->Next;
+    }
+    if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Prev->Top.X)
+      ReverseHorizontal(*E);
+    Result = Result->Next; // move to the edge just beyond current bound
+  } else {
+    while (Result->Top.Y == Result->Prev->Bot.Y && Result->Prev->OutIdx != Skip)
+      Result = Result->Prev;
+    if (IsHorizontal(*Result) && Result->Prev->OutIdx != Skip) {
+      Horz = Result;
+      while (IsHorizontal(*Horz->Next))
+        Horz = Horz->Next;
+      if (Horz->Next->Top.X == Result->Prev->Top.X ||
+          Horz->Next->Top.X > Result->Prev->Top.X)
+        Result = Horz->Next;
+    }
+
+    while (E != Result) {
+      E->NextInLML = E->Prev;
+      if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X)
+        ReverseHorizontal(*E);
+      E = E->Prev;
+    }
+    if (IsHorizontal(*E) && E != EStart && E->Bot.X != E->Next->Top.X)
+      ReverseHorizontal(*E);
+    Result = Result->Prev; // move to the edge just beyond current bound
+  }
+
+  return Result;
+}
+//------------------------------------------------------------------------------
+
+bool ClipperBase::AddPath(const Path &pg, PolyType PolyTyp, bool Closed) {
+#ifdef use_lines
+  if (!Closed && PolyTyp == ptClip)
+    throw clipperException("AddPath: Open paths must be subject.");
+#else
+  if (!Closed)
+    throw clipperException("AddPath: Open paths have been disabled.");
+#endif
+
+  int highI = (int)pg.size() - 1;
+  if (Closed)
+    while (highI > 0 && (pg[highI] == pg[0]))
+      --highI;
+  while (highI > 0 && (pg[highI] == pg[highI - 1]))
+    --highI;
+  if ((Closed && highI < 2) || (!Closed && highI < 1))
+    return false;
+
+  // create a new edge array ...
+  TEdge *edges = new TEdge[highI + 1];
+
+  bool IsFlat = true;
+  // 1. Basic (first) edge initialization ...
+  try {
+    edges[1].Curr = pg[1];
+    RangeTest(pg[0], m_UseFullRange);
+    RangeTest(pg[highI], m_UseFullRange);
+    InitEdge(&edges[0], &edges[1], &edges[highI], pg[0]);
+    InitEdge(&edges[highI], &edges[0], &edges[highI - 1], pg[highI]);
+    for (int i = highI - 1; i >= 1; --i) {
+      RangeTest(pg[i], m_UseFullRange);
+      InitEdge(&edges[i], &edges[i + 1], &edges[i - 1], pg[i]);
+    }
+  } catch (...) {
+    delete[] edges;
+    throw; // range test fails
+  }
+  TEdge *eStart = &edges[0];
+
+  // 2. Remove duplicate vertices, and (when closed) collinear edges ...
+  TEdge *E = eStart, *eLoopStop = eStart;
+  for (;;) {
+    // nb: allows matching start and end points when not Closed ...
+    if (E->Curr == E->Next->Curr && (Closed || E->Next != eStart)) {
+      if (E == E->Next)
+        break;
+      if (E == eStart)
+        eStart = E->Next;
+      E = RemoveEdge(E);
+      eLoopStop = E;
+      continue;
+    }
+    if (E->Prev == E->Next)
+      break; // only two vertices
+    else if (Closed &&
+             SlopesEqual(E->Prev->Curr, E->Curr, E->Next->Curr,
+                         m_UseFullRange) &&
+             (!m_PreserveCollinear ||
+              !Pt2IsBetweenPt1AndPt3(E->Prev->Curr, E->Curr, E->Next->Curr))) {
+      // Collinear edges are allowed for open paths but in closed paths
+      // the default is to merge adjacent collinear edges into a single edge.
+      // However, if the PreserveCollinear property is enabled, only overlapping
+      // collinear edges (ie spikes) will be removed from closed paths.
+      if (E == eStart)
+        eStart = E->Next;
+      E = RemoveEdge(E);
+      E = E->Prev;
+      eLoopStop = E;
+      continue;
+    }
+    E = E->Next;
+    if ((E == eLoopStop) || (!Closed && E->Next == eStart))
+      break;
+  }
+
+  if ((!Closed && (E == E->Next)) || (Closed && (E->Prev == E->Next))) {
+    delete[] edges;
+    return false;
+  }
+
+  if (!Closed) {
+    m_HasOpenPaths = true;
+    eStart->Prev->OutIdx = Skip;
+  }
+
+  // 3. Do second stage of edge initialization ...
+  E = eStart;
+  do {
+    InitEdge2(*E, PolyTyp);
+    E = E->Next;
+    if (IsFlat && E->Curr.Y != eStart->Curr.Y)
+      IsFlat = false;
+  } while (E != eStart);
+
+  // 4. Finally, add edge bounds to LocalMinima list ...
+
+  // Totally flat paths must be handled differently when adding them
+  // to LocalMinima list to avoid endless loops etc ...
+  if (IsFlat) {
+    if (Closed) {
+      delete[] edges;
+      return false;
+    }
+    E->Prev->OutIdx = Skip;
+    MinimaList::value_type locMin;
+    locMin.Y = E->Bot.Y;
+    locMin.LeftBound = 0;
+    locMin.RightBound = E;
+    locMin.RightBound->Side = esRight;
+    locMin.RightBound->WindDelta = 0;
+    for (;;) {
+      if (E->Bot.X != E->Prev->Top.X)
+        ReverseHorizontal(*E);
+      if (E->Next->OutIdx == Skip)
+        break;
+      E->NextInLML = E->Next;
+      E = E->Next;
+    }
+    m_MinimaList.emplace_back(std::move(locMin));
+    m_edges.emplace_back(edges);
+    return true;
+  }
+
+  m_edges.emplace_back(edges);
+  bool leftBoundIsForward;
+  TEdge *EMin = 0;
+
+  // workaround to avoid an endless loop in the while loop below when
+  // open paths have matching start and end points ...
+  if (E->Prev->Bot == E->Prev->Top)
+    E = E->Next;
+
+  for (;;) {
+    E = FindNextLocMin(E);
+    if (E == EMin)
+      break;
+    else if (!EMin)
+      EMin = E;
+
+    // E and E.Prev now share a local minima (left aligned if horizontal).
+    // Compare their slopes to find which starts which bound ...
+    MinimaList::value_type locMin;
+    locMin.Y = E->Bot.Y;
+    if (E->Dx < E->Prev->Dx) {
+      locMin.LeftBound = E->Prev;
+      locMin.RightBound = E;
+      leftBoundIsForward = false; // Q.nextInLML = Q.prev
+    } else {
+      locMin.LeftBound = E;
+      locMin.RightBound = E->Prev;
+      leftBoundIsForward = true; // Q.nextInLML = Q.next
+    }
+
+    if (!Closed)
+      locMin.LeftBound->WindDelta = 0;
+    else if (locMin.LeftBound->Next == locMin.RightBound)
+      locMin.LeftBound->WindDelta = -1;
+    else
+      locMin.LeftBound->WindDelta = 1;
+    locMin.RightBound->WindDelta = -locMin.LeftBound->WindDelta;
+
+    E = ProcessBound(locMin.LeftBound, leftBoundIsForward);
+    if (E->OutIdx == Skip)
+      E = ProcessBound(E, leftBoundIsForward);
+
+    TEdge *E2 = ProcessBound(locMin.RightBound, !leftBoundIsForward);
+    if (E2->OutIdx == Skip)
+      E2 = ProcessBound(E2, !leftBoundIsForward);
+
+    if (locMin.LeftBound->OutIdx == Skip)
+      locMin.LeftBound = 0;
+    else if (locMin.RightBound->OutIdx == Skip)
+      locMin.RightBound = 0;
+    m_MinimaList.emplace_back(std::move(locMin));
+    if (!leftBoundIsForward)
+      E = E2;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+
+bool ClipperBase::AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed) {
+  bool result = false;
+  for (Paths::size_type i = 0; i < ppg.size(); ++i)
+    if (AddPath(ppg[i], PolyTyp, Closed))
+      result = true;
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::Clear() noexcept {
+  DisposeLocalMinimaList();
+  for (EdgeList::size_type i = 0; i < m_edges.size(); ++i) {
+    TEdge *edges = m_edges[i];
+    delete[] edges;
+  }
+  m_edges.clear();
+  m_UseFullRange = false;
+  m_HasOpenPaths = false;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::Reset() noexcept {
+  m_CurrentLM = m_MinimaList.begin();
+  if (m_CurrentLM == m_MinimaList.end())
+    return; // ie nothing to process
+  std::sort(m_MinimaList.begin(), m_MinimaList.end(), LocMinSorter());
+
+  m_Scanbeam = ScanbeamList(); // clears/resets priority_queue
+  // reset all edges ...
+  for (MinimaList::iterator lm = m_MinimaList.begin(); lm != m_MinimaList.end();
+       ++lm) {
+    InsertScanbeam(lm->Y);
+    TEdge *e = lm->LeftBound;
+    if (e) {
+      e->Curr = e->Bot;
+      e->Side = esLeft;
+      e->OutIdx = Unassigned;
+    }
+
+    e = lm->RightBound;
+    if (e) {
+      e->Curr = e->Bot;
+      e->Side = esRight;
+      e->OutIdx = Unassigned;
+    }
+  }
+  m_ActiveEdges = 0;
+  m_CurrentLM = m_MinimaList.begin();
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::DisposeLocalMinimaList() noexcept {
+  m_MinimaList.clear();
+  m_CurrentLM = m_MinimaList.begin();
+}
+//------------------------------------------------------------------------------
+
+bool ClipperBase::PopLocalMinima(cInt Y, const LocalMinimum *&locMin) noexcept {
+  if (m_CurrentLM == m_MinimaList.end() || (*m_CurrentLM).Y != Y)
+    return false;
+  locMin = &(*m_CurrentLM);
+  ++m_CurrentLM;
+  return true;
+}
+//------------------------------------------------------------------------------
+
+IntRect ClipperBase::GetBounds() noexcept {
+  IntRect result;
+  MinimaList::iterator lm = m_MinimaList.begin();
+  if (lm == m_MinimaList.end()) {
+    result.left = result.top = result.right = result.bottom = 0;
+    return result;
+  }
+  result.left = lm->LeftBound->Bot.X;
+  result.top = lm->LeftBound->Bot.Y;
+  result.right = lm->LeftBound->Bot.X;
+  result.bottom = lm->LeftBound->Bot.Y;
+  while (lm != m_MinimaList.end()) {
+    // todo - needs fixing for open paths
+    result.bottom = std::max(result.bottom, lm->LeftBound->Bot.Y);
+    TEdge *e = lm->LeftBound;
+    for (;;) {
+      TEdge *bottomE = e;
+      while (e->NextInLML) {
+        if (e->Bot.X < result.left)
+          result.left = e->Bot.X;
+        if (e->Bot.X > result.right)
+          result.right = e->Bot.X;
+        e = e->NextInLML;
+      }
+      result.left = std::min(result.left, e->Bot.X);
+      result.right = std::max(result.right, e->Bot.X);
+      result.left = std::min(result.left, e->Top.X);
+      result.right = std::max(result.right, e->Top.X);
+      result.top = std::min(result.top, e->Top.Y);
+      if (bottomE == lm->LeftBound)
+        e = lm->RightBound;
+      else
+        break;
+    }
+    ++lm;
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::InsertScanbeam(const cInt Y) noexcept { m_Scanbeam.push(Y); }
+//------------------------------------------------------------------------------
+
+bool ClipperBase::PopScanbeam(cInt &Y) noexcept {
+  if (m_Scanbeam.empty())
+    return false;
+  Y = m_Scanbeam.top();
+  m_Scanbeam.pop();
+  while (!m_Scanbeam.empty() && Y == m_Scanbeam.top()) {
+    m_Scanbeam.pop();
+  } // Pop duplicates.
+  return true;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::DisposeAllOutRecs() noexcept {
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i)
+    DisposeOutRec(i);
+  m_PolyOuts.clear();
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::DisposeOutRec(PolyOutList::size_type index) noexcept {
+  OutRec *outRec = m_PolyOuts[index];
+  if (outRec->Pts)
+    DisposeOutPts(outRec->Pts);
+  delete outRec;
+  m_PolyOuts[index] = 0;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::DeleteFromAEL(TEdge *e) noexcept {
+  TEdge *AelPrev = e->PrevInAEL;
+  TEdge *AelNext = e->NextInAEL;
+  if (!AelPrev && !AelNext && (e != m_ActiveEdges))
+    return; // already deleted
+  if (AelPrev)
+    AelPrev->NextInAEL = AelNext;
+  else
+    m_ActiveEdges = AelNext;
+  if (AelNext)
+    AelNext->PrevInAEL = AelPrev;
+  e->NextInAEL = 0;
+  e->PrevInAEL = 0;
+}
+//------------------------------------------------------------------------------
+
+OutRec *ClipperBase::CreateOutRec() noexcept {
+  OutRec *result = new OutRec;
+  result->IsHole = false;
+  result->IsOpen = false;
+  result->FirstLeft = 0;
+  result->Pts = 0;
+  result->BottomPt = 0;
+  result->PolyNd = 0;
+  m_PolyOuts.emplace_back(result);
+  result->Idx = (int)m_PolyOuts.size() - 1;
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::SwapPositionsInAEL(TEdge *Edge1, TEdge *Edge2) noexcept {
+  // check that one or other edge hasn't already been removed from AEL ...
+  if (Edge1->NextInAEL == Edge1->PrevInAEL ||
+      Edge2->NextInAEL == Edge2->PrevInAEL)
+    return;
+
+  if (Edge1->NextInAEL == Edge2) {
+    TEdge *Next = Edge2->NextInAEL;
+    if (Next)
+      Next->PrevInAEL = Edge1;
+    TEdge *Prev = Edge1->PrevInAEL;
+    if (Prev)
+      Prev->NextInAEL = Edge2;
+    Edge2->PrevInAEL = Prev;
+    Edge2->NextInAEL = Edge1;
+    Edge1->PrevInAEL = Edge2;
+    Edge1->NextInAEL = Next;
+  } else if (Edge2->NextInAEL == Edge1) {
+    TEdge *Next = Edge1->NextInAEL;
+    if (Next)
+      Next->PrevInAEL = Edge2;
+    TEdge *Prev = Edge2->PrevInAEL;
+    if (Prev)
+      Prev->NextInAEL = Edge1;
+    Edge1->PrevInAEL = Prev;
+    Edge1->NextInAEL = Edge2;
+    Edge2->PrevInAEL = Edge1;
+    Edge2->NextInAEL = Next;
+  } else {
+    TEdge *Next = Edge1->NextInAEL;
+    TEdge *Prev = Edge1->PrevInAEL;
+    Edge1->NextInAEL = Edge2->NextInAEL;
+    if (Edge1->NextInAEL)
+      Edge1->NextInAEL->PrevInAEL = Edge1;
+    Edge1->PrevInAEL = Edge2->PrevInAEL;
+    if (Edge1->PrevInAEL)
+      Edge1->PrevInAEL->NextInAEL = Edge1;
+    Edge2->NextInAEL = Next;
+    if (Edge2->NextInAEL)
+      Edge2->NextInAEL->PrevInAEL = Edge2;
+    Edge2->PrevInAEL = Prev;
+    if (Edge2->PrevInAEL)
+      Edge2->PrevInAEL->NextInAEL = Edge2;
+  }
+
+  if (!Edge1->PrevInAEL)
+    m_ActiveEdges = Edge1;
+  else if (!Edge2->PrevInAEL)
+    m_ActiveEdges = Edge2;
+}
+//------------------------------------------------------------------------------
+
+void ClipperBase::UpdateEdgeIntoAEL(TEdge *&e) {
+  if (!e->NextInLML)
+    throw clipperException("UpdateEdgeIntoAEL: invalid call");
+
+  e->NextInLML->OutIdx = e->OutIdx;
+  TEdge *AelPrev = e->PrevInAEL;
+  TEdge *AelNext = e->NextInAEL;
+  if (AelPrev)
+    AelPrev->NextInAEL = e->NextInLML;
+  else
+    m_ActiveEdges = e->NextInLML;
+  if (AelNext)
+    AelNext->PrevInAEL = e->NextInLML;
+  e->NextInLML->Side = e->Side;
+  e->NextInLML->WindDelta = e->WindDelta;
+  e->NextInLML->WindCnt = e->WindCnt;
+  e->NextInLML->WindCnt2 = e->WindCnt2;
+  e = e->NextInLML;
+  e->Curr = e->Bot;
+  e->PrevInAEL = AelPrev;
+  e->NextInAEL = AelNext;
+  if (!IsHorizontal(*e))
+    InsertScanbeam(e->Top.Y);
+}
+//------------------------------------------------------------------------------
+
+bool ClipperBase::LocalMinimaPending() noexcept {
+  return (m_CurrentLM != m_MinimaList.end());
+}
+
+//------------------------------------------------------------------------------
+// TClipper methods ...
+//------------------------------------------------------------------------------
+
+Clipper::Clipper(int initOptions) noexcept
+    : ClipperBase() // constructor
+{
+  m_ExecuteLocked = false;
+  m_UseFullRange = false;
+  m_ReverseOutput = ((initOptions & ioReverseSolution) != 0);
+  m_StrictSimple = ((initOptions & ioStrictlySimple) != 0);
+  m_PreserveCollinear = ((initOptions & ioPreserveCollinear) != 0);
+  m_HasOpenPaths = false;
+#ifdef use_xyz
+  m_ZFill = 0;
+#endif
+}
+//------------------------------------------------------------------------------
+
+#ifdef use_xyz
+void Clipper::ZFillFunction(ZFillCallback zFillFunc) noexcept {
+  m_ZFill = zFillFunc;
+}
+//------------------------------------------------------------------------------
+#endif
+
+bool Clipper::Execute(ClipType clipType, Paths &solution,
+                      PolyFillType fillType) {
+  return Execute(clipType, solution, fillType, fillType);
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::Execute(ClipType clipType, PolyTree &polytree,
+                      PolyFillType fillType) noexcept {
+  return Execute(clipType, polytree, fillType, fillType);
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::Execute(ClipType clipType, Paths &solution,
+                      PolyFillType subjFillType, PolyFillType clipFillType) {
+  if (m_ExecuteLocked)
+    return false;
+  if (m_HasOpenPaths)
+    throw clipperException(
+        "Error: PolyTree struct is needed for open path clipping.");
+  m_ExecuteLocked = true;
+  solution.resize(0);
+  m_SubjFillType = subjFillType;
+  m_ClipFillType = clipFillType;
+  m_ClipType = clipType;
+  m_UsingPolyTree = false;
+  bool succeeded = ExecuteInternal();
+  if (succeeded)
+    BuildResult(solution);
+  DisposeAllOutRecs();
+  m_ExecuteLocked = false;
+  return succeeded;
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::Execute(ClipType clipType, PolyTree &polytree,
+                      PolyFillType subjFillType,
+                      PolyFillType clipFillType) noexcept {
+  if (m_ExecuteLocked)
+    return false;
+  m_ExecuteLocked = true;
+  m_SubjFillType = subjFillType;
+  m_ClipFillType = clipFillType;
+  m_ClipType = clipType;
+  m_UsingPolyTree = true;
+  bool succeeded = ExecuteInternal();
+  if (succeeded)
+    BuildResult2(polytree);
+  DisposeAllOutRecs();
+  m_ExecuteLocked = false;
+  return succeeded;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::FixHoleLinkage(OutRec &outrec) noexcept {
+  // skip OutRecs that (a) contain outermost polygons or
+  //(b) already have the correct owner/child linkage ...
+  if (!outrec.FirstLeft ||
+      (outrec.IsHole != outrec.FirstLeft->IsHole && outrec.FirstLeft->Pts))
+    return;
+
+  OutRec *orfl = outrec.FirstLeft;
+  while (orfl && ((orfl->IsHole == outrec.IsHole) || !orfl->Pts))
+    orfl = orfl->FirstLeft;
+  outrec.FirstLeft = orfl;
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::ExecuteInternal() noexcept {
+  bool succeeded = true;
+  try {
+    Reset();
+    m_Maxima = MaximaList();
+    m_SortedEdges = 0;
+
+    succeeded = true;
+    cInt botY, topY;
+    if (!PopScanbeam(botY))
+      return false;
+    InsertLocalMinimaIntoAEL(botY);
+    while (PopScanbeam(topY) || LocalMinimaPending()) {
+      ProcessHorizontals();
+      ClearGhostJoins();
+      if (!ProcessIntersections(topY)) {
+        succeeded = false;
+        break;
+      }
+      ProcessEdgesAtTopOfScanbeam(topY);
+      botY = topY;
+      InsertLocalMinimaIntoAEL(botY);
+    }
+  } catch (...) {
+    succeeded = false;
+  }
+
+  if (succeeded) {
+    // fix orientations ...
+    for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+      OutRec *outRec = m_PolyOuts[i];
+      if (!outRec->Pts || outRec->IsOpen)
+        continue;
+      if ((outRec->IsHole ^ m_ReverseOutput) == (Area(*outRec) > 0))
+        ReversePolyPtLinks(outRec->Pts);
+    }
+
+    if (!m_Joins.empty())
+      JoinCommonEdges();
+
+    // unfortunately FixupOutPolygon() must be done after JoinCommonEdges()
+    for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+      OutRec *outRec = m_PolyOuts[i];
+      if (!outRec->Pts)
+        continue;
+      if (outRec->IsOpen)
+        FixupOutPolyline(*outRec);
+      else
+        FixupOutPolygon(*outRec);
+    }
+
+    if (m_StrictSimple)
+      DoSimplePolygons();
+  }
+
+  ClearJoins();
+  ClearGhostJoins();
+  return succeeded;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::SetWindingCount(TEdge &edge) noexcept {
+  TEdge *e = edge.PrevInAEL;
+  // find the edge of the same polytype that immediately precedes 'edge' in AEL
+  while (e && ((e->PolyTyp != edge.PolyTyp) || (e->WindDelta == 0)))
+    e = e->PrevInAEL;
+  if (!e) {
+    if (edge.WindDelta == 0) {
+      PolyFillType pft =
+          (edge.PolyTyp == ptSubject ? m_SubjFillType : m_ClipFillType);
+      edge.WindCnt = (pft == pftNegative ? -1 : 1);
+    } else
+      edge.WindCnt = edge.WindDelta;
+    edge.WindCnt2 = 0;
+    e = m_ActiveEdges; // ie get ready to calc WindCnt2
+  } else if (edge.WindDelta == 0 && m_ClipType != ctUnion) {
+    edge.WindCnt = 1;
+    edge.WindCnt2 = e->WindCnt2;
+    e = e->NextInAEL; // ie get ready to calc WindCnt2
+  } else if (IsEvenOddFillType(edge)) {
+    // EvenOdd filling ...
+    if (edge.WindDelta == 0) {
+      // are we inside a subj polygon ...
+      bool Inside = true;
+      TEdge *e2 = e->PrevInAEL;
+      while (e2) {
+        if (e2->PolyTyp == e->PolyTyp && e2->WindDelta != 0)
+          Inside = !Inside;
+        e2 = e2->PrevInAEL;
+      }
+      edge.WindCnt = (Inside ? 0 : 1);
+    } else {
+      edge.WindCnt = edge.WindDelta;
+    }
+    edge.WindCnt2 = e->WindCnt2;
+    e = e->NextInAEL; // ie get ready to calc WindCnt2
+  } else {
+    // nonZero, Positive or Negative filling ...
+    if (e->WindCnt * e->WindDelta < 0) {
+      // prev edge is 'decreasing' WindCount (WC) toward zero
+      // so we're outside the previous polygon ...
+      if (Abs(e->WindCnt) > 1) {
+        // outside prev poly but still inside another.
+        // when reversing direction of prev poly use the same WC
+        if (e->WindDelta * edge.WindDelta < 0)
+          edge.WindCnt = e->WindCnt;
+        // otherwise continue to 'decrease' WC ...
+        else
+          edge.WindCnt = e->WindCnt + edge.WindDelta;
+      } else
+        // now outside all polys of same polytype so set own WC ...
+        edge.WindCnt = (edge.WindDelta == 0 ? 1 : edge.WindDelta);
+    } else {
+      // prev edge is 'increasing' WindCount (WC) away from zero
+      // so we're inside the previous polygon ...
+      if (edge.WindDelta == 0)
+        edge.WindCnt = (e->WindCnt < 0 ? e->WindCnt - 1 : e->WindCnt + 1);
+      // if wind direction is reversing prev then use same WC
+      else if (e->WindDelta * edge.WindDelta < 0)
+        edge.WindCnt = e->WindCnt;
+      // otherwise add to WC ...
+      else
+        edge.WindCnt = e->WindCnt + edge.WindDelta;
+    }
+    edge.WindCnt2 = e->WindCnt2;
+    e = e->NextInAEL; // ie get ready to calc WindCnt2
+  }
+
+  // update WindCnt2 ...
+  if (IsEvenOddAltFillType(edge)) {
+    // EvenOdd filling ...
+    while (e != &edge) {
+      if (e->WindDelta != 0)
+        edge.WindCnt2 = (edge.WindCnt2 == 0 ? 1 : 0);
+      e = e->NextInAEL;
+    }
+  } else {
+    // nonZero, Positive or Negative filling ...
+    while (e != &edge) {
+      edge.WindCnt2 += e->WindDelta;
+      e = e->NextInAEL;
+    }
+  }
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::IsEvenOddFillType(const TEdge &edge) const noexcept {
+  if (edge.PolyTyp == ptSubject)
+    return m_SubjFillType == pftEvenOdd;
+  else
+    return m_ClipFillType == pftEvenOdd;
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::IsEvenOddAltFillType(const TEdge &edge) const noexcept {
+  if (edge.PolyTyp == ptSubject)
+    return m_ClipFillType == pftEvenOdd;
+  else
+    return m_SubjFillType == pftEvenOdd;
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::IsContributing(const TEdge &edge) const noexcept {
+  PolyFillType pft, pft2;
+  if (edge.PolyTyp == ptSubject) {
+    pft = m_SubjFillType;
+    pft2 = m_ClipFillType;
+  } else {
+    pft = m_ClipFillType;
+    pft2 = m_SubjFillType;
+  }
+
+  switch (pft) {
+  case pftEvenOdd:
+    // return false if a subj line has been flagged as inside a subj polygon
+    if (edge.WindDelta == 0 && edge.WindCnt != 1)
+      return false;
+    break;
+  case pftNonZero:
+    if (Abs(edge.WindCnt) != 1)
+      return false;
+    break;
+  case pftPositive:
+    if (edge.WindCnt != 1)
+      return false;
+    break;
+  default: // pftNegative
+    if (edge.WindCnt != -1)
+      return false;
+  }
+
+  switch (m_ClipType) {
+  case ctIntersection:
+    switch (pft2) {
+    case pftEvenOdd:
+    case pftNonZero:
+      return (edge.WindCnt2 != 0);
+    case pftPositive:
+      return (edge.WindCnt2 > 0);
+    default:
+      return (edge.WindCnt2 < 0);
+    }
+    break;
+  case ctUnion:
+    switch (pft2) {
+    case pftEvenOdd:
+    case pftNonZero:
+      return (edge.WindCnt2 == 0);
+    case pftPositive:
+      return (edge.WindCnt2 <= 0);
+    default:
+      return (edge.WindCnt2 >= 0);
+    }
+    break;
+  case ctDifference:
+    if (edge.PolyTyp == ptSubject)
+      switch (pft2) {
+      case pftEvenOdd:
+      case pftNonZero:
+        return (edge.WindCnt2 == 0);
+      case pftPositive:
+        return (edge.WindCnt2 <= 0);
+      default:
+        return (edge.WindCnt2 >= 0);
+      }
+    else
+      switch (pft2) {
+      case pftEvenOdd:
+      case pftNonZero:
+        return (edge.WindCnt2 != 0);
+      case pftPositive:
+        return (edge.WindCnt2 > 0);
+      default:
+        return (edge.WindCnt2 < 0);
+      }
+    break;
+  case ctXor:
+    if (edge.WindDelta == 0) // XOr always contributing unless open
+      switch (pft2) {
+      case pftEvenOdd:
+      case pftNonZero:
+        return (edge.WindCnt2 == 0);
+      case pftPositive:
+        return (edge.WindCnt2 <= 0);
+      default:
+        return (edge.WindCnt2 >= 0);
+      }
+    else
+      return true;
+    break;
+  default:
+    return true;
+  }
+}
+//------------------------------------------------------------------------------
+
+OutPt *Clipper::AddLocalMinPoly(TEdge *e1, TEdge *e2,
+                                const IntPoint &Pt) noexcept {
+  OutPt *result;
+  TEdge *e, *prevE;
+  if (IsHorizontal(*e2) || (e1->Dx > e2->Dx)) {
+    result = AddOutPt(e1, Pt);
+    e2->OutIdx = e1->OutIdx;
+    e1->Side = esLeft;
+    e2->Side = esRight;
+    e = e1;
+    if (e->PrevInAEL == e2)
+      prevE = e2->PrevInAEL;
+    else
+      prevE = e->PrevInAEL;
+  } else {
+    result = AddOutPt(e2, Pt);
+    e1->OutIdx = e2->OutIdx;
+    e1->Side = esRight;
+    e2->Side = esLeft;
+    e = e2;
+    if (e->PrevInAEL == e1)
+      prevE = e1->PrevInAEL;
+    else
+      prevE = e->PrevInAEL;
+  }
+
+  if (prevE && prevE->OutIdx >= 0 && prevE->Top.Y < Pt.Y && e->Top.Y < Pt.Y) {
+    cInt xPrev = TopX(*prevE, Pt.Y);
+    cInt xE = TopX(*e, Pt.Y);
+    if (xPrev == xE && (e->WindDelta != 0) && (prevE->WindDelta != 0) &&
+        SlopesEqual(IntPoint(xPrev, Pt.Y), prevE->Top, IntPoint(xE, Pt.Y),
+                    e->Top, m_UseFullRange)) {
+      OutPt *outPt = AddOutPt(prevE, Pt);
+      AddJoin(result, outPt, e->Top);
+    }
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::AddLocalMaxPoly(TEdge *e1, TEdge *e2,
+                              const IntPoint &Pt) noexcept {
+  AddOutPt(e1, Pt);
+  if (e2->WindDelta == 0)
+    AddOutPt(e2, Pt);
+  if (e1->OutIdx == e2->OutIdx) {
+    e1->OutIdx = Unassigned;
+    e2->OutIdx = Unassigned;
+  } else if (e1->OutIdx < e2->OutIdx)
+    AppendPolygon(e1, e2);
+  else
+    AppendPolygon(e2, e1);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::AddEdgeToSEL(TEdge *edge) noexcept {
+  // SEL pointers in PEdge are reused to build a list of horizontal edges.
+  // However, we don't need to worry about order with horizontal edge
+  // processing.
+  if (!m_SortedEdges) {
+    m_SortedEdges = edge;
+    edge->PrevInSEL = 0;
+    edge->NextInSEL = 0;
+  } else {
+    edge->NextInSEL = m_SortedEdges;
+    edge->PrevInSEL = 0;
+    m_SortedEdges->PrevInSEL = edge;
+    m_SortedEdges = edge;
+  }
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::PopEdgeFromSEL(TEdge *&edge) noexcept {
+  if (!m_SortedEdges)
+    return false;
+  edge = m_SortedEdges;
+  DeleteFromSEL(m_SortedEdges);
+  return true;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::CopyAELToSEL() noexcept {
+  TEdge *e = m_ActiveEdges;
+  m_SortedEdges = e;
+  while (e) {
+    e->PrevInSEL = e->PrevInAEL;
+    e->NextInSEL = e->NextInAEL;
+    e = e->NextInAEL;
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::AddJoin(OutPt *op1, OutPt *op2, const IntPoint OffPt) noexcept {
+  Join *j = new Join;
+  j->OutPt1 = op1;
+  j->OutPt2 = op2;
+  j->OffPt = OffPt;
+  m_Joins.emplace_back(j);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::ClearJoins() noexcept {
+  for (JoinList::size_type i = 0; i < m_Joins.size(); ++i)
+    delete m_Joins[i];
+  m_Joins.resize(0);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::ClearGhostJoins() noexcept {
+  for (JoinList::size_type i = 0; i < m_GhostJoins.size(); ++i)
+    delete m_GhostJoins[i];
+  m_GhostJoins.resize(0);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::AddGhostJoin(OutPt *op, const IntPoint OffPt) noexcept {
+  Join *j = new Join;
+  j->OutPt1 = op;
+  j->OutPt2 = 0;
+  j->OffPt = OffPt;
+  m_GhostJoins.emplace_back(j);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::InsertLocalMinimaIntoAEL(const cInt botY) noexcept {
+  const LocalMinimum *lm;
+  while (PopLocalMinima(botY, lm)) {
+    TEdge *lb = lm->LeftBound;
+    TEdge *rb = lm->RightBound;
+
+    OutPt *Op1 = 0;
+    if (!lb || !rb) {
+      // nb: don't insert LB into either AEL or SEL
+      InsertEdgeIntoAEL(rb, 0);
+      SetWindingCount(*rb);
+      if (IsContributing(*rb))
+        Op1 = AddOutPt(rb, rb->Bot);
+      //} else if (!rb) {
+      //  InsertEdgeIntoAEL(lb, 0);
+      //  SetWindingCount(*lb);
+      //  if (IsContributing(*lb))
+      //    Op1 = AddOutPt(lb, lb->Bot);
+      InsertScanbeam(lb->Top.Y);
+    } else {
+      InsertEdgeIntoAEL(lb, 0);
+      InsertEdgeIntoAEL(rb, lb);
+      SetWindingCount(*lb);
+      rb->WindCnt = lb->WindCnt;
+      rb->WindCnt2 = lb->WindCnt2;
+      if (IsContributing(*lb))
+        Op1 = AddLocalMinPoly(lb, rb, lb->Bot);
+      InsertScanbeam(lb->Top.Y);
+    }
+
+    if (rb) {
+      if (IsHorizontal(*rb)) {
+        AddEdgeToSEL(rb);
+        if (rb->NextInLML)
+          InsertScanbeam(rb->NextInLML->Top.Y);
+      } else
+        InsertScanbeam(rb->Top.Y);
+    }
+
+    if (!lb || !rb)
+      continue;
+
+    // if any output polygons share an edge, they'll need joining later ...
+    if (Op1 && IsHorizontal(*rb) && m_GhostJoins.size() > 0 &&
+        (rb->WindDelta != 0)) {
+      for (JoinList::size_type i = 0; i < m_GhostJoins.size(); ++i) {
+        Join *jr = m_GhostJoins[i];
+        // if the horizontal Rb and a 'ghost' horizontal overlap, then convert
+        // the 'ghost' join to a real join ready for later ...
+        if (HorzSegmentsOverlap(jr->OutPt1->Pt.X, jr->OffPt.X, rb->Bot.X,
+                                rb->Top.X))
+          AddJoin(jr->OutPt1, Op1, jr->OffPt);
+      }
+    }
+
+    if (lb->OutIdx >= 0 && lb->PrevInAEL &&
+        lb->PrevInAEL->Curr.X == lb->Bot.X && lb->PrevInAEL->OutIdx >= 0 &&
+        SlopesEqual(lb->PrevInAEL->Bot, lb->PrevInAEL->Top, lb->Curr, lb->Top,
+                    m_UseFullRange) &&
+        (lb->WindDelta != 0) && (lb->PrevInAEL->WindDelta != 0)) {
+      OutPt *Op2 = AddOutPt(lb->PrevInAEL, lb->Bot);
+      AddJoin(Op1, Op2, lb->Top);
+    }
+
+    if (lb->NextInAEL != rb) {
+
+      if (rb->OutIdx >= 0 && rb->PrevInAEL->OutIdx >= 0 &&
+          SlopesEqual(rb->PrevInAEL->Curr, rb->PrevInAEL->Top, rb->Curr,
+                      rb->Top, m_UseFullRange) &&
+          (rb->WindDelta != 0) && (rb->PrevInAEL->WindDelta != 0)) {
+        OutPt *Op2 = AddOutPt(rb->PrevInAEL, rb->Bot);
+        AddJoin(Op1, Op2, rb->Top);
+      }
+
+      TEdge *e = lb->NextInAEL;
+      if (e) {
+        while (e != rb) {
+          // nb: For calculating winding counts etc, IntersectEdges() assumes
+          // that param1 will be to the Right of param2 ABOVE the intersection
+          // ...
+          IntersectEdges(rb, e, lb->Curr); // order important here
+          e = e->NextInAEL;
+        }
+      }
+    }
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::DeleteFromSEL(TEdge *e) noexcept {
+  TEdge *SelPrev = e->PrevInSEL;
+  TEdge *SelNext = e->NextInSEL;
+  if (!SelPrev && !SelNext && (e != m_SortedEdges))
+    return; // already deleted
+  if (SelPrev)
+    SelPrev->NextInSEL = SelNext;
+  else
+    m_SortedEdges = SelNext;
+  if (SelNext)
+    SelNext->PrevInSEL = SelPrev;
+  e->NextInSEL = 0;
+  e->PrevInSEL = 0;
+}
+//------------------------------------------------------------------------------
+
+#ifdef use_xyz
+void Clipper::SetZ(IntPoint &pt, TEdge &e1, TEdge &e2) noexcept {
+  if (pt.Z != 0 || !m_ZFill)
+    return;
+  else if (pt == e1.Bot)
+    pt.Z = e1.Bot.Z;
+  else if (pt == e1.Top)
+    pt.Z = e1.Top.Z;
+  else if (pt == e2.Bot)
+    pt.Z = e2.Bot.Z;
+  else if (pt == e2.Top)
+    pt.Z = e2.Top.Z;
+  else
+    (*m_ZFill)(e1.Bot, e1.Top, e2.Bot, e2.Top, pt);
+}
+//------------------------------------------------------------------------------
+#endif
+
+void Clipper::IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &Pt) noexcept {
+  bool e1Contributing = (e1->OutIdx >= 0);
+  bool e2Contributing = (e2->OutIdx >= 0);
+
+#ifdef use_xyz
+  SetZ(Pt, *e1, *e2);
+#endif
+
+#ifdef use_lines
+  // if either edge is on an OPEN path ...
+  if (e1->WindDelta == 0 || e2->WindDelta == 0) {
+    // ignore subject-subject open path intersections UNLESS they
+    // are both open paths, AND they are both 'contributing maximas' ...
+    if (e1->WindDelta == 0 && e2->WindDelta == 0)
+      return;
+
+    // if intersecting a subj line with a subj poly ...
+    else if (e1->PolyTyp == e2->PolyTyp && e1->WindDelta != e2->WindDelta &&
+             m_ClipType == ctUnion) {
+      if (e1->WindDelta == 0) {
+        if (e2Contributing) {
+          AddOutPt(e1, Pt);
+          if (e1Contributing)
+            e1->OutIdx = Unassigned;
+        }
+      } else {
+        if (e1Contributing) {
+          AddOutPt(e2, Pt);
+          if (e2Contributing)
+            e2->OutIdx = Unassigned;
+        }
+      }
+    } else if (e1->PolyTyp != e2->PolyTyp) {
+      // toggle subj open path OutIdx on/off when Abs(clip.WndCnt) == 1 ...
+      if ((e1->WindDelta == 0) && abs(e2->WindCnt) == 1 &&
+          (m_ClipType != ctUnion || e2->WindCnt2 == 0)) {
+        AddOutPt(e1, Pt);
+        if (e1Contributing)
+          e1->OutIdx = Unassigned;
+      } else if ((e2->WindDelta == 0) && (abs(e1->WindCnt) == 1) &&
+                 (m_ClipType != ctUnion || e1->WindCnt2 == 0)) {
+        AddOutPt(e2, Pt);
+        if (e2Contributing)
+          e2->OutIdx = Unassigned;
+      }
+    }
+    return;
+  }
+#endif
+
+  // update winding counts...
+  // assumes that e1 will be to the Right of e2 ABOVE the intersection
+  if (e1->PolyTyp == e2->PolyTyp) {
+    if (IsEvenOddFillType(*e1)) {
+      int oldE1WindCnt = e1->WindCnt;
+      e1->WindCnt = e2->WindCnt;
+      e2->WindCnt = oldE1WindCnt;
+    } else {
+      if (e1->WindCnt + e2->WindDelta == 0)
+        e1->WindCnt = -e1->WindCnt;
+      else
+        e1->WindCnt += e2->WindDelta;
+      if (e2->WindCnt - e1->WindDelta == 0)
+        e2->WindCnt = -e2->WindCnt;
+      else
+        e2->WindCnt -= e1->WindDelta;
+    }
+  } else {
+    if (!IsEvenOddFillType(*e2))
+      e1->WindCnt2 += e2->WindDelta;
+    else
+      e1->WindCnt2 = (e1->WindCnt2 == 0) ? 1 : 0;
+    if (!IsEvenOddFillType(*e1))
+      e2->WindCnt2 -= e1->WindDelta;
+    else
+      e2->WindCnt2 = (e2->WindCnt2 == 0) ? 1 : 0;
+  }
+
+  PolyFillType e1FillType, e2FillType, e1FillType2, e2FillType2;
+  if (e1->PolyTyp == ptSubject) {
+    e1FillType = m_SubjFillType;
+    e1FillType2 = m_ClipFillType;
+  } else {
+    e1FillType = m_ClipFillType;
+    e1FillType2 = m_SubjFillType;
+  }
+  if (e2->PolyTyp == ptSubject) {
+    e2FillType = m_SubjFillType;
+    e2FillType2 = m_ClipFillType;
+  } else {
+    e2FillType = m_ClipFillType;
+    e2FillType2 = m_SubjFillType;
+  }
+
+  cInt e1Wc, e2Wc;
+  switch (e1FillType) {
+  case pftPositive:
+    e1Wc = e1->WindCnt;
+    break;
+  case pftNegative:
+    e1Wc = -e1->WindCnt;
+    break;
+  default:
+    e1Wc = Abs(e1->WindCnt);
+  }
+  switch (e2FillType) {
+  case pftPositive:
+    e2Wc = e2->WindCnt;
+    break;
+  case pftNegative:
+    e2Wc = -e2->WindCnt;
+    break;
+  default:
+    e2Wc = Abs(e2->WindCnt);
+  }
+
+  if (e1Contributing && e2Contributing) {
+    if ((e1Wc != 0 && e1Wc != 1) || (e2Wc != 0 && e2Wc != 1) ||
+        (e1->PolyTyp != e2->PolyTyp && m_ClipType != ctXor)) {
+      AddLocalMaxPoly(e1, e2, Pt);
+    } else {
+      AddOutPt(e1, Pt);
+      AddOutPt(e2, Pt);
+      SwapSides(*e1, *e2);
+      SwapPolyIndexes(*e1, *e2);
+    }
+  } else if (e1Contributing) {
+    if (e2Wc == 0 || e2Wc == 1) {
+      AddOutPt(e1, Pt);
+      SwapSides(*e1, *e2);
+      SwapPolyIndexes(*e1, *e2);
+    }
+  } else if (e2Contributing) {
+    if (e1Wc == 0 || e1Wc == 1) {
+      AddOutPt(e2, Pt);
+      SwapSides(*e1, *e2);
+      SwapPolyIndexes(*e1, *e2);
+    }
+  } else if ((e1Wc == 0 || e1Wc == 1) && (e2Wc == 0 || e2Wc == 1)) {
+    // neither edge is currently contributing ...
+
+    cInt e1Wc2, e2Wc2;
+    switch (e1FillType2) {
+    case pftPositive:
+      e1Wc2 = e1->WindCnt2;
+      break;
+    case pftNegative:
+      e1Wc2 = -e1->WindCnt2;
+      break;
+    default:
+      e1Wc2 = Abs(e1->WindCnt2);
+    }
+    switch (e2FillType2) {
+    case pftPositive:
+      e2Wc2 = e2->WindCnt2;
+      break;
+    case pftNegative:
+      e2Wc2 = -e2->WindCnt2;
+      break;
+    default:
+      e2Wc2 = Abs(e2->WindCnt2);
+    }
+
+    if (e1->PolyTyp != e2->PolyTyp) {
+      AddLocalMinPoly(e1, e2, Pt);
+    } else if (e1Wc == 1 && e2Wc == 1)
+      switch (m_ClipType) {
+      case ctIntersection:
+        if (e1Wc2 > 0 && e2Wc2 > 0)
+          AddLocalMinPoly(e1, e2, Pt);
+        break;
+      case ctUnion:
+        if (e1Wc2 <= 0 && e2Wc2 <= 0)
+          AddLocalMinPoly(e1, e2, Pt);
+        break;
+      case ctDifference:
+        if (((e1->PolyTyp == ptClip) && (e1Wc2 > 0) && (e2Wc2 > 0)) ||
+            ((e1->PolyTyp == ptSubject) && (e1Wc2 <= 0) && (e2Wc2 <= 0)))
+          AddLocalMinPoly(e1, e2, Pt);
+        break;
+      case ctXor:
+        AddLocalMinPoly(e1, e2, Pt);
+      }
+    else
+      SwapSides(*e1, *e2);
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::SetHoleState(TEdge *e, OutRec *outrec) noexcept {
+  TEdge *e2 = e->PrevInAEL;
+  TEdge *eTmp = 0;
+  while (e2) {
+    if (e2->OutIdx >= 0 && e2->WindDelta != 0) {
+      if (!eTmp)
+        eTmp = e2;
+      else if (eTmp->OutIdx == e2->OutIdx)
+        eTmp = 0;
+    }
+    e2 = e2->PrevInAEL;
+  }
+  if (!eTmp) {
+    outrec->FirstLeft = 0;
+    outrec->IsHole = false;
+  } else {
+    outrec->FirstLeft = m_PolyOuts[eTmp->OutIdx];
+    outrec->IsHole = !outrec->FirstLeft->IsHole;
+  }
+}
+//------------------------------------------------------------------------------
+
+OutRec *GetLowermostRec(OutRec *outRec1, OutRec *outRec2) noexcept {
+  // work out which polygon fragment has the correct hole state ...
+  if (!outRec1->BottomPt)
+    outRec1->BottomPt = GetBottomPt(outRec1->Pts);
+  if (!outRec2->BottomPt)
+    outRec2->BottomPt = GetBottomPt(outRec2->Pts);
+  OutPt *OutPt1 = outRec1->BottomPt;
+  OutPt *OutPt2 = outRec2->BottomPt;
+  if (OutPt1->Pt.Y > OutPt2->Pt.Y)
+    return outRec1;
+  else if (OutPt1->Pt.Y < OutPt2->Pt.Y)
+    return outRec2;
+  else if (OutPt1->Pt.X < OutPt2->Pt.X)
+    return outRec1;
+  else if (OutPt1->Pt.X > OutPt2->Pt.X)
+    return outRec2;
+  else if (OutPt1->Next == OutPt1)
+    return outRec2;
+  else if (OutPt2->Next == OutPt2)
+    return outRec1;
+  else if (FirstIsBottomPt(OutPt1, OutPt2))
+    return outRec1;
+  else
+    return outRec2;
+}
+//------------------------------------------------------------------------------
+
+bool OutRec1RightOfOutRec2(OutRec *outRec1, OutRec *outRec2) noexcept {
+  do {
+    outRec1 = outRec1->FirstLeft;
+    if (outRec1 == outRec2)
+      return true;
+  } while (outRec1);
+  return false;
+}
+//------------------------------------------------------------------------------
+
+OutRec *Clipper::GetOutRec(int Idx) noexcept {
+  OutRec *outrec = m_PolyOuts[Idx];
+  while (outrec != m_PolyOuts[outrec->Idx])
+    outrec = m_PolyOuts[outrec->Idx];
+  return outrec;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::AppendPolygon(TEdge *e1, TEdge *e2) noexcept {
+  // get the start and ends of both output polygons ...
+  OutRec *outRec1 = m_PolyOuts[e1->OutIdx];
+  OutRec *outRec2 = m_PolyOuts[e2->OutIdx];
+
+  OutRec *holeStateRec;
+  if (OutRec1RightOfOutRec2(outRec1, outRec2))
+    holeStateRec = outRec2;
+  else if (OutRec1RightOfOutRec2(outRec2, outRec1))
+    holeStateRec = outRec1;
+  else
+    holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+  // get the start and ends of both output polygons and
+  // join e2 poly onto e1 poly and delete pointers to e2 ...
+
+  OutPt *p1_lft = outRec1->Pts;
+  OutPt *p1_rt = p1_lft->Prev;
+  OutPt *p2_lft = outRec2->Pts;
+  OutPt *p2_rt = p2_lft->Prev;
+
+  // join e2 poly onto e1 poly and delete pointers to e2 ...
+  if (e1->Side == esLeft) {
+    if (e2->Side == esLeft) {
+      // z y x a b c
+      ReversePolyPtLinks(p2_lft);
+      p2_lft->Next = p1_lft;
+      p1_lft->Prev = p2_lft;
+      p1_rt->Next = p2_rt;
+      p2_rt->Prev = p1_rt;
+      outRec1->Pts = p2_rt;
+    } else {
+      // x y z a b c
+      p2_rt->Next = p1_lft;
+      p1_lft->Prev = p2_rt;
+      p2_lft->Prev = p1_rt;
+      p1_rt->Next = p2_lft;
+      outRec1->Pts = p2_lft;
+    }
+  } else {
+    if (e2->Side == esRight) {
+      // a b c z y x
+      ReversePolyPtLinks(p2_lft);
+      p1_rt->Next = p2_rt;
+      p2_rt->Prev = p1_rt;
+      p2_lft->Next = p1_lft;
+      p1_lft->Prev = p2_lft;
+    } else {
+      // a b c x y z
+      p1_rt->Next = p2_lft;
+      p2_lft->Prev = p1_rt;
+      p1_lft->Prev = p2_rt;
+      p2_rt->Next = p1_lft;
+    }
+  }
+
+  outRec1->BottomPt = 0;
+  if (holeStateRec == outRec2) {
+    if (outRec2->FirstLeft != outRec1)
+      outRec1->FirstLeft = outRec2->FirstLeft;
+    outRec1->IsHole = outRec2->IsHole;
+  }
+  outRec2->Pts = 0;
+  outRec2->BottomPt = 0;
+  outRec2->FirstLeft = outRec1;
+
+  int OKIdx = e1->OutIdx;
+  int ObsoleteIdx = e2->OutIdx;
+
+  e1->OutIdx =
+      Unassigned; // nb: safe because we only get here via AddLocalMaxPoly
+  e2->OutIdx = Unassigned;
+
+  TEdge *e = m_ActiveEdges;
+  while (e) {
+    if (e->OutIdx == ObsoleteIdx) {
+      e->OutIdx = OKIdx;
+      e->Side = e1->Side;
+      break;
+    }
+    e = e->NextInAEL;
+  }
+
+  outRec2->Idx = outRec1->Idx;
+}
+//------------------------------------------------------------------------------
+
+OutPt *Clipper::AddOutPt(TEdge *e, const IntPoint &pt) noexcept {
+  if (e->OutIdx < 0) {
+    OutRec *outRec = CreateOutRec();
+    outRec->IsOpen = (e->WindDelta == 0);
+    OutPt *newOp = new OutPt;
+    outRec->Pts = newOp;
+    newOp->Idx = outRec->Idx;
+    newOp->Pt = pt;
+    newOp->Next = newOp;
+    newOp->Prev = newOp;
+    if (!outRec->IsOpen)
+      SetHoleState(e, outRec);
+    e->OutIdx = outRec->Idx;
+    return newOp;
+  } else {
+    OutRec *outRec = m_PolyOuts[e->OutIdx];
+    // OutRec.Pts is the 'Left-most' point & OutRec.Pts.Prev is the 'Right-most'
+    OutPt *op = outRec->Pts;
+
+    bool ToFront = (e->Side == esLeft);
+    if (ToFront && (pt == op->Pt))
+      return op;
+    else if (!ToFront && (pt == op->Prev->Pt))
+      return op->Prev;
+
+    OutPt *newOp = new OutPt;
+    newOp->Idx = outRec->Idx;
+    newOp->Pt = pt;
+    newOp->Next = op;
+    newOp->Prev = op->Prev;
+    newOp->Prev->Next = newOp;
+    op->Prev = newOp;
+    if (ToFront)
+      outRec->Pts = newOp;
+    return newOp;
+  }
+}
+//------------------------------------------------------------------------------
+
+OutPt *Clipper::GetLastOutPt(TEdge *e) noexcept {
+  OutRec *outRec = m_PolyOuts[e->OutIdx];
+  if (e->Side == esLeft)
+    return outRec->Pts;
+  else
+    return outRec->Pts->Prev;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::ProcessHorizontals() noexcept {
+  TEdge *horzEdge;
+  while (PopEdgeFromSEL(horzEdge))
+    ProcessHorizontal(horzEdge);
+}
+//------------------------------------------------------------------------------
+
+inline bool IsMinima(TEdge *e) noexcept {
+  return e && (e->Prev->NextInLML != e) && (e->Next->NextInLML != e);
+}
+//------------------------------------------------------------------------------
+
+inline bool IsMaxima(TEdge *e, const cInt Y) noexcept {
+  return e && e->Top.Y == Y && !e->NextInLML;
+}
+//------------------------------------------------------------------------------
+
+inline bool IsIntermediate(TEdge *e, const cInt Y) noexcept {
+  return e->Top.Y == Y && e->NextInLML;
+}
+//------------------------------------------------------------------------------
+
+TEdge *GetMaximaPair(TEdge *e) noexcept {
+  if ((e->Next->Top == e->Top) && !e->Next->NextInLML)
+    return e->Next;
+  else if ((e->Prev->Top == e->Top) && !e->Prev->NextInLML)
+    return e->Prev;
+  else
+    return 0;
+}
+//------------------------------------------------------------------------------
+
+TEdge *GetMaximaPairEx(TEdge *e) noexcept {
+  // as GetMaximaPair() but returns 0 if MaxPair isn't in AEL (unless it's
+  // horizontal)
+  TEdge *result = GetMaximaPair(e);
+  if (result &&
+      (result->OutIdx == Skip ||
+       (result->NextInAEL == result->PrevInAEL && !IsHorizontal(*result))))
+    return 0;
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::SwapPositionsInSEL(TEdge *Edge1, TEdge *Edge2) noexcept {
+  if (!(Edge1->NextInSEL) && !(Edge1->PrevInSEL))
+    return;
+  if (!(Edge2->NextInSEL) && !(Edge2->PrevInSEL))
+    return;
+
+  if (Edge1->NextInSEL == Edge2) {
+    TEdge *Next = Edge2->NextInSEL;
+    if (Next)
+      Next->PrevInSEL = Edge1;
+    TEdge *Prev = Edge1->PrevInSEL;
+    if (Prev)
+      Prev->NextInSEL = Edge2;
+    Edge2->PrevInSEL = Prev;
+    Edge2->NextInSEL = Edge1;
+    Edge1->PrevInSEL = Edge2;
+    Edge1->NextInSEL = Next;
+  } else if (Edge2->NextInSEL == Edge1) {
+    TEdge *Next = Edge1->NextInSEL;
+    if (Next)
+      Next->PrevInSEL = Edge2;
+    TEdge *Prev = Edge2->PrevInSEL;
+    if (Prev)
+      Prev->NextInSEL = Edge1;
+    Edge1->PrevInSEL = Prev;
+    Edge1->NextInSEL = Edge2;
+    Edge2->PrevInSEL = Edge1;
+    Edge2->NextInSEL = Next;
+  } else {
+    TEdge *Next = Edge1->NextInSEL;
+    TEdge *Prev = Edge1->PrevInSEL;
+    Edge1->NextInSEL = Edge2->NextInSEL;
+    if (Edge1->NextInSEL)
+      Edge1->NextInSEL->PrevInSEL = Edge1;
+    Edge1->PrevInSEL = Edge2->PrevInSEL;
+    if (Edge1->PrevInSEL)
+      Edge1->PrevInSEL->NextInSEL = Edge1;
+    Edge2->NextInSEL = Next;
+    if (Edge2->NextInSEL)
+      Edge2->NextInSEL->PrevInSEL = Edge2;
+    Edge2->PrevInSEL = Prev;
+    if (Edge2->PrevInSEL)
+      Edge2->PrevInSEL->NextInSEL = Edge2;
+  }
+
+  if (!Edge1->PrevInSEL)
+    m_SortedEdges = Edge1;
+  else if (!Edge2->PrevInSEL)
+    m_SortedEdges = Edge2;
+}
+//------------------------------------------------------------------------------
+
+TEdge *GetNextInAEL(TEdge *e, Direction dir) noexcept {
+  return dir == dLeftToRight ? e->NextInAEL : e->PrevInAEL;
+}
+//------------------------------------------------------------------------------
+
+void GetHorzDirection(TEdge &HorzEdge, Direction &Dir, cInt &Left,
+                      cInt &Right) noexcept {
+  if (HorzEdge.Bot.X < HorzEdge.Top.X) {
+    Left = HorzEdge.Bot.X;
+    Right = HorzEdge.Top.X;
+    Dir = dLeftToRight;
+  } else {
+    Left = HorzEdge.Top.X;
+    Right = HorzEdge.Bot.X;
+    Dir = dRightToLeft;
+  }
+}
+//------------------------------------------------------------------------
+
+/*******************************************************************************
+ * Notes: Horizontal edges (HEs) at scanline intersections (ie at the Top or *
+ * Bottom of a scanbeam) are processed as if layered. The order in which HEs *
+ * are processed doesn't matter. HEs intersect with other HE Bot.Xs only [#] *
+ * (or they could intersect with Top.Xs only, ie EITHER Bot.Xs OR Top.Xs), * and
+ *with other non-horizontal edges [*]. Once these intersections are        *
+ * processed, intermediate HEs then 'promote' the Edge above (NextInLML) into *
+ * the AEL. These 'promoted' edges may in turn intersect [%] with other HEs. *
+ *******************************************************************************/
+
+void Clipper::ProcessHorizontal(TEdge *horzEdge) noexcept {
+  Direction dir;
+  cInt horzLeft, horzRight;
+  bool IsOpen = (horzEdge->WindDelta == 0);
+
+  GetHorzDirection(*horzEdge, dir, horzLeft, horzRight);
+
+  TEdge *eLastHorz = horzEdge, *eMaxPair = 0;
+  while (eLastHorz->NextInLML && IsHorizontal(*eLastHorz->NextInLML))
+    eLastHorz = eLastHorz->NextInLML;
+  if (!eLastHorz->NextInLML)
+    eMaxPair = GetMaximaPair(eLastHorz);
+
+  MaximaList::const_iterator maxIt;
+  MaximaList::const_reverse_iterator maxRit;
+  if (m_Maxima.size() > 0) {
+    // get the first maxima in range (X) ...
+    if (dir == dLeftToRight) {
+      maxIt = m_Maxima.begin();
+      while (maxIt != m_Maxima.end() && *maxIt <= horzEdge->Bot.X)
+        ++maxIt;
+      if (maxIt != m_Maxima.end() && *maxIt >= eLastHorz->Top.X)
+        maxIt = m_Maxima.end();
+    } else {
+      maxRit = m_Maxima.rbegin();
+      while (maxRit != m_Maxima.rend() && *maxRit > horzEdge->Bot.X)
+        ++maxRit;
+      if (maxRit != m_Maxima.rend() && *maxRit <= eLastHorz->Top.X)
+        maxRit = m_Maxima.rend();
+    }
+  }
+
+  OutPt *op1 = 0;
+
+  for (;;) // loop through consec. horizontal edges
+  {
+
+    bool IsLastHorz = (horzEdge == eLastHorz);
+    TEdge *e = GetNextInAEL(horzEdge, dir);
+    while (e) {
+
+      // this code block inserts extra coords into horizontal edges (in output
+      // polygons) wherever maxima touch these horizontal edges. This helps
+      //'simplifying' polygons (ie if the Simplify property is set).
+      if (m_Maxima.size() > 0) {
+        if (dir == dLeftToRight) {
+          while (maxIt != m_Maxima.end() && *maxIt < e->Curr.X) {
+            if (horzEdge->OutIdx >= 0 && !IsOpen)
+              AddOutPt(horzEdge, IntPoint(*maxIt, horzEdge->Bot.Y));
+            ++maxIt;
+          }
+        } else {
+          while (maxRit != m_Maxima.rend() && *maxRit > e->Curr.X) {
+            if (horzEdge->OutIdx >= 0 && !IsOpen)
+              AddOutPt(horzEdge, IntPoint(*maxRit, horzEdge->Bot.Y));
+            ++maxRit;
+          }
+        }
+      };
+
+      if ((dir == dLeftToRight && e->Curr.X > horzRight) ||
+          (dir == dRightToLeft && e->Curr.X < horzLeft))
+        break;
+
+      // Also break if we've got to the end of an intermediate horizontal edge
+      // ...
+      // nb: Smaller Dx's are to the right of larger Dx's ABOVE the horizontal.
+      if (e->Curr.X == horzEdge->Top.X && horzEdge->NextInLML &&
+          e->Dx < horzEdge->NextInLML->Dx)
+        break;
+
+      if (horzEdge->OutIdx >= 0 && !IsOpen) // note: may be done multiple times
+      {
+#ifdef use_xyz
+        if (dir == dLeftToRight)
+          SetZ(e->Curr, *horzEdge, *e);
+        else
+          SetZ(e->Curr, *e, *horzEdge);
+#endif
+        op1 = AddOutPt(horzEdge, e->Curr);
+        TEdge *eNextHorz = m_SortedEdges;
+        while (eNextHorz) {
+          if (eNextHorz->OutIdx >= 0 &&
+              HorzSegmentsOverlap(horzEdge->Bot.X, horzEdge->Top.X,
+                                  eNextHorz->Bot.X, eNextHorz->Top.X)) {
+            OutPt *op2 = GetLastOutPt(eNextHorz);
+            AddJoin(op2, op1, eNextHorz->Top);
+          }
+          eNextHorz = eNextHorz->NextInSEL;
+        }
+        AddGhostJoin(op1, horzEdge->Bot);
+      }
+
+      // OK, so far we're still in range of the horizontal Edge  but make sure
+      // we're at the last of consec. horizontals when matching with eMaxPair
+      if (e == eMaxPair && IsLastHorz) {
+        if (horzEdge->OutIdx >= 0)
+          AddLocalMaxPoly(horzEdge, eMaxPair, horzEdge->Top);
+        DeleteFromAEL(horzEdge);
+        DeleteFromAEL(eMaxPair);
+        return;
+      }
+
+      if (dir == dLeftToRight) {
+        IntPoint Pt(e->Curr.X, horzEdge->Curr.Y);
+        IntersectEdges(horzEdge, e, Pt);
+      } else {
+        IntPoint Pt(e->Curr.X, horzEdge->Curr.Y);
+        IntersectEdges(e, horzEdge, Pt);
+      }
+      TEdge *eNext = GetNextInAEL(e, dir);
+      SwapPositionsInAEL(horzEdge, e);
+      e = eNext;
+    } // end while(e)
+
+    // Break out of loop if HorzEdge.NextInLML is not also horizontal ...
+    if (!horzEdge->NextInLML || !IsHorizontal(*horzEdge->NextInLML))
+      break;
+
+    UpdateEdgeIntoAEL(horzEdge);
+    if (horzEdge->OutIdx >= 0)
+      AddOutPt(horzEdge, horzEdge->Bot);
+    GetHorzDirection(*horzEdge, dir, horzLeft, horzRight);
+
+  } // end for (;;)
+
+  if (horzEdge->OutIdx >= 0 && !op1) {
+    op1 = GetLastOutPt(horzEdge);
+    TEdge *eNextHorz = m_SortedEdges;
+    while (eNextHorz) {
+      if (eNextHorz->OutIdx >= 0 &&
+          HorzSegmentsOverlap(horzEdge->Bot.X, horzEdge->Top.X,
+                              eNextHorz->Bot.X, eNextHorz->Top.X)) {
+        OutPt *op2 = GetLastOutPt(eNextHorz);
+        AddJoin(op2, op1, eNextHorz->Top);
+      }
+      eNextHorz = eNextHorz->NextInSEL;
+    }
+    AddGhostJoin(op1, horzEdge->Top);
+  }
+
+  if (horzEdge->NextInLML) {
+    if (horzEdge->OutIdx >= 0) {
+      op1 = AddOutPt(horzEdge, horzEdge->Top);
+      UpdateEdgeIntoAEL(horzEdge);
+      if (horzEdge->WindDelta == 0)
+        return;
+      // nb: HorzEdge is no longer horizontal here
+      TEdge *ePrev = horzEdge->PrevInAEL;
+      TEdge *eNext = horzEdge->NextInAEL;
+      if (ePrev && ePrev->Curr.X == horzEdge->Bot.X &&
+          ePrev->Curr.Y == horzEdge->Bot.Y && ePrev->WindDelta != 0 &&
+          (ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y &&
+           SlopesEqual(*horzEdge, *ePrev, m_UseFullRange))) {
+        OutPt *op2 = AddOutPt(ePrev, horzEdge->Bot);
+        AddJoin(op1, op2, horzEdge->Top);
+      } else if (eNext && eNext->Curr.X == horzEdge->Bot.X &&
+                 eNext->Curr.Y == horzEdge->Bot.Y && eNext->WindDelta != 0 &&
+                 eNext->OutIdx >= 0 && eNext->Curr.Y > eNext->Top.Y &&
+                 SlopesEqual(*horzEdge, *eNext, m_UseFullRange)) {
+        OutPt *op2 = AddOutPt(eNext, horzEdge->Bot);
+        AddJoin(op1, op2, horzEdge->Top);
+      }
+    } else
+      UpdateEdgeIntoAEL(horzEdge);
+  } else {
+    if (horzEdge->OutIdx >= 0)
+      AddOutPt(horzEdge, horzEdge->Top);
+    DeleteFromAEL(horzEdge);
+  }
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::ProcessIntersections(const cInt topY) {
+  if (!m_ActiveEdges)
+    return true;
+  try {
+    BuildIntersectList(topY);
+    size_t IlSize = m_IntersectList.size();
+    if (IlSize == 0)
+      return true;
+    if (IlSize == 1 || FixupIntersectionOrder())
+      ProcessIntersectList();
+    else
+      return false;
+  } catch (...) {
+    m_SortedEdges = 0;
+    DisposeIntersectNodes();
+    throw clipperException("ProcessIntersections error");
+  }
+  m_SortedEdges = 0;
+  return true;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::DisposeIntersectNodes() noexcept {
+  for (size_t i = 0; i < m_IntersectList.size(); ++i)
+    delete m_IntersectList[i];
+  m_IntersectList.clear();
+}
+//------------------------------------------------------------------------------
+
+void Clipper::BuildIntersectList(const cInt topY) noexcept {
+  if (!m_ActiveEdges)
+    return;
+
+  // prepare for sorting ...
+  TEdge *e = m_ActiveEdges;
+  m_SortedEdges = e;
+  while (e) {
+    e->PrevInSEL = e->PrevInAEL;
+    e->NextInSEL = e->NextInAEL;
+    e->Curr.X = TopX(*e, topY);
+    e = e->NextInAEL;
+  }
+
+  // bubblesort ...
+  bool isModified;
+  do {
+    isModified = false;
+    e = m_SortedEdges;
+    while (e->NextInSEL) {
+      TEdge *eNext = e->NextInSEL;
+      IntPoint Pt;
+      if (e->Curr.X > eNext->Curr.X) {
+        IntersectPoint(*e, *eNext, Pt);
+        if (Pt.Y < topY)
+          Pt.reset(TopX(*e, topY), topY);
+        IntersectNode *newNode = new IntersectNode;
+        newNode->Edge1 = e;
+        newNode->Edge2 = eNext;
+        newNode->Pt = Pt;
+        m_IntersectList.emplace_back(newNode);
+
+        SwapPositionsInSEL(e, eNext);
+        isModified = true;
+      } else
+        e = eNext;
+    }
+    if (e->PrevInSEL)
+      e->PrevInSEL->NextInSEL = 0;
+    else
+      break;
+  } while (isModified);
+  m_SortedEdges = 0; // important
+}
+//------------------------------------------------------------------------------
+
+void Clipper::ProcessIntersectList() noexcept {
+  for (size_t i = 0; i < m_IntersectList.size(); ++i) {
+    IntersectNode *iNode = m_IntersectList[i];
+    {
+      IntersectEdges(iNode->Edge1, iNode->Edge2, iNode->Pt);
+      SwapPositionsInAEL(iNode->Edge1, iNode->Edge2);
+    }
+    delete iNode;
+  }
+  m_IntersectList.clear();
+}
+//------------------------------------------------------------------------------
+
+bool IntersectListSort(IntersectNode *node1, IntersectNode *node2) noexcept {
+  return node2->Pt.Y < node1->Pt.Y;
+}
+//------------------------------------------------------------------------------
+
+inline bool EdgesAdjacent(const IntersectNode &inode) noexcept {
+  return (inode.Edge1->NextInSEL == inode.Edge2) ||
+         (inode.Edge1->PrevInSEL == inode.Edge2);
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::FixupIntersectionOrder() noexcept {
+  // pre-condition: intersections are sorted Bottom-most first.
+  // Now it's crucial that intersections are made only between adjacent edges,
+  // so to ensure this the order of intersections may need adjusting ...
+  CopyAELToSEL();
+  std::sort(m_IntersectList.begin(), m_IntersectList.end(), IntersectListSort);
+  size_t cnt = m_IntersectList.size();
+  for (size_t i = 0; i < cnt; ++i) {
+    if (!EdgesAdjacent(*m_IntersectList[i])) {
+      size_t j = i + 1;
+      while (j < cnt && !EdgesAdjacent(*m_IntersectList[j]))
+        ++j;
+      if (j == cnt)
+        return false;
+      std::swap(m_IntersectList[i], m_IntersectList[j]);
+    }
+    SwapPositionsInSEL(m_IntersectList[i]->Edge1, m_IntersectList[i]->Edge2);
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::DoMaxima(TEdge *e) {
+  TEdge *eMaxPair = GetMaximaPairEx(e);
+  if (!eMaxPair) {
+    if (e->OutIdx >= 0)
+      AddOutPt(e, e->Top);
+    DeleteFromAEL(e);
+    return;
+  }
+
+  TEdge *eNext = e->NextInAEL;
+  while (eNext && eNext != eMaxPair) {
+    IntersectEdges(e, eNext, e->Top);
+    SwapPositionsInAEL(e, eNext);
+    eNext = e->NextInAEL;
+  }
+
+  if (e->OutIdx == Unassigned && eMaxPair->OutIdx == Unassigned) {
+    DeleteFromAEL(e);
+    DeleteFromAEL(eMaxPair);
+  } else if (e->OutIdx >= 0 && eMaxPair->OutIdx >= 0) {
+    if (e->OutIdx >= 0)
+      AddLocalMaxPoly(e, eMaxPair, e->Top);
+    DeleteFromAEL(e);
+    DeleteFromAEL(eMaxPair);
+  }
+#ifdef use_lines
+  else if (e->WindDelta == 0) {
+    if (e->OutIdx >= 0) {
+      AddOutPt(e, e->Top);
+      e->OutIdx = Unassigned;
+    }
+    DeleteFromAEL(e);
+
+    if (eMaxPair->OutIdx >= 0) {
+      AddOutPt(eMaxPair, e->Top);
+      eMaxPair->OutIdx = Unassigned;
+    }
+    DeleteFromAEL(eMaxPair);
+  }
+#endif
+  else
+    throw clipperException("DoMaxima error");
+}
+//------------------------------------------------------------------------------
+
+void Clipper::ProcessEdgesAtTopOfScanbeam(const cInt topY) {
+  TEdge *e = m_ActiveEdges;
+  while (e) {
+    // 1. process maxima, treating them as if they're 'bent' horizontal edges,
+    //   but exclude maxima with horizontal edges. nb: e can't be a horizontal.
+    bool IsMaximaEdge = IsMaxima(e, topY);
+
+    if (IsMaximaEdge) {
+      TEdge *eMaxPair = GetMaximaPairEx(e);
+      IsMaximaEdge = (!eMaxPair || !IsHorizontal(*eMaxPair));
+    }
+
+    if (IsMaximaEdge) {
+      if (m_StrictSimple)
+        m_Maxima.emplace_back(e->Top.X);
+      TEdge *ePrev = e->PrevInAEL;
+      DoMaxima(e);
+      if (!ePrev)
+        e = m_ActiveEdges;
+      else
+        e = ePrev->NextInAEL;
+    } else {
+      // 2. promote horizontal edges, otherwise update Curr.X and Curr.Y ...
+      if (IsIntermediate(e, topY) && IsHorizontal(*e->NextInLML)) {
+        UpdateEdgeIntoAEL(e);
+        if (e->OutIdx >= 0)
+          AddOutPt(e, e->Bot);
+        AddEdgeToSEL(e);
+      } else {
+        e->Curr.X = TopX(*e, topY);
+        e->Curr.Y = topY;
+#ifdef use_xyz
+        e->Curr.Z =
+            topY == e->Top.Y ? e->Top.Z : (topY == e->Bot.Y ? e->Bot.Z : 0);
+#endif
+      }
+
+      // When StrictlySimple and 'e' is being touched by another edge, then
+      // make sure both edges have a vertex here ...
+      if (m_StrictSimple) {
+        TEdge *ePrev = e->PrevInAEL;
+        if ((e->OutIdx >= 0) && (e->WindDelta != 0) && ePrev &&
+            (ePrev->OutIdx >= 0) && (ePrev->Curr.X == e->Curr.X) &&
+            (ePrev->WindDelta != 0)) {
+          IntPoint pt = e->Curr;
+#ifdef use_xyz
+          SetZ(pt, *ePrev, *e);
+#endif
+          OutPt *op = AddOutPt(ePrev, pt);
+          OutPt *op2 = AddOutPt(e, pt);
+          AddJoin(op, op2, pt); // StrictlySimple (type-3) join
+        }
+      }
+
+      e = e->NextInAEL;
+    }
+  }
+
+  // 3. Process horizontals at the Top of the scanbeam ...
+  m_Maxima.sort();
+  ProcessHorizontals();
+  m_Maxima.clear();
+
+  // 4. Promote intermediate vertices ...
+  e = m_ActiveEdges;
+  while (e) {
+    if (IsIntermediate(e, topY)) {
+      OutPt *op = 0;
+      if (e->OutIdx >= 0)
+        op = AddOutPt(e, e->Top);
+      UpdateEdgeIntoAEL(e);
+
+      // if output polygons share an edge, they'll need joining later ...
+      TEdge *ePrev = e->PrevInAEL;
+      TEdge *eNext = e->NextInAEL;
+      if (ePrev && ePrev->Curr.X == e->Bot.X && ePrev->Curr.Y == e->Bot.Y &&
+          op && ePrev->OutIdx >= 0 && ePrev->Curr.Y > ePrev->Top.Y &&
+          SlopesEqual(e->Curr, e->Top, ePrev->Curr, ePrev->Top,
+                      m_UseFullRange) &&
+          (e->WindDelta != 0) && (ePrev->WindDelta != 0)) {
+        OutPt *op2 = AddOutPt(ePrev, e->Bot);
+        AddJoin(op, op2, e->Top);
+      } else if (eNext && eNext->Curr.X == e->Bot.X &&
+                 eNext->Curr.Y == e->Bot.Y && op && eNext->OutIdx >= 0 &&
+                 eNext->Curr.Y > eNext->Top.Y &&
+                 SlopesEqual(e->Curr, e->Top, eNext->Curr, eNext->Top,
+                             m_UseFullRange) &&
+                 (e->WindDelta != 0) && (eNext->WindDelta != 0)) {
+        OutPt *op2 = AddOutPt(eNext, e->Bot);
+        AddJoin(op, op2, e->Top);
+      }
+    }
+    e = e->NextInAEL;
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::FixupOutPolyline(OutRec &outrec) noexcept {
+  OutPt *pp = outrec.Pts;
+  OutPt *lastPP = pp->Prev;
+  while (pp != lastPP) {
+    pp = pp->Next;
+    if (pp->Pt == pp->Prev->Pt) {
+      if (pp == lastPP)
+        lastPP = pp->Prev;
+      OutPt *tmpPP = pp->Prev;
+      tmpPP->Next = pp->Next;
+      pp->Next->Prev = tmpPP;
+      delete pp;
+      pp = tmpPP;
+    }
+  }
+
+  if (pp == pp->Prev) {
+    DisposeOutPts(pp);
+    outrec.Pts = 0;
+    return;
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::FixupOutPolygon(OutRec &outrec) noexcept {
+  // FixupOutPolygon() - removes duplicate points and simplifies consecutive
+  // parallel edges by removing the middle vertex.
+  OutPt *lastOK = 0;
+  outrec.BottomPt = 0;
+  OutPt *pp = outrec.Pts;
+  bool preserveCol = m_PreserveCollinear || m_StrictSimple;
+
+  for (;;) {
+    if (pp->Prev == pp || pp->Prev == pp->Next) {
+      DisposeOutPts(pp);
+      outrec.Pts = 0;
+      return;
+    }
+
+    // test for duplicate points and collinear edges ...
+    if ((pp->Pt == pp->Next->Pt) || (pp->Pt == pp->Prev->Pt) ||
+        (SlopesEqual(pp->Prev->Pt, pp->Pt, pp->Next->Pt, m_UseFullRange) &&
+         (!preserveCol ||
+          !Pt2IsBetweenPt1AndPt3(pp->Prev->Pt, pp->Pt, pp->Next->Pt)))) {
+      lastOK = 0;
+      OutPt *tmp = pp;
+      pp->Prev->Next = pp->Next;
+      pp->Next->Prev = pp->Prev;
+      pp = pp->Prev;
+      delete tmp;
+    } else if (pp == lastOK)
+      break;
+    else {
+      if (!lastOK)
+        lastOK = pp;
+      pp = pp->Next;
+    }
+  }
+  outrec.Pts = pp;
+}
+//------------------------------------------------------------------------------
+
+int PointCount(OutPt *Pts) noexcept {
+  if (!Pts)
+    return 0;
+  int result = 0;
+  OutPt *p = Pts;
+  do {
+    result++;
+    p = p->Next;
+  } while (p != Pts);
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::BuildResult(Paths &polys) noexcept {
+  polys.reserve(m_PolyOuts.size());
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    if (!m_PolyOuts[i]->Pts)
+      continue;
+    Path pg;
+    OutPt *p = m_PolyOuts[i]->Pts->Prev;
+    int cnt = PointCount(p);
+    if (cnt < 2)
+      continue;
+    pg.reserve(cnt);
+    for (int i = 0; i < cnt; ++i) {
+      pg.emplace_back(p->Pt);
+      p = p->Prev;
+    }
+    polys.emplace_back(pg);
+  }
+}
+//------------------------------------------------------------------------------
+
+void Clipper::BuildResult2(PolyTree &polytree) noexcept {
+  polytree.Clear();
+  polytree.AllNodes.reserve(m_PolyOuts.size());
+  // add each output polygon/contour to polytree ...
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    OutRec *outRec = m_PolyOuts[i];
+    int cnt = PointCount(outRec->Pts);
+    if ((outRec->IsOpen && cnt < 2) || (!outRec->IsOpen && cnt < 3))
+      continue;
+    FixHoleLinkage(*outRec);
+    PolyNode *pn = new PolyNode();
+    // nb: polytree takes ownership of all the PolyNodes
+    polytree.AllNodes.emplace_back(pn);
+    outRec->PolyNd = pn;
+    pn->Parent = 0;
+    pn->Index = 0;
+    pn->Contour.reserve(cnt);
+    OutPt *op = outRec->Pts->Prev;
+    for (int j = 0; j < cnt; ++j) {
+      pn->Contour.emplace_back(op->Pt);
+      op = op->Prev;
+    }
+  }
+
+  // fixup PolyNode links etc ...
+  polytree.Children.reserve(m_PolyOuts.size());
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    OutRec *outRec = m_PolyOuts[i];
+    if (!outRec->PolyNd)
+      continue;
+    if (outRec->IsOpen) {
+      outRec->PolyNd->m_IsOpen = true;
+      polytree.AddChild(*outRec->PolyNd);
+    } else if (outRec->FirstLeft && outRec->FirstLeft->PolyNd)
+      outRec->FirstLeft->PolyNd->AddChild(*outRec->PolyNd);
+    else
+      polytree.AddChild(*outRec->PolyNd);
+  }
+}
+//------------------------------------------------------------------------------
+
+void SwapIntersectNodes(IntersectNode &int1, IntersectNode &int2) noexcept {
+  // just swap the contents (because fIntersectNodes is a single-linked-list)
+  IntersectNode inode = int1; // gets a copy of Int1
+  int1.Edge1 = int2.Edge1;
+  int1.Edge2 = int2.Edge2;
+  int1.Pt = int2.Pt;
+  int2.Edge1 = inode.Edge1;
+  int2.Edge2 = inode.Edge2;
+  int2.Pt = inode.Pt;
+}
+//------------------------------------------------------------------------------
+
+inline bool E2InsertsBeforeE1(TEdge &e1, TEdge &e2) noexcept {
+  if (e2.Curr.X == e1.Curr.X) {
+    if (e2.Top.Y > e1.Top.Y)
+      return e2.Top.X < TopX(e1, e2.Top.Y);
+    else
+      return e1.Top.X > TopX(e2, e1.Top.Y);
+  } else
+    return e2.Curr.X < e1.Curr.X;
+}
+//------------------------------------------------------------------------------
+
+bool GetOverlap(const cInt a1, const cInt a2, const cInt b1, const cInt b2,
+                cInt &Left, cInt &Right) noexcept {
+  if (a1 < a2) {
+    if (b1 < b2) {
+      Left = std::max(a1, b1);
+      Right = std::min(a2, b2);
+    } else {
+      Left = std::max(a1, b2);
+      Right = std::min(a2, b1);
+    }
+  } else {
+    if (b1 < b2) {
+      Left = std::max(a2, b1);
+      Right = std::min(a1, b2);
+    } else {
+      Left = std::max(a2, b2);
+      Right = std::min(a1, b1);
+    }
+  }
+  return Left < Right;
+}
+//------------------------------------------------------------------------------
+
+inline void UpdateOutPtIdxs(OutRec &outrec) noexcept {
+  OutPt *op = outrec.Pts;
+  do {
+    op->Idx = outrec.Idx;
+    op = op->Prev;
+  } while (op != outrec.Pts);
+}
+//------------------------------------------------------------------------------
+
+void Clipper::InsertEdgeIntoAEL(TEdge *edge, TEdge *startEdge) noexcept {
+  if (!m_ActiveEdges) {
+    edge->PrevInAEL = 0;
+    edge->NextInAEL = 0;
+    m_ActiveEdges = edge;
+  } else if (!startEdge && E2InsertsBeforeE1(*m_ActiveEdges, *edge)) {
+    edge->PrevInAEL = 0;
+    edge->NextInAEL = m_ActiveEdges;
+    m_ActiveEdges->PrevInAEL = edge;
+    m_ActiveEdges = edge;
+  } else {
+    if (!startEdge)
+      startEdge = m_ActiveEdges;
+    while (startEdge->NextInAEL &&
+           !E2InsertsBeforeE1(*startEdge->NextInAEL, *edge))
+      startEdge = startEdge->NextInAEL;
+    edge->NextInAEL = startEdge->NextInAEL;
+    if (startEdge->NextInAEL)
+      startEdge->NextInAEL->PrevInAEL = edge;
+    edge->PrevInAEL = startEdge;
+    startEdge->NextInAEL = edge;
+  }
+}
+//----------------------------------------------------------------------
+
+OutPt *DupOutPt(OutPt *outPt, bool InsertAfter) noexcept {
+  OutPt *result = new OutPt;
+  result->Pt = outPt->Pt;
+  result->Idx = outPt->Idx;
+  if (InsertAfter) {
+    result->Next = outPt->Next;
+    result->Prev = outPt;
+    outPt->Next->Prev = result;
+    outPt->Next = result;
+  } else {
+    result->Prev = outPt->Prev;
+    result->Next = outPt;
+    outPt->Prev->Next = result;
+    outPt->Prev = result;
+  }
+  return result;
+}
+//------------------------------------------------------------------------------
+
+bool JoinHorz(OutPt *op1, OutPt *op1b, OutPt *op2, OutPt *op2b,
+              const IntPoint Pt, bool DiscardLeft) noexcept {
+  Direction Dir1 = (op1->Pt.X > op1b->Pt.X ? dRightToLeft : dLeftToRight);
+  Direction Dir2 = (op2->Pt.X > op2b->Pt.X ? dRightToLeft : dLeftToRight);
+  if (Dir1 == Dir2)
+    return false;
+
+  // When DiscardLeft, we want Op1b to be on the Left of Op1, otherwise we
+  // want Op1b to be on the Right. (And likewise with Op2 and Op2b.)
+  // So, to facilitate this while inserting Op1b and Op2b ...
+  // when DiscardLeft, make sure we're AT or RIGHT of Pt before adding Op1b,
+  // otherwise make sure we're AT or LEFT of Pt. (Likewise with Op2b.)
+  if (Dir1 == dLeftToRight) {
+    while (op1->Next->Pt.X <= Pt.X && op1->Next->Pt.X >= op1->Pt.X &&
+           op1->Next->Pt.Y == Pt.Y)
+      op1 = op1->Next;
+    if (DiscardLeft && (op1->Pt.X != Pt.X))
+      op1 = op1->Next;
+    op1b = DupOutPt(op1, !DiscardLeft);
+    if (op1b->Pt != Pt) {
+      op1 = op1b;
+      op1->Pt = Pt;
+      op1b = DupOutPt(op1, !DiscardLeft);
+    }
+  } else {
+    while (op1->Next->Pt.X >= Pt.X && op1->Next->Pt.X <= op1->Pt.X &&
+           op1->Next->Pt.Y == Pt.Y)
+      op1 = op1->Next;
+    if (!DiscardLeft && (op1->Pt.X != Pt.X))
+      op1 = op1->Next;
+    op1b = DupOutPt(op1, DiscardLeft);
+    if (op1b->Pt != Pt) {
+      op1 = op1b;
+      op1->Pt = Pt;
+      op1b = DupOutPt(op1, DiscardLeft);
+    }
+  }
+
+  if (Dir2 == dLeftToRight) {
+    while (op2->Next->Pt.X <= Pt.X && op2->Next->Pt.X >= op2->Pt.X &&
+           op2->Next->Pt.Y == Pt.Y)
+      op2 = op2->Next;
+    if (DiscardLeft && (op2->Pt.X != Pt.X))
+      op2 = op2->Next;
+    op2b = DupOutPt(op2, !DiscardLeft);
+    if (op2b->Pt != Pt) {
+      op2 = op2b;
+      op2->Pt = Pt;
+      op2b = DupOutPt(op2, !DiscardLeft);
+    };
+  } else {
+    while (op2->Next->Pt.X >= Pt.X && op2->Next->Pt.X <= op2->Pt.X &&
+           op2->Next->Pt.Y == Pt.Y)
+      op2 = op2->Next;
+    if (!DiscardLeft && (op2->Pt.X != Pt.X))
+      op2 = op2->Next;
+    op2b = DupOutPt(op2, DiscardLeft);
+    if (op2b->Pt != Pt) {
+      op2 = op2b;
+      op2->Pt = Pt;
+      op2b = DupOutPt(op2, DiscardLeft);
+    };
+  };
+
+  if ((Dir1 == dLeftToRight) == DiscardLeft) {
+    op1->Prev = op2;
+    op2->Next = op1;
+    op1b->Next = op2b;
+    op2b->Prev = op1b;
+  } else {
+    op1->Next = op2;
+    op2->Prev = op1;
+    op1b->Prev = op2b;
+    op2b->Next = op1b;
+  }
+  return true;
+}
+//------------------------------------------------------------------------------
+
+bool Clipper::JoinPoints(Join *j, OutRec *outRec1, OutRec *outRec2) noexcept {
+  OutPt *op1 = j->OutPt1, *op1b;
+  OutPt *op2 = j->OutPt2, *op2b;
+
+  // There are 3 kinds of joins for output polygons ...
+  // 1. Horizontal joins where Join.OutPt1 & Join.OutPt2 are vertices anywhere
+  // along (horizontal) collinear edges (& Join.OffPt is on the same
+  // horizontal).
+  // 2. Non-horizontal joins where Join.OutPt1 & Join.OutPt2 are at the same
+  // location at the Bottom of the overlapping segment (& Join.OffPt is above).
+  // 3. StrictSimple joins where edges touch but are not collinear and where
+  // Join.OutPt1, Join.OutPt2 & Join.OffPt all share the same point.
+  bool isHorizontal = (j->OutPt1->Pt.Y == j->OffPt.Y);
+
+  if (isHorizontal && (j->OffPt == j->OutPt1->Pt) &&
+      (j->OffPt == j->OutPt2->Pt)) {
+    // Strictly Simple join ...
+    if (outRec1 != outRec2)
+      return false;
+    op1b = j->OutPt1->Next;
+    while (op1b != op1 && (op1b->Pt == j->OffPt))
+      op1b = op1b->Next;
+    bool reverse1 = (op1b->Pt.Y > j->OffPt.Y);
+    op2b = j->OutPt2->Next;
+    while (op2b != op2 && (op2b->Pt == j->OffPt))
+      op2b = op2b->Next;
+    bool reverse2 = (op2b->Pt.Y > j->OffPt.Y);
+    if (reverse1 == reverse2)
+      return false;
+    if (reverse1) {
+      op1b = DupOutPt(op1, false);
+      op2b = DupOutPt(op2, true);
+      op1->Prev = op2;
+      op2->Next = op1;
+      op1b->Next = op2b;
+      op2b->Prev = op1b;
+      j->OutPt1 = op1;
+      j->OutPt2 = op1b;
+      return true;
+    } else {
+      op1b = DupOutPt(op1, true);
+      op2b = DupOutPt(op2, false);
+      op1->Next = op2;
+      op2->Prev = op1;
+      op1b->Prev = op2b;
+      op2b->Next = op1b;
+      j->OutPt1 = op1;
+      j->OutPt2 = op1b;
+      return true;
+    }
+  } else if (isHorizontal) {
+    // treat horizontal joins differently to non-horizontal joins since with
+    // them we're not yet sure where the overlapping is. OutPt1.Pt & OutPt2.Pt
+    // may be anywhere along the horizontal edge.
+    op1b = op1;
+    while (op1->Prev->Pt.Y == op1->Pt.Y && op1->Prev != op1b &&
+           op1->Prev != op2)
+      op1 = op1->Prev;
+    while (op1b->Next->Pt.Y == op1b->Pt.Y && op1b->Next != op1 &&
+           op1b->Next != op2)
+      op1b = op1b->Next;
+    if (op1b->Next == op1 || op1b->Next == op2)
+      return false; // a flat 'polygon'
+
+    op2b = op2;
+    while (op2->Prev->Pt.Y == op2->Pt.Y && op2->Prev != op2b &&
+           op2->Prev != op1b)
+      op2 = op2->Prev;
+    while (op2b->Next->Pt.Y == op2b->Pt.Y && op2b->Next != op2 &&
+           op2b->Next != op1)
+      op2b = op2b->Next;
+    if (op2b->Next == op2 || op2b->Next == op1)
+      return false; // a flat 'polygon'
+
+    cInt Left, Right;
+    // Op1 --> Op1b & Op2 --> Op2b are the extremites of the horizontal edges
+    if (!GetOverlap(op1->Pt.X, op1b->Pt.X, op2->Pt.X, op2b->Pt.X, Left, Right))
+      return false;
+
+    // DiscardLeftSide: when overlapping edges are joined, a spike will created
+    // which needs to be cleaned up. However, we don't want Op1 or Op2 caught up
+    // on the discard Side as either may still be needed for other joins ...
+    IntPoint Pt;
+    bool DiscardLeftSide;
+    if (op1->Pt.X >= Left && op1->Pt.X <= Right) {
+      Pt = op1->Pt;
+      DiscardLeftSide = (op1->Pt.X > op1b->Pt.X);
+    } else if (op2->Pt.X >= Left && op2->Pt.X <= Right) {
+      Pt = op2->Pt;
+      DiscardLeftSide = (op2->Pt.X > op2b->Pt.X);
+    } else if (op1b->Pt.X >= Left && op1b->Pt.X <= Right) {
+      Pt = op1b->Pt;
+      DiscardLeftSide = op1b->Pt.X > op1->Pt.X;
+    } else {
+      Pt = op2b->Pt;
+      DiscardLeftSide = (op2b->Pt.X > op2->Pt.X);
+    }
+    j->OutPt1 = op1;
+    j->OutPt2 = op2;
+    return JoinHorz(op1, op1b, op2, op2b, Pt, DiscardLeftSide);
+  } else {
+    // nb: For non-horizontal joins ...
+    //    1. Jr.OutPt1.Pt.Y == Jr.OutPt2.Pt.Y
+    //    2. Jr.OutPt1.Pt > Jr.OffPt.Y
+
+    // make sure the polygons are correctly oriented ...
+    op1b = op1->Next;
+    while ((op1b->Pt == op1->Pt) && (op1b != op1))
+      op1b = op1b->Next;
+    bool Reverse1 = ((op1b->Pt.Y > op1->Pt.Y) ||
+                     !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange));
+    if (Reverse1) {
+      op1b = op1->Prev;
+      while ((op1b->Pt == op1->Pt) && (op1b != op1))
+        op1b = op1b->Prev;
+      if ((op1b->Pt.Y > op1->Pt.Y) ||
+          !SlopesEqual(op1->Pt, op1b->Pt, j->OffPt, m_UseFullRange))
+        return false;
+    };
+    op2b = op2->Next;
+    while ((op2b->Pt == op2->Pt) && (op2b != op2))
+      op2b = op2b->Next;
+    bool Reverse2 = ((op2b->Pt.Y > op2->Pt.Y) ||
+                     !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange));
+    if (Reverse2) {
+      op2b = op2->Prev;
+      while ((op2b->Pt == op2->Pt) && (op2b != op2))
+        op2b = op2b->Prev;
+      if ((op2b->Pt.Y > op2->Pt.Y) ||
+          !SlopesEqual(op2->Pt, op2b->Pt, j->OffPt, m_UseFullRange))
+        return false;
+    }
+
+    if ((op1b == op1) || (op2b == op2) || (op1b == op2b) ||
+        ((outRec1 == outRec2) && (Reverse1 == Reverse2)))
+      return false;
+
+    if (Reverse1) {
+      op1b = DupOutPt(op1, false);
+      op2b = DupOutPt(op2, true);
+      op1->Prev = op2;
+      op2->Next = op1;
+      op1b->Next = op2b;
+      op2b->Prev = op1b;
+      j->OutPt1 = op1;
+      j->OutPt2 = op1b;
+      return true;
+    } else {
+      op1b = DupOutPt(op1, true);
+      op2b = DupOutPt(op2, false);
+      op1->Next = op2;
+      op2->Prev = op1;
+      op1b->Prev = op2b;
+      op2b->Next = op1b;
+      j->OutPt1 = op1;
+      j->OutPt2 = op1b;
+      return true;
+    }
+  }
+}
+//----------------------------------------------------------------------
+
+static OutRec *ParseFirstLeft(OutRec *FirstLeft) noexcept {
+  while (FirstLeft && !FirstLeft->Pts)
+    FirstLeft = FirstLeft->FirstLeft;
+  return FirstLeft;
+}
+//------------------------------------------------------------------------------
+
+void Clipper::FixupFirstLefts1(OutRec *OldOutRec, OutRec *NewOutRec) noexcept {
+  // tests if NewOutRec contains the polygon before reassigning FirstLeft
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    OutRec *outRec = m_PolyOuts[i];
+    OutRec *firstLeft = ParseFirstLeft(outRec->FirstLeft);
+    if (outRec->Pts && firstLeft == OldOutRec) {
+      if (Poly2ContainsPoly1(outRec->Pts, NewOutRec->Pts))
+        outRec->FirstLeft = NewOutRec;
+    }
+  }
+}
+//----------------------------------------------------------------------
+
+void Clipper::FixupFirstLefts2(OutRec *InnerOutRec,
+                               OutRec *OuterOutRec) noexcept {
+  // A polygon has split into two such that one is now the inner of the other.
+  // It's possible that these polygons now wrap around other polygons, so check
+  // every polygon that's also contained by OuterOutRec's FirstLeft container
+  //(including 0) to see if they've become inner to the new inner polygon ...
+  OutRec *orfl = OuterOutRec->FirstLeft;
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    OutRec *outRec = m_PolyOuts[i];
+
+    if (!outRec->Pts || outRec == OuterOutRec || outRec == InnerOutRec)
+      continue;
+    OutRec *firstLeft = ParseFirstLeft(outRec->FirstLeft);
+    if (firstLeft != orfl && firstLeft != InnerOutRec &&
+        firstLeft != OuterOutRec)
+      continue;
+    if (Poly2ContainsPoly1(outRec->Pts, InnerOutRec->Pts))
+      outRec->FirstLeft = InnerOutRec;
+    else if (Poly2ContainsPoly1(outRec->Pts, OuterOutRec->Pts))
+      outRec->FirstLeft = OuterOutRec;
+    else if (outRec->FirstLeft == InnerOutRec ||
+             outRec->FirstLeft == OuterOutRec)
+      outRec->FirstLeft = orfl;
+  }
+}
+//----------------------------------------------------------------------
+void Clipper::FixupFirstLefts3(OutRec *OldOutRec, OutRec *NewOutRec) noexcept {
+  // reassigns FirstLeft WITHOUT testing if NewOutRec contains the polygon
+  for (PolyOutList::size_type i = 0; i < m_PolyOuts.size(); ++i) {
+    OutRec *outRec = m_PolyOuts[i];
+    OutRec *firstLeft = ParseFirstLeft(outRec->FirstLeft);
+    if (outRec->Pts && firstLeft == OldOutRec)
+      outRec->FirstLeft = NewOutRec;
+  }
+}
+//----------------------------------------------------------------------
+
+void Clipper::JoinCommonEdges() noexcept {
+  for (JoinList::size_type i = 0; i < m_Joins.size(); ++i) {
+    Join *join = m_Joins[i];
+
+    OutRec *outRec1 = GetOutRec(join->OutPt1->Idx);
+    OutRec *outRec2 = GetOutRec(join->OutPt2->Idx);
+
+    if (!outRec1->Pts || !outRec2->Pts)
+      continue;
+    if (outRec1->IsOpen || outRec2->IsOpen)
+      continue;
+
+    // get the polygon fragment with the correct hole state (FirstLeft)
+    // before calling JoinPoints() ...
+    OutRec *holeStateRec;
+    if (outRec1 == outRec2)
+      holeStateRec = outRec1;
+    else if (OutRec1RightOfOutRec2(outRec1, outRec2))
+      holeStateRec = outRec2;
+    else if (OutRec1RightOfOutRec2(outRec2, outRec1))
+      holeStateRec = outRec1;
+    else
+      holeStateRec = GetLowermostRec(outRec1, outRec2);
+
+    if (!JoinPoints(join, outRec1, outRec2))
+      continue;
+
+    if (outRec1 == outRec2) {
+      // instead of joining two polygons, we've just created a new one by
+      // splitting one polygon into two.
+      outRec1->Pts = join->OutPt1;
+      outRec1->BottomPt = 0;
+      outRec2 = CreateOutRec();
+      outRec2->Pts = join->OutPt2;
+
+      // update all OutRec2.Pts Idx's ...
+      UpdateOutPtIdxs(*outRec2);
+
+      if (Poly2ContainsPoly1(outRec2->Pts, outRec1->Pts)) {
+        // outRec1 contains outRec2 ...
+        outRec2->IsHole = !outRec1->IsHole;
+        outRec2->FirstLeft = outRec1;
+
+        if (m_UsingPolyTree)
+          FixupFirstLefts2(outRec2, outRec1);
+
+        if ((outRec2->IsHole ^ m_ReverseOutput) == (Area(*outRec2) > 0))
+          ReversePolyPtLinks(outRec2->Pts);
+
+      } else if (Poly2ContainsPoly1(outRec1->Pts, outRec2->Pts)) {
+        // outRec2 contains outRec1 ...
+        outRec2->IsHole = outRec1->IsHole;
+        outRec1->IsHole = !outRec2->IsHole;
+        outRec2->FirstLeft = outRec1->FirstLeft;
+        outRec1->FirstLeft = outRec2;
+
+        if (m_UsingPolyTree)
+          FixupFirstLefts2(outRec1, outRec2);
+
+        if ((outRec1->IsHole ^ m_ReverseOutput) == (Area(*outRec1) > 0))
+          ReversePolyPtLinks(outRec1->Pts);
+      } else {
+        // the 2 polygons are completely separate ...
+        outRec2->IsHole = outRec1->IsHole;
+        outRec2->FirstLeft = outRec1->FirstLeft;
+
+        // fixup FirstLeft pointers that may need reassigning to OutRec2
+        if (m_UsingPolyTree)
+          FixupFirstLefts1(outRec1, outRec2);
+      }
+
+    } else {
+      // joined 2 polygons together ...
+
+      outRec2->Pts = 0;
+      outRec2->BottomPt = 0;
+      outRec2->Idx = outRec1->Idx;
+
+      outRec1->IsHole = holeStateRec->IsHole;
+      if (holeStateRec == outRec2)
+        outRec1->FirstLeft = outRec2->FirstLeft;
+      outRec2->FirstLeft = outRec1;
+
+      if (m_UsingPolyTree)
+        FixupFirstLefts3(outRec2, outRec1);
+    }
+  }
+}
+
+//------------------------------------------------------------------------------
+// ClipperOffset support functions ...
+//------------------------------------------------------------------------------
+
+DoublePoint GetUnitNormal(const IntPoint &pt1, const IntPoint &pt2) noexcept {
+  if (pt2.X == pt1.X && pt2.Y == pt1.Y)
+    return DoublePoint(0, 0);
+
+  double Dx = (double)(pt2.X - pt1.X);
+  double dy = (double)(pt2.Y - pt1.Y);
+  double f = 1 * 1.0 / std::sqrt(Dx * Dx + dy * dy);
+  Dx *= f;
+  dy *= f;
+  return DoublePoint(dy, -Dx);
+}
+
+//------------------------------------------------------------------------------
+// ClipperOffset class
+//------------------------------------------------------------------------------
+
+ClipperOffset::ClipperOffset(double miterLimit, double arcTolerance) noexcept {
+  this->MiterLimit = miterLimit;
+  this->ArcTolerance = arcTolerance;
+  m_lowest.X = -1;
+}
+//------------------------------------------------------------------------------
+
+ClipperOffset::~ClipperOffset() { Clear(); }
+//------------------------------------------------------------------------------
+
+void ClipperOffset::Clear() noexcept {
+  for (int i = 0; i < m_polyNodes.ChildCount(); ++i)
+    delete m_polyNodes.Children[i];
+  m_polyNodes.Children.clear();
+  m_lowest.X = -1;
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::AddPath(const Path &path, JoinType joinType,
+                            EndType endType) noexcept {
+  int highI = (int)path.size() - 1;
+  if (highI < 0)
+    return;
+  PolyNode *newNode = new PolyNode();
+  newNode->m_jointype = joinType;
+  newNode->m_endtype = endType;
+
+  // strip duplicate points from path and also get index to the lowest point ...
+  if (endType == etClosedLine || endType == etClosedPolygon)
+    while (highI > 0 && path[0] == path[highI])
+      highI--;
+  newNode->Contour.reserve(highI + 1);
+  newNode->Contour.emplace_back(path[0]);
+  int j = 0, k = 0;
+  for (int i = 1; i <= highI; ++i)
+    if (newNode->Contour[j] != path[i]) {
+      ++j;
+      newNode->Contour.emplace_back(path[i]);
+      if (path[i].Y > newNode->Contour[k].Y ||
+          (path[i].Y == newNode->Contour[k].Y &&
+           path[i].X < newNode->Contour[k].X))
+        k = j;
+    }
+  if (endType == etClosedPolygon && j < 2) {
+    delete newNode;
+    return;
+  }
+  m_polyNodes.AddChild(*newNode);
+
+  // if this path's lowest pt is lower than all the others then update m_lowest
+  if (endType != etClosedPolygon)
+    return;
+  if (m_lowest.X < 0)
+    m_lowest.reset(m_polyNodes.ChildCount() - 1, k);
+  else {
+    IntPoint ip =
+        m_polyNodes.Children[(int)m_lowest.X]->Contour[(int)m_lowest.Y];
+    if (newNode->Contour[k].Y > ip.Y ||
+        (newNode->Contour[k].Y == ip.Y && newNode->Contour[k].X < ip.X))
+      m_lowest.reset(m_polyNodes.ChildCount() - 1, k);
+  }
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::AddPaths(const Paths &paths, JoinType joinType,
+                             EndType endType) noexcept {
+  for (Paths::size_type i = 0; i < paths.size(); ++i)
+    AddPath(paths[i], joinType, endType);
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::FixOrientations() noexcept {
+  // fixup orientations of all closed paths if the orientation of the
+  // closed path with the lowermost vertex is wrong ...
+  if (m_lowest.X >= 0 &&
+      !Orientation(m_polyNodes.Children[(int)m_lowest.X]->Contour)) {
+    for (int i = 0; i < m_polyNodes.ChildCount(); ++i) {
+      PolyNode &node = *m_polyNodes.Children[i];
+      if (node.m_endtype == etClosedPolygon ||
+          (node.m_endtype == etClosedLine && Orientation(node.Contour)))
+        ReversePath(node.Contour);
+    }
+  } else {
+    for (int i = 0; i < m_polyNodes.ChildCount(); ++i) {
+      PolyNode &node = *m_polyNodes.Children[i];
+      if (node.m_endtype == etClosedLine && !Orientation(node.Contour))
+        ReversePath(node.Contour);
+    }
+  }
+}
+//------------------------------------------------------------------------------
+
+bool ClipperOffset::Execute(Paths &solution, double delta) noexcept {
+  solution.clear();
+  FixOrientations();
+  DoOffset(delta);
+
+  try {
+    // now clean up 'corners' ...
+    Clipper clpr;
+    clpr.AddPaths(m_destPolys, ptSubject, true);
+    if (delta > 0) {
+      clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
+    } else {
+      IntRect r = clpr.GetBounds();
+      Path outer(4);
+      outer[0].reset(r.left - 10, r.bottom + 10);
+      outer[1].reset(r.right + 10, r.bottom + 10);
+      outer[2].reset(r.right + 10, r.top - 10);
+      outer[3].reset(r.left - 10, r.top - 10);
+
+      clpr.AddPath(outer, ptSubject, true);
+      clpr.ReverseSolution(true);
+      clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
+      if (solution.size() > 0)
+        solution.erase(solution.begin());
+    }
+    return true;
+  } catch (std::exception &e) {
+    fprintf(stderr, "%s\n", e.what());
+    fflush(stderr);
+    return false;
+  }
+}
+//------------------------------------------------------------------------------
+
+bool ClipperOffset::Execute(PolyTree &solution, double delta) noexcept {
+  solution.Clear();
+  FixOrientations();
+  DoOffset(delta);
+
+  try {
+    // now clean up 'corners' ...
+    Clipper clpr;
+    clpr.AddPaths(m_destPolys, ptSubject, true);
+    if (delta > 0) {
+      clpr.Execute(ctUnion, solution, pftPositive, pftPositive);
+    } else {
+      IntRect r = clpr.GetBounds();
+      Path outer(4);
+      outer[0].reset(r.left - 10, r.bottom + 10);
+      outer[1].reset(r.right + 10, r.bottom + 10);
+      outer[2].reset(r.right + 10, r.top - 10);
+      outer[3].reset(r.left - 10, r.top - 10);
+
+      clpr.AddPath(outer, ptSubject, true);
+      clpr.ReverseSolution(true);
+      clpr.Execute(ctUnion, solution, pftNegative, pftNegative);
+      // remove the outer PolyNode rectangle ...
+      if (solution.ChildCount() == 1 &&
+          solution.Children[0]->ChildCount() > 0) {
+        PolyNode *outerNode = solution.Children[0];
+        solution.Children.reserve(outerNode->ChildCount());
+        solution.Children[0] = outerNode->Children[0];
+        solution.Children[0]->Parent = outerNode->Parent;
+        for (int i = 1; i < outerNode->ChildCount(); ++i)
+          solution.AddChild(*outerNode->Children[i]);
+      } else
+        solution.Clear();
+    }
+    return true;
+  } catch (std::exception &e) {
+    fprintf(stderr, "%s\n", e.what());
+    fflush(stderr);
+    return false;
+  }
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::DoOffset(double delta) noexcept {
+  m_destPolys.clear();
+  m_delta = delta;
+
+  // if Zero offset, just copy any CLOSED polygons to m_p and return ...
+  if (NEAR_ZERO(delta)) {
+    m_destPolys.reserve(m_polyNodes.ChildCount());
+    for (int i = 0; i < m_polyNodes.ChildCount(); ++i) {
+      PolyNode &node = *m_polyNodes.Children[i];
+      if (node.m_endtype == etClosedPolygon)
+        m_destPolys.emplace_back(node.Contour);
+    }
+    return;
+  }
+
+  // see offset_triginometry3.svg in the documentation folder ...
+  if (MiterLimit > 2)
+    m_miterLim = 2 / (MiterLimit * MiterLimit);
+  else
+    m_miterLim = 0.5;
+
+  double y;
+  if (ArcTolerance <= 0.0)
+    y = def_arc_tolerance;
+  else if (ArcTolerance > std::fabs(delta) * def_arc_tolerance)
+    y = std::fabs(delta) * def_arc_tolerance;
+  else
+    y = ArcTolerance;
+  // see offset_triginometry2.svg in the documentation folder ...
+  double steps = pi / std::acos(1 - y / std::fabs(delta));
+  if (steps > std::fabs(delta) * pi)
+    steps = std::fabs(delta) * pi; // ie excessive precision check
+  m_sin = std::sin(two_pi / steps);
+  m_cos = std::cos(two_pi / steps);
+  m_StepsPerRad = steps / two_pi;
+  if (delta < 0.0)
+    m_sin = -m_sin;
+
+  m_destPolys.reserve(m_polyNodes.ChildCount() * 2);
+  for (int i = 0; i < m_polyNodes.ChildCount(); ++i) {
+    PolyNode &node = *m_polyNodes.Children[i];
+    m_srcPoly = node.Contour;
+
+    int len = (int)m_srcPoly.size();
+    if (len == 0 ||
+        (delta <= 0 && (len < 3 || node.m_endtype != etClosedPolygon)))
+      continue;
+
+    m_destPoly.clear();
+    if (len == 1) {
+      if (node.m_jointype == jtRound) {
+        double X = 1.0, Y = 0.0;
+        for (cInt j = 1; j <= steps; ++j) {
+          m_destPoly.emplace_back(Round(m_srcPoly[0].X + X * delta),
+                                  Round(m_srcPoly[0].Y + Y * delta));
+          double X2 = X;
+          X = X * m_cos - m_sin * Y;
+          Y = X2 * m_sin + Y * m_cos;
+        }
+      } else {
+        double X = -1.0, Y = -1.0;
+        for (int j = 0; j < 4; ++j) {
+          m_destPoly.emplace_back(Round(m_srcPoly[0].X + X * delta),
+                                  Round(m_srcPoly[0].Y + Y * delta));
+          if (X < 0)
+            X = 1;
+          else if (Y < 0)
+            Y = 1;
+          else
+            X = -1;
+        }
+      }
+      m_destPolys.emplace_back(m_destPoly);
+      continue;
+    }
+    // build m_normals ...
+    m_normals.clear();
+    m_normals.reserve(len);
+    for (int j = 0; j < len - 1; ++j)
+      m_normals.emplace_back(GetUnitNormal(m_srcPoly[j], m_srcPoly[j + 1]));
+    if (node.m_endtype == etClosedLine || node.m_endtype == etClosedPolygon)
+      m_normals.emplace_back(GetUnitNormal(m_srcPoly[len - 1], m_srcPoly[0]));
+    else
+      m_normals.emplace_back(m_normals[len - 2]);
+
+    if (node.m_endtype == etClosedPolygon) {
+      int k = len - 1;
+      for (int j = 0; j < len; ++j)
+        OffsetPoint(j, k, node.m_jointype);
+      m_destPolys.emplace_back(m_destPoly);
+    } else if (node.m_endtype == etClosedLine) {
+      int k = len - 1;
+      for (int j = 0; j < len; ++j)
+        OffsetPoint(j, k, node.m_jointype);
+      m_destPolys.emplace_back(m_destPoly);
+      m_destPoly.clear();
+      // re-build m_normals ...
+      DoublePoint n = m_normals[len - 1];
+      for (int j = len - 1; j > 0; j--)
+        m_normals[j].reset(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+      m_normals[0].reset(-n.X, -n.Y);
+      k = 0;
+      for (int j = len - 1; j >= 0; j--)
+        OffsetPoint(j, k, node.m_jointype);
+      m_destPolys.emplace_back(m_destPoly);
+    } else {
+      int k = 0;
+      for (int j = 1; j < len - 1; ++j)
+        OffsetPoint(j, k, node.m_jointype);
+
+      if (node.m_endtype == etOpenButt) {
+        int j = len - 1;
+        m_destPoly.emplace_back(
+            (cInt)Round(m_srcPoly[j].X + m_normals[j].X * delta),
+            (cInt)Round(m_srcPoly[j].Y + m_normals[j].Y * delta));
+        m_destPoly.emplace_back(
+            (cInt)Round(m_srcPoly[j].X - m_normals[j].X * delta),
+            (cInt)Round(m_srcPoly[j].Y - m_normals[j].Y * delta));
+      } else {
+        int j = len - 1;
+        k = len - 2;
+        m_sinA = 0;
+        m_normals[j].reset(-m_normals[j].X, -m_normals[j].Y);
+        if (node.m_endtype == etOpenSquare)
+          DoSquare(j, k);
+        else
+          DoRound(j, k);
+      }
+
+      // re-build m_normals ...
+      for (int j = len - 1; j > 0; j--)
+        m_normals[j].reset(-m_normals[j - 1].X, -m_normals[j - 1].Y);
+      m_normals[0].reset(-m_normals[1].X, -m_normals[1].Y);
+
+      k = len - 1;
+      for (int j = k - 1; j > 0; --j)
+        OffsetPoint(j, k, node.m_jointype);
+
+      if (node.m_endtype == etOpenButt) {
+        m_destPoly.emplace_back(
+            (cInt)Round(m_srcPoly[0].X - m_normals[0].X * delta),
+            (cInt)Round(m_srcPoly[0].Y - m_normals[0].Y * delta));
+        m_destPoly.emplace_back(
+            (cInt)Round(m_srcPoly[0].X + m_normals[0].X * delta),
+            (cInt)Round(m_srcPoly[0].Y + m_normals[0].Y * delta));
+      } else {
+        k = 1;
+        m_sinA = 0;
+        if (node.m_endtype == etOpenSquare)
+          DoSquare(0, 1);
+        else
+          DoRound(0, 1);
+      }
+      m_destPolys.emplace_back(m_destPoly);
+    }
+  }
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::OffsetPoint(int j, int &k, JoinType jointype) noexcept {
+  // cross product ...
+  m_sinA = (m_normals[k].X * m_normals[j].Y - m_normals[j].X * m_normals[k].Y);
+  if (std::fabs(m_sinA * m_delta) < 1.0) {
+    // dot product ...
+    double cosA =
+        (m_normals[k].X * m_normals[j].X + m_normals[j].Y * m_normals[k].Y);
+    if (cosA > 0) // angle => 0 degrees
+    {
+      m_destPoly.emplace_back(Round(m_srcPoly[j].X + m_normals[k].X * m_delta),
+                              Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta));
+      return;
+    }
+    // else angle => 180 degrees
+  } else if (m_sinA > 1.0)
+    m_sinA = 1.0;
+  else if (m_sinA < -1.0)
+    m_sinA = -1.0;
+
+  if (m_sinA * m_delta < 0) {
+    m_destPoly.emplace_back(Round(m_srcPoly[j].X + m_normals[k].X * m_delta),
+                            Round(m_srcPoly[j].Y + m_normals[k].Y * m_delta));
+    m_destPoly.emplace_back(m_srcPoly[j]);
+    m_destPoly.emplace_back(Round(m_srcPoly[j].X + m_normals[j].X * m_delta),
+                            Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta));
+  } else
+    switch (jointype) {
+    case jtMiter: {
+      double r = 1 + (m_normals[j].X * m_normals[k].X +
+                      m_normals[j].Y * m_normals[k].Y);
+      if (r >= m_miterLim)
+        DoMiter(j, k, r);
+      else
+        DoSquare(j, k);
+      break;
+    }
+    case jtSquare:
+      DoSquare(j, k);
+      break;
+    case jtRound:
+      DoRound(j, k);
+      break;
+    }
+  k = j;
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::DoSquare(int j, int k) noexcept {
+  double dx = std::tan(std::atan2(m_sinA, m_normals[k].X * m_normals[j].X +
+                                              m_normals[k].Y * m_normals[j].Y) /
+                       4);
+  m_destPoly.emplace_back(
+      Round(m_srcPoly[j].X + m_delta * (m_normals[k].X - m_normals[k].Y * dx)),
+      Round(m_srcPoly[j].Y + m_delta * (m_normals[k].Y + m_normals[k].X * dx)));
+  m_destPoly.emplace_back(
+      Round(m_srcPoly[j].X + m_delta * (m_normals[j].X + m_normals[j].Y * dx)),
+      Round(m_srcPoly[j].Y + m_delta * (m_normals[j].Y - m_normals[j].X * dx)));
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::DoMiter(int j, int k, double r) noexcept {
+  double q = m_delta / r;
+  m_destPoly.emplace_back(
+      Round(m_srcPoly[j].X + (m_normals[k].X + m_normals[j].X) * q),
+      Round(m_srcPoly[j].Y + (m_normals[k].Y + m_normals[j].Y) * q));
+}
+//------------------------------------------------------------------------------
+
+void ClipperOffset::DoRound(int j, int k) noexcept {
+  double a = std::atan2(m_sinA, m_normals[k].X * m_normals[j].X +
+                                    m_normals[k].Y * m_normals[j].Y);
+  int steps = std::max((int)Round(m_StepsPerRad * std::fabs(a)), 1);
+
+  double X = m_normals[k].X, Y = m_normals[k].Y, X2;
+  for (int i = 0; i < steps; ++i) {
+    m_destPoly.emplace_back(Round(m_srcPoly[j].X + X * m_delta),
+                            Round(m_srcPoly[j].Y + Y * m_delta));
+    X2 = X;
+    X = X * m_cos - m_sin * Y;
+    Y = X2 * m_sin + Y * m_cos;
+  }
+  m_destPoly.emplace_back(Round(m_srcPoly[j].X + m_normals[j].X * m_delta),
+                          Round(m_srcPoly[j].Y + m_normals[j].Y * m_delta));
+}
+
+//------------------------------------------------------------------------------
+// Miscellaneous public functions
+//------------------------------------------------------------------------------
+
+void Clipper::DoSimplePolygons() noexcept {
+  PolyOutList::size_type i = 0;
+  while (i < m_PolyOuts.size()) {
+    OutRec *outrec = m_PolyOuts[i++];
+    OutPt *op = outrec->Pts;
+    if (!op || outrec->IsOpen)
+      continue;
+    do // for each Pt in Polygon until duplicate found do ...
+    {
+      OutPt *op2 = op->Next;
+      while (op2 != outrec->Pts) {
+        if ((op->Pt == op2->Pt) && op2->Next != op && op2->Prev != op) {
+          // split the polygon into two ...
+          OutPt *op3 = op->Prev;
+          OutPt *op4 = op2->Prev;
+          op->Prev = op4;
+          op4->Next = op;
+          op2->Prev = op3;
+          op3->Next = op2;
+
+          outrec->Pts = op;
+          OutRec *outrec2 = CreateOutRec();
+          outrec2->Pts = op2;
+          UpdateOutPtIdxs(*outrec2);
+          if (Poly2ContainsPoly1(outrec2->Pts, outrec->Pts)) {
+            // OutRec2 is contained by OutRec1 ...
+            outrec2->IsHole = !outrec->IsHole;
+            outrec2->FirstLeft = outrec;
+            if (m_UsingPolyTree)
+              FixupFirstLefts2(outrec2, outrec);
+          } else if (Poly2ContainsPoly1(outrec->Pts, outrec2->Pts)) {
+            // OutRec1 is contained by OutRec2 ...
+            outrec2->IsHole = outrec->IsHole;
+            outrec->IsHole = !outrec2->IsHole;
+            outrec2->FirstLeft = outrec->FirstLeft;
+            outrec->FirstLeft = outrec2;
+            if (m_UsingPolyTree)
+              FixupFirstLefts2(outrec, outrec2);
+          } else {
+            // the 2 polygons are separate ...
+            outrec2->IsHole = outrec->IsHole;
+            outrec2->FirstLeft = outrec->FirstLeft;
+            if (m_UsingPolyTree)
+              FixupFirstLefts1(outrec, outrec2);
+          }
+          op2 = op; // ie get ready for the Next iteration
+        }
+        op2 = op2->Next;
+      }
+      op = op->Next;
+    } while (op != outrec->Pts);
+  }
+}
+//------------------------------------------------------------------------------
+
+void ReversePath(Path &p) noexcept { std::reverse(p.begin(), p.end()); }
+//------------------------------------------------------------------------------
+
+void ReversePaths(Paths &p) noexcept {
+  for (Paths::size_type i = 0; i < p.size(); ++i)
+    ReversePath(p[i]);
+}
+//------------------------------------------------------------------------------
+
+#if 0
+void SimplifyPolygon(const Path &in_poly, Paths &out_polys,
+                     PolyFillType fillType) {
+  Clipper c;
+  c.StrictlySimple(true);
+  c.AddPath(in_poly, ptSubject, true);
+  c.Execute(ctUnion, out_polys, fillType, fillType);
+}
+//------------------------------------------------------------------------------
+
+void SimplifyPolygons(const Paths &in_polys, Paths &out_polys,
+                      PolyFillType fillType) {
+  Clipper c;
+  c.StrictlySimple(true);
+  c.AddPaths(in_polys, ptSubject, true);
+  c.Execute(ctUnion, out_polys, fillType, fillType);
+}
+//------------------------------------------------------------------------------
+
+void SimplifyPolygons(Paths &polys, PolyFillType fillType) {
+  SimplifyPolygons(polys, polys, fillType);
+}
+#endif
+//------------------------------------------------------------------------------
+
+inline double DistanceSqrd(const IntPoint &pt1, const IntPoint &pt2) noexcept {
+  double Dx = ((double)pt1.X - pt2.X);
+  double dy = ((double)pt1.Y - pt2.Y);
+  return (Dx * Dx + dy * dy);
+}
+//------------------------------------------------------------------------------
+
+double DistanceFromLineSqrd(const IntPoint &pt, const IntPoint &ln1,
+                            const IntPoint &ln2) noexcept {
+  // The equation of a line in general form (Ax + By + C = 0)
+  // given 2 points (x�,y�) & (x�,y�) is ...
+  //(y� - y�)x + (x� - x�)y + (y� - y�)x� - (x� - x�)y� = 0
+  // A = (y� - y�); B = (x� - x�); C = (y� - y�)x� - (x� - x�)y�
+  // perpendicular distance of point (x�,y�) = (Ax� + By� + C)/Sqrt(A� + B�)
+  // see http://en.wikipedia.org/wiki/Perpendicular_distance
+  double A = double(ln1.Y - ln2.Y);
+  double B = double(ln2.X - ln1.X);
+  double C = A * ln1.X + B * ln1.Y;
+  C = A * pt.X + B * pt.Y - C;
+  return (C * C) / (A * A + B * B);
+}
+//---------------------------------------------------------------------------
+
+bool SlopesNearCollinear(const IntPoint &pt1, const IntPoint &pt2,
+                         const IntPoint &pt3, double distSqrd) noexcept {
+  // this function is more accurate when the point that's geometrically
+  // between the other 2 points is the one that's tested for distance.
+  // ie makes it more likely to pick up 'spikes' ...
+  if (Abs(pt1.X - pt2.X) > Abs(pt1.Y - pt2.Y)) {
+    if ((pt1.X > pt2.X) == (pt1.X < pt3.X))
+      return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+    else if ((pt2.X > pt1.X) == (pt2.X < pt3.X))
+      return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+    else
+      return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+  } else {
+    if ((pt1.Y > pt2.Y) == (pt1.Y < pt3.Y))
+      return DistanceFromLineSqrd(pt1, pt2, pt3) < distSqrd;
+    else if ((pt2.Y > pt1.Y) == (pt2.Y < pt3.Y))
+      return DistanceFromLineSqrd(pt2, pt1, pt3) < distSqrd;
+    else
+      return DistanceFromLineSqrd(pt3, pt1, pt2) < distSqrd;
+  }
+}
+//------------------------------------------------------------------------------
+
+bool PointsAreClose(IntPoint &pt1, IntPoint &pt2, double distSqrd) noexcept {
+  double Dx = (double)pt1.X - pt2.X;
+  double dy = (double)pt1.Y - pt2.Y;
+  return ((Dx * Dx) + (dy * dy) <= distSqrd);
+}
+//------------------------------------------------------------------------------
+
+OutPt *ExcludeOp(OutPt *op) noexcept {
+  OutPt *result = op->Prev;
+  result->Next = op->Next;
+  op->Next->Prev = result;
+  result->Idx = 0;
+  return result;
+}
+//------------------------------------------------------------------------------
+
+void CleanPolygon(const Path &in_poly, Path &out_poly,
+                  double distance) noexcept {
+  // distance = proximity in units/pixels below which vertices
+  // will be stripped. Default ~= sqrt(2).
+
+  size_t size = in_poly.size();
+
+  if (size == 0) {
+    out_poly.clear();
+    return;
+  }
+
+  OutPt *outPts = new OutPt[size];
+  for (size_t i = 0; i < size; ++i) {
+    outPts[i].Pt = in_poly[i];
+    outPts[i].Next = &outPts[(i + 1) % size];
+    outPts[i].Next->Prev = &outPts[i];
+    outPts[i].Idx = 0;
+  }
+
+  double distSqrd = distance * distance;
+  OutPt *op = &outPts[0];
+  while (op->Idx == 0 && op->Next != op->Prev) {
+    if (PointsAreClose(op->Pt, op->Prev->Pt, distSqrd)) {
+      op = ExcludeOp(op);
+      size--;
+    } else if (PointsAreClose(op->Prev->Pt, op->Next->Pt, distSqrd)) {
+      ExcludeOp(op->Next);
+      op = ExcludeOp(op);
+      size -= 2;
+    } else if (SlopesNearCollinear(op->Prev->Pt, op->Pt, op->Next->Pt,
+                                   distSqrd)) {
+      op = ExcludeOp(op);
+      size--;
+    } else {
+      op->Idx = 1;
+      op = op->Next;
+    }
+  }
+
+  if (size < 3)
+    size = 0;
+  out_poly.resize(size);
+  for (size_t i = 0; i < size; ++i) {
+    out_poly[i] = op->Pt;
+    op = op->Next;
+  }
+  delete[] outPts;
+}
+//------------------------------------------------------------------------------
+
+void CleanPolygon(Path &poly, double distance) noexcept {
+  CleanPolygon(poly, poly, distance);
+}
+//------------------------------------------------------------------------------
+
+void CleanPolygons(const Paths &in_polys, Paths &out_polys,
+                   double distance) noexcept {
+  out_polys.resize(in_polys.size());
+  for (Paths::size_type i = 0; i < in_polys.size(); ++i)
+    CleanPolygon(in_polys[i], out_polys[i], distance);
+}
+//------------------------------------------------------------------------------
+
+void CleanPolygons(Paths &polys, double distance) noexcept {
+  CleanPolygons(polys, polys, distance);
+}
+//------------------------------------------------------------------------------
+
+void Minkowski(const Path &poly, const Path &path, Paths &solution, bool isSum,
+               bool isClosed) noexcept {
+  int delta = (isClosed ? 1 : 0);
+  size_t polyCnt = poly.size();
+  size_t pathCnt = path.size();
+  Paths pp;
+  pp.reserve(pathCnt);
+  if (isSum)
+    for (size_t i = 0; i < pathCnt; ++i) {
+      Path p;
+      p.reserve(polyCnt);
+      for (size_t j = 0; j < poly.size(); ++j)
+        p.emplace_back(path[i].X + poly[j].X, path[i].Y + poly[j].Y);
+      pp << std::move(p);
+    }
+  else
+    for (size_t i = 0; i < pathCnt; ++i) {
+      Path p;
+      p.reserve(polyCnt);
+      for (size_t j = 0; j < poly.size(); ++j)
+        p.emplace_back(path[i].X - poly[j].X, path[i].Y - poly[j].Y);
+      pp << std::move(p);
+    }
+
+  solution.clear();
+  solution.reserve((pathCnt + delta) * (polyCnt + 1));
+  for (size_t i = 0; i < pathCnt - 1 + delta; ++i)
+    for (size_t j = 0; j < polyCnt; ++j) {
+      Path quad;
+      quad.reserve(4);
+      quad.emplace_back(pp[i % pathCnt][j % polyCnt]);
+      quad.emplace_back(pp[(i + 1) % pathCnt][j % polyCnt]);
+      quad.emplace_back(pp[(i + 1) % pathCnt][(j + 1) % polyCnt]);
+      quad.emplace_back(pp[i % pathCnt][(j + 1) % polyCnt]);
+      if (!Orientation(quad))
+        ReversePath(quad);
+      solution << std::move(quad);
+    }
+}
+//------------------------------------------------------------------------------
+
+#if 0
+void MinkowskiSum(const Path &pattern, const Path &path, Paths &solution,
+                  bool pathIsClosed) {
+  Minkowski(pattern, path, solution, true, pathIsClosed);
+  Clipper c;
+  c.AddPaths(solution, ptSubject, true);
+  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+}
+#endif
+//------------------------------------------------------------------------------
+
+void TranslatePath(const Path &input, Path &output,
+                   const IntPoint &delta) noexcept {
+  // precondition: input != output
+  output.resize(input.size());
+  for (size_t i = 0; i < input.size(); ++i)
+    output[i].reset(input[i].X + delta.X, input[i].Y + delta.Y);
+}
+//------------------------------------------------------------------------------
+
+#if 0
+void MinkowskiSum(const Path &pattern, const Paths &paths, Paths &solution,
+                  bool pathIsClosed) {
+  Clipper c;
+  for (size_t i = 0; i < paths.size(); ++i) {
+    Paths tmp;
+    Minkowski(pattern, paths[i], tmp, true, pathIsClosed);
+    c.AddPaths(tmp, ptSubject, true);
+    if (pathIsClosed) {
+      Path tmp2;
+      TranslatePath(paths[i], tmp2, pattern[0]);
+      c.AddPath(tmp2, ptClip, true);
+    }
+  }
+  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+}
+//------------------------------------------------------------------------------
+
+void MinkowskiDiff(const Path &poly1, const Path &poly2, Paths &solution) {
+  Minkowski(poly1, poly2, solution, false, true);
+  Clipper c;
+  c.AddPaths(solution, ptSubject, true);
+  c.Execute(ctUnion, solution, pftNonZero, pftNonZero);
+}
+//------------------------------------------------------------------------------
+#endif
+
+enum NodeType { ntAny, ntOpen, ntClosed };
+
+void AddPolyNodeToPaths(const PolyNode &polynode, NodeType nodetype,
+                        Paths &paths) noexcept {
+  bool match = true;
+  if (nodetype == ntClosed)
+    match = !polynode.IsOpen();
+  else if (nodetype == ntOpen)
+    return;
+
+  if (!polynode.Contour.empty() && match)
+    paths.emplace_back(polynode.Contour);
+  for (int i = 0; i < polynode.ChildCount(); ++i)
+    AddPolyNodeToPaths(*polynode.Children[i], nodetype, paths);
+}
+//------------------------------------------------------------------------------
+
+void PolyTreeToPaths(const PolyTree &polytree, Paths &paths) noexcept {
+  paths.resize(0);
+  paths.reserve(polytree.Total());
+  AddPolyNodeToPaths(polytree, ntAny, paths);
+}
+//------------------------------------------------------------------------------
+
+void ClosedPathsFromPolyTree(const PolyTree &polytree, Paths &paths) noexcept {
+  paths.resize(0);
+  paths.reserve(polytree.Total());
+  AddPolyNodeToPaths(polytree, ntClosed, paths);
+}
+//------------------------------------------------------------------------------
+
+void OpenPathsFromPolyTree(PolyTree &polytree, Paths &paths) noexcept {
+  paths.resize(0);
+  paths.reserve(polytree.Total());
+  // Open paths are top level only, so ...
+  for (int i = 0; i < polytree.ChildCount(); ++i)
+    if (polytree.Children[i]->IsOpen())
+      paths.emplace_back(polytree.Children[i]->Contour);
+}
+//------------------------------------------------------------------------------
+
+std::ostream &operator<<(std::ostream &s, const IntPoint &p) noexcept {
+  s << "(" << p.X << "," << p.Y << ")";
+  return s;
+}
+//------------------------------------------------------------------------------
+
+std::ostream &operator<<(std::ostream &s, const Path &p) noexcept {
+  if (p.empty())
+    return s;
+  Path::size_type last = p.size() - 1;
+  for (Path::size_type i = 0; i < last; ++i)
+    s << "(" << p[i].X << "," << p[i].Y << "), ";
+  s << "(" << p[last].X << "," << p[last].Y << ")\n";
+  return s;
+}
+//------------------------------------------------------------------------------
+
+std::ostream &operator<<(std::ostream &s, const Paths &p) noexcept {
+  for (Paths::size_type i = 0; i < p.size(); ++i)
+    s << p[i];
+  s << "\n";
+  return s;
+}
+//------------------------------------------------------------------------------
+
+} // namespace ClipperLib

deploy/cpp_infer/src/main.cpp

+// 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

+// 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;
+  config.SetModel(model_dir + "/inference.pdmodel",
+                  model_dir + "/inference.pdiparams");
+
+  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_);
+  }
+
+  // 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

+// 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;
+  config.SetModel(model_dir + "/inference.pdmodel",
+                  model_dir + "/inference.pdiparams");
+
+  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_);
+  }
+  // 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

+// 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;
+  config.SetModel(model_dir + "/inference.pdmodel",
+                  model_dir + "/inference.pdiparams");
+  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_);
+  }
+
+  // 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

+// 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

+// 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

+// 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

+// 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,
+                     {0, 0, 0});
+}
+
+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

+// 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;
+  if (Utility::PathExists(model_dir + "/inference.pdmodel") &&
+      Utility::PathExists(model_dir + "/inference.pdiparams")) {
+    config.SetModel(model_dir + "/inference.pdmodel",
+                    model_dir + "/inference.pdiparams");
+  } else if (Utility::PathExists(model_dir + "/model.pdmodel") &&
+             Utility::PathExists(model_dir + "/model.pdiparams")) {
+    config.SetModel(model_dir + "/model.pdmodel",
+                    model_dir + "/model.pdiparams");
+  } else {
+    std::cerr << "[ERROR] not find model.pdiparams or inference.pdiparams in "
+              << model_dir << std::endl;
+    exit(1);
+  }
+
+  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_);
+  }
+
+  // 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

+// 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;
+  config.SetModel(model_dir + "/inference.pdmodel",
+                  model_dir + "/inference.pdiparams");
+
+  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_);
+  }
+
+  // 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