这是项目《智能驾驶车牌检测和识别》系列之《C++实现车牌检测和识别（可实时车牌识别）》；本项目将开发一个C/C++版本的车牌检测和识别，其中车牌检测算法采用YOLOv5模型，车牌识别算法采用PlateNet模型；车牌检测和识别Demo在OpenCL加速下，可以达到实时的检测和识别效果，基本满足业务的性能需求。

车牌识别Demo效果展示：

【整套项目下载地址】：智能驾驶车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》

【Android Demo体验】Android实现车牌检测和识别-Android文档类资源-CSDN下载

【尊重原创，转载请注明出处】智能驾驶车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》：https://blog.csdn.net/guyuealian/article/details/128704276

更多项目《智能驾驶车牌检测和识别》系列文章请参考：

智能驾驶车牌检测和识别（一）《CCPD车牌数据集》：https://blog.csdn.net/guyuealian/article/details/128704181
智能驾驶车牌检测和识别（二）《YOLOv5实现车牌检测（含车牌检测数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704068
智能驾驶车牌检测和识别（三）《CRNN和LPRNet实现车牌识别（含车牌识别数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704209
智能驾驶车牌检测和识别（四）《Android实现车牌检测和识别（可实时车牌识别）》：https://blog.csdn.net/guyuealian/article/details/128704242
智能驾驶车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》：https://blog.csdn.net/guyuealian/article/details/128704276
智能驾驶红绿灯检测（一）《红绿灯(交通信号灯)数据集》：https://blog.csdn.net/guyuealian/article/details/128222850
智能驾驶红绿灯检测（二）《YOLOv5实现红绿灯检测(含红绿灯数据集+训练代码)》：https://blog.csdn.net/guyuealian/article/details/128240198
智能驾驶红绿灯检测（三）《Android实现红绿灯检测(含Android源码可实时运行)》：https://blog.csdn.net/guyuealian/article/details/128240334
智能驾驶车辆检测（一）《UA-DETRAC BITVehicle车辆检测数据集》：https://blog.csdn.net/guyuealian/article/details/127907325
智能驾驶车辆检测（二）《YOLOv5实现车辆检测(含车辆检测数据集+训练代码)》：https://blog.csdn.net/guyuealian/article/details/128099672
智能驾驶车辆检测（三）《Android实现车辆检测(含Android源码可实时运行)》：https://blog.csdn.net/guyuealian/article/details/128190532

2. 车牌检测模型（YOLOv5）

车牌检测模型训练过程，请参考：智能驾驶车牌检测和识别（二）《YOLOv5实现车牌检测（含车牌检测数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704068

为了能部署在开发板或者手机平台上，本人对YOLOv5s进行了简单的模型轻量化，并开发了一个轻量级的版本yolov5s05_416和yolov5s05_320模型；轻量化模型在普通Android手机上可以达到实时的检测效果，CPU(4线程)约30ms左右，GPU约25ms左右，基本满足业务的性能需求。下表格给出轻量化模型的计算量和参数量以及其检测精度

模型	input-size	params(M)	GFLOPs	mAP_0.5:0.95
yolov5s	640×640	7.2	16.5	0.75261
yolov5s05	416×416	1.7	1.8	0.74593
yolov5s05	320×320	1.7	1.1	0.74341

车牌检测效果：

YOLOv5车牌检测模型在C++端上部署过程，请参考如下

（1）将Pytorch模型转换ONNX模型

训练好yolov5s05或者yolov5s模型后，你需要将模型转换为ONNX模型，并使用onnx-simplifier简化网络结构


  
   
    
     
    
    
     
      # 转换yolov5s05模型
     
    
   
    
     
    
    
     
      python export.py --weights 
      "runs/yolov5s05_320/weights/best.pt" --img-size 320 320
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # 转换yolov5s模型
     
    
   
    
     
    
    
     
      python export.py --weights 
      "runs/yolov5s_640/weights/best.pt" --img-size 640 640

GitHub： https://github.com/daquexian/onnx-simplifier
Install: pip3 install onnx-simplifier

（2）将ONNX模型转换为TNN模型

目前CNN模型有多种部署方式，可以采用TNN，MNN,NCNN，以及TensorRT等部署工具，鄙人采用TNN进行Android端上部署：

TNN转换工具：

（1）将ONNX模型转换为TNN模型，请参考TNN官方说明：TNN/onnx2tnn.md at master · Tencent/TNN · GitHub

（2）一键转换，懒人必备：一键转换 Caffe, ONNX, TensorFlow 到 NCNN, MNN, Tengine (可能存在版本问题，这个工具转换的TNN模型可能不兼容，建议还是自己build源码进行转换，2022年9约25日测试可用)

3. 车牌识别模型（PlateNet）

车牌识别模型训练过程，请参考智能驾驶车牌检测和识别（三）《CRNN和LPRNet实现车牌识别（含车牌识别数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704209

项目基于CRNN或LPRNet模型构建车牌识别算法，支持绿牌和蓝牌识别；为方便后续工程化，项目对CRNN模型进行魔改，提出一个PlateNet模型，用于支持部署到Android平台或者开发板上

整套智能车牌检测和识别系统，在OpenCL加速下，可以达到实时的检测效果，基本满足业务的性能需求。下表格给出CRNN，LPRNet和PlateNet模型的计算量和参数量以及其车牌识别的准确率：

模型	input-size	params(M)	GFLOPs	Accuracy
LPRNet	94×24	0.48M	0.147GFlops	0.9393
CRNN	160×32	8.35M	1.06GFlops	0.9343
PlateNet	168×48	1.92M	1.25GFlops	0.9583

车牌识别Demo效果展示：

PlateNet车牌识别模型在C++端上部署过程，请参考如下

（1）将Pytorch模型转换ONNX模型

车牌识别项目源码demo.py文件中参数--export设置为True，可将Pytorch的模型转换为ONNX模型文件，且ONNX文件会默认保存在Pytorch的模型文件同一目录下。

（2）将ONNX模型转换为TNN模型

TNN转换工具，请参考：

（1）将ONNX模型转换为TNN模型，请参考TNN官方说明：TNN/onnx2tnn.md at master · Tencent/TNN · GitHub

（2）一键转换，懒人必备：一键转换 Caffe, ONNX, TensorFlow 到 NCNN, MNN, Tengine (可能存在版本问题，这个工具转换的TNN模型可能不兼容，建议还是自己build源码进行转换，2022年9约25日测试可用)

4. 车牌检测和识别C++端上部署

（1）项目结构

（2）配置开发环境(OpenCV+OpenCL+base-utils+TNN)

项目仅在Ubuntu18.04进行测试，Windows系统下请自行配置和编译

安装OpenCV：图像处理

图像处理（如读取图片，图像裁剪等）都需要使用OpenCV库进行处理

安装教程：Ubuntu18.04安装opencv和opencv_contrib_AI吃大瓜的博客-CSDN博客_opencv opencv_contrib ubuntu

OpenCV库使用opencv-4.3.0版本，opencv_contrib库暂时未使用，可不安装

安装OpenCL：模型加速

安装教程：Ubuntu16.04 安装OpenCV&OpenCL_xiaozl_284的博客-CSDN博客_clinfo源码下载

OpenCL用于模型GPU加速，若不使用OpenCL进行模型推理加速，纯C++推理模型，速度会特别特别慢

base-utils：C++库

GitHub：https://github.com/PanJinquan/base-utils （无需安装，项目已经配置了）

base_utils是个人开发常用的C++库，集成了C/C++ OpenCV等常用的算法

TNN：模型推理

GitHub：https://github.com/Tencent/TNN （无需安装，项目已经配置了）

由腾讯优图实验室开源的高性能、轻量级神经网络推理框架，同时拥有跨平台、高性能、模型压缩、代码裁剪等众多突出优势。TNN框架在原有Rapidnet、ncnn框架的基础上进一步加强了移动端设备的支持以及性能优化，同时借鉴了业界主流开源框架高性能和良好拓展性的特性，拓展了对于后台X86, NV GPU的支持。手机端 TNN已经在手机QQ、微视、P图等众多应用中落地，服务端TNN作为腾讯云AI基础加速框架已为众多业务落地提供加速支持。

（3）部署TNN模型

项目实现了C/C++版本的车牌检测和车牌识别，车牌检测模型YOLOv5和车牌识别模型PlateNet，模型推理采用TNN部署框架（支持多线程CPU和GPU加速推理）；图像处理采用OpenCV库，模型加速采用OpenCL，在普通设备即可达到实时处理。

如果你想在这个 Demo部署你自己训练的车牌检测模型YOLOv5和车牌识别模型PlateNet，你可将训练好的Pytorch模型转换ONNX ，再转换成TNN模型，然后把原始的模型替换成你自己的TNN模型即可。

（4）CMake配置

这是CMakeLists.txt，其中主要配置OpenCV+OpenCL+base-utils+TNN这四个库，Windows系统下请自行配置和编译


  
   
    
     
    
    
     
      cmake_minimum_required(VERSION 3.5)
     
    
   
    
     
    
    
     
      project(Detector)
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      add_compile_options(-fPIC) 
      # fix Bug: can not be used when making a shared object
     
    
   
    
     
    
    
     
      set(CMAKE_CXX_FLAGS 
      "-Wall -std=c++11 -pthread")
     
    
   
    
     
    
    
     
      #set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
     
    
   
    
     
    
    
     
      #set(CMAKE_CXX_FLAGS_DEBUG "-g")
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
     
    
   
    
     
    
    
         
      # -DCMAKE_BUILD_TYPE=Debug
     
    
   
    
     
    
    
         
      # -DCMAKE_BUILD_TYPE=Release
     
    
   
    
     
    
    
     
          message(STATUS 
      "No build type selected, default to Release")
     
    
   
    
     
    
    
         
      set(CMAKE_BUILD_TYPE 
      "Release" CACHE STRING 
      "Build type (default Debug)" FORCE)
     
    
   
    
     
    
    
     
      endif ()
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # opencv set
     
    
   
    
     
    
    
     
      find_package(OpenCV REQUIRED)
     
    
   
    
     
    
    
     
      include_directories(
      ${OpenCV_INCLUDE_DIRS} ./src/)
     
    
   
    
     
    
    
     
      #MESSAGE(STATUS "OpenCV_INCLUDE_DIRS = ${OpenCV_INCLUDE_DIRS}")
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # base_utils
     
    
   
    
     
    
    
     
      set(BASE_ROOT 3rdparty/base-utils) 
      # 设置base-utils所在的根目录
     
    
   
    
     
    
    
     
      add_subdirectory(
      ${BASE_ROOT}/base_utils/ base_build) 
      # 添加子目录到build中
     
    
   
    
     
    
    
     
      include_directories(
      ${BASE_ROOT}/base_utils/include)
     
    
   
    
     
    
    
     
      include_directories(
      ${BASE_ROOT}/base_utils/src)
     
    
   
    
     
    
    
     
      MESSAGE(STATUS 
      "BASE_ROOT = ${BASE_ROOT}")
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # TNN set
     
    
   
    
     
    
    
     
      # 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 it for you.
     
    
   
    
     
    
    
     
      # Gradle automatically packages shared libraries with your APK.
     
    
   
    
     
    
    
     
      # build for platform
     
    
   
    
     
    
    
     
      if (CMAKE_SYSTEM_NAME MATCHES 
      "Android")
     
    
   
    
     
    
    
         
      set(TNN_OPENCL_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_ARM_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_BUILD_SHARED OFF CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_OPENMP_ENABLE ON CACHE BOOL 
      "" FORCE)  
      # Multi-Thread
     
    
   
    
     
    
    
         
      #set(TNN_HUAWEI_NPU_ENABLE OFF CACHE BOOL "" FORCE)
     
    
   
    
     
    
    
     
          add_definitions(-DTNN_OPENCL_ENABLE)           
      # for OpenCL GPU
     
    
   
    
     
    
    
     
          add_definitions(-DTNN_ARM_ENABLE)              
      # for Android CPU
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_ANDROID_ON)            
      # for Android Log
     
    
   
    
     
    
    
     
          add_definitions(-DPLATFORM_ANDROID)
     
    
   
    
     
    
    
     
      elseif (CMAKE_SYSTEM_NAME MATCHES 
      "Linux")
     
    
   
    
     
    
    
         
      set(TNN_OPENCL_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_CPU_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_X86_ENABLE OFF CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_QUANTIZATION_ENABLE OFF CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_OPENMP_ENABLE OFF CACHE BOOL 
      "" FORCE)  
      # Multi-Thread
     
    
   
    
     
    
    
     
          add_definitions(-DTNN_OPENCL_ENABLE)           
      # for OpenCL GPU
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_ON)                    
      # for WIN/Linux Log
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_LOG_ON)                
      # for WIN/Linux Log
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_IMSHOW_OFF)            
      # for OpenCV show
     
    
   
    
     
    
    
     
          add_definitions(-DPLATFORM_LINUX)
     
    
   
    
     
    
    
     
      elseif (CMAKE_SYSTEM_NAME MATCHES 
      "Windows")
     
    
   
    
     
    
    
         
      set(TNN_OPENCL_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_CPU_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_X86_ENABLE ON CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_QUANTIZATION_ENABLE OFF CACHE BOOL 
      "" FORCE)
     
    
   
    
     
    
    
         
      set(TNN_OPENMP_ENABLE ON CACHE BOOL 
      "" FORCE)  
      # Multi-Thread
     
    
   
    
     
    
    
     
          add_definitions(-DTNN_OPENCL_ENABLE)           
      # for OpenCL GPU
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_ON)                    
      # for WIN/Linux Log
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_LOG_ON)                
      # for WIN/Linux Log
     
    
   
    
     
    
    
     
          add_definitions(-DDEBUG_IMSHOW_OFF)            
      # for OpenCV show
     
    
   
    
     
    
    
     
          add_definitions(-DPLATFORM_WINDOWS)
     
    
   
    
     
    
    
     
      endif ()
     
    
   
    
     
    
    
     
      set(TNN_ROOT 3rdparty/TNN)
     
    
   
    
     
    
    
     
      #set(TNN_ROOT 3rdparty/TNN-latest)
     
    
   
    
     
    
    
     
      include_directories(
      ${TNN_ROOT}/include)
     
    
   
    
     
    
    
     
      include_directories(
      ${TNN_ROOT}/third_party/opencl/include)
     
    
   
    
     
    
    
     
      add_subdirectory(
      ${TNN_ROOT}) 
      # 添加外部项目文件夹
     
    
   
    
     
    
    
     
      set(TNN -Wl,--whole-archive TNN -Wl,--no-whole-archive)
      # set TNN library
     
    
   
    
     
    
    
     
      MESSAGE(STATUS 
      "TNN_ROOT = ${TNN_ROOT}")
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      # Detector
     
    
   
    
     
    
    
     
      include_directories(src)
     
    
   
    
     
    
    
     
      set(SRC_LIST
     
    
   
    
     
    
    
     
              src/crnn.cpp
     
    
   
    
     
    
    
     
              src/yolov5.cpp
     
    
   
    
     
    
    
     
              src/Interpreter.cpp)
     
    
   
    
     
    
    
     
      add_library(dmcv SHARED 
      ${SRC_LIST})
     
    
   
    
     
    
    
     
      target_link_libraries(dmcv
     
    
   
    
     
    
    
             
      ${TNN}
     
    
   
    
     
    
    
             
      ${OpenCV_LIBS}
     
    
   
    
     
    
    
     
              base_utils)
     
    
   
    
     
    
    
     
      MESSAGE(STATUS 
      "DIR_SRCS = ${SRC_LIST}")
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      add_executable(demo src/main_for_crnn.cpp)
     
    
   
    
     
    
    
     
      target_link_libraries(demo dmcv -lpthread)

（5）main源码

主程序中函数main_for_detect_plate()实现车牌检测+车牌识别的过程，函数main_for_plate()仅仅包含车牌识别，没有车牌检测


  
   
    
     
    
    
     
      //
     
    
   
    
     
    
    
     
      // Created by on 2020/6/24.
     
    
   
    
     
    
    
     
      //
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      #include "crnn.h"
     
    
   
    
     
    
    
     
      #include <iostream>
     
    
   
    
     
    
    
     
      #include <string>
     
    
   
    
     
    
    
     
      #include <vector>
     
    
   
    
     
    
    
     
      #include "file_utils.h"
     
    
   
    
     
    
    
     
      #include "yolov5.h"
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      using 
      namespace dl;
     
    
   
    
     
    
    
     
      using 
      namespace vision;
     
    
   
    
     
    
    
     
      using 
      namespace std;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      void main_for_plate() {
     
    
   
    
     
    
    
         
      const 
      int num_thread = 
      1;
     
    
   
    
     
    
    
         
      // 选择运行设备：GPU or CPU
     
    
   
    
     
    
    
     
          DeviceType device = GPU;
     
    
   
    
     
    
    
         
      // 初始化识别模型
     
    
   
    
     
    
    
         
      const 
      char *model_file = (
      char *) 
      "../data/tnn/plate/platenet.tnnmodel";
     
    
   
    
     
    
    
         
      const 
      char *proto_file = (
      char *) 
      "../data/tnn/plate/platenet.tnnproto";
     
    
   
    
     
    
    
     
          CRNNRecognizeParam classifier_param = CRNN_MODEL;
     
    
   
    
     
    
    
     
          CRNNRecognize *recognize = 
      new 
      CRNNRecognize(model_file,
     
    
   
    
     
    
    
     
                                                       proto_file,
     
    
   
    
     
    
    
     
                                                       classifier_param,
     
    
   
    
     
    
    
     
                                                       num_thread,
     
    
   
    
     
    
    
     
                                                       device);
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      // 测试图片路径
     
    
   
    
     
    
    
     
          string image_dir = 
      "../data/test_image/plate";
     
    
   
    
     
    
    
     
          std::vector<string> image_list = 
      get_files_list(image_dir);
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      for (string image_path:image_list) {
     
    
   
    
     
    
    
             
      // 读取图片（不进行车牌检测）
     
    
   
    
     
    
    
     
              cv::Mat bgr_image = cv::
      imread(image_path);
     
    
   
    
     
    
    
             
      int w = bgr_image.cols;
     
    
   
    
     
    
    
             
      int h = bgr_image.rows;
     
    
   
    
     
    
    
             
      if (bgr_image.
      empty()) 
      continue;
     
    
   
    
     
    
    
     
              FrameInfo resultInfo;
     
    
   
    
     
    
    
     
              ObjectInfo info;
     
    
   
    
     
    
    
     
              info.x1 = 
      0;
     
    
   
    
     
    
    
     
              info.y1 = 
      0;
     
    
   
    
     
    
    
     
              info.x2 = w;
     
    
   
    
     
    
    
     
              info.y2 = h;
     
    
   
    
     
    
    
     
              info.score = 
      1.0;
     
    
   
    
     
    
    
     
              resultInfo.info.
      push_back(info);
     
    
   
    
     
    
    
             
      // 开始识别
     
    
   
    
     
    
    
     
              recognize->
      detect(bgr_image, &resultInfo);
     
    
   
    
     
    
    
             
      // 显示结果
     
    
   
    
     
    
    
     
              recognize->
      visualizeResult(bgr_image, &resultInfo);
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      delete recognize;
     
    
   
    
     
    
    
     
          recognize = 
      nullptr;
     
    
   
    
     
    
    
         
      printf(
      "FINISHED.\n");
     
    
   
    
     
    
    
     
      }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      void main_for_detect_plate() {
     
    
   
    
     
    
    
         
      const 
      int num_thread = 
      1;
     
    
   
    
     
    
    
         
      // 选择运行设备：GPU or CPU
     
    
   
    
     
    
    
     
          DeviceType device = GPU;
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      //string det_proto_file = "../data/tnn/yolov5/yolov5s_640.sim.tnnproto";
     
    
   
    
     
    
    
         
      //string det_model_file = "../data/tnn/yolov5/yolov5s_640.sim.tnnmodel";
     
    
   
    
     
    
    
         
      //YOLOv5Param yolOv5Param = YOLOv5s_640;//模型参数
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          string det_proto_file = 
      "../data/tnn/yolov5/yolov5s05_416.sim.tnnproto";
     
    
   
    
     
    
    
     
          string det_model_file = 
      "../data/tnn/yolov5/yolov5s05_416.sim.tnnmodel";
     
    
   
    
     
    
    
     
          YOLOv5Param yolOv5Param = YOLOv5s05_416;
      //模型参数
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      //string det_proto_file = "../data/tnn/yolov5/yolov5s05_320.sim.tnnproto";
     
    
   
    
     
    
    
         
      //string det_model_file = "../data/tnn/yolov5/yolov5s05_320.sim.tnnmodel";
     
    
   
    
     
    
    
         
      //YOLOv5Param yolOv5Param = YOLOv5s05_320;//模型参数
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      // 初始化检测模型
     
    
   
    
     
    
    
         
      const 
      float scoreThresh = 
      0.3;
     
    
   
    
     
    
    
         
      const 
      float iouThresh = 
      0.2;
     
    
   
    
     
    
    
     
          YOLOv5 *detector = 
      new 
      YOLOv5(det_model_file,
     
    
   
    
     
    
    
     
                                        det_proto_file,
     
    
   
    
     
    
    
     
                                        yolOv5Param,
     
    
   
    
     
    
    
     
                                        num_thread,
     
    
   
    
     
    
    
     
                                        device);
     
    
   
    
     
    
    
         
      // 初始化识别模型
     
    
   
    
     
    
    
         
      const 
      char *model_file = (
      char *) 
      "../data/tnn/plate/platenet.tnnmodel";
     
    
   
    
     
    
    
         
      const 
      char *proto_file = (
      char *) 
      "../data/tnn/plate/platenet.tnnproto";
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          CRNNRecognizeParam classifier_param = CRNN_MODEL;
     
    
   
    
     
    
    
     
          CRNNRecognize *recognize = 
      new 
      CRNNRecognize(model_file,
     
    
   
    
     
    
    
     
                                                       proto_file,
     
    
   
    
     
    
    
     
                                                       classifier_param,
     
    
   
    
     
    
    
     
                                                       num_thread,
     
    
   
    
     
    
    
     
                                                       device);
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
          string image_dir = 
      "../data/test_image/plate_car";
     
    
   
    
     
    
    
     
          std::vector<string> image_list = 
      get_files_list(image_dir);
     
    
   
    
     
    
    
         
      for (string image_path:image_list) {
     
    
   
    
     
    
    
             
      // 读取图片
     
    
   
    
     
    
    
     
              cv::Mat bgr_image = cv::
      imread(image_path);
     
    
   
    
     
    
    
             
      if (bgr_image.
      empty()) 
      continue;
     
    
   
    
     
    
    
     
              FrameInfo resultInfo;
     
    
   
    
     
    
    
             
      // 开始检测
     
    
   
    
     
    
    
     
              detector->
      detect(bgr_image, &resultInfo, scoreThresh, iouThresh);
     
    
   
    
     
    
    
             
      // 开始识别
     
    
   
    
     
    
    
     
              recognize->
      detect(bgr_image, &resultInfo);
     
    
   
    
     
    
    
             
      // 显示结果
     
    
   
    
     
    
    
     
              recognize->
      visualizeResult(bgr_image, &resultInfo);
     
    
   
    
     
    
    
     
          }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
         
      delete recognize;
     
    
   
    
     
    
    
     
          recognize = 
      nullptr;
     
    
   
    
     
    
    
         
      delete detector;
     
    
   
    
     
    
    
     
          detector = 
      nullptr;
     
    
   
    
     
    
    
         
      printf(
      "FINISHED.\n");
     
    
   
    
     
    
    
     
      }
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
      
     
    
   
    
     
    
    
     
      int main() {
     
    
   
    
     
    
    
         
      // 车牌检测+车牌识别
     
    
   
    
     
    
    
         
      main_for_detect_plate();
     
    
   
    
     
    
    
         
      // 车牌识别
     
    
   
    
     
    
    
         
      //main_for_plate();
     
    
   
    
     
    
    
         
      return 
      0;
     
    
   
    
     
    
    
     
      }

（6）源码编译和运行

编译脚本，或者直接：bash build.sh


  
   
    
     
    
    
     
      #!/usr/bin/env bash
     
    
   
    
     
    
    
     
      if [ ! -d 
      "build/" ];
      then
     
    
   
    
     
    
    
       
      mkdir 
      "build"
     
    
   
    
     
    
    
     
      else
     
    
   
    
     
    
    
       
      echo 
      "exist build"
     
    
   
    
     
    
    
     
      fi
     
    
   
    
     
    
    
     
      cd build
     
    
   
    
     
    
    
     
      cmake ..
     
    
   
    
     
    
    
     
      make -j4
     
    
   
    
     
    
    
     
      sleep 1
     
    
   
    
     
    
    
     
      ./demo

如果你要测试CPU运行的性能，请修改src/main_for_crnn.cpp

DeviceType device = CPU;

如果你要测试GPU运行的性能，请修改src/main_for_crnn.cpp （需配置好OpenCL）

DeviceType device = GPU;

下面截图给出开启OpenCL加速的性能对比截图，纯C++推理模式需要耗时几秒的时间，而开启OpenCL加速后，GPU模式耗时仅需十几毫秒，性能极大的提高。

CPU
GPU

5. 车牌检测和识别效果

C++版本的opencv不支持中文显示,暂时未解决这个BUG，不过LOG会打印车牌的信息，凑合的用吧

下图GIF这是Python版本的车牌检测和识别效果，C++版本与Python版本的结果几乎是一致

6. 项目源码下载

【车牌检测和识别C/C++源码下载】智能驾驶车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》

整套项目源码内容包含：

提供YOLOv5车牌检测模型：包含快速版yolov5s05车牌检测模型，在普通手机可实时检测识别，CPU(4线程)约30ms左右，GPU约25ms左右；包含高精度版本yolov5s车牌检测模型，CPU(4线程)约250ms左右，GPU约100ms左右

提供PlateNet车牌识别模型：支持蓝牌和绿牌车牌识别

C++源码支持CPU和GPU，GPU模型加速需要配置好OpenCL，否则速度很慢

如果你想体验一下车牌检测和识别效果，可下载Android版本进行测试，Android和C++版本的车牌检测和识别核心算法是一样的

【Android APP Demo体验】Android实现车牌检测和识别-Android文档类资源-CSDN下载

更多项目《智能驾驶车牌检测和识别》系列文章请参考：

智能驾驶车牌检测和识别（一）《CCPD车牌数据集》：https://blog.csdn.net/guyuealian/article/details/128704181
智能驾驶车牌检测和识别（二）《YOLOv5实现车牌检测（含车牌检测数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704068
智能驾驶车牌检测和识别（三）《CRNN和LPRNet实现车牌识别（含车牌识别数据集和训练代码）》：https://blog.csdn.net/guyuealian/article/details/128704209
智能驾驶车牌检测和识别（四）《Android实现车牌检测和识别（可实时车牌识别）》：https://blog.csdn.net/guyuealian/article/details/128704242
智能驾驶车牌检测和识别（五）《C++实现车牌检测和识别（可实时车牌识别）》：https://blog.csdn.net/guyuealian/article/details/128704276

转载：https://blog.csdn.net/guyuealian/article/details/128704276

查看评论

小言_互联网的博客

小言_互联网的博客

个人资料

文章分类

文章存档

阅读排行

评论排行

推荐文章