车牌识别（四）灰度算法

乘简

接下来，就是把旋转矫正的小区域车牌图灰度化，所谓灰度化，就是以车牌中字的颜色为白色这一特点计算的，防止有些车牌上面很脏，但这些脏东西一般都不是白色的，所以可以把白色过滤出来，再二值化，从中抓取出文字进行识别！

其实一个颜色是否为灰度色，主要就是看红绿蓝3基色是不是相等，如果相等则是灰度色，不相等就偏红，绿，蓝

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef unsigned long       DWORD;
   
6. typedef int                 BOOL;
   
7. typedef unsigned char       BYTE;
   
8. typedef unsigned short      WORD;
   
9. typedef float               FLOAT;
   
10. typedef unsigned char       byte;
    
11. 
    
12. #define max(a,b)            (((a) > (b)) ? (a) : (b))
    
13. #define min(a,b)            (((a) < (b)) ? (a) : (b))
    
14. 
    
15. //BMP图像结构
    
16. struct BMP_img
    
17. {
    
18.     //{BMP头
    
19.     BYTE  bfType[2];//类型，判断是否为‘B’,‘M’
    
20.     DWORD size;//文件尺寸
    
21.     DWORD reser;//保留，为0
    
22.     DWORD header_length;//头部长度，也就是数据起始位置
    
23.     //}BMP头长度，14字节
    
24. 
    
25.     //{信息头40字节
    
26.     DWORD infoheader_length;//信息头长度,40
    
27.     DWORD width;//图像宽度
    
28.     DWORD height;//图像高度
    
29.     WORD  biplanes;//颜色平面数，为1
    
30.     WORD  bmp_type;/* 8bit 24bit; */
    
31.     DWORD compres;//0表示不压缩
    
32.     DWORD datasize;//数据长度，size-54
    
33.     DWORD bixpm;//水平分辩率
    
34.     DWORD biypm;//垂直分辩率
    
35.     DWORD clrused;//为0所有颜色，其它的为索引数
    
36.     DWORD relclrused;//0表示都重要
    
37.     //}信息头结束
    
38. 
    
39.     //其它信息
    
40.     BYTE *image;//指向一块内存，保存BMP的内容
    
41.     DWORD lineBytes;//一行占多少字节
    
42. };
    
43. 
    
44. //从源BMP图中，剪切车牌所在区域的新结构
    
45. struct Bmp1{
    
46.     DWORD width;
    
47.     DWORD height;
    
48.     BYTE *image;
    
49.     int left[10];//保存车牌中7个字的左右列
    
50.     int right[10];
    
51.     int top[10];//保存车牌上下位置
    
52.     int bottom[10];
    
53.     int up;
    
54.     int down;
    
55.     byte strr[7][1024];
    
56.     byte string[7];//反回已找到的车牌下标
    
57.     float ang;//倾斜角度
    
58. };
    
59. 
    
60. //蓝色车牌
    
61. struct HSV{
    
62.   float H;//H值范围：190 ~ 245
    
63.   float S;//S值范围： 0.35 ~ 1，我理解为黑白灰度
    
64.   int V;//V值范围： 0.3 ~ 1
    
65. };
    
66. 
    
67. //文件图文件到内存中
    
68. int read_img(char const *fn, struct BMP_img *img)
    
69. {
    
70.     FILE *infile;
    
71.     if((infile=fopen(fn,"rb"))==NULL)return 0;
    
72. 
    
73.     fread(&img->bfType,2,1,infile);//BM
    
74.     if(!(img->bfType[0]=='B' && img->bfType[1]=='M'))return 0;
    
75.     fread(&img->size,sizeof(DWORD),1,infile);
    
76.     printf("\nBMP size             :%d",(int)img->size);
    
77.     fread(&img->reser,sizeof(DWORD),1,infile);
    
78.     printf("\n保留位:");
    
79.     fread(&img->header_length,sizeof(DWORD),1,infile);
    
80.     printf("\nheader length    :%d",(int)img->header_length);
    
81.     fread(&img->infoheader_length,sizeof(DWORD),1,infile);
    
82.     fread(&img->width, sizeof(DWORD), 1, infile);
    
83.     fread(&img->height, sizeof(DWORD), 1, infile);
    
84.     printf( "\nwidth   :%d\n  height  :%d ", (int)img->width, (int)img->height);
    
85.     fread(&img->biplanes, sizeof(WORD), 1, infile);
    
86.     fread(&img->bmp_type, sizeof(WORD), 1, infile);
    
87.     printf("\nBMP Tpye             :%d ", img->bmp_type);
    
88.     fread(&img->compres, sizeof(DWORD), 1, infile);
    
89.     if(img->compres==0) {printf("\nbmp图片为非压缩!");}printf(" ");
    
90.     fread(&img->datasize, sizeof(DWORD), 1, infile);
    
91.     printf("\nBMP Data Size        :%d ",(int)img->datasize);
    
92.     fread(&img->bixpm, sizeof(DWORD), 1, infile);
    
93.     fread(&img->biypm, sizeof(DWORD), 1, infile);
    
94.     fread(&img->clrused, sizeof(DWORD), 1, infile);
    
95.     printf("\n实际使用颜色数=%d ",(int)img->clrused);printf(" ");
    
96.     fread(&img->relclrused, sizeof(DWORD), 1, infile);
    
97. 
    
98.     if(img->bmp_type==24)//24位色，这里只考虑24位色图，其它的不考虑
    
99.     {
    
100.         img->lineBytes=((img->width*3+3)>>2)<<2;//计算一行需要多少字节，对齐到4字节
     
101. 
     
102.         //byte *temp=(byte *)malloc(sizeof(byte) * img->height * img->lineBytes);//分配一块内存，用于读文件
     
103.         img->image=(byte *)malloc(img->lineBytes*img->height);//分配一块内存，用于保存图像数据
     
104.         if(img->image==NULL) fprintf(stderr, "\n Allocation error for temp in read_bmp() \n");
     
105.         fseek(infile, img->header_length, SEEK_SET);//跳过头部，也就是跳到图像位置
     
106.         fread(img->image, sizeof(byte), (img->lineBytes)*img->height, infile);//全部读到内存中
     
107.     }
     
108.     fclose(infile);
     
109.     return 1;
     
110. }
     
111. 
     
112. //把二值图保存为24位黑白图
     
113. void WriteBmp1(char const *fn,byte *bmp,int width,int height)
     
114. {
     
115.     int w4;
     
116.     struct BMP_img img;
     
117.     //一行有多少个字节
     
118.     img.lineBytes=((width*3+3)>>2)<<2;//对齐到4字节边界
     
119.     w4=img.lineBytes*height;//图像尺寸
     
120.     img.bfType[0]='B';img.bfType[1]='M';
     
121.     img.size=w4+54;
     
122.     img.reser=0;
     
123.     img.header_length=54;
     
124.     img.infoheader_length=40;
     
125.     img.width=width;
     
126.     img.height=height;
     
127.     img.biplanes=1;
     
128.     img.bmp_type=24;
     
129.     img.compres=0;
     
130.     img.datasize=w4;
     
131.     img.bixpm=0;
     
132.     img.biypm=0;
     
133.     img.clrused=0;
     
134.     img.relclrused=0;
     
135.    
     
136.     FILE *infile;
     
137.     if((infile=fopen(fn,"wb"))==NULL)
     
138.     {
     
139.         return;
     
140.     }
     
141.     fwrite(&img.bfType,2,1,infile);//printf("\n打开的图为 %d",img->bfType);//B M
     
142.     fwrite(&img.size,sizeof(DWORD),1,infile);     //        printf("\nBMP size             :%l",img->size);
     
143.     fwrite(&img.reser,sizeof(DWORD),1,infile);//printf("\n保留位:");
     
144.     fwrite(&img.header_length,sizeof(DWORD),1,infile); //printf("\nheader length    :%l",img->header_length);
     
145.     fwrite(&img.infoheader_length,sizeof(DWORD),1,infile);
     
146.     fwrite(&img.width, sizeof(DWORD), 1, infile);
     
147.     fwrite(&img.height, sizeof(DWORD), 1, infile);     //printf( "\nwidth   :%l\n  height  :%l ", img->width, img->height);
     
148.     fwrite(&img.biplanes, sizeof(WORD), 1, infile);
     
149.     fwrite(&img.bmp_type, sizeof(WORD), 1, infile);  // printf("\nBMP Tpye             :%l ", img->bmp_type);
     
150.     fwrite(&img.compres, sizeof(DWORD), 1, infile);    //if(img->compres==0) {printf("\nbmp图片为非压缩!");}printf(" ");
     
151.     fwrite(&img.datasize, sizeof(DWORD), 1, infile);//printf("\nBMP Data Size        :%l ",img->datasize);
     
152.     fwrite(&img.bixpm, sizeof(DWORD), 1, infile);
     
153.     fwrite(&img.biypm, sizeof(DWORD), 1, infile);
     
154.     fwrite(&img.clrused, sizeof(DWORD), 1, infile);    //printf("\n实际使用颜色数=%d ",img->clrused);printf(" ");
     
155.     fwrite(&img.relclrused, sizeof(DWORD), 1, infile);
     
156.    
     
157.     byte *wbmp=(byte*)malloc(w4);//后面多加两个字节，用于4字节对齐
     
158.     for(int i=0,s,w;i<height;i++)
     
159.     {
     
160.         s=i*width;
     
161.         w=i*img.lineBytes;
     
162.         for(int j=0;j<width;j++)
     
163.         {
     
164.             if(bmp[s+j]){
     
165.                 wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=bmp[s+j];
     
166.             }
     
167.             else wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=0;               
     
168.         }
     
169.     }
     
170.     fwrite(wbmp,img.datasize,1,infile);
     
171.     free(wbmp);
     
172.     fclose(infile);
     
173. }
     
174. 
     
175. //灰度，不再是蓝色变白色，其它变黑色的，而是从黑到白变灰，
     
176. //因为车牌是白色的字，所以与蓝底无关了，即使蓝底上有一些不干净的点，也可以过滤掉
     
177. void huidu(byte *srcBmp,byte *dstBmp,int width,int height)
     
178. {
     
179.     int i,j;
     
180.     int n;
     
181.     float gray;
     
182.     for(i=0;i<height;i++)
     
183.     {
     
184.         for(j=0,n=0;j<width;n+=3,j++)
     
185.         {
     
186.             //灰义勇=红色*0.299 + 绿色*0.578 + 蓝色*0.114
     
187.             gray=srcBmp[i*width*3+n+2]*0.299 + srcBmp[i*width*3+n+1]*0.578 + srcBmp[i*width*3+n]*0.114;
     
188.             //当然，也可以采用下面的算法，平均3种颜色
     
189.                         //gray=((int)srcBmp[i*width*3+n+2]+(int)srcBmp[i*width*3+n+1]+srcBmp[i*width*3+n])/3.0+0.5;
     
190.             dstBmp[i*width+j]=(byte)(gray+0.5);
     
191.         }
     
192.     }
     
193. }
     
194. 
     
195. int main(int argc, char **argv)
     
196. {
     
197.     struct BMP_img img;//定义结构
     
198. 
     
199.     //把当前文件夹下的1.bmp文件内容，读到img结构中，并上下镜像
     
200.     if(read_img("1.bmp", &img)==0)
     
201.     {
     
202.         printf("error");
     
203.         return 0;
     
204.     }
     
205.    
     
206.     byte *temp=(byte*)malloc(img.width*img.height);
     
207.     huidu(img.image,temp,img.width,img.height);
     
208.    
     
209.     //写入镜像后的数据到2.bmp中
     
210.     WriteBmp1("2.bmp",temp,img.width,img.height);
     
211.    
     
212.     free(img.image);//释放动态分配的内存
     
213.     free(temp);
     
214.    
     
215.     printf("请打开2.bmp进行查看\n");
     
216.     system("pause");
     
217.     return 0;
     
218. }
     

复制代码

当然，我给的图片是除了蓝色车牌部分，外面还有很多，其实是可以再次根据蓝底这一特点，只切出蓝点这块区域，再进行灰度处理的，代码和前面的方法一样，就省略了。。。