init commit

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

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

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

+//
+// Created by fu on 4/25/18.
+//
+
+#pragma once
+#import <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

+//
+// 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_use_opencl, 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.use_opencl = j_use_opencl;
+  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.c_str());
+  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, jobject original_image,jint j_max_size_len, jint j_run_det, jint j_run_cls, jint j_run_rec) {
+  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);
+  }
+
+  int max_size_len = j_max_size_len;
+  int run_det = j_run_det;
+  int run_cls = j_run_cls;
+  int run_rec = j_run_rec;
+
+  ppredictor::OCR_PPredictor *ppredictor =
+      (ppredictor::OCR_PPredictor *)java_pointer;
+  std::vector<int64_t> dims_arr;
+  std::vector<ppredictor::OCRPredictResult> results =
+      ppredictor->infer_ocr(origin, max_size_len, run_det, run_cls, run_rec);
+  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);
+    // add det point
+    for (const std::vector<int> &point : r.points) {
+      float_arr.push_back(point.at(0));
+      float_arr.push_back(point.at(1));
+    }
+    // add rec word idx
+    for (int index : r.word_index) {
+      float_arr.push_back(index);
+    }
+    // add cls result
+    float_arr.push_back(r.cls_label);
+    float_arr.push_back(r.cls_score);
+  }
+  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

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