opencv实现车牌识别之字符分割

最新推荐文章于 2021-09-03 17:29:11 发布
最新推荐文章于 2021-09-03 17:29:11 发布
阅读量3.3k 收藏 9
点赞数 1
分类专栏： 图像算法

简介

　　在前一篇中，我们已经定位出来了在图片中车牌号的位置，并且将车牌号图片复制成了新图片，并显示出来，本章在这些被截取出来的图片上继续处理。
截取出来的新图片如下：


图像灰阶/二值化

　　首先也是选择将图像进行灰阶，然后采用以255一遍开始，取占了总pixel为5%的地方作为阀值，进行二值化。
代码如下：
  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     在CODE上查看代码片
     
     派生到我的代码片
     
     

    
    

   
   

   
   
  1. #include <opencv2/core/core.hpp>  
  2. #include <opencv2/highgui/highgui.hpp>  
  3. #include <math.h>  
  4. #include <string.h>  
  5. #include <opencv/cv.h>  
  6. #include <stdio.h>  
  7. #include "lib/normal.h"  
  8. #include "lib/cutchar.h"  
  9.    
  10. #define DEBUG  
  11.    
  12. #ifdef DEBUG  
  13. #define DE(format, ...) printf(format, ## __VA_ARGS__)  
  14. #else  
  15. #define DE(format, ...) while(0)  
  16. #endif  
  17.    
  18. int main(int argc, char** argv){  
  19.     Mat img, img_2, img_3, img_4, img_5, img_w;  
  20.     IplImage pI_1;  
  21.     IplImage pI_2;  
  22.     int width, reWidth=30, wWidth=20, pic_width;  
  23.     int height, reHeight=100, wHeight = 20;  
  24.     char str[2];  
  25.     int i = 0, j = 0, k;  
  26.     int threshold = 0, pic_ArrNumber, tmp;  
  27.     int vArr[reHeight];  
  28.     int **pic_Arr;  
  29.     CvScalar s1;  
  30.     float percentage = 0.0;  
  31.    
  32.     if(argc < 2){  
  33.         DE("Please input argv[1]\n");  
  34.         return -1;  
  35.     }  
  36.     img = cv::imread(argv[1]);  
  37.    
  38.     namedWindow(str);  
  39.     imshow(str, img);  
  40.    
  41.     width = img.rows;  
  42.     height = img.cols;  
  43.    
  44.     pic_gray(img, img_2);  
  45.     threshold = histogram_Calculate(img_2, 5);  
  46.     DE("threshold:%d\n",threshold);  
  47.    
  48.     pic_Thresholding(img_2, threshold);  
  49.     sprintf(str, "%d", i+1);  
  50.     namedWindow(str);  
  51.     imshow(str, img_2);  
  52.    
  53.     waitKey(0);  
  54.     return 0;  
  55. }  

  
  
　　首先装载截取出来的车牌号图片到img，然后pic_gray进行灰阶化到img_2,接着计算出5%时候的pixel阀值threshold，最后对灰阶图像img_2进行二值化操作。
结果显示如下：


上下边缘分离

　　从图片和周围，我们知道车牌号的四周被白色的边框包围着，所以我们需要排除掉这部分干扰，这里我们首先来去除掉边框的上线边缘干扰。
代码如下：
  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     在CODE上查看代码片
     
     派生到我的代码片
     
     

    
    

   
   

   
   
  1. int detectionChange(Mat& mat1, Mat& mat2, int number){  
  2.     IplImage pI_1 = mat1, pI_2;  
  3.     CvScalar s1, s2;  
  4.     int width = mat1.rows;  
  5.     int height = mat1.cols;  
  6.     int sum = 0, sum_2 = 0, width_1 = 0, width_2 = 0;  
  7.     int i, j;  
  8.    
  9.     for(i=0; i<width; i++){  
  10.         sum = 0;  
  11.         sum_2 = 0;  
  12.         for(j=0; j<height-1; j++){  
  13.             s1 = cvGet2D(&pI_1, i, j);  
  14.             s2 = cvGet2D(&pI_1, i, j+1);  
  15.             if(((int)s1.val[0]) != ((int)s2.val[0])){  
  16.                 sum += 1;  
  17.                 sum_2 = 0;  
  18.             }else{  
  19.                 sum_2 += 1;   
  20.             }  
  21.             if(sum_2 != 0){  
  22.                 if(height / sum_2 < 5){  
  23.                     sum = 0;  
  24.                     break;  
  25.                 }  
  26.             }  
  27.         }  
  28.         if(sum >= number){  
  29.             width_1 = i;  
  30.             break;  
  31.         }else{  
  32.             width_1 = i;      
  33.         }  
  34.     }  
  35.    
  36.     for(i=width-1; i> 0; i--){  
  37.         sum = 0;  
  38.         sum_2 = 0;  
  39.         for(j=0; j<height-1; j++){  
  40.             s1 = cvGet2D(&pI_1, i, j);  
  41.             s2 = cvGet2D(&pI_1, i, j+1);  
  42.             if(((int)s1.val[0]) != ((int)s2.val[0])){  
  43.                 sum += 1;  
  44.                 sum_2 = 0;  
  45.             }else{  
  46.                 sum_2 += 1;   
  47.             }  
  48.             if(sum_2 != 0){  
  49.                 if(height / sum_2 < 1){  
  50.                     sum = 0;  
  51.                     break;  
  52.                 }  
  53.             }  
  54.         }  
  55.         if(sum >= number){  
  56.             width_2 = i;  
  57.             break;    
  58.         }else{  
  59.             width_2 = i;  
  60.         }  
  61.     }  
  62.     if(width_2 <= width_1){  
  63.         width_2 = width;      
  64.     }  
  65.     mat2 = cv::Mat(width_2 - width_1 + 1, height, CV_8UC1, 1);  
  66.     pI_2 = mat2;  
  67.     for(i=width_1; i<= width_2; i++){  
  68.         for(j=0; j<height; j++){  
  69.             s1 = cvGet2D(&pI_1, i, j);  
  70.             cvSet2D(&pI_2, i-width_1, j, s1);  
  71.         }     
  72.     }  
  73. }  
  74.    
  75. int main(int argc, char** argv){  
  76.     pic_Thresholding(img_2, threshold);  
  77.    
  78.     sprintf(str, "%d", i+1);  
  79.     namedWindow(str);  
  80.     imshow(str, img_2);  
  81.    
  82.         detectionChange(img_2, img_3, 7);  
  83.    
  84.     sprintf(str, "%d", i+2);  
  85.     namedWindow(str);  
  86.     imshow(str, img_3);  
  87.    
  88.     waitKey(0);  
  89.     return 0;  
  90. }  

  
  
　　重点就是函数detectionChange，在这个函数中主要是进行那个判断，首先判断一行中，是否有连续的255像素大于了一定该行宽度的一定比例，
正常的牌照单个字符，它的字符宽度肯定小于整个车牌宽度的1/6；然后还判断一行中pixel从0到255或者从255到0的跳变有没有大于一定的数量，在
车牌号所在的行中，该跳变至少是7次。
　　detectionChange中首先将img_2从头开始扫描，找到车牌号真正开始的行头。然后反过来，从尾部开始扫描，找到车牌字符真正结束时候的尾部。
最后将这部分图像，复制到img_3中。
　　图像结果显示如下：



字符分割

　　经过如上之后，接着就是根据车牌图片的垂直投影宽度和积累的数值，进行字符分割。
具体代码如下：
  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     在CODE上查看代码片
     
     派生到我的代码片
     
     

    
    

   
   

   
   
  1. void verProjection_calculate(Mat& mat1, int* vArr, int number){  
  2.     IplImage pI_1 = mat1;  
  3.     CvScalar s1;  
  4.     int width = mat1.rows;  
  5.     int height = mat1.cols;  
  6.     int i, j;  
  7.    
  8.     for(i=0; i< number; i++){  
  9.         vArr[i] = 0;      
  10.     }  
  11.    
  12.     for(j=0; j<height; j++){  
  13.         for(i=0; i<width; i++){  
  14.             s1 = cvGet2D(&pI_1, i, j);  
  15.             if(s1.val[0] > 20){  
  16.                 vArr[j] += 1;                 
  17.             }     
  18.         }  
  19.     }  
  20. }  
  21.    
  22. int** verProjection_cut(int* vArr, int width, int* number){  
  23.     int **a;  
  24.     int i, flag = 0;  
  25.     int num = 0;  
  26.     int threshold = 2;  
  27.    
  28.     a = (int**)malloc(width / 2 * sizeof(int*));  
  29.    
  30.     for(i=0; i<width-1; i++){  
  31.         if((vArr[i] <= threshold) && (vArr[i+1] > threshold)){  
  32.             a[num] = (int* )malloc(2 * sizeof(int));  
  33.             a[num][0] = i;  
  34.             flag = 1;  
  35.         }else if((vArr[i] > threshold) && (vArr[i+1] <= threshold) && (flag != 0)){  
  36.             a[num][1] = i;  
  37.             num += 1;  
  38.             flag = 0;  
  39.         }  
  40.     }  
  41.     *number = num;  
  42.    
  43.     return a;  
  44.    
  45. int main(int argc, char** argv){  
  46.     int width, reWidth=30, wWidth=20, pic_width;  
  47.     int height, reHeight=100, wHeight = 20;  
  48.    
  49.     ................  
  50.     carCard_Resize(img_3, img_4, reWidth, reHeight);  
  51.     pic_Thresholding(img_4, 60);  
  52.     pI_1 = img_4;  
  53.    
  54.     verProjection_calculate(img_4, vArr, reHeight);  
  55.     pic_Arr = verProjection_cut(vArr, reHeight, &pic_ArrNumber);  
  56.    
  57.     for(i=0; i< pic_ArrNumber; i++){  
  58.         printf("pic_Arr[%d]:%d, %d\n", i, pic_Arr[i][0], pic_Arr[i][1]);                                                               
  59.     }  
  60.     sprintf(str, "%d", i+3);  
  61.     namedWindow(str);  
  62.     imshow(str, img_4);  
  63.    
  64.     waitKey(0);  
  65.     return 0;  
  66. }  

  
  
　　这一步中，首先将消除了上下边缘的img_3，放大保存到img_4(reWidth=30,reHeight=100)，接着将放大后图片img_4从新以阀值60来二值化,接着用
verProjection_calculate计算出img_4的垂直投影数据，保存到一维数组vArr中；然后verProjection_cut函数利用垂直投影数据vArr来分割出字符宽度。
在verProjection_cut中，到某一列的垂直投影数据小于等于2，就表示该位置不是字符。
　　打印出来的字符分割宽度位置和图像表现如下：


后续处理

　　在宽度分割出来之后，就可以在img_4上将对应的字符图片分割复制出来，然后在排除掉左右两边的边缘干扰和车牌的中间那一点的干扰，就获取到了合适的
车牌字符图片了。对应代码如下：
  
  

   
   

    
    

     
     [cpp] 
     
     view plain
     
     copy
     
     在CODE上查看代码片
     
     派生到我的代码片
     
     

    
    

   
   

   
   
  1. float pixelPercentage(Mat& mat1){  
  2.     IplImage pI_1 = mat1;  
  3.     CvScalar s1;  
  4.     int width = mat1.rows;  
  5.     int height = mat1.cols;  
  6.     int i, j;  
  7.     float sum = 0, allSum = 0, tmp;  
  8.    
  9.     for(i=0; i<width; i++){  
  10.         for(j=0; j<height; j++){  
  11.             s1 = cvGet2D(&pI_1, i, j);  
  12.             if(s1.val[0] > 20){  
  13.                 sum += 1;  
  14.             }  
  15.             allSum += 1;  
  16.         }     
  17.     }  
  18.     tmp = sum / allSum;  
  19.    
  20.     return tmp;  
  21. }   
  22.    
  23. int main(int argc, char** argv){  
  24.     ......................  
  25.     verProjection_calculate(img_4, vArr, reHeight);  
  26.     pic_Arr = verProjection_cut(vArr, reHeight, &pic_ArrNumber);  
  27.    
  28.     for(i=0; i< pic_ArrNumber; i++){  
  29.         pic_width = pic_Arr[i][1] - pic_Arr[i][0];  
  30.         if(pic_width < 3){  
  31.             continue;  
  32.         }  
  33.    
  34.         img_5 = cv::Mat(reWidth, pic_Arr[i][1] - pic_Arr[i][0], CV_8UC1, 1);  
  35.         pI_2 = img_5;  
  36.         for(j=0; j<reWidth; j++){  
  37.             for(k=pic_Arr[i][0]; k<pic_Arr[i][1]; k++){  
  38.                 s1 = cvGet2D(&pI_1, j, k);  
  39.                 cvSet2D(&pI_2, j, k-pic_Arr[i][0], s1);   
  40.             }  
  41.         }  
  42.         percentage = pixelPercentage(img_5);  
  43.         if(percentage < 0.1){  
  44.             continue;  
  45.         }  
  46.         if(pic_width < 6){  
  47.             printf("the %d is 1\n", i);  
  48.             continue;  
  49.         }  
  50.         carCard_Resize(img_5, img_w, wWidth, wHeight);  
  51.         pic_Thresholding(img_w, 60);  
  52.         sprintf(str, "%d", i+10);  
  53.         namedWindow(str);  
  54.         imshow(str, img_w);  
  55.     }  
  56.    
  57.     sprintf(str, "%d", i+3);  
  58.     namedWindow(str);  
  59.     imshow(str, img_4);  
  60.    
  61.     waitKey(0);  
  62.     return 0;  
  63. }  

  
  
　　在代码中，首先计算出分割出来的字符宽度pic_width，如果宽度小于3，表示不是正常的车牌字符，将该图片排除掉。如果满足大于2，则将分割字符图片
复制到img_5中，然后使用函数pixelPercentage计算出img_5中图片255的pixel占了总像素比例的比值，如果小于0.1，则表示该图像是车牌中的那个点。那么该
图片也排除掉，接着再宽度判断，如果宽度大于2而小于6，则表示该图片应该是1，因为1的垂直投影和其他字符相比，相差很多(注意：该方法很容易导致左右
边沿也被检测成了1)。最后在一次将筛选分割出来的字符img_5，归一化为wWidth=20，wHeight = 20的img_5,在以60为阀值的二值化后，将它们分别显示出来。
　　最后的显示效果如下：


效果演示

　　使用该方法做的效果并不好，如下是一些效果演示：

                                       
　　在这图片中，因为1之前已经判断筛选了，所以不会显示出1。

                                       
    
                                       
　　如图所示，该图片的效果就很差。
    代码下载位置：http://download.csdn.net/detail/u011630458/8440123

版权声明：本文为博主原创文章，未经博主允许不得转载。

顶
lien0906
关注
专栏目录
opencv车牌字符分割
03-05
用opencv实现车牌字符分割程序 包括测试图片 效率高
opencv对车牌号做分割
02-01
使用opencv对车牌号做简单的字符分割
OpenCV（项目）车牌识别2 -- 车牌字符分割（直方图）
热门推荐
great_yzl的博客
09-03 1万+
一、车牌字符提取 需要把字符揉成一团，这样才能提取轮廓。 0、试错 一开始采取的是膨胀提取车牌字符，发现很多情况无法兼顾。 0-1、没有膨胀/膨胀过小：无法连接上单个字符。 可以看到，一些没有连接上的汉字，轮廓提取就把它们当成了多个字符。 0-2、膨胀过大：错误连接相邻字符。 给予膨胀之后，膨胀又太大了，虽然同一个字符的不同笔画连接成功，但是又错误地把两个字符连接在了一起。 上面的算法感觉很难行得通了，除非借助其他分割算法。下面是优化...
车牌识别完整版 基于OPENCV3 完全实现车牌的字符提取 分割 识别 准确率高达95%
05-26
作者历经小半年的调试 才把程序调试好 完全可以实现车牌的字符识别，分割，提取，采用了SVM分类器和ANN神经网络，若下载后实现不了相应的功能，可以找作者把积分退还给大家
Python+OpenCV实现车牌字符分割和识别
09-20
Python和OpenCV库被广泛应用于计算机视觉领域，其中车牌识别是一个典型应用。车牌识别主要分为两个步骤：车牌定位和车牌字符识别。车牌定位是指从照片中确定车牌的位置，而车牌字符识别则是对定位到的车牌中的字符...
OpenCV+Python识别车牌和字符分割的实现
09-19
### OpenCV+Python识别车牌和字符分割的实现 本文旨在详细介绍如何使用OpenCV与Python实现车牌的识别以及车牌上的字符分割。此技术广泛应用于交通管理、自动停车系统等多个领域。 #### 1. 车辆图像获取 首先，...
OpenCV实现车牌字符分割(C++)
01-21
之前的车牌定位中已经获取到了车牌的位置，并且对车牌进行了提取。...后面的字都是完整的，字符分割的过程不会受影响。首先来一波常规操作，为了更方便处理，将其变成灰度图片： 分割的方法不止一种
opencv车牌分割_opencv_opencv车牌识别_opencv分割车牌_车牌分割_车牌分割_
09-30
8. **字符分割**：最后一步是将车牌上的单个字符分离开来，这可以通过垂直投影或者连通组件分析实现，为字符识别做准备。 在提供的“opencv车牌分割.txt”文件中，可能包含了实现上述步骤的代码示例或详细步骤。...
基于opencv2.4.9的车牌定位、倾斜校正、字符分割代码实现。含详细注解。
05-18
本人最近练手做的小项目，在CSDN上也参考了很多代码，积分花了不少可是大多都没用上！要么是版本不对劲，要么是完全读不懂，所以自己上传了！代码包括车牌定位，车牌倾斜校正，字符分割。字符的识别部分未做完。
车牌定位之字符分割
02-11
基于opencv实现车牌识别之字符定位部分
opencv python车牌定位字符分割
04-19
opencv python车牌定位，字符分割.
车牌字符分割
11-24
用matlab仿真了精确的车牌字符分割算法，效果十分可靠
Opencv车牌号字符分割
Twilight737的博客
06-24 2306
Opencv车牌号字符分割 字符分割的任务，就是把多字符图像中的每个字符从整体图像中分割出来，使其成为单个字符图像，为下一步的单个字符的图像识别做准备。 字符分割是字符识别的基础，字符分割的质量直接影响到字符识别的效果。 文章目录Opencv车牌号字符分割一、算法流程二、效果展示三、源码四、项目链接 一、算法流程 输入原始图片，将其resize到(320, 100)尺寸，灰度化处理： 利用cv2.bilateralFilter函数，在保持边界清晰的情况下有效去除噪声： 利用cv2.Canny函数，检
OPENCV(五) 对给定的车牌进行字符分割
BaseLike的博客
12-07 2200
下面有这样的一个车牌号： 现在的任务是将每一个字符区分开来，并方框圈出来。 完成这个功能需要以下的步骤： 1.灰度处理 #读取图片 image1 = cv2.imread('../img/car1.png') #灰度处理 gray = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY) 2.二值化处理（并反色） #对灰度处理进行反色 fanse = cv2.bitwise_not(gray) #二值化 retval, binary = cv2.threshold(fans
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值