该系统是博主结合许多QT开发项目综合制作，借用了Opencv的开发库来完成的一个项目，具体的可以按照目录来，关于识别方面仅仅提供一个思路，目前还在想如何去优化（准备采用神经网络将数据集拟合，减少时间复杂度，目前还在实现...）。因为识别时间太长会很影响效率，具体的安装我不在这里讲解
QT版本：5.9.9
Opencv: 4.5.1
一、车牌提取
1、图像预处理
首先我们将图像读取出来用imread函数输入图片路径
Mat image = imread("D:\\qthome\\test_car\\test2.png");
之后我们将图像进行高斯去噪去除一些图像的杂质，之后灰度处理转化成黑白图，进行边缘检测将车牌的轮廓检测出来，使用自适应阀值使图像的灰度大于阀值以便跟好的提取
Mat img_HSV;//原图
GaussianBlur(img_HSV, img2_gauss, Size(3, 3), 0);//高斯去噪
cvtColor(img2_gauss, img2_gray, COLOR_BGR2GRAY);//灰度处理
/*边缘检测*/
Sobel(img2_gray, dst_x, CV_16S, 1, 0); //梯度算子
convertScaleAbs(dst_x, abs_X); //将CV_16S型的输出图像转变成CV_8U型的图像
Mat img_temo = abs_X;
threshold(img_temo, img_temo, 0, 255, THRESH_OTSU); //自适应阀值图像灰度大于阈值
imshow("tests",img_temo);
效果如下：
2、轮廓封闭提取
首先对矩形进行封闭操作，长宽比为17:5，然后进行膨胀和腐蚀，将腐蚀的面积扩大，具体的使用函数如下：
图像膨胀：
图像腐蚀：
2个函数的意思相近，基本上都是输入原图，然后用一个相同类型的变量去接收，第三个参数进行怎样的处理，具体腐蚀几下和膨胀几下根据效果来
// 闭操作,封闭轮廓
Mat kernelY;
Mat kernelX = getStructuringElement(MORPH_RECT, Size(17, 5)); //构造一个矩形
morphologyEx(img_temo, img_temo, MORPH_CLOSE, kernelX);
//用矩形来封闭
kernelX = getStructuringElement(MORPH_RECT,Size(20, 1));
kernelY = getStructuringElement(MORPH_RECT,Size(1, 19));
dilate(img_temo, img_temo, kernelX); //图像膨胀
dilate(img_temo, img_temo, kernelX);
erode(img_temo, img_temo, kernelX); //图像腐蚀
erode(img_temo, img_temo, kernelY);
dilate(img_temo, img_temo, kernelY);
// 平滑去噪处理，使边缘检测更准确
GaussianBlur(img_temo, img_temo, Size(15, 0), 1);
效果如下：
随后将轮廓在原图勾画出来
vector<vector<Point>> contours;
vector<Vec4i> vec_4f;
// 从二值化后的img图中提取所有轮廓
findContours(img_temo, contours, vec_4f, RETR_TREE, CHAIN_APPROX_SIMPLE);
// 在原图image上绘制所有轮廓(红色)
drawContours(image, contours, -1, Scalar(0, 0, 255), 1);
imshow("car_num",image);
3、车牌号提取
将区域进行比对筛选，选择长宽比例为1:2.3（这个参数具体可以设置，根据自己的感觉来，不一定参考这个）面积选择10000左右的即可
Mat chepai;
int j = 0;
for (int i = 0; i < contours.size(); i++)
{
//计算轮廓的垂直边界最小矩形
Rect rect = boundingRect(contours[i]);
int x = rect.x;
int y = rect.y;
int area = rect.height * rect.width;
if ((rect.width > (rect.height * 2.3) )&& area > 10000)
{
chepai = img_HSV(Rect(rect.x,rect.y,rect.width,rect.height)); //区域提取
//将提取出来的区域拿绿色矩形围起来
rectangle(chepai,Point(rect.x,rect.y),Point(rect.x + rect.width, rect.y + rect.height),Scalar(0,255,0),1);
}
}
最后车牌也被提取了出来
效果如下：
车牌提取的完整代码：
Mat getcarnumber_Border(Mat image)
{
Mat img_HSV = image.clone();//复制
Mat img_t = image.clone();
Mat img2_gauss;
Mat img2_gray,dst_x,abs_X;
//高斯去噪
GaussianBlur(img_HSV, img2_gauss, Size(3, 3), 0);
cvtColor(img2_gauss, img2_gray, COLOR_BGR2GRAY);
Sobel(img2_gray, dst_x, CV_16S, 1, 0); //梯度算子
convertScaleAbs(dst_x, abs_X); //将CV_16S型的输出图像转变成CV_8U型的图像
imshow("tests1",dst_x);
Mat img_temo = abs_X;
threshold(img_temo, img_temo, 0, 255, THRESH_OTSU); //用这个函数，自适应阀值图像灰度大于阈值
imshow("tests",img_temo);
// 闭操作,封闭轮廓
Mat kernelY;
Mat kernelX = getStructuringElement(MORPH_RECT, Size(17, 5)); //构造一个矩形
morphologyEx(img_temo, img_temo, MORPH_CLOSE, kernelX);
//用矩形来封闭
kernelX = getStructuringElement(MORPH_RECT,Size(20, 1));
kernelY = getStructuringElement(MORPH_RECT,Size(1, 19));
dilate(img_temo, img_temo, kernelX); //图像膨胀
dilate(img_temo, img_temo, kernelX);
erode(img_temo, img_temo, kernelX); //图像腐蚀
erode(img_temo, img_temo, kernelY);
dilate(img_temo, img_temo, kernelY);
// 平滑去噪处理，使边缘检测更准确
GaussianBlur(img_temo, img_temo, Size(15, 0), 1);
//imshow("car_num",img_temo);
vector<vector<Point>> contours;
vector<Vec4i> vec_4f;
// 从二值化后的img图中提取所有轮廓
findContours(img_temo, contours, vec_4f, RETR_TREE, CHAIN_APPROX_SIMPLE);
// 在原图image上绘制所有轮廓(红色)
// drawContours(image, contours, -1, Scalar(0, 0, 255), 1);
// imshow("car_num",image);
//筛选
Mat chepai;
int j = 0;
vector<vector<Point>>contours_1;
Rect rect_1;
for (int i = 0; i < contours.size(); i++)
{
//计算轮廓的垂直边界最小矩形
Rect rect = boundingRect(contours[i]);
int x = rect.x;
int y = rect.y;
int area = rect.height * rect.width;
if ((rect.width > (rect.height * 2.3) )&& area > 10000)
{
chepai = img_HSV(Rect(rect.x,rect.y,rect.width,rect.height)); //区域提取
//将提取出来的区域拿绿色矩形围起来
rectangle(chepai,Point(rect.x,rect.y),Point(rect.x + rect.width, rect.y + rect.height),Scalar(0,255,0),1);
rect_1 = rect;
contours_1.push_back(contours[i]);
}
}
// drawContours(img_t, contours_1, -1, Scalar(0, 0, 255), 1);
// imshow("sda",chepai);
//对倾斜车牌进行处理操作
// vector<Point> cnt = contours_1[contours_1.size() - 1];
// Vec4f d;
// fitLine(cnt,d,DIST_L2,0,0.01,0.01);
// double k = d[1] / d[0];
// double b = d[2] - d[3] * k;
// double w = img_t.size().width;
// double h = img_t.size().height;
// double lefty = b;
// double righty = k*w+b;
// double a = atan(k);
// a = a*180/3.1415926;
// Mat m = getRotationMatrix2D(Point(w/2,h/2),a,0.8);
// Mat dst;
// warpAffine(img_t,dst,m,Size((int(w*0.9)),(int(h*0.9))));
// dst = do_line(dst);
// if(dst.empty()){
// return chepai;
// }
return chepai;
}
二、车牌字符串切割
1、车牌号码处理
车牌号码提取出来之后我们也要对他进行相同的如以上相同的处理，最后转化为黑白图，但重点不同的是蓝牌、黄牌以及新能源汽车的车牌型号都不同，为此我们对像素点进行将车牌彻底转化为背景为黑色，字为白色的情况
效果1（蓝色车牌的黑白图）：
效果2（新能源车牌的黑白图）：
所以就统计了黑白像素点的个数，确保黑像素点个数大于白像素点个数，否则进行翻转
Mat Get_License_ROI(Mat src)
{
Mat gray;
cvtColor(src, gray, COLOR_BGR2GRAY);
Mat thresh;
threshold(gray, thresh, 0, 255, THRESH_OTSU);
//使用形态学开操作去除一些小轮廓
Mat kernel = getStructuringElement(MORPH_RECT, Size(2, 2));
Mat open;
morphologyEx(thresh, open, MORPH_OPEN, kernel);
//下面是我自己写的，这个可以自己去实现
int black = PixelCounter(open,2);
int white = PixelCounter(open,1);
qDebug()<<"黑像素点"<<black<<"白像素点"<<white;
if(black < white){
threshold(open, open, 0, 255, THRESH_OTSU|THRESH_BINARY_INV);
}
return open;
}
效果如下：
2、水平切割去除多余的边框
我是采取将每一行的白像素点求一个极限阀值，然后从中间一行往两边延伸，当碰到一个阀值时候就停止扩展，因为如上图，白色边框的白像素的个数明显多余中间的白像素点，最后为了方便切割提取将字符膨胀
代码：
Mat Horizon_Cut(Mat image){
Mat temp = image.clone();
int rows = temp.rows;
int cols = temp.cols;
QVector<int> white_n;
for(int row = 0;row < rows;row++){
int tem = 0;
for(int col = 0;col < cols;col++){
if(temp.at<uchar>(row, col) > 0){
tem++;
}
}
white_n.append(tem);
}
int mid = 0;
for(int i = 0;i < rows/2;i++){
mid += white_n[i];
}
mid = mid/(rows/2 + 1);
int i_0;
int i_1;
for(int i = rows/2 ;i >= 2; i--){
if(white_n[i] < mid){
i_0 = i;
break;
}
}
for(int i = rows/2;i < rows; i++){
if(white_n[i] < mid){
i_1 = i;
break;
}
}
Mat t_est = temp(Range(i_0,i_1),Range(0,cols));
return t_est;
}
效果如下：
3、字符串逐步提取
我是采取从左往右进行逐步遍历切割，腐蚀膨胀后的字符串白像素点的间隔明显很大，这个可以注释慢慢去比对，一定距离进行切割，保存每个字符的前后2列数据即可
QVector<QVector<int> > Remove_Vertial_Border(Mat image)
{
Mat temp = image.clone();
int rows = temp.rows;
int cols = temp.cols;
QVector<int> white_n;
for(int col = 0;col < cols;col++){
int tem = 0;
for(int row = 0;row < rows;row++){
if(temp.at<uchar>(row, col) > 0){
tem++;
}
}
white_n.append(tem);
}
QVector<QVector<int> > region1;
QVector<int> reg;
int flag = 0;
if(white_n[0] != 0){
reg.append(0);
}
for(int i = 0;i<cols - 1;i++){
if(white_n[i] == 0 && white_n[i + 1] != 0){
reg.append(i);
}
if(white_n[i] != 0 && white_n[i + 1] == 0){
reg.append(i + 1);
}
if(reg.size() == 2){
if(reg[1] - reg[0] > 10){
region1.append(reg);
reg.clear();
}else{
reg.clear();
}
}
}
return region1;
}
之后将保存的每一个字符元素返回，写入新的文件夹
QVector<QVector<int> > t = Remove_Vertial_Border(car_gray);
int j = 0;
for (int i = 0; i < t.size(); i++)
{
Mat str = car_gray(Range(0,car_gray.rows),Range(t[i][0],t[i][1]));
j++;
QString t_s = QString::number(j);
string s = string((const char *)t_s.toLocal8Bit());
imwrite("D:\\qthome\\test_car\\car_each_number\\"+s+".jpg",str);
}
效果如下：
三、图片识别
车牌识别除了字符串提取的难点另一个难点就是识别，识别的话，我是自己准备了一个训练集，每个训练集中包含了多种数据
将每个图文文件中图片的路径保存在列表当中
之后使用MatchTemplate函数讲每个图片进行比对（也许这里很大程度增加了时间复杂度，但是我目前是保证能做出来优先，时间复杂度之后慢慢优化）
而method方法有很多
cv::TM_SQDIFF：该方法使用平方差进行匹配，因此最佳的匹配结果在结果为0处，值越大匹配结果越差。
cv::TM_SQDIFF_NORMED：该方法使用归一化的平方差进行匹配，最佳匹配也在结果为0处。
cv::TM_CCORR：相关性匹配方法，该方法使用源图像与模板图像的卷积结果进行匹配，因此，最佳匹配位置在值最大处，值越小匹配结果越差。
cv::TM_CCORR_NORMED：归一化的相关性匹配方法，与相关性匹配方法类似，最佳匹配位置也是在值最大处。
cv::TM_CCOEFF：相关性系数匹配方法，该方法使用源图像与其均值的差、模板与其均值的差二者之间的相关性进行匹配，最佳匹配结果在值等于1处，最差匹配结果在值等于-1处，值等于0直接表示二者不相关。
cv::TM_CCOEFF_NORMED：归一化的相关性系数匹配方法，正值表示匹配的结果较好，负值则表示匹配的效果较差，也是值越大，匹配效果也好。
这里可以选择自己喜欢的，我是选择了第5个
double do_read(Mat temo,Mat temp){
int height = temo.size().height;
int width = temo.size().width;
Mat image = temp.clone();
resize(image,image,Size(width,height));
Mat result;
matchTemplate(image,temo,result,TM_CCOEFF);
//求解最大值
double minValue, maxValue;
Point minLocation, maxLocation;
Point matchLocation;
minMaxLoc(result, &minValue, &maxValue, &minLocation, &maxLocation);
return maxValue;
}
车牌里面没有I和O目的就是为了区分0和1而汉字只在第一个出现，后面的则是一些字符所以我进行了分开识别，最后找到该图片中最大相似度的坐标（最大坐标函数是我自己写的，这里我就不详写了）进行锁定
void shibie(){
Mat temp = imread("D:\\qthome\\car_stop_t\\car_each_number\\1.jpg");
cvtColor(temp, temp, COLOR_BGR2GRAY);
threshold(temp, temp, 0, 255, THRESH_OTSU);
QString str;
QVector<double> score;
for(int i = 0;i < 31;i++){
double Max = 0;
for(int j = 0;j < chinese_str[i].size();j++){
string str = string((const char *)chinese_str[i][j].toLocal8Bit());
Mat temo = imread(str);
cvtColor(temo,temo,COLOR_RGB2GRAY);
threshold(temo,temo,0,255,THRESH_OTSU);
double maxValue = do_read(temo,temp);
if(maxValue > Max) Max = maxValue;
}
score.append(Max);
}
int posmax = Max_index(score);
str.append(chineses[posmax]);
for(int i = 2;i <= 8;i++){
QString str_1 = "D:\\qthome\\car_stop_t\\car_each_number\\"+QString::number(i)+".jpg";
temp = imread(string((const char *)str_1.toLocal8Bit()));
cvtColor(temp, temp, COLOR_BGR2GRAY);
threshold(temp, temp, 0, 255, THRESH_OTSU);
score.clear();
for(int i = 0;i < 34;i++){
double Max = 0;
for(int j = 0;j < char_str[i].size();j++){
string str = string((const char *)char_str[i][j].toLocal8Bit());
Mat temo = imread(str);
cvtColor(temo,temo,COLOR_RGB2GRAY);
threshold(temo,temo,0,255,THRESH_OTSU);
double maxValue = do_read(temo,temp);
if(maxValue > Max) Max = maxValue;
}
score.append(Max);
}
posmax = Max_index(score);
str.append(chars[posmax]);
}
qDebug()<<str;
}
效果展示：
四、总结：
1、项目中整体难点在于车牌处理以及像素点的切割，合理的处理这些对后续的切割有很大帮助
2、字符串的识别速率还有待提高，但是精度方面的话已经完善
最后给观看的人看一个系统雏形旁边的mv纯纯是为了区别识别慢，这个还需要突破，希望还是能带来帮助
本文转载自: https://blog.csdn.net/qq_54395977/article/details/125921456
版权归原作者 small建攻 所有， 如有侵权，请联系我们删除。
版权归原作者 small建攻 所有， 如有侵权，请联系我们删除。