Merge remote-tracking branch 'PaddlePaddle/dygraph' into dygraph

.gitignore

@@ -24,4 +24,8 @@ output/
 
 build/
 dist/
-paddleocr.egg-info/
+paddleocr.egg-info/
+/deploy/android_demo/app/OpenCV/
+/deploy/android_demo/app/PaddleLite/
+/deploy/android_demo/app/.cxx/
+/deploy/android_demo/app/cache/

README.md

@@ -43,7 +43,7 @@ The above pictures are the visualizations of the general ppocr_server model. For
 - Scan the QR code below with your Wechat, you can access to official technical exchange group. Look forward to your participation.
 
 <div align="center">
-<img src="https://raw.githubusercontent.com/PaddlePaddle/PaddleOCR/release/2.0/doc/joinus.PNG"  width = "200" height = "200" />
+<img src="https://raw.githubusercontent.com/PaddlePaddle/PaddleOCR/dygraph/doc/joinus.PNG"  width = "200" height = "200" />
 </div>
 
 

README_ch.md

@@ -46,7 +46,7 @@ PaddleOCR同时支持动态图与静态图两种编程范式
 - 微信扫描二维码加入官方交流群，获得更高效的问题答疑，与各行各业开发者充分交流，期待您的加入。
 
 <div align="center">
-<img src="https://raw.githubusercontent.com/PaddlePaddle/PaddleOCR/release/2.0/doc/joinus.PNG"  width = "200" height = "200" />
+<img src="https://raw.githubusercontent.com/PaddlePaddle/PaddleOCR/dygraph/doc/joinus.PNG"  width = "200" height = "200" />
 </div>
 
 ## 快速体验

configs/det/ch_ppocr_v2.0/ch_det_mv3_db_v2.0.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1200
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [3000, 2000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/MobileNetV3_large_x0_5_pretrained
   checkpoints:

configs/det/ch_ppocr_v2.0/ch_det_res18_db_v2.0.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1200
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [3000, 2000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/ResNet18_vd_pretrained
   checkpoints:

configs/det/det_mv3_db.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1200
   # evaluation is run every 2000 iterations
   eval_batch_step: [0, 2000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/MobileNetV3_large_x0_5_pretrained
   checkpoints:

configs/det/det_mv3_east.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1000
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [4000, 5000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/MobileNetV3_large_x0_5_pretrained
   checkpoints: 

configs/det/det_r50_vd_db.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1200
   # evaluation is run every 2000 iterations
   eval_batch_step: [0,2000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/ResNet50_vd_ssld_pretrained
   checkpoints:

configs/det/det_r50_vd_east.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1000
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [4000, 5000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/ResNet50_vd_pretrained/
   checkpoints: 

configs/det/det_r50_vd_sast_icdar15.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1000
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [4000, 5000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/ResNet50_vd_ssld_pretrained/
   checkpoints:

configs/det/det_r50_vd_sast_totaltext.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 1000
   # evaluation is run every 5000 iterations after the 4000th iteration
   eval_batch_step: [4000, 5000]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: True
   cal_metric_during_train: False
   pretrained_model: ./pretrain_models/ResNet50_vd_ssld_pretrained/
   checkpoints: 

configs/e2e/e2e_r50_vd_pg.yml

@@ -7,11 +7,6 @@ Global:
   save_epoch_step: 10
   # evaluation is run every 0 iterationss after the 1000th iteration
   eval_batch_step: [ 0, 1000 ]
-  # 1. If pretrained_model is saved in static mode, such as classification pretrained model
-  #    from static branch, load_static_weights must be set as True.
-  # 2. If you want to finetune the pretrained models we provide in the docs,
-  #    you should set load_static_weights as False.
-  load_static_weights: False
   cal_metric_during_train: False
   pretrained_model:
   checkpoints:

configs/rec/rec_icdar15_train.yml

@@ -82,7 +82,7 @@ Eval:
   dataset:
     name: SimpleDataSet
     data_dir: ./train_data/
-    label_file_list: ["./train_data/train_list.txt"]
+    label_file_list: ["./train_data/val_list.txt"]
     transforms:
       - DecodeImage: # load image
           img_mode: BGR

deploy/android_demo/.gitignore

@@ -0,0 +1,9 @@
+*.iml
+.gradle
+/local.properties
+/.idea/*
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+

deploy/android_demo/README.md

@@ -0,0 +1,19 @@
+# 如何快速测试
+### 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

@@ -0,0 +1 @@
+/build

deploy/android_demo/app/build.gradle

@@ -0,0 +1,98 @@
+import java.security.MessageDigest
+
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 29
+    defaultConfig {
+        applicationId "com.baidu.paddle.lite.demo.ocr"
+        minSdkVersion 23
+        targetSdkVersion 29
+        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 'androidx.appcompat:appcompat:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    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://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/paddle_lite_libs_v2_9_0.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/dygraph_v2.0/lite/ocr_v2_for_cpu.tar.gz',
+                'dest' : 'src/main/assets/models'
+        ],
+        [
+                'src' : 'https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_dict.tar.gz',
+                'dest' : 'src/main/assets/labels'
+        ]
+]
+
+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

deploy/android_demo/app/proguard-rules.pro

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,39 @@
+<?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">
+        <!-- to test MiniActivity, change this to com.baidu.paddle.lite.demo.ocr.MiniActivity -->
+        <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>
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="com.baidu.paddle.lite.demo.ocr.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths"></meta-data>
+        </provider>
+    </application>
+
+</manifest>

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

@@ -0,0 +1,117 @@
+# 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)

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

@@ -0,0 +1,37 @@
+//
+// Created by fu on 4/25/18.
+//
+
+#pragma once
+#import <numeric>
+#import <vector>
+
+#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

@@ -0,0 +1,114 @@
+//
+// Created by fujiayi on 2020/7/5.
+//
+
+#include "native.h"
+#include "ocr_ppredictor.h"
+#include <algorithm>
+#include <paddle_api.h>
+#include <string>
+
+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, jstring j_cls_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);
+  std::string cls_model_path = jstring_to_cpp_string(env, j_cls_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, cls_model_path);
+  return reinterpret_cast<jlong>(orc_predictor);
+}
+
+/**
+ * "LITE_POWER_HIGH" convert to 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;
+}

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

@@ -0,0 +1,137 @@
+//
+// Created by fujiayi on 2020/7/5.
+//
+
+#pragma once
+
+#include "common.h"
+#include <android/bitmap.h>
+#include <jni.h>
+#include <opencv2/opencv.hpp>
+#include <string>
+#include <vector>
+
+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

@@ -0,0 +1,544 @@
+/*******************************************************************************
+*                                                                              *
+* 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 <cstdlib>
+#include <cstring>
+#include <functional>
+#include <list>
+#include <ostream>
+#include <queue>
+#include <set>
+#include <stdexcept>
+#include <vector>
+
+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_cls_process.cpp

@@ -0,0 +1,46 @@
+// 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_cls_process.h"
+#include <cmath>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <iostream>
+#include <vector>
+
+const std::vector<int> CLS_IMAGE_SHAPE = {3, 48, 192};
+
+cv::Mat cls_resize_img(const cv::Mat &img) {
+  int imgC = CLS_IMAGE_SHAPE[0];
+  int imgW = CLS_IMAGE_SHAPE[2];
+  int imgH = CLS_IMAGE_SHAPE[1];
+
+  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);
+
+  if (resize_w < imgW) {
+    cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0, int(imgW - resize_w),
+                       cv::BORDER_CONSTANT, {0, 0, 0});
+  }
+  return resize_img;
+}

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

@@ -0,0 +1,23 @@
+// 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 "common.h"
+#include <opencv2/opencv.hpp>
+#include <vector>
+
+extern const std::vector<int> CLS_IMAGE_SHAPE;
+
+cv::Mat cls_resize_img(const cv::Mat &img);

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

@@ -0,0 +1,142 @@
+// 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 <cmath>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <iostream>
+#include <vector>
+
+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

@@ -0,0 +1,20 @@
+//
+// Created by fujiayi on 2020/7/3.
+//
+#pragma once
+
+#include "common.h"
+#include <opencv2/opencv.hpp>
+#include <vector>
+
+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));
+}

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

@@ -0,0 +1,342 @@
+// 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_clipper.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+#include <iostream>
+#include <math.h>
+#include <vector>
+
+static void getcontourarea(float **box, float unclip_ratio, float &distance) {
+  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;
+}
+
+static cv::RotatedRect unclip(float **box) {
+  float unclip_ratio = 2.0;
+  float distance = 1.0;
+
+  getcontourarea(box, unclip_ratio, distance);
+
+  ClipperLib::ClipperOffset offset;
+  ClipperLib::Path p;
+  p << ClipperLib::IntPoint(int(box[0][0]), int(box[0][1]))
+    << ClipperLib::IntPoint(int(box[1][0]), int(box[1][1]))
+    << ClipperLib::IntPoint(int(box[2][0]), int(box[2][1]))
+    << ClipperLib::IntPoint(int(box[3][0]), int(box[3][1]));
+  offset.AddPath(p, ClipperLib::jtRound, ClipperLib::etClosedPolygon);
+
+  ClipperLib::Paths soln;
+  offset.Execute(soln, distance);
+  std::vector<cv::Point2f> points;
+
+  for (int j = 0; j < soln.size(); j++) {
+    for (int i = 0; i < soln[soln.size() - 1].size(); i++) {
+      points.emplace_back(soln[j][i].X, soln[j][i].Y);
+    }
+  }
+  cv::RotatedRect res = cv::minAreaRect(points);
+
+  return res;
+}
+
+static float **Mat2Vec(cv::Mat mat) {
+  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;
+}
+
+static void quickSort(float **s, int l, int r) {
+  if (l < r) {
+    int i = l, j = r;
+    float x = s[l][0];
+    float *xp = s[l];
+    while (i < j) {
+      while (i < j && s[j][0] >= x) {
+        j--;
+      }
+      if (i < j) {
+        std::swap(s[i++], s[j]);
+      }
+      while (i < j && s[i][0] < x) {
+        i++;
+      }
+      if (i < j) {
+        std::swap(s[j--], s[i]);
+      }
+    }
+    s[i] = xp;
+    quickSort(s, l, i - 1);
+    quickSort(s, i + 1, r);
+  }
+}
+
+static void quickSort_vector(std::vector<std::vector<int>> &box, int l, int r,
+                             int axis) {
+  if (l < r) {
+    int i = l, j = r;
+    int x = box[l][axis];
+    std::vector<int> xp(box[l]);
+    while (i < j) {
+      while (i < j && box[j][axis] >= x) {
+        j--;
+      }
+      if (i < j) {
+        std::swap(box[i++], box[j]);
+      }
+      while (i < j && box[i][axis] < x) {
+        i++;
+      }
+      if (i < j) {
+        std::swap(box[j--], box[i]);
+      }
+    }
+    box[i] = xp;
+    quickSort_vector(box, l, i - 1, axis);
+    quickSort_vector(box, i + 1, r, axis);
+  }
+}
+
+static std::vector<std::vector<int>>
+order_points_clockwise(std::vector<std::vector<int>> pts) {
+  std::vector<std::vector<int>> box = pts;
+  quickSort_vector(box, 0, int(box.size() - 1), 0);
+  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;
+}
+
+static float **get_mini_boxes(cv::RotatedRect box, float &ssid) {
+  ssid = box.size.width >= box.size.height ? box.size.height : box.size.width;
+
+  cv::Mat points;
+  cv::boxPoints(box, points);
+  // sorted box points
+  auto array = Mat2Vec(points);
+  quickSort(array, 0, 3);
+
+  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;
+}
+
+template <class T> T clamp(T x, T min, T max) {
+  if (x > max) {
+    return max;
+  }
+  if (x < min) {
+    return min;
+  }
+  return x;
+}
+
+static float clampf(float x, float min, float max) {
+  if (x > max)
+    return max;
+  if (x < min)
+    return min;
+  return x;
+}
+
+float box_score_fast(float **box_array, cv::Mat pred) {
+  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::floorf(*(std::min_element(box_x, box_x + 4)))), 0,
+                   width - 1);
+  int xmax = clamp(int(std::ceilf(*(std::max_element(box_x, box_x + 4)))), 0,
+                   width - 1);
+  int ymin = clamp(int(std::floorf(*(std::min_element(box_y, box_y + 4)))), 0,
+                   height - 1);
+  int ymax = clamp(int(std::ceilf(*(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>>>
+boxes_from_bitmap(const cv::Mat &pred, const cv::Mat &bitmap) {
+  const int min_size = 3;
+  const int max_candidates = 1000;
+  const float box_thresh = 0.5;
+
+  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++) {
+    float ssid;
+    cv::RotatedRect box = cv::minAreaRect(contours[_i]);
+    auto array = get_mini_boxes(box, ssid);
+
+    auto box_for_unclip = array;
+    // end get_mini_box
+
+    if (ssid < min_size) {
+      continue;
+    }
+
+    float score;
+    score = box_score_fast(array, pred);
+    // end box_score_fast
+    if (score < box_thresh) {
+      continue;
+    }
+
+    // start for unclip
+    cv::RotatedRect points = unclip(box_for_unclip);
+    // end for unclip
+
+    cv::RotatedRect clipbox = points;
+    auto cliparray = get_mini_boxes(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;
+}
+
+int _max(int a, int b) { return a >= b ? a : b; }
+
+int _min(int a, int b) { return a >= b ? b : a; }
+
+std::vector<std::vector<std::vector<int>>>
+filter_tag_det_res(const std::vector<std::vector<std::vector<int>>> &o_boxes,
+                   float ratio_h, float ratio_w, const cv::Mat &srcimg) {
+  int oriimg_h = srcimg.rows;
+  int oriimg_w = srcimg.cols;
+  std::vector<std::vector<std::vector<int>>> boxes{o_boxes};
+  std::vector<std::vector<std::vector<int>>> root_points;
+  for (int n = 0; n < boxes.size(); n++) {
+    boxes[n] = order_points_clockwise(boxes[n]);
+    for (int 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 (int 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 <= 10 || rect_height <= 10)
+      continue;
+    root_points.push_back(boxes[n]);
+  }
+  return root_points;
+}

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

@@ -0,0 +1,13 @@
+//
+// Created by fujiayi on 2020/7/2.
+//
+#pragma once
+#include <opencv2/opencv.hpp>
+#include <vector>
+
+std::vector<std::vector<std::vector<int>>>
+boxes_from_bitmap(const cv::Mat &pred, const cv::Mat &bitmap);
+
+std::vector<std::vector<std::vector<int>>>
+filter_tag_det_res(const std::vector<std::vector<std::vector<int>>> &o_boxes,
+                   float ratio_h, float ratio_w, const cv::Mat &srcimg);

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

@@ -0,0 +1,261 @@
+//
+// Created by fujiayi on 2020/7/1.
+//
+
+#include "ocr_ppredictor.h"
+#include "common.h"
+#include "ocr_cls_process.h"
+#include "ocr_crnn_process.h"
+#include "ocr_db_post_process.h"
+#include "preprocess.h"
+
+namespace ppredictor {
+
+OCR_PPredictor::OCR_PPredictor(const OCR_Config &config) : _config(config) {}
+
+int OCR_PPredictor::init(const std::string &det_model_content,
+                         const std::string &rec_model_content,
+                         const std::string &cls_model_content) {
+  _det_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR, _config.mode});
+  _det_predictor->init_nb(det_model_content);
+
+  _rec_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR_INTERNAL, _config.mode});
+  _rec_predictor->init_nb(rec_model_content);
+
+  _cls_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR_INTERNAL, _config.mode});
+  _cls_predictor->init_nb(cls_model_content);
+  return RETURN_OK;
+}
+
+int OCR_PPredictor::init_from_file(const std::string &det_model_path,
+                                   const std::string &rec_model_path,
+                                   const std::string &cls_model_path) {
+  _det_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR, _config.mode});
+  _det_predictor->init_from_file(det_model_path);
+
+  _rec_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR_INTERNAL, _config.mode});
+  _rec_predictor->init_from_file(rec_model_path);
+
+  _cls_predictor = std::unique_ptr<PPredictor>(
+      new PPredictor{_config.thread_num, NET_OCR_INTERNAL, _config.mode});
+  _cls_predictor->init_from_file(cls_model_path);
+  return RETURN_OK;
+}
+/**
+ * for debug use, show result of First Step
+ * @param filter_boxes
+ * @param boxes
+ * @param srcimg
+ */
+static void
+visual_img(const std::vector<std::vector<std::vector<int>>> &filter_boxes,
+           const std::vector<std::vector<std::vector<int>>> &boxes,
+           const cv::Mat &srcimg) {
+  // visualization
+  cv::Point rook_points[filter_boxes.size()][4];
+  for (int n = 0; n < filter_boxes.size(); n++) {
+    for (int m = 0; m < filter_boxes[0].size(); m++) {
+      rook_points[n][m] =
+          cv::Point(int(filter_boxes[n][m][0]), int(filter_boxes[n][m][1]));
+    }
+  }
+
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  for (int n = 0; n < boxes.size(); n++) {
+    const cv::Point *ppt[1] = {rook_points[n]};
+    int npt[] = {4};
+    cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+  }
+  // 调试用，自行替换需要修改的路径
+  cv::imwrite("/sdcard/1/vis.png", img_vis);
+}
+
+std::vector<OCRPredictResult>
+OCR_PPredictor::infer_ocr(const std::vector<int64_t> &dims,
+                          const float *input_data, int input_len, int net_flag,
+                          cv::Mat &origin) {
+  PredictorInput input = _det_predictor->get_first_input();
+  input.set_dims(dims);
+  input.set_data(input_data, input_len);
+  std::vector<PredictorOutput> results = _det_predictor->infer();
+  PredictorOutput &res = results.at(0);
+  std::vector<std::vector<std::vector<int>>> filtered_box = calc_filtered_boxes(
+      res.get_float_data(), res.get_size(), (int)dims[2], (int)dims[3], origin);
+  LOGI("Filter_box size %ld", filtered_box.size());
+  return infer_rec(filtered_box, origin);
+}
+
+std::vector<OCRPredictResult> OCR_PPredictor::infer_rec(
+    const std::vector<std::vector<std::vector<int>>> &boxes,
+    const cv::Mat &origin_img) {
+  std::vector<float> mean = {0.5f, 0.5f, 0.5f};
+  std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
+  std::vector<int64_t> dims = {1, 3, 0, 0};
+  std::vector<OCRPredictResult> ocr_results;
+
+  PredictorInput input = _rec_predictor->get_first_input();
+  for (auto bp = boxes.crbegin(); bp != boxes.crend(); ++bp) {
+    const std::vector<std::vector<int>> &box = *bp;
+    cv::Mat crop_img = get_rotate_crop_image(origin_img, box);
+    crop_img = infer_cls(crop_img);
+
+    float wh_ratio = float(crop_img.cols) / float(crop_img.rows);
+    cv::Mat input_image = crnn_resize_img(crop_img, wh_ratio);
+    input_image.convertTo(input_image, CV_32FC3, 1 / 255.0f);
+    const float *dimg = reinterpret_cast<const float *>(input_image.data);
+    int input_size = input_image.rows * input_image.cols;
+
+    dims[2] = input_image.rows;
+    dims[3] = input_image.cols;
+    input.set_dims(dims);
+
+    neon_mean_scale(dimg, input.get_mutable_float_data(), input_size, mean,
+                    scale);
+
+    std::vector<PredictorOutput> results = _rec_predictor->infer();
+    const float *predict_batch = results.at(0).get_float_data();
+    const std::vector<int64_t> predict_shape = results.at(0).get_shape();
+
+    OCRPredictResult res;
+
+    // ctc decode
+    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++) {
+      argmax_idx = int(argmax(&predict_batch[n * predict_shape[2]],
+                              &predict_batch[(n + 1) * predict_shape[2]]));
+      max_value =
+          float(*std::max_element(&predict_batch[n * predict_shape[2]],
+                                  &predict_batch[(n + 1) * predict_shape[2]]));
+      if (argmax_idx > 0 && (!(n > 0 && argmax_idx == last_index))) {
+        score += max_value;
+        count += 1;
+        res.word_index.push_back(argmax_idx);
+      }
+      last_index = argmax_idx;
+    }
+    score /= count;
+    if (res.word_index.empty()) {
+      continue;
+    }
+    res.score = score;
+    res.points = box;
+    ocr_results.emplace_back(std::move(res));
+  }
+  LOGI("ocr_results finished %lu", ocr_results.size());
+  return ocr_results;
+}
+
+cv::Mat OCR_PPredictor::infer_cls(const cv::Mat &img, float thresh) {
+  std::vector<float> mean = {0.5f, 0.5f, 0.5f};
+  std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
+  std::vector<int64_t> dims = {1, 3, 0, 0};
+  std::vector<OCRPredictResult> ocr_results;
+
+  PredictorInput input = _cls_predictor->get_first_input();
+
+  cv::Mat input_image = cls_resize_img(img);
+  input_image.convertTo(input_image, CV_32FC3, 1 / 255.0f);
+  const float *dimg = reinterpret_cast<const float *>(input_image.data);
+  int input_size = input_image.rows * input_image.cols;
+
+  dims[2] = input_image.rows;
+  dims[3] = input_image.cols;
+  input.set_dims(dims);
+
+  neon_mean_scale(dimg, input.get_mutable_float_data(), input_size, mean,
+                  scale);
+
+  std::vector<PredictorOutput> results = _cls_predictor->infer();
+
+  const float *scores = results.at(0).get_float_data();
+  float score = 0;
+  int label = 0;
+  for (int64_t i = 0; i < results.at(0).get_size(); i++) {
+    LOGI("output scores [%f]", scores[i]);
+    if (scores[i] > score) {
+      score = scores[i];
+      label = i;
+    }
+  }
+  cv::Mat srcimg;
+  img.copyTo(srcimg);
+  if (label % 2 == 1 && score > thresh) {
+    cv::rotate(srcimg, srcimg, 1);
+  }
+  return srcimg;
+}
+
+std::vector<std::vector<std::vector<int>>>
+OCR_PPredictor::calc_filtered_boxes(const float *pred, int pred_size,
+                                    int output_height, int output_width,
+                                    const cv::Mat &origin) {
+  const double threshold = 0.3;
+  const double maxvalue = 1;
+
+  cv::Mat pred_map = cv::Mat::zeros(output_height, output_width, CV_32F);
+  memcpy(pred_map.data, pred, pred_size * sizeof(float));
+  cv::Mat cbuf_map;
+  pred_map.convertTo(cbuf_map, CV_8UC1);
+
+  cv::Mat bit_map;
+  cv::threshold(cbuf_map, bit_map, threshold, maxvalue, cv::THRESH_BINARY);
+
+  std::vector<std::vector<std::vector<int>>> boxes =
+      boxes_from_bitmap(pred_map, bit_map);
+  float ratio_h = output_height * 1.0f / origin.rows;
+  float ratio_w = output_width * 1.0f / origin.cols;
+  std::vector<std::vector<std::vector<int>>> filter_boxes =
+      filter_tag_det_res(boxes, ratio_h, ratio_w, origin);
+  return filter_boxes;
+}
+
+std::vector<int>
+OCR_PPredictor::postprocess_rec_word_index(const PredictorOutput &res) {
+  const int *rec_idx = res.get_int_data();
+  const std::vector<std::vector<uint64_t>> rec_idx_lod = res.get_lod();
+
+  std::vector<int> pred_idx;
+  for (int n = int(rec_idx_lod[0][0]); n < int(rec_idx_lod[0][1] * 2); n += 2) {
+    pred_idx.emplace_back(rec_idx[n]);
+  }
+  return pred_idx;
+}
+
+float OCR_PPredictor::postprocess_rec_score(const PredictorOutput &res) {
+  const float *predict_batch = res.get_float_data();
+  const std::vector<int64_t> predict_shape = res.get_shape();
+  const std::vector<std::vector<uint64_t>> predict_lod = res.get_lod();
+  int blank = predict_shape[1];
+  float score = 0.f;
+  int count = 0;
+  for (int n = predict_lod[0][0]; n < predict_lod[0][1] - 1; n++) {
+    int argmax_idx = argmax(predict_batch + n * predict_shape[1],
+                            predict_batch + (n + 1) * predict_shape[1]);
+    float max_value = predict_batch[n * predict_shape[1] + argmax_idx];
+    if (blank - 1 - argmax_idx > 1e-5) {
+      score += max_value;
+      count += 1;
+    }
+  }
+  if (count == 0) {
+    LOGE("calc score count 0");
+  } else {
+    score /= count;
+  }
+  LOGI("calc score: %f", score);
+  return score;
+}
+
+NET_TYPE OCR_PPredictor::get_net_flag() const { return NET_OCR; }
+}

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

@@ -0,0 +1,122 @@
+//
+// Created by fujiayi on 2020/7/1.
+//
+
+#pragma once
+
+#include "ppredictor.h"
+#include <opencv2/opencv.hpp>
+#include <paddle_api.h>
+#include <string>
+
+namespace ppredictor {
+
+/**
+ * Config
+ */
+struct OCR_Config {
+  int thread_num = 4; // Thread num
+  paddle::lite_api::PowerMode mode =
+      paddle::lite_api::LITE_POWER_HIGH; // PaddleLite Mode
+};
+
+/**
+ * PolyGone Result
+ */
+struct OCRPredictResult {
+  std::vector<int> word_index;
+  std::vector<std::vector<int>> points;
+  float score;
+};
+
+/**
+ * OCR there are 2 models
+ * 1. First model（det），select polygones to show where are the texts
+ * 2. crop from the origin images, use these polygones to infer
+ */
+class OCR_PPredictor : public PPredictor_Interface {
+public:
+  OCR_PPredictor(const OCR_Config &config);
+
+  virtual ~OCR_PPredictor() {}
+
+  /**
+   * 初始化二个模型的Predictor
+   * @param det_model_content
+   * @param rec_model_content
+   * @return
+   */
+  int init(const std::string &det_model_content,
+           const std::string &rec_model_content,
+           const std::string &cls_model_content);
+  int init_from_file(const std::string &det_model_path,
+                     const std::string &rec_model_path,
+                     const std::string &cls_model_path);
+  /**
+   * Return OCR result
+   * @param dims
+   * @param input_data
+   * @param input_len
+   * @param net_flag
+   * @param origin
+   * @return
+   */
+  virtual std::vector<OCRPredictResult>
+  infer_ocr(const std::vector<int64_t> &dims, const float *input_data,
+            int input_len, int net_flag, cv::Mat &origin);
+
+  virtual NET_TYPE get_net_flag() const;
+
+private:
+  /**
+   * calcul Polygone from the result image of first model
+   * @param pred
+   * @param output_height
+   * @param output_width
+   * @param origin
+   * @return
+   */
+  std::vector<std::vector<std::vector<int>>>
+  calc_filtered_boxes(const float *pred, int pred_size, int output_height,
+                      int output_width, const cv::Mat &origin);
+
+  /**
+   * infer for second model
+   *
+   * @param boxes
+   * @param origin
+   * @return
+   */
+  std::vector<OCRPredictResult>
+  infer_rec(const std::vector<std::vector<std::vector<int>>> &boxes,
+            const cv::Mat &origin);
+
+  /**
+  * infer for cls model
+  *
+  * @param boxes
+  * @param origin
+  * @return
+  */
+  cv::Mat infer_cls(const cv::Mat &origin, float thresh = 0.9);
+
+  /**
+   * Postprocess or sencod model to extract text
+   * @param res
+   * @return
+   */
+  std::vector<int> postprocess_rec_word_index(const PredictorOutput &res);
+
+  /**
+   * calculate confidence of second model text result
+   * @param res
+   * @return
+   */
+  float postprocess_rec_score(const PredictorOutput &res);
+
+  std::unique_ptr<PPredictor> _det_predictor;
+  std::unique_ptr<PPredictor> _rec_predictor;
+  std::unique_ptr<PPredictor> _cls_predictor;
+  OCR_Config _config;
+};
+}

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

@@ -0,0 +1,65 @@
+#include "ppredictor.h"
+#include "common.h"
+
+namespace ppredictor {
+PPredictor::PPredictor(int thread_num, int net_flag,
+                       paddle::lite_api::PowerMode mode)
+    : _thread_num(thread_num), _net_flag(net_flag), _mode(mode) {}
+
+int PPredictor::init_nb(const std::string &model_content) {
+  paddle::lite_api::MobileConfig config;
+  config.set_model_from_buffer(model_content);
+  return _init(config);
+}
+
+int PPredictor::init_from_file(const std::string &model_content) {
+  paddle::lite_api::MobileConfig config;
+  config.set_model_from_file(model_content);
+  return _init(config);
+}
+
+template <typename ConfigT> int PPredictor::_init(ConfigT &config) {
+  config.set_threads(_thread_num);
+  config.set_power_mode(_mode);
+  _predictor = paddle::lite_api::CreatePaddlePredictor(config);
+  LOGI("paddle instance created");
+  return RETURN_OK;
+}
+
+PredictorInput PPredictor::get_input(int index) {
+  PredictorInput input{_predictor->GetInput(index), index, _net_flag};
+  _is_input_get = true;
+  return input;
+}
+
+std::vector<PredictorInput> PPredictor::get_inputs(int num) {
+  std::vector<PredictorInput> results;
+  for (int i = 0; i < num; i++) {
+    results.emplace_back(get_input(i));
+  }
+  return results;
+}
+
+PredictorInput PPredictor::get_first_input() { return get_input(0); }
+
+std::vector<PredictorOutput> PPredictor::infer() {
+  LOGI("infer Run start %d", _net_flag);
+  std::vector<PredictorOutput> results;
+  if (!_is_input_get) {
+    return results;
+  }
+  _predictor->Run();
+  LOGI("infer Run end");
+
+  for (int i = 0; i < _predictor->GetOutputNames().size(); i++) {
+    std::unique_ptr<const paddle::lite_api::Tensor> output_tensor =
+        _predictor->GetOutput(i);
+    LOGI("output tensor[%d] size %ld", i, product(output_tensor->shape()));
+    PredictorOutput result{std::move(output_tensor), i, _net_flag};
+    results.emplace_back(std::move(result));
+  }
+  return results;
+}
+
+NET_TYPE PPredictor::get_net_flag() const { return (NET_TYPE)_net_flag; }
+}

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

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "paddle_api.h"
+#include "predictor_input.h"
+#include "predictor_output.h"
+
+namespace ppredictor {
+
+/**
+ * PaddleLite Preditor Common Interface
+ */
+class PPredictor_Interface {
+public:
+  virtual ~PPredictor_Interface() {}
+
+  virtual NET_TYPE get_net_flag() const = 0;
+};
+
+/**
+ * Common Predictor
+ */
+class PPredictor : public PPredictor_Interface {
+public:
+  PPredictor(
+      int thread_num, int net_flag = 0,
+      paddle::lite_api::PowerMode mode = paddle::lite_api::LITE_POWER_HIGH);
+
+  virtual ~PPredictor() {}
+
+  /**
+   * init paddlitelite opt model，nb format ，or use ini_paddle
+   * @param model_content
+   * @return 0
+   */
+  virtual int init_nb(const std::string &model_content);
+
+  virtual int init_from_file(const std::string &model_content);
+
+  std::vector<PredictorOutput> infer();
+
+  std::shared_ptr<paddle::lite_api::PaddlePredictor> get_predictor() {
+    return _predictor;
+  }
+
+  virtual std::vector<PredictorInput> get_inputs(int num);
+
+  virtual PredictorInput get_input(int index);
+
+  virtual PredictorInput get_first_input();
+
+  virtual NET_TYPE get_net_flag() const;
+
+protected:
+  template <typename ConfigT> int _init(ConfigT &config);
+
+private:
+  int _thread_num;
+  paddle::lite_api::PowerMode _mode;
+  std::shared_ptr<paddle::lite_api::PaddlePredictor> _predictor;
+  bool _is_input_get = false;
+  int _net_flag;
+};
+}

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

@@ -0,0 +1,28 @@
+#include "predictor_input.h"
+
+namespace ppredictor {
+
+void PredictorInput::set_dims(std::vector<int64_t> dims) {
+  // yolov3
+  if (_net_flag == 101 && _index == 1) {
+    _tensor->Resize({1, 2});
+    _tensor->mutable_data<int>()[0] = (int)dims.at(2);
+    _tensor->mutable_data<int>()[1] = (int)dims.at(3);
+  } else {
+    _tensor->Resize(dims);
+  }
+  _is_dims_set = true;
+}
+
+float *PredictorInput::get_mutable_float_data() {
+  if (!_is_dims_set) {
+    LOGE("PredictorInput::set_dims is not called");
+  }
+  return _tensor->mutable_data<float>();
+}
+
+void PredictorInput::set_data(const float *input_data, int input_float_len) {
+  float *input_raw_data = get_mutable_float_data();
+  memcpy(input_raw_data, input_data, input_float_len * sizeof(float));
+}
+}

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "common.h"
+#include <paddle_api.h>
+#include <vector>
+
+namespace ppredictor {
+class PredictorInput {
+public:
+  PredictorInput(std::unique_ptr<paddle::lite_api::Tensor> &&tensor, int index,
+                 int net_flag)
+      : _tensor(std::move(tensor)), _index(index), _net_flag(net_flag) {}
+
+  void set_dims(std::vector<int64_t> dims);
+
+  float *get_mutable_float_data();
+
+  void set_data(const float *input_data, int input_float_len);
+
+private:
+  std::unique_ptr<paddle::lite_api::Tensor> _tensor;
+  bool _is_dims_set = false;
+  int _index;
+  int _net_flag;
+};
+}

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

@@ -0,0 +1,26 @@
+#include "predictor_output.h"
+namespace ppredictor {
+const float *PredictorOutput::get_float_data() const {
+  return _tensor->data<float>();
+}
+
+const int *PredictorOutput::get_int_data() const {
+  return _tensor->data<int>();
+}
+
+const std::vector<std::vector<uint64_t>> PredictorOutput::get_lod() const {
+  return _tensor->lod();
+}
+
+int64_t PredictorOutput::get_size() const {
+  if (_net_flag == NET_OCR) {
+    return _tensor->shape().at(2) * _tensor->shape().at(3);
+  } else {
+    return product(_tensor->shape());
+  }
+}
+
+const std::vector<int64_t> PredictorOutput::get_shape() const {
+  return _tensor->shape();
+}
+}

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

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "common.h"
+#include <paddle_api.h>
+#include <vector>
+
+namespace ppredictor {
+class PredictorOutput {
+public:
+  PredictorOutput() {}
+  PredictorOutput(std::unique_ptr<const paddle::lite_api::Tensor> &&tensor,
+                  int index, int net_flag)
+      : _tensor(std::move(tensor)), _index(index), _net_flag(net_flag) {}
+
+  const float *get_float_data() const;
+  const int *get_int_data() const;
+  int64_t get_size() const;
+  const std::vector<std::vector<uint64_t>> get_lod() const;
+  const std::vector<int64_t> get_shape() const;
+
+  std::vector<float> data;    // return float, or use data_int
+  std::vector<int> data_int;  // several layers return int ，or use data
+  std::vector<int64_t> shape; // PaddleLite output shape
+  std::vector<std::vector<uint64_t>> lod; // PaddleLite output lod
+
+private:
+  std::unique_ptr<const paddle::lite_api::Tensor> _tensor;
+  int _index;
+  int _net_flag;
+};
+}

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

@@ -0,0 +1,82 @@
+#include "preprocess.h"
+#include <android/bitmap.h>
+
+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;
+}
+
+cv::Mat resize_img(const cv::Mat &img, int height, int width) {
+  if (img.rows == height && img.cols == width) {
+    return img;
+  }
+  cv::Mat new_img;
+  cv::resize(img, new_img, cv::Size(height, width));
+  return new_img;
+}
+
+// fill tensor with mean and scale and trans layout: nhwc -> nchw, neon speed up
+void neon_mean_scale(const float *din, float *dout, int size,
+                     const std::vector<float> &mean,
+                     const std::vector<float> &scale) {
+  if (mean.size() != 3 || scale.size() != 3) {
+    LOGE("[ERROR] mean or scale size must equal to 3");
+    return;
+  }
+
+  float32x4_t vmean0 = vdupq_n_f32(mean[0]);
+  float32x4_t vmean1 = vdupq_n_f32(mean[1]);
+  float32x4_t vmean2 = vdupq_n_f32(mean[2]);
+  float32x4_t vscale0 = vdupq_n_f32(scale[0]);
+  float32x4_t vscale1 = vdupq_n_f32(scale[1]);
+  float32x4_t vscale2 = vdupq_n_f32(scale[2]);
+
+  float *dout_c0 = dout;
+  float *dout_c1 = dout + size;
+  float *dout_c2 = dout + size * 2;
+
+  int i = 0;
+  for (; i < size - 3; i += 4) {
+    float32x4x3_t vin3 = vld3q_f32(din);
+    float32x4_t vsub0 = vsubq_f32(vin3.val[0], vmean0);
+    float32x4_t vsub1 = vsubq_f32(vin3.val[1], vmean1);
+    float32x4_t vsub2 = vsubq_f32(vin3.val[2], vmean2);
+    float32x4_t vs0 = vmulq_f32(vsub0, vscale0);
+    float32x4_t vs1 = vmulq_f32(vsub1, vscale1);
+    float32x4_t vs2 = vmulq_f32(vsub2, vscale2);
+    vst1q_f32(dout_c0, vs0);
+    vst1q_f32(dout_c1, vs1);
+    vst1q_f32(dout_c2, vs2);
+
+    din += 12;
+    dout_c0 += 4;
+    dout_c1 += 4;
+    dout_c2 += 4;
+  }
+  for (; i < size; i++) {
+    *(dout_c0++) = (*(din++) - mean[0]) * scale[0];
+    *(dout_c1++) = (*(din++) - mean[1]) * scale[1];
+    *(dout_c2++) = (*(din++) - mean[2]) * scale[2];
+  }
+}

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

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "common.h"
+#include <jni.h>
+#include <opencv2/opencv.hpp>
+cv::Mat bitmap_to_cv_mat(JNIEnv *env, jobject bitmap);
+
+cv::Mat resize_img(const cv::Mat &img, int height, int width);
+
+void neon_mean_scale(const float *din, float *dout, int size,
+                     const std::vector<float> &mean,
+                     const std::vector<float> &scale);

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/AppCompatPreferenceActivity.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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.
+ */
+
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.preference.PreferenceActivity;
+import android.view.MenuInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import androidx.annotation.LayoutRes;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AppCompatDelegate;
+import androidx.appcompat.widget.Toolbar;
+
+/**
+ * A {@link PreferenceActivity} which implements and proxies the necessary calls
+ * to be used with AppCompat.
+ * <p>
+ * This technique can be used with an {@link android.app.Activity} class, not just
+ * {@link PreferenceActivity}.
+ */
+public abstract class AppCompatPreferenceActivity extends PreferenceActivity {
+    private AppCompatDelegate mDelegate;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        getDelegate().installViewFactory();
+        getDelegate().onCreate(savedInstanceState);
+        super.onCreate(savedInstanceState);
+    }
+
+    @Override
+    protected void onPostCreate(Bundle savedInstanceState) {
+        super.onPostCreate(savedInstanceState);
+        getDelegate().onPostCreate(savedInstanceState);
+    }
+
+    public ActionBar getSupportActionBar() {
+        return getDelegate().getSupportActionBar();
+    }
+
+    public void setSupportActionBar(@Nullable Toolbar toolbar) {
+        getDelegate().setSupportActionBar(toolbar);
+    }
+
+    @Override
+    public MenuInflater getMenuInflater() {
+        return getDelegate().getMenuInflater();
+    }
+
+    @Override
+    public void setContentView(@LayoutRes int layoutResID) {
+        getDelegate().setContentView(layoutResID);
+    }
+
+    @Override
+    public void setContentView(View view) {
+        getDelegate().setContentView(view);
+    }
+
+    @Override
+    public void setContentView(View view, ViewGroup.LayoutParams params) {
+        getDelegate().setContentView(view, params);
+    }
+
+    @Override
+    public void addContentView(View view, ViewGroup.LayoutParams params) {
+        getDelegate().addContentView(view, params);
+    }
+
+    @Override
+    protected void onPostResume() {
+        super.onPostResume();
+        getDelegate().onPostResume();
+    }
+
+    @Override
+    protected void onTitleChanged(CharSequence title, int color) {
+        super.onTitleChanged(title, color);
+        getDelegate().setTitle(title);
+    }
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        getDelegate().onConfigurationChanged(newConfig);
+    }
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        getDelegate().onStop();
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        getDelegate().onDestroy();
+    }
+
+    public void invalidateOptionsMenu() {
+        getDelegate().invalidateOptionsMenu();
+    }
+
+    private AppCompatDelegate getDelegate() {
+        if (mDelegate == null) {
+            mDelegate = AppCompatDelegate.create(this, null);
+        }
+        return mDelegate;
+    }
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/MainActivity.java

@@ -0,0 +1,505 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.Manifest;
+import android.app.ProgressDialog;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.drawable.BitmapDrawable;
+import android.media.ExifInterface;
+import android.content.res.AssetManager;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.preference.PreferenceManager;
+import android.provider.MediaStore;
+import android.text.method.ScrollingMovementMethod;
+import android.util.Log;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+import androidx.core.content.FileProvider;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+public class MainActivity extends AppCompatActivity {
+    private static final String TAG = MainActivity.class.getSimpleName();
+    public static final int OPEN_GALLERY_REQUEST_CODE = 0;
+    public static final int TAKE_PHOTO_REQUEST_CODE = 1;
+
+    public static final int REQUEST_LOAD_MODEL = 0;
+    public static final int REQUEST_RUN_MODEL = 1;
+    public static final int RESPONSE_LOAD_MODEL_SUCCESSED = 0;
+    public static final int RESPONSE_LOAD_MODEL_FAILED = 1;
+    public static final int RESPONSE_RUN_MODEL_SUCCESSED = 2;
+    public static final int RESPONSE_RUN_MODEL_FAILED = 3;
+
+    protected ProgressDialog pbLoadModel = null;
+    protected ProgressDialog pbRunModel = null;
+
+    protected Handler receiver = null; // Receive messages from worker thread
+    protected Handler sender = null; // Send command to worker thread
+    protected HandlerThread worker = null; // Worker thread to load&run model
+
+    // UI components of object detection
+    protected TextView tvInputSetting;
+    protected TextView tvStatus;
+    protected ImageView ivInputImage;
+    protected TextView tvOutputResult;
+    protected TextView tvInferenceTime;
+
+    // Model settings of object detection
+    protected String modelPath = "";
+    protected String labelPath = "";
+    protected String imagePath = "";
+    protected int cpuThreadNum = 1;
+    protected String cpuPowerMode = "";
+    protected String inputColorFormat = "";
+    protected long[] inputShape = new long[]{};
+    protected float[] inputMean = new float[]{};
+    protected float[] inputStd = new float[]{};
+    protected float scoreThreshold = 0.1f;
+    private String currentPhotoPath;
+    private AssetManager assetManager =null;
+
+    protected Predictor predictor = new Predictor();
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        // Clear all setting items to avoid app crashing due to the incorrect settings
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+        SharedPreferences.Editor editor = sharedPreferences.edit();
+        editor.clear();
+        editor.apply();
+
+        // Setup the UI components
+        tvInputSetting = findViewById(R.id.tv_input_setting);
+        tvStatus = findViewById(R.id.tv_model_img_status);
+        ivInputImage = findViewById(R.id.iv_input_image);
+        tvInferenceTime = findViewById(R.id.tv_inference_time);
+        tvOutputResult = findViewById(R.id.tv_output_result);
+        tvInputSetting.setMovementMethod(ScrollingMovementMethod.getInstance());
+        tvOutputResult.setMovementMethod(ScrollingMovementMethod.getInstance());
+
+        // Prepare the worker thread for mode loading and inference
+        receiver = new Handler() {
+            @Override
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case RESPONSE_LOAD_MODEL_SUCCESSED:
+                        if(pbLoadModel!=null && pbLoadModel.isShowing()){
+                            pbLoadModel.dismiss();
+                        }
+                        onLoadModelSuccessed();
+                        break;
+                    case RESPONSE_LOAD_MODEL_FAILED:
+                        if(pbLoadModel!=null && pbLoadModel.isShowing()){
+                            pbLoadModel.dismiss();
+                        }
+                        Toast.makeText(MainActivity.this, "Load model failed!", Toast.LENGTH_SHORT).show();
+                        onLoadModelFailed();
+                        break;
+                    case RESPONSE_RUN_MODEL_SUCCESSED:
+                        if(pbRunModel!=null && pbRunModel.isShowing()){
+                            pbRunModel.dismiss();
+                        }
+                        onRunModelSuccessed();
+                        break;
+                    case RESPONSE_RUN_MODEL_FAILED:
+                        if(pbRunModel!=null && pbRunModel.isShowing()){
+                            pbRunModel.dismiss();
+                        }
+                        Toast.makeText(MainActivity.this, "Run model failed!", Toast.LENGTH_SHORT).show();
+                        onRunModelFailed();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        };
+
+        worker = new HandlerThread("Predictor Worker");
+        worker.start();
+        sender = new Handler(worker.getLooper()) {
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case REQUEST_LOAD_MODEL:
+                        // Load model and reload test image
+                        if (onLoadModel()) {
+                            receiver.sendEmptyMessage(RESPONSE_LOAD_MODEL_SUCCESSED);
+                        } else {
+                            receiver.sendEmptyMessage(RESPONSE_LOAD_MODEL_FAILED);
+                        }
+                        break;
+                    case REQUEST_RUN_MODEL:
+                        // Run model if model is loaded
+                        if (onRunModel()) {
+                            receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_SUCCESSED);
+                        } else {
+                            receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_FAILED);
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        };
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
+        boolean settingsChanged = false;
+        String model_path = sharedPreferences.getString(getString(R.string.MODEL_PATH_KEY),
+                getString(R.string.MODEL_PATH_DEFAULT));
+        String label_path = sharedPreferences.getString(getString(R.string.LABEL_PATH_KEY),
+                getString(R.string.LABEL_PATH_DEFAULT));
+        String image_path = sharedPreferences.getString(getString(R.string.IMAGE_PATH_KEY),
+                getString(R.string.IMAGE_PATH_DEFAULT));
+        settingsChanged |= !model_path.equalsIgnoreCase(modelPath);
+        settingsChanged |= !label_path.equalsIgnoreCase(labelPath);
+        settingsChanged |= !image_path.equalsIgnoreCase(imagePath);
+        int cpu_thread_num = Integer.parseInt(sharedPreferences.getString(getString(R.string.CPU_THREAD_NUM_KEY),
+                getString(R.string.CPU_THREAD_NUM_DEFAULT)));
+        settingsChanged |= cpu_thread_num != cpuThreadNum;
+        String cpu_power_mode =
+                sharedPreferences.getString(getString(R.string.CPU_POWER_MODE_KEY),
+                        getString(R.string.CPU_POWER_MODE_DEFAULT));
+        settingsChanged |= !cpu_power_mode.equalsIgnoreCase(cpuPowerMode);
+        String input_color_format =
+                sharedPreferences.getString(getString(R.string.INPUT_COLOR_FORMAT_KEY),
+                        getString(R.string.INPUT_COLOR_FORMAT_DEFAULT));
+        settingsChanged |= !input_color_format.equalsIgnoreCase(inputColorFormat);
+        long[] input_shape =
+                Utils.parseLongsFromString(sharedPreferences.getString(getString(R.string.INPUT_SHAPE_KEY),
+                        getString(R.string.INPUT_SHAPE_DEFAULT)), ",");
+        float[] input_mean =
+                Utils.parseFloatsFromString(sharedPreferences.getString(getString(R.string.INPUT_MEAN_KEY),
+                        getString(R.string.INPUT_MEAN_DEFAULT)), ",");
+        float[] input_std =
+                Utils.parseFloatsFromString(sharedPreferences.getString(getString(R.string.INPUT_STD_KEY)
+                        , getString(R.string.INPUT_STD_DEFAULT)), ",");
+        settingsChanged |= input_shape.length != inputShape.length;
+        settingsChanged |= input_mean.length != inputMean.length;
+        settingsChanged |= input_std.length != inputStd.length;
+        if (!settingsChanged) {
+            for (int i = 0; i < input_shape.length; i++) {
+                settingsChanged |= input_shape[i] != inputShape[i];
+            }
+            for (int i = 0; i < input_mean.length; i++) {
+                settingsChanged |= input_mean[i] != inputMean[i];
+            }
+            for (int i = 0; i < input_std.length; i++) {
+                settingsChanged |= input_std[i] != inputStd[i];
+            }
+        }
+        float score_threshold =
+                Float.parseFloat(sharedPreferences.getString(getString(R.string.SCORE_THRESHOLD_KEY),
+                        getString(R.string.SCORE_THRESHOLD_DEFAULT)));
+        settingsChanged |= scoreThreshold != score_threshold;
+        if (settingsChanged) {
+            modelPath = model_path;
+            labelPath = label_path;
+            imagePath = image_path;
+            cpuThreadNum = cpu_thread_num;
+            cpuPowerMode = cpu_power_mode;
+            inputColorFormat = input_color_format;
+            inputShape = input_shape;
+            inputMean = input_mean;
+            inputStd = input_std;
+            scoreThreshold = score_threshold;
+            // Update UI
+            tvInputSetting.setText("Model: " + modelPath.substring(modelPath.lastIndexOf("/") + 1) + "\n" + "CPU" +
+                    " Thread Num: " + Integer.toString(cpuThreadNum) + "\n" + "CPU Power Mode: " + cpuPowerMode);
+            tvInputSetting.scrollTo(0, 0);
+            // Reload model if configure has been changed
+//            loadModel();
+            set_img();
+        }
+    }
+
+    public void loadModel() {
+        pbLoadModel = ProgressDialog.show(this, "", "loading model...", false, false);
+        sender.sendEmptyMessage(REQUEST_LOAD_MODEL);
+    }
+
+    public void runModel() {
+        pbRunModel = ProgressDialog.show(this, "", "running model...", false, false);
+        sender.sendEmptyMessage(REQUEST_RUN_MODEL);
+    }
+
+    public boolean onLoadModel() {
+        return predictor.init(MainActivity.this, modelPath, labelPath, cpuThreadNum,
+                cpuPowerMode,
+                inputColorFormat,
+                inputShape, inputMean,
+                inputStd, scoreThreshold);
+    }
+
+    public boolean onRunModel() {
+        return predictor.isLoaded() && predictor.runModel();
+    }
+
+    public void onLoadModelSuccessed() {
+        // Load test image from path and run model
+        tvStatus.setText("STATUS: load model successed");
+    }
+
+    public void onLoadModelFailed() {
+        tvStatus.setText("STATUS: load model failed");
+    }
+
+    public void onRunModelSuccessed() {
+        tvStatus.setText("STATUS: run model successed");
+        // Obtain results and update UI
+        tvInferenceTime.setText("Inference time: " + predictor.inferenceTime() + " ms");
+        Bitmap outputImage = predictor.outputImage();
+        if (outputImage != null) {
+            ivInputImage.setImageBitmap(outputImage);
+        }
+        tvOutputResult.setText(predictor.outputResult());
+        tvOutputResult.scrollTo(0, 0);
+    }
+
+    public void onRunModelFailed() {
+        tvStatus.setText("STATUS: run model failed");
+    }
+
+    public void onImageChanged(Bitmap image) {
+        // Rerun model if users pick test image from gallery or camera
+        if (image != null && predictor.isLoaded()) {
+            predictor.setInputImage(image);
+            runModel();
+        }
+    }
+
+    public void set_img() {
+        // Load test image from path and run model
+        try {
+            assetManager= getAssets();
+            InputStream in=assetManager.open(imagePath);
+            Bitmap bmp=BitmapFactory.decodeStream(in);
+            ivInputImage.setImageBitmap(bmp);
+        } catch (IOException e) {
+            Toast.makeText(MainActivity.this, "Load image failed!", Toast.LENGTH_SHORT).show();
+            e.printStackTrace();
+        }
+    }
+
+    public void onSettingsClicked() {
+        startActivity(new Intent(MainActivity.this, SettingsActivity.class));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.menu_action_options, menu);
+        return true;
+    }
+
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        boolean isLoaded = predictor.isLoaded();
+        return super.onPrepareOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                finish();
+                break;
+            case R.id.settings:
+                if (requestAllPermissions()) {
+                    // Make sure we have SDCard r&w permissions to load model from SDCard
+                    onSettingsClicked();
+                }
+                break;
+        }
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
+                                           @NonNull int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        if (grantResults[0] != PackageManager.PERMISSION_GRANTED || grantResults[1] != PackageManager.PERMISSION_GRANTED) {
+            Toast.makeText(this, "Permission Denied", Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    private boolean requestAllPermissions() {
+        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
+                != PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(this,
+                Manifest.permission.CAMERA)
+                != PackageManager.PERMISSION_GRANTED) {
+            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,
+                            Manifest.permission.CAMERA},
+                    0);
+            return false;
+        }
+        return true;
+    }
+
+    private void openGallery() {
+        Intent intent = new Intent(Intent.ACTION_PICK, null);
+        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
+        startActivityForResult(intent, OPEN_GALLERY_REQUEST_CODE);
+    }
+
+    private void takePhoto() {
+        Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
+        // Ensure that there's a camera activity to handle the intent
+        if (takePictureIntent.resolveActivity(getPackageManager()) != null) {
+            // Create the File where the photo should go
+            File photoFile = null;
+            try {
+                photoFile = createImageFile();
+            } catch (IOException ex) {
+                Log.e("MainActitity", ex.getMessage(), ex);
+                Toast.makeText(MainActivity.this,
+                        "Create Camera temp file failed: " + ex.getMessage(), Toast.LENGTH_SHORT).show();
+            }
+            // Continue only if the File was successfully created
+            if (photoFile != null) {
+                Log.i(TAG, "FILEPATH " + getExternalFilesDir("Pictures").getAbsolutePath());
+                Uri photoURI = FileProvider.getUriForFile(this,
+                        "com.baidu.paddle.lite.demo.ocr.fileprovider",
+                        photoFile);
+                currentPhotoPath = photoFile.getAbsolutePath();
+                takePictureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);
+                startActivityForResult(takePictureIntent, TAKE_PHOTO_REQUEST_CODE);
+                Log.i(TAG, "startActivityForResult finished");
+            }
+        }
+
+    }
+
+    private File createImageFile() throws IOException {
+        // Create an image file name
+        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
+        String imageFileName = "JPEG_" + timeStamp + "_";
+        File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
+        File image = File.createTempFile(
+                imageFileName,  /* prefix */
+                ".bmp",         /* suffix */
+                storageDir      /* directory */
+        );
+
+        return image;
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (resultCode == RESULT_OK) {
+            switch (requestCode) {
+                case OPEN_GALLERY_REQUEST_CODE:
+                    if (data == null) {
+                        break;
+                    }
+                    try {
+                        ContentResolver resolver = getContentResolver();
+                        Uri uri = data.getData();
+                        Bitmap image = MediaStore.Images.Media.getBitmap(resolver, uri);
+                        String[] proj = {MediaStore.Images.Media.DATA};
+                        Cursor cursor = managedQuery(uri, proj, null, null, null);
+                        cursor.moveToFirst();
+                        if (image != null) {
+//                            onImageChanged(image);
+                            ivInputImage.setImageBitmap(image);
+                        }
+                    } catch (IOException e) {
+                        Log.e(TAG, e.toString());
+                    }
+                    break;
+                case TAKE_PHOTO_REQUEST_CODE:
+                    if (currentPhotoPath != null) {
+                        ExifInterface exif = null;
+                        try {
+                            exif = new ExifInterface(currentPhotoPath);
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                        int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
+                                ExifInterface.ORIENTATION_UNDEFINED);
+                        Log.i(TAG, "rotation " + orientation);
+                        Bitmap image = BitmapFactory.decodeFile(currentPhotoPath);
+                        image = Utils.rotateBitmap(image, orientation);
+                        if (image != null) {
+//                            onImageChanged(image);
+                            ivInputImage.setImageBitmap(image);
+                        }
+                    } else {
+                        Log.e(TAG, "currentPhotoPath is null");
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    public void btn_load_model_click(View view) {
+        tvStatus.setText("STATUS: load model ......");
+        loadModel();
+    }
+
+    public void btn_run_model_click(View view) {
+        Bitmap image =((BitmapDrawable)ivInputImage.getDrawable()).getBitmap();
+        if(image == null) {
+            tvStatus.setText("STATUS: image is not exists");
+        }
+        else if (!predictor.isLoaded()){
+            tvStatus.setText("STATUS: model is not loaded");
+        }else{
+            tvStatus.setText("STATUS: run model ...... ");
+            predictor.setInputImage(image);
+            runModel();
+        }
+    }
+    public void btn_choice_img_click(View view) {
+        if (requestAllPermissions()) {
+            openGallery();
+        }
+    }
+
+    public void btn_take_photo_click(View view) {
+        if (requestAllPermissions()) {
+            takePhoto();
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        if (predictor != null) {
+            predictor.releaseModel();
+        }
+        worker.quit();
+        super.onDestroy();
+    }
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/MiniActivity.java

@@ -0,0 +1,157 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.util.Log;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class MiniActivity extends AppCompatActivity {
+
+
+    public static final int REQUEST_LOAD_MODEL = 0;
+    public static final int REQUEST_RUN_MODEL = 1;
+    public static final int REQUEST_UNLOAD_MODEL = 2;
+    public static final int RESPONSE_LOAD_MODEL_SUCCESSED = 0;
+    public static final int RESPONSE_LOAD_MODEL_FAILED = 1;
+    public static final int RESPONSE_RUN_MODEL_SUCCESSED = 2;
+    public static final int RESPONSE_RUN_MODEL_FAILED = 3;
+
+    private static final String TAG = "MiniActivity";
+
+    protected Handler receiver = null; // Receive messages from worker thread
+    protected Handler sender = null; // Send command to worker thread
+    protected HandlerThread worker = null; // Worker thread to load&run model
+    protected volatile Predictor predictor = null;
+
+    private String assetModelDirPath = "models/ocr_v2_for_cpu";
+    private String assetlabelFilePath = "labels/ppocr_keys_v1.txt";
+
+    private Button button;
+    private ImageView imageView; // image result
+    private TextView textView; // text result
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_mini);
+
+        Log.i(TAG, "SHOW in Logcat");
+
+        // Prepare the worker thread for mode loading and inference
+        worker = new HandlerThread("Predictor Worker");
+        worker.start();
+        sender = new Handler(worker.getLooper()) {
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case REQUEST_LOAD_MODEL:
+                        // Load model and reload test image
+                        if (!onLoadModel()) {
+                            runOnUiThread(new Runnable() {
+                                @Override
+                                public void run() {
+                                    Toast.makeText(MiniActivity.this, "Load model failed!", Toast.LENGTH_SHORT).show();
+                                }
+                            });
+                        }
+                        break;
+                    case REQUEST_RUN_MODEL:
+                        // Run model if model is loaded
+                        final boolean isSuccessed = onRunModel();
+                        runOnUiThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                if (isSuccessed){
+                                    onRunModelSuccessed();
+                                }else{
+                                    Toast.makeText(MiniActivity.this, "Run model failed!", Toast.LENGTH_SHORT).show();
+                                }
+                            }
+                        });
+                        break;
+                }
+            }
+        };
+        sender.sendEmptyMessage(REQUEST_LOAD_MODEL); // corresponding to REQUEST_LOAD_MODEL， to call onLoadModel()
+
+        imageView = findViewById(R.id.imageView);
+        textView = findViewById(R.id.sample_text);
+        button = findViewById(R.id.button);
+        button.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                sender.sendEmptyMessage(REQUEST_RUN_MODEL);
+            }
+        });
+
+
+    }
+
+    @Override
+    protected void onDestroy() {
+        onUnloadModel();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            worker.quitSafely();
+        } else {
+            worker.quit();
+        }
+        super.onDestroy();
+    }
+
+    /**
+     * call in onCreate, model init
+     *
+     * @return
+     */
+    private boolean onLoadModel() {
+        if (predictor == null) {
+            predictor = new Predictor();
+        }
+        return predictor.init(this, assetModelDirPath, assetlabelFilePath);
+    }
+
+    /**
+     * init engine
+     * call in onCreate
+     *
+     * @return
+     */
+    private boolean onRunModel() {
+        try {
+            String assetImagePath = "images/0.jpg";
+            InputStream imageStream = getAssets().open(assetImagePath);
+            Bitmap image = BitmapFactory.decodeStream(imageStream);
+            // Input is Bitmap
+            predictor.setInputImage(image);
+            return predictor.isLoaded() && predictor.runModel();
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    private void onRunModelSuccessed() {
+        Log.i(TAG, "onRunModelSuccessed");
+        textView.setText(predictor.outputResult);
+        imageView.setImageBitmap(predictor.outputImage);
+    }
+
+    private void onUnloadModel() {
+        if (predictor != null) {
+            predictor.releaseModel();
+        }
+    }
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/OCRPredictorNative.java

@@ -0,0 +1,102 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.graphics.Bitmap;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class OCRPredictorNative {
+
+    private static final AtomicBoolean isSOLoaded = new AtomicBoolean();
+
+    public static void loadLibrary() throws RuntimeException {
+        if (!isSOLoaded.get() && isSOLoaded.compareAndSet(false, true)) {
+            try {
+                System.loadLibrary("Native");
+            } catch (Throwable e) {
+                RuntimeException exception = new RuntimeException(
+                        "Load libNative.so failed, please check it exists in apk file.", e);
+                throw exception;
+            }
+        }
+    }
+
+    private Config config;
+
+    private long nativePointer = 0;
+
+    public OCRPredictorNative(Config config) {
+        this.config = config;
+        loadLibrary();
+        nativePointer = init(config.detModelFilename, config.recModelFilename,config.clsModelFilename,
+                config.cpuThreadNum, config.cpuPower);
+        Log.i("OCRPredictorNative", "load success " + nativePointer);
+
+    }
+
+
+    public ArrayList<OcrResultModel> runImage(float[] inputData, int width, int height, int channels, Bitmap originalImage) {
+        Log.i("OCRPredictorNative", "begin to run image " + inputData.length + " " + width + " " + height);
+        float[] dims = new float[]{1, channels, height, width};
+        float[] rawResults = forward(nativePointer, inputData, dims, originalImage);
+        ArrayList<OcrResultModel> results = postprocess(rawResults);
+        return results;
+    }
+
+    public static class Config {
+        public int cpuThreadNum;
+        public String cpuPower;
+        public String detModelFilename;
+        public String recModelFilename;
+        public String clsModelFilename;
+
+    }
+
+    public void destory(){
+        if (nativePointer > 0) {
+            release(nativePointer);
+            nativePointer = 0;
+        }
+    }
+
+    protected native long init(String detModelPath, String recModelPath,String clsModelPath, int threadNum, String cpuMode);
+
+    protected native float[] forward(long pointer, float[] buf, float[] ddims, Bitmap originalImage);
+
+    protected native void release(long pointer);
+
+    private ArrayList<OcrResultModel> postprocess(float[] raw) {
+        ArrayList<OcrResultModel> results = new ArrayList<OcrResultModel>();
+        int begin = 0;
+
+        while (begin < raw.length) {
+            int point_num = Math.round(raw[begin]);
+            int word_num = Math.round(raw[begin + 1]);
+            OcrResultModel model = parse(raw, begin + 2, point_num, word_num);
+            begin += 2 + 1 + point_num * 2 + word_num;
+            results.add(model);
+        }
+
+        return results;
+    }
+
+    private OcrResultModel parse(float[] raw, int begin, int pointNum, int wordNum) {
+        int current = begin;
+        OcrResultModel model = new OcrResultModel();
+        model.setConfidence(raw[current]);
+        current++;
+        for (int i = 0; i < pointNum; i++) {
+            model.addPoints(Math.round(raw[current + i * 2]), Math.round(raw[current + i * 2 + 1]));
+        }
+        current += (pointNum * 2);
+        for (int i = 0; i < wordNum; i++) {
+            int index = Math.round(raw[current + i]);
+            model.addWordIndex(index);
+        }
+        Log.i("OCRPredictorNative", "word finished " + wordNum);
+        return model;
+    }
+
+
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/OcrResultModel.java

@@ -0,0 +1,52 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.graphics.Point;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class OcrResultModel {
+    private List<Point> points;
+    private List<Integer> wordIndex;
+    private String label;
+    private float confidence;
+
+    public OcrResultModel() {
+        super();
+        points = new ArrayList<>();
+        wordIndex = new ArrayList<>();
+    }
+
+    public void addPoints(int x, int y) {
+        Point point = new Point(x, y);
+        points.add(point);
+    }
+
+    public void addWordIndex(int index) {
+        wordIndex.add(index);
+    }
+
+    public List<Point> getPoints() {
+        return points;
+    }
+
+    public List<Integer> getWordIndex() {
+        return wordIndex;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public float getConfidence() {
+        return confidence;
+    }
+
+    public void setConfidence(float confidence) {
+        this.confidence = confidence;
+    }
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/Predictor.java

@@ -0,0 +1,357 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Path;
+import android.graphics.Point;
+import android.util.Log;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Vector;
+
+import static android.graphics.Color.*;
+
+public class Predictor {
+    private static final String TAG = Predictor.class.getSimpleName();
+    public boolean isLoaded = false;
+    public int warmupIterNum = 1;
+    public int inferIterNum = 1;
+    public int cpuThreadNum = 4;
+    public String cpuPowerMode = "LITE_POWER_HIGH";
+    public String modelPath = "";
+    public String modelName = "";
+    protected OCRPredictorNative paddlePredictor = null;
+    protected float inferenceTime = 0;
+    // Only for object detection
+    protected Vector<String> wordLabels = new Vector<String>();
+    protected String inputColorFormat = "BGR";
+    protected long[] inputShape = new long[]{1, 3, 960};
+    protected float[] inputMean = new float[]{0.485f, 0.456f, 0.406f};
+    protected float[] inputStd = new float[]{1.0f / 0.229f, 1.0f / 0.224f, 1.0f / 0.225f};
+    protected float scoreThreshold = 0.1f;
+    protected Bitmap inputImage = null;
+    protected Bitmap outputImage = null;
+    protected volatile String outputResult = "";
+    protected float preprocessTime = 0;
+    protected float postprocessTime = 0;
+
+
+    public Predictor() {
+    }
+
+    public boolean init(Context appCtx, String modelPath, String labelPath) {
+        isLoaded = loadModel(appCtx, modelPath, cpuThreadNum, cpuPowerMode);
+        if (!isLoaded) {
+            return false;
+        }
+        isLoaded = loadLabel(appCtx, labelPath);
+        return isLoaded;
+    }
+
+
+    public boolean init(Context appCtx, String modelPath, String labelPath, int cpuThreadNum, String cpuPowerMode,
+                        String inputColorFormat,
+                        long[] inputShape, float[] inputMean,
+                        float[] inputStd, float scoreThreshold) {
+        if (inputShape.length != 3) {
+            Log.e(TAG, "Size of input shape should be: 3");
+            return false;
+        }
+        if (inputMean.length != inputShape[1]) {
+            Log.e(TAG, "Size of input mean should be: " + Long.toString(inputShape[1]));
+            return false;
+        }
+        if (inputStd.length != inputShape[1]) {
+            Log.e(TAG, "Size of input std should be: " + Long.toString(inputShape[1]));
+            return false;
+        }
+        if (inputShape[0] != 1) {
+            Log.e(TAG, "Only one batch is supported in the image classification demo, you can use any batch size in " +
+                    "your Apps!");
+            return false;
+        }
+        if (inputShape[1] != 1 && inputShape[1] != 3) {
+            Log.e(TAG, "Only one/three channels are supported in the image classification demo, you can use any " +
+                    "channel size in your Apps!");
+            return false;
+        }
+        if (!inputColorFormat.equalsIgnoreCase("BGR")) {
+            Log.e(TAG, "Only  BGR color format is supported.");
+            return false;
+        }
+        boolean isLoaded = init(appCtx, modelPath, labelPath);
+        if (!isLoaded) {
+            return false;
+        }
+        this.inputColorFormat = inputColorFormat;
+        this.inputShape = inputShape;
+        this.inputMean = inputMean;
+        this.inputStd = inputStd;
+        this.scoreThreshold = scoreThreshold;
+        return true;
+    }
+
+    protected boolean loadModel(Context appCtx, String modelPath, int cpuThreadNum, String cpuPowerMode) {
+        // Release model if exists
+        releaseModel();
+
+        // Load model
+        if (modelPath.isEmpty()) {
+            return false;
+        }
+        String realPath = modelPath;
+        if (!modelPath.substring(0, 1).equals("/")) {
+            // Read model files from custom path if the first character of mode path is '/'
+            // otherwise copy model to cache from assets
+            realPath = appCtx.getCacheDir() + "/" + modelPath;
+            Utils.copyDirectoryFromAssets(appCtx, modelPath, realPath);
+        }
+        if (realPath.isEmpty()) {
+            return false;
+        }
+
+        OCRPredictorNative.Config config = new OCRPredictorNative.Config();
+        config.cpuThreadNum = cpuThreadNum;
+        config.detModelFilename = realPath + File.separator + "ch_ppocr_mobile_v2.0_det_opt.nb";
+        config.recModelFilename = realPath + File.separator + "ch_ppocr_mobile_v2.0_rec_opt.nb";
+        config.clsModelFilename = realPath + File.separator + "ch_ppocr_mobile_v2.0_cls_opt.nb";
+        Log.e("Predictor", "model path" + config.detModelFilename + " ; " + config.recModelFilename + ";" + config.clsModelFilename);
+        config.cpuPower = cpuPowerMode;
+        paddlePredictor = new OCRPredictorNative(config);
+
+        this.cpuThreadNum = cpuThreadNum;
+        this.cpuPowerMode = cpuPowerMode;
+        this.modelPath = realPath;
+        this.modelName = realPath.substring(realPath.lastIndexOf("/") + 1);
+        return true;
+    }
+
+    public void releaseModel() {
+        if (paddlePredictor != null) {
+            paddlePredictor.destory();
+            paddlePredictor = null;
+        }
+        isLoaded = false;
+        cpuThreadNum = 1;
+        cpuPowerMode = "LITE_POWER_HIGH";
+        modelPath = "";
+        modelName = "";
+    }
+
+    protected boolean loadLabel(Context appCtx, String labelPath) {
+        wordLabels.clear();
+        wordLabels.add("black");
+        // Load word labels from file
+        try {
+            InputStream assetsInputStream = appCtx.getAssets().open(labelPath);
+            int available = assetsInputStream.available();
+            byte[] lines = new byte[available];
+            assetsInputStream.read(lines);
+            assetsInputStream.close();
+            String words = new String(lines);
+            String[] contents = words.split("\n");
+            for (String content : contents) {
+                wordLabels.add(content);
+            }
+            Log.i(TAG, "Word label size: " + wordLabels.size());
+        } catch (Exception e) {
+            Log.e(TAG, e.getMessage());
+            return false;
+        }
+        return true;
+    }
+
+
+    public boolean runModel() {
+        if (inputImage == null || !isLoaded()) {
+            return false;
+        }
+
+        // Pre-process image, and feed input tensor with pre-processed data
+
+        Bitmap scaleImage = Utils.resizeWithStep(inputImage, Long.valueOf(inputShape[2]).intValue(), 32);
+
+        Date start = new Date();
+        int channels = (int) inputShape[1];
+        int width = scaleImage.getWidth();
+        int height = scaleImage.getHeight();
+        float[] inputData = new float[channels * width * height];
+        if (channels == 3) {
+            int[] channelIdx = null;
+            if (inputColorFormat.equalsIgnoreCase("RGB")) {
+                channelIdx = new int[]{0, 1, 2};
+            } else if (inputColorFormat.equalsIgnoreCase("BGR")) {
+                channelIdx = new int[]{2, 1, 0};
+            } else {
+                Log.i(TAG, "Unknown color format " + inputColorFormat + ", only RGB and BGR color format is " +
+                        "supported!");
+                return false;
+            }
+            int[] channelStride = new int[]{width * height, width * height * 2};
+            int p = scaleImage.getPixel(scaleImage.getWidth() - 1, scaleImage.getHeight() - 1);
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                    int color = scaleImage.getPixel(x, y);
+                    float[] rgb = new float[]{(float) red(color) / 255.0f, (float) green(color) / 255.0f,
+                            (float) blue(color) / 255.0f};
+                    inputData[y * width + x] = (rgb[channelIdx[0]] - inputMean[0]) / inputStd[0];
+                    inputData[y * width + x + channelStride[0]] = (rgb[channelIdx[1]] - inputMean[1]) / inputStd[1];
+                    inputData[y * width + x + channelStride[1]] = (rgb[channelIdx[2]] - inputMean[2]) / inputStd[2];
+
+                }
+            }
+        } else if (channels == 1) {
+            for (int y = 0; y < height; y++) {
+                for (int x = 0; x < width; x++) {
+                    int color = inputImage.getPixel(x, y);
+                    float gray = (float) (red(color) + green(color) + blue(color)) / 3.0f / 255.0f;
+                    inputData[y * width + x] = (gray - inputMean[0]) / inputStd[0];
+                }
+            }
+        } else {
+            Log.i(TAG, "Unsupported channel size " + Integer.toString(channels) + ",  only channel 1 and 3 is " +
+                    "supported!");
+            return false;
+        }
+        float[] pixels = inputData;
+        Log.i(TAG, "pixels " + pixels[0] + " " + pixels[1] + " " + pixels[2] + " " + pixels[3]
+                + " " + pixels[pixels.length / 2] + " " + pixels[pixels.length / 2 + 1] + " " + pixels[pixels.length - 2] + " " + pixels[pixels.length - 1]);
+        Date end = new Date();
+        preprocessTime = (float) (end.getTime() - start.getTime());
+
+        // Warm up
+        for (int i = 0; i < warmupIterNum; i++) {
+            paddlePredictor.runImage(inputData, width, height, channels, inputImage);
+        }
+        warmupIterNum = 0; // do not need warm
+        // Run inference
+        start = new Date();
+        ArrayList<OcrResultModel> results = paddlePredictor.runImage(inputData, width, height, channels, inputImage);
+        end = new Date();
+        inferenceTime = (end.getTime() - start.getTime()) / (float) inferIterNum;
+
+        results = postprocess(results);
+        Log.i(TAG, "[stat] Preprocess Time: " + preprocessTime
+                + " ; Inference Time: " + inferenceTime + " ;Box Size " + results.size());
+        drawResults(results);
+
+        return true;
+    }
+
+
+    public boolean isLoaded() {
+        return paddlePredictor != null && isLoaded;
+    }
+
+    public String modelPath() {
+        return modelPath;
+    }
+
+    public String modelName() {
+        return modelName;
+    }
+
+    public int cpuThreadNum() {
+        return cpuThreadNum;
+    }
+
+    public String cpuPowerMode() {
+        return cpuPowerMode;
+    }
+
+    public float inferenceTime() {
+        return inferenceTime;
+    }
+
+    public Bitmap inputImage() {
+        return inputImage;
+    }
+
+    public Bitmap outputImage() {
+        return outputImage;
+    }
+
+    public String outputResult() {
+        return outputResult;
+    }
+
+    public float preprocessTime() {
+        return preprocessTime;
+    }
+
+    public float postprocessTime() {
+        return postprocessTime;
+    }
+
+
+    public void setInputImage(Bitmap image) {
+        if (image == null) {
+            return;
+        }
+        this.inputImage = image.copy(Bitmap.Config.ARGB_8888, true);
+    }
+
+    private ArrayList<OcrResultModel> postprocess(ArrayList<OcrResultModel> results) {
+        for (OcrResultModel r : results) {
+            StringBuffer word = new StringBuffer();
+            for (int index : r.getWordIndex()) {
+                if (index >= 0 && index < wordLabels.size()) {
+                    word.append(wordLabels.get(index));
+                } else {
+                    Log.e(TAG, "Word index is not in label list:" + index);
+                    word.append("×");
+                }
+            }
+            r.setLabel(word.toString());
+        }
+        return results;
+    }
+
+    private void drawResults(ArrayList<OcrResultModel> results) {
+        StringBuffer outputResultSb = new StringBuffer("");
+        for (int i = 0; i < results.size(); i++) {
+            OcrResultModel result = results.get(i);
+            StringBuilder sb = new StringBuilder("");
+            sb.append(result.getLabel());
+            sb.append(" ").append(result.getConfidence());
+            sb.append("; Points: ");
+            for (Point p : result.getPoints()) {
+                sb.append("(").append(p.x).append(",").append(p.y).append(") ");
+            }
+            Log.i(TAG, sb.toString()); // show LOG in Logcat panel
+            outputResultSb.append(i + 1).append(": ").append(result.getLabel()).append("\n");
+        }
+        outputResult = outputResultSb.toString();
+        outputImage = inputImage;
+        Canvas canvas = new Canvas(outputImage);
+        Paint paintFillAlpha = new Paint();
+        paintFillAlpha.setStyle(Paint.Style.FILL);
+        paintFillAlpha.setColor(Color.parseColor("#3B85F5"));
+        paintFillAlpha.setAlpha(50);
+
+        Paint paint = new Paint();
+        paint.setColor(Color.parseColor("#3B85F5"));
+        paint.setStrokeWidth(5);
+        paint.setStyle(Paint.Style.STROKE);
+
+        for (OcrResultModel result : results) {
+            Path path = new Path();
+            List<Point> points = result.getPoints();
+            path.moveTo(points.get(0).x, points.get(0).y);
+            for (int i = points.size() - 1; i >= 0; i--) {
+                Point p = points.get(i);
+                path.lineTo(p.x, p.y);
+            }
+            canvas.drawPath(path, paint);
+            canvas.drawPath(path, paintFillAlpha);
+        }
+    }
+
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/SettingsActivity.java

@@ -0,0 +1,201 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.EditTextPreference;
+import android.preference.ListPreference;
+
+import androidx.appcompat.app.ActionBar;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class SettingsActivity extends AppCompatPreferenceActivity implements SharedPreferences.OnSharedPreferenceChangeListener {
+    ListPreference lpChoosePreInstalledModel = null;
+    CheckBoxPreference cbEnableCustomSettings = null;
+    EditTextPreference etModelPath = null;
+    EditTextPreference etLabelPath = null;
+    ListPreference etImagePath = null;
+    ListPreference lpCPUThreadNum = null;
+    ListPreference lpCPUPowerMode = null;
+    ListPreference lpInputColorFormat = null;
+    EditTextPreference etInputShape = null;
+    EditTextPreference etInputMean = null;
+    EditTextPreference etInputStd = null;
+    EditTextPreference etScoreThreshold = null;
+
+    List<String> preInstalledModelPaths = null;
+    List<String> preInstalledLabelPaths = null;
+    List<String> preInstalledImagePaths = null;
+    List<String> preInstalledInputShapes = null;
+    List<String> preInstalledCPUThreadNums = null;
+    List<String> preInstalledCPUPowerModes = null;
+    List<String> preInstalledInputColorFormats = null;
+    List<String> preInstalledInputMeans = null;
+    List<String> preInstalledInputStds = null;
+    List<String> preInstalledScoreThresholds = null;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        addPreferencesFromResource(R.xml.settings);
+        ActionBar supportActionBar = getSupportActionBar();
+        if (supportActionBar != null) {
+            supportActionBar.setDisplayHomeAsUpEnabled(true);
+        }
+
+        // Initialized pre-installed models
+        preInstalledModelPaths = new ArrayList<String>();
+        preInstalledLabelPaths = new ArrayList<String>();
+        preInstalledImagePaths = new ArrayList<String>();
+        preInstalledInputShapes = new ArrayList<String>();
+        preInstalledCPUThreadNums = new ArrayList<String>();
+        preInstalledCPUPowerModes = new ArrayList<String>();
+        preInstalledInputColorFormats = new ArrayList<String>();
+        preInstalledInputMeans = new ArrayList<String>();
+        preInstalledInputStds = new ArrayList<String>();
+        preInstalledScoreThresholds = new ArrayList<String>();
+        // Add ssd_mobilenet_v1_pascalvoc_for_cpu
+        preInstalledModelPaths.add(getString(R.string.MODEL_PATH_DEFAULT));
+        preInstalledLabelPaths.add(getString(R.string.LABEL_PATH_DEFAULT));
+        preInstalledImagePaths.add(getString(R.string.IMAGE_PATH_DEFAULT));
+        preInstalledCPUThreadNums.add(getString(R.string.CPU_THREAD_NUM_DEFAULT));
+        preInstalledCPUPowerModes.add(getString(R.string.CPU_POWER_MODE_DEFAULT));
+        preInstalledInputColorFormats.add(getString(R.string.INPUT_COLOR_FORMAT_DEFAULT));
+        preInstalledInputShapes.add(getString(R.string.INPUT_SHAPE_DEFAULT));
+        preInstalledInputMeans.add(getString(R.string.INPUT_MEAN_DEFAULT));
+        preInstalledInputStds.add(getString(R.string.INPUT_STD_DEFAULT));
+        preInstalledScoreThresholds.add(getString(R.string.SCORE_THRESHOLD_DEFAULT));
+
+        // Setup UI components
+        lpChoosePreInstalledModel =
+                (ListPreference) findPreference(getString(R.string.CHOOSE_PRE_INSTALLED_MODEL_KEY));
+        String[] preInstalledModelNames = new String[preInstalledModelPaths.size()];
+        for (int i = 0; i < preInstalledModelPaths.size(); i++) {
+            preInstalledModelNames[i] =
+                    preInstalledModelPaths.get(i).substring(preInstalledModelPaths.get(i).lastIndexOf("/") + 1);
+        }
+        lpChoosePreInstalledModel.setEntries(preInstalledModelNames);
+        lpChoosePreInstalledModel.setEntryValues(preInstalledModelPaths.toArray(new String[preInstalledModelPaths.size()]));
+        cbEnableCustomSettings =
+                (CheckBoxPreference) findPreference(getString(R.string.ENABLE_CUSTOM_SETTINGS_KEY));
+        etModelPath = (EditTextPreference) findPreference(getString(R.string.MODEL_PATH_KEY));
+        etModelPath.setTitle("Model Path (SDCard: " + Utils.getSDCardDirectory() + ")");
+        etLabelPath = (EditTextPreference) findPreference(getString(R.string.LABEL_PATH_KEY));
+        etImagePath = (ListPreference) findPreference(getString(R.string.IMAGE_PATH_KEY));
+        lpCPUThreadNum =
+                (ListPreference) findPreference(getString(R.string.CPU_THREAD_NUM_KEY));
+        lpCPUPowerMode =
+                (ListPreference) findPreference(getString(R.string.CPU_POWER_MODE_KEY));
+        lpInputColorFormat =
+                (ListPreference) findPreference(getString(R.string.INPUT_COLOR_FORMAT_KEY));
+        etInputShape = (EditTextPreference) findPreference(getString(R.string.INPUT_SHAPE_KEY));
+        etInputMean = (EditTextPreference) findPreference(getString(R.string.INPUT_MEAN_KEY));
+        etInputStd = (EditTextPreference) findPreference(getString(R.string.INPUT_STD_KEY));
+        etScoreThreshold = (EditTextPreference) findPreference(getString(R.string.SCORE_THRESHOLD_KEY));
+    }
+
+    private void reloadPreferenceAndUpdateUI() {
+        SharedPreferences sharedPreferences = getPreferenceScreen().getSharedPreferences();
+        boolean enableCustomSettings =
+                sharedPreferences.getBoolean(getString(R.string.ENABLE_CUSTOM_SETTINGS_KEY), false);
+        String modelPath = sharedPreferences.getString(getString(R.string.CHOOSE_PRE_INSTALLED_MODEL_KEY),
+                getString(R.string.MODEL_PATH_DEFAULT));
+        int modelIdx = lpChoosePreInstalledModel.findIndexOfValue(modelPath);
+        if (modelIdx >= 0 && modelIdx < preInstalledModelPaths.size()) {
+            if (!enableCustomSettings) {
+                SharedPreferences.Editor editor = sharedPreferences.edit();
+                editor.putString(getString(R.string.MODEL_PATH_KEY), preInstalledModelPaths.get(modelIdx));
+                editor.putString(getString(R.string.LABEL_PATH_KEY), preInstalledLabelPaths.get(modelIdx));
+                editor.putString(getString(R.string.IMAGE_PATH_KEY), preInstalledImagePaths.get(modelIdx));
+                editor.putString(getString(R.string.CPU_THREAD_NUM_KEY), preInstalledCPUThreadNums.get(modelIdx));
+                editor.putString(getString(R.string.CPU_POWER_MODE_KEY), preInstalledCPUPowerModes.get(modelIdx));
+                editor.putString(getString(R.string.INPUT_COLOR_FORMAT_KEY),
+                        preInstalledInputColorFormats.get(modelIdx));
+                editor.putString(getString(R.string.INPUT_SHAPE_KEY), preInstalledInputShapes.get(modelIdx));
+                editor.putString(getString(R.string.INPUT_MEAN_KEY), preInstalledInputMeans.get(modelIdx));
+                editor.putString(getString(R.string.INPUT_STD_KEY), preInstalledInputStds.get(modelIdx));
+                editor.putString(getString(R.string.SCORE_THRESHOLD_KEY),
+                        preInstalledScoreThresholds.get(modelIdx));
+                editor.apply();
+            }
+            lpChoosePreInstalledModel.setSummary(modelPath);
+        }
+        cbEnableCustomSettings.setChecked(enableCustomSettings);
+        etModelPath.setEnabled(enableCustomSettings);
+        etLabelPath.setEnabled(enableCustomSettings);
+        etImagePath.setEnabled(enableCustomSettings);
+        lpCPUThreadNum.setEnabled(enableCustomSettings);
+        lpCPUPowerMode.setEnabled(enableCustomSettings);
+        lpInputColorFormat.setEnabled(enableCustomSettings);
+        etInputShape.setEnabled(enableCustomSettings);
+        etInputMean.setEnabled(enableCustomSettings);
+        etInputStd.setEnabled(enableCustomSettings);
+        etScoreThreshold.setEnabled(enableCustomSettings);
+        modelPath = sharedPreferences.getString(getString(R.string.MODEL_PATH_KEY),
+                getString(R.string.MODEL_PATH_DEFAULT));
+        String labelPath = sharedPreferences.getString(getString(R.string.LABEL_PATH_KEY),
+                getString(R.string.LABEL_PATH_DEFAULT));
+        String imagePath = sharedPreferences.getString(getString(R.string.IMAGE_PATH_KEY),
+                getString(R.string.IMAGE_PATH_DEFAULT));
+        String cpuThreadNum = sharedPreferences.getString(getString(R.string.CPU_THREAD_NUM_KEY),
+                getString(R.string.CPU_THREAD_NUM_DEFAULT));
+        String cpuPowerMode = sharedPreferences.getString(getString(R.string.CPU_POWER_MODE_KEY),
+                getString(R.string.CPU_POWER_MODE_DEFAULT));
+        String inputColorFormat = sharedPreferences.getString(getString(R.string.INPUT_COLOR_FORMAT_KEY),
+                getString(R.string.INPUT_COLOR_FORMAT_DEFAULT));
+        String inputShape = sharedPreferences.getString(getString(R.string.INPUT_SHAPE_KEY),
+                getString(R.string.INPUT_SHAPE_DEFAULT));
+        String inputMean = sharedPreferences.getString(getString(R.string.INPUT_MEAN_KEY),
+                getString(R.string.INPUT_MEAN_DEFAULT));
+        String inputStd = sharedPreferences.getString(getString(R.string.INPUT_STD_KEY),
+                getString(R.string.INPUT_STD_DEFAULT));
+        String scoreThreshold = sharedPreferences.getString(getString(R.string.SCORE_THRESHOLD_KEY),
+                getString(R.string.SCORE_THRESHOLD_DEFAULT));
+        etModelPath.setSummary(modelPath);
+        etModelPath.setText(modelPath);
+        etLabelPath.setSummary(labelPath);
+        etLabelPath.setText(labelPath);
+        etImagePath.setSummary(imagePath);
+        etImagePath.setValue(imagePath);
+        lpCPUThreadNum.setValue(cpuThreadNum);
+        lpCPUThreadNum.setSummary(cpuThreadNum);
+        lpCPUPowerMode.setValue(cpuPowerMode);
+        lpCPUPowerMode.setSummary(cpuPowerMode);
+        lpInputColorFormat.setValue(inputColorFormat);
+        lpInputColorFormat.setSummary(inputColorFormat);
+        etInputShape.setSummary(inputShape);
+        etInputShape.setText(inputShape);
+        etInputMean.setSummary(inputMean);
+        etInputMean.setText(inputMean);
+        etInputStd.setSummary(inputStd);
+        etInputStd.setText(inputStd);
+        etScoreThreshold.setText(scoreThreshold);
+        etScoreThreshold.setSummary(scoreThreshold);
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(this);
+        reloadPreferenceAndUpdateUI();
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(this);
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        if (key.equals(getString(R.string.CHOOSE_PRE_INSTALLED_MODEL_KEY))) {
+            SharedPreferences.Editor editor = sharedPreferences.edit();
+            editor.putBoolean(getString(R.string.ENABLE_CUSTOM_SETTINGS_KEY), false);
+            editor.commit();
+        }
+        reloadPreferenceAndUpdateUI();
+    }
+}

deploy/android_demo/app/src/main/java/com/baidu/paddle/lite/demo/ocr/Utils.java

@@ -0,0 +1,159 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Matrix;
+import android.media.ExifInterface;
+import android.os.Environment;
+
+import java.io.*;
+
+public class Utils {
+    private static final String TAG = Utils.class.getSimpleName();
+
+    public static void copyFileFromAssets(Context appCtx, String srcPath, String dstPath) {
+        if (srcPath.isEmpty() || dstPath.isEmpty()) {
+            return;
+        }
+        InputStream is = null;
+        OutputStream os = null;
+        try {
+            is = new BufferedInputStream(appCtx.getAssets().open(srcPath));
+            os = new BufferedOutputStream(new FileOutputStream(new File(dstPath)));
+            byte[] buffer = new byte[1024];
+            int length = 0;
+            while ((length = is.read(buffer)) != -1) {
+                os.write(buffer, 0, length);
+            }
+        } catch (FileNotFoundException e) {
+            e.printStackTrace();
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            try {
+                os.close();
+                is.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    public static void copyDirectoryFromAssets(Context appCtx, String srcDir, String dstDir) {
+        if (srcDir.isEmpty() || dstDir.isEmpty()) {
+            return;
+        }
+        try {
+            if (!new File(dstDir).exists()) {
+                new File(dstDir).mkdirs();
+            }
+            for (String fileName : appCtx.getAssets().list(srcDir)) {
+                String srcSubPath = srcDir + File.separator + fileName;
+                String dstSubPath = dstDir + File.separator + fileName;
+                if (new File(srcSubPath).isDirectory()) {
+                    copyDirectoryFromAssets(appCtx, srcSubPath, dstSubPath);
+                } else {
+                    copyFileFromAssets(appCtx, srcSubPath, dstSubPath);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static float[] parseFloatsFromString(String string, String delimiter) {
+        String[] pieces = string.trim().toLowerCase().split(delimiter);
+        float[] floats = new float[pieces.length];
+        for (int i = 0; i < pieces.length; i++) {
+            floats[i] = Float.parseFloat(pieces[i].trim());
+        }
+        return floats;
+    }
+
+    public static long[] parseLongsFromString(String string, String delimiter) {
+        String[] pieces = string.trim().toLowerCase().split(delimiter);
+        long[] longs = new long[pieces.length];
+        for (int i = 0; i < pieces.length; i++) {
+            longs[i] = Long.parseLong(pieces[i].trim());
+        }
+        return longs;
+    }
+
+    public static String getSDCardDirectory() {
+        return Environment.getExternalStorageDirectory().getAbsolutePath();
+    }
+
+    public static boolean isSupportedNPU() {
+        return false;
+        // String hardware = android.os.Build.HARDWARE;
+        // return hardware.equalsIgnoreCase("kirin810") || hardware.equalsIgnoreCase("kirin990");
+    }
+
+    public static Bitmap resizeWithStep(Bitmap bitmap, int maxLength, int step) {
+        int width = bitmap.getWidth();
+        int height = bitmap.getHeight();
+        int maxWH = Math.max(width, height);
+        float ratio = 1;
+        int newWidth = width;
+        int newHeight = height;
+        if (maxWH > maxLength) {
+            ratio = maxLength * 1.0f / maxWH;
+            newWidth = (int) Math.floor(ratio * width);
+            newHeight = (int) Math.floor(ratio * height);
+        }
+
+        newWidth = newWidth - newWidth % step;
+        if (newWidth == 0) {
+            newWidth = step;
+        }
+        newHeight = newHeight - newHeight % step;
+        if (newHeight == 0) {
+            newHeight = step;
+        }
+        return Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true);
+    }
+
+    public static Bitmap rotateBitmap(Bitmap bitmap, int orientation) {
+
+        Matrix matrix = new Matrix();
+        switch (orientation) {
+            case ExifInterface.ORIENTATION_NORMAL:
+                return bitmap;
+            case ExifInterface.ORIENTATION_FLIP_HORIZONTAL:
+                matrix.setScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_180:
+                matrix.setRotate(180);
+                break;
+            case ExifInterface.ORIENTATION_FLIP_VERTICAL:
+                matrix.setRotate(180);
+                matrix.postScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_TRANSPOSE:
+                matrix.setRotate(90);
+                matrix.postScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_90:
+                matrix.setRotate(90);
+                break;
+            case ExifInterface.ORIENTATION_TRANSVERSE:
+                matrix.setRotate(-90);
+                matrix.postScale(-1, 1);
+                break;
+            case ExifInterface.ORIENTATION_ROTATE_270:
+                matrix.setRotate(-90);
+                break;
+            default:
+                return bitmap;
+        }
+        try {
+            Bitmap bmRotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+            bitmap.recycle();
+            return bmRotated;
+        }
+        catch (OutOfMemoryError e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

deploy/android_demo/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -0,0 +1,34 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillType="evenOdd"
+        android:pathData="M32,64C32,64 38.39,52.99 44.13,50.95C51.37,48.37 70.14,49.57 70.14,49.57L108.26,87.69L108,109.01L75.97,107.97L32,64Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000">
+        <aapt:attr name="android:fillColor">
+            <gradient
+                android:endX="78.5885"
+                android:endY="90.9159"
+                android:startX="48.7653"
+                android:startY="61.0927"
+                android:type="linear">
+                <item
+                    android:color="#44000000"
+                    android:offset="0.0" />
+                <item
+                    android:color="#00000000"
+                    android:offset="1.0" />
+            </gradient>
+        </aapt:attr>
+    </path>
+    <path
+        android:fillColor="#FFFFFF"
+        android:fillType="nonZero"
+        android:pathData="M66.94,46.02L66.94,46.02C72.44,50.07 76,56.61 76,64L32,64C32,56.61 35.56,50.11 40.98,46.06L36.18,41.19C35.45,40.45 35.45,39.3 36.18,38.56C36.91,37.81 38.05,37.81 38.78,38.56L44.25,44.05C47.18,42.57 50.48,41.71 54,41.71C57.48,41.71 60.78,42.57 63.68,44.05L69.11,38.56C69.84,37.81 70.98,37.81 71.71,38.56C72.44,39.3 72.44,40.45 71.71,41.19L66.94,46.02ZM62.94,56.92C64.08,56.92 65,56.01 65,54.88C65,53.76 64.08,52.85 62.94,52.85C61.8,52.85 60.88,53.76 60.88,54.88C60.88,56.01 61.8,56.92 62.94,56.92ZM45.06,56.92C46.2,56.92 47.13,56.01 47.13,54.88C47.13,53.76 46.2,52.85 45.06,52.85C43.92,52.85 43,53.76 43,54.88C43,56.01 43.92,56.92 45.06,56.92Z"
+        android:strokeWidth="1"
+        android:strokeColor="#00000000" />
+</vector>

deploy/android_demo/app/src/main/res/drawable/ic_launcher_background.xml

@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+    <path
+        android:fillColor="#008577"
+        android:pathData="M0,0h108v108h-108z" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M9,0L9,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,0L19,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,0L29,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,0L39,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,0L49,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,0L59,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,0L69,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,0L79,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M89,0L89,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M99,0L99,108"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,9L108,9"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,19L108,19"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,29L108,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,39L108,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,49L108,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,59L108,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,69L108,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,79L108,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,89L108,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M0,99L108,99"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,29L89,29"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,39L89,39"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,49L89,49"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,59L89,59"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,69L89,69"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M19,79L89,79"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M29,19L29,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M39,19L39,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M49,19L49,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M59,19L59,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M69,19L69,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+    <path
+        android:fillColor="#00000000"
+        android:pathData="M79,19L79,89"
+        android:strokeWidth="0.8"
+        android:strokeColor="#33FFFFFF" />
+</vector>

deploy/android_demo/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,148 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+                                             xmlns:app="http://schemas.android.com/apk/res-auto"
+                                             xmlns:tools="http://schemas.android.com/tools"
+                                             android:layout_width="match_parent"
+                                             android:layout_height="match_parent"
+                                             tools:context=".MainActivity">
+
+    <RelativeLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent">
+
+        <LinearLayout
+                android:id="@+id/v_input_info"
+                android:layout_width="fill_parent"
+                android:layout_height="wrap_content"
+                android:layout_alignParentTop="true"
+                android:orientation="vertical">
+
+            <LinearLayout
+                android:id="@+id/btn_layout"
+                android:layout_width="fill_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal">
+
+                <Button
+                    android:id="@+id/btn_load_model"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:onClick="btn_load_model_click"
+                    android:text="加载模型" />
+                <Button
+                    android:id="@+id/btn_run_model"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:onClick="btn_run_model_click"
+                    android:text="运行模型" />
+                <Button
+                    android:id="@+id/btn_take_photo"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:onClick="btn_take_photo_click"
+                    android:text="拍照识别" />
+                <Button
+                    android:id="@+id/btn_choice_img"
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:onClick="btn_choice_img_click"
+                    android:text="选取图片" />
+
+            </LinearLayout>
+            <TextView
+                    android:id="@+id/tv_input_setting"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:scrollbars="vertical"
+                    android:layout_marginLeft="12dp"
+                    android:layout_marginRight="12dp"
+                    android:layout_marginTop="10dp"
+                    android:layout_marginBottom="5dp"
+                    android:lineSpacingExtra="4dp"
+                    android:singleLine="false"
+                    android:maxLines="6"
+                    android:text=""/>
+            <TextView
+                android:id="@+id/tv_model_img_status"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:scrollbars="vertical"
+                android:layout_marginLeft="12dp"
+                android:layout_marginRight="12dp"
+                android:layout_marginTop="-5dp"
+                android:layout_marginBottom="5dp"
+                android:lineSpacingExtra="4dp"
+                android:singleLine="false"
+                android:maxLines="6"
+                android:text="STATUS: ok"/>
+
+        </LinearLayout>
+
+        <RelativeLayout
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:layout_above="@+id/v_output_info"
+                android:layout_below="@+id/v_input_info">
+
+            <ImageView
+                    android:id="@+id/iv_input_image"
+                    android:layout_width="400dp"
+                    android:layout_height="400dp"
+                    android:layout_centerHorizontal="true"
+                    android:layout_centerVertical="true"
+                    android:layout_marginLeft="12dp"
+                    android:layout_marginRight="12dp"
+                    android:layout_marginTop="5dp"
+                    android:layout_marginBottom="5dp"
+                    android:adjustViewBounds="true"
+                    android:scaleType="fitCenter"/>
+        </RelativeLayout>
+
+
+        <RelativeLayout
+                android:id="@+id/v_output_info"
+                android:layout_width="wrap_content"
+                android:layout_height="wrap_content"
+                android:layout_alignParentBottom="true"
+                android:layout_centerHorizontal="true">
+
+            <TextView
+                    android:id="@+id/tv_output_result"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_alignParentTop="true"
+                    android:layout_centerHorizontal="true"
+                    android:layout_centerVertical="true"
+                    android:scrollbars="vertical"
+                    android:layout_marginLeft="12dp"
+                    android:layout_marginRight="12dp"
+                    android:layout_marginTop="5dp"
+                    android:layout_marginBottom="5dp"
+                    android:textAlignment="center"
+                    android:lineSpacingExtra="5dp"
+                    android:singleLine="false"
+                    android:maxLines="5"
+                    android:text=""/>
+
+            <TextView
+                    android:id="@+id/tv_inference_time"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_below="@+id/tv_output_result"
+                    android:layout_centerHorizontal="true"
+                    android:layout_centerVertical="true"
+                    android:textAlignment="center"
+                    android:layout_marginLeft="12dp"
+                    android:layout_marginRight="12dp"
+                    android:layout_marginTop="5dp"
+                    android:layout_marginBottom="10dp"
+                    android:text=""/>
+
+        </RelativeLayout>
+
+    </RelativeLayout>
+</androidx.constraintlayout.widget.ConstraintLayout>

deploy/android_demo/app/src/main/res/layout/activity_mini.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- for MiniActivity Use Only -->
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    app:layout_constraintLeft_toLeftOf="parent"
+    app:layout_constraintLeft_toRightOf="parent"
+    tools:context=".MainActivity">
+
+    <TextView
+        android:id="@+id/sample_text"
+        android:layout_width="0dp"
+        android:layout_height="wrap_content"
+        android:text="Hello World!"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toBottomOf="@id/imageView"
+        android:scrollbars="vertical"
+        />
+
+    <ImageView
+        android:id="@+id/imageView"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:paddingTop="20dp"
+        android:paddingBottom="20dp"
+        app:layout_constraintBottom_toTopOf="@id/imageView"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        tools:srcCompat="@tools:sample/avatars" />
+
+    <Button
+        android:id="@+id/button"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="4dp"
+        android:text="Button"
+        app:layout_constraintBottom_toBottomOf="parent"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        tools:layout_editor_absoluteX="161dp" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>

deploy/android_demo/app/src/main/res/menu/menu_action_options.xml

@@ -0,0 +1,10 @@
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+      xmlns:app="http://schemas.android.com/apk/res-auto">
+
+    <group>
+        <item
+                android:id="@+id/settings"
+                android:title="Settings..."
+                app:showAsAction="withText"/>
+    </group>
+</menu>

deploy/android_demo/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

deploy/android_demo/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background" />
+    <foreground android:drawable="@drawable/ic_launcher_foreground" />
+</adaptive-icon>

deploy/android_demo/app/src/main/res/values/arrays.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string-array name="image_name_entries">
+        <item>0.jpg</item>
+        <item>90.jpg</item>
+        <item>180.jpg</item>
+        <item>270.jpg</item>
+    </string-array>
+    <string-array name="image_name_values">
+        <item>images/0.jpg</item>
+        <item>images/90.jpg</item>
+        <item>images/180.jpg</item>
+        <item>images/270.jpg</item>
+    </string-array>
+    <string-array name="cpu_thread_num_entries">
+        <item>1 threads</item>
+        <item>2 threads</item>
+        <item>4 threads</item>
+        <item>8 threads</item>
+    </string-array>
+    <string-array name="cpu_thread_num_values">
+        <item>1</item>
+        <item>2</item>
+        <item>4</item>
+        <item>8</item>
+    </string-array>
+    <string-array name="cpu_power_mode_entries">
+        <item>HIGH(only big cores)</item>
+        <item>LOW(only LITTLE cores)</item>
+        <item>FULL(all cores)</item>
+        <item>NO_BIND(depends on system)</item>
+        <item>RAND_HIGH</item>
+        <item>RAND_LOW</item>
+    </string-array>
+    <string-array name="cpu_power_mode_values">
+        <item>LITE_POWER_HIGH</item>
+        <item>LITE_POWER_LOW</item>
+        <item>LITE_POWER_FULL</item>
+        <item>LITE_POWER_NO_BIND</item>
+        <item>LITE_POWER_RAND_HIGH</item>
+        <item>LITE_POWER_RAND_LOW</item>
+    </string-array>
+    <string-array name="input_color_format_entries">
+        <item>BGR color format</item>
+        <item>RGB color format</item>
+    </string-array>
+    <string-array name="input_color_format_values">
+        <item>BGR</item>
+        <item>RGB</item>
+    </string-array>
+</resources>

deploy/android_demo/app/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="colorPrimary">#008577</color>
+    <color name="colorPrimaryDark">#00574B</color>
+    <color name="colorAccent">#D81B60</color>
+</resources>

deploy/android_demo/app/src/main/res/values/strings.xml

@@ -0,0 +1,26 @@
+<resources>
+    <string name="app_name">OCR Chinese</string>
+    <string name="CHOOSE_PRE_INSTALLED_MODEL_KEY">CHOOSE_PRE_INSTALLED_MODEL_KEY</string>
+    <string name="ENABLE_CUSTOM_SETTINGS_KEY">ENABLE_CUSTOM_SETTINGS_KEY</string>
+    <string name="MODEL_PATH_KEY">MODEL_PATH_KEY</string>
+    <string name="LABEL_PATH_KEY">LABEL_PATH_KEY</string>
+    <string name="IMAGE_PATH_KEY">IMAGE_PATH_KEY</string>
+    <string name="CPU_THREAD_NUM_KEY">CPU_THREAD_NUM_KEY</string>
+    <string name="CPU_POWER_MODE_KEY">CPU_POWER_MODE_KEY</string>
+    <string name="INPUT_COLOR_FORMAT_KEY">INPUT_COLOR_FORMAT_KEY</string>
+    <string name="INPUT_SHAPE_KEY">INPUT_SHAPE_KEY</string>
+    <string name="INPUT_MEAN_KEY">INPUT_MEAN_KEY</string>
+    <string name="INPUT_STD_KEY">INPUT_STD_KEY</string>
+    <string name="SCORE_THRESHOLD_KEY">SCORE_THRESHOLD_KEY</string>
+    <string name="MODEL_PATH_DEFAULT">models/ocr_v2_for_cpu</string>
+    <string name="LABEL_PATH_DEFAULT">labels/ppocr_keys_v1.txt</string>
+    <string name="IMAGE_PATH_DEFAULT">images/0.jpg</string>
+    <string name="CPU_THREAD_NUM_DEFAULT">4</string>
+    <string name="CPU_POWER_MODE_DEFAULT">LITE_POWER_HIGH</string>
+    <string name="INPUT_COLOR_FORMAT_DEFAULT">BGR</string>
+    <string name="INPUT_SHAPE_DEFAULT">1,3,960</string>
+    <string name="INPUT_MEAN_DEFAULT">0.485, 0.456, 0.406</string>
+    <string name="INPUT_STD_DEFAULT">0.229,0.224,0.225</string>
+    <string name="SCORE_THRESHOLD_DEFAULT">0.1</string>
+</resources>
+

deploy/android_demo/app/src/main/res/values/styles.xml

@@ -0,0 +1,25 @@
+<resources>
+
+    <!-- Base application theme. -->
+    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <!-- Customize your theme here. -->
+        <item name="colorPrimary">@color/colorPrimary</item>
+        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
+        <item name="colorAccent">@color/colorAccent</item>
+        <item name="actionOverflowMenuStyle">@style/OverflowMenuStyle</item>
+    </style>
+
+    <style name="OverflowMenuStyle" parent="Widget.AppCompat.Light.PopupMenu.Overflow">
+        <item name="overlapAnchor">false</item>
+    </style>
+
+    <style name="AppTheme.NoActionBar">
+        <item name="windowActionBar">false</item>
+        <item name="windowNoTitle">true</item>
+    </style>
+
+    <style name="AppTheme.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar"/>
+
+    <style name="AppTheme.PopupOverlay" parent="ThemeOverlay.AppCompat.Light"/>
+
+</resources>

deploy/android_demo/app/src/main/res/xml/file_paths.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <external-files-path name="my_images" path="Pictures" />
+</paths>

deploy/android_demo/app/src/main/res/xml/settings.xml

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" >
+    <PreferenceCategory android:title="Model Settings">
+        <ListPreference
+                android:defaultValue="@string/MODEL_PATH_DEFAULT"
+                android:key="@string/CHOOSE_PRE_INSTALLED_MODEL_KEY"
+                android:negativeButtonText="@null"
+                android:positiveButtonText="@null"
+                android:title="Choose pre-installed models" />
+        <CheckBoxPreference
+                android:defaultValue="false"
+                android:key="@string/ENABLE_CUSTOM_SETTINGS_KEY"
+                android:summaryOn="Enable"
+                android:summaryOff="Disable"
+                android:title="Enable custom settings"/>
+        <EditTextPreference
+                android:key="@string/MODEL_PATH_KEY"
+                android:defaultValue="@string/MODEL_PATH_DEFAULT"
+                android:title="Model Path" />
+        <EditTextPreference
+                android:key="@string/LABEL_PATH_KEY"
+                android:defaultValue="@string/LABEL_PATH_DEFAULT"
+                android:title="Label Path" />
+        <ListPreference
+                android:key="@string/IMAGE_PATH_KEY"
+                android:defaultValue="@string/IMAGE_PATH_DEFAULT"
+                android:entries="@array/image_name_entries"
+                android:entryValues="@array/image_name_values"
+                android:title="Image Path" />
+    </PreferenceCategory>
+    <PreferenceCategory android:title="CPU Settings">
+        <ListPreference
+                android:defaultValue="@string/CPU_THREAD_NUM_DEFAULT"
+                android:key="@string/CPU_THREAD_NUM_KEY"
+                android:negativeButtonText="@null"
+                android:positiveButtonText="@null"
+                android:title="CPU Thread Num"
+                android:entries="@array/cpu_thread_num_entries"
+                android:entryValues="@array/cpu_thread_num_values"/>
+        <ListPreference
+                android:defaultValue="@string/CPU_POWER_MODE_DEFAULT"
+                android:key="@string/CPU_POWER_MODE_KEY"
+                android:negativeButtonText="@null"
+                android:positiveButtonText="@null"
+                android:title="CPU Power Mode"
+                android:entries="@array/cpu_power_mode_entries"
+                android:entryValues="@array/cpu_power_mode_values"/>
+    </PreferenceCategory>
+    <PreferenceCategory android:title="Input Settings">
+        <ListPreference
+                android:defaultValue="@string/INPUT_COLOR_FORMAT_DEFAULT"
+                android:key="@string/INPUT_COLOR_FORMAT_KEY"
+                android:negativeButtonText="@null"
+                android:positiveButtonText="@null"
+                android:title="Input Color Format: BGR or RGB"
+                android:entries="@array/input_color_format_entries"
+                android:entryValues="@array/input_color_format_values"/>
+        <EditTextPreference
+                android:key="@string/INPUT_SHAPE_KEY"
+                android:defaultValue="@string/INPUT_SHAPE_DEFAULT"
+                android:title="Input Shape: (1,1,max_width_height) or (1,3,max_width_height)" />
+        <EditTextPreference
+                android:key="@string/INPUT_MEAN_KEY"
+                android:defaultValue="@string/INPUT_MEAN_DEFAULT"
+                android:title="Input Mean: (channel/255-mean)/std" />
+        <EditTextPreference
+                android:key="@string/INPUT_STD_KEY"
+                android:defaultValue="@string/INPUT_STD_DEFAULT"
+                android:title="Input Std: (channel/255-mean)/std" />
+    </PreferenceCategory>
+    <PreferenceCategory android:title="Output Settings">
+        <EditTextPreference
+                android:key="@string/SCORE_THRESHOLD_KEY"
+                android:defaultValue="@string/SCORE_THRESHOLD_DEFAULT"
+                android:title="Score Threshold" />
+    </PreferenceCategory>
+</PreferenceScreen>

deploy/android_demo/app/src/test/java/com/baidu/paddle/lite/demo/ocr/ExampleUnitTest.java

@@ -0,0 +1,17 @@
+package com.baidu.paddle.lite.demo.ocr;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * Example local unit test, which will execute on the development machine (host).
+ *
+ * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
+ */
+public class ExampleUnitTest {
+    @Test
+    public void addition_isCorrect() {
+        assertEquals(4, 2 + 2);
+    }
+}

deploy/android_demo/build.gradle

@@ -0,0 +1,27 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        google()
+        jcenter()
+        
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:4.1.2'
+        
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        google()
+        jcenter()
+        
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}

deploy/android_demo/gradle.properties

@@ -0,0 +1,15 @@
+# Project-wide Gradle settings.
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
+android.useAndroidX=true

deploy/android_demo/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Thu Feb 04 20:28:08 CST 2021
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-bin.zip

deploy/android_demo/gradlew

@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

deploy/android_demo/gradlew.bat

@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

deploy/android_demo/settings.gradle

@@ -0,0 +1 @@
+include ':app'

deploy/lite/Makefile

@@ -0,0 +1,80 @@
+ARM_ABI = arm8
+export ARM_ABI
+
+include ../Makefile.def
+
+LITE_ROOT=../../../
+
+THIRD_PARTY_DIR=${LITE_ROOT}/third_party
+
+OPENCV_VERSION=opencv4.1.0
+
+OPENCV_LIBS = ../../../third_party/${OPENCV_VERSION}/arm64-v8a/libs/libopencv_imgcodecs.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/libs/libopencv_imgproc.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/libs/libopencv_core.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/libtegra_hal.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/liblibjpeg-turbo.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/liblibwebp.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/liblibpng.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/liblibjasper.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/liblibtiff.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/libIlmImf.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/libtbb.a \
+              ../../../third_party/${OPENCV_VERSION}/arm64-v8a/3rdparty/libs/libcpufeatures.a
+
+OPENCV_INCLUDE = -I../../../third_party/${OPENCV_VERSION}/arm64-v8a/include
+
+CXX_INCLUDES = $(INCLUDES) ${OPENCV_INCLUDE} -I$(LITE_ROOT)/cxx/include
+
+CXX_LIBS = ${OPENCV_LIBS} -L$(LITE_ROOT)/cxx/lib/ -lpaddle_light_api_shared $(SYSTEM_LIBS)
+
+###############################################################
+# How to use one of static libaray:                           #
+#  `libpaddle_api_full_bundled.a`                             #
+#  `libpaddle_api_light_bundled.a`                            #
+###############################################################
+# Note: default use lite's shared library.                    #
+###############################################################
+# 1. Comment above line using `libpaddle_light_api_shared.so`
+# 2. Undo comment below line using `libpaddle_api_light_bundled.a`
+
+#CXX_LIBS = $(LITE_ROOT)/cxx/lib/libpaddle_api_light_bundled.a $(SYSTEM_LIBS)
+
+ocr_db_crnn: fetch_clipper fetch_opencv ocr_db_crnn.o crnn_process.o db_post_process.o clipper.o cls_process.o
+	$(CC) $(SYSROOT_LINK) $(CXXFLAGS_LINK) ocr_db_crnn.o crnn_process.o db_post_process.o clipper.o cls_process.o -o ocr_db_crnn  $(CXX_LIBS) $(LDFLAGS)
+
+ocr_db_crnn.o: ocr_db_crnn.cc
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o ocr_db_crnn.o -c ocr_db_crnn.cc
+
+crnn_process.o: fetch_opencv crnn_process.cc
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o crnn_process.o -c crnn_process.cc
+
+cls_process.o: fetch_opencv cls_process.cc
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o cls_process.o -c cls_process.cc
+
+db_post_process.o: fetch_clipper fetch_opencv db_post_process.cc
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o db_post_process.o -c db_post_process.cc
+
+clipper.o: fetch_clipper
+	$(CC) $(SYSROOT_COMPLILE) $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o clipper.o -c clipper.cpp
+
+fetch_clipper:
+	@test -e clipper.hpp || \
+        ( echo "Fetch clipper " && \
+        wget -c https://paddle-inference-dist.cdn.bcebos.com/PaddleLite/Clipper/clipper.hpp)
+	@ test -e clipper.cpp || \
+        wget -c https://paddle-inference-dist.cdn.bcebos.com/PaddleLite/Clipper/clipper.cpp
+
+fetch_opencv:
+	@ test -d ${THIRD_PARTY_DIR} ||  mkdir ${THIRD_PARTY_DIR}
+	@ test -e ${THIRD_PARTY_DIR}/${OPENCV_VERSION}.tar.gz || \
+      (echo "fetch opencv libs" && \
+      wget -P ${THIRD_PARTY_DIR} https://paddle-inference-dist.bj.bcebos.com/${OPENCV_VERSION}.tar.gz)
+	@ test -d ${THIRD_PARTY_DIR}/${OPENCV_VERSION} || \
+      tar -zxvf ${THIRD_PARTY_DIR}/${OPENCV_VERSION}.tar.gz -C ${THIRD_PARTY_DIR}
+
+
+.PHONY: clean
+clean:
+	rm -f ocr_db_crnn.o clipper.o db_post_process.o crnn_process.o cls_process.o
+	rm -f ocr_db_crnn

deploy/lite/cls_process.cc

@@ -0,0 +1,43 @@
+// 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 "cls_process.h" //NOLINT
+#include <algorithm>
+#include <memory>
+#include <string>
+
+const std::vector<int> rec_image_shape{3, 48, 192};
+
+cv::Mat ClsResizeImg(cv::Mat img) {
+  int imgC, imgH, imgW;
+  imgC = rec_image_shape[0];
+  imgH = rec_image_shape[1];
+  imgW = rec_image_shape[2];
+
+  float ratio = static_cast<float>(img.cols) / static_cast<float>(img.rows);
+
+  int resize_w, resize_h;
+  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_LINEAR);
+  if (resize_w < imgW) {
+    cv::copyMakeBorder(resize_img, resize_img, 0, 0, 0, imgW - resize_w,
+                       cv::BORDER_CONSTANT, cv::Scalar(0, 0, 0));
+  }
+  return resize_img;
+}

deploy/lite/cls_process.h

@@ -0,0 +1,29 @@
+// 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 <cstring>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "math.h" //NOLINT
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+
+cv::Mat ClsResizeImg(cv::Mat img);

deploy/lite/config.txt

@@ -0,0 +1,7 @@
+max_side_len  960
+det_db_thresh  0.3
+det_db_box_thresh  0.5
+det_db_unclip_ratio  1.6
+det_db_use_dilate 0
+det_use_polygon_score 1
+use_direction_classify  1

deploy/lite/crnn_process.cc

@@ -0,0 +1,115 @@
+// 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 "crnn_process.h" //NOLINT
+#include <algorithm>
+#include <memory>
+#include <string>
+
+const std::vector<int> rec_image_shape{3, 32, 320};
+
+cv::Mat CrnnResizeImg(cv::Mat img, float wh_ratio) {
+  int imgC, imgH, imgW;
+  imgC = rec_image_shape[0];
+  imgW = rec_image_shape[2];
+  imgH = rec_image_shape[1];
+
+  imgW = int(32 * wh_ratio);
+
+  float ratio = static_cast<float>(img.cols) / static_cast<float>(img.rows);
+  int resize_w, resize_h;
+  if (ceilf(imgH * ratio) > imgW)
+    resize_w = imgW;
+  else
+    resize_w = static_cast<int>(ceilf(imgH * ratio));
+  cv::Mat resize_img;
+  cv::resize(img, resize_img, cv::Size(resize_w, imgH), 0.f, 0.f,
+             cv::INTER_LINEAR);
+
+  return resize_img;
+}
+
+std::vector<std::string> ReadDict(std::string path) {
+  std::ifstream in(path);
+  std::string filename;
+  std::string line;
+  std::vector<std::string> m_vec;
+  if (in) {
+    while (getline(in, line)) {
+      m_vec.push_back(line);
+    }
+  } else {
+    std::cout << "no such file" << std::endl;
+  }
+  return m_vec;
+}
+
+cv::Mat GetRotateCropImage(cv::Mat srcimage,
+                           std::vector<std::vector<int>> box) {
+  cv::Mat image;
+  srcimage.copyTo(image);
+  std::vector<std::vector<int>> points = box;
+
+  int x_collect[4] = {box[0][0], box[1][0], box[2][0], box[3][0]};
+  int y_collect[4] = {box[0][1], box[1][1], box[2][1], box[3][1]};
+  int left = int(*std::min_element(x_collect, x_collect + 4));
+  int right = int(*std::max_element(x_collect, x_collect + 4));
+  int top = int(*std::min_element(y_collect, y_collect + 4));
+  int bottom = int(*std::max_element(y_collect, y_collect + 4));
+
+  cv::Mat img_crop;
+  image(cv::Rect(left, top, right - left, bottom - top)).copyTo(img_crop);
+
+  for (int i = 0; i < points.size(); i++) {
+    points[i][0] -= left;
+    points[i][1] -= top;
+  }
+
+  int img_crop_width =
+      static_cast<int>(sqrt(pow(points[0][0] - points[1][0], 2) +
+                            pow(points[0][1] - points[1][1], 2)));
+  int img_crop_height =
+      static_cast<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);
+
+  const float ratio = 1.5;
+  if (static_cast<float>(dst_img.rows) >=
+      static_cast<float>(dst_img.cols) * ratio) {
+    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;
+  } else {
+    return dst_img;
+  }
+}

deploy/lite/crnn_process.h

@@ -0,0 +1,38 @@
+// 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 <cstring>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "math.h" //NOLINT
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+
+cv::Mat CrnnResizeImg(cv::Mat img, float wh_ratio);
+
+std::vector<std::string> ReadDict(std::string path);
+
+cv::Mat GetRotateCropImage(cv::Mat srcimage, std::vector<std::vector<int>> box);
+
+template <class ForwardIterator>
+inline size_t Argmax(ForwardIterator first, ForwardIterator last) {
+  return std::distance(first, std::max_element(first, last));
+}

deploy/lite/db_post_process.cc

@@ -0,0 +1,351 @@
+// 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 "db_post_process.h" // NOLINT
+#include <algorithm>
+#include <utility>
+
+void GetContourArea(std::vector<std::vector<float>> box, float unclip_ratio,
+                    float &distance) {
+  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 Unclip(std::vector<std::vector<float>> box,
+                       float unclip_ratio) {
+  float distance = 1.0;
+
+  GetContourArea(box, unclip_ratio, distance);
+
+  ClipperLib::ClipperOffset offset;
+  ClipperLib::Path p;
+  p << ClipperLib::IntPoint(static_cast<int>(box[0][0]),
+                            static_cast<int>(box[0][1]))
+    << ClipperLib::IntPoint(static_cast<int>(box[1][0]),
+                            static_cast<int>(box[1][1]))
+    << ClipperLib::IntPoint(static_cast<int>(box[2][0]),
+                            static_cast<int>(box[2][1]))
+    << ClipperLib::IntPoint(static_cast<int>(box[3][0]),
+                            static_cast<int>(box[3][1]));
+  offset.AddPath(p, ClipperLib::jtRound, ClipperLib::etClosedPolygon);
+
+  ClipperLib::Paths soln;
+  offset.Execute(soln, distance);
+  std::vector<cv::Point2f> points;
+
+  for (int j = 0; j < soln.size(); j++) {
+    for (int i = 0; i < soln[soln.size() - 1].size(); i++) {
+      points.emplace_back(soln[j][i].X, soln[j][i].Y);
+    }
+  }
+  cv::RotatedRect res = cv::minAreaRect(points);
+
+  return res;
+}
+
+std::vector<std::vector<float>> Mat2Vector(cv::Mat mat) {
+  std::vector<std::vector<float>> img_vec;
+  std::vector<float> tmp;
+
+  for (int i = 0; i < mat.rows; ++i) {
+    tmp.clear();
+    for (int j = 0; j < mat.cols; ++j) {
+      tmp.push_back(mat.at<float>(i, j));
+    }
+    img_vec.push_back(tmp);
+  }
+  return img_vec;
+}
+
+bool XsortFp32(std::vector<float> a, std::vector<float> b) {
+  if (a[0] != b[0])
+    return a[0] < b[0];
+  return false;
+}
+
+bool XsortInt(std::vector<int> a, std::vector<int> b) {
+  if (a[0] != b[0])
+    return a[0] < b[0];
+  return false;
+}
+
+std::vector<std::vector<int>>
+OrderPointsClockwise(std::vector<std::vector<int>> pts) {
+  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>> GetMiniBoxes(cv::RotatedRect box, float &ssid) {
+  ssid = std::min(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 BoxScoreFast(std::vector<std::vector<float>> box_array, cv::Mat pred) {
+  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(
+      static_cast<int>(std::floorf(*(std::min_element(box_x, box_x + 4)))), 0,
+      width - 1);
+  int xmax =
+      clamp(static_cast<int>(std::ceilf(*(std::max_element(box_x, box_x + 4)))),
+            0, width - 1);
+  int ymin = clamp(
+      static_cast<int>(std::floorf(*(std::min_element(box_y, box_y + 4)))), 0,
+      height - 1);
+  int ymax =
+      clamp(static_cast<int>(std::ceilf(*(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(static_cast<int>(array[0][0]) - xmin,
+                            static_cast<int>(array[0][1]) - ymin);
+  root_point[1] = cv::Point(static_cast<int>(array[1][0]) - xmin,
+                            static_cast<int>(array[1][1]) - ymin);
+  root_point[2] = cv::Point(static_cast<int>(array[2][0]) - xmin,
+                            static_cast<int>(array[2][1]) - ymin);
+  root_point[3] = cv::Point(static_cast<int>(array[3][0]) - xmin,
+                            static_cast<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;
+}
+
+float PolygonScoreAcc(std::vector<cv::Point> contour, cv::Mat pred) {
+  int width = pred.cols;
+  int height = pred.rows;
+  std::vector<float> box_x;
+  std::vector<float> box_y;
+  for (int i = 0; i < contour.size(); ++i) {
+    box_x.push_back(contour[i].x);
+    box_y.push_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 (int 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;
+}
+
+std::vector<std::vector<std::vector<int>>>
+BoxesFromBitmap(const cv::Mat pred, const cv::Mat bitmap,
+                std::map<std::string, double> Config) {
+  const int min_size = 3;
+  const int max_candidates = 1000;
+  const float box_thresh = static_cast<float>(Config["det_db_box_thresh"]);
+  const float unclip_ratio = static_cast<float>(Config["det_db_unclip_ratio"]);
+  const int det_use_polygon_score = int(Config["det_use_polygon_score"]);
+
+  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++) {
+    float ssid;
+    if (contours[i].size() <= 2)
+      continue;
+
+    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_use_polygon_score) {
+      score = PolygonScoreAcc(contours[i], pred);
+    } else {
+      score = BoxScoreFast(array, pred);
+    }
+    // end box_score_fast
+    if (score < box_thresh)
+      continue;
+
+    // start for unclip
+    cv::RotatedRect points = Unclip(box_for_unclip, 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{
+          static_cast<int>(clamp(
+              roundf(cliparray[num_pt][0] / float(width) * float(dest_width)),
+              float(0), float(dest_width))),
+          static_cast<int>(clamp(
+              roundf(cliparray[num_pt][1] / float(height) * float(dest_height)),
+              float(0), float(dest_height)))};
+      intcliparray.push_back(a);
+    }
+    boxes.push_back(intcliparray);
+
+  } // end for
+  return boxes;
+}
+
+std::vector<std::vector<std::vector<int>>>
+FilterTagDetRes(std::vector<std::vector<std::vector<int>>> boxes, float ratio_h,
+                float ratio_w, cv::Mat srcimg) {
+  int oriimg_h = srcimg.rows;
+  int oriimg_w = srcimg.cols;
+
+  std::vector<std::vector<std::vector<int>>> root_points;
+  for (int n = 0; n < static_cast<int>(boxes.size()); n++) {
+    boxes[n] = OrderPointsClockwise(boxes[n]);
+    for (int m = 0; m < static_cast<int>(boxes[0].size()); m++) {
+      boxes[n][m][0] /= ratio_w;
+      boxes[n][m][1] /= ratio_h;
+
+      boxes[n][m][0] =
+          static_cast<int>(std::min(std::max(boxes[n][m][0], 0), oriimg_w - 1));
+      boxes[n][m][1] =
+          static_cast<int>(std::min(std::max(boxes[n][m][1], 0), oriimg_h - 1));
+    }
+  }
+
+  for (int n = 0; n < boxes.size(); n++) {
+    int rect_width, rect_height;
+    rect_width =
+        static_cast<int>(sqrt(pow(boxes[n][0][0] - boxes[n][1][0], 2) +
+                              pow(boxes[n][0][1] - boxes[n][1][1], 2)));
+    rect_height =
+        static_cast<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.push_back(boxes[n]);
+  }
+  return root_points;
+}

deploy/lite/db_post_process.h

@@ -0,0 +1,62 @@
+// 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 <math.h>
+
+#include <iostream>
+#include <map>
+#include <vector>
+
+#include "clipper.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/imgproc.hpp"
+
+template <class T> T clamp(T x, T min, T max) {
+  if (x > max)
+    return max;
+  if (x < min)
+    return min;
+  return x;
+}
+
+std::vector<std::vector<float>> Mat2Vector(cv::Mat mat);
+
+void GetContourArea(std::vector<std::vector<float>> box, float unclip_ratio,
+                    float &distance);
+
+cv::RotatedRect Unclip(std::vector<std::vector<float>> box, float unclip_ratio);
+
+std::vector<std::vector<float>> Mat2Vector(cv::Mat mat);
+
+bool XsortFp32(std::vector<float> a, std::vector<float> b);
+
+bool XsortInt(std::vector<int> a, std::vector<int> b);
+
+std::vector<std::vector<int>>
+OrderPointsClockwise(std::vector<std::vector<int>> pts);
+
+std::vector<std::vector<float>> GetMiniBoxes(cv::RotatedRect box, float &ssid);
+
+float BoxScoreFast(std::vector<std::vector<float>> box_array, cv::Mat pred);
+
+std::vector<std::vector<std::vector<int>>>
+BoxesFromBitmap(const cv::Mat pred, const cv::Mat bitmap,
+                std::map<std::string, double> Config);
+
+std::vector<std::vector<std::vector<int>>>
+FilterTagDetRes(std::vector<std::vector<std::vector<int>>> boxes, float ratio_h,
+                float ratio_w, cv::Mat srcimg);

deploy/lite/ocr_db_crnn.cc

@@ -0,0 +1,413 @@
+// 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 "paddle_api.h" // NOLINT
+#include <chrono>
+
+#include "cls_process.h"
+#include "crnn_process.h"
+#include "db_post_process.h"
+
+using namespace paddle::lite_api; // NOLINT
+using namespace std;
+
+// fill tensor with mean and scale and trans layout: nhwc -> nchw, neon speed up
+void NeonMeanScale(const float *din, float *dout, int size,
+                   const std::vector<float> mean,
+                   const std::vector<float> scale) {
+  if (mean.size() != 3 || scale.size() != 3) {
+    std::cerr << "[ERROR] mean or scale size must equal to 3\n";
+    exit(1);
+  }
+  float32x4_t vmean0 = vdupq_n_f32(mean[0]);
+  float32x4_t vmean1 = vdupq_n_f32(mean[1]);
+  float32x4_t vmean2 = vdupq_n_f32(mean[2]);
+  float32x4_t vscale0 = vdupq_n_f32(scale[0]);
+  float32x4_t vscale1 = vdupq_n_f32(scale[1]);
+  float32x4_t vscale2 = vdupq_n_f32(scale[2]);
+
+  float *dout_c0 = dout;
+  float *dout_c1 = dout + size;
+  float *dout_c2 = dout + size * 2;
+
+  int i = 0;
+  for (; i < size - 3; i += 4) {
+    float32x4x3_t vin3 = vld3q_f32(din);
+    float32x4_t vsub0 = vsubq_f32(vin3.val[0], vmean0);
+    float32x4_t vsub1 = vsubq_f32(vin3.val[1], vmean1);
+    float32x4_t vsub2 = vsubq_f32(vin3.val[2], vmean2);
+    float32x4_t vs0 = vmulq_f32(vsub0, vscale0);
+    float32x4_t vs1 = vmulq_f32(vsub1, vscale1);
+    float32x4_t vs2 = vmulq_f32(vsub2, vscale2);
+    vst1q_f32(dout_c0, vs0);
+    vst1q_f32(dout_c1, vs1);
+    vst1q_f32(dout_c2, vs2);
+
+    din += 12;
+    dout_c0 += 4;
+    dout_c1 += 4;
+    dout_c2 += 4;
+  }
+  for (; i < size; i++) {
+    *(dout_c0++) = (*(din++) - mean[0]) * scale[0];
+    *(dout_c1++) = (*(din++) - mean[1]) * scale[1];
+    *(dout_c2++) = (*(din++) - mean[2]) * scale[2];
+  }
+}
+
+// resize image to a size multiple of 32 which is required by the network
+cv::Mat DetResizeImg(const cv::Mat img, int max_size_len,
+                     std::vector<float> &ratio_hw) {
+  int w = img.cols;
+  int h = img.rows;
+
+  float ratio = 1.f;
+  int max_wh = w >= h ? w : h;
+  if (max_wh > max_size_len) {
+    if (h > w) {
+      ratio = static_cast<float>(max_size_len) / static_cast<float>(h);
+    } else {
+      ratio = static_cast<float>(max_size_len) / static_cast<float>(w);
+    }
+  }
+
+  int resize_h = static_cast<int>(float(h) * ratio);
+  int resize_w = static_cast<int>(float(w) * ratio);
+  if (resize_h % 32 == 0)
+    resize_h = resize_h;
+  else if (resize_h / 32 < 1 + 1e-5)
+    resize_h = 32;
+  else
+    resize_h = (resize_h / 32 - 1) * 32;
+
+  if (resize_w % 32 == 0)
+    resize_w = resize_w;
+  else if (resize_w / 32 < 1 + 1e-5)
+    resize_w = 32;
+  else
+    resize_w = (resize_w / 32 - 1) * 32;
+
+  cv::Mat resize_img;
+  cv::resize(img, resize_img, cv::Size(resize_w, resize_h));
+
+  ratio_hw.push_back(static_cast<float>(resize_h) / static_cast<float>(h));
+  ratio_hw.push_back(static_cast<float>(resize_w) / static_cast<float>(w));
+  return resize_img;
+}
+
+cv::Mat RunClsModel(cv::Mat img, std::shared_ptr<PaddlePredictor> predictor_cls,
+                    const float thresh = 0.9) {
+  std::vector<float> mean = {0.5f, 0.5f, 0.5f};
+  std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
+
+  cv::Mat srcimg;
+  img.copyTo(srcimg);
+  cv::Mat crop_img;
+  img.copyTo(crop_img);
+  cv::Mat resize_img;
+
+  int index = 0;
+  float wh_ratio =
+      static_cast<float>(crop_img.cols) / static_cast<float>(crop_img.rows);
+
+  resize_img = ClsResizeImg(crop_img);
+  resize_img.convertTo(resize_img, CV_32FC3, 1 / 255.f);
+
+  const float *dimg = reinterpret_cast<const float *>(resize_img.data);
+
+  std::unique_ptr<Tensor> input_tensor0(std::move(predictor_cls->GetInput(0)));
+  input_tensor0->Resize({1, 3, resize_img.rows, resize_img.cols});
+  auto *data0 = input_tensor0->mutable_data<float>();
+
+  NeonMeanScale(dimg, data0, resize_img.rows * resize_img.cols, mean, scale);
+  // Run CLS predictor
+  predictor_cls->Run();
+
+  // Get output and run postprocess
+  std::unique_ptr<const Tensor> softmax_out(
+      std::move(predictor_cls->GetOutput(0)));
+  auto *softmax_scores = softmax_out->mutable_data<float>();
+  auto softmax_out_shape = softmax_out->shape();
+  float score = 0;
+  int label = 0;
+  for (int i = 0; i < softmax_out_shape[1]; i++) {
+    if (softmax_scores[i] > score) {
+      score = softmax_scores[i];
+      label = i;
+    }
+  }
+  if (label % 2 == 1 && score > thresh) {
+    cv::rotate(srcimg, srcimg, 1);
+  }
+  return srcimg;
+}
+
+void RunRecModel(std::vector<std::vector<std::vector<int>>> boxes, cv::Mat img,
+                 std::shared_ptr<PaddlePredictor> predictor_crnn,
+                 std::vector<std::string> &rec_text,
+                 std::vector<float> &rec_text_score,
+                 std::vector<std::string> charactor_dict,
+                 std::shared_ptr<PaddlePredictor> predictor_cls,
+                 int use_direction_classify) {
+  std::vector<float> mean = {0.5f, 0.5f, 0.5f};
+  std::vector<float> scale = {1 / 0.5f, 1 / 0.5f, 1 / 0.5f};
+
+  cv::Mat srcimg;
+  img.copyTo(srcimg);
+  cv::Mat crop_img;
+  cv::Mat resize_img;
+
+  int index = 0;
+  for (int i = boxes.size() - 1; i >= 0; i--) {
+    crop_img = GetRotateCropImage(srcimg, boxes[i]);
+    if (use_direction_classify >= 1) {
+      crop_img = RunClsModel(crop_img, predictor_cls);
+    }
+    float wh_ratio =
+        static_cast<float>(crop_img.cols) / static_cast<float>(crop_img.rows);
+
+    resize_img = CrnnResizeImg(crop_img, wh_ratio);
+    resize_img.convertTo(resize_img, CV_32FC3, 1 / 255.f);
+
+    const float *dimg = reinterpret_cast<const float *>(resize_img.data);
+
+    std::unique_ptr<Tensor> input_tensor0(
+        std::move(predictor_crnn->GetInput(0)));
+    input_tensor0->Resize({1, 3, resize_img.rows, resize_img.cols});
+    auto *data0 = input_tensor0->mutable_data<float>();
+
+    NeonMeanScale(dimg, data0, resize_img.rows * resize_img.cols, mean, scale);
+    //// Run CRNN predictor
+    predictor_crnn->Run();
+
+    // Get output and run postprocess
+    std::unique_ptr<const Tensor> output_tensor0(
+        std::move(predictor_crnn->GetOutput(0)));
+    auto *predict_batch = output_tensor0->data<float>();
+    auto predict_shape = output_tensor0->shape();
+
+    // ctc decode
+    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++) {
+      argmax_idx = int(Argmax(&predict_batch[n * predict_shape[2]],
+                              &predict_batch[(n + 1) * predict_shape[2]]));
+      max_value =
+          float(*std::max_element(&predict_batch[n * predict_shape[2]],
+                                  &predict_batch[(n + 1) * predict_shape[2]]));
+      if (argmax_idx > 0 && (!(n > 0 && argmax_idx == last_index))) {
+        score += max_value;
+        count += 1;
+        str_res += charactor_dict[argmax_idx];
+      }
+      last_index = argmax_idx;
+    }
+    score /= count;
+    rec_text.push_back(str_res);
+    rec_text_score.push_back(score);
+  }
+}
+
+std::vector<std::vector<std::vector<int>>>
+RunDetModel(std::shared_ptr<PaddlePredictor> predictor, cv::Mat img,
+            std::map<std::string, double> Config) {
+  // Read img
+  int max_side_len = int(Config["max_side_len"]);
+  int det_db_use_dilate = int(Config["det_db_use_dilate"]);
+
+  cv::Mat srcimg;
+  img.copyTo(srcimg);
+
+  std::vector<float> ratio_hw;
+  img = DetResizeImg(img, max_side_len, ratio_hw);
+  cv::Mat img_fp;
+  img.convertTo(img_fp, CV_32FC3, 1.0 / 255.f);
+
+  // Prepare input data from image
+  std::unique_ptr<Tensor> input_tensor0(std::move(predictor->GetInput(0)));
+  input_tensor0->Resize({1, 3, img_fp.rows, img_fp.cols});
+  auto *data0 = input_tensor0->mutable_data<float>();
+
+  std::vector<float> mean = {0.485f, 0.456f, 0.406f};
+  std::vector<float> scale = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
+  const float *dimg = reinterpret_cast<const float *>(img_fp.data);
+  NeonMeanScale(dimg, data0, img_fp.rows * img_fp.cols, mean, scale);
+
+  // Run predictor
+  predictor->Run();
+
+  // Get output and post process
+  std::unique_ptr<const Tensor> output_tensor(
+      std::move(predictor->GetOutput(0)));
+  auto *outptr = output_tensor->data<float>();
+  auto shape_out = output_tensor->shape();
+
+  // Save output
+  float pred[shape_out[2] * shape_out[3]];
+  unsigned char cbuf[shape_out[2] * shape_out[3]];
+
+  for (int i = 0; i < int(shape_out[2] * shape_out[3]); i++) {
+    pred[i] = static_cast<float>(outptr[i]);
+    cbuf[i] = static_cast<unsigned char>((outptr[i]) * 255);
+  }
+
+  cv::Mat cbuf_map(shape_out[2], shape_out[3], CV_8UC1,
+                   reinterpret_cast<unsigned char *>(cbuf));
+  cv::Mat pred_map(shape_out[2], shape_out[3], CV_32F,
+                   reinterpret_cast<float *>(pred));
+
+  const double threshold = double(Config["det_db_thresh"]) * 255;
+  const double max_value = 255;
+  cv::Mat bit_map;
+  cv::threshold(cbuf_map, bit_map, threshold, max_value, cv::THRESH_BINARY);
+  if (det_db_use_dilate == 1) {
+    cv::Mat dilation_map;
+    cv::Mat dila_ele =
+        cv::getStructuringElement(cv::MORPH_RECT, cv::Size(2, 2));
+    cv::dilate(bit_map, dilation_map, dila_ele);
+    bit_map = dilation_map;
+  }
+  auto boxes = BoxesFromBitmap(pred_map, bit_map, Config);
+
+  std::vector<std::vector<std::vector<int>>> filter_boxes =
+      FilterTagDetRes(boxes, ratio_hw[0], ratio_hw[1], srcimg);
+
+  return filter_boxes;
+}
+
+std::shared_ptr<PaddlePredictor> loadModel(std::string model_file) {
+  MobileConfig config;
+  config.set_model_from_file(model_file);
+
+  std::shared_ptr<PaddlePredictor> predictor =
+      CreatePaddlePredictor<MobileConfig>(config);
+  return predictor;
+}
+
+cv::Mat Visualization(cv::Mat srcimg,
+                      std::vector<std::vector<std::vector<int>>> boxes) {
+  cv::Point rook_points[boxes.size()][4];
+  for (int n = 0; n < boxes.size(); n++) {
+    for (int m = 0; m < boxes[0].size(); m++) {
+      rook_points[n][m] = cv::Point(static_cast<int>(boxes[n][m][0]),
+                                    static_cast<int>(boxes[n][m][1]));
+    }
+  }
+  cv::Mat img_vis;
+  srcimg.copyTo(img_vis);
+  for (int n = 0; n < boxes.size(); n++) {
+    const cv::Point *ppt[1] = {rook_points[n]};
+    int npt[] = {4};
+    cv::polylines(img_vis, ppt, npt, 1, 1, CV_RGB(0, 255, 0), 2, 8, 0);
+  }
+
+  cv::imwrite("./vis.jpg", img_vis);
+  std::cout << "The detection visualized image saved in ./vis.jpg" << std::endl;
+  return img_vis;
+}
+
+std::vector<std::string> split(const std::string &str,
+                               const std::string &delim) {
+  std::vector<std::string> res;
+  if ("" == str)
+    return res;
+  char *strs = new char[str.length() + 1];
+  std::strcpy(strs, str.c_str());
+
+  char *d = new char[delim.length() + 1];
+  std::strcpy(d, delim.c_str());
+
+  char *p = std::strtok(strs, d);
+  while (p) {
+    string s = p;
+    res.push_back(s);
+    p = std::strtok(NULL, d);
+  }
+
+  return res;
+}
+
+std::map<std::string, double> LoadConfigTxt(std::string config_path) {
+  auto config = ReadDict(config_path);
+
+  std::map<std::string, double> dict;
+  for (int i = 0; i < config.size(); i++) {
+    std::vector<std::string> res = split(config[i], " ");
+    dict[res[0]] = stod(res[1]);
+  }
+  return dict;
+}
+
+int main(int argc, char **argv) {
+  if (argc < 5) {
+    std::cerr << "[ERROR] usage: " << argv[0]
+              << " det_model_file cls_model_file rec_model_file image_path "
+                 "charactor_dict\n";
+    exit(1);
+  }
+  std::string det_model_file = argv[1];
+  std::string rec_model_file = argv[2];
+  std::string cls_model_file = argv[3];
+  std::string img_path = argv[4];
+  std::string dict_path = argv[5];
+
+  //// load config from txt file
+  auto Config = LoadConfigTxt("./config.txt");
+  int use_direction_classify = int(Config["use_direction_classify"]);
+
+  auto start = std::chrono::system_clock::now();
+
+  auto det_predictor = loadModel(det_model_file);
+  auto rec_predictor = loadModel(rec_model_file);
+  auto cls_predictor = loadModel(cls_model_file);
+
+  auto charactor_dict = ReadDict(dict_path);
+  charactor_dict.insert(charactor_dict.begin(), "#"); // blank char for ctc
+  charactor_dict.push_back(" ");
+
+  cv::Mat srcimg = cv::imread(img_path, cv::IMREAD_COLOR);
+  auto boxes = RunDetModel(det_predictor, srcimg, Config);
+
+  std::vector<std::string> rec_text;
+  std::vector<float> rec_text_score;
+
+  RunRecModel(boxes, srcimg, rec_predictor, rec_text, rec_text_score,
+              charactor_dict, cls_predictor, use_direction_classify);
+
+  auto end = std::chrono::system_clock::now();
+  auto duration =
+      std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+
+  //// visualization
+  auto img_vis = Visualization(srcimg, boxes);
+
+  //// print recognized text
+  for (int i = 0; i < rec_text.size(); i++) {
+    std::cout << i << "\t" << rec_text[i] << "\t" << rec_text_score[i]
+              << std::endl;
+  }
+
+  std::cout << "花费了"
+            << double(duration.count()) *
+                   std::chrono::microseconds::period::num /
+                   std::chrono::microseconds::period::den
+            << "秒" << std::endl;
+
+  return 0;
+}

deploy/lite/prepare.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+mkdir -p  $1/demo/cxx/ocr/debug/
+cp  ../../ppocr/utils/ppocr_keys_v1.txt  $1/demo/cxx/ocr/debug/
+cp -r  ./*   $1/demo/cxx/ocr/
+cp ./config.txt  $1/demo/cxx/ocr/debug/
+cp ../../doc/imgs/11.jpg  $1/demo/cxx/ocr/debug/
+
+echo "Prepare Done"

deploy/lite/readme.md

@@ -0,0 +1,276 @@
+# 端侧部署
+
+本教程将介绍基于[Paddle Lite](https://github.com/PaddlePaddle/Paddle-Lite) 在移动端部署PaddleOCR超轻量中文检测、识别模型的详细步骤。
+
+Paddle Lite是飞桨轻量化推理引擎，为手机、IOT端提供高效推理能力，并广泛整合跨平台硬件，为端侧部署及应用落地问题提供轻量化的部署方案。
+
+
+## 1. 准备环境
+
+### 运行准备
+- 电脑（编译Paddle Lite）
+- 安卓手机（armv7或armv8）
+
+### 1.1 准备交叉编译环境
+交叉编译环境用于编译 Paddle Lite 和 PaddleOCR 的C++ demo。
+支持多种开发环境，不同开发环境的编译流程请参考对应文档。
+
+1. [Docker](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#docker)
+2. [Linux](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#linux)
+3. [MAC OS](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#mac-os)
+
+### 1.2 准备预测库
+
+预测库有两种获取方式：
+- 1. 直接下载，预测库下载链接如下：
+
+      | 平台 | 预测库下载链接 |
+      |---|---|
+      |Android|[arm7](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.android.armv7.gcc.c++_shared.with_extra.with_cv.tar.gz) / [arm8](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.android.armv8.gcc.c++_shared.with_extra.with_cv.tar.gz)|
+      |IOS|[arm7](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.ios.armv7.with_cv.with_extra.with_log.tiny_publish.tar.gz) / [arm8](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.ios.armv8.with_cv.with_extra.with_log.tiny_publish.tar.gz)|
+
+      注：1. 上述预测库为PaddleLite 2.9分支编译得到，有关PaddleLite 2.9 详细信息可参考 [链接](https://github.com/PaddlePaddle/Paddle-Lite/releases/tag/v2.9) 。
+
+- 2. [推荐]编译Paddle-Lite得到预测库，Paddle-Lite的编译方式如下：
+```
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+# 切换到Paddle-Lite release/v2.9 稳定分支
+git checkout release/v2.9
+./lite/tools/build_android.sh  --arch=armv8  --with_cv=ON --with_extra=ON
+```
+
+注意：编译Paddle-Lite获得预测库时，需要打开`--with_cv=ON --with_extra=ON`两个选项，`--arch`表示`arm`版本，这里指定为armv8，
+更多编译命令
+介绍请参考 [链接](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_andriod.html) 。
+
+直接下载预测库并解压后，可以得到`inference_lite_lib.android.armv8/`文件夹，通过编译Paddle-Lite得到的预测库位于
+`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/`文件夹下。
+预测库的文件目录如下：
+```
+inference_lite_lib.android.armv8/
+|-- cxx                                        C++ 预测库和头文件
+|   |-- include                                C++ 头文件
+|   |   |-- paddle_api.h
+|   |   |-- paddle_image_preprocess.h
+|   |   |-- paddle_lite_factory_helper.h
+|   |   |-- paddle_place.h
+|   |   |-- paddle_use_kernels.h
+|   |   |-- paddle_use_ops.h
+|   |   `-- paddle_use_passes.h
+|   `-- lib                                           C++预测库
+|       |-- libpaddle_api_light_bundled.a             C++静态库
+|       `-- libpaddle_light_api_shared.so             C++动态库
+|-- java                                     Java预测库
+|   |-- jar
+|   |   `-- PaddlePredictor.jar
+|   |-- so
+|   |   `-- libpaddle_lite_jni.so
+|   `-- src
+|-- demo                                     C++和Java示例代码
+|   |-- cxx                                  C++  预测库demo
+|   `-- java                                 Java 预测库demo
+```
+
+## 2 开始运行
+
+### 2.1 模型优化
+
+Paddle-Lite 提供了多种策略来自动优化原始的模型，其中包括量化、子图融合、混合调度、Kernel优选等方法，使用Paddle-lite的opt工具可以自动
+对inference模型进行优化，优化后的模型更轻量，模型运行速度更快。
+
+如果已经准备好了 `.nb` 结尾的模型文件，可以跳过此步骤。
+
+下述表格中也提供了一系列中文移动端模型：
+
+|模型版本|模型简介|模型大小|检测模型|文本方向分类模型|识别模型|Paddle-Lite版本|
+|---|---|---|---|---|---|---|
+|V2.0|超轻量中文OCR 移动端模型|7.8M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_opt.nb)|v2.9|
+|V2.0(slim)|超轻量中文OCR 移动端模型|3.3M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_slim_opt.nb)|v2.9|
+
+如果直接使用上述表格中的模型进行部署，可略过下述步骤，直接阅读 [2.2节](#2.2与手机联调)。
+
+如果要部署的模型不在上述表格中，则需要按照如下步骤获得优化后的模型。
+
+模型优化需要Paddle-Lite的opt可执行文件，可以通过编译Paddle-Lite源码获得，编译步骤如下：
+```
+# 如果准备环境时已经clone了Paddle-Lite，则不用重新clone Paddle-Lite
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+git checkout release/v2.9
+# 启动编译
+./lite/tools/build.sh build_optimize_tool
+```
+
+编译完成后，opt文件位于`build.opt/lite/api/`下，可通过如下方式查看opt的运行选项和使用方式；
+```
+cd build.opt/lite/api/
+./opt
+```
+
+|选项|说明|
+|---|---|
+|--model_dir|待优化的PaddlePaddle模型（非combined形式）的路径|
+|--model_file|待优化的PaddlePaddle模型（combined形式）的网络结构文件路径|
+|--param_file|待优化的PaddlePaddle模型（combined形式）的权重文件路径|
+|--optimize_out_type|输出模型类型，目前支持两种类型：protobuf和naive_buffer，其中naive_buffer是一种更轻量级的序列化/反序列化实现。若您需要在mobile端执行模型预测，请将此选项设置为naive_buffer。默认为protobuf|
+|--optimize_out|优化模型的输出路径|
+|--valid_targets|指定模型可执行的backend，默认为arm。目前可支持x86、arm、opencl、npu、xpu，可以同时指定多个backend(以空格分隔)，Model Optimize Tool将会自动选择最佳方式。如果需要支持华为NPU（Kirin 810/990 Soc搭载的达芬奇架构NPU），应当设置为npu, arm|
+|--record_tailoring_info|当使用 根据模型裁剪库文件 功能时，则设置该选项为true，以记录优化后模型含有的kernel和OP信息，默认为false|
+
+`--model_dir`适用于待优化的模型是非combined方式，PaddleOCR的inference模型是combined方式，即模型结构和模型参数使用单独一个文件存储。
+
+下面以PaddleOCR的超轻量中文模型为例，介绍使用编译好的opt文件完成inference模型到Paddle-Lite优化模型的转换。
+
+```
+# 【推荐】 下载PaddleOCR V2.0版本的中英文 inference模型
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_det_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_det_slim_infer.tar
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_rec_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_rec_slim_infer.tar
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_cls_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_cls_slim_infer.tar
+# 转换V2.0检测模型
+./opt --model_file=./ch_ppocr_mobile_v2.0_det_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_det_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_det_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+# 转换V2.0识别模型
+./opt --model_file=./ch_ppocr_mobile_v2.0_rec_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_rec_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_rec_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+# 转换V2.0方向分类器模型
+./opt --model_file=./ch_ppocr_mobile_v2.0_cls_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_cls_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_cls_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+
+```
+
+转换成功后，inference模型目录下会多出`.nb`结尾的文件，即是转换成功的模型文件。
+
+注意：使用paddle-lite部署时，需要使用opt工具优化后的模型。 opt 工具的输入模型是paddle保存的inference模型
+
+<a name="2.2与手机联调"></a>
+### 2.2 与手机联调
+
+首先需要进行一些准备工作。
+ 1. 准备一台arm8的安卓手机，如果编译的预测库和opt文件是armv7，则需要arm7的手机，并修改Makefile中`ARM_ABI = arm7`。
+ 2. 打开手机的USB调试选项，选择文件传输模式，连接电脑。
+ 3. 电脑上安装adb工具，用于调试。 adb安装方式如下：
+
+    3.1. MAC电脑安装ADB:
+    ```
+    brew cask install android-platform-tools
+    ```
+    3.2. Linux安装ADB
+    ```
+    sudo apt update
+    sudo apt install -y wget adb
+    ```
+    3.3. Window安装ADB
+
+    win上安装需要去谷歌的安卓平台下载adb软件包进行安装：[链接](https://developer.android.com/studio)
+
+    打开终端，手机连接电脑，在终端中输入
+    ```
+    adb devices
+    ```
+    如果有device输出，则表示安装成功。
+    ```
+       List of devices attached
+       744be294    device
+    ```
+
+ 4. 准备优化后的模型、预测库文件、测试图像和使用的字典文件。
+ ```
+ git clone https://github.com/PaddlePaddle/PaddleOCR.git
+ cd PaddleOCR/deploy/lite/
+ # 运行prepare.sh，准备预测库文件、测试图像和使用的字典文件，并放置在预测库中的demo/cxx/ocr文件夹下
+ sh prepare.sh /{lite prediction library path}/inference_lite_lib.android.armv8
+
+ # 进入OCR demo的工作目录
+ cd /{lite prediction library path}/inference_lite_lib.android.armv8/
+ cd demo/cxx/ocr/
+ # 将C++预测动态库so文件复制到debug文件夹中
+ cp ../../../cxx/lib/libpaddle_light_api_shared.so ./debug/
+ ```
+
+ 准备测试图像，以`PaddleOCR/doc/imgs/11.jpg`为例，将测试的图像复制到`demo/cxx/ocr/debug/`文件夹下。
+ 准备lite opt工具优化后的模型文件，比如使用`ch_ppocr_mobile_v2.0_det_slim_opt.nb，ch_ppocr_mobile_v2.0_rec_slim_opt.nb, ch_ppocr_mobile_v2.0_cls_slim_opt.nb`，模型文件放置在`demo/cxx/ocr/debug/`文件夹下。
+
+ 执行完成后，ocr文件夹下将有如下文件格式：
+
+```
+demo/cxx/ocr/
+|-- debug/  
+|   |--ch_ppocr_mobile_v2.0_det_slim_opt.nb           优化后的检测模型文件
+|   |--ch_ppocr_mobile_v2.0_rec_slim_opt.nb           优化后的识别模型文件
+|   |--ch_ppocr_mobile_v2.0_cls_slim_opt.nb           优化后的文字方向分类器模型文件
+|   |--11.jpg                           待测试图像
+|   |--ppocr_keys_v1.txt                中文字典文件
+|   |--libpaddle_light_api_shared.so    C++预测库文件
+|   |--config.txt                       超参数配置
+|-- config.txt                  超参数配置
+|-- cls_process.cc              方向分类器的预处理和后处理文件
+|-- cls_process.h
+|-- crnn_process.cc             识别模型CRNN的预处理和后处理文件
+|-- crnn_process.h
+|-- db_post_process.cc          检测模型DB的后处理文件
+|-- db_post_process.h
+|-- Makefile                    编译文件
+|-- ocr_db_crnn.cc              C++预测源文件
+```
+
+#### 注意：
+1. ppocr_keys_v1.txt是中文字典文件，如果使用的 nb 模型是英文数字或其他语言的模型，需要更换为对应语言的字典。
+PaddleOCR 在ppocr/utils/下存放了多种字典，包括：
+```
+dict/french_dict.txt     # 法语字典
+dict/german_dict.txt     # 德语字典
+ic15_dict.txt       # 英文字典
+dict/japan_dict.txt      # 日语字典
+dict/korean_dict.txt     # 韩语字典
+ppocr_keys_v1.txt   # 中文字典
+...
+```
+
+2.  `config.txt` 包含了检测器、分类器的超参数，如下：
+```
+max_side_len  960         # 输入图像长宽大于960时，等比例缩放图像，使得图像最长边为960
+det_db_thresh  0.3        # 用于过滤DB预测的二值化图像，设置为0.-0.3对结果影响不明显
+det_db_box_thresh  0.5    # DB后处理过滤box的阈值，如果检测存在漏框情况，可酌情减小
+det_db_unclip_ratio  1.6  # 表示文本框的紧致程度，越小则文本框更靠近文本
+use_direction_classify  0  # 是否使用方向分类器，0表示不使用，1表示使用
+```
+
+ 5. 启动调试
+
+ 上述步骤完成后就可以使用adb将文件push到手机上运行，步骤如下：
+
+ ```
+ # 执行编译，得到可执行文件ocr_db_crnn, 第一次执行此命令会下载opencv等依赖库，下载完成后，需要再执行一次
+ make -j
+
+ # 将编译的可执行文件移动到debug文件夹中
+ mv ocr_db_crnn ./debug/
+ # 将debug文件夹push到手机上
+ adb push debug /data/local/tmp/
+ adb shell
+ cd /data/local/tmp/debug
+ export LD_LIBRARY_PATH=${PWD}:$LD_LIBRARY_PATH
+ # 开始使用，ocr_db_crnn可执行文件的使用方式为:
+ # ./ocr_db_crnn  检测模型文件 方向分类器模型文件  识别模型文件  测试图像路径  字典文件路径
+ ./ocr_db_crnn ch_ppocr_mobile_v2.0_det_slim_opt.nb  ch_ppocr_mobile_v2.0_rec_slim_opt.nb  ch_ppocr_mobile_v2.0_cls_slim_opt.nb  ./11.jpg  ppocr_keys_v1.txt
+ ```
+
+ 如果对代码做了修改，则需要重新编译并push到手机上。
+
+ 运行效果如下：
+
+<div align="center">
+    <img src="imgs/lite_demo.png" width="600">
+</div>
+
+
+## FAQ
+Q1：如果想更换模型怎么办，需要重新按照流程走一遍吗？
+
+A1：如果已经走通了上述步骤，更换模型只需要替换 .nb 模型文件即可，同时要注意更新字典
+
+Q2：换一个图测试怎么做？
+
+A2：替换debug下的.jpg测试图像为你想要测试的图像，adb push 到手机上即可
+
+Q3：如何封装到手机APP中？
+
+A3：此demo旨在提供能在手机上运行OCR的核心算法部分，PaddleOCR/deploy/android_demo是将这个demo封装到手机app的示例，供参考

deploy/lite/readme_en.md

@@ -0,0 +1,275 @@
+# Tutorial of PaddleOCR Mobile deployment
+
+This tutorial will introduce how to use [Paddle Lite](https://github.com/PaddlePaddle/Paddle-Lite) to deploy paddleOCR ultra-lightweight Chinese and English detection models on mobile phones.
+
+paddle-lite is a lightweight inference engine for PaddlePaddle. It provides efficient inference capabilities for mobile phones and IoTs, and extensively integrates cross-platform hardware to provide lightweight deployment solutions for end-side deployment issues.
+
+## 1. Preparation
+
+### 运行准备
+
+- Computer (for Compiling Paddle Lite)
+- Mobile phone (arm7 or arm8)
+
+### 1.1 Prepare the cross-compilation environment
+The cross-compilation environment is used to compile C++ demos of Paddle Lite and PaddleOCR.
+Supports multiple development environments.
+
+For the compilation process of different development environments, please refer to the corresponding documents.
+
+1. [Docker](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#docker)
+2. [Linux](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#linux)
+3. [MAC OS](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_env.html#mac-os)
+
+### 1.2 Prepare Paddle-Lite library
+
+There are two ways to obtain the Paddle-Lite library：
+- 1. Download directly, the download link of the Paddle-Lite library is as follows：
+
+      | Platform | Paddle-Lite library download link |
+      |---|---|
+      |Android|[arm7](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.android.armv7.gcc.c++_shared.with_extra.with_cv.tar.gz) / [arm8](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.android.armv8.gcc.c++_shared.with_extra.with_cv.tar.gz)|
+      |IOS|[arm7](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.ios.armv7.with_cv.with_extra.with_log.tiny_publish.tar.gz) / [arm8](https://github.com/PaddlePaddle/Paddle-Lite/releases/download/v2.9/inference_lite_lib.ios.armv8.with_cv.with_extra.with_log.tiny_publish.tar.gz)|
+
+      Note: 1. The above Paddle-Lite library is compiled from the Paddle-Lite 2.9 branch. For more information about Paddle-Lite 2.9, please refer to [link](https://github.com/PaddlePaddle/Paddle-Lite/releases/tag/v2.9).
+
+- 2. [Recommended] Compile Paddle-Lite to get the prediction library. The compilation method of Paddle-Lite is as follows：
+```
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+# Switch to Paddle-Lite release/v2.8 stable branch
+git checkout release/v2.8
+./lite/tools/build_android.sh  --arch=armv8  --with_cv=ON --with_extra=ON
+```
+
+Note: When compiling Paddle-Lite to obtain the Paddle-Lite library, you need to turn on the two options `--with_cv=ON --with_extra=ON`, `--arch` means the `arm` version, here is designated as armv8,
+
+More compilation commands refer to the introduction [link](https://paddle-lite.readthedocs.io/zh/latest/source_compile/compile_andriod.html) 。
+
+After directly downloading the Paddle-Lite library and decompressing it, you can get the `inference_lite_lib.android.armv8/` folder, and the Paddle-Lite library obtained by compiling Paddle-Lite is located
+`Paddle-Lite/build.lite.android.armv8.gcc/inference_lite_lib.android.armv8/` folder.
+
+The structure of the prediction library is as follows:
+```
+inference_lite_lib.android.armv8/
+|-- cxx                                        C++ prebuild library
+|   |-- include                                C++
+|   |   |-- paddle_api.h
+|   |   |-- paddle_image_preprocess.h
+|   |   |-- paddle_lite_factory_helper.h
+|   |   |-- paddle_place.h
+|   |   |-- paddle_use_kernels.h
+|   |   |-- paddle_use_ops.h
+|   |   `-- paddle_use_passes.h
+|   `-- lib                                           C++ library
+|       |-- libpaddle_api_light_bundled.a             C++ static library
+|       `-- libpaddle_light_api_shared.so             C++ dynamic library
+|-- java                                     Java library
+|   |-- jar
+|   |   `-- PaddlePredictor.jar
+|   |-- so
+|   |   `-- libpaddle_lite_jni.so
+|   `-- src
+|-- demo                                     C++ and Java demo
+|   |-- cxx                                  C++ demo
+|   `-- java                                 Java demo
+```
+
+## 2 Run
+
+### 2.1 Inference Model Optimization
+
+Paddle Lite provides a variety of strategies to automatically optimize the original training model, including quantization, sub-graph fusion, hybrid scheduling, Kernel optimization and so on. In order to make the optimization process more convenient and easy to use, Paddle Lite provide opt tools to automatically complete the optimization steps and output a lightweight, optimal executable model.
+
+If you have prepared the model file ending in .nb, you can skip this step.
+
+The following table also provides a series of models that can be deployed on mobile phones to recognize Chinese. You can directly download the optimized model.
+
+|Version|Introduction|Model size|Detection model|Text Direction model|Recognition model|Paddle-Lite branch|
+|---|---|---|---|---|---|---|
+|V2.0|extra-lightweight chinese OCR optimized model|7.8M|[download link](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_opt.nb)|[download lin](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_opt.nb)|[download lin](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_opt.nb)|v2.9|
+|V2.0(slim)|extra-lightweight chinese OCR optimized model|3.3M|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_det_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_cls_slim_opt.nb)|[下载地址](https://paddleocr.bj.bcebos.com/dygraph_v2.0/lite/ch_ppocr_mobile_v2.0_rec_slim_opt.nb)|v2.9|
+
+If you directly use the model in the above table for deployment, you can skip the following steps and directly read [Section 2.2](#2.2 Run optimized model on Phone).
+
+If the model to be deployed is not in the above table, you need to follow the steps below to obtain the optimized model.
+
+The `opt` tool can be obtained by compiling Paddle Lite.
+```
+git clone https://github.com/PaddlePaddle/Paddle-Lite.git
+cd Paddle-Lite
+git checkout release/v2.9
+./lite/tools/build.sh build_optimize_tool
+```
+
+After the compilation is complete, the opt file is located under build.opt/lite/api/, You can view the operating options and usage of opt in the following ways:
+
+```
+cd build.opt/lite/api/
+./opt
+```
+
+|Options|Description|
+|---|---|
+|--model_dir|The path of the PaddlePaddle model to be optimized (non-combined form)|
+|--model_file|The network structure file path of the PaddlePaddle model (combined form) to be optimized|
+|--param_file|The weight file path of the PaddlePaddle model (combined form) to be optimized|
+|--optimize_out_type|Output model type, currently supports two types: protobuf and naive_buffer, among which naive_buffer is a more lightweight serialization/deserialization implementation. If you need to perform model prediction on the mobile side, please set this option to naive_buffer. The default is protobuf|
+|--optimize_out|The output path of the optimized model|
+|--valid_targets|The executable backend of the model, the default is arm. Currently it supports x86, arm, opencl, npu, xpu, multiple backends can be specified at the same time (separated by spaces), and Model Optimize Tool will automatically select the best method. If you need to support Huawei NPU (DaVinci architecture NPU equipped with Kirin 810/990 Soc), it should be set to npu, arm|
+|--record_tailoring_info|When using the function of cutting library files according to the model, set this option to true to record the kernel and OP information contained in the optimized model. The default is false|
+
+`--model_dir` is suitable for the non-combined mode of the model to be optimized, and the inference model of PaddleOCR is the combined mode, that is, the model structure and model parameters are stored in a single file.
+
+The following takes the ultra-lightweight Chinese model of PaddleOCR as an example to introduce the use of the compiled opt file to complete the conversion of the inference model to the Paddle-Lite optimized model
+
+```
+# [Recommendation] Download the Chinese and English inference model of PaddleOCR V2.0
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_det_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_det_slim_infer.tar
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_rec_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_rec_slim_infer.tar
+wget  https://paddleocr.bj.bcebos.com/dygraph_v2.0/slim/ch_ppocr_mobile_v2.0_cls_slim_infer.tar && tar xf  ch_ppocr_mobile_v2.0_cls_slim_infer.tar
+# Convert V2.0 detection model
+./opt --model_file=./ch_ppocr_mobile_v2.0_det_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_det_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_det_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+# Convert V2.0 recognition model
+./opt --model_file=./ch_ppocr_mobile_v2.0_rec_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_rec_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_rec_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+# Convert V2.0 angle classifier model
+./opt --model_file=./ch_ppocr_mobile_v2.0_cls_slim_infer/inference.pdmodel  --param_file=./ch_ppocr_mobile_v2.0_cls_slim_infer/inference.pdiparams  --optimize_out=./ch_ppocr_mobile_v2.0_cls_slim_opt --valid_targets=arm  --optimize_out_type=naive_buffer
+
+```
+
+After the conversion is successful, there will be more files ending with `.nb` in the inference model directory, which is the successfully converted model file.
+
+<a name="2.2 Run optimized model on Phone"></a>
+### 2.2 Run optimized model on Phone
+
+Some preparatory work is required first.
+ 1. Prepare an Android phone with arm8. If the compiled prediction library and opt file are armv7, you need an arm7 phone and modify ARM_ABI = arm7 in the Makefile.
+ 2. Make sure the phone is connected to the computer, open the USB debugging option of the phone, and select the file transfer mode.
+ 3. Install the adb tool on the computer.
+
+    3.1. Install ADB for MAC:
+    ```
+    brew cask install android-platform-tools
+    ```
+    3.2. Install ADB for Linux
+    ```
+    sudo apt update
+    sudo apt install -y wget adb
+    ```
+    3.3. Install ADB for windows
+
+    To install on win, you need to go to Google's Android platform to download the adb package for installation：[link](https://developer.android.com/studio)
+
+    Verify whether adb is installed successfully
+     ```
+    adb devices
+    ```
+    If there is device output, it means the installation is successful。
+    ```
+       List of devices attached
+       744be294    device
+    ```
+
+ 4. Prepare optimized models, prediction library files, test images and dictionary files used.
+ ```
+ git clone https://github.com/PaddlePaddle/PaddleOCR.git
+ cd PaddleOCR/deploy/lite/
+ # run prepare.sh
+ sh prepare.sh /{lite prediction library path}/inference_lite_lib.android.armv8
+
+ #
+ cd /{lite prediction library path}/inference_lite_lib.android.armv8/
+ cd demo/cxx/ocr/
+ # copy paddle-lite C++ .so file to debug/ directory
+ cp ../../../cxx/lib/libpaddle_light_api_shared.so ./debug/
+
+ cd inference_lite_lib.android.armv8/demo/cxx/ocr/
+ cp ../../../cxx/lib/libpaddle_light_api_shared.so ./debug/
+ ```
+
+Prepare the test image, taking PaddleOCR/doc/imgs/11.jpg as an example, copy the image file to the demo/cxx/ocr/debug/ folder. Prepare the model files optimized by the lite opt tool, ch_det_mv3_db_opt.nb, ch_rec_mv3_crnn_opt.nb, and place them under the demo/cxx/ocr/debug/ folder.
+
+The structure of the OCR demo is as follows after the above command is executed:
+
+```
+demo/cxx/ocr/
+|-- debug/  
+|   |--ch_ppocr_mobile_v2.0_det_slim_opt.nb           Detection model
+|   |--ch_ppocr_mobile_v2.0_rec_slim_opt.nb           Recognition model
+|   |--ch_ppocr_mobile_v2.0_cls_slim_opt.nb           Text direction classification model
+|   |--11.jpg                           Image for OCR
+|   |--ppocr_keys_v1.txt                Dictionary file
+|   |--libpaddle_light_api_shared.so    C++ .so file
+|   |--config.txt                       Config file
+|-- config.txt                  Config file
+|-- cls_process.cc              Pre-processing and post-processing files for the angle classifier
+|-- cls_process.h
+|-- crnn_process.cc             Pre-processing and post-processing files for the CRNN model
+|-- crnn_process.h
+|-- db_post_process.cc          Pre-processing and post-processing files for the DB model
+|-- db_post_process.h
+|-- Makefile  
+|-- ocr_db_crnn.cc              C++ main code
+```
+
+#### 注意：
+1. `ppocr_keys_v1.txt` is a Chinese dictionary file. If the nb model is used for English recognition or other language recognition, dictionary file should be replaced with a dictionary of the corresponding language. PaddleOCR provides a variety of dictionaries under ppocr/utils/, including:
+```
+dict/french_dict.txt     # french
+dict/german_dict.txt     # german
+ic15_dict.txt       # english
+dict/japan_dict.txt      # japan
+dict/korean_dict.txt     # korean
+ppocr_keys_v1.txt   # chinese
+```
+
+2.  `config.txt` of the detector and classifier, as shown below:
+```
+max_side_len  960         #  Limit the maximum image height and width to 960
+det_db_thresh  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  0.5    # DDB post-processing filter box threshold, if there is a missing box detected, it can be reduced as appropriate
+det_db_unclip_ratio  1.6  # Indicates the compactness of the text box, the smaller the value, the closer the text box to the text
+use_direction_classify  0  # Whether to use the direction classifier, 0 means not to use, 1 means to use
+```
+
+ 5. Run Model on phone
+
+After the above steps are completed, you can use adb to push the file to the phone to run, the steps are as follows:
+
+ ```
+ # Execute the compilation and get the executable file ocr_db_crnn
+ # The first execution of this command will download dependent libraries such as opencv. After the download is complete, you need to execute it again
+ make -j
+ # Move the compiled executable file to the debug folder
+ mv ocr_db_crnn ./debug/
+ # Push the debug folder to the phone
+ adb push debug /data/local/tmp/
+ adb shell
+ cd /data/local/tmp/debug
+ export LD_LIBRARY_PATH=${PWD}:$LD_LIBRARY_PATH
+ # The use of ocr_db_crnn is:
+ # ./ocr_db_crnn Detection model file Orientation classifier model file Recognition model file Test image path Dictionary file path
+ ./ocr_db_crnn ch_ppocr_mobile_v2.0_det_opt.nb  ch_ppocr_mobile_v2.0_rec_opt.nb  ch_ppocr_mobile_v2.0_cls_opt.nb  ./11.jpg  ppocr_keys_v1.txt
+ ```
+
+If you modify the code, you need to recompile and push to the phone.
+
+The outputs are as follows:
+
+<div align="center">
+    <img src="imgs/lite_demo.png" width="600">
+</div>
+
+## FAQ
+
+Q1: What if I want to change the model, do I need to run it again according to the process?
+
+A1: If you have performed the above steps, you only need to replace the .nb model file to complete the model replacement.
+
+Q2: How to test with another picture?
+
+A2: Replace the .jpg test image under ./debug with the image you want to test, and run adb push to push new image to the phone.
+
+Q3: How to package it into the mobile APP?
+
+A3: This demo aims to provide the core algorithm part that can run OCR on mobile phones. Further, PaddleOCR/deploy/android_demo is an example of encapsulating this demo into a mobile app for reference.

deploy/pdserving/README.md

@@ -30,38 +30,32 @@ The introduction and tutorial of Paddle Serving service deployment framework ref
 PaddleOCR operating environment and Paddle Serving operating environment are needed.
 
 1. Please prepare PaddleOCR operating environment reference [link](../../doc/doc_ch/installation.md).
+   Download the corresponding paddle whl package according to the environment, it is recommended to install version 2.0.1.
+
 
 2. The steps of PaddleServing operating environment prepare are as follows:
 
     Install serving which used to start the service
     ```
-    pip3 install paddle-serving-server==0.5.0 # for CPU
-    pip3 install paddle-serving-server-gpu==0.5.0 # for GPU
+    pip3 install paddle-serving-server==0.6.1 # for CPU
+    pip3 install paddle-serving-server-gpu==0.6.1 # for GPU
     # Other GPU environments need to confirm the environment and then choose to execute the following commands
-    pip3 install paddle-serving-server-gpu==0.5.0.post9 # GPU with CUDA9.0
-    pip3 install paddle-serving-server-gpu==0.5.0.post10 # GPU with CUDA10.0
-    pip3 install paddle-serving-server-gpu==0.5.0.post101 # GPU with CUDA10.1 + TensorRT6
-    pip3 install paddle-serving-server-gpu==0.5.0.post11 # GPU with CUDA10.1 + TensorRT7
+    pip3 install paddle-serving-server-gpu==0.6.1.post101 # GPU with CUDA10.1 + TensorRT6
+    pip3 install paddle-serving-server-gpu==0.6.1.post11 # GPU with CUDA11 + TensorRT7
     ```
 
 3. Install the client to send requests to the service
-    ```
-    pip3 install paddle-serving-client==0.5.0 # for CPU
+    In [download link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md) find the client installation package corresponding to the python version.
+    The python3.7 version is recommended here:
 
-    pip3 install paddle-serving-client-gpu==0.5.0 # for GPU
+    ```
+    wget https://paddle-serving.bj.bcebos.com/test-dev/whl/paddle_serving_client-0.0.0-cp37-none-any.whl
+    pip3 install paddle_serving_client-0.0.0-cp37-none-any.whl
     ```
 
 4. Install serving-app
     ```
-    pip3 install paddle-serving-app==0.3.0
-    # fix local_predict to support load dynamic model
-    # find the install directoory of paddle_serving_app
-    vim /usr/local/lib/python3.7/site-packages/paddle_serving_app/local_predict.py
-    # replace line 85 of local_predict.py config = AnalysisConfig(model_path) with:
-    if os.path.exists(os.path.join(model_path, "__params__")):
-        config = AnalysisConfig(os.path.join(model_path, "__model__"), os.path.join(model_path, "__params__"))
-    else:
-        config = AnalysisConfig(model_path)
+    pip3 install paddle-serving-app==0.6.1
     ```
 
    **note:** If you want to install the latest version of PaddleServing, refer to [link](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md).
@@ -74,38 +68,38 @@ When using PaddleServing for service deployment, you need to convert the saved i
 Firstly, download the [inference model](https://github.com/PaddlePaddle/PaddleOCR#pp-ocr-20-series-model-listupdate-on-dec-15) of PPOCR
 ```
 # Download and unzip the OCR text detection model
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_infer.tar && tar xf ch_ppocr_server_v2.0_det_infer.tar
+wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar && tar xf ch_ppocr_mobile_v2.0_det_infer.tar
 # Download and unzip the OCR text recognition model
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_infer.tar && tar xf ch_ppocr_server_v2.0_rec_infer.tar
+wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar && tar xf ch_ppocr_mobile_v2.0_rec_infer.tar
 
 ```
-Then, you can use installed paddle_serving_client tool to convert inference model to server model.
+Then, you can use installed paddle_serving_client tool to convert inference model to mobile model.
 ```
 #  Detection model conversion
-python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_server_v2.0_det_infer/ \
+python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_mobile_v2.0_det_infer/ \
                                          --model_filename inference.pdmodel          \
                                          --params_filename inference.pdiparams       \
-                                         --serving_server ./ppocr_det_server_2.0_serving/ \
-                                         --serving_client ./ppocr_det_server_2.0_client/
+                                         --serving_server ./ppocr_det_mobile_2.0_serving/ \
+                                         --serving_client ./ppocr_det_mobile_2.0_client/
 
 #  Recognition model conversion
-python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_server_v2.0_rec_infer/ \
+python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_mobile_v2.0_rec_infer/ \
                                          --model_filename inference.pdmodel          \
                                          --params_filename inference.pdiparams       \
-                                         --serving_server ./ppocr_rec_server_2.0_serving/  \
-                                         --serving_client ./ppocr_rec_server_2.0_client/
+                                         --serving_server ./ppocr_rec_mobile_2.0_serving/  \
+                                         --serving_client ./ppocr_rec_mobile_2.0_client/
 
 ```
 
-After the detection model is converted, there will be additional folders of `ppocr_det_server_2.0_serving` and `ppocr_det_server_2.0_client` in the current folder, with the following format:
+After the detection model is converted, there will be additional folders of `ppocr_det_mobile_2.0_serving` and `ppocr_det_mobile_2.0_client` in the current folder, with the following format:
 ```
-|- ppocr_det_server_2.0_serving/
+|- ppocr_det_mobile_2.0_serving/
    |- __model__
    |- __params__
    |- serving_server_conf.prototxt
    |- serving_server_conf.stream.prototxt
 
-|- ppocr_det_server_2.0_client
+|- ppocr_det_mobile_2.0_client
    |- serving_client_conf.prototxt
    |- serving_client_conf.stream.prototxt
 
@@ -147,6 +141,89 @@ The recognition model is the same.
     After successfully running, the predicted result of the model will be printed in the cmd window. An example of the result is:
     ![](./imgs/results.png)  
 
+    Adjust the number of concurrency in config.yml to get the largest QPS. Generally, the number of concurrent detection and recognition is 2:1
+
+    ```
+    det:
+        concurrency: 8
+        ...
+    rec:
+        concurrency: 4
+        ...
+    ```
+
+    Multiple service requests can be sent at the same time if necessary.
+
+    The predicted performance data will be automatically written into the `PipelineServingLogs/pipeline.tracer` file.
+
+    Tested on 200 real pictures, and limited the detection long side to 960. The average QPS on T4 GPU can reach around 23:
+
+    ```
+
+    2021-05-13 03:42:36,895 ==================== TRACER ======================
+    2021-05-13 03:42:36,975 Op(rec):
+    2021-05-13 03:42:36,976         in[14.472382882882883 ms]
+    2021-05-13 03:42:36,976         prep[9.556855855855856 ms]
+    2021-05-13 03:42:36,976         midp[59.921905405405404 ms]
+    2021-05-13 03:42:36,976         postp[15.345945945945946 ms]
+    2021-05-13 03:42:36,976         out[1.9921216216216215 ms]
+    2021-05-13 03:42:36,976         idle[0.16254943864471572]
+    2021-05-13 03:42:36,976 Op(det):
+    2021-05-13 03:42:36,976         in[315.4468035714286 ms]
+    2021-05-13 03:42:36,976         prep[69.5980625 ms]
+    2021-05-13 03:42:36,976         midp[18.989535714285715 ms]
+    2021-05-13 03:42:36,976         postp[18.857803571428573 ms]
+    2021-05-13 03:42:36,977         out[3.1337544642857145 ms]
+    2021-05-13 03:42:36,977         idle[0.7477961159203756]
+    2021-05-13 03:42:36,977 DAGExecutor:
+    2021-05-13 03:42:36,977         Query count[224]
+    2021-05-13 03:42:36,977         QPS[22.4 q/s]
+    2021-05-13 03:42:36,977         Succ[0.9910714285714286]
+    2021-05-13 03:42:36,977         Error req[169, 170]
+    2021-05-13 03:42:36,977         Latency:
+    2021-05-13 03:42:36,977                 ave[535.1678348214285 ms]
+    2021-05-13 03:42:36,977                 .50[172.651 ms]
+    2021-05-13 03:42:36,977                 .60[187.904 ms]
+    2021-05-13 03:42:36,977                 .70[245.675 ms]
+    2021-05-13 03:42:36,977                 .80[526.684 ms]
+    2021-05-13 03:42:36,977                 .90[854.596 ms]
+    2021-05-13 03:42:36,977                 .95[1722.728 ms]
+    2021-05-13 03:42:36,977                 .99[3990.292 ms]
+    2021-05-13 03:42:36,978 Channel (server worker num[10]):
+    2021-05-13 03:42:36,978         chl0(In: ['@DAGExecutor'], Out: ['det']) size[0/0]
+    2021-05-13 03:42:36,979         chl1(In: ['det'], Out: ['rec']) size[6/0]
+    2021-05-13 03:42:36,979         chl2(In: ['rec'], Out: ['@DAGExecutor']) size[0/0]
+    ```
+
+## WINDOWS Users
+
+Windows does not support Pipeline Serving, if we want to lauch paddle serving on Windows, we should use Web Service, for more infomation please refer to [Paddle Serving for Windows Users](https://github.com/PaddlePaddle/Serving/blob/develop/doc/WINDOWS_TUTORIAL.md)
+
+
+**WINDOWS user can only use version 0.5.0 CPU Mode**
+
+**Prepare Stage:**
+
+```
+pip3 install paddle-serving-server==0.5.0
+pip3 install paddle-serving-app==0.3.1
+```
+
+1. Start Server
+
+```
+cd win
+python3 ocr_web_server.py gpu(for gpu user)
+or
+python3 ocr_web_server.py cpu(for cpu user)
+```
+
+2. Client Send Requests
+
+```
+python3 ocr_web_client.py
+```
+
 <a name="faq"></a>
 ## FAQ
 **Q1**: No result return after sending the request.

deploy/pdserving/README_CN.md

@@ -29,41 +29,31 @@ PaddleOCR提供2种服务部署方式：
 
 需要准备PaddleOCR的运行环境和Paddle Serving的运行环境。
 
-- 准备PaddleOCR的运行环境参考[链接](../../doc/doc_ch/installation.md)
+- 准备PaddleOCR的运行环境[链接](../../doc/doc_ch/installation.md)
+  根据环境下载对应的paddle whl包，推荐安装2.0.1版本
 
 - 准备PaddleServing的运行环境，步骤如下
 
 1. 安装serving，用于启动服务
     ```
-    pip3 install paddle-serving-server==0.5.0 # for CPU
-    pip3 install paddle-serving-server-gpu==0.5.0 # for GPU
+    pip3 install paddle-serving-server==0.6.1 # for CPU
+    pip3 install paddle-serving-server-gpu==0.6.1 # for GPU
     # 其他GPU环境需要确认环境再选择执行如下命令
-    pip3 install paddle-serving-server-gpu==0.5.0.post9 # GPU with CUDA9.0
-    pip3 install paddle-serving-server-gpu==0.5.0.post10 # GPU with CUDA10.0
-    pip3 install paddle-serving-server-gpu==0.5.0.post101 # GPU with CUDA10.1 + TensorRT6
-    pip3 install paddle-serving-server-gpu==0.5.0.post11 # GPU with CUDA10.1 + TensorRT7
+    pip3 install paddle-serving-server-gpu==0.6.1.post101 # GPU with CUDA10.1 + TensorRT6
+    pip3 install paddle-serving-server-gpu==0.6.1.post11 # GPU with CUDA11 + TensorRT7
     ```
 
 2. 安装client，用于向服务发送请求
-    ```
-    pip3 install paddle-serving-client==0.5.0  # for CPU
+    在[下载链接](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md)中找到对应python版本的client安装包，这里推荐python3.7版本：
 
-    pip3 install paddle-serving-client-gpu==0.5.0   # for GPU
+    ```
+    wget https://paddle-serving.bj.bcebos.com/test-dev/whl/paddle_serving_client-0.0.0-cp37-none-any.whl
+    pip3 install paddle_serving_client-0.0.0-cp37-none-any.whl
     ```
 
 3. 安装serving-app
     ```
-    pip3 install paddle-serving-app==0.3.0
-    ```
-    **note:**  安装0.3.0版本的serving-app后，为了能加载动态图模型，需要修改serving_app的源码，具体为：
-    ```
-    # 找到paddle_serving_app的安装目录，找到并编辑local_predict.py文件
-    vim /usr/local/lib/python3.7/site-packages/paddle_serving_app/local_predict.py
-    # 将local_predict.py 的第85行 config = AnalysisConfig(model_path)  替换为：
-    if os.path.exists(os.path.join(model_path, "__params__")):
-        config = AnalysisConfig(os.path.join(model_path, "__model__"), os.path.join(model_path, "__params__"))
-    else:
-        config = AnalysisConfig(model_path)
+    pip3 install paddle-serving-app==0.6.1
     ```
 
     **Note:** 如果要安装最新版本的PaddleServing参考[链接](https://github.com/PaddlePaddle/Serving/blob/develop/doc/LATEST_PACKAGES.md)。
@@ -76,38 +66,38 @@ PaddleOCR提供2种服务部署方式：
 首先，下载PPOCR的[inference模型](https://github.com/PaddlePaddle/PaddleOCR#pp-ocr-20-series-model-listupdate-on-dec-15)
 ```
 # 下载并解压 OCR 文本检测模型
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_det_infer.tar && tar xf ch_ppocr_server_v2.0_det_infer.tar
+wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_det_infer.tar && tar xf ch_ppocr_mobile_v2.0_det_infer.tar
 # 下载并解压 OCR 文本识别模型
-wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_server_v2.0_rec_infer.tar && tar xf ch_ppocr_server_v2.0_rec_infer.tar
+wget https://paddleocr.bj.bcebos.com/dygraph_v2.0/ch/ch_ppocr_mobile_v2.0_rec_infer.tar && tar xf ch_ppocr_mobile_v2.0_rec_infer.tar
 ```
 
 接下来，用安装的paddle_serving_client把下载的inference模型转换成易于server部署的模型格式。
 
 ```
 # 转换检测模型
-python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_server_v2.0_det_infer/ \
+python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_mobile_v2.0_det_infer/ \
                                          --model_filename inference.pdmodel          \
                                          --params_filename inference.pdiparams       \
-                                         --serving_server ./ppocr_det_server_2.0_serving/ \
-                                         --serving_client ./ppocr_det_server_2.0_client/
+                                         --serving_server ./ppocr_det_mobile_2.0_serving/ \
+                                         --serving_client ./ppocr_det_mobile_2.0_client/
 
 # 转换识别模型
-python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_server_v2.0_rec_infer/ \
+python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_mobile_v2.0_rec_infer/ \
                                          --model_filename inference.pdmodel          \
                                          --params_filename inference.pdiparams       \
-                                         --serving_server ./ppocr_rec_server_2.0_serving/  \
-                                         --serving_client ./ppocr_rec_server_2.0_client/
+                                         --serving_server ./ppocr_rec_mobile_2.0_serving/  \
+                                         --serving_client ./ppocr_rec_mobile_2.0_client/
 ```
 
-检测模型转换完成后，会在当前文件夹多出`ppocr_det_server_2.0_serving` 和`ppocr_det_server_2.0_client`的文件夹，具备如下格式：
+检测模型转换完成后，会在当前文件夹多出`ppocr_det_mobile_2.0_serving` 和`ppocr_det_mobile_2.0_client`的文件夹，具备如下格式：
 ```
-|- ppocr_det_server_2.0_serving/
+|- ppocr_det_mobile_2.0_serving/
   |- __model__  
   |- __params__
   |- serving_server_conf.prototxt  
   |- serving_server_conf.stream.prototxt
 
-|- ppocr_det_server_2.0_client
+|- ppocr_det_mobile_2.0_client
   |- serving_client_conf.prototxt  
   |- serving_client_conf.stream.prototxt
 
@@ -148,6 +138,86 @@ python3 -m paddle_serving_client.convert --dirname ./ch_ppocr_server_v2.0_rec_in
     成功运行后，模型预测的结果会打印在cmd窗口中，结果示例为：
     ![](./imgs/results.png)
 
+    调整 config.yml 中的并发个数获得最大的QPS, 一般检测和识别的并发数为2：1
+    ```
+    det:
+        #并发数，is_thread_op=True时，为线程并发；否则为进程并发
+        concurrency: 8
+        ...
+    rec:
+        #并发数，is_thread_op=True时，为线程并发；否则为进程并发
+        concurrency: 4
+        ...
+    ```
+    有需要的话可以同时发送多个服务请求
+
+    预测性能数据会被自动写入 `PipelineServingLogs/pipeline.tracer` 文件中。
+
+    在200张真实图片上测试，把检测长边限制为960。T4 GPU 上 QPS 均值可达到23左右：
+
+    ```
+    2021-05-13 03:42:36,895 ==================== TRACER ======================
+    2021-05-13 03:42:36,975 Op(rec):
+    2021-05-13 03:42:36,976         in[14.472382882882883 ms]
+    2021-05-13 03:42:36,976         prep[9.556855855855856 ms]
+    2021-05-13 03:42:36,976         midp[59.921905405405404 ms]
+    2021-05-13 03:42:36,976         postp[15.345945945945946 ms]
+    2021-05-13 03:42:36,976         out[1.9921216216216215 ms]
+    2021-05-13 03:42:36,976         idle[0.16254943864471572]
+    2021-05-13 03:42:36,976 Op(det):
+    2021-05-13 03:42:36,976         in[315.4468035714286 ms]
+    2021-05-13 03:42:36,976         prep[69.5980625 ms]
+    2021-05-13 03:42:36,976         midp[18.989535714285715 ms]
+    2021-05-13 03:42:36,976         postp[18.857803571428573 ms]
+    2021-05-13 03:42:36,977         out[3.1337544642857145 ms]
+    2021-05-13 03:42:36,977         idle[0.7477961159203756]
+    2021-05-13 03:42:36,977 DAGExecutor:
+    2021-05-13 03:42:36,977         Query count[224]
+    2021-05-13 03:42:36,977         QPS[22.4 q/s]
+    2021-05-13 03:42:36,977         Succ[0.9910714285714286]
+    2021-05-13 03:42:36,977         Error req[169, 170]
+    2021-05-13 03:42:36,977         Latency:
+    2021-05-13 03:42:36,977                 ave[535.1678348214285 ms]
+    2021-05-13 03:42:36,977                 .50[172.651 ms]
+    2021-05-13 03:42:36,977                 .60[187.904 ms]
+    2021-05-13 03:42:36,977                 .70[245.675 ms]
+    2021-05-13 03:42:36,977                 .80[526.684 ms]
+    2021-05-13 03:42:36,977                 .90[854.596 ms]
+    2021-05-13 03:42:36,977                 .95[1722.728 ms]
+    2021-05-13 03:42:36,977                 .99[3990.292 ms]
+    2021-05-13 03:42:36,978 Channel (server worker num[10]):
+    2021-05-13 03:42:36,978         chl0(In: ['@DAGExecutor'], Out: ['det']) size[0/0]
+    2021-05-13 03:42:36,979         chl1(In: ['det'], Out: ['rec']) size[6/0]
+    2021-05-13 03:42:36,979         chl2(In: ['rec'], Out: ['@DAGExecutor']) size[0/0]
+    ```
+
+## WINDOWS用户
+
+Windows用户不能使用上述的启动方式，需要使用Web Service，详情参见[Windows平台使用Paddle Serving指导](https://github.com/PaddlePaddle/Serving/blob/develop/doc/WINDOWS_TUTORIAL_CN.md)
+
+**WINDOWS只能使用0.5.0版本的CPU模式**
+
+准备阶段：
+```
+pip3 install paddle-serving-server==0.5.0
+pip3 install paddle-serving-app==0.3.1
+```
+
+1. 启动服务端程序
+
+```
+cd win 
+python3 ocr_web_server.py gpu(使用gpu方式)
+或者
+python3 ocr_web_server.py cpu(使用cpu方式)
+```
+
+2. 发送服务请求
+
+```
+python3 ocr_web_client.py
+```
+
 
 <a name="FAQ"></a>
 ## FAQ