10.实现简化版字符数字识别全过程

上个帖子里面简单介绍了SVM机制，给出了一个简单例子，不过那种界面上点击鼠标取像素值进行SVM训练，然后进行识别的操作给人的感觉不是那么明显。下面我们来将一个简化版的车牌识别过程和解决思路。
首先明确几个概念和知识：
1）SVM机制，就是把一部分数据作为已知项，通过某种规则来判断未知项是什么的过程；
2）车牌识别的实质是数字和字母的识别，手动将26个字符和10个数字制作那种白底黑字的图片作为SVM训练数据，同时使用同样大小的数字和字母制作图片模拟车牌，我认为这样的过程可以让我们一定程度上了解车牌识别的原理。
3）图像中全白的像素值为255，全黑为0.
一）操作步骤
1.制作36个字符图片
记事本写入字符，设置字体大小为“72”，为了程序便于处理，我们分为三行，并分别保存到3个文件里面。

2.将36个字符分割为36个图片保存
int cutLeft(Mat& src, Mat& leftImg, Mat& rightImg)//左右切割
cutleft函数从第一列像素数值之和=0的开始，到第N列结束，且满足N+1列像素数值合！=0,此时获得图像类似下图（实际是黑色背景）

void cutTop(Mat& src, Mat& dstImg)//上下切割
cutTop函数与cutleft函数类似，只是按照行操作，获取最终图像如下：

注意上图中字符与图片文件名字的关系。
3.制作两个模拟车牌图片
将上图中字符任意组合排列，得到两个图片

4.通过程序识别两个模拟车牌图片，并显示结果
cutleft和cuttop函数获取车牌的每个字符，cal_char函数计算每个字符图片的像素之和。将车牌每个字符与前面保存好的36个字符像素之和比较，获取保存字符的文件名，从而获取车牌字符是什么，组合起来就是我们所要检测的车牌。
二）代码

1. #include "opencv2/opencv.hpp"
   
2. using namespace std;
   
3. using namespace cv;
   
4. 
   
5. 
   
6. typedef struct _CHAR_NODE{
   
7.         char c;
   
8.         int sum;
   
9. }CHAR_NODE;
   
10. CHAR_NODE g_CHAR_NODE[36];
    
11. 
    
12. 
    
13. 
    
14. double sumMat(Mat& inputImg)  
    
15. {  
    
16.         double sum = 0.0;  
    
17. 
    
18.         //printf("\n =2=sumMat inputImg.rows=%d, inputImg.cols=%d sum=%f\n", inputImg.rows, inputImg.cols, sum);
    
19.     threshold(inputImg, inputImg, 100, 255, CV_THRESH_BINARY);  
    
20. 
    
21.     for (int i = 0; i < inputImg.rows;i++)  
    
22.     {  
    
23.         for (int j = 0; j < inputImg.cols; j++)  
    
24.         {  
    
25.             sum += inputImg.at <uchar>(i, j);  
    
26.         }  
    
27.     }  
    
28.    return sum;
    
29. }
    
30. 
    
31. double getRowSum(Mat& src, int i)
    
32. {
    
33.         double sum = 0;
    
34.         double sum1 = 0;
    
35.         int rowNumber = src.rows;  
    
36.         int colNumber = src.cols * src.channels();  
    
37.         #if 0
    
38.         printf("rowNumber=%d, colNumber=%d\n", rowNumber, colNumber);  
    
39.         for (int i = 0; i < rowNumber;i++)  
    
40.         {  
    
41.                 uchar* data = src.ptr<uchar>(i);  
    
42.                 for (int j = 0; j < colNumber; j++)  
    
43.                 {  
    
44.                         if(j > 100)
    
45.                                 break;
    
46.                         sum =  data[j] + sum;  
    
47.                 }  
    
48.         }  
    
49.         printf("\nrowNumber=%d, colNumber=%d sum=%f\n", rowNumber, colNumber, sum);  
    
50.         #endif
    
51.         Mat ColClone=src.row(i).clone();
    
52.         sum = sumMat(ColClone);
    
53.         //        printf("getColSum sum=%f i=%d\n", sum,i);  
    
54. 
    
55.    return sum;
    
56. }
    
57. double getColSum(Mat& src, int i)
    
58. {
    
59.         double sum = 0;
    
60.         double sum1 = 0;
    
61.         int rowNumber = src.rows;  
    
62.     int colNumber = src.cols * src.channels();  
    
63. #if 0
    
64.         printf("rowNumber=%d, colNumber=%d\n", rowNumber, colNumber);  
    
65.         for (int i = 0; i < rowNumber;i++)  
    
66.         {  
    
67.                 uchar* data = src.ptr<uchar>(i);  
    
68.                 for (int j = 0; j < colNumber; j++)  
    
69.                 {  
    
70.                         if(j > 100)
    
71.                         break;
    
72.                         sum =  data[j] + sum;  
    
73.                         printf("data[j]=%d sum=%f\t", data[j], sum);  
    
74.                 }  
    
75.         }  
    
76.         printf("\nrowNumber=%d, colNumber=%d sum=%f\n", rowNumber, colNumber, sum);  
    
77. #endif
    
78.         Mat RowClone=src.col(i).clone();
    
79.         sum = sumMat(RowClone);
    
80. //        printf("getColSum sum=%f i=%d\n", sum,i);  
    
81. 
    
82.    return sum;
    
83. }
    
84. void cutTop(Mat& src, Mat& dstImg)//上下切割  
    
85. {  
    
86.     int top, bottom;  
    
87.     top = 0;  
    
88.     bottom = src.rows;  
    
89.         double colValue = 0;
    
90.     int i;  
    
91.     for (i = 0; i < src.rows; i++)  
    
92.     {  
    
93.         colValue = getRowSum(src, i);  
    
94.         if (colValue>0)  
    
95.         {  
    
96.             top = i;  
    
97.             break;  
    
98.         }  
    
99.     }  
    
100.     for (; i < src.rows; i++)  
     
101.     {  
     
102.         colValue = getRowSum(src, i);  
     
103.         if (colValue == 0)  
     
104.         {  
     
105.             bottom = i;  
     
106.             break;  
     
107.         }  
     
108.     }  
     
109.   
     
110.     int height = bottom - top;  
     
111.     Rect rect(0, top, src.cols, height);  
     
112.     dstImg = src(rect).clone();  
     
113. }  
     
114. 
     
115. int cutLeft(Mat& src, Mat& leftImg, Mat& rightImg)//左右切割  
     
116. {  
     
117.         int left, right;  
     
118.         left = 0;  
     
119.         right = src.cols;  
     
120. 
     
121.         int i = 0;  
     
122.         double colValue = 0;
     
123. 
     
124.         for (i = 0; i < src.cols; i++)  
     
125.         {  
     
126.                 colValue = getColSum(src, i);  
     
127.                 if (colValue>0)  
     
128.                 {  
     
129.                         left = i;  
     
130.                         break;  
     
131.                 }  
     
132.         }  
     
133.         if (left == 0)  
     
134.         {  
     
135.                 return 1;  
     
136.         }  
     
137. 
     
138. 
     
139.         for (; i < src.cols; i++)  
     
140.         {  
     
141.                 colValue = getColSum(src, i);  
     
142.                 if (colValue == 0)  
     
143.                 {  
     
144.                         right = i;  
     
145.                         break;  
     
146.                 }  
     
147.         }  
     
148.         int width = right - left;  
     
149.         Rect rect(left, 0, width, src.rows);  
     
150.         leftImg = src(rect).clone();  
     
151. //        imshow("1=",leftImg);  
     
152. 
     
153.         Rect rectRight(right, 0, src.cols - right, src.rows);  
     
154.         rightImg = src(rectRight).clone();  
     
155. 
     
156.         cutTop(leftImg, leftImg);
     
157. 
     
158.         return 0;  
     
159. }
     
160. int make_svm(char* filename, int char_num)
     
161. {
     
162.         Mat imgSrc1 = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);  
     
163.         Mat imgLeft;
     
164.         Mat imgRight;
     
165.         imshow("origin", imgSrc1);
     
166.         threshold(imgSrc1, imgSrc1, 100 , 255, CV_THRESH_BINARY_INV);  
     
167.         int nRet = cutLeft(imgSrc1, imgLeft, imgRight);
     
168.         int i = 0;   
     
169. 
     
170.         while (nRet == 0)  
     
171.         {         
     
172.                 char nameLeft[256];  
     
173.                 sprintf(nameLeft, "./char_number/left_%c.png", char_num + i);  
     
174.                 i++;
     
175. 
     
176.                 printf("***nameLeft=%s\n", nameLeft);
     
177.                 //imshow(nameLeft,imgLeft);  
     
178.                 imwrite(nameLeft, imgLeft);
     
179.                 //imwrite(nameRight, imgRight);
     
180.                 Mat srcTmp = imgRight;  
     
181.                 nRet = cutLeft(srcTmp, imgLeft, imgRight);
     
182. 
     
183.         }
     
184.         return 0;
     
185. }
     
186. void callmake_svm()
     
187. {
     
188.         int a[3] = {'A', 'N', '0'};
     
189.         char str[64] = "chars_numbers3";
     
190.         for(int i = 0; i < 3; i ++)
     
191.         {
     
192.                 char str_name[128] = "chars_numbers3";
     
193.                 sprintf(str_name, "%s%d.png", str, i+1);
     
194.                 make_svm(str_name, a[i]);
     
195.         }
     
196. }
     
197. 
     
198. char findout_char(Mat &charImg)
     
199. {
     
200.         char cc = ' ';
     
201.         int i = 0;
     
202.         int j = 0;
     
203.         double fcharsum = 0;
     
204.         threshold(charImg, charImg, 100 , 255, CV_THRESH_BINARY_INV);  
     
205. 
     
206.         fcharsum = sumMat(charImg);  
     
207. //        printf("=1=get_findout_char charImg.rows=%d, charImg.cols=%d charsum=%d\n", charImg.rows, charImg.cols, charsum);
     
208.         for(i=0; i < 26; i++)
     
209.         {
     
210.                 if(fcharsum == g_CHAR_NODE[i + 0].sum)
     
211.                         return g_CHAR_NODE[i + 0].c;
     
212.         }
     
213.         for(j=0; j < 10; j++)
     
214.         {
     
215.                 if(fcharsum == g_CHAR_NODE[i + j].sum)
     
216.                         return g_CHAR_NODE[i + j].c;
     
217.         }
     
218.         printf("findout_char error\n");
     
219.         return cc;
     
220. }
     
221. int get_findout_char(char* filename, int char_num)
     
222. {
     
223.         char str_result[12];
     
224.         Mat imgSrc1 = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);  
     
225.         Mat imgLeft;
     
226.         Mat imgRight;
     
227.         imshow("origin", imgSrc1);
     
228.         threshold(imgSrc1, imgSrc1, 100 , 255, CV_THRESH_BINARY_INV);  
     
229.         imshow("threshold", imgSrc1);
     
230. 
     
231.         int nRet = cutLeft(imgSrc1, imgLeft, imgRight);
     
232.         int i = 0;   
     
233. 
     
234.         printf("get_findout_char nRet=%d i=%d\n", nRet,i);  
     
235.         while (nRet == 0)  
     
236.         {         
     
237.                 char nameLeft[256];  
     
238.                 sprintf(nameLeft, "./char_number/left_%d.png", i);  
     
239. 
     
240.                 //printf("nameLeft=%s\n", nameLeft);
     
241.                 //imshow("get_findout_char",imgLeft);  
     
242.                 //imwrite(nameLeft, imgLeft);
     
243.                 //imwrite(nameRight, imgRight);
     
244.                 str_result[i] = findout_char(imgLeft);
     
245.                 //printf("nameLeft=%d <0>=%d\n", str_result[i], '0');
     
246.                 i++;
     
247.                 Mat srcTmp = imgRight;  
     
248.                 nRet = cutLeft(srcTmp, imgLeft, imgRight);
     
249. 
     
250.         }
     
251.         printf("get_findout_char str_result=%s\n", str_result);  
     
252.         return 0;
     
253. }
     
254. 
     
255. double cal_char(char* filename)
     
256. {
     
257.         double fsum = 0;
     
258.         Mat imgSrc1 = imread(filename, CV_LOAD_IMAGE_GRAYSCALE);  
     
259.         Mat imgLeft;
     
260.         Mat imgRight;
     
261.         int i = 0;
     
262.         imshow("origin", imgSrc1);
     
263.         threshold(imgSrc1, imgSrc1, 100 , 255, CV_THRESH_BINARY_INV);  
     
264.         //        printf("=0=cal_cha src.cols=%d src.rows=%d  fsum=%f\n", imgSrc1.cols, imgSrc1.rows, fsum);        //       
     
265.         fsum = sumMat(imgSrc1);
     
266.         return fsum;
     
267. }
     
268. int main(int argc, char** argv)
     
269. {
     
270. 
     
271.         if(argc < 2)
     
272.         {
     
273.                 printf("argc < 2\n");
     
274.                 return -1;
     
275.         }
     
276.         printf("argv[1]=%s\n", argv[1]);
     
277.         if(strcmp(argv[1], "-svm") == 0)
     
278.         {
     
279.                 callmake_svm();
     
280.                 printf("-svm\n");
     
281.         }
     
282.         if(strcmp(argv[1], "-findout") == 0)
     
283.         {
     
284.                 int i = 0;
     
285.                 int j = 0;
     
286. 
     
287.                 char filename1[128] = "./char_number/left_";//0.png
     
288.                 char filename2[128] = "./char_number/left_";//0.png
     
289.                 for(i=0; i < 26; i++)
     
290.                 {
     
291.                         sprintf(filename2, "%s%c.png", filename1, 'A' + i);
     
292.                         g_CHAR_NODE[i].c = 'A' + i;
     
293.                         g_CHAR_NODE[i].sum = cal_char(filename2);
     
294.                 }
     
295.                 for(j=0; j < 10; j++)
     
296.                 {
     
297.                         sprintf(filename2, "%s%d.png", filename1, j);
     
298.                         g_CHAR_NODE[i + j].c =  '0' + j;
     
299.                         g_CHAR_NODE[i + j].sum = cal_char(filename2);
     
300.                 }
     
301.         #if 0
     
302.                 for(i=0; i < 26; i++)
     
303.                 {
     
304.                         printf("=2=g_CHAR_NODE[i + 0].c=%c, g_CHAR_NODE[i + 0].sum=%d\n", g_CHAR_NODE[i + 0].c, g_CHAR_NODE[i + 0].sum);
     
305.                 }
     
306.                 for(j=0; j < 10; j++)
     
307.                 {
     
308.                         printf("=2=g_CHAR_NODE[i + j].c=%d, g_CHAR_NODE[i + j].sum=%d\n", g_CHAR_NODE[i + j].c, g_CHAR_NODE[i + j].sum);
     
309.                 }
     
310.         #endif
     
311.                 get_findout_char(argv[2], 0);
     
312. 
     
313.                 printf("-svm\n");
     
314.         }
     
315.         waitKey(0);
     
316.         return 0;
     
317. }
     

复制代码

三）运行结果

四）总结
1）实际的车牌识别的过程比我们这个复杂很多，比如拍摄角度，图片的清晰度等都需要进行处理，而且处理的结果直接影响最终的识别正确性。
2）为了减少代码的逻辑，本程序开始识别以前直接将所要的图片信息保存到一个全局结构体中，实际中可以使用Opencv中操作xml文件的方法，将所有的保存文件信息保存到xml文件中，这也是后面实际的车牌识别使用的方式。
3）注意像素操作前应该将图像进行threshold操作。
4）下面会根据时间来完成一个外接设备的驱动，或者调用第三方库来完成Android系统上的车牌识别的项目结项。

纯干货必须赞