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

OpenCV实战5 车牌号识别_opencv 车牌号识别c#

作者：你好赵伟 | 2024-05-23 07:29:02

赞

踩

opencv 车牌号识别c#

原文在这里，参考这个进行了改进

感觉学到了很多东西，便在这里作下笔记。

效果：

目录

一、知识点学习：

1. fstream

2. 形态学开操作与形态闭操作

2.1 第一个角度:消除较小的联通区域 vs 弥合较小的联通区域

2.2 第二个角度：消除背景噪音 vs 消除前景噪音

3、approPolyDp函数

4、冒泡排序

5、匹配目标

6、putText函数打印中文

 7、文字文件、标签文件

7.1 文字文件

7.2 标签文件

二、车牌识别代码

三、项目总结

一、知识点学习：

1. fstream

作用：输入输出文件;

例子：

  1.     fstream fin;
  2. 	fin.open(filename, ios::in);
  3. 	if (!fin.is_open())
  4. 	{
  5. 		cout << "can not open the file!" << endl;
  6. 		return false;
  7. 	}
  8.  
  9. 	string s;
  10. 	while (std::getline(fin, s))
  11. 	{
  12. 		string str = s;
  13. 		data_name.push_back(str);
  14. 	}
  15. 	fin.close();

上面用到的open函数详细介绍：

  1. void open ( const char * filename,  
  2.             ios_base::openmode mode = ios_base::in | ios_base::out );

filename 操作文件名

mode 打开文件的方式，常用的有下面这两种

  1. ios::in：　　　  //文件以输入方式打开（文件数据输入到内存）  
  2. ios::out：　　　 //文件以输出方式打开（内存数据输出到文件）

2. 形态学开操作与形态闭操作

这两个我一直不太懂，今天正好称这机会学习下。

2.1 第一个角度:消除较小的联通区域 vs 弥合较小的联通区域

形态学开运算的作用有以下这些：

  • 消除值高于邻近点的孤立点，达到去除图像中噪声的作用；
  • 消除较小的连通域，保留较大的连通域；
  • 断开较窄的狭颈，可以在两个物体纤细的连接处将它们分离；
  • 不明显改变较大连通域的面积的情况下平滑连通域的连界、轮廓；

形态学闭运算的作用有以下这些：

  • 消除值低于邻近点的孤立点，达到去除图像中噪声的作用；
  • 连接两个邻近的连通域；
  • 弥合较窄的间断和细长的沟壑；
  • 去除连通域内的小型空洞；
  • 和开运算一样也能够平滑物体的轮廓；

2.2 第二个角度：消除背景噪音 vs 消除前景噪音

开操作：消除背景噪音

 闭操作：填充前景物体中的小洞，或者前景物体上的小黑点

3、approPolyDp函数

函数的作用：对图像轮廓点进行多边形拟合

函数的的调用形式：

  1. void approxPolyDP( InputArray curve,
  2.                    OutputArray approxCurve,
  3.                    double epsilon, 
  4.                    bool closed );

 参数详解：

InputArray curve:一般是由图像的轮廓点组成的点集

OutputArray approxCurve：表示输出的多边形点集

 double epsilon：主要表示输出的精度，就是另个轮廓点之间最大距离数，5,6,7，，8，，,,，

bool closed：表示输出的多边形是否封闭

4、冒泡排序

这里有直观的动图展示：动图

这里用到冒泡排序对车牌字符的Rect进行排序：

  1.     for (size_t i =0; i< Character_ROI.size(); i++)
  2.     {
  3.         for (size_t j=0; j< Character_ROI.size() -1 -i; j++)
  4.         {
  5.             if (Character_ROI[j].rect.x > Character_ROI[j+1].rect.x)
  6.             {
  7.                 License temp = Character_ROI[j];
  8.                 Character_ROI[j] = Character_ROI[j+1];
  9.                 Character_ROI[j+1] = temp;
  10.             }
  11.         }
  12.     }

 假设有5个字符，它们的Rect的X坐标是  4 1 3 0 2, 现在用冒泡排序进行排序：

5、匹配目标

这里使用OpenCV absdiff函数计算两张图像的像素差,以此来判断图像的相似程度。

其他方法除了模板匹配，基于Hu矩轮廓匹配，基于篇幅原因就在另外博客再学习。

6、putText函数打印中文

我用的是OpenCV4.5.5,Ubuntun20.04,直接引入头文件就好了。

字体文件路径（windows系统）：

/Windows/Fonts/

然后复制到Ubuntu系统下某个目录就行了

示例：

  1. #include <iostream>
  2. #include <opencv2/freetype.hpp>
  3. #include <opencv2/opencv.hpp>
  4.  
  5. using namespace std;
  6. using namespace cv;
  7.  
  8.  
  9. int main()
  10. {
  11.     Mat src = imread("/home/jason/work/01-img/dog.png");
  12.  
  13.     string text = "中华田园犬";
  14.  
  15.     Ptr<cv::freetype::FreeType2> ft2;
  16.     ft2 = cv::freetype::createFreeType2();
  17.     ft2->loadFontData("/usr/share/fonts/winFonts/SIMYOU.TTF",0);
  18.  
  19.     ft2->putText(src, text, Point(300, 200), 30 , Scalar(0, 0,255), 2, 8, true);
  20.  
  21.     imshow("src", src);
  22.     waitKey();
  23.  
  24.     return 0;
  25. }

 7、文字文件、标签文件

向博主私信了，但是没有回复，那就自己做一个。

7.1 文字文件

wps word导出的图片：

扣出字符来：

  1. #include <iostream>
  2. #include <opencv2/opencv.hpp>
  3.  
  4. using namespace std;
  5. using namespace cv;
  6.  
  7. void Get_character(Mat & src, Mat & result)
  8. {
  9.     Mat gray;
  10.     cvtColor(src, gray, COLOR_BGR2GRAY);
  11.  
  12.     // 黑色的点
  13.     vector<Point> locations;
  14.     for (int x=0; x< src.cols; x++)
  15.         for (int y=0; y< src.rows; y++)
  16.         {
  17.  
  18.             if(gray.at<uchar>(y, x) < 255)
  19.             {
  20.                 locations.push_back(Point(x,y));
  21.             }
  22.         }
  23.  
  24.     // 字符左上角 右下角
  25.     double xmin, ymin, xmax, ymax;
  26.     vector<int> xs, ys;
  27.     for(size_t i=0; i<locations.size(); i++)
  28.     {
  29.         xs.push_back(locations[i].x);
  30.         ys.push_back(locations[i].y);
  31.  
  32.     }
  33.     Mat tempX(xs);
  34.     Mat tempY(ys);
  35.     Point p1;
  36.     minMaxLoc(tempX, &xmin, &xmax,0,0);
  37.     minMaxLoc(tempY, &ymin, &ymax, 0,0);
  38.  
  39.  
  40.     // 画框
  41.     Rect roi;
  42.     Mat temp = src.clone();
  43.     roi.x = xmin - 30;
  44.     roi.y = ymin - 30;
  45.     roi.width = xmax - xmin + 60;
  46.     roi.height = ymax - ymin + 60;
  47.     rectangle(src,roi, Scalar(255, 0,0), 1, 8);
  48.  
  49.     // 扣出来
  50.     Mat ROI = temp(roi);
  51.     imshow("ROI", ROI);
  52.     result = ROI.clone();
  53.  
  54.  
  55.     imshow("src", src);
  56.     waitKey(10);
  57. }
  58.  
  59.  
  60. int main()
  61. {
  62.  
  63.     string tail = ".png";
  64.     string head;
  65.     string path, outpath;
  66.     string outpath_head = "/home/jason/work/01-img/car/car_roi/";
  67.     for (int i=0; i<= 69; i++)
  68.     {
  69.         if (i<10)
  70.         {
  71.             head = "/home/jason/work/01-img/car/car/0";
  72.         }
  73.  
  74.         else
  75.         {
  76.             head = "/home/jason/work/01-img/car/car/";
  77.         }
  78.         path = head + to_string(i) + tail;
  79.         outpath = outpath_head + to_string(i) + tail;
  80.  
  81.         Mat src = imread(path);
  82.         Mat result;
  83.         Get_character(src, result);
  84.         imwrite(outpath,result);
  85.  
  86.     }
  87.  
  88.     return 0;
  89. }

7.2 标签文件

二、车牌识别代码

我在识别俄过程中，发现自己字母字体与车牌字体对应不上，就可能出现偏差。

怎么办？我干脆就把车牌字符扣下来保存为模板！

locate.hpp

  1. #include <iostream>
  2. #include <opencv2/opencv.hpp>
  3. #include<opencv2/freetype.hpp>
  4. #include <fstream>
  5. using namespace cv;
  6. using namespace std;
  7.  
  8.  
  9.  
  10. using namespace cv;
  11. using namespace std;
  12.  
  13. // 自定义车牌结构体
  14. struct License
  15. {
  16.     Mat mat; // ROI图片
  17.     Rect rect; // ROI所在矩形
  18. };
  19.  
  20.  
  21. class Locate
  22. {
  23. private:
  24.     // 车牌字符模板图片
  25.     vector<Mat>  Dataset;
  26.  
  27.     // 车牌字符名
  28.     vector<string> Data_name;
  29.  
  30.     // 字体文件路径
  31.     string Font_Path;
  32.  
  33.     // 车牌字符扣出来另存路径
  34.     string Character_Out_Path;
  35.  
  36.     bool Read_Data(string filename, vector<Mat>& dataset);
  37.     bool Read_Data(string filename, vector<string>&data_name);
  38.  
  39.     void Image_Preprocessing(Mat& gray, Mat& result);
  40.  
  41.     void Morphological_Process(Mat& preprocess, Mat& result);
  42.  
  43.     void Character_ROI_Preprocessing(vector<License>& License_ROI);
  44.  
  45.     void Get_License_ROI(Mat &morpho, Mat &src,
  46.                               vector<License>& License_ROI);
  47.     void Remove_vertial_Border(Mat& car_bord, Mat& result);
  48.     void Remove_Horizon_Border(Mat& car_bord, Mat & result);
  49.  
  50.  
  51. public:
  52.     bool Set_Input(string label_Path, string template_Path,
  53.                    string font_Path, string character_out_path);
  54.  
  55.     void Get_License_ROI(Mat& src, vector<License>& License_ROI);
  56.  
  57.     void Get_Character_ROI(vector<License>& License_ROI,
  58.                            vector<vector<License>>&Character_ROI,
  59.                            Mat &src, bool character_save);
  60.  
  61.     int pixCount(Mat image);
  62.  
  63.     void License_Recognition(vector<vector<License>>&Character_ROI,
  64.                              vector<vector<int>>&result_index);
  65.  
  66.     void Draw_Result(Mat &src,
  67.                      vector<License>& License_ROI,
  68.                      vector<vector<License>>&Character_ROI,
  69.                      vector<vector<int>>&result_index);
  70.  
  71. };

locate.cpp

  1. #include "Locate_License.h"
  2.  
  3.  
  4. // 读取文件 图片
  5. bool Locate::Read_Data(string filename, vector<Mat>& dataset)
  6. {
  7.     vector<String> imagePathList;
  8.     glob(filename, imagePathList); // 遍历文件夹下所有文件
  9.     if (imagePathList.empty()) return  false;
  10.  
  11.     for (size_t i=0; i<imagePathList.size(); i++)
  12.     {
  13.         cout << imagePathList[i] << endl;
  14.         Mat image = imread(imagePathList[i]);
  15.         resize(image, image, Size(50, 100), 1, 1, INTER_LINEAR);
  16.         cvtColor(image, image, COLOR_BGR2GRAY);
  17.         threshold(image, image, 0, 255, THRESH_BINARY_INV|THRESH_OTSU); // 字符需要是白色
  18.  
  19.         Mat kernel = getStructuringElement(MORPH_RECT, Size(3,3));
  20.         dilate(image, image,kernel,Point(-1,-1),1);
  21.  
  22.  
  23. //        imshow(to_string(i), image);
  24.         dataset.push_back(image);
  25.  
  26.  
  27.     }
  28.     this->Dataset = dataset;
  29.     return true;
  30. }
  31.  
  32. //读取文件 标签
  33. bool Locate::Read_Data(string filename, vector<string>&data_name)
  34. {
  35.     fstream fin;
  36.     fin.open(filename, ios::in);
  37.     if(!fin.is_open())
  38.     {
  39.         cout << "can not open the file!" << endl;
  40.         return false;
  41.     }
  42.  
  43.     string s;
  44.     while (getline(fin, s))
  45.     {
  46.         string str = s;
  47.         data_name.push_back(str);
  48.  
  49.     }
  50.     fin.close();
  51.  
  52.     this->Data_name = data_name;
  53.     return  true;
  54. }
  55.  
  56. bool Locate::Set_Input(string label_Path,
  57.                        string template_Path,
  58.                        string font_Path="/usr/share/fonts/winFonts/SIMYOU.TTF",
  59.                        string character_out_path = "/home/jason/work/01-img/car/out")
  60. {
  61.     this->Font_Path = font_Path;
  62.     printf("字体路径设置为: %s, 请检查该目录是否正确\n",font_Path.c_str());
  63.  
  64.     this->Character_Out_Path = character_out_path;
  65.     printf("车牌字符输出路径设置为: %s, 请检查该目录是否正确\n",character_out_path.c_str());
  66.  
  67.     if (Read_Data(label_Path, this->Data_name) &&
  68.             Read_Data(template_Path, this->Dataset))
  69.     {
  70.         printf("***** 成功读取模板图片、标签数据\n");
  71.         return true;
  72.     }
  73.     else
  74.     {
  75.         printf("***** err:读取模板图片、标签数据\n");
  76.         return false;
  77.     }
  78. }
  79.  
  80. // 突出字符
  81. void Locate::Image_Preprocessing(Mat& gray, Mat& result)
  82. {
  83.  
  84.     // 开操作,平滑作用，断开较窄的狭颈和消除细的突出物
  85.     Mat kernel = getStructuringElement(MORPH_RECT, Size(25,25));
  86.     Mat gray_blur;
  87.     morphologyEx(gray, gray_blur, MORPH_OPEN, kernel);
  88.     imshow("open1", gray_blur);
  89.  
  90.     // 灰度图-开操作图，突显字符等部分
  91.     Mat rst;
  92.     subtract(gray, gray_blur, rst, Mat());
  93.     imshow("rst", rst);
  94.  
  95.     // Canny算子进行边缘检测
  96.     Mat canny_Image;
  97.     Canny(rst, canny_Image, 400, 200, 3);
  98.  
  99.     imshow("canny_Image", canny_Image);
  100.  
  101.     result=canny_Image.clone();
  102. }
  103.  
  104.  
  105. // 通过膨胀连接相近的图像区域，
  106. // 利用腐蚀去除孤立细小的色块，从而将所有的车牌上所有的字符都连通起来
  107. void Locate::Morphological_Process(Mat& preprocess, Mat& result)
  108. {
  109.     // 图片膨胀处理
  110.     Mat dilate_image, erode_image;
  111.  
  112.     //自定义核：进行 x 方向的膨胀腐蚀
  113.     Mat elementX = getStructuringElement(MORPH_RECT, Size(19, 1));
  114.     Mat elementY = getStructuringElement(MORPH_RECT, Size(1, 19));
  115.     Point point(-1, -1);
  116.  
  117.     dilate(preprocess, dilate_image, elementX, point, 2);
  118.     imshow("dilate1", dilate_image);
  119.  
  120.  
  121. //    // 闭操作，避免车牌与 其他区域联通在一起
  122. //    Mat kernel = getStructuringElement(MORPH_RECT, Size(10, 10));
  123. //    morphologyEx(dilate_image, dilate_image, MORPH_OPEN,
  124. //                 kernel, Point(-1,-1),2);
  125. //    imshow("MORPH_OPEN", dilate_image);
  126.  
  127.     erode(dilate_image, erode_image, elementX, point, 3);
  128.     imshow("erode1", erode_image);
  129.  
  130.     dilate(erode_image, dilate_image, elementX, point, 2);
  131.     imshow("dialte2", dilate_image);
  132.  
  133.     //自定义核：进行 Y 方向的膨胀腐蚀
  134.     erode(dilate_image, erode_image, elementY, point, 1);
  135.     imshow("yerode", erode_image);
  136.  
  137.     dilate(erode_image, dilate_image, elementY, point, 2);
  138.     imshow("Ydilate", erode_image);
  139.  
  140.     // 平滑处理
  141.     Mat median_Image;
  142.     medianBlur(dilate_image, median_Image, 15);
  143.     imshow("median1",median_Image);
  144.  
  145.     medianBlur(median_Image, median_Image, 15);
  146.     imshow("median2", median_Image);
  147.     result = median_Image.clone();
  148. }
  149.  
  150.  
  151. // 扣出车牌
  152. void Locate::Get_License_ROI(Mat &morpho, Mat &src, vector<License>& License_ROI)
  153. {
  154.     vector<vector<Point>> contours;
  155.     findContours(morpho, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
  156.  
  157.     //
  158.     Mat temp =src.clone();
  159.     drawContours(temp, contours, -1, Scalar(255,0,0), 4);
  160.  
  161.     //
  162.     double area;
  163.     for (size_t i=0; i< contours.size(); i++)
  164.     {
  165.         // 轮廓 --》 rect
  166.         Rect rect = boundingRect(contours[i]);
  167.  
  168.         // 车牌的宽高比大约为3.3
  169.         double width_height = (double)rect.width/ (double)rect.height;
  170.         printf("height_width:%.2f\n", width_height);
  171.         if (width_height>2.5 && width_height < 4.0)
  172.         {
  173.             rectangle(temp, rect, Scalar(0,0, 255), 4, 8);
  174.             License temp_license = {src(rect), rect};
  175.             License_ROI.push_back(temp_license);
  176.         }
  177.  
  178.     }
  179.     imshow("标出车牌",temp);
  180.  
  181.     if (License_ROI.size() > 0)
  182.     {
  183.         printf("****** 共提取到 %d 块车牌\n",(int)License_ROI.size());
  184.         for (size_t i = 0; i< License_ROI.size(); i++)
  185.         {
  186.             string tempName = "第" + to_string(i) + "块车牌";
  187.             imshow(tempName, License_ROI[i].mat);
  188.         }
  189.     }
  190.     else
  191.     {
  192.         printf("****** 没有发现车牌\n");
  193.     }
  194.  
  195.  
  196.  
  197. }
  198.  
  199. // 从图片中扣出车牌
  200. void Locate::Get_License_ROI(Mat& src, vector<License>& License_ROI)
  201. {
  202.  
  203.     // 灰度图
  204.     Mat gray;
  205.     cvtColor(src, gray, COLOR_BGR2GRAY);
  206.     imshow("gray", gray);
  207.  
  208.     // 均衡化
  209.     equalizeHist(gray, gray);
  210.  
  211.  
  212.     // 突出字符，并获得canny边缘
  213.     Mat preprocess_result;
  214.     Image_Preprocessing(gray, preprocess_result);
  215.  
  216.     // 将车牌字符形成一个整体
  217.     Mat morpho_image;
  218.     Morphological_Process(preprocess_result, morpho_image);
  219.  
  220.  
  221.     // 扣出整块车牌
  222.     Get_License_ROI(morpho_image, src, License_ROI);
  223.  
  224. }
  225.  
  226.  
  227. void Locate::Remove_vertial_Border(Mat& car_bord, Mat & result)
  228. {
  229.     Mat vline = getStructuringElement(MORPH_RECT, Size(1,car_bord.rows));
  230.     Mat dst1, temp1;
  231.  
  232.     erode(car_bord, temp1, vline);
  233. //    imshow("V-erode",temp1);
  234.  
  235.     dilate(temp1, dst1, vline);
  236. //    imshow("V-dilate",dst1);
  237.  
  238.     subtract(car_bord, dst1, result, Mat());
  239. //    imshow("V-result",result);
  240. }
  241.  
  242.  
  243.  
  244.  
  245. void Locate::Remove_Horizon_Border(Mat& car_bord, Mat & result)
  246. {
  247.     Mat hline = getStructuringElement(MORPH_RECT, Size(car_bord.rows,1));
  248.     Mat dst1, temp1;
  249.  
  250.     erode(car_bord, temp1, hline);
  251. //    imshow("H-erode",temp1);
  252.  
  253.     dilate(temp1, dst1, hline);
  254. //    imshow("H-dilate",dst1);
  255.  
  256.     subtract(car_bord, dst1, result, Mat());
  257. //    imshow("H-result",result);
  258. }
  259.  
  260.  
  261. // 对整块车牌进行预处理，
  262. void Locate::Character_ROI_Preprocessing(vector<License>& License_ROI)
  263. {
  264.     for (size_t i=0; i<License_ROI.size(); i++)
  265.     {
  266.         // 灰度化
  267.         Mat gray;
  268.         cvtColor(License_ROI[i].mat, gray, COLOR_BGR2GRAY);
  269.         imshow("gray--", gray);
  270.  
  271.  
  272.  
  273. //        // 均衡化 这里不需要用，用了方而效果不好，因为车牌中车牌字符本身就很显眼，不需要用均衡
  274. //        equalizeHist(gray, gray);
  275.  
  276.  
  277.         // 大津阈值化
  278.         Mat thresh;
  279.         threshold(gray, thresh, 0, 255, THRESH_BINARY|THRESH_OTSU ); // 字是白色的的
  280.         imshow("thres", thresh);
  281.  
  282.         Mat hori;
  283.         Remove_Horizon_Border(thresh, hori);
  284.  
  285.         Mat vert;
  286.         Remove_vertial_Border(hori,vert);
  287.         imshow("H V", vert);
  288.  
  289.         Mat open;
  290.         Mat kernel = getStructuringElement(MORPH_RECT, Size(2,2));
  291.         morphologyEx(vert, open,MORPH_CLOSE, kernel, Point(-1,-1),1);
  292.         imshow("连接汉字两边", open);
  293.  
  294.         License_ROI[i].mat = open.clone();
  295.  
  296.     }
  297.  
  298. }
  299.  
  300. //
  301. void Locate::Get_Character_ROI(vector<License>& License_ROI,
  302.                                vector<vector<License>>&Character_ROI,
  303.                                Mat &src,bool character_save=true)
  304. {
  305.     Character_ROI_Preprocessing(License_ROI);
  306.     Mat temp = src.clone();
  307.  
  308.     for (size_t j=0; j<License_ROI.size(); j++)
  309.     {
  310.         Mat temp_carbod = License_ROI[j].mat.clone();
  311.         Character_ROI.push_back({}); // 必须先添加一个空项进去
  312.  
  313.  
  314.         vector<vector<Point>> contours;
  315.         findContours(License_ROI[j].mat, contours, RETR_EXTERNAL, CHAIN_APPROX_SIMPLE);
  316.         drawContours(temp, contours, -1, Scalar(255,0,0), 2, 8);
  317.         imshow("Get_Character_ROI", temp);
  318.  
  319.         for (size_t i = 0; i<contours.size(); i++)
  320.         {
  321.             double area = contourArea(contours[i]);
  322.             //由于我们筛选出来的轮廓是无序的，故后续我们需要将字符重新排序
  323.             if (area > 100)
  324.             {
  325.                 Rect rect = boundingRect(contours[i]);
  326.                 // 计算外接矩形框高比
  327.                 double ratio = double(rect.height)/ double(rect.width);
  328.                 if (ratio > 1)
  329.                 {
  330.                     // 字符扣出来
  331.                     Mat roi = License_ROI[j].mat(rect);
  332.                     resize(roi, roi, Size(50, 100), 1, 1, INTER_LINEAR);
  333.                     Character_ROI[j].push_back({roi, rect});  // 前面不添加一个空项进去，这就就报错
  334.  
  335.                     // 字符在原图画框
  336.                     rectangle(temp_carbod ,rect, Scalar(255, 0, 0), 2, 8);
  337.                     imshow("字符框",temp_carbod);
  338.  
  339.  
  340.                     // 字符另外为
  341.                     if (character_save)
  342.                     {
  343.                         threshold(roi,roi,0, 255, THRESH_BINARY_INV|THRESH_OTSU);
  344.                         string outpath = this->Character_Out_Path + "/" + to_string(i) + ".png";
  345.                         imwrite(outpath,roi);
  346.  
  347.                     }
  348.                 }
  349.             }
  350.         }
  351.  
  352.         //将筛选出来的字符轮廓 按照其左上角点坐标从左到右依次顺序排列
  353.         // 冒泡排序 ； 你查一下，用41302自己排下序就懂了
  354.         for (size_t k =0; k<Character_ROI.size(); k++)
  355.         {
  356.             for (size_t ii =0; ii< Character_ROI[k].size(); ii++)
  357.             {
  358.                 for (size_t jj=0; jj< Character_ROI[k].size() -1 -ii; jj++)
  359.                 {
  360.                     if (Character_ROI[k][jj].rect.x > Character_ROI[k][jj+1].rect.x)
  361.                     {
  362.                         License temp = Character_ROI[k][jj];
  363.                         Character_ROI[k][jj] = Character_ROI[k][jj+1];
  364.                         Character_ROI[k][jj+1] = temp;
  365.                     }
  366.                 }
  367.             }
  368.         }
  369.  
  370.     }
  371.  
  372.     if (Character_ROI.size() > 0)
  373.     {
  374.         for (size_t k =0; k<Character_ROI.size(); k++)
  375.         {
  376.             printf("******* 第 %d 块车牌共扣出： %d 个字符\n", (int)k,(int)Character_ROI[k].size());
  377.         }
  378.     }
  379.     else
  380.     {
  381.         printf("***** err :第车牌没有扣出字符！\n");
  382.  
  383.     }
  384.  
  385. }
  386.  
  387.  
  388.  
  389. int Locate::pixCount(Mat image)
  390. {
  391.     int count =0;
  392.     if (image.channels() == 1)
  393.     {
  394.         for (int i=0; i<image.rows; i++)
  395.         {
  396.             for (int j=0; j<image.cols; j++)
  397.             {
  398.                 if (image.at<uchar>(i, j) == 255) // 数的是白色像素
  399.                 {
  400.                     count++;
  401.                 }
  402.             }
  403.         }
  404.         return count;
  405.     }
  406.     else
  407.     {
  408.         return -1;
  409.     }
  410. }
  411.  
  412. // 识别车牌字符
  413. // 使用OpenCV absdiff函数计算两张图像的像素差,以此来判断图像的相似程度
  414. // 进行字符匹配的方法还有：模板匹配，基于Hu矩轮廓匹配
  415. void Locate::License_Recognition(vector<vector<License>>&Character_ROI,
  416.                                  vector<vector<int>>& result_inedx)
  417. {
  418.  
  419.     for (size_t k =0; k<Character_ROI.size(); k++)
  420.     {
  421.         result_inedx.push_back({});
  422.  
  423.         for (int i=0; i<Character_ROI[k].size(); i++)
  424.         {
  425.             // 车牌单个字符预处理
  426.             Mat roi_thresh;
  427.             threshold(Character_ROI[k][i].mat, roi_thresh, 0, 255, THRESH_BINARY_INV); // 车牌字符需是白色
  428.             string car = "car" + to_string(i);
  429.             imshow(car,roi_thresh);
  430.  
  431.  
  432.             int minCount = 1000000000;
  433.             int index = 0;
  434.  
  435.             for (int j=0; j < this->Dataset.size(); j++)
  436.             {
  437.  
  438.                 // 计算车牌字符与模板的像素差，以此判断两张图片是否相同
  439.                 Mat templa = this->Dataset[j];
  440.                 Mat dst;
  441.                 absdiff(roi_thresh, templa, dst);
  442.  
  443.  
  444.                 // 白字黑底，两图像素相减，白色像素越少，两图越接近
  445.                 int  count = pixCount(dst);
  446.                 if (count< minCount)
  447.                 {
  448.                     minCount = count;
  449.                     index = j;
  450.                 }
  451.     //            imshow(to_string(j),dst);
  452.             }
  453.             string p = "templ" + to_string(i);
  454.             imshow(p, this->Dataset[index]);
  455.             result_inedx[k].push_back(index);
  456.         }
  457.     }
  458.  
  459.     printf("*****共对 %d 块车牌的字符完成字符匹配\n",(int)Character_ROI.size());
  460.  
  461. }
  462.  
  463.  
  464. // 显示最终效果
  465. void Locate::Draw_Result(Mat &src, vector<License> &License_ROI,
  466.                          vector<vector<License>>&Character_ROI,
  467.                  vector<vector<int>>&result_index)
  468. {
  469.     Ptr<cv::freetype::FreeType2> ft2;
  470.     ft2 = cv::freetype::createFreeType2();
  471.  
  472.     ft2->loadFontData(this->Font_Path,0);
  473.  
  474.     for (size_t k=0; k<License_ROI.size(); k++)
  475.     {
  476.  
  477.         // 原图上框出车牌
  478.         rectangle(src, License_ROI[k].rect, Scalar(0, 255, 0), 2);
  479.  
  480.         // 在原图车牌框上方上打印车牌字符
  481.         for (size_t i=0; i< Character_ROI[k].size(); i++)
  482.         {
  483.     //        cout << data_name[result_index[i]] << " ";
  484.             string str = this->Data_name[result_index[k][i]];
  485.             ft2->putText(src, str,
  486.                          Point(License_ROI[k].rect.x + Character_ROI[k][i].rect.x,
  487.                                License_ROI[k].rect.y - Character_ROI[k][i].rect.y),
  488.                          30,Scalar(255, 0, 0), 1, 8, true);
  489.         }
  490.     //    cout  << endl;
  491.     }
  492.  
  493. }

main.cpp

  1. #include "Locate_License.h"
  2.  
  3.  
  4.  
  5. int main()
  6. {
  7.  
  8.     Mat src = imread("/home/jason/work/01-img/car.png");
  9.     if (src.empty())
  10.     {
  11.         cout << "No image!" << endl;
  12.         system("pause");
  13.         return -1;
  14.     }
  15.  
  16.     Locate locate;
  17.     locate.Set_Input("/home/jason/work/01-img/car/car.txt",
  18.                      "/home/jason/work/01-img/car/template",
  19.                      "/usr/share/fonts/winFonts/SIMYOU.TTF",
  20.                      "/home/jason/work/01-img/car/out");
  21.  
  22.     vector<License> License_ROI;
  23.     locate.Get_License_ROI(src, License_ROI);
  24.  
  25.     vector<vector<License>> Character_ROI;
  26.     locate.Get_Character_ROI(License_ROI, Character_ROI,
  27.                              src, true);
  28.  
  29.     vector<vector<int>> result_index;
  30.     locate.License_Recognition(Character_ROI,result_index);
  31.  
  32.     locate.Draw_Result(src, License_ROI,
  33.                        Character_ROI, result_index);
  34.  
  35.     imshow("车牌识别结果", src);
  36.     waitKey();
  37.  
  38.  
  39.  
  40.  
  41.  
  42.  
  43.     return 0;
  44. }

想要模板图片文件和标签文件可以在评论区留言或者私信我，上传在CSDN还得是VIP你们才能下载。

三、项目总结

代码思路：

  1. 获取整个车牌  （这里部分涉及预处理很有意思）
  2. 对车牌进行切割，获得7个字符
  3. 将获得的车牌字符与模板匹配

项目不足：

  1. 本项目仅仅对车牌字符为白色的车牌有用
  2. 未对车牌作旋转矫正【p1, p2】，透视矫正，这两个因素影响很大，后面有空再补上

ps: 这个项目做了好几天，cpp文件干到了500行，原文才300行，增加近一半代码，短时间不想改了

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

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

  

闽ICP备14008679号