Merge branch 'develop' of https://github.com/PaddlePaddle/PaddleOCR into fixocr

README_cn.md

+[English](README.md) | 简体中文
+
+## 简介
+PaddleOCR旨在打造一套丰富、领先、且实用的OCR工具库，助力使用者训练出更好的模型，并应用落地。
+
+**直播预告：2020年7月21日晚8点B站直播，PaddleOCR开源大礼包全面解读，直播地址当天更新**
+
+**近期更新**
+- 2020.7.15 添加基于EasyEdge和Paddle-Lite的移动端DEMO，支持iOS和Android系统
+- 2020.7.15 完善预测部署，添加基于C++预测引擎推理、服务化部署和端侧部署方案，以及超轻量级中文OCR模型预测耗时Benchmark
+- 2020.7.15 整理OCR相关数据集、常用数据标注以及合成工具
+- 2020.7.9 添加支持空格的识别模型，识别效果，预测及训练方式请参考快速开始和文本识别训练相关文档
+- 2020.7.9 添加数据增强、学习率衰减策略,具体参考[配置文件](./doc/doc_ch/config.md)
+- [more](./doc/doc_ch/update.md)
+
+
+## 特性
+- 超轻量级中文OCR模型，总模型仅8.6M
+    - 单模型支持中英文数字组合识别、竖排文本识别、长文本识别
+    - 检测模型DB（4.1M）+识别模型CRNN（4.5M）
+- 实用通用中文OCR模型
+- 多种预测推理部署方案，包括服务部署和端侧部署
+- 多种文本检测训练算法，EAST、DB
+- 多种文本识别训练算法，Rosetta、CRNN、STAR-Net、RARE
+- 可运行于Linux、Windows、MacOS等多种系统
+
+## 快速体验
+
+<div align="center">
+    <img src="doc/imgs_results/11.jpg" width="800">
+</div>
+
+上图是超轻量级中文OCR模型效果展示，更多效果图请见[效果展示页面](./doc/doc_ch/visualization.md)。
+
+- 超轻量级中文OCR在线体验地址：https://www.paddlepaddle.org.cn/hub/scene/ocr
+- 移动端DEMO体验(基于EasyEdge和Paddle-Lite, 支持iOS和Android系统)：[安装包二维码获取地址](https://ai.baidu.com/easyedge/app/openSource?from=paddlelite) 
+
+   Android手机也可以扫描下面二维码安装体验。
+
+<div align="center">
+<img src="./doc/ocr-android-easyedge.png"  width = "200" height = "200" />
+</div>
+
+- [**中文OCR模型快速使用**](./doc/doc_ch/quickstart.md)
+
+
+## 中文OCR模型列表
+
+|模型名称|模型简介|检测模型地址|识别模型地址|支持空格的识别模型地址|
+|-|-|-|-|-|
+|chinese_db_crnn_mobile|超轻量级中文OCR模型|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db.tar)|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn.tar)|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance.tar)
+|chinese_db_crnn_server|通用中文OCR模型|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db.tar)|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn.tar)|[inference模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance_infer.tar) / [预训练模型](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance.tar)
+
+## 文档教程
+- [快速安装](./doc/doc_ch/installation.md)
+- [中文OCR模型快速使用](./doc/doc_ch/quickstart.md)
+- 算法介绍
+    - [文本检测](#文本检测算法)
+    - [文本识别](#文本识别算法)
+    - [端到端OCR](#端到端OCR算法)
+- 模型训练/评估
+    - [文本检测](./doc/doc_ch/detection.md)
+    - [文本识别](./doc/doc_ch/recognition.md)
+    - [yml参数配置文件介绍](./doc/doc_ch/config.md)
+    - [中文OCR训练预测技巧](./doc/doc_ch/tricks.md)
+- 预测部署
+    - [基于Python预测引擎推理](./doc/doc_ch/inference.md)
+    - [基于C++预测引擎推理](./deploy/cpp_infer/readme.md)
+    - [服务化部署](./doc/doc_ch/serving.md)
+    - [端侧部署](./deploy/lite/readme.md)
+    - 模型量化压缩（coming soon）
+    - [Benchmark](./doc/doc_ch/benchmark.md)
+- 数据集
+    - [通用中英文OCR数据集](./doc/doc_ch/datasets.md)
+    - [手写中文OCR数据集](./doc/doc_ch/handwritten_datasets.md)
+    - [垂类多语言OCR数据集](./doc/doc_ch/vertical_and_multilingual_datasets.md)
+    - [常用数据标注工具](./doc/doc_ch/data_annotation.md)
+    - [常用数据合成工具](./doc/doc_ch/data_synthesis.md)
+- [FAQ](#FAQ)
+- 效果展示
+    - [超轻量级中文OCR效果展示](#超轻量级中文OCR效果展示)
+    - [通用中文OCR效果展示](#通用中文OCR效果展示)
+    - [支持空格的中文OCR效果展示](#支持空格的中文OCR效果展示)
+- [技术交流群](#欢迎加入PaddleOCR技术交流群)
+- [参考文献](./doc/doc_ch/reference.md)
+- [许可证书](#许可证书)
+- [贡献代码](#贡献代码)
+
+<a name="算法介绍"></a>
+## 算法介绍
+<a name="文本检测算法"></a>
+### 1.文本检测算法
+
+PaddleOCR开源的文本检测算法列表：
+- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))
+- [x]  DB([paper](https://arxiv.org/abs/1911.08947))
+- [ ]  SAST([paper](https://arxiv.org/abs/1908.05498))(百度自研, coming soon)
+
+在ICDAR2015文本检测公开数据集上，算法效果如下：
+
+|模型|骨干网络|precision|recall|Hmean|下载链接|
+|-|-|-|-|-|-|
+|EAST|ResNet50_vd|88.18%|85.51%|86.82%|[下载链接](https://paddleocr.bj.bcebos.com/det_r50_vd_east.tar)|
+|EAST|MobileNetV3|81.67%|79.83%|80.74%|[下载链接](https://paddleocr.bj.bcebos.com/det_mv3_east.tar)|
+|DB|ResNet50_vd|83.79%|80.65%|82.19%|[下载链接](https://paddleocr.bj.bcebos.com/det_r50_vd_db.tar)|
+|DB|MobileNetV3|75.92%|73.18%|74.53%|[下载链接](https://paddleocr.bj.bcebos.com/det_mv3_db.tar)|
+
+使用[LSVT](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_ch/datasets.md#1icdar2019-lsvt)街景数据集共3w张数据，训练中文检测模型的相关配置和预训练文件如下：
+|模型|骨干网络|配置文件|预训练模型|
+|-|-|-|-|
+|超轻量中文模型|MobileNetV3|det_mv3_db.yml|[下载链接](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db.tar)|
+|通用中文OCR模型|ResNet50_vd|det_r50_vd_db.yml|[下载链接](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db.tar)|
+
+* 注： 上述DB模型的训练和评估，需设置后处理参数box_thresh=0.6，unclip_ratio=1.5，使用不同数据集、不同模型训练，可调整这两个参数进行优化
+
+PaddleOCR文本检测算法的训练和使用请参考文档教程中[模型训练/评估中的文本检测部分](./doc/doc_ch/detection.md)。
+
+<a name="文本识别算法"></a>
+### 2.文本识别算法
+
+PaddleOCR开源的文本识别算法列表：
+- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))
+- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))
+- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))
+- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))
+- [ ]  SRN([paper](https://arxiv.org/abs/2003.12294))(百度自研, coming soon)
+
+参考[DTRB](https://arxiv.org/abs/1904.01906)文字识别训练和评估流程，使用MJSynth和SynthText两个文字识别数据集训练，在IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE数据集上进行评估，算法效果如下：
+
+|模型|骨干网络|Avg Accuracy|模型存储命名|下载链接|
+|-|-|-|-|-|
+|Rosetta|Resnet34_vd|80.24%|rec_r34_vd_none_none_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_r34_vd_none_none_ctc.tar)|
+|Rosetta|MobileNetV3|78.16%|rec_mv3_none_none_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_mv3_none_none_ctc.tar)|
+|CRNN|Resnet34_vd|82.20%|rec_r34_vd_none_bilstm_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_r34_vd_none_bilstm_ctc.tar)|
+|CRNN|MobileNetV3|79.37%|rec_mv3_none_bilstm_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_mv3_none_bilstm_ctc.tar)|
+|STAR-Net|Resnet34_vd|83.93%|rec_r34_vd_tps_bilstm_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_r34_vd_tps_bilstm_ctc.tar)|
+|STAR-Net|MobileNetV3|81.56%|rec_mv3_tps_bilstm_ctc|[下载链接](https://paddleocr.bj.bcebos.com/rec_mv3_tps_bilstm_ctc.tar)|
+|RARE|Resnet34_vd|84.90%|rec_r34_vd_tps_bilstm_attn|[下载链接](https://paddleocr.bj.bcebos.com/rec_r34_vd_tps_bilstm_attn.tar)|
+|RARE|MobileNetV3|83.32%|rec_mv3_tps_bilstm_attn|[下载链接](https://paddleocr.bj.bcebos.com/rec_mv3_tps_bilstm_attn.tar)|
+
+使用[LSVT](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_ch/datasets.md#1icdar2019-lsvt)街景数据集根据真值将图crop出来30w数据，进行位置校准。此外基于LSVT语料生成500w合成数据训练中文模型，相关配置和预训练文件如下：  
+
+|模型|骨干网络|配置文件|预训练模型|
+|-|-|-|-|
+|超轻量中文模型|MobileNetV3|rec_chinese_lite_train.yml|[下载链接](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn.tar)|
+|通用中文OCR模型|Resnet34_vd|rec_chinese_common_train.yml|[下载链接](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn.tar)|
+
+PaddleOCR文本识别算法的训练和使用请参考文档教程中[模型训练/评估中的文本识别部分](./doc/doc_ch/recognition.md)。
+
+<a name="端到端OCR算法"></a>
+### 3.端到端OCR算法
+- [ ]  [End2End-PSL](https://arxiv.org/abs/1909.07808)(百度自研, coming soon)
+
+## 效果展示
+
+<a name="超轻量级中文OCR效果展示"></a>
+### 1.超轻量级中文OCR效果展示  [more](./doc/doc_ch/visualization.md)
+
+<div align="center">
+    <img src="doc/imgs_results/1.jpg" width="800">
+</div>
+
+<a name="通用中文OCR效果展示"></a>
+### 2.通用中文OCR效果展示  [more](./doc/doc_ch/visualization.md)
+
+<div align="center">
+    <img src="doc/imgs_results/chinese_db_crnn_server/11.jpg" width="800">
+</div>
+
+<a name="支持空格的中文OCR效果展示"></a>
+### 3.支持空格的中文OCR效果展示  [more](./doc/doc_ch/visualization.md)
+
+<div align="center">
+    <img src="doc/imgs_results/chinese_db_crnn_server/en_paper.jpg" width="800">
+</div>
+
+<a name="FAQ"></a>
+## FAQ
+1. **转换attention识别模型时报错：KeyError: 'predict'**  
+问题已解，请更新到最新代码。  
+
+2. **关于推理速度**  
+图片中的文字较多时，预测时间会增，可以使用--rec_batch_num设置更小预测batch num，默认值为30，可以改为10或其他数值。  
+
+3. **服务部署与移动端部署**  
+预计6月中下旬会先后发布基于Serving的服务部署方案和基于Paddle Lite的移动端部署方案，欢迎持续关注。  
+
+4. **自研算法发布时间**  
+自研算法SAST、SRN、End2End-PSL都将在7-8月陆续发布，敬请期待。  
+
+[more](./doc/doc_ch/FAQ.md)
+
+<a name="欢迎加入PaddleOCR技术交流群"></a>
+## 欢迎加入PaddleOCR技术交流群
+请扫描下面二维码，完成问卷填写，获取加群二维码和OCR方向的炼丹秘籍
+
+<div align="center">
+<img src="./doc/joinus.jpg"  width = "200" height = "200" />
+</div>
+
+<a name="许可证书"></a>
+## 许可证书
+本项目的发布受<a href="https://github.com/PaddlePaddle/PaddleOCR/blob/master/LICENSE">Apache 2.0 license</a>许可认证。
+
+<a name="贡献代码"></a>
+## 贡献代码
+我们非常欢迎你为PaddleOCR贡献代码，也十分感谢你的反馈。
+
+- 非常感谢 [Khanh Tran](https://github.com/xxxpsyduck) 贡献了英文文档。
+- 非常感谢 [zhangxin](https://github.com/ZhangXinNan)([Blog](https://blog.csdn.net/sdlypyzq)) 贡献新的可视化方式、添加.gitgnore、处理手动设置PYTHONPATH环境变量的问题
+- 非常感谢 [lyl120117](https://github.com/lyl120117) 贡献打印网络结构的代码
+- 非常感谢 [xiangyubo](https://github.com/xiangyubo) 贡献手写中文OCR数据集
+- 非常感谢 [authorfu](https://github.com/authorfu) 贡献Android和[xiadeye](https://github.com/xiadeye) 贡献IOS的demo代码

README_en.md

-English | [简体中文](README.md)
-
-## INTRODUCTION
-PaddleOCR aims to create a rich, leading, and practical OCR tools that help users train better models and apply them into practice.
-
-**Recent updates**、
-- 2020.7.9 Add recognition model to support space, [recognition result](#space Chinese OCR results). For more information: [Recognition](./doc/doc_ch/recognition.md) and [quickstart](./doc/doc_ch/quickstart.md)
-- 2020.7.9 Add data auguments and learning rate decay strategies,please read [config](./doc/doc_en/config_en.md)
-- 2020.6.8 Add [dataset](./doc/doc_en/datasets_en.md) and keep updating
-- 2020.6.5 Support exporting `attention` model to `inference_model`
-- 2020.6.5 Support separate prediction and recognition, output result score
-- [more](./doc/doc_en/update_en.md)
-
-## FEATURES
-- Lightweight Chinese OCR model, total model size is only 8.6M
-    - Single model supports Chinese and English numbers combination recognition, vertical text recognition, long text recognition
-    - Detection model DB (4.1M) + recognition model CRNN (4.5M)
-- Various text detection algorithms: EAST, DB
-- Various text recognition algorithms: Rosetta, CRNN, STAR-Net, RARE
-
-<a name="Supported-Chinese-model-list"></a>
-### Supported Chinese models list:
-
-|Model Name|Description |Detection Model link|Recognition Model link| Support for space Recognition Model link|
-|-|-|-|-|-|
-|chinese_db_crnn_mobile|lightweight Chinese OCR model|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db_infer.tar) / [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_infer.tar) / [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance_infer.tar) / [pre-train model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance.tar)
-|chinese_db_crnn_server|General Chinese OCR model|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db_infer.tar) / [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_infer.tar) / [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance_infer.tar) / [pre-train model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance.tar)
-
-
-For testing our Chinese OCR online：https://www.paddlepaddle.org.cn/hub/scene/ocr
-
-**You can also quickly experience the lightweight Chinese OCR and General Chinese OCR models as follows:**
-
-## **LIGHTWEIGHT CHINESE OCR AND GENERAL CHINESE OCR INFERENCE**
-
-![](doc/imgs_results/11.jpg)
-
-The picture above is the result of our lightweight Chinese OCR model. For more testing results, please see the end of the article [lightweight Chinese OCR results](#lightweight-Chinese-OCR-results) , [General Chinese OCR results](#General-Chinese-OCR-results) and [Support for space Recognition Model](#Space-Chinese-OCR-results).
-
-#### 1. ENVIRONMENT CONFIGURATION
-
-Please see [Quick installation](./doc/doc_en/installation_en.md)
-
-#### 2. DOWNLOAD INFERENCE MODELS
-
-#### (1) Download lightweight Chinese OCR models
-*If wget is not installed in the windows system, you can copy the link to the browser to download the model. After model downloaded, unzip it and place it in the corresponding directory*
-
-Copy the detection and recognition 'inference model' address in [Chinese model List](#Supported-Chinese-model-list), download and unpack:
-
-```
-mkdir inference && cd inference
-# Download the detection part of the Chinese OCR and decompress it
-wget {url/of/detection/inference_model} && tar xf {name/of/detection/inference_model/package}
-# Download the recognition part of the Chinese OCR and decompress it
-wget {url/of/recognition/inference_model} && tar xf {name/of/recognition/inference_model/package}
-cd ..
-```
-
-Take lightweight Chinese OCR model as an example:
-
-```
-mkdir inference && cd inference
-# Download the detection part of the lightweight Chinese OCR and decompress it
-wget https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db_infer.tar && tar xf ch_det_mv3_db_infer.tar
-# Download the recognition part of the lightweight Chinese OCR and decompress it
-wget https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_infer.tar && tar xf ch_rec_mv3_crnn_infer.tar
-# Download the space-recognized part of the lightweight Chinese OCR and decompress it
-wget https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance_infer.tar && tar xf ch_rec_mv3_crnn_enhance_infer.tar
-
-cd ..
-```
-
-After the decompression is completed, the file structure should be as follows:
-
-```
-|-inference
-    |-ch_rec_mv3_crnn
-        |- model
-        |- params
-    |-ch_det_mv3_db
-        |- model
-        |- params
-    ...
-```
-
-#### 3. SINGLE IMAGE AND BATCH PREDICTION
-
-The following code implements text detection and recognition inference tandemly. When performing prediction, you need to specify the path of a single image or image folder through the parameter `image_dir`, the parameter `det_model_dir` specifies the path to detection model, and the parameter `rec_model_dir` specifies the path to the recognition model. The visual prediction results are saved to the `./inference_results` folder by default.
-
-```bash
-
-# Prediction on a single image by specifying image path to image_dir
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_det_mv3_db/"  --rec_model_dir="./inference/ch_rec_mv3_crnn/"
-
-# Prediction on a batch of images by specifying image folder path to image_dir
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/" --det_model_dir="./inference/ch_det_mv3_db/"  --rec_model_dir="./inference/ch_rec_mv3_crnn/"
-
-# If you want to use CPU for prediction, you need to set the use_gpu parameter to False
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_det_mv3_db/"  --rec_model_dir="./inference/ch_rec_mv3_crnn/" --use_gpu=False
-```
-
-To run inference of the Generic Chinese OCR model, follow these steps above to download the corresponding models and update the relevant parameters. Examples are as follows:
-```
-# Prediction on a single image by specifying image path to image_dir
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs/11.jpg" --det_model_dir="./inference/ch_det_r50_vd_db/"  --rec_model_dir="./inference/ch_rec_r34_vd_crnn/"
-```
-
-To run inference of the space-Generic Chinese OCR model, follow these steps above to download the corresponding models and update the relevant parameters. Examples are as follows:
-
-```
-# Prediction on a single image by specifying image path to image_dir
-python3 tools/infer/predict_system.py --image_dir="./doc/imgs_en/img_12.jpg" --det_model_dir="./inference/ch_det_r50_vd_db/"  --rec_model_dir="./inference/ch_rec_r34_vd_crnn_enhance/"
-```
-
-For more text detection and recognition models, please refer to the document [Inference](./doc/doc_en/inference_en.md)
-
-## DOCUMENTATION
-- [Quick installation](./doc/doc_en/installation_en.md)
-- [Text detection model training/evaluation/prediction](./doc/doc_en/detection_en.md)
-- [Text recognition model training/evaluation/prediction](./doc/doc_en/recognition_en.md)
-- [Inference](./doc/doc_en/inference_en.md)
-- [Introduction of yml file](./doc/doc_en/config_en.md)
-- [Dataset](./doc/doc_en/datasets_en.md)
-- [FAQ]((#FAQ)
-
-## TEXT DETECTION ALGORITHM
-
-PaddleOCR open source text detection algorithms list:
-- [x]  EAST([paper](https://arxiv.org/abs/1704.03155))
-- [x]  DB([paper](https://arxiv.org/abs/1911.08947))
-- [ ]  SAST([paper](https://arxiv.org/abs/1908.05498))(Baidu Self-Research, comming soon)
-
-On the ICDAR2015 dataset, the text detection result is as follows:
-
-|Model|Backbone|precision|recall|Hmean|Download link|
-|-|-|-|-|-|-|
-|EAST|ResNet50_vd|88.18%|85.51%|86.82%|[Download link](https://paddleocr.bj.bcebos.com/det_r50_vd_east.tar)|
-|EAST|MobileNetV3|81.67%|79.83%|80.74%|[Download link](https://paddleocr.bj.bcebos.com/det_mv3_east.tar)|
-|DB|ResNet50_vd|83.79%|80.65%|82.19%|[Download link](https://paddleocr.bj.bcebos.com/det_r50_vd_db.tar)|
-|DB|MobileNetV3|75.92%|73.18%|74.53%|[Download link](https://paddleocr.bj.bcebos.com/det_mv3_db.tar)|
-
-For use of [LSVT](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_en/datasets_en.md#1-icdar2019-lsvt) street view dataset with a total of 3w training data，the related configuration and pre-trained models for Chinese detection task are as follows:
-|Model|Backbone|Configuration file|Pre-trained model|
-|-|-|-|-|
-|lightweight Chinese model|MobileNetV3|det_mv3_db.yml|[Download link](https://paddleocr.bj.bcebos.com/ch_models/ch_det_mv3_db.tar)|
-|General Chinese OCR model|ResNet50_vd|det_r50_vd_db.yml|[Download link](https://paddleocr.bj.bcebos.com/ch_models/ch_det_r50_vd_db.tar)|
-
-* Note: For the training and evaluation of the above DB model, post-processing parameters box_thresh=0.6 and unclip_ratio=1.5 need to be set. If using different datasets and different models for training, these two parameters can be adjusted for better result.
-
-For the training guide and use of PaddleOCR text detection algorithms, please refer to the document [Text detection model training/evaluation/prediction](./doc/doc_en/detection_en.md)
-
-## TEXT RECOGNITION ALGORITHM
-
-PaddleOCR open-source text recognition algorithms list:
-- [x]  CRNN([paper](https://arxiv.org/abs/1507.05717))
-- [x]  Rosetta([paper](https://arxiv.org/abs/1910.05085))
-- [x]  STAR-Net([paper](http://www.bmva.org/bmvc/2016/papers/paper043/index.html))
-- [x]  RARE([paper](https://arxiv.org/abs/1603.03915v1))
-- [ ]  SRN([paper](https://arxiv.org/abs/2003.12294))(Baidu Self-Research, comming soon)
-
-Refer to [DTRB](https://arxiv.org/abs/1904.01906), the training and evaluation result of these above text recognition (using MJSynth and SynthText for training, evaluate on IIIT, SVT, IC03, IC13, IC15, SVTP, CUTE) is as follow:
-
-|Model|Backbone|Avg Accuracy|Module combination|Download link|
-|-|-|-|-|-|
-|Rosetta|Resnet34_vd|80.24%|rec_r34_vd_none_none_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_r34_vd_none_none_ctc.tar)|
-|Rosetta|MobileNetV3|78.16%|rec_mv3_none_none_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_mv3_none_none_ctc.tar)|
-|CRNN|Resnet34_vd|82.20%|rec_r34_vd_none_bilstm_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_r34_vd_none_bilstm_ctc.tar)|
-|CRNN|MobileNetV3|79.37%|rec_mv3_none_bilstm_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_mv3_none_bilstm_ctc.tar)|
-|STAR-Net|Resnet34_vd|83.93%|rec_r34_vd_tps_bilstm_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_r34_vd_tps_bilstm_ctc.tar)|
-|STAR-Net|MobileNetV3|81.56%|rec_mv3_tps_bilstm_ctc|[Download link](https://paddleocr.bj.bcebos.com/rec_mv3_tps_bilstm_ctc.tar)|
-|RARE|Resnet34_vd|84.90%|rec_r34_vd_tps_bilstm_attn|[Download link](https://paddleocr.bj.bcebos.com/rec_r34_vd_tps_bilstm_attn.tar)|
-|RARE|MobileNetV3|83.32%|rec_mv3_tps_bilstm_attn|[Download link](https://paddleocr.bj.bcebos.com/rec_mv3_tps_bilstm_attn.tar)|
-
-We use [LSVT](https://github.com/PaddlePaddle/PaddleOCR/blob/develop/doc/doc_en/datasets_en.md#1-icdar2019-lsvt) dataset and cropout 30w  traning data from original photos by using position groundtruth and make some calibration needed. In addition, based on the LSVT corpus, 500w synthetic data is generated to train the Chinese model. The related configuration and pre-trained models are as follows:
-|Model|Backbone|Configuration file|Pre-trained model|
-|-|-|-|-|
-|lightweight Chinese model|MobileNetV3|rec_chinese_lite_train.yml|[Download link](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance_infer.tar) & [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_mv3_crnn_enhance.tar)|
-|General Chinese OCR model|Resnet34_vd|rec_chinese_common_train.yml|[Download link](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn.tar)|[inference model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance_infer.tar) & [pre-trained model](https://paddleocr.bj.bcebos.com/ch_models/ch_rec_r34_vd_crnn_enhance.tar)|
-
-Please refer to the document for training guide and use of PaddleOCR text recognition algorithms [Text recognition model training/evaluation/prediction](./doc/doc_en/recognition_en.md)
-
-## END-TO-END OCR ALGORITHM
-- [ ]  [End2End-PSL](https://arxiv.org/abs/1909.07808)(Baidu Self-Research, comming soon)
-
-<a name="lightweight-Chinese-OCR-results"></a>
-## LIGHTWEIGHT CHINESE OCR RESULTS
-![](doc/imgs_results/1.jpg)
-![](doc/imgs_results/7.jpg)
-![](doc/imgs_results/12.jpg)
-![](doc/imgs_results/4.jpg)
-![](doc/imgs_results/6.jpg)
-![](doc/imgs_results/9.jpg)
-![](doc/imgs_results/16.png)
-![](doc/imgs_results/22.jpg)
-
-<a name="General-Chinese-OCR-results"></a>
-## General Chinese OCR results
-![](doc/imgs_results/chinese_db_crnn_server/11.jpg)
-![](doc/imgs_results/chinese_db_crnn_server/2.jpg)
-![](doc/imgs_results/chinese_db_crnn_server/8.jpg)
-
-<a name="Space-Chinese-OCR-results"></a>
-
-## space Chinese OCR results
-
-### LIGHTWEIGHT CHINESE OCR RESULTS
-
-![](doc/imgs_results/img_11.jpg)
-
-### General Chinese OCR results
-![](doc/imgs_results/chinese_db_crnn_server/en_paper.jpg)
-
-<a name="FAQ"></a>
-## FAQ
-1. Error when using attention-based recognition model: KeyError: 'predict'
-
-    The inference of recognition model based on attention loss is still being debugged. For Chinese text recognition, it is recommended to choose the recognition model based on CTC loss first. In practice, it is also found that the recognition model based on attention loss is not as effective as the one based on CTC loss.
-
-2. About inference speed
-
-    When there are a lot of texts in the picture, the prediction time will increase. You can use `--rec_batch_num` to set a smaller prediction batch size. The default value is 30, which can be changed to 10 or other values.
-
-3. Service deployment and mobile deployment
-
-    It is expected that the service deployment based on Serving and the mobile deployment based on Paddle Lite will be released successively in mid-to-late June. Stay tuned for more updates.
-
-4. Release time of self-developed algorithm
-
-    Baidu Self-developed algorithms such as SAST, SRN and end2end PSL will be released in June or July. Please be patient.
-
-[more](./doc/doc_en/FAQ_en.md)
-
-## WELCOME TO THE PaddleOCR TECHNICAL EXCHANGE GROUP
-WeChat: paddlehelp, note OCR, our assistant will get you into the group~
-
-<img src="./doc/paddlehelp.jpg"  width = "200" height = "200" />
-
-## REFERENCES
-```
-1. EAST:
-@inproceedings{zhou2017east,
-  title={EAST: an efficient and accurate scene text detector},
-  author={Zhou, Xinyu and Yao, Cong and Wen, He and Wang, Yuzhi and Zhou, Shuchang and He, Weiran and Liang, Jiajun},
-  booktitle={Proceedings of the IEEE conference on Computer Vision and Pattern Recognition},
-  pages={5551--5560},
-  year={2017}
-}
-
-2. DB:
-@article{liao2019real,
-  title={Real-time Scene Text Detection with Differentiable Binarization},
-  author={Liao, Minghui and Wan, Zhaoyi and Yao, Cong and Chen, Kai and Bai, Xiang},
-  journal={arXiv preprint arXiv:1911.08947},
-  year={2019}
-}
-
-3. DTRB:
-@inproceedings{baek2019wrong,
-  title={What is wrong with scene text recognition model comparisons? dataset and model analysis},
-  author={Baek, Jeonghun and Kim, Geewook and Lee, Junyeop and Park, Sungrae and Han, Dongyoon and Yun, Sangdoo and Oh, Seong Joon and Lee, Hwalsuk},
-  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
-  pages={4715--4723},
-  year={2019}
-}
-
-4. SAST:
-@inproceedings{wang2019single,
-  title={A Single-Shot Arbitrarily-Shaped Text Detector based on Context Attended Multi-Task Learning},
-  author={Wang, Pengfei and Zhang, Chengquan and Qi, Fei and Huang, Zuming and En, Mengyi and Han, Junyu and Liu, Jingtuo and Ding, Errui and Shi, Guangming},
-  booktitle={Proceedings of the 27th ACM International Conference on Multimedia},
-  pages={1277--1285},
-  year={2019}
-}
-
-5. SRN:
-@article{yu2020towards,
-  title={Towards Accurate Scene Text Recognition with Semantic Reasoning Networks},
-  author={Yu, Deli and Li, Xuan and Zhang, Chengquan and Han, Junyu and Liu, Jingtuo and Ding, Errui},
-  journal={arXiv preprint arXiv:2003.12294},
-  year={2020}
-}
-
-6. end2end-psl:
-@inproceedings{sun2019chinese,
-  title={Chinese Street View Text: Large-scale Chinese Text Reading with Partially Supervised Learning},
-  author={Sun, Yipeng and Liu, Jiaming and Liu, Wei and Han, Junyu and Ding, Errui and Liu, Jingtuo},
-  booktitle={Proceedings of the IEEE International Conference on Computer Vision},
-  pages={9086--9095},
-  year={2019}
-}
-```
-
-## LICENSE
-This project is released under <a href="https://github.com/PaddlePaddle/PaddleOCR/blob/master/LICENSE">Apache 2.0 license</a>
-
-## CONTRIBUTION
-We welcome all the contributions to PaddleOCR and appreciate for your feedback very much.
-
-- Many thanks to [Khanh Tran](https://github.com/xxxpsyduck) for contributing the English documentation.
-- Many thanks to [zhangxin](https://github.com/ZhangXinNan) for contributing the new visualize function、add .gitgnore and discard set PYTHONPATH manually.
-- Many thanks to [lyl120117](https://github.com/lyl120117) for contributing the code for printing the network structure.

deploy/android_demo/.gitignore

+*.iml
+.gradle
+/local.properties
+/.idea/*
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+

deploy/android_demo/README.md

+# 如何快速测试
+### 1. 安装最新版本的Android Studio
+可以从https://developer.android.com/studio下载。本Demo使用是4.0版本Android Studio编写。
+
+### 2. 按照NDK 20 以上版本 
+Demo测试的时候使用的是NDK 20b版本，20版本以上均可以支持编译成功。
+
+如果您是初学者，可以用以下方式安装和测试NDK编译环境。
+点击 File -> New ->New Project，  新建  "Native C++" project
+
+### 3. 导入项目
+点击 File->New->Import Project...， 然后跟着Android Studio的引导导入
+
+
+# 获得更多支持
+前往[端计算模型生成平台EasyEdge](https://ai.baidu.com/easyedge/app/open_source_demo?referrerUrl=paddlelite)，获得更多开发支持：
+
+- Demo APP：可使用手机扫码安装，方便手机端快速体验文字识别
+- SDK：模型被封装为适配不同芯片硬件和操作系统SDK，包括完善的接口，方便进行二次开发

deploy/android_demo/app/.gitignore

+/build

deploy/android_demo/app/build.gradle

+import java.security.MessageDigest
+
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 28
+    defaultConfig {
+        applicationId "com.baidu.paddle.lite.demo.ocr"
+        minSdkVersion 15
+        targetSdkVersion 28
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        externalNativeBuild {
+            cmake {
+                cppFlags "-std=c++11 -frtti -fexceptions -Wno-format"
+                arguments '-DANDROID_PLATFORM=android-23', '-DANDROID_STL=c++_shared' ,"-DANDROID_ARM_NEON=TRUE"
+            }
+        }
+        ndk {
+            // abiFilters "arm64-v8a", "armeabi-v7a"
+            abiFilters   "arm64-v8a", "armeabi-v7a"
+            ldLibs "jnigraphics"
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    externalNativeBuild {
+        cmake {
+            path "src/main/cpp/CMakeLists.txt"
+            version "3.10.2"
+        }
+    }
+}
+
+dependencies {
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation 'com.android.support:appcompat-v7:28.0.0'
+    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
+    implementation 'com.android.support:design:28.0.0'
+    testImplementation 'junit:junit:4.12'
+    androidTestImplementation 'com.android.support.test:runner:1.0.2'
+    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
+}
+
+def archives = [
+        [
+                'src' : 'https://paddlelite-demo.bj.bcebos.com/libs/android/paddle_lite_libs_v2_6_1.tar.gz',
+                'dest': 'PaddleLite'
+        ],
+        [
+                'src' : 'https://paddlelite-demo.bj.bcebos.com/libs/android/opencv-4.2.0-android-sdk.tar.gz',
+                'dest': 'OpenCV'
+        ],
+        [
+                'src' : 'https://paddleocr.bj.bcebos.com/deploy/lite/ocr_v1_for_cpu.tar.gz',
+                'dest' : 'src/main/assets/models/ocr_v1_for_cpu'
+        ]
+]
+
+task downloadAndExtractArchives(type: DefaultTask) {
+    doFirst {
+        println "Downloading and extracting archives including libs and models"
+    }
+    doLast {
+        // Prepare cache folder for archives
+        String cachePath = "cache"
+        if (!file("${cachePath}").exists()) {
+            mkdir "${cachePath}"
+        }
+        archives.eachWithIndex { archive, index ->
+            MessageDigest messageDigest = MessageDigest.getInstance('MD5')
+            messageDigest.update(archive.src.bytes)
+            String cacheName = new BigInteger(1, messageDigest.digest()).toString(32)
+            // Download the target archive if not exists
+            boolean copyFiles = !file("${archive.dest}").exists()
+            if (!file("${cachePath}/${cacheName}.tar.gz").exists()) {
+                ant.get(src: archive.src, dest: file("${cachePath}/${cacheName}.tar.gz"))
+                copyFiles = true; // force to copy files from the latest archive files
+            }
+            // Extract the target archive if its dest path does not exists
+            if (copyFiles) {
+                copy {
+                    from tarTree("${cachePath}/${cacheName}.tar.gz")
+                    into "${archive.dest}"
+                }
+            }
+        }
+    }
+}
+preBuild.dependsOn downloadAndExtractArchives
\ No newline at end of file

deploy/android_demo/app/proguard-rules.pro

+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

deploy/android_demo/app/src/androidTest/java/com/baidu/paddle/lite/demo/ocr/ExampleInstrumentedTest.java

+package com.baidu.paddle.lite.demo.ocr;
+
+import android.content.Context;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import static org.junit.Assert.*;
+
+/**
+ * Instrumented test, which will execute on an Android device.
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+@RunWith(AndroidJUnit4.class)
+public class ExampleInstrumentedTest {
+    @Test
+    public void useAppContext() {
+        // Context of the app under test.
+        Context appContext = InstrumentationRegistry.getTargetContext();
+
+        assertEquals("com.baidu.paddle.lite.demo", appContext.getPackageName());
+    }
+}

deploy/android_demo/app/src/main/AndroidManifest.xml

+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.baidu.paddle.lite.demo.ocr">
+
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.CAMERA"/>
+
+
+    <application
+            android:allowBackup="true"
+            android:icon="@mipmap/ic_launcher"
+            android:label="@string/app_name"
+            android:roundIcon="@mipmap/ic_launcher_round"
+            android:supportsRtl="true"
+            android:theme="@style/AppTheme">
+        <activity android:name="com.baidu.paddle.lite.demo.ocr.MainActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        <activity
+                android:name="com.baidu.paddle.lite.demo.ocr.SettingsActivity"
+                android:label="Settings">
+        </activity>
+    </application>
+
+</manifest>
\ No newline at end of file

deploy/android_demo/app/src/main/cpp/CMakeLists.txt

+# For more information about using CMake with Android Studio, read the
+# documentation: https://d.android.com/studio/projects/add-native-code.html
+
+# Sets the minimum version of CMake required to build the native library.
+
+cmake_minimum_required(VERSION 3.4.1)
+
+# Creates and names a library, sets it as either STATIC or SHARED, and provides
+# the relative paths to its source code. You can define multiple libraries, and
+# CMake builds them for you. Gradle automatically packages shared libraries with
+# your APK.
+
+set(PaddleLite_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../PaddleLite")
+include_directories(${PaddleLite_DIR}/cxx/include)
+
+set(OpenCV_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../OpenCV/sdk/native/jni")
+message(STATUS "opencv dir: ${OpenCV_DIR}")
+find_package(OpenCV REQUIRED)
+message(STATUS "OpenCV libraries: ${OpenCV_LIBS}")
+include_directories(${OpenCV_INCLUDE_DIRS})
+aux_source_directory(. SOURCES)
+set(CMAKE_CXX_FLAGS
+        "${CMAKE_CXX_FLAGS} -ffast-math -Ofast -Os"
+        )
+set(CMAKE_CXX_FLAGS
+        "${CMAKE_CXX_FLAGS} -fvisibility=hidden -fvisibility-inlines-hidden -fdata-sections -ffunction-sections"
+        )
+set(CMAKE_SHARED_LINKER_FLAGS
+        "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--gc-sections -Wl,-z,nocopyreloc")
+
+add_library(
+        # Sets the name of the library.
+        Native
+        # Sets the library as a shared library.
+        SHARED
+        # Provides a relative path to your source file(s).
+        ${SOURCES})
+
+find_library(
+        # Sets the name of the path variable.
+        log-lib
+        # Specifies the name of the NDK library that you want CMake to locate.
+        log)
+
+add_library(
+        # Sets the name of the library.
+        paddle_light_api_shared
+        # Sets the library as a shared library.
+        SHARED
+        # Provides a relative path to your source file(s).
+        IMPORTED)
+
+set_target_properties(
+        # Specifies the target library.
+        paddle_light_api_shared
+        # Specifies the parameter you want to define.
+        PROPERTIES
+        IMPORTED_LOCATION
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libpaddle_light_api_shared.so
+        # Provides the path to the library you want to import.
+)
+
+
+# Specifies libraries CMake should link to your target library. You can link
+# multiple libraries, such as libraries you define in this build script,
+# prebuilt third-party libraries, or system libraries.
+
+target_link_libraries(
+        # Specifies the target library.
+        Native
+        paddle_light_api_shared
+        ${OpenCV_LIBS}
+        GLESv2
+        EGL
+        jnigraphics
+        ${log-lib}
+)
+
+add_custom_command(
+        TARGET Native
+        POST_BUILD
+        COMMAND
+        ${CMAKE_COMMAND} -E copy
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libc++_shared.so
+        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libc++_shared.so)
+
+add_custom_command(
+        TARGET Native
+        POST_BUILD
+        COMMAND
+        ${CMAKE_COMMAND} -E copy
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libpaddle_light_api_shared.so
+        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libpaddle_light_api_shared.so)
+
+add_custom_command(
+        TARGET Native
+        POST_BUILD
+        COMMAND
+        ${CMAKE_COMMAND} -E copy
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libhiai.so
+        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libhiai.so)
+
+add_custom_command(
+        TARGET Native
+        POST_BUILD
+        COMMAND
+        ${CMAKE_COMMAND} -E copy
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libhiai_ir.so
+        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libhiai_ir.so)
+
+add_custom_command(
+        TARGET Native
+        POST_BUILD
+        COMMAND
+        ${CMAKE_COMMAND} -E copy
+        ${PaddleLite_DIR}/cxx/libs/${ANDROID_ABI}/libhiai_ir_build.so
+        ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libhiai_ir_build.so)
\ No newline at end of file

deploy/android_demo/app/src/main/cpp/common.h

+//
+// Created by fu on 4/25/18.
+//
+
+#pragma once
+#import <vector>
+#import <numeric>
+
+#ifdef __ANDROID__
+
+#include <android/log.h>
+
+#define LOG_TAG "OCR_NDK"
+
+#define LOGI(...) \
+  __android_log_print(ANDROID_LOG_INFO,  LOG_TAG,  __VA_ARGS__)
+#define LOGW(...) \
+  __android_log_print(ANDROID_LOG_WARN,  LOG_TAG,  __VA_ARGS__)
+#define LOGE(...) \
+  __android_log_print(ANDROID_LOG_ERROR,  LOG_TAG,  __VA_ARGS__)
+#else
+#include <stdio.h>
+#define LOGI(format, ...) \
+  fprintf(stdout, "[" LOG_TAG "]" format "\n", ##__VA_ARGS__)
+#define LOGW(format, ...) \
+  fprintf(stdout, "[" LOG_TAG "]" format "\n", ##__VA_ARGS__)
+#define LOGE(format, ...) \
+  fprintf(stderr, "[" LOG_TAG "]Error: " format "\n", ##__VA_ARGS__)
+#endif
+
+enum RETURN_CODE {
+    RETURN_OK = 0
+};
+
+enum NET_TYPE{
+    NET_OCR = 900100,
+    NET_OCR_INTERNAL = 991008
+};
+
+
+template <typename  T>
+inline T product(const std::vector<T> &vec) {
+    if (vec.empty()){
+        return 0;
+    }
+    return std::accumulate(vec.begin(), vec.end(), 1, std::multiplies<T>());
+}
+

deploy/android_demo/app/src/main/cpp/native.cpp

+//
+// Created by fujiayi on 2020/7/5.
+//
+
+#include "native.h"
+#include "ocr_ppredictor.h"
+#include <string>
+#include <algorithm>
+#include <paddle_api.h>
+
+static paddle::lite_api::PowerMode str_to_cpu_mode(const std::string &cpu_mode);
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_com_baidu_paddle_lite_demo_ocr_OCRPredictorNative_init(JNIEnv *env, jobject thiz,
+                                                            jstring j_det_model_path,
+                                                            jstring j_rec_model_path,
+                                                            jint j_thread_num,
+                                                            jstring j_cpu_mode) {
+    std::string det_model_path = jstring_to_cpp_string(env, j_det_model_path);
+    std::string rec_model_path = jstring_to_cpp_string(env, j_rec_model_path);
+    int thread_num = j_thread_num;
+    std::string cpu_mode = jstring_to_cpp_string(env, j_cpu_mode);
+    ppredictor::OCR_Config conf;
+    conf.thread_num = thread_num;
+    conf.mode = str_to_cpu_mode(cpu_mode);
+    ppredictor::OCR_PPredictor *orc_predictor = new ppredictor::OCR_PPredictor{conf};
+    orc_predictor->init_from_file(det_model_path, rec_model_path);
+    return reinterpret_cast<jlong>(orc_predictor);
+}
+
+/**
+ * "LITE_POWER_HIGH" 转为 paddle::lite_api::LITE_POWER_HIGH
+ * @param cpu_mode
+ * @return
+ */
+static paddle::lite_api::PowerMode str_to_cpu_mode(const std::string &cpu_mode) {
+    static std::map<std::string, paddle::lite_api::PowerMode> cpu_mode_map{
+        {"LITE_POWER_HIGH",      paddle::lite_api::LITE_POWER_HIGH},
+        {"LITE_POWER_LOW",       paddle::lite_api::LITE_POWER_HIGH},
+        {"LITE_POWER_FULL",      paddle::lite_api::LITE_POWER_FULL},
+        {"LITE_POWER_NO_BIND",   paddle::lite_api::LITE_POWER_NO_BIND},
+        {"LITE_POWER_RAND_HIGH", paddle::lite_api::LITE_POWER_RAND_HIGH},
+        {"LITE_POWER_RAND_LOW",  paddle::lite_api::LITE_POWER_RAND_LOW}
+    };
+    std::string upper_key;
+    std::transform(cpu_mode.cbegin(), cpu_mode.cend(), upper_key.begin(), ::toupper);
+    auto index = cpu_mode_map.find(upper_key);
+    if (index == cpu_mode_map.end()) {
+        LOGE("cpu_mode not found %s", upper_key.c_str());
+        return paddle::lite_api::LITE_POWER_HIGH;
+    } else {
+        return index->second;
+    }
+
+}
+
+extern "C"
+JNIEXPORT jfloatArray JNICALL
+Java_com_baidu_paddle_lite_demo_ocr_OCRPredictorNative_forward(JNIEnv *env, jobject thiz,
+                                                               jlong java_pointer, jfloatArray buf,
+                                                               jfloatArray ddims,
+                                                               jobject original_image) {
+    LOGI("begin to run native forward");
+    if (java_pointer == 0) {
+        LOGE("JAVA pointer is NULL");
+        return cpp_array_to_jfloatarray(env, nullptr, 0);
+    }
+    cv::Mat origin = bitmap_to_cv_mat(env, original_image);
+    if (origin.size == 0) {
+        LOGE("origin bitmap cannot convert to CV Mat");
+        return cpp_array_to_jfloatarray(env, nullptr, 0);
+    }
+    ppredictor::OCR_PPredictor *ppredictor = (ppredictor::OCR_PPredictor *) java_pointer;
+    std::vector<float> dims_float_arr = jfloatarray_to_float_vector(env, ddims);
+    std::vector<int64_t> dims_arr;
+    dims_arr.resize(dims_float_arr.size());
+    std::copy(dims_float_arr.cbegin(), dims_float_arr.cend(), dims_arr.begin());
+
+    // 这里值有点大，就不调用jfloatarray_to_float_vector了
+    int64_t buf_len = (int64_t) env->GetArrayLength(buf);
+    jfloat *buf_data = env->GetFloatArrayElements(buf, JNI_FALSE);
+    float *data = (jfloat *) buf_data;
+    std::vector<ppredictor::OCRPredictResult> results = ppredictor->infer_ocr(dims_arr, data,
+                                                                              buf_len,
+                                                                              NET_OCR, origin);
+    LOGI("infer_ocr finished with boxes %ld", results.size());
+    // 这里将std::vector<ppredictor::OCRPredictResult> 序列化成 float数组，传输到java层再反序列化
+    std::vector<float> float_arr;
+    for (const ppredictor::OCRPredictResult &r :results) {
+        float_arr.push_back(r.points.size());
+        float_arr.push_back(r.word_index.size());
+        float_arr.push_back(r.score);
+        for (const std::vector<int> &point : r.points) {
+            float_arr.push_back(point.at(0));
+            float_arr.push_back(point.at(1));
+        }
+        for (int index: r.word_index) {
+            float_arr.push_back(index);
+        }
+    }
+    return cpp_array_to_jfloatarray(env, float_arr.data(), float_arr.size());
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_com_baidu_paddle_lite_demo_ocr_OCRPredictorNative_release(JNIEnv *env, jobject thiz,
+                                                               jlong java_pointer){
+    if (java_pointer == 0) {
+        LOGE("JAVA pointer is NULL");
+        return;
+    }
+    ppredictor::OCR_PPredictor *ppredictor = (ppredictor::OCR_PPredictor *) java_pointer;
+    delete ppredictor;
+}
\ No newline at end of file

deploy/android_demo/app/src/main/cpp/native.h

+//
+// Created by fujiayi on 2020/7/5.
+//
+
+#pragma once
+
+
+#include <jni.h>
+#include <string>
+#include <vector>
+#include <android/bitmap.h>
+#include <opencv2/opencv.hpp>
+#include "common.h"
+
+inline std::string jstring_to_cpp_string(JNIEnv *env, jstring jstr) {
+    // In java, a unicode char will be encoded using 2 bytes (utf16).
+    // so jstring will contain characters utf16. std::string in c++ is
+    // essentially a string of bytes, not characters, so if we want to
+    // pass jstring from JNI to c++, we have convert utf16 to bytes.
+    if (!jstr) {
+        return "";
+    }
+    const jclass stringClass = env->GetObjectClass(jstr);
+    const jmethodID getBytes =
+        env->GetMethodID(stringClass, "getBytes", "(Ljava/lang/String;)[B");
+    const jbyteArray stringJbytes = (jbyteArray) env->CallObjectMethod(
+        jstr, getBytes, env->NewStringUTF("UTF-8"));
+
+    size_t length = (size_t) env->GetArrayLength(stringJbytes);
+    jbyte *pBytes = env->GetByteArrayElements(stringJbytes, NULL);
+
+    std::string ret = std::string(reinterpret_cast<char *>(pBytes), length);
+    env->ReleaseByteArrayElements(stringJbytes, pBytes, JNI_ABORT);
+
+    env->DeleteLocalRef(stringJbytes);
+    env->DeleteLocalRef(stringClass);
+    return ret;
+}
+
+inline jstring cpp_string_to_jstring(JNIEnv *env, std::string str) {
+    auto *data = str.c_str();
+    jclass strClass = env->FindClass("java/lang/String");
+    jmethodID strClassInitMethodID =
+        env->GetMethodID(strClass, "<init>", "([BLjava/lang/String;)V");
+
+    jbyteArray bytes = env->NewByteArray(strlen(data));
+    env->SetByteArrayRegion(bytes, 0, strlen(data),
+                            reinterpret_cast<const jbyte *>(data));
+
+    jstring encoding = env->NewStringUTF("UTF-8");
+    jstring res = (jstring) (
+        env->NewObject(strClass, strClassInitMethodID, bytes, encoding));
+
+    env->DeleteLocalRef(strClass);
+    env->DeleteLocalRef(encoding);
+    env->DeleteLocalRef(bytes);
+
+    return res;
+}
+
+inline jfloatArray cpp_array_to_jfloatarray(JNIEnv *env, const float *buf,
+                                            int64_t len) {
+    if (len == 0) {
+        return env->NewFloatArray(0);
+    }
+    jfloatArray result = env->NewFloatArray(len);
+    env->SetFloatArrayRegion(result, 0, len, buf);
+    return result;
+}
+
+inline jintArray cpp_array_to_jintarray(JNIEnv *env, const int *buf,
+                                        int64_t len) {
+    jintArray result = env->NewIntArray(len);
+    env->SetIntArrayRegion(result, 0, len, buf);
+    return result;
+}
+
+inline jbyteArray cpp_array_to_jbytearray(JNIEnv *env, const int8_t *buf,
+                                          int64_t len) {
+    jbyteArray result = env->NewByteArray(len);
+    env->SetByteArrayRegion(result, 0, len, buf);
+    return result;
+}
+
+inline jlongArray int64_vector_to_jlongarray(JNIEnv *env,
+                                             const std::vector<int64_t> &vec) {
+    jlongArray result = env->NewLongArray(vec.size());
+    jlong *buf = new jlong[vec.size()];
+    for (size_t i = 0; i < vec.size(); ++i) {
+        buf[i] = (jlong) vec[i];
+    }
+    env->SetLongArrayRegion(result, 0, vec.size(), buf);
+    delete[] buf;
+    return result;
+}
+
+inline std::vector<int64_t> jlongarray_to_int64_vector(JNIEnv *env,
+                                                       jlongArray data) {
+    int data_size = env->GetArrayLength(data);
+    jlong *data_ptr = env->GetLongArrayElements(data, nullptr);
+    std::vector<int64_t> data_vec(data_ptr, data_ptr + data_size);
+    env->ReleaseLongArrayElements(data, data_ptr, 0);
+    return data_vec;
+}
+
+inline std::vector<float> jfloatarray_to_float_vector(JNIEnv *env,
+                                                      jfloatArray data) {
+    int data_size = env->GetArrayLength(data);
+    jfloat *data_ptr = env->GetFloatArrayElements(data, nullptr);
+    std::vector<float> data_vec(data_ptr, data_ptr + data_size);
+    env->ReleaseFloatArrayElements(data, data_ptr, 0);
+    return data_vec;
+}
+
+inline cv::Mat bitmap_to_cv_mat(JNIEnv *env, jobject bitmap) {
+    AndroidBitmapInfo info;
+    int result = AndroidBitmap_getInfo(env, bitmap, &info);
+    if (result != ANDROID_BITMAP_RESULT_SUCCESS) {
+        LOGE("AndroidBitmap_getInfo failed, result: %d", result);
+        return cv::Mat{};
+    }
+    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
+        LOGE("Bitmap format is not RGBA_8888 !");
+        return cv::Mat{};
+    }
+    unsigned char *srcData = NULL;
+    AndroidBitmap_lockPixels(env, bitmap, (void **) &srcData);
+    cv::Mat mat = cv::Mat::zeros(info.height, info.width, CV_8UC4);
+    memcpy(mat.data, srcData, info.height * info.width * 4);
+    AndroidBitmap_unlockPixels(env, bitmap);
+    cv::cvtColor(mat, mat, cv::COLOR_RGBA2BGR);
+    /**
+    if (!cv::imwrite("/sdcard/1/copy.jpg", mat)){
+        LOGE("Write image failed " );
+    }
+     */
+    return mat;
+}

deploy/android_demo/app/src/main/cpp/ocr_clipper.hpp

+/*******************************************************************************
+*                                                                              *
+* 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              *
+*                                                                              *
+*******************************************************************************/
+
+#ifndef clipper_hpp
+#define clipper_hpp
+
+#define CLIPPER_VERSION "6.4.2"
+
+//use_int32: When enabled 32bit ints are used instead of 64bit ints. This
+//improve performance but coordinate values are limited to the range +/- 46340
+//#define use_int32
+
+//use_xyz: adds a Z member to IntPoint. Adds a minor cost to perfomance.
+//#define use_xyz
+
+//use_lines: Enables line clipping. Adds a very minor cost to performance.
+#define use_lines
+
+//use_deprecated: Enables temporary support for the obsolete functions
+//#define use_deprecated
+
+#include <vector>
+#include <list>
+#include <set>
+#include <stdexcept>
+#include <cstring>
+#include <cstdlib>
+#include <ostream>
+#include <functional>
+#include <queue>
+
+namespace ClipperLib {
+
+enum ClipType {
+    ctIntersection, ctUnion, ctDifference, ctXor
+};
+enum PolyType {
+    ptSubject, ptClip
+};
+//By far the most widely used winding rules for polygon filling are
+//EvenOdd & NonZero (GDI, GDI+, XLib, OpenGL, Cairo, AGG, Quartz, SVG, Gr32)
+//Others rules include Positive, Negative and ABS_GTR_EQ_TWO (only in OpenGL)
+//see http://glprogramming.com/red/chapter11.html
+enum PolyFillType {
+    pftEvenOdd, pftNonZero, pftPositive, pftNegative
+};
+
+#ifdef use_int32
+typedef int cInt;
+static cInt const loRange = 0x7FFF;
+static cInt const hiRange = 0x7FFF;
+#else
+typedef signed long long cInt;
+static cInt const loRange = 0x3FFFFFFF;
+static cInt const hiRange = 0x3FFFFFFFFFFFFFFFLL;
+typedef signed long long long64;     //used by Int128 class
+typedef unsigned long long ulong64;
+
+#endif
+
+struct IntPoint {
+    cInt X;
+    cInt Y;
+#ifdef use_xyz
+    cInt Z;
+    IntPoint(cInt x = 0, cInt y = 0, cInt z = 0): X(x), Y(y), Z(z) {};
+#else
+
+    IntPoint(cInt x = 0, cInt y = 0) : X(x), Y(y) {};
+#endif
+
+    friend inline bool operator==(const IntPoint &a, const IntPoint &b) {
+        return a.X == b.X && a.Y == b.Y;
+    }
+
+    friend inline bool operator!=(const IntPoint &a, const IntPoint &b) {
+        return a.X != b.X || a.Y != b.Y;
+    }
+};
+//------------------------------------------------------------------------------
+
+typedef std::vector <IntPoint> Path;
+typedef std::vector <Path> Paths;
+
+inline Path &operator<<(Path &poly, const IntPoint &p) {
+    poly.push_back(p);
+    return poly;
+}
+
+inline Paths &operator<<(Paths &polys, const Path &p) {
+    polys.push_back(p);
+    return polys;
+}
+
+std::ostream &operator<<(std::ostream &s, const IntPoint &p);
+
+std::ostream &operator<<(std::ostream &s, const Path &p);
+
+std::ostream &operator<<(std::ostream &s, const Paths &p);
+
+struct DoublePoint {
+    double X;
+    double Y;
+
+    DoublePoint(double x = 0, double y = 0) : X(x), Y(y) {}
+
+    DoublePoint(IntPoint ip) : X((double) ip.X), Y((double) ip.Y) {}
+};
+//------------------------------------------------------------------------------
+
+#ifdef use_xyz
+typedef void (*ZFillCallback)(IntPoint& e1bot, IntPoint& e1top, IntPoint& e2bot, IntPoint& e2top, IntPoint& pt);
+#endif
+
+enum InitOptions {
+    ioReverseSolution = 1, ioStrictlySimple = 2, ioPreserveCollinear = 4
+};
+enum JoinType {
+    jtSquare, jtRound, jtMiter
+};
+enum EndType {
+    etClosedPolygon, etClosedLine, etOpenButt, etOpenSquare, etOpenRound
+};
+
+class PolyNode;
+
+typedef std::vector<PolyNode *> PolyNodes;
+
+class PolyNode {
+public:
+    PolyNode();
+
+    virtual ~PolyNode() {};
+    Path Contour;
+    PolyNodes Childs;
+    PolyNode *Parent;
+
+    PolyNode *GetNext() const;
+
+    bool IsHole() const;
+
+    bool IsOpen() const;
+
+    int ChildCount() const;
+
+private:
+    //PolyNode& operator =(PolyNode& other);
+    unsigned Index; //node index in Parent.Childs
+    bool m_IsOpen;
+    JoinType m_jointype;
+    EndType m_endtype;
+
+    PolyNode *GetNextSiblingUp() const;
+
+    void AddChild(PolyNode &child);
+
+    friend class Clipper; //to access Index
+    friend class ClipperOffset;
+};
+
+class PolyTree : public PolyNode {
+public:
+    ~PolyTree() { Clear(); };
+
+    PolyNode *GetFirst() const;
+
+    void Clear();
+
+    int Total() const;
+
+private:
+    //PolyTree& operator =(PolyTree& other);
+    PolyNodes AllNodes;
+
+    friend class Clipper; //to access AllNodes
+};
+
+bool Orientation(const Path &poly);
+
+double Area(const Path &poly);
+
+int PointInPolygon(const IntPoint &pt, const Path &path);
+
+void SimplifyPolygon(const Path &in_poly, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
+
+void SimplifyPolygons(const Paths &in_polys, Paths &out_polys, PolyFillType fillType = pftEvenOdd);
+
+void SimplifyPolygons(Paths &polys, PolyFillType fillType = pftEvenOdd);
+
+void CleanPolygon(const Path &in_poly, Path &out_poly, double distance = 1.415);
+
+void CleanPolygon(Path &poly, double distance = 1.415);
+
+void CleanPolygons(const Paths &in_polys, Paths &out_polys, double distance = 1.415);
+
+void CleanPolygons(Paths &polys, double distance = 1.415);
+
+void MinkowskiSum(const Path &pattern, const Path &path, Paths &solution, bool pathIsClosed);
+
+void MinkowskiSum(const Path &pattern, const Paths &paths, Paths &solution, bool pathIsClosed);
+
+void MinkowskiDiff(const Path &poly1, const Path &poly2, Paths &solution);
+
+void PolyTreeToPaths(const PolyTree &polytree, Paths &paths);
+
+void ClosedPathsFromPolyTree(const PolyTree &polytree, Paths &paths);
+
+void OpenPathsFromPolyTree(PolyTree &polytree, Paths &paths);
+
+void ReversePath(Path &p);
+
+void ReversePaths(Paths &p);
+
+struct IntRect {
+    cInt left;
+    cInt top;
+    cInt right;
+    cInt bottom;
+};
+
+//enums that are used internally ...
+enum EdgeSide {
+    esLeft = 1, esRight = 2
+};
+
+//forward declarations (for stuff used internally) ...
+struct TEdge;
+struct IntersectNode;
+struct LocalMinimum;
+struct OutPt;
+struct OutRec;
+struct Join;
+
+typedef std::vector<OutRec *> PolyOutList;
+typedef std::vector<TEdge *> EdgeList;
+typedef std::vector<Join *> JoinList;
+typedef std::vector<IntersectNode *> IntersectList;
+
+//------------------------------------------------------------------------------
+
+//ClipperBase is the ancestor to the Clipper class. It should not be
+//instantiated directly. This class simply abstracts the conversion of sets of
+//polygon coordinates into edge objects that are stored in a LocalMinima list.
+class ClipperBase {
+public:
+    ClipperBase();
+
+    virtual ~ClipperBase();
+
+    virtual bool AddPath(const Path &pg, PolyType PolyTyp, bool Closed);
+
+    bool AddPaths(const Paths &ppg, PolyType PolyTyp, bool Closed);
+
+    virtual void Clear();
+
+    IntRect GetBounds();
+
+    bool PreserveCollinear() { return m_PreserveCollinear; };
+
+    void PreserveCollinear(bool value) { m_PreserveCollinear = value; };
+protected:
+    void DisposeLocalMinimaList();
+
+    TEdge *AddBoundsToLML(TEdge *e, bool IsClosed);
+
+    virtual void Reset();
+
+    TEdge *ProcessBound(TEdge *E, bool IsClockwise);
+
+    void InsertScanbeam(const cInt Y);
+
+    bool PopScanbeam(cInt &Y);
+
+    bool LocalMinimaPending();
+
+    bool PopLocalMinima(cInt Y, const LocalMinimum *&locMin);
+
+    OutRec *CreateOutRec();
+
+    void DisposeAllOutRecs();
+
+    void DisposeOutRec(PolyOutList::size_type index);
+
+    void SwapPositionsInAEL(TEdge *edge1, TEdge *edge2);
+
+    void DeleteFromAEL(TEdge *e);
+
+    void UpdateEdgeIntoAEL(TEdge *&e);
+
+    typedef std::vector <LocalMinimum> MinimaList;
+    MinimaList::iterator m_CurrentLM;
+    MinimaList m_MinimaList;
+
+    bool m_UseFullRange;
+    EdgeList m_edges;
+    bool m_PreserveCollinear;
+    bool m_HasOpenPaths;
+    PolyOutList m_PolyOuts;
+    TEdge *m_ActiveEdges;
+
+    typedef std::priority_queue <cInt> ScanbeamList;
+    ScanbeamList m_Scanbeam;
+};
+//------------------------------------------------------------------------------
+
+class Clipper : public virtual ClipperBase {
+public:
+    Clipper(int initOptions = 0);
+
+    bool Execute(ClipType clipType,
+                 Paths &solution,
+                 PolyFillType fillType = pftEvenOdd);
+
+    bool Execute(ClipType clipType,
+                 Paths &solution,
+                 PolyFillType subjFillType,
+                 PolyFillType clipFillType);
+
+    bool Execute(ClipType clipType,
+                 PolyTree &polytree,
+                 PolyFillType fillType = pftEvenOdd);
+
+    bool Execute(ClipType clipType,
+                 PolyTree &polytree,
+                 PolyFillType subjFillType,
+                 PolyFillType clipFillType);
+
+    bool ReverseSolution() { return m_ReverseOutput; };
+
+    void ReverseSolution(bool value) { m_ReverseOutput = value; };
+
+    bool StrictlySimple() { return m_StrictSimple; };
+
+    void StrictlySimple(bool value) { m_StrictSimple = value; };
+    //set the callback function for z value filling on intersections (otherwise Z is 0)
+#ifdef use_xyz
+    void ZFillFunction(ZFillCallback zFillFunc);
+#endif
+protected:
+    virtual bool ExecuteInternal();
+
+private:
+    JoinList m_Joins;
+    JoinList m_GhostJoins;
+    IntersectList m_IntersectList;
+    ClipType m_ClipType;
+    typedef std::list <cInt> MaximaList;
+    MaximaList m_Maxima;
+    TEdge *m_SortedEdges;
+    bool m_ExecuteLocked;
+    PolyFillType m_ClipFillType;
+    PolyFillType m_SubjFillType;
+    bool m_ReverseOutput;
+    bool m_UsingPolyTree;
+    bool m_StrictSimple;
+#ifdef use_xyz
+    ZFillCallback   m_ZFill; //custom callback
+#endif
+
+    void SetWindingCount(TEdge &edge);
+
+    bool IsEvenOddFillType(const TEdge &edge) const;
+
+    bool IsEvenOddAltFillType(const TEdge &edge) const;
+
+    void InsertLocalMinimaIntoAEL(const cInt botY);
+
+    void InsertEdgeIntoAEL(TEdge *edge, TEdge *startEdge);
+
+    void AddEdgeToSEL(TEdge *edge);
+
+    bool PopEdgeFromSEL(TEdge *&edge);
+
+    void CopyAELToSEL();
+
+    void DeleteFromSEL(TEdge *e);
+
+    void SwapPositionsInSEL(TEdge *edge1, TEdge *edge2);
+
+    bool IsContributing(const TEdge &edge) const;
+
+    bool IsTopHorz(const cInt XPos);
+
+    void DoMaxima(TEdge *e);
+
+    void ProcessHorizontals();
+
+    void ProcessHorizontal(TEdge *horzEdge);
+
+    void AddLocalMaxPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+
+    OutPt *AddLocalMinPoly(TEdge *e1, TEdge *e2, const IntPoint &pt);
+
+    OutRec *GetOutRec(int idx);
+
+    void AppendPolygon(TEdge *e1, TEdge *e2);
+
+    void IntersectEdges(TEdge *e1, TEdge *e2, IntPoint &pt);
+
+    OutPt *AddOutPt(TEdge *e, const IntPoint &pt);
+
+    OutPt *GetLastOutPt(TEdge *e);
+
+    bool ProcessIntersections(const cInt topY);
+
+    void BuildIntersectList(const cInt topY);
+
+    void ProcessIntersectList();
+
+    void ProcessEdgesAtTopOfScanbeam(const cInt topY);
+
+    void BuildResult(Paths &polys);
+
+    void BuildResult2(PolyTree &polytree);
+
+    void SetHoleState(TEdge *e, OutRec *outrec);
+
+    void DisposeIntersectNodes();
+
+    bool FixupIntersectionOrder();
+
+    void FixupOutPolygon(OutRec &outrec);
+
+    void FixupOutPolyline(OutRec &outrec);
+
+    bool IsHole(TEdge *e);
+
+    bool FindOwnerFromSplitRecs(OutRec &outRec, OutRec *&currOrfl);
+
+    void FixHoleLinkage(OutRec &outrec);
+
+    void AddJoin(OutPt *op1, OutPt *op2, const IntPoint offPt);
+
+    void ClearJoins();
+
+    void ClearGhostJoins();
+
+    void AddGhostJoin(OutPt *op, const IntPoint offPt);
+
+    bool JoinPoints(Join *j, OutRec *outRec1, OutRec *outRec2);
+
+    void JoinCommonEdges();
+
+    void DoSimplePolygons();
+
+    void FixupFirstLefts1(OutRec *OldOutRec, OutRec *NewOutRec);
+
+    void FixupFirstLefts2(OutRec *InnerOutRec, OutRec *OuterOutRec);
+
+    void FixupFirstLefts3(OutRec *OldOutRec, OutRec *NewOutRec);
+
+#ifdef use_xyz
+    void SetZ(IntPoint& pt, TEdge& e1, TEdge& e2);
+#endif
+};
+//------------------------------------------------------------------------------
+
+class ClipperOffset {
+public:
+    ClipperOffset(double miterLimit = 2.0, double roundPrecision = 0.25);
+
+    ~ClipperOffset();
+
+    void AddPath(const Path &path, JoinType joinType, EndType endType);
+
+    void AddPaths(const Paths &paths, JoinType joinType, EndType endType);
+
+    void Execute(Paths &solution, double delta);
+
+    void Execute(PolyTree &solution, double delta);
+
+    void Clear();
+
+    double MiterLimit;
+    double ArcTolerance;
+private:
+    Paths m_destPolys;
+    Path m_srcPoly;
+    Path m_destPoly;
+    std::vector <DoublePoint> m_normals;
+    double m_delta, m_sinA, m_sin, m_cos;
+    double m_miterLim, m_StepsPerRad;
+    IntPoint m_lowest;
+    PolyNode m_polyNodes;
+
+    void FixOrientations();
+
+    void DoOffset(double delta);
+
+    void OffsetPoint(int j, int &k, JoinType jointype);
+
+    void DoSquare(int j, int k);
+
+    void DoMiter(int j, int k, double r);
+
+    void DoRound(int j, int k);
+};
+//------------------------------------------------------------------------------
+
+class clipperException : public std::exception {
+public:
+    clipperException(const char *description) : m_descr(description) {}
+
+    virtual ~clipperException() throw() {}
+
+    virtual const char *what() const throw() { return m_descr.c_str(); }
+
+private:
+    std::string m_descr;
+};
+//------------------------------------------------------------------------------
+
+} //ClipperLib namespace
+
+#endif //clipper_hpp
+
+

deploy/android_demo/app/src/main/cpp/ocr_crnn_process.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 "ocr_crnn_process.h"
+#include <iostream>
+#include <vector>
+#include <iostream>
+#include <cstring>
+#include <fstream>
+#include <cmath>
+
+const std::string CHARACTER_TYPE = "ch";
+const int MAX_DICT_LENGTH = 6624;
+const std::vector<int> REC_IMAGE_SHAPE = {3, 32, 320};
+
+static cv::Mat crnn_resize_norm_img(cv::Mat img, float wh_ratio) {
+    int imgC = REC_IMAGE_SHAPE[0];
+    int imgW = REC_IMAGE_SHAPE[2];
+    int imgH = REC_IMAGE_SHAPE[1];
+
+    if (CHARACTER_TYPE == "ch")
+        imgW = int(32 * wh_ratio);
+
+    float ratio = float(img.cols) / float(img.rows);
+    int resize_w = 0;
+    if (ceilf(imgH * ratio) > imgW)
+        resize_w = imgW;
+    else
+        resize_w = int(ceilf(imgH * ratio));
+    cv::Mat resize_img;
+    cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f, cv::INTER_CUBIC);
+
+    resize_img.convertTo(resize_img, CV_32FC3, 1 / 255.f);
+
+    for (int h = 0; h < resize_img.rows; h++) {
+        for (int w = 0; w < resize_img.cols; w++) {
+            resize_img.at<cv::Vec3f>(h, w)[0] = (resize_img.at<cv::Vec3f>(h, w)[0] - 0.5) * 2;
+            resize_img.at<cv::Vec3f>(h, w)[1] = (resize_img.at<cv::Vec3f>(h, w)[1] - 0.5) * 2;
+            resize_img.at<cv::Vec3f>(h, w)[2] = (resize_img.at<cv::Vec3f>(h, w)[2] - 0.5) * 2;
+        }
+    }
+
+    cv::Mat dist;
+    cv::copyMakeBorder(resize_img, dist, 0, 0, 0, int(imgW - resize_w), cv::BORDER_CONSTANT,
+                       {0, 0, 0});
+
+    return dist;
+
+}
+
+cv::Mat crnn_resize_img(const cv::Mat &img, float wh_ratio) {
+    int imgC = REC_IMAGE_SHAPE[0];
+    int imgW = REC_IMAGE_SHAPE[2];
+    int imgH = REC_IMAGE_SHAPE[1];
+
+    if (CHARACTER_TYPE == "ch") {
+        imgW = int(32 * wh_ratio);
+    }
+
+    float ratio = float(img.cols) / float(img.rows);
+    int resize_w = 0;
+    if (ceilf(imgH * ratio) > imgW)
+        resize_w = imgW;
+    else
+        resize_w = int(ceilf(imgH * ratio));
+    cv::Mat resize_img;
+    cv::resize(img, resize_img, cv::Size(resize_w, imgH));
+    return resize_img;
+}
+
+
+cv::Mat get_rotate_crop_image(const cv::Mat &srcimage, const std::vector<std::vector<int>> &box) {
+
+    std::vector<std::vector<int>> points = box;
+
+    int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+    int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+    int left = int(*std::min_element(x_collect, x_collect + 4));
+    int right = int(*std::max_element(x_collect, x_collect + 4));
+    int top = int(*std::min_element(y_collect, y_collect + 4));
+    int bottom = int(*std::max_element(y_collect, y_collect + 4));
+
+    cv::Mat img_crop;
+    srcimage(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
+
+    for (int i = 0; i < points.size(); i++) {
+        points[i][0] -= left;
+        points[i][1] -= top;
+    }
+
+    int img_crop_width = int(sqrt(pow(points[0][0] - points[1][0], 2) +
+                                  pow(points[0][1] - points[1][1], 2)));
+    int img_crop_height = int(sqrt(pow(points[0][0] - points[3][0], 2) +
+                                   pow(points[0][1] - points[3][1], 2)));
+
+    cv::Point2f pts_std[4];
+    pts_std[0] = cv::Point2f(0., 0.);
+    pts_std[1] = cv::Point2f(img_crop_width, 0.);
+    pts_std[2] = cv::Point2f(img_crop_width, img_crop_height);
+    pts_std[3] = cv::Point2f(0.f, img_crop_height);
+
+    cv::Point2f pointsf[4];
+    pointsf[0] = cv::Point2f(points[0][0], points[0][1]);
+    pointsf[1] = cv::Point2f(points[1][0], points[1][1]);
+    pointsf[2] = cv::Point2f(points[2][0], points[2][1]);
+    pointsf[3] = cv::Point2f(points[3][0], points[3][1]);
+
+    cv::Mat M = cv::getPerspectiveTransform(pointsf, pts_std);
+
+    cv::Mat dst_img;
+    cv::warpPerspective(img_crop, dst_img, M, cv::Size(img_crop_width, img_crop_height),
+                        cv::BORDER_REPLICATE);
+
+    if (float(dst_img.rows) >= float(dst_img.cols) * 1.5) {
+        /*
+        cv::Mat srcCopy = cv::Mat(dst_img.rows, dst_img.cols, dst_img.depth());
+        cv::transpose(dst_img, srcCopy);
+        cv::flip(srcCopy, srcCopy, 0);
+        return srcCopy;
+        */
+        cv::transpose(dst_img, dst_img);
+        cv::flip(dst_img, dst_img, 0);
+        return dst_img;
+    } else {
+        return dst_img;
+    }
+
+}
+

deploy/android_demo/app/src/main/cpp/ocr_crnn_process.h

+//
+// Created by fujiayi on 2020/7/3.
+//
+#pragma once
+
+#include <vector>
+#include <opencv2/opencv.hpp>
+#include "common.h"
+
+extern const std::vector<int> REC_IMAGE_SHAPE;
+
+cv::Mat get_rotate_crop_image(const cv::Mat &srcimage, const std::vector<std::vector<int>> &box);
+
+cv::Mat crnn_resize_img(const cv::Mat &img, float wh_ratio);
+
+template<class ForwardIterator>
+inline size_t argmax(ForwardIterator first, ForwardIterator last) {
+    return std::distance(first, std::max_element(first, last));
+}
\ No newline at end of file