C++ BMP位图读取

 要识别图像中的字符，首先要会处理图像，把图像的信息读出来。这就必须先了解图像的结构，存储方式。清华大学出版的一本《数字图像处理编程入门》给了我不少帮助。第一章的Windows位图和调色板让我对bmp图像有了基本了解。对于彩色图，可以用RGB模型来表示。基本上所有颜色都可以用这三种颜色的组合来形成。但实际上也有一些差别，小于24位图都利用到了调色板，也就是一张R、G、B表，主要是为了节省存储空间。bmp文件结构如下：

                                                          图一 bmp位图结构示意图

 

第一部分为位图文件头BITMAPFILEHEADER，是一个结构，其定义如下：

typedef struct tagBITMAPFILEHEADER {

WORD           bfType;

DWORD bfSize;

WORD           bfReserved1;

WORD           bfReserved2;

DWORD bfOffBits;

} BITMAPFILEHEADER;

这个结构的长度是固定的，为14个字节(WORD为无符号16位整数，DWORD为无符号32位整数)，各个域的说明如下：

bfType

指定文件类型，必须是0x424D，即字符串“BM”，也就是说所有.bmp文件的头两个字节都是“BM”。

bfSize

指定文件大小，包括这14个字节。

bfReserved1，bfReserved2     

为保留字，不用考虑

bfOffBits

为从文件头到实际的位图数据的偏移字节数，即图1.3中前三个部分的长度之和。

第二部分为位图信息头BITMAPINFOHEADER，也是一个结构，其定义如下：

typedef struct tagBITMAPINFOHEADER{

DWORD  biSize;

LONG            biWidth;

LONG            biHeight;

WORD           biPlanes;

WORD           biBitCount

DWORD  biCompression;

DWORD  biSizeImage;

LONG            biXPelsPerMeter;

LONG            biYPelsPerMeter;

DWORD  biClrUsed;

DWORD  biClrImportant;

} BITMAPINFOHEADER;

这个结构的长度是固定的，为40个字节(LONG为32位整数)，各个域的说明如下：

biSize

指定这个结构的长度，为40。

biWidth

指定图象的宽度，单位是象素。

biHeight

指定图象的高度，单位是象素。

biPlanes

必须是1，不用考虑。

biBitCount

指定表示颜色时要用到的位数，常用的值为1(黑白二色图), 4(16色图), 8(256色), 24(真彩色图)(新的.bmp格式支持32位色，这里就不做讨论了)。

biCompression

指定位图是否压缩，有效的值为BI_RGB，BI_RLE8，BI_RLE4，BI_BITFIELDS(都是一些Windows定义好的常量)。要说明的是，Windows位图可以采用RLE4，和RLE8的压缩格式，但用的不多。我们今后所讨论的只有第一种不压缩的情况，即biCompression为BI_RGB的情况。

biSizeImage

指定实际的位图数据占用的字节数，其实也可以从以下的公式中计算出来：

biSizeImage=biWidth’ × biHeight

要注意的是：上述公式中的biWidth’必须是4的整倍数(所以不是biWidth，而是biWidth’，表示大于或等于biWidth的，最接近4的整倍数。举个例子，如果biWidth=240，则biWidth’=240；如果biWidth=241，biWidth’=244)。

如果biCompression为BI_RGB，则该项可能为零

biXPelsPerMeter

指定目标设备的水平分辨率，单位是每米的象素个数，关于分辨率的概念，我们将在第4章详细介绍。

biYPelsPerMeter

指定目标设备的垂直分辨率，单位同上。

biClrUsed

指定本图象实际用到的颜色数，如果该值为零，则用到的颜色数为2^biBitCount。

biClrImportant

指定本图象中重要的颜色数，如果该值为零，则认为所有的颜色都是重要的。

第三部分为调色板Palette，当然，这里是对那些需要调色板的位图文件而言的。有些位图，如真彩色图，前面已经讲过，是不需要调色板的，BITMAPINFOHEADER后直接是位图数据。

调色板实际上是一个数组，共有biClrUsed个元素(如果该值为零，则有2^biBitCount个元素)。数组中每个元素的类型是一个RGBQUAD结构，占4个字节，其定义如下：

typedef struct tagRGBQUAD {

BYTE    rgbBlue; //该颜色的蓝色分量

BYTE    rgbGreen; //该颜色的绿色分量

BYTE    rgbRed; //该颜色的红色分量

BYTE    rgbReserved; //保留值

} RGBQUAD;

第四部分就是实际的图象数据了。对于用到调色板的位图，图象数据就是该象素颜在调色板中的索引值。对于真彩色图，图象数据就是实际的R、G、B值。下面针对2色、16色、256色位图和真彩色位图分别介绍。

对于2色位图，用1位就可以表示该象素的颜色(一般0表示黑，1表示白)，所以一个字节可以表示8个象素。

对于16色位图，用4位可以表示一个象素的颜色，所以一个字节可以表示2个象素。

对于256色位图，一个字节刚好可以表示1个象素。

对于真彩色图，三个字节才能表示1个象素，哇，好费空间呀！没办法，谁叫你想让图的颜色显得更亮丽呢，有得必有失嘛。

 

要注意两点：

(1)    每一行的字节数必须是4的整倍数，如果不是，则需要补齐。这在前面介绍biSizeImage时已经提到了。

(2)    一般来说，.bMP文件的数据从下到上，从左到右的。也就是说，从文件中最先读到的是图象最下面一行的左边第一个象素，然后是左边第二个象素……接下来是倒数第二行左边第一个象素，左边第二个象素……依次类推 ，最后得到的是最上面一行的最右一个象素。

 

 

      当了解了这些后，就可以将图片灰度化，编程黑白二色图片。再读出bmp文件的像素信息，可以将其存储在一个一维数组里面，其他的信息还有宽度和高度。以后处理图片就是直接对这个数组进行处理。接下来是进行去噪处理。一些图片常常有噪点，对识别效果造成影响，所以必须进行去噪。去噪方法很多。我的做法是对一个像素点作如下处理：取它和周围8个点共9个点的像素的平均值，效果还可以。

      接下来的操作我都是参考的一篇哈尔滨工业大学工学硕士学位论文，上面的思路很清晰，感觉很不错。首先是归一化，即将图片编程32*32大小的图片。

      另一种方法是非线性归一化，但是上面的求质心和散度公式看不清楚，而且没有告诉怎么用质心和散度去实现归一化。所以我就采用了线性归一化。效果比非线性归一化要差一些。

      归一化之后是特征提取。

    网格特征就是将32*32的图片分成4*4共16块，每个方块64个小方块。求黑色像素的个数就行了。穿越特征包括水平穿越特征和垂直穿越特征。水平穿越特征即把图片按行分成8行，每行4小行。计算每一行由白色像素到黑色像素的变化次数即可。即得到前8维水平穿越特征t1,t2,..,t8。后8维水平穿越特征利用公式求解。Pi=ti/[(t1+t2+..+t8)*10+0.5]。垂直穿越特征则类似。

      16维网格特征、16维水平穿越特征和16维垂直穿越特征合起来总共48维特征。还可以求加权特征，形成64维特征。

      最后是模板匹配。根据相应特征值的差值的平方和进行匹配。

 

 

 

[cpp]  view plain copy

1. #include<math.h>  
2. #include <iomanip.h>   
3. #include <stdlib.h>  
4. #include <windows.h>  
5. #include <stdio.h>  
6. #include <stdlib.h>  
7. #include <iostream.h>  
8. #include <fstream.h>  
9.   
10. //---------------------------------------------------------------------------------------  
11. //以下该模块是完成BMP图像(彩色图像是24bit RGB各8bit)的像素获取，并存在文件名为xiang_su_zhi.txt中  
12. unsigned char *pBmpBuf;//读入图像数据的指针  
13.   
14. int bmpWidth;//图像的宽  
15. int bmpHeight;//图像的高  
16. RGBQUAD *pColorTable;//颜色表指针  
17.   
18. int biBitCount;//图像类型，每像素位数  
19.   
20. //-------------------------------------------------------------------------------------------  
21. //读图像的位图数据、宽、高、颜色表及每像素位数等数据进内存，存放在相应的全局变量中  
22. bool readBmp(char *bmpName)   
23. {  
24.     FILE *fp=fopen(bmpName,"rb");//二进制读方式打开指定的图像文件  
25.   
26.     if(fp==0)  
27.         return 0;  
28.   
29.     //跳过位图文件头结构BITMAPFILEHEADER  
30.   
31.     fseek(fp, sizeof(BITMAPFILEHEADER),0);  
32.   
33.     //定义位图信息头结构变量，读取位图信息头进内存，存放在变量head中  
34.   
35.     BITMAPINFOHEADER head;    
36.   
37.     fread(&head, sizeof(BITMAPINFOHEADER), 1,fp); //获取图像宽、高、每像素所占位数等信息  
38.   
39.     bmpWidth = head.biWidth;  
40.   
41.     bmpHeight = head.biHeight;  
42.   
43.     biBitCount = head.biBitCount;//定义变量，计算图像每行像素所占的字节数（必须是4的倍数）  
44.   
45.     int lineByte=(bmpWidth * biBitCount/8+3)/4*4;//灰度图像有颜色表，且颜色表表项为256  
46.   
47.     if(biBitCount==8)  
48.     {  
49.   
50.         //申请颜色表所需要的空间，读颜色表进内存  
51.   
52.         pColorTable=new RGBQUAD[256];  
53.   
54.         fread(pColorTable,sizeof(RGBQUAD),256,fp);  
55.   
56.     }  
57.   
58.     //申请位图数据所需要的空间，读位图数据进内存  
59.   
60.     pBmpBuf=new unsigned char[lineByte * bmpHeight];  
61.   
62.     fread(pBmpBuf,1,lineByte * bmpHeight,fp);  
63.   
64.     fclose(fp);//关闭文件  
65.   
66.     return 1;//读取文件成功  
67. }  
68.   
69. //-----------------------------------------------------------------------------------------  
70. //给定一个图像位图数据、宽、高、颜色表指针及每像素所占的位数等信息,将其写到指定文件中  
71. bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height, int biBitCount, RGBQUAD *pColorTable)  
72. {  
73.   
74.     //如果位图数据指针为0，则没有数据传入，函数返回  
75.   
76.     if(!imgBuf)  
77.         return 0;  
78.   
79.     //颜色表大小，以字节为单位，灰度图像颜色表为1024字节，彩色图像颜色表大小为0  
80.   
81.     int colorTablesize=0;  
82.   
83.     if(biBitCount==8)  
84.         colorTablesize=1024;  
85.   
86.     //待存储图像数据每行字节数为4的倍数  
87.   
88.     int lineByte=(width * biBitCount/8+3)/4*4;  
89.   
90.     //以二进制写的方式打开文件  
91.   
92.     FILE *fp=fopen(bmpName,"wb");  
93.   
94.     if(fp==0)  
95.         return 0;  
96.   
97.     //申请位图文件头结构变量，填写文件头信息  
98.   
99.     BITMAPFILEHEADER fileHead;  
100.   
101.     fileHead.bfType = 0x4D42;//bmp类型  
102.   
103.     //bfSize是图像文件4个组成部分之和  
104.   
105.     fileHead.bfSize= sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + colorTablesize + lineByte*height;  
106.   
107.     fileHead.bfReserved1 = 0;  
108.   
109.     fileHead.bfReserved2 = 0;  
110.   
111.     //bfOffBits是图像文件前3个部分所需空间之和  
112.   
113.     fileHead.bfOffBits=54+colorTablesize;  
114.   
115.     //写文件头进文件  
116.   
117.     fwrite(&fileHead, sizeof(BITMAPFILEHEADER),1, fp);  
118.   
119.     //申请位图信息头结构变量，填写信息头信息  
120.   
121.     BITMAPINFOHEADER head;   
122.   
123.     head.biBitCount=biBitCount;  
124.   
125.     head.biClrImportant=0;  
126.   
127.     head.biClrUsed=0;  
128.   
129.     head.biCompression=0;  
130.   
131.     head.biHeight=height;  
132.   
133.     head.biPlanes=1;  
134.   
135.     head.biSize=40;  
136.   
137.     head.biSizeImage=lineByte*height;  
138.   
139.     head.biWidth=width;  
140.   
141.     head.biXPelsPerMeter=0;  
142.   
143.     head.biYPelsPerMeter=0;  
144.   
145.     //写位图信息头进内存  
146.   
147.     fwrite(&head, sizeof(BITMAPINFOHEADER),1, fp);  
148.   
149.     //如果灰度图像，有颜色表，写入文件   
150.   
151.     if(biBitCount==8)  
152.         fwrite(pColorTable, sizeof(RGBQUAD),256, fp);  
153.   
154.     //写位图数据进文件  
155.   
156.     fwrite(imgBuf, height*lineByte, 1, fp);  
157.   
158.     //关闭文件  
159.   
160.     fclose(fp);  
161.   
162.     return 1;  
163.   
164. }  
165.   
166. //----------------------------------------------------------------------------------------  
167. //以下为像素的读取函数  
168. void doIt()  
169. {  
170.   
171.     //读入指定BMP文件进内存  
172.   
173.     char readPath[]="nv.BMP";  
174.   
175.     readBmp(readPath);  
176.   
177.     //输出图像的信息  
178.   
179.     cout<<"width="<<bmpWidth<<" height="<<bmpHeight<<" biBitCount="<<biBitCount<<endl;  
180.       
181.     //循环变量，图像的坐标  
182.   
183.     //每行字节数  
184.   
185.     int lineByte=(bmpWidth*biBitCount/8+3)/4*4;  
186.   
187.     //循环变量，针对彩色图像，遍历每像素的三个分量  
188.   
189.     int m=0,n=0,count_xiang_su=0;  
190.   
191.     //将图像左下角1/4部分置成黑色  
192.    
193.     ofstream outfile("图像像素.txt",ios::in|ios::trunc);  
194.   
195.     if(biBitCount==8) //对于灰度图像  
196.     {                
197.     //------------------------------------------------------------------------------------  
198.     //以下完成图像的分割成8*8小单元，并把像素值存储到指定文本中。由于BMP图像的像素数据是从  
199.     //左下角：由左往右，由上往下逐行扫描的  
200.         int L1=0;  
201.         int hang=63;  
202.         int lie=0;  
203.         //int L2=0;  
204.         //int fen_ge=8;  
205.         for(int fen_ge_hang=0;fen_ge_hang<8;fen_ge_hang++)//64*64矩阵行循环  
206.         {   
207.             for(int fen_ge_lie=0;fen_ge_lie<8;fen_ge_lie++)//64*64列矩阵循环  
208.             {   
209.             //--------------------------------------------  
210.                 for(L1=hang;L1>hang-8;L1--)//8*8矩阵行  
211.                 {  
212.                     for(int L2=lie;L2<lie+8;L2++)//8*8矩阵列  
213.                     {  
214.                         m=*(pBmpBuf+L1*lineByte+L2);  
215.                         outfile<<m<<" ";  
216.                         count_xiang_su++;  
217.                         if(count_xiang_su%8==0)//每8*8矩阵读入文本文件  
218.                         {  
219.                             outfile<<endl;  
220.                         }  
221.                     }  
222.                 }  
223.             //---------------------------------------------  
224.                 hang=63-fen_ge_hang*8;//64*64矩阵行变换  
225.                 lie+=8;//64*64矩阵列变换  
226.                     //该一行（64）由8个8*8矩阵的行组成  
227.             }  
228.             hang-=8;//64*64矩阵的列变换  
229.             lie=0;//64*64juzhen  
230.         }  
231.     }  
232.   
233.     //double xiang_su[2048];  
234.     //ofstream outfile("xiang_su_zhi.txt",ios::in|ios::trunc);  
235.     if(!outfile)  
236.     {  
237.         cout<<"open error!"<<endl;  
238.         exit(1);  
239.     }  
240.     else if(biBitCount==24)  
241.     {//彩色图像  
242.         for(int i=0;i<bmpHeight;i++)  
243.         {  
244.             for(int j=0;j<bmpWidth;j++)  
245.             {  
246.                 for(int k=0;k<3;k++)//每像素RGB三个分量分别置0才变成黑色  
247.                 {  
248.                     //*(pBmpBuf+i*lineByte+j*3+k)-=40;  
249.                     m=*(pBmpBuf+i*lineByte+j*3+k);  
250.                     outfile<<m<<" ";  
251.                     count_xiang_su++;  
252.                     if(count_xiang_su%8==0)  
253.                     {  
254.                         outfile<<endl;  
255.                     }  
256.                 //n++;  
257.                 }  
258.                 n++;  
259.             }  
260.   
261.   
262.         }  
263.         cout<<"总的像素个素为:"<<n<<endl;  
264.         cout<<"----------------------------------------------------"<<endl;  
265.     }  
266.       
267.     //将图像数据存盘  
268.       
269.     char writePath[]="nvcpy.BMP";//图片处理后再存储  
270.   
271.     saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);  
272.   
273.     //清除缓冲区，pBmpBuf和pColorTable是全局变量，在文件读入时申请的空间  
274.   
275.     delete []pBmpBuf;  
276.   
277.     if(biBitCount==8)  
278.         delete []pColorTable;  
279. }  
280.   
281. void main()  
282. {  
283.     doIt();  
284. }