活动专区 活动发布区 【MediaTek X20开发板试用体...  

【MediaTek X20开发板试用体验】小区车牌自动识别系统项目结贴  

    最新回复
分享到：

xble
 xble
Level 1
注册时间:8年 前
帖子数: 15
2017年3月14日 上午9:35  
本帖最后由 xble 于 2017-3-14 09:34 编辑

一）项目概述
  汽车已经成为很多人生活中的必需品，成为人们的代步工具，随之也引发了很多管理问题。车牌作为汽车的唯一身份证，其重要性不言而喻，车牌自动识别需求应运而生，它相对人工管理有很大优点：1.可以不间断的连续工作；2.准确、自动、长时间的保存车牌信息。当然也有很多缺点：1，识别成功率不高；2.位置固定，不如人工灵活。
  希望可以通过这个项目让我学习到一下知识：1）MTK X20开发平台相关知识；2）学习USB Camera模块相关知识；3）学习Opencv的概念和车牌识别的原理，流程。应用到的技术主要有C/C++编程，Android开发，
  Opencv跨平台计算机视觉库，人工智能的相关知识，当然由于水平和时间限制我这里只是简单接触一下，在前人的基础大概了解其大概原理和实现过程。
二）硬件设计
  1.X20开发板
  2.USB Camera
  3.HDMI转接线，DIV显示器，USB鼠标，USB下载线。
三）软件调试
1）USB Camera模块加载和抓取车牌图片
  由于USB Camera模块无法固定，导致抓取图片的质量非常差，所以没有实时解析Camera拍摄图形，而是保存成图片后在进行识别。其实现参考前面的帖子，连接为： http://bbs.elecfans.com/forum.ph ... &tid=1108917&extra=
2）车牌识别原理，过程
        车牌识别原理与我们前面的实现过的简化版字符数字识别全过程原理一致，只是需要添加许多额外的步骤来提高识别准确度。参考连接： http://bbs.elecfans.com/forum.ph ... &tid=1112867&extra=
        我们将车牌识别实现分为两步：1）SVM训练数据准备；2）车牌定位，识别。从一定意义上来说SVM数据训练也是车牌定位识别的过程，只是我们会人工干预，确保这个过程的正确性。
        车牌定位主要处理步骤：1）高斯模糊Sobel算子，闭操作；2）处理图形旋转角度；3）对比SVM数据初步判断图块是否是车牌。
        字符识别主要处理步骤：1）字符分割（阀值操作，取轮廓）；2）通过ANN模型进行字符识别。        
        如果想要产品化必须深入了解图形学的相关知识，原理，分析各种图形算法来提高识别准确性，另外准备大量的训练好的SVM和ANN数据也是提高准确性的重要方法。
3）测试车牌图片准备。
        简单方法：从网上搜索一些车牌图片，使用附件里面提供的APK，准确度非常高。
        Camera采集方法：附件里面的video.avi文件是我们使用USB camera拍摄的一段视频，可以在这里抓取一些车牌图片来识别，可惜这种方法的识别正确率实在不高。

 

  
        将这些图片都push到/storage/emulated/0文件夹下。
4）Android+Studio分析上步所得图片，识别，显示结果
        Android界面：edit输入框中的文件名加上前面的文件路径（/storage/emulated/0），显示按钮，识别按钮。代码如下：

  1. package com.example.gzh.myplaterecognizer;
  3. import android.Manifest;
  4. import android.content.DialogInterface;
  5. import android.content.pm.PackageManager;
  6. import android.graphics.Bitmap;
  7. import android.graphics.BitmapFactory;
  8. import android.os.Environment;
  9. import android.support.annotation.NonNull;
  10. import android.support.v4.app.ActivityCompat;
  11. import android.support.v4.content.ContextCompat;
  12. import android.support.v7.app.AlertDialog;
  13. import android.support.v7.app.AppCompatActivity;
  14. import android.os.Bundle;
  15. import android.util.Log;
  16. import android.view.View;
  17. import android.widget.EditText;
  18. import android.widget.ImageView;
  19. import android.widget.TextView;
  20. import android.widget.Toast;
  22. import org.opencv.android.Utils;
  23. import org.opencv.core.Mat;
  26. import java.io.File;
  27. import java.io.FileNotFoundException;
  28. import java.io.IOException;
  30. import static org.opencv.android.OpenCVLoader.initDebug;
  31. import static org.opencv.imgproc.Imgproc.COLOR_RGB2GRAY;
  32. import static org.opencv.imgproc.Imgproc.cvtColor;
  35. public class MainActivity extends AppCompatActivity {
  36.     private static final int MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE = 1;
  37.     private boolean mExternalStorageAvailable = false;
  38.     private boolean mExternalStorageWriteable = false;
  39.     private static final int CAMERA_REQUEST_CODE = 1;
  40.     private boolean mCamera = false;
  41.     static String TAG = "myplaterecognizer";
  42.     ImageView show_image;
  43.     Bitmap srcBitmap;
  44.     Bitmap grayBitmap;
  45.     private long mRecognizerPtr = 0;
  46.     private static boolean flag = true;
  47.     TextView Mytv;
  48.     PlateRecognizer myplaterecognizer;
  49.     EditText MyeditText;
  50.     int nRunningOnce = 0;
  51.     String strMyeditText = "1.PNG";
  52. //    String myPath = "/storage/emulated/0/Documents/PlateRcognizer";
  53.     String myPath = "/storage/emulated/0";
  54.     protected void onCreate(Bundle savedInstanceState) {
  55.         super.onCreate(savedInstanceState);
  56.         setContentView(R.layout.activity_main);
  57.         Log.d(TAG, "call SetExternalStoragepermission_OK");
  58.                                 int nRet = 0;//
  59.         SetExternalStoragepermission_OK();
  60.         nRet = CheckExternalStoragepermission_OK();
  61.         if(nRet == 0)
  62.         {
  63.                 Log.i("Surface:", "nRet ==0");
  64.         }
  65.         else
  66.         {
  67.                 Log.i("Surface:", "nRet !=0");
  68.         Mytv = (TextView) findViewById(R.id.sample_text);
  69.         myplaterecognizer = new PlateRecognizer(this);
  71.         MyeditText = (EditText)findViewById(R.id.editText);
  72.        // str1 = editText1.getText().toString();
  73.         MyeditText.setText(strMyeditText.toCharArray(), 0, strMyeditText.length());
  74.         //initData();
  76.         Mytv.setText(myplaterecognizer.stringFromJNI());
  77.         show_image = (ImageView) findViewById(R.id.imageView);        
  78.         }        // Example of a call to a native method
  80.        // show_image.setImageResource(R.drawable.heidfk640);
  81.         findViewById(R.id.button_show).setOnClickListener(new View.OnClickListener() {
  82.             @Override
  83.             public void onClick(View v) {
  84.                 //myPath
  85.                 String fileName = "";
  86.                 strMyeditText = MyeditText.getText().toString();
  87.                 fileName = String.format("%s/%s", myPath, strMyeditText);
  88.                 String str_test = "";
  89.                 str_test = String.format("=1=fileName=%s", fileName);
  90.                 Log.d(TAG, str_test);
  91.                 Bitmap bm = BitmapFactory.decodeFile(fileName);
  92.                 show_image.setImageBitmap(bm);
  94.             }
  95.         });
  96.         findViewById(R.id.button_PlateRecognizer).setOnClickListener(new View.OnClickListener() {
  97.             @Override
  98.             public void onClick(View v) {
  99.                 String fileName = "";
  100.                 strMyeditText = MyeditText.getText().toString();
  101.                 fileName = String.format("%s/%s", myPath, strMyeditText);
  102.                 String str_test = "";
  103.                 str_test = String.format("=1=fileName=%s/%s", myPath, strMyeditText);
  104.                 Log.d(TAG, str_test);
  105.                 // 进行车牌识别 pr_jingph7n90.jpg
  106.                 //  String plate = myplaterecognizer.recognize("/storage/sdcard/Pictures/PlateRcognizer/heidfk640.jpg");
  107.                 String plate = myplaterecognizer.recognize(fileName);
  108.                 // String plate = myplaterecognizer.recognize(pictureFile.getAbsolutePath());
  109.                 if (null != plate && ! plate.equalsIgnoreCase("0")) {
  110.                     Mytv.setText(plate);
  111.                 } else {
  112.                     Mytv.setText("can not recognize");
  113.                 }
  114.             }
  115.         });
  117.     }
  119.     @Override
  120.     protected void onResume() {
  121.         super.onResume();
  122.         if (initDebug()) {
  123.             Log.i(TAG, "OpenCV initialize success");
  124.         } else {
  125.             Log.i(TAG, "OpenCV initialize failed");
  126.         }
  127.     }
  128.     private int CheckExternalStoragepermission_OK()
  129.     {
  130.         String externalStorageState = Environment.getExternalStorageState();
  131.         if (Environment.MEDIA_MOUNTED.equals(externalStorageState)) {
  132.             mExternalStorageAvailable = true;
  133.             mExternalStorageWriteable = true;
  134.             return 2;      } else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(externalStorageState)) {
  135.             mExternalStorageAvailable = true;
  136.             mExternalStorageWriteable = false;
  137.             return 1;       } else {
  138.             mExternalStorageAvailable = mExternalStorageWriteable = false;
  139.             return 0;
  140.         }
  141.     //    handleExternalStorageState(mExternalStorageAvailable,mExternalStorageWriteable);
  142.     }
  143.     private void SetExternalStoragepermission_OK()
  144.     {
  145.         String externalStorageState = Environment.getExternalStorageState();
  146.         if (Environment.MEDIA_MOUNTED.equals(externalStorageState)) {
  147.             mExternalStorageAvailable = true;
  148.             mExternalStorageWriteable = true;
  149.         } else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(externalStorageState)) {
  150.             mExternalStorageAvailable = true;
  151.             mExternalStorageWriteable = false;
  152.         } else {
  153.             mExternalStorageAvailable = mExternalStorageWriteable = false;
  154.         }
  155.         handleExternalStorageState(mExternalStorageAvailable,mExternalStorageWriteable);
  156.         
  158.                                 requestPermission();
  159.         
  160.     }
  161.     private void requestPermission() {
  162.         if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
  163.                 != PackageManager.PERMISSION_GRANTED) {
  164.             // 第一次请求权限时，用户如果拒绝，下一次请求shouldShowRequestPermissionRationale()返回true
  165.             // 向用户解释为什么需要这个权限
  166.             if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
  167.                 new AlertDialog.Builder(this)
  168.                         .setMessage("申请相机权限")
  169.                         .setPositiveButton("确定", new DialogInterface.OnClickListener() {
  170.                             @Override
  171.                             public void onClick(DialogInterface dialog, int which) {
  172.                                 //申请相机权限
  173.                                 ActivityCompat.requestPermissions(MainActivity.this,
  174.                                         new String[]{Manifest.permission.CAMERA}, CAMERA_REQUEST_CODE);
  175.                             }
  176.                         })
  177.                         .show();
  178.             } else {
  179.                 //申请相机权限
  180.                 ActivityCompat.requestPermissions(this,
  181.                         new String[]{Manifest.permission.CAMERA}, CAMERA_REQUEST_CODE);
  182.             }
  183.         } else {
  184.           //  Tv.setTextColor(Color.GREEN);
  185.           //  Tv.setText("相机权限已申请");
  186.         }
  187.     }
  188.     private void handleCameraState(boolean mCamera ) {
  189.                 }
  190.     private void handleExternalStorageState(boolean mExternalStorageAvailable,boolean mExternalStorageWriteable ) {
  191.         if(mExternalStorageAvailable && mExternalStorageWriteable){
  192.             //STORAGE is dangerous so check
  193.             // checkSelfPermission()
  194.             int permissionCheck = ContextCompat.checkSelfPermission(this,
  195.                     Manifest.permission.WRITE_EXTERNAL_STORAGE);
  196.             Log.d("permission", "permissionCheck=="+permissionCheck);
  197.             if (permissionCheck != PackageManager.PERMISSION_GRANTED) {
  198.                 //has not granted request permission
  199.                 // Should we show an explanation?
  200.                 if (ActivityCompat.shouldShowRequestPermissionRationale(this,
  201.                         Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
  203.                     // Show an expanation to the user *asynchronously* -- don't block
  204.                     // this thread waiting for the user's response! After the user
  205.                     // sees the explanation, try again to request the permission.
  206.                     //  Toast.makeText(MainActivity.this, "Permission++++", Toast.LENGTH_SHORT).show();
  208. //                    ActivityCompat.requestPermissions(this,
  209. //                            new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
  210. //                            MY_PERMISSIONS_REQUEST_READ_CONTACTS);
  211.                     new AlertDialog.Builder(this)
  212.                             .setMessage("您拒绝过授予访问外部存储设备的权限,但是只有申请该权限,才能往外部存储设备写入数据,你确定要重新申请获取权限吗？")
  213.                             .setPositiveButton("ok", new DialogInterface.OnClickListener() {
  214.                                 @Override
  215.                                 public void onClick(DialogInterface dialog, int which) {
  216.                                     dialog.dismiss();
  217.                                     //again request permission
  218.                                     ActivityCompat.requestPermissions(MainActivity.this,
  219.                                             new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
  220.                                             MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
  222.                                 }
  223.                             })
  224.                             .setNegativeButton("no", new DialogInterface.OnClickListener() {
  225.                                 @Override
  226.                                 public void onClick(DialogInterface dialog, int which) {
  227.                                     dialog.dismiss();
  228.                                 }
  229.                             })
  230.                             .create()
  231.                             .show();
  232.                 } else {
  233.                     // No explanation needed, we can request the permission.
  234.                     ActivityCompat.requestPermissions(this,
  235.                             new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
  236.                             MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE);
  238.                     // MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE is an
  239.                     // app-defined int constant. The callback method gets the
  240.                     // result of the request.
  241.                 }
  243.             }else{
  244.                 //had granted
  245.                 Toast.makeText(MainActivity.this, "run writeDatasToExternalStorage() method", Toast.LENGTH_SHORT).show();
  246.                 // writeDatasToExternalStorage();
  247.             }
  248.         }else{
  249.             Log.d("permission", "ExternalStorage can not be write  or unAvailable");
  250.         }
  251.     }
  253.     /**          */
  254.     private void writeDatasToExternalStorage(){
  255.         File directory = Environment.getExternalStorageDirectory();// 6.0 /storage/emulated/0    5.0 /storage/sdcard
  256.             /*
  257.              Environment.getDataDirectory();//  /data
  258.              Environment.getRootDirectory();// /system
  259.              Environment.getDownloadCacheDirectory();//  /cache
  260.              Environment.getExternalStoragePublicDirectory(
  261.                     Environment.DIRECTORY_PICTURES);// 6.0 /storage/emulated/0/Pictures   5.0/storage/sdcard/Pictures
  262.            */
  263.         File file = new File(directory, "permisson");
  264.         if(!file.exists()){
  265.             try {
  266.                 file.createNewFile();
  267.             } catch (IOException e) {
  268.                 e.printStackTrace();
  269.             }
  270.         }
  271.     }
  273.     /**
  274.      *
  275.      * @param requestCode
  276.      * @param permissions
  277.      * @param grantResults
  278.      */
  279.     @Override
  280.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  281.         Log.d("permission", "onRequestPermissionsResult  requestCode" + requestCode);
  282.         if (requestCode == MY_PERMISSIONS_REQUEST_WRITE_EXTERNAL_STORAGE) {
  284.                 // If request is cancelled, the result arrays are empty.
  285.                 if (grantResults.length > 0
  286.                         && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  288.                     // permission was granted, yay! Do the
  289.                     // contacts-related task you need to do.
  290.                     Toast.makeText(MainActivity.this, "run writeDatasToExternalStorage() method", Toast.LENGTH_SHORT).show();
  291.                     //   writeDatasToExternalStorage();
  293.                 } else {
  294.                     // Permission Denied
  295.                     Toast.makeText(MainActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
  296.                     // permission denied, boo! Disable the
  297.                     // functionality that depends on this permission.
  298.                 }
  299.                 return;
  300.             }
  301.         if (requestCode == CAMERA_REQUEST_CODE) {
  303.                     if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  304.                    // Tv.setTextColor(Color.GREEN);
  305.                   //  Tv.setText("相机权限已申请");
  306.             } else {
  307.                 //用户勾选了不再询问
  308.                 //提示用户手动打开权限
  309.                 if (!ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
  310.                     Toast.makeText(this, "相机权限已被禁止", Toast.LENGTH_SHORT).show();
  311.                 }
  312.             }
  313.             }
  314.             // other 'case' lines to check for other
  315.             // permissions this app might request
  318.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  320.     }
  324. }

复制代码

        NDK算法实现；

  1. #include "EasyPR.h"
  3. #include "easyPR/include/core/plate_locate.h"
  4. #include "easyPR/include/core/plate_judge.h"
  5. #include "easyPR/include/core/chars_segment.h"
  6. #include "easyPR/include/core/chars_identify.h"
  7. #include "easyPR/include/core/plate_detect.h"
  8. #include "easyPR/include/core/chars_recognise.h"
  9. #include "easyPR/include/core/plate_recognize.h"
  11. using namespace easypr;
  12. #include <android/log.h>
  14. #define LOG_TAG "System.out"
  15. #define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
  16. #define  LOGD(...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG,__VA_ARGS__)
  17. #define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
  18. extern "C"
  19. JNIEXPORT jstring JNICALL Java_com_example_gzh_myplaterecognizer_PlateRecognizer_stringFromJNI(
  20.                 JNIEnv *env,
  21.                 jobject /* this */
  22.         ) {
  23.     return env->NewStringUTF("myplaterecognizer JNI!");
  24. }
  26. char* jstring2str(JNIEnv* env, jstring jstr) {
  27.         char* rtn = NULL;
  29.         jclass clsstring = env->FindClass("java/lang/String");
  30.         jstring strencode = env->NewStringUTF("utf-8"); // "GB2312"
  31.         jmethodID mid = env->GetMethodID(clsstring, "getBytes", "(Ljava/lang/String;)[B");
  32.         jbyteArray barr = (jbyteArray) env->CallObjectMethod(jstr, mid, strencode);
  33.         jsize alen = env->GetArrayLength(barr);
  34.         jbyte* ba = env->GetByteArrayElements(barr, JNI_FALSE);
  35.         if (alen > 0) {
  36.                 rtn = (char *)malloc(alen + 1);
  37.                 memcpy(rtn, ba, alen);
  38.                 rtn[alen] = 0;
  39.         }
  40.         env->ReleaseByteArrayElements(barr, ba, 0);
  41.         return rtn;
  42. }
  43. extern "C"
  44. JNIEXPORT jlong JNICALL Java_com_example_gzh_myplaterecognizer_PlateRecognizer_initPR(
  45.                 JNIEnv *env,
  46.                 jobject /* this */,
  47.                 jstring svmpath,
  48.                 jstring annpath)
  49. {
  50. //        const string *svm = (*env)->GetStringUTFChars(env, svmpath, 0);
  51. //        const string *ann = (*env)->GetStringUTFChars(env, annpath, 0);
  52.         char* svm = jstring2str(env, svmpath);
  53.         char* ann = jstring2str(env, annpath);
  54.         LOGE("Java_com_example_gzh_myplaterecognizer_PlateRecognizer_initPR svm=%s, ann=%s", svm, ann);
  55.         CPlateRecognize *pr = new CPlateRecognize();
  57.         pr->setDebug(false);
  58.         pr->setLifemode(true);
  59.     pr->setMaxPlates(4);
  61.     pr->loadSVM(svm);
  62.     pr->loadANN(ann);
  64.     return (jlong)pr;
  65. }
  66. extern "C"
  67. JNIEXPORT jlong JNICALL Java_com_example_gzh_myplaterecognizer_PlateRecognizer_uninitPR(
  68.                 JNIEnv *env, jobject, jlong recognizerPtr) {
  69.     CPlateRecognize *pr = (CPlateRecognize *)recognizerPtr;
  70.         LOGE("Java_com_example_gzh_myplaterecognizer_PlateRecognizer_uninitPR");
  71.     delete pr;
  73.     return 0;
  74. }
  75. extern "C"
  76. JNIEXPORT jbyteArray JNICALL Java_com_example_gzh_myplaterecognizer_PlateRecognizer_plateRecognize(
  77.                 JNIEnv *env, jobject, jlong recognizerPtr, jstring imgpath) {
  78.     CPlateRecognize *pr = (CPlateRecognize *)recognizerPtr;
  80.     //        const string *img = (*env)->GetStringUTFChars(env, imgpath, 0);
  81.     char* img = jstring2str(env, imgpath);
  82.         Mat src = imread(img);
  84.         std::vector<std::string> plateVec;
  85.         int count = pr->plateRecognize(src, plateVec);
  87.         std::string str = "0";
  88.         if(! plateVec.empty() && count == 0) {
  89.                 str = plateVec[0];
  90.         }
  92.         char *result = new char[str.length() + 1];
  93.         strcpy(result, str.c_str());
  94.         jbyte *by = (jbyte*) result;
  95.         jbyteArray jarray = env->NewByteArray(strlen(result));
  96.         env->SetByteArrayRegion(jarray, 0, strlen(result), by);
  98.         return jarray;
  99. }
  100. extern "C"
  101. JNIEXPORT jbyteArray JNICALL Java_com_example_gzh_myplaterecognizer_PlateRecognizer_plateRecognize1(
  102.                 JNIEnv *env, jobject, jlong recognizerPtr, jlong imgMat) {
  103.         CPlateRecognize *pr = (CPlateRecognize *)recognizerPtr;
  105.         //        const string *img = (*env)->GetStringUTFChars(env, imgpath, 0);
  106.         //char* img = jstring2str(env, imgpath);
  107.         Mat& src = *(Mat*)imgMat;// = imread(img);
  109.         std::vector<std::string> plateVec;
  110.         int count = pr->plateRecognize(src, plateVec);
  112.         std::string str = "0";
  113.         if(! plateVec.empty() && count == 0) {
  114.                 str = plateVec[0];
  115.         }
  117.         char *result = new char[str.length() + 1];
  118.         strcpy(result, str.c_str());
  119.         jbyte *by = (jbyte*) result;
  120.         jbyteArray jarray = env->NewByteArray(strlen(result));
  121.         env->SetByteArrayRegion(jarray, 0, strlen(result), by);
  123.         return jarray;
  124. }

复制代码

  1. #include "../../include/core/plate_recognize.h"
  2. #include "../../include/config.h"
  4. namespace easypr {
  6. CPlateRecognize::CPlateRecognize() { }
  8. // !车牌识别模块
  10. int CPlateRecognize::plateRecognize(Mat src, std::vector<std::string> &licenseVec) {
  12.   // 车牌方块集合
  14.   std::vector<CPlate> plateVec;
  16.   // 进行深度定位，使用颜色信息与二次Sobel
  18.   int resultPD = plateDetect(src, plateVec, kDebug, 0);
  20.   if (resultPD == 0) {
  21.     size_t num = plateVec.size();
  22.     int index = 0;
  24.     //依次识别每个车牌内的符号
  26.     for (size_t j = 0; j < num; j++) {
  27.       CPlate item = plateVec[j];
  28.       Mat plate = item.getPlateMat();
  30.       //获取车牌颜色
  32.       std::string plateType = getPlateColor(plate);
  34.       //获取车牌号
  36.       std::string plateIdentify = "";
  37.       int resultCR = charsRecognise(plate, plateIdentify);
  38.       if (resultCR == 0) {
  39.         std::string license = plateType + ":" + plateIdentify;
  40.         licenseVec.push_back(license);
  41.       }
  42.     }
  44.     //完整识别过程到此结束
  46.     //如果是Debug模式，则还需要将定位的图片显示在原图左上角
  48.     if (getPDDebug()) {
  49.       Mat result;
  50.       src.copyTo(result);
  52.       for (size_t j = 0; j < num; j++) {
  53.         CPlate item = plateVec[j];
  54.         Mat plate = item.getPlateMat();
  56.         int height = 36;
  57.         int width = 136;
  58.         if (height * index + height < result.rows) {
  59.           Mat imageRoi = result(Rect(0, 0 + height * index, width, height));
  60.           addWeighted(imageRoi, 0, plate, 1, 0, imageRoi);
  61.         }
  62.         index++;
  64.         RotatedRect minRect = item.getPlatePos();
  65.         Point2f rect_points[4];
  66.         minRect.points(rect_points);
  68.         Scalar lineColor = Scalar(255, 255, 255);
  70.         if (item.getPlateLocateType() == SOBEL) lineColor = Scalar(255, 0, 0);
  72.         if (item.getPlateLocateType() == COLOR) lineColor = Scalar(0, 255, 0);
  74.         for (int j = 0; j < 4; j++)
  75.           line(result, rect_points[j], rect_points[(j + 1) % 4], lineColor, 2,
  76.                8);
  77.       }
  79.       //显示定位框的图片
  81.       showResult(result);
  82.     }
  83.   }
  85.   return resultPD;
  86. }
  87. }

复制代码

四）测试过程和视频
   测试过程：1）安装APK；2）准备测试图片
          
 
测试视频： http://v.youku.com/v_show/id_XMjYyODcwNzkzNg==.html。
抓取测试图片视频地址： https://pan.baidu.com/s/1pLvxVbd
apk共享地址; https://pan.baidu.com/s/1o84Ttvc
五）总结
        改进方案：
        1）Android界面上应该使用通过按钮选择车牌图片来识别，或者通过Listbox显示多个图片，或者通过Combox选择框来显示多个图片；
        2）对plateRecognize类众多函数没有详细解读；
        3）固定Camera处理实时图像。


DragonCat liked
回复引用
DragonCat
 DragonCat
Level 2Admin
注册时间:8年 前
帖子数: 42
2017年3月20日 上午10:42  

牛，希望大家去结合更多的应用场景使用MediaTek X20 board，然后发出来共享讨论，哈哈，让我们的论坛飞起来呀。


回复引用

×
      
    Working

    请 登陆 或者 注册