车牌识别（七）缩放锁定文字绽放到模板等同大小

乘简

由于给定的车牌图片中的文字大小不一，还得进行缩放操作，保存与模板大小一致，再与模板进行比较。

给定的模板为16 x 32像素，所以要把锁定的图片进行缩放操作。

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][2500];
    
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.     //计算一行需要多少字节，对齐到4字节
    
99.     img->lineBytes=(img->width*img->bmp_type+31)/32*4;//printf("\nLineBytes            :%l\n",img->lineBytes);
    
100.     if(img->bmp_type==24)//24位色
     
101.     {
     
102.         img->image=(unsigned char *)malloc(img->lineBytes*img->height);//分配一块内存，用于保存图像数据
     
103.         if(img->image==NULL) fprintf(stderr, "\n Allocation error for temp in read_bmp() \n");
     
104.         fseek(infile, img->header_length, SEEK_SET);//跳过头部，也就是跳到图像位置
     
105.         if(img->datasize==img->width*3)
     
106.             fread(img->image, sizeof(unsigned char), (img->lineBytes)*img->height, infile);//全部读到内存中
     
107.         else
     
108.         {
     
109.             for(int i=0;i<img->height;i++)
     
110.             {
     
111.                 fread(&img->image[i*img->width*3], sizeof(unsigned char), img->lineBytes, infile);//全部读到内存中
     
112.             }
     
113.         }
     
114.     }
     
115.     fclose(infile);
     
116.     return 1;
     
117. }
     
118. 
     
119. //把二值图保存为24位黑白图
     
120. void WriteBmp1(char const *fn,byte *bmp,int width,int height)
     
121. {
     
122.     int w4;
     
123.     struct BMP_img img;
     
124.     //一行有多少个字节
     
125.     img.lineBytes=((width*3+3)>>2)<<2;//对齐到4字节边界
     
126.     w4=img.lineBytes*height;//图像尺寸
     
127.     img.bfType[0]='B';img.bfType[1]='M';
     
128.     img.size=w4+54;
     
129.     img.reser=0;
     
130.     img.header_length=54;
     
131.     img.infoheader_length=40;
     
132.     img.width=width;
     
133.     img.height=height;
     
134.     img.biplanes=1;
     
135.     img.bmp_type=24;
     
136.     img.compres=0;
     
137.     img.datasize=w4;
     
138.     img.bixpm=0;
     
139.     img.biypm=0;
     
140.     img.clrused=0;
     
141.     img.relclrused=0;
     
142.    
     
143.     FILE *infile;
     
144.     if((infile=fopen(fn,"wb"))==NULL)
     
145.     {
     
146.         return;
     
147.     }
     
148.     fwrite(&img.bfType,2,1,infile);//printf("\n打开的图为 %d",img->bfType);//B M
     
149.     fwrite(&img.size,sizeof(DWORD),1,infile);     //        printf("\nBMP size             :%l",img->size);
     
150.     fwrite(&img.reser,sizeof(DWORD),1,infile);//printf("\n保留位:");
     
151.     fwrite(&img.header_length,sizeof(DWORD),1,infile); //printf("\nheader length    :%l",img->header_length);
     
152.     fwrite(&img.infoheader_length,sizeof(DWORD),1,infile);
     
153.     fwrite(&img.width, sizeof(DWORD), 1, infile);
     
154.     fwrite(&img.height, sizeof(DWORD), 1, infile);     //printf( "\nwidth   :%l\n  height  :%l ", img->width, img->height);
     
155.     fwrite(&img.biplanes, sizeof(WORD), 1, infile);
     
156.     fwrite(&img.bmp_type, sizeof(WORD), 1, infile);  // printf("\nBMP Tpye             :%l ", img->bmp_type);
     
157.     fwrite(&img.compres, sizeof(DWORD), 1, infile);    //if(img->compres==0) {printf("\nbmp图片为非压缩!");}printf(" ");
     
158.     fwrite(&img.datasize, sizeof(DWORD), 1, infile);//printf("\nBMP Data Size        :%l ",img->datasize);
     
159.     fwrite(&img.bixpm, sizeof(DWORD), 1, infile);
     
160.     fwrite(&img.biypm, sizeof(DWORD), 1, infile);
     
161.     fwrite(&img.clrused, sizeof(DWORD), 1, infile);    //printf("\n实际使用颜色数=%d ",img->clrused);printf(" ");
     
162.     fwrite(&img.relclrused, sizeof(DWORD), 1, infile);
     
163.    
     
164.     byte *wbmp=(byte*)malloc(w4);//后面多加两个字节，用于4字节对齐
     
165.     for(int i=0,s,w;i<height;i++)
     
166.     {
     
167.         s=i*width;
     
168.         w=i*img.lineBytes;
     
169.         for(int j=0;j<width;j++)
     
170.         {
     
171.             if(bmp[s+j]){
     
172.                 wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=bmp[s+j];
     
173.             }
     
174.             else wbmp[w+j*3]=wbmp[w+j*3+1]=wbmp[w+j*3+2]=0;               
     
175.         }
     
176.     }
     
177.     fwrite(wbmp,img.datasize,1,infile);
     
178.     free(wbmp);
     
179.     fclose(infile);
     
180. }
     
181. 
     
182. //水平投影，从中间往两边计算，从而去掉最上面与最下面的多余部分
     
183. void shuipingtouying(struct Bmp1 *img,byte *dst)//得到车牌的上下边缘
     
184. {
     
185.     byte temp;
     
186.     int i,j,m,n;
     
187.     int *p=(int*)malloc(img->height*sizeof(int));//申请以行为单位的整型内存数
     
188. 
     
189.     for(i=0;i<img->width;i++)//宽度循环
     
190.     {
     
191.         if((dst[i]==255)||(dst[img->width+i]==255))//如果第一行 或 第二行有白点
     
192.         for(j=0;j<img->height;j++)//消除此白点，直到碰到黑点退出
     
193.         {
     
194.             if(dst[j*img->width+i]==255)
     
195.                 dst[j*img->width+i]=0;
     
196.             else break;
     
197.         }
     
198.     }
     
199.     for(i=0;i<img->width;i++)
     
200.     {
     
201.         //倒数1，2行中有白点，则消除，否则退出
     
202.         if((dst[img->width*(img->height-1)+i]==255)||(dst[img->width*(img->height-2)+i]==255))
     
203.             for(j=img->height-1;j>0;j--)
     
204.             {
     
205.                 if(dst[j*img->width+i]==255)
     
206.                     dst[j*img->width+i]=0;
     
207.                 else break;
     
208.             }
     
209.     }
     
210. 
     
211.     //记录每一行的白点数
     
212.     for(i=0;i<img->height;i++)
     
213.     {
     
214.         p[i]=0;
     
215.         for(j=0;j<img->width;j++)
     
216.         {
     
217.             if(dst[i*img->width+j]==255)
     
218.                 p[i]++;
     
219.         }
     
220.     }
     
221. 
     
222.     //找到白点数最多的行
     
223.     temp=0;
     
224.     for(i=0;i<img->height;i++)
     
225.     {
     
226.         if(p[i]>temp)
     
227.         {
     
228.           temp=p[i];
     
229.         }
     
230.     }
     
231. 
     
232.     n=temp/5;//以20%做为阀值
     
233.     img->up=0;
     
234.     img->down=img->height;
     
235.     m=img->height/2;
     
236.     for(i=m-1;i>0;i--)//从中间往上下遍历，如果有一行的白点数小于20%，则做为起点与终点
     
237.     {
     
238.         if(p[i]<n)
     
239.         {
     
240.             img->up=i+1;//只有第一次，才赋值
     
241.             break;
     
242.         }
     
243.     }
     
244.     for(i=m+1;i<img->height;i++)//从下面往中间遍历
     
245.     {
     
246.         if(p[i]<n)
     
247.         {
     
248.             img->down=i-1;
     
249.             break;
     
250.         }
     
251.     }
     
252.     free(p);
     
253. 
     
254.     //删除起始行之前的白点
     
255.     for(i=0;i<img->up;i++)
     
256.     {
     
257.         for(j=0;j<img->width;j++)
     
258.         {
     
259.             dst[i*img->width+j]=0;
     
260.         }
     
261.     }
     
262.    
     
263.     //删除结束行之后的白点
     
264.     for(i=img->down+1;i<img->height;i++)
     
265.     {
     
266.         for(j=0;j<img->width;j++)
     
267.         {
     
268.             dst[i*img->width+j]=0;
     
269.         }
     
270.     }
     
271. }
     
272. 
     
273. //垂直投影法
     
274. void cuizhitouying(struct Bmp1 *img,byte *temp)
     
275. {
     
276.     DWORD i,j;
     
277.     int num,flag;
     
278. 
     
279.     int up;
     
280.     int down;
     
281.     int bd;//当前列白点数
     
282. 
     
283.     //计算1个字符的宽度,也就是1块车牌的宽度，把所有字挨紧，空白区域占30%左右
     
284.     //然后一块车牌有7个字，所以一个字的宽度大根是width*0.7/7
     
285.     num=flag=0;
     
286.     up=img->height;//最高一个白点
     
287.     down=0;//最低一个白点
     
288.     for(i=0;i<img->width;i++)//按宽遍历
     
289.     {
     
290.         bd=0;
     
291.         for(j=0;j<img->height;j++)//按高遍历，也就是1列1列的遍历
     
292.         {
     
293.             if(temp[j*img->width+i]==255)//记录每列白点数
     
294.             {
     
295.                 bd++;
     
296.                 if(up>j)up=j;//最高白点
     
297.                 if(down<j)down=j;//记住最后一个白点的位置
     
298.             }
     
299.         }
     
300. 
     
301.         if(bd)//当前列有白点
     
302.         {
     
303.             if(flag==0)//还没有记录起点
     
304.             {
     
305.                 flag=1;
     
306.                 img->left[num]=i;//记录下起点
     
307.             }
     
308.         }
     
309.         else//当前列没白点
     
310.         {
     
311.             if(flag)//如果已记录了起点
     
312.             {
     
313.                 if((down-up)+1>img->height/2)//找到正确的字符
     
314.                 {
     
315.                     img->right[num]=i-1;//记录结束区域
     
316.                     img->top[num]=up;
     
317.                     img->bottom[num]=down;
     
318.                     num++;//查找下一个字符
     
319.                 }
     
320.                 flag=0;//记录下一个记点
     
321.                 up=img->height;
     
322.                 down=0;
     
323.             }
     
324.         }
     
325.     }
     
326.     //如果最后一个没有结束
     
327.     if(flag){
     
328.         img->right[num]=img->width-1;
     
329.         img->top[num]=up;
     
330.         img->bottom[num]=down;
     
331.         num++;
     
332.     }
     
333.         
     
334.     if(num<7)//位数不够
     
335.     {
     
336.         printf("car no min error\n");
     
337.     }
     
338.     else if(num>7)//如果找到多于7个字符，说明里面有一个“川”字
     
339.     {
     
340.         printf("car no error\n");
     
341.     }
     
342. }
     
343. 
     
344. //复制单个字符，存进数组中
     
345. void strBmp(struct Bmp1 *img,byte *temp)
     
346. {
     
347.     int i,j,k,n;
     
348.     //int w,h;
     
349.     for(i=0;i<7;i++)
     
350.     {
     
351.         n=0;
     
352.         for(j=img->top[i];j<=img->bottom[i];j++)//高度循环
     
353.         {
     
354.             for(k=img->left[i];k<=img->right[i];k++)//宽度循环
     
355.             {
     
356.                 img->strr[i][n++]=temp[j*img->width+k];
     
357.             }
     
358.         }
     
359.         if(i==0)WriteBmp1("z1.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
360.         if(i==1)WriteBmp1("z2.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
361.         if(i==2)WriteBmp1("z3.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
362.         if(i==3)WriteBmp1("z4.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
363.         if(i==4)WriteBmp1("z5.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
364.         if(i==5)WriteBmp1("z6.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
365.         if(i==6)WriteBmp1("z7.bmp",img->strr[i],img->right[i]-img->left[i]+1,img->bottom[i]-img->top[i]+1);
     
366.     }
     
367. }
     
368. 
     
369. //缩放到指定的宽度与高度
     
370. void changeGray(byte *srcBmp,byte *dstBmp,int width,int height,int nWidth,int nHeight)
     
371. {
     
372.     int i=0,j=0,i0,j0;
     
373.     float xx;float yy;
     
374.     xx=(float)nWidth/width;//宽度缩放比
     
375.     yy=(float)nHeight/height;
     
376. 
     
377.     memset(dstBmp,0x00,nHeight*nWidth*sizeof(byte));
     
378.     if(width<nWidth/2)//说明为1
     
379.     {
     
380.         for(i=0;i<nHeight;i++)
     
381.         {
     
382.             for(j=0;j<width;j++)
     
383.             {
     
384.                 if(i<=height)
     
385.                 {
     
386.                     dstBmp[i*nWidth+j]=srcBmp[i*width+j];
     
387.                 }
     
388.                 else{
     
389.                     dstBmp[i*nWidth+j]=srcBmp[(height-1)*width+j];
     
390.                 }
     
391.             }
     
392.         }
     
393.     }
     
394.     else
     
395.     {
     
396.         for(i = 0; i <nHeight; i++)
     
397.         {
     
398.             for(j = 0; j <nWidth; j++)
     
399.             {
     
400.                 //i0 = (int) ((float)i/yy+0.5);
     
401.                 //j0 = (int) ((float)j/xx+0.5);
     
402.                 i0 = (int) ((float)i/yy);
     
403.                 j0 = (int) ((float)j/xx);
     
404.                 if((j0>=0)&&(j0<width)&&(i0>=0)&&(i0<height))
     
405.                 // {
     
406.                     dstBmp[i*nWidth+j]=srcBmp[i0*width+j0];
     
407.                  //}
     
408.                  //else
     
409.                  //{
     
410.                 //    dstBmp[i*nWidth+j]=255;
     
411.                  //}
     
412.             }
     
413.         }
     
414.     }
     
415. }
     
416. 
     
417. void guiyi(struct Bmp1 *img)
     
418. {
     
419.     int xxx;
     
420.     int i;
     
421.     int yyy;
     
422. 
     
423.     byte *temp=(byte *)malloc(sizeof(byte)*512);
     
424.     for(i=0;i<7;i++)
     
425.     {
     
426.         xxx=img->right[i]-img->left[i]+1;
     
427.         yyy=img->bottom[i]-img->top[i]+1;
     
428. 
     
429.         changeGray(img->strr[i],temp,xxx,yyy,16,32);
     
430. 
     
431.         memcpy(img->strr[i],temp,sizeof(byte)*512);
     
432.         if(i==0)WriteBmp1("zz1.bmp",img->strr[i],16,32);
     
433.         if(i==1)WriteBmp1("zz2.bmp",img->strr[i],16,32);
     
434.         if(i==2)WriteBmp1("zz3.bmp",img->strr[i],16,32);
     
435.         if(i==3)WriteBmp1("zz4.bmp",img->strr[i],16,32);
     
436.         if(i==4)WriteBmp1("zz5.bmp",img->strr[i],16,32);
     
437.         if(i==5)WriteBmp1("zz6.bmp",img->strr[i],16,32);
     
438.         if(i==6)WriteBmp1("zz7.bmp",img->strr[i],16,32);
     
439.     }
     
440. }
     
441. 
     
442. int main(int argc, char **argv)
     
443. {
     
444.     struct BMP_img img;//定义结构
     
445.     struct Bmp1 img1;
     
446. 
     
447.     //把当前文件夹下的1.bmp文件内容，读到img结构中，并上下镜像
     
448.     if(read_img("1.bmp", &img)==0)
     
449.     {
     
450.         printf("error");
     
451.         return 0;
     
452.     }
     
453.    
     
454.     img1.width=img.width;
     
455.     img1.height=img.height;
     
456.     byte *temp=(byte*)malloc(img.width*img.height);
     
457.     //24位灰度图转单色灰度图
     
458.     for(int i=0;i<img.height;i++)
     
459.     {
     
460.         for(int j=0;j<img.width;j++)
     
461.         {
     
462.             temp[i*img.width+j]=img.image[i*img.width*3+j*3];
     
463.         }
     
464.     }
     
465.    
     
466.     //水平投影，去掉上下非文字区域
     
467.     shuipingtouying(&img1,temp);
     
468.    
     
469.     //垂直投影，去掉车牌中的点，并计算7个字各在什么位置
     
470.     cuizhitouying(&img1,temp);//垂直投影，框住每一个字符
     
471.    
     
472.     //写入镜像后的数据到2.bmp中
     
473.     WriteBmp1("2.bmp",temp,img.width,img.height);
     
474.    
     
475.     //把每个文字切出来
     
476.     strBmp(&img1,temp);//把车牌字符放到数组里面
     
477. 
     
478.     //缩放每个文字，与模板大小相等
     
479.     guiyi(&img1);
     
480.    
     
481.     free(img.image);//释放动态分配的内存
     
482.     free(temp);
     
483.    
     
484.     printf("请打开2.bmp进行查看\n");
     
485.     system("pause");
     
486.     return 0;
     
487. }
     

复制代码

原图