0


实战:QT车牌识别系统综合设计

   该系统是博主结合许多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);
}

效果如下:

三、图片识别

    车牌识别除了字符串提取的难点另一个难点就是识别,识别的话,我是自己准备了一个训练集,每个训练集中包含了多种数据![](https://img-blog.csdnimg.cn/b4a6424a8d0547f1833418ab30825f72.png)

    将每个图文文件中图片的路径保存在列表当中

之后使用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建攻 所有, 如有侵权,请联系我们删除。

“实战:QT车牌识别系统综合设计”的评论:

还没有评论