devbox
空白诗007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于PaddleOCR文字识别Android端打包成aar包_paddleocr android

作者：空白诗007 | 2024-06-30 03:57:22

赞

踩

paddleocr android

目的

官方其实已经提供了详细的端侧部署，如果按照官方步骤无法正常编译的，可在评论区留言，我将详细编译步骤也发布出来，在这里我主要讲一下如何将官方的提供的代码转成可方便移植的module包，便于方便引入各个项目中。

官方2.5编译教程：PaddleOCR/readme.md at release/2.5 · PaddlePaddle/PaddleOCR (github.com)

开始！！！

官方包结构对比module包结构，可以发现后面结构清晰明了

   

1、首先将官方包下所有文件拷贝到新建的Module包下

2、删除以下文件

    

 3、新建单例模式启动OCRPredictor类和接口OnImagePredictorListener类，代码如下：

  1. package com.yangy.ocr;
  2.  
  3. import android.annotation.SuppressLint;
  4. import android.content.Context;
  5. import android.graphics.Bitmap;
  6. import android.graphics.BitmapFactory;
  7. import android.media.ExifInterface;
  8. import android.os.Binder;
  9. import android.os.Build;
  10. import android.os.Bundle;
  11. import android.os.Handler;
  12. import android.os.HandlerThread;
  13. import android.os.Message;
  14. import android.text.TextUtils;
  15. import android.util.Base64;
  16. import android.util.Log;
  17.  
  18. import java.io.IOException;
  19.  
  20. public class OCRPredictor {
  21.     public final int REQUEST_LOAD_MODEL = 0;
  22.     public final int REQUEST_RUN_MODEL = 1;
  23.     public final int RESPONSE_LOAD_MODEL_SUCCESSED = 0;
  24.     public final int RESPONSE_LOAD_MODEL_FAILED = 1;
  25.     public final int RESPONSE_RUN_MODEL_SUCCESSED = 2;
  26.     public final int RESPONSE_RUN_MODEL_FAILED = 3;
  27.     public final int RESPONSE_RUN_MODEL_NO_FILE = 4;
  28.  
  29. //    private final String assetModelDirPath = "models/bank";
  30. //    private final String assetlabelFilePath = "labels/ppocr_keys_bank.txt";
  31.     private final String assetModelDirPath = "models/ocr";
  32.     private final String assetlabelFilePath = "labels/ppocr_keys_v1.txt";
  33.  
  34.     protected Handler sender = null; // Send command to worker thread
  35.     protected HandlerThread worker = null; // Worker thread to load&run model
  36.     protected volatile Predictor predictor = null;
  37.  
  38.     private OnImagePredictorListener listener;
  39.     @SuppressLint("StaticFieldLeak")
  40.     private static OCRPredictor ocrPredictor;
  41.     private Context context;
  42.  
  43.     public static OCRPredictor getInstance(Context context) {
  44.         if (ocrPredictor == null) {
  45.             ocrPredictor = new OCRPredictor(context);
  46.         }
  47.         return ocrPredictor;
  48.     }
  49.  
  50.  
  51.     public OCRPredictor(Context context) {
  52.         this.context = context;
  53.         init();
  54.     }
  55.  
  56.     /**
  57.      *
  58.      */
  59.     private void init() {
  60.         worker = new HandlerThread("Predictor Worker");
  61.         worker.start();
  62.         sender = new Handler(worker.getLooper()) {
  63.             public void handleMessage(Message msg) {
  64.                 switch (msg.what) {
  65.                     case REQUEST_LOAD_MODEL:
  66.                         // Load model and reload test image
  67.                         if (!onLoadModel(context)) {
  68.                             predictor = null;
  69.                             Log.d("OCR", "加载模型失败！");
  70.                         } else {
  71.                             Log.d("OCR", "加载模型成功！");
  72.                         }
  73.                         break;
  74.                     case REQUEST_RUN_MODEL:
  75.                         Bundle bundle = msg.getData();
  76.                         if (predictor == null) {
  77.                             receiver.sendEmptyMessage(RESPONSE_LOAD_MODEL_FAILED);
  78.                         } else {
  79.                             // Run model if model is loaded
  80.                             if (!TextUtils.isEmpty(bundle.getString("imagePath"))) {
  81.                                 if (!onRunModel(bundle.getString("imagePath"))) {
  82.                                     receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_FAILED);
  83.                                 } else {
  84.                                     receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_SUCCESSED);
  85.                                 }
  86.                             } else {
  87.                                 ImageBinder imageBinder = (ImageBinder) bundle.getBinder("bitmap");
  88.                                 if (imageBinder != null) {
  89.                                     Bitmap bitmap = imageBinder.getBitmap();
  90.                                     if (!onRunModel(bitmap)) {
  91.                                         receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_FAILED);
  92.                                     } else {
  93.                                         receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_SUCCESSED);
  94.                                     }
  95.                                 } else {
  96.                                     StringBinder stringBinder = (StringBinder) bundle.getBinder("base64");
  97.                                     if (stringBinder != null) {
  98.                                         String str = stringBinder.getStr();
  99.                                         if (!onRunModelBase64(str)) {
  100.                                             receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_FAILED);
  101.                                         } else {
  102.                                             receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_SUCCESSED);
  103.                                         }
  104.                                     } else {
  105.                                         receiver.sendEmptyMessage(RESPONSE_RUN_MODEL_NO_FILE);
  106.                                     }
  107.                                 }
  108.  
  109.                             }
  110.                         }
  111.                         break;
  112.                 }
  113.             }
  114.         };
  115.         sender.sendEmptyMessage(REQUEST_LOAD_MODEL);
  116.     }
  117.  
  118.     private Handler receiver = new Handler() {
  119.         @Override
  120.         public void handleMessage(Message msg) {
  121.             switch (msg.what) {
  122. //                case RESPONSE_LOAD_MODEL_SUCCESSED:
  123. //                    sender.sendEmptyMessage(REQUEST_RUN_MODEL);
  124. //                    break;
  125.                 case RESPONSE_LOAD_MODEL_FAILED:
  126.                     listener.failure(0, "加载模型失败！");
  127.                     break;
  128.                 case RESPONSE_RUN_MODEL_SUCCESSED:
  129.                     listener.success(predictor.outputResult, predictor.outputResultList, predictor.outputImage);
  130.                     break;
  131.                 case RESPONSE_RUN_MODEL_FAILED:
  132.                     listener.failure(1, "运行模型失败！");
  133.                     break;
  134.                 case RESPONSE_RUN_MODEL_NO_FILE:
  135.                     listener.failure(2, "运行模型失败，请传入待识别图片！");
  136.                     break;
  137.                 default:
  138.                     break;
  139.             }
  140.         }
  141.     };
  142.  
  143.     public void predictor(final String imagePath, final OnImagePredictorListener listener) {
  144.         this.listener = listener;
  145.  
  146.         Message message = new Message();
  147.         message.what = REQUEST_RUN_MODEL;
  148.         Bundle bundle = new Bundle();
  149.         bundle.putString("imagePath", imagePath);
  150.         message.setData(bundle);
  151.  
  152.         sender.sendMessage(message);
  153.     }
  154.  
  155.     public void predictorBitMap(final Bitmap bitmap, final OnImagePredictorListener listener) {
  156.         this.listener = listener;
  157.  
  158.         Message message = new Message();
  159.         message.what = REQUEST_RUN_MODEL;
  160.         Bundle bundle = new Bundle();
  161.         bundle.putBinder("bitmap", new ImageBinder(bitmap));
  162.         message.setData(bundle);
  163.  
  164.         sender.sendMessage(message);
  165.     }
  166.  
  167.     public void predictorBase64(final String base64, final OnImagePredictorListener listener) {
  168.         this.listener = listener;
  169.  
  170.         Message message = new Message();
  171.         message.what = REQUEST_RUN_MODEL;
  172.         Bundle bundle = new Bundle();
  173.         bundle.putBinder("base64", new StringBinder(base64));
  174.         message.setData(bundle);
  175.  
  176.         sender.sendMessage(message);
  177.     }
  178.  
  179.  
  180.     private static class ImageBinder extends Binder {
  181.         private Bitmap bitmap;
  182.  
  183.         public ImageBinder(Bitmap bitmap) {
  184.             this.bitmap = bitmap;
  185.         }
  186.  
  187.         Bitmap getBitmap() {
  188.             return bitmap;
  189.         }
  190.     }
  191.  
  192.  
  193.     private static class StringBinder extends Binder {
  194.         private String str;
  195.  
  196.         public StringBinder(String str) {
  197.             this.str = str;
  198.         }
  199.  
  200.         String getStr() {
  201.             return str;
  202.         }
  203.     }
  204.  
  205.  
  206.     /**
  207.      * call in onCreate, model init
  208.      *
  209.      * @return
  210.      */
  211.     private boolean onLoadModel(Context context) {
  212.         if (predictor == null) {
  213.             predictor = new Predictor();
  214.         }
  215.         return predictor.init(context, assetModelDirPath, assetlabelFilePath);
  216.     }
  217.  
  218.     private boolean onRunModel(String imagePath) {
  219.         try {
  220.             ExifInterface exif = null;
  221.             exif = new ExifInterface(imagePath);
  222.             int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
  223.                     ExifInterface.ORIENTATION_UNDEFINED);
  224.             Log.i("OCR", "rotation " + orientation);
  225.             Bitmap image = BitmapFactory.decodeFile(imagePath);
  226.             image = Utils.rotateBitmap(image, orientation);
  227.  
  228.             predictor.setInputImage(image);
  229.             return predictor.isLoaded() && predictor.runModel();
  230.         } catch (IOException e) {
  231.             e.printStackTrace();
  232.             return false;
  233.         }
  234.     }
  235.  
  236.     private boolean onRunModel(Bitmap image) {
  237.         try {
  238.             predictor.setInputImage(image);
  239.             return predictor.isLoaded() && predictor.runModel();
  240.         } catch (Exception e) {
  241.             e.printStackTrace();
  242.             return false;
  243.         }
  244.     }
  245.  
  246.     private boolean onRunModelBase64(String base64) {
  247.         try {
  248.             byte[] bitmapByte = Base64.decode(base64, Base64.DEFAULT);
  249.             Bitmap bitmap = BitmapFactory.decodeByteArray(bitmapByte, 0, bitmapByte.length);
  250.             predictor.setInputImage(bitmap);
  251.             return predictor.isLoaded() && predictor.runModel();
  252.         } catch (Exception e) {
  253.             e.printStackTrace();
  254.             return false;
  255.         }
  256.     }
  257.  
  258.     /**
  259.      * 卸载模型
  260.      */
  261.     private void onUnloadModel() {
  262.         if (predictor != null) {
  263.             predictor.releaseModel();
  264.             predictor = null;
  265.         }
  266.     }
  267.  
  268.     /**
  269.      * 退出线程
  270.      */
  271.     private void quit() {
  272.         if (worker != null) {
  273.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
  274.                 worker.quitSafely();
  275.             } else {
  276.                 worker.quit();
  277.             }
  278.         }
  279.     }
  280.  
  281.     /**
  282.      * 销毁
  283.      */
  284.     public void onDestroy() {
  285.         onUnloadModel();
  286.         quit();
  287.         ocrPredictor = null;
  288.     }
  289.  
  290. }
  1. package com.yangy.ocr;
  2.  
  3. import android.graphics.Bitmap;
  4.  
  5. import java.util.ArrayList;
  6.  
  7. public abstract class OnImagePredictorListener {
  8.     public abstract void success(String result, ArrayList<OCRResultModel> list, Bitmap bitmap);
  9.  
  10.     public void failure(int code, String message) {
  11.     }
  12. }

4、修改Predictor类，加入以下两行

 

 5、修改native.cpp文件，将官方的_com_baidu_paddle_lite_demo_ocr_替换成我们自己的包名，如_com_yangy_ocr_，如下截图：

 6、最后一步，删除Module包下build.gradle中下载PaddleLite、OpenCV包的代码，红框部分全部删除，我们不需要 ，PaddleLite和模型包需要自行编译

 7、使用方式，在主App下引入该Module包，短短几行代码就可实现

完毕！！！

这里发布一个自己打的包，引入aar包后，使用如上面最后一图：

1、minSdkVersion 21

2、支持arm64-v8a和armabi-v7a

下载地址

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/空白诗007/article/detail/771295
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号