OpenCV的基础光学字符识别（Basic OCR in OpenCV）

Github源码

From:http://blog.damiles.com/2008/11/basic-ocr-in-opencv/

在这个教程当中我们将完成一个基础的数字光学字符识别。这包括把一个手写的数字分类进它所属的类里。

为了完成它，们我将要使用我们之前的教程里所有学到的东西，我们将要使用简单的basic painter和the basic pattern recognition and classification with openCV 两个教程。

在一个典型的模式识别分类器里，包括三个模块：

预处理（信号获取和滤波）

特征提取（特征向量的计算）

分类（特征向量的分类）

预处理（Preprocessing）：在这个模块我们将要处理我们输入的图片，比如大小标准化，彩色图像灰度化等等。

特征提取(Feature extraction)：在这个模块我们转换我们处理后的图像为一个特征向量以便于分类，它可能是像素矩阵转换成向量或者获取轮廓编码链的数据表示。

分类模块获取特征向量，并训练我们的系统或者说使用一个分类方法（比如knn）把输入的特征向量分类。

这个基础光学字符识别的流程图如下：

现在我们有由图片组成的一个训练集和一个测试集来训练和测试我们的分类器（knn）。

我们有1000张手写数字的图片，每个数字100张。我们使用每个数字的50张图片来训练，另外50张来测试我们的系统。

接下来我们要做的第一个工作就是对所有训练集的图片预处理，为了完成它我们创建一个预处理函数。在这个函数中，我们输入一张图片和我们想要它在处理后得到的新的长和宽，这个函数讲返回一个标准大小的带有边框的图片。你可以看到更多清楚的处理流程：

预处理代码：

1. void findX(IplImage* imgSrc,int* min, int* max){  
2. int i;  
3. int minFound=0;  
4. CvMat data;  
5. CvScalar maxVal=cvRealScalar(imgSrc->width * 255);  
6. CvScalar val=cvRealScalar(0);  
7. //For each col sum, if sum < width*255 then we find the min  
8. //then continue to end to search the max, if sum< width*255 then is new max  
9. for (i=0; i< imgSrc->width; i++){  
10. cvGetCol(imgSrc, &data, i);  
11. val= cvSum(&data);  
12. if(val.val[0] < maxVal.val[0]){  
13. *max= i;  
14. if(!minFound){  
15. *min= i;  
16. minFound= 1;  
17. }  
18. }  
19. }  
20. }  
21.   
22. void findY(IplImage* imgSrc,int* min, int* max){  
23. int i;  
24. int minFound=0;  
25. CvMat data;  
26. CvScalar maxVal=cvRealScalar(imgSrc->width * 255);  
27. CvScalar val=cvRealScalar(0);  
28. //For each col sum, if sum < width*255 then we find the min  
29. //then continue to end to search the max, if sum< width*255 then is new max  
30. for (i=0; i< imgSrc->height; i++){  
31. cvGetRow(imgSrc, &data, i);  
32. val= cvSum(&data);  
33. if(val.val[0] < maxVal.val[0]){  
34. *max=i;  
35. if(!minFound){  
36. *min= i;  
37. minFound= 1;  
38. }  
39. }  
40. }  
41. }  
42. CvRect findBB(IplImage* imgSrc){  
43. CvRect aux;  
44. int xmin, xmax, ymin, ymax;  
45. xmin=xmax=ymin=ymax=0;  
46.   
47. findX(imgSrc, &xmin, &xmax);  
48. findY(imgSrc, &ymin, &ymax);  
49.   
50. aux=cvRect(xmin, ymin, xmax-xmin, ymax-ymin);  
51.   
52. //printf("BB: %d,%d - %d,%d\n", aux.x, aux.y, aux.width, aux.height);  
53.   
54. return aux;  
55.   
56. }  
57.   
58. IplImage preprocessing(IplImage* imgSrc,int new_width, int new_height){  
59. IplImage* result;  
60. IplImage* scaledResult;  
61.   
62. CvMat data;  
63. CvMat dataA;  
64. CvRect bb;//bounding box  
65. CvRect bba;//boundinb box maintain aspect ratio  
66.   
67. //Find bounding box  
68. bb=findBB(imgSrc);  
69.   
70. //Get bounding box data and no with aspect ratio, the x and y can be corrupted  
71. cvGetSubRect(imgSrc, &data, cvRect(bb.x, bb.y, bb.width, bb.height));  
72. //Create image with this data with width and height with aspect ratio 1  
73. //then we get highest size betwen width and height of our bounding box  
74. int size=(bb.width>bb.height)?bb.width:bb.height;  
75. result=cvCreateImage( cvSize( size, size ), 8, 1 );  
76. cvSet(result,CV_RGB(255,255,255),NULL);  
77. //Copy de data in center of image  
78. int x=(int)floor((float)(size-bb.width)/2.0f);  
79. int y=(int)floor((float)(size-bb.height)/2.0f);  
80. cvGetSubRect(result, &dataA, cvRect(x,y,bb.width, bb.height));  
81. cvCopy(&data, &dataA, NULL);  
82. //Scale result  
83. scaledResult=cvCreateImage( cvSize( new_width, new_height ), 8, 1 );  
84. cvResize(result, scaledResult, CV_INTER_NN);  
85.   
86. //Return processed data  
87. return *scaledResult;  
88.   
89. }  

我们使用basicOCR类的getData函数来创建训练数据和训练类，这个函数获取所有在OCR文件夹下的图片来创建训练数据，OCR文件夹中的每个类是一个文件夹，其中每个文件都是名为cnn.pbm的pbm文件，c是类（0,1,...,9）中的一个，nn是图片的编号(00,01,...,99)。

我们得到的每张图片都是预处理过的了，然后他们将转换成特征向量里的数据以便我们使用。

basicOCR.cpp 获取数据代码：

1. void basicOCR::getData()  
2. {  
3. IplImage* src_image;  
4. IplImage prs_image;  
5. CvMat row,data;  
6. char file[255];  
7. int i,j;  
8. for(i =0; i<classes; i++){  
9. for( j = 0; j< train_samples; j++){  
10.   
11. //Load file  
12. if(j<10)  
13. sprintf(file,"%s%d/%d0%d.pbm",file_path, i, i , j);  
14. else  
15. sprintf(file,"%s%d/%d%d.pbm",file_path, i, i , j);  
16. src_image = cvLoadImage(file,0);  
17. if(!src_image){  
18. printf("Error: Cant load image %s\n", file);  
19. //exit(-1);  
20. }  
21. //process file  
22. prs_image = preprocessing(src_image, size, size);  
23.   
24. //Set class label  
25. cvGetRow(trainClasses, &row, i*train_samples + j);  
26. cvSet(&row, cvRealScalar(i));  
27. //Set data  
28. cvGetRow(trainData, &row, i*train_samples + j);  
29.   
30. IplImage* img = cvCreateImage( cvSize( size, size ), IPL_DEPTH_32F, 1 );  
31. //convert 8 bits image to 32 float image  
32. cvConvertScale(&prs_image, img, 0.0039215, 0);  
33.   
34. cvGetSubRect(img, &data, cvRect(0,0, size,size));  
35.   
36. CvMat row_header, *row1;  
37. //convert data matrix sizexsize to vecor  
38. row1 = cvReshape( &data, &row_header, 0, 1 );  
39. cvCopy(row1, &row, NULL);  
40. }  
41. }  
42. }  

在处理并且得到训练数据和类以后我们用我们的模型训练这些数据，在这个例子中我们用knn方法：

1. knn=new CvKNearest( trainData, trainClasses, 0, false, K );  

现在我们可以测试我们的模型了，并且我们可以使用测试的结果来和其它我们使用的方法比较，又或者我们减小图片大小等等。这里是在我们的basicOCR类里创建的一个函数，测试函数。

这个函数获取其它500个样本并且用我们选择的方法分类，再检验得到的结果。

1. void basicOCR::test(){  
2. IplImage* src_image;  
3. IplImage prs_image;  
4. CvMat row,data;  
5. char file[255];  
6. int i,j;  
7. int error=0;  
8. int testCount=0;  
9. for(i =0; i<classes; i++){  
10. for( j = 50; j< 50+train_samples; j++){  
11.   
12. sprintf(file,"%s%d/%d%d.pbm",file_path, i, i , j);  
13. src_image = cvLoadImage(file,0);  
14. if(!src_image){  
15. printf("Error: Cant load image %s\n", file);  
16. //exit(-1);  
17. }  
18. //process file  
19. prs_image = preprocessing(src_image, size, size);  
20. float r=classify(&prs_image,0);  
21. if((int)r!=i)  
22. error++;  
23.   
24. testCount++;  
25. }  
26. }  
27. float totalerror=100*(float)error/(float)testCount;  
28. printf("System Error: %.2f%%\n", totalerror);  
29.   
30. }  

test函数使用了分类函数，获取图片，处理图片，得到特征向量并且用knn类的find_nearest函数对其分类。下面

这个函数我们用来分类输入的用户图片：

1. float basicOCR::classify(IplImage* img, int showResult)  
2. {  
3. IplImage prs_image;  
4. CvMat data;  
5. CvMat* nearest=cvCreateMat(1,K,CV_32FC1);  
6. float result;  
7. //process file  
8. prs_image = preprocessing(img, size, size);  
9.   
10. //Set data  
11. IplImage* img32 = cvCreateImage( cvSize( size, size ), IPL_DEPTH_32F, 1 );  
12. cvConvertScale(&prs_image, img32, 0.0039215, 0);  
13. cvGetSubRect(img32, &data, cvRect(0,0, size,size));  
14. CvMat row_header, *row1;  
15. row1 = cvReshape( &data, &row_header, 0, 1 );  
16.   
17. result=knn->find_nearest(row1,K,0,0,nearest,0);  
18.   
19. int accuracy=0;  
20. for(int i=0;i<K;i++){  
21. if( nearest->data.fl[i] == result)  
22. accuracy++;  
23. }  
24. float pre=100*((float)accuracy/(float)K);  
25. if(showResult==1){  
26. printf("|\t%.0f\t| \t%.2f%%  \t| \t%d of %d \t| \n",result,pre,accuracy,K);  
27. printf(" ---------------------------------------------------------------\n");  
28. }  
29.   
30. return result;  
31.   
32. }  

所有的工作或者训练和测试都在basicOCR类里，当我们创建一个basicOCR的实例时只需要调用classify函数来分类我们输入的图片。然后我们使用我们之前在其它教程里创建的简单的Painter来给用户交互绘出一张图片并且分类它。

---

译者注：

1.knn,即K最邻近结点算法（k-Nearest Neighbor algorithm）,最简单的机器学习算法之一，简单说就是在特征空间里找到周围最近的k个样本，如果这k个样本中的大多数属于某个类，则该样本也属于这个类。

2.painter,GUI编程中的绘图接口，也就是完成绘制和显示图像的功能。

Github源码