C++8位和24位bmp位图平滑、锐化和二值处理，24位真彩图的灰度化

BMP头文件：

[cpp]  view plain  copy

 

1. #ifndef BMP_H//预处理器  
2. #define BMP_H  
3.   
4. typedef unsigned char BYTE;  
5. typedef unsigned short WORD;  
6. typedef unsigned int DWORD;  
7. typedef long LONG;  
8.   
9. //BMP文件头（14字节）  
10. typedef struct tagBITMAPFILEHEADER {  
11.     //WORD bfType;//位图文件的类型，必须为BM(在结构体中读取会发生错误，所以在函数中读取)  
12.     DWORD bfSize;//位图文件的大小，以字节为单位  
13.     WORD bfReserved1;//位图文件保留字，必须为0  
14.     WORD bfReserved2;//位图文件保留字，必须为0  
15.     DWORD bfOffBits;//位图数据的起始位置，以相对于位图文件头的偏移量表示，以字节为单位  
16. }BITMAPFILEHEADER;  
17.   
18. //BMP信息头（40字节）  
19. typedef struct tagBITMAPINFOHEADER {  
20.     DWORD biSize;//本结构所占用字节数  
21.     LONG biWidth;//位图的宽度，以像素为单位  
22.     LONG biHeight;//位图的高度，以像素为单位  
23.     WORD biPlanes;//目标设备的级别，必须为1  
24.     WORD biBitCount;//每个像素所需的位数，必须是1（双色），4(16色），8(256色）16(高彩色)或24（真彩色）之一  
25.     DWORD biCompression;//位图压缩类型，必须是0（不压缩）,1(BI_RLE8压缩类型）或2(BI_RLE4压缩类型）之一  
26.     DWORD biSizeImage;//位图的大小(其中包含了为了补齐行数是4的倍数而添加的空字节)，以字节为单位  
27.     LONG biXPelsPerMeter;//位图水平分辨率，每米像素数  
28.     LONG biYPelsPerMeter;//位图垂直分辨率，每米像素数  
29.     DWORD biClrUsed;//位图实际使用的颜色表中的颜色数  
30.     DWORD biClrImportant;//位图显示过程中重要的颜色数  
31. }BITMAPINFOHEADER;  
32.   
33. //调色板  
34. //只有8位位图才用调色板，用像素值作为索引（0~255），调色板中RGB值都是一样的，范围是0~255  
35. //一个unsigned char的范围刚好是0~255，所以用BYTE类型存储8位位图的像素  
36. typedef struct tagRGBQUAD {  
37.     BYTE rgbBlue;  
38.     BYTE rgbGreen;  
39.     BYTE rgbRed;  
40.     BYTE rgbReserved;//保留，必须为0  
41. }RGBQUAD;  
42.   
43. //像素信息  
44. //8位BMP图1个字节代表一个像素，所以可以不用结构存储像素素组，直接用一个指针即可  
45. typedef struct tagIMAGEDATA {  
46.     BYTE blue;  
47.     BYTE green;  
48.     BYTE red;  
49. }IMAGEDATA;  
50.   
51. #endif  

8位BMP头文件：

[cpp]  view plain  copy

 

1. #ifndef EIGHTBITMAP_H//预处理器  
2. #define EIGHTBITMAP_H  
3.   
4. #include<iostream>  
5. #include"BMP.h"  
6. using namespace std;  
7.   
8. class eightBitMap {  
9. private:  
10.     char imageName[30];//图像名  
11.     int width, height;//图像的宽高  
12.     BITMAPFILEHEADER bmpHead;//文件头  
13.     BITMAPINFOHEADER bmpInfo;//信息头  
14.     BYTE *imagedata = NULL, *newimagedata = NULL;//存储图片像素信息的二维数组  
15.     RGBQUAD *pallet = new RGBQUAD[256];//调色板指针  
16.     FILE *fpin, *fpout;//文件指针  
17.   
18.                        //平滑算子也是通过模板进行处理的，所以可以把平滑处理和锐化处理通过一个函数实现  
19.     int Template1[3][3]{ 1,1,1,1,1,1,1,1,1 };//平滑模板  
20.     int Template2[3][3]{ 0,-1,0,-1,5,-1,0,-1,0 };//laplace锐化模板,4邻域（原图减去轮廓）  
21.     int Template3[3][3]{ -1,-1,-1,-1,9,-1,-1,-1,-1 };//laplace锐化模板,8邻域  
22. public:  
23.     bool readImage();//读取图片  
24.     bool writeImage();//保存图片  
25.     bool Operation(int x);//图像平滑和锐化处理  
26.     bool Operation(int Template[][3], int coefficient);//图像处理  
27.     bool Binarization();//二值化  
28.     void showBmpHead(BITMAPFILEHEADER BmpHead);//显示文件头  
29.     void showBmpInfo(tagBITMAPINFOHEADER BmpInfo);//显示信息头  
30. };  
31. bool eightBitMap::readImage() {  
32.     cout << "输入要读取的图片名：";  
33.     cin >> imageName;  
34.     if (!fopen_s(&fpin, imageName, "rb")) {  
35.         //读取图片类型  
36.         WORD bfType;  
37.         fread(&bfType, sizeof(WORD), 1, fpin);//fread()的使用  
38.         if (bfType != 0x4d42) {  
39.             cout << "该图片不是BMP！" << endl;  
40.             return false;  
41.         }  
42.         //读取文件头和信息头  
43.         fread(&bmpHead, sizeof(tagBITMAPFILEHEADER), 1, fpin);  
44.         fread(&bmpInfo, sizeof(tagBITMAPINFOHEADER), 1, fpin);  
45.         //检查是否是8位位图  
46.         if (bmpInfo.biBitCount != 8) {  
47.             cout << "该图片不是8位！" << endl;  
48.             return false;  
49.         }  
50.         //读取调色板  
51.         fread(pallet, sizeof(RGBQUAD), 256, fpin);  
52.         //读取图片的像素信息  
53.         width = bmpInfo.biWidth;  
54.         height = bmpInfo.biHeight;  
55.         width = (width*sizeof(BYTE) + 3) / 4 * 4;//图像的每一行必须是4的整数倍  
56.         imagedata = new BYTE[width*height];  
57.         fread(imagedata, sizeof(BYTE)*width, height, fpin);  
58.         //显示文件头和信息头  
59.         showBmpHead(bmpHead);  
60.         showBmpInfo(bmpInfo);  
61.         //关闭图片  
62.         fclose(fpin);  
63.     }  
64.     else {  
65.         cout << "图片不存在！" << endl;  
66.         return false;  
67.     }  
68.     return true;  
69. }  
70. bool eightBitMap::writeImage() {  
71.     char imageName[30];  
72.     cout << "输入处理后的位图名：";  
73.     cin >> imageName;  
74.     //创建位图文件  
75.     if (fopen_s(&fpout, imageName, "wb")) {  
76.         cout << "创建文件失败！" << endl;  
77.         return false;  
78.     }  
79.     //写入位图类型  
80.     WORD bfBYTE = 0x4d42;  
81.     fwrite(&bfBYTE, 1, sizeof(WORD), fpout);  
82.     //写入文件头和信息头  
83.     fwrite(&bmpHead, 1, sizeof(BITMAPFILEHEADER), fpout);  
84.     fwrite(&bmpInfo, 1, sizeof(BITMAPINFOHEADER), fpout);  
85.     //写入调色板  
86.     fwrite(pallet, sizeof(RGBQUAD), 256, fpout);  
87.     //写入图像像素数据  
88.     fwrite(newimagedata, sizeof(BYTE)*width, height, fpout);  
89.     //关闭图片  
90.     fclose(fpout);  
91.     //释放内存  
92.     delete imagedata;  
93.     delete newimagedata;  
94.     delete pallet;  
95.     return true;  
96. }  
97. bool eightBitMap::Operation(int x) {  
98.     if (x == 1)  
99.         return Operation(Template1, 9);  
100.     else if (x == 2)  
101.         return Operation(Template2, 1);  
102.     else if (x == 3)  
103.         return Operation(Template3, 1);  
104.     else {  
105.         cout << "模板调用错误！" << endl;  
106.         return false;  
107.     }  
108. }  
109. bool eightBitMap::Operation(int Template[][3], int coefficient) {  
110.     //分配新像素素组的空间  
111.     newimagedata = new BYTE[width*height];  
112.     //进行模板操作  
113.     for (int i = 0; i < height; ++i)  
114.         for (int j = 0; j < width; ++j) {  
115.             if (i == 0 || j == 0 || i == height - 1 || j == width - 1)  
116.                 *(newimagedata + i*width + j) = *(imagedata + i*width + j);  
117.             else {  
118.                 int sum = 0;  
119.                 for (int m = i - 1; m < i + 2; ++m)  
120.                     for (int n = j - 1; n < j + 2; ++n) {  
121.                         sum += (*(imagedata + m*width + n))*Template[n - j + 1][m - i + 1] / coefficient;  
122.                     }  
123.                 //8位BMP中一个像素值，对应调色板中索引号为该像素值的项所存放的RGB色彩  
124.                 //所以像素值范围为0~255  
125.                 //像素值小于0就取0，大于255就取255  
126.                 sum = (sum >= 0) ? sum : 0;  
127.                 sum = ((sum + *(imagedata + i*width + j))>255) ? 255 : sum;  
128.                 *(newimagedata + i*width + j) = sum;  
129.             }  
130.         }  
131.     //保存图片  
132.     if (writeImage()) {  
133.         cout << "\n处理成功！" << endl;  
134.         return true;  
135.     }  
136.     else {  
137.         cout << "\n处理失败！" << endl;  
138.         return false;  
139.     }  
140. }  
141. bool eightBitMap::Binarization() {  
142.     //分配新像素素组的空间  
143.     newimagedata = new BYTE[width*height];  
144.     //二值化操作  
145.     for (int i = 0; i < width*height; ++i)  
146.         if (*(imagedata + i) > 128)  
147.             *(newimagedata + i) = 255;  
148.         else  
149.             *(newimagedata + i) = 0;  
150.     //保存图片  
151.     if (writeImage()) {  
152.         cout << "\n处理成功！" << endl;  
153.         return true;  
154.     }  
155.     else {  
156.         cout << "\n处理失败！" << endl;  
157.         return false;  
158.     }  
159. }  
160. void eightBitMap::showBmpHead(BITMAPFILEHEADER BmpHead) {  
161.     cout << "\n图片文件头:" << endl;  
162.     cout << "  图片大小:" << BmpHead.bfSize << endl;  
163.     cout << "  保留字_1:" << BmpHead.bfReserved1 << endl;  
164.     cout << "  保留字_2:" << BmpHead.bfReserved2 << endl;  
165.     cout << "  实际位图片数据的偏移字节数:" << BmpHead.bfOffBits << endl;  
166. }  
167. void eightBitMap::showBmpInfo(tagBITMAPINFOHEADER BmpInfo) {  
168.     cout << "图片信息头:" << endl;  
169.     cout << "  结构体的长度:" << BmpInfo.biSize << endl;  
170.     cout << "  位图宽:" << BmpInfo.biWidth << endl;  
171.     cout << "  位图高:" << BmpInfo.biHeight << endl;  
172.     cout << "  平面数:" << BmpInfo.biPlanes << endl;  
173.     cout << "  采用颜色位数:" << BmpInfo.biBitCount << endl;  
174.     cout << "  压缩方式:" << BmpInfo.biCompression << endl;  
175.     cout << "  实际位图数据占用的字节数:" << BmpInfo.biSizeImage << endl;  
176.     cout << "  X方向分辨率:" << BmpInfo.biXPelsPerMeter << endl;  
177.     cout << "  Y方向分辨率:" << BmpInfo.biYPelsPerMeter << endl;  
178.     cout << "  使用的颜色数:" << BmpInfo.biClrUsed << endl;  
179.     cout << "  重要颜色数:" << BmpInfo.biClrImportant << endl;  
180. }  
181.   
182. #endif  

24位BMP头文件：

[cpp]  view plain  copy

 

1. #ifndef TWENTYFOURBITMAP_H  
2. #define TWENTYDOURBITMAP_H  
3.   
4. #include <iostream>  
5. #include "BMP.h"  
6. using namespace std;  
7.   
8. class twentyfourBitMap {  
9.     char imageName[30];//图像名  
10.     int width, height;//图像的宽高  
11.     BITMAPFILEHEADER bmpHead;//文件头  
12.     BITMAPINFOHEADER bmpInfo;//信息头  
13.     IMAGEDATA *imagedata = NULL, *newimagedata = NULL;//存储图片像素信息的二维数组  
14.     FILE *fpin, *fpout;//文件指针  
15.   
16.                        //平滑算子也是通过模板进行处理的，所以可以把平滑处理和锐化处理通过一个函数实现  
17.     int Template1[3][3]{ 1,1,1,1,1,1,1,1,1 };//平滑模板  
18.     int Template2[3][3]{ 0,-1,0,-1,5,-1,0,-1,0 };//laplace锐化模板,4邻域  
19.     int Template3[3][3]{ -1,-1,-1,-1,9,-1,-1,-1,-1 };//laplace锐化模板,8邻域  
20. public:  
21.     bool readImage();//读取图片  
22.     bool writeImage();//保存图片  
23.     bool Operation(int x);//图像平滑和锐化处理  
24.     bool Operation(int Template[][3], int coefficient);//图像处理  
25.     bool makeGray();//将彩色图转换为灰度图  
26.     bool Binarization();//二值化  
27.     void showBmpHead(BITMAPFILEHEADER BmpHead);//显示文件头  
28.     void showBmpInfo(tagBITMAPINFOHEADER BmpInfo);//显示信息头  
29. };  
30. bool twentyfourBitMap::readImage() {  
31.     cout << "输入要读取的图片名：";  
32.     cin >> imageName;  
33.     if (!fopen_s(&fpin, imageName, "rb")) {  
34.         //读取图片类型  
35.         WORD bfType;  
36.         fread(&bfType, sizeof(WORD), 1, fpin);//fread()的使用  
37.         if (bfType != 0x4d42) {  
38.             cout << "该图片不是BMP！" << endl;  
39.             return false;  
40.         }  
41.         //读取文件头和信息头  
42.         fread(&bmpHead, sizeof(tagBITMAPFILEHEADER), 1, fpin);  
43.         fread(&bmpInfo, sizeof(tagBITMAPINFOHEADER), 1, fpin);  
44.         //检查是否是24位位图  
45.         if (bmpInfo.biBitCount != 24) {  
46.             cout << "该图片不是24位！" << endl;  
47.             return false;  
48.         }  
49.         //读取图片的像素信息  
50.         width = bmpInfo.biWidth;  
51.         height = bmpInfo.biHeight;  
52.         width = (width * sizeof(BYTE) + 3) / 4 * 4;//图像的每一行必须是4的整数倍  
53.         imagedata = new IMAGEDATA[width*height];  
54.         fread(imagedata, sizeof(IMAGEDATA)*width, height, fpin);  
55.         //显示文件头和信息头  
56.         showBmpHead(bmpHead);  
57.         showBmpInfo(bmpInfo);  
58.         //关闭图片  
59.         fclose(fpin);  
60.     }  
61.     else {  
62.         cout << "图片不存在！" << endl;  
63.         return false;  
64.     }  
65.     return true;  
66. }  
67. bool  twentyfourBitMap::writeImage() {  
68.     char imageName[30];  
69.     cout << "输入处理后的位图名：";  
70.     cin >> imageName;  
71.     //创建位图文件  
72.     if (fopen_s(&fpout, imageName, "wb")) {  
73.         cout << "创建文件失败！" << endl;  
74.         return false;  
75.     }  
76.     //写入位图类型  
77.     WORD bfBYTE = 0x4d42;  
78.     fwrite(&bfBYTE, 1, sizeof(WORD), fpout);  
79.     //写入文件头和信息头  
80.     fwrite(&bmpHead, 1, sizeof(BITMAPFILEHEADER), fpout);  
81.     fwrite(&bmpInfo, 1, sizeof(BITMAPINFOHEADER), fpout);  
82.     //写入图像像素数据  
83.     fwrite(newimagedata, sizeof(IMAGEDATA)*width, height, fpout);  
84.     //关闭图片  
85.     fclose(fpout);  
86.     //释放内存  
87.     delete imagedata;  
88.     delete newimagedata;  
89.     return true;  
90. }  
91. bool  twentyfourBitMap::Operation(int x) {  
92.     if (x == 1)  
93.         return Operation(Template1, 9);  
94.     else if (x == 2)  
95.         return Operation(Template2, 1);  
96.     else if (x == 3)  
97.         return Operation(Template3, 1);  
98.     else {  
99.         cout << "模板调用错误！" << endl;  
100.         return false;  
101.     }  
102. }  
103. bool  twentyfourBitMap::Operation(int Template[][3], int coefficient) {  
104.     //分配新像素素组的空间  
105.     newimagedata = new IMAGEDATA[width*height];  
106.     //进行模板操作  
107.     for (int i = 0; i < height; ++i)  
108.         for (int j = 0; j < width; ++j) {  
109.             if (i == 0 || j == 0 || i == height - 1 || j == width - 1)  
110.                 *(newimagedata + i*width + j) = *(imagedata + i*width + j);  
111.             else {  
112.                 int sum = 0;  
113.                 for (int m = i - 1; m < i + 2; ++m)  
114.                     for (int n = j - 1; n < j + 2; ++n) {  
115.                         sum += ((*(imagedata + m*width + n)).blue)*Template[n - j + 1][m - i + 1] / coefficient;  
116.                     }  
117.                 //8位BMP中一个像素值，对应调色板中索引号为该像素值的项所存放的RGB色彩  
118.                 //所以像素值范围为0~255  
119.                 //像素值小于0就取0，大于255就取255  
120.                 sum = (sum >= 0) ? sum : 0;  
121.                 sum = (sum + ((*(imagedata + i*width + j)).blue)>255) ? 255 : sum;  
122.                 //把新RGB值存入新数组  
123.                 (*(newimagedata + i*width + j)).blue = sum;  
124.                 (*(newimagedata + i*width + j)).green = sum;  
125.                 (*(newimagedata + i*width + j)).red = sum;  
126.             }  
127.         }  
128.     //保存图片  
129.     if (writeImage()) {  
130.         cout << "\n处理成功！" << endl;  
131.         return true;  
132.     }  
133.     else {  
134.         cout << "\n处理失败！" << endl;  
135.         return false;  
136.     }  
137. }  
138. bool twentyfourBitMap::makeGray() {  
139.     //分配新像素素组的空间  
140.     newimagedata = new IMAGEDATA[width*height];  
141.     //进行灰度化操作  
142.     int sum;  
143.     for (int i = 0; i < width*height; ++i) {  
144.         sum = (*(imagedata + i)).blue +  
145.             (*(imagedata + i)).green +  
146.             (*(imagedata + i)).red;  
147.         (*(newimagedata + i)).blue = (*(newimagedata + i)).green = (*(newimagedata + i)).red = sum / 3;  
148.     }  
149.     //保存图片  
150.     if (writeImage()) {  
151.         cout << "\n处理成功！" << endl;  
152.         return true;  
153.     }  
154.     else {  
155.         cout << "\n处理失败！" << endl;  
156.         return false;  
157.     }  
158. }  
159. bool twentyfourBitMap::Binarization() {  
160.     //分配新像素素组的空间  
161.     newimagedata = new IMAGEDATA[width*height];  
162.     //二值化操作  
163.     for (int i = 0; i < width*height; ++i)  
164.         if ((*(imagedata + i)).blue > 128)  
165.             (*(newimagedata + i)).blue =  
166.             (*(newimagedata + i)).green =  
167.             (*(newimagedata + i)).red = 255;  
168.         else  
169.             (*(newimagedata + i)).blue =  
170.             (*(newimagedata + i)).green =  
171.             (*(newimagedata + i)).red = 0;  
172.     //保存图片  
173.     if (writeImage()) {  
174.         cout << "\n处理成功！" << endl;  
175.         return true;  
176.     }  
177.     else {  
178.         cout << "\n处理失败！" << endl;  
179.         return false;  
180.     }  
181. }  
182. void  twentyfourBitMap::showBmpHead(BITMAPFILEHEADER BmpHead) {  
183.     cout << "\n图片文件头:" << endl;  
184.     cout << "  图片大小:" << BmpHead.bfSize << endl;  
185.     cout << "  保留字_1:" << BmpHead.bfReserved1 << endl;  
186.     cout << "  保留字_2:" << BmpHead.bfReserved2 << endl;  
187.     cout << "  实际位图片数据的偏移字节数:" << BmpHead.bfOffBits << endl;  
188. }  
189. void  twentyfourBitMap::showBmpInfo(tagBITMAPINFOHEADER BmpInfo) {  
190.     cout << "图片信息头:" << endl;  
191.     cout << "  结构体的长度:" << BmpInfo.biSize << endl;  
192.     cout << "  位图宽:" << BmpInfo.biWidth << endl;  
193.     cout << "  位图高:" << BmpInfo.biHeight << endl;  
194.     cout << "  平面数:" << BmpInfo.biPlanes << endl;  
195.     cout << "  采用颜色位数:" << BmpInfo.biBitCount << endl;  
196.     cout << "  压缩方式:" << BmpInfo.biCompression << endl;  
197.     cout << "  实际位图数据占用的字节数:" << BmpInfo.biSizeImage << endl;  
198.     cout << "  X方向分辨率:" << BmpInfo.biXPelsPerMeter << endl;  
199.     cout << "  Y方向分辨率:" << BmpInfo.biYPelsPerMeter << endl;  
200.     cout << "  使用的颜色数:" << BmpInfo.biClrUsed << endl;  
201.     cout << "  重要颜色数:" << BmpInfo.biClrImportant << endl;  
202. }  
203.   
204. #endif  

源代码：

[cpp]  view plain  copy

 

1. int main() {  
2.     int depth = 0;  
3.     cout << "输入要处理的位图深度：";  
4.     cin >> depth;  
5.     if (depth == 8) {  
6.         eightBitMap Image;  
7.         if (Image.readImage()) {  
8.             int answer;  
9.             cout << "\n1.平滑处理"  
10.                 << "\n2.4邻域锐化"  
11.                 << "\n3.8邻域锐化"  
12.                 << "\n4.二值化"  
13.                 << "\n选择处理方式：";  
14.             cin >> answer;  
15.             switch (answer) {  
16.             case 1:  
17.                 Image.Operation(1);  
18.                 break;  
19.             case 2:  
20.                 Image.Operation(2);  
21.                 break;  
22.             case 3:  
23.                 Image.Operation(3);  
24.                 break;  
25.             case 4:  
26.                 Image.Binarization();  
27.                 break;  
28.             default:  
29.                 cout << "错误选择！" << endl;  
30.             }  
31.         }  
32.         else cout << "位图读取错误！" << endl;  
33.     }  
34.     else if (depth == 24) {  
35.         twentyfourBitMap Image;  
36.         if (Image.readImage()) {  
37.             int answer;  
38.             cout << "\n1.平滑处理"  
39.                 << "\n2.4邻域锐化"  
40.                 << "\n3.8邻域锐化"  
41.                 << "\n4.彩色位图灰度化"  
42.                 << "\n5.二值化"  
43.                 << "\n选择处理方式：";  
44.             cin >> answer;  
45.             switch (answer) {  
46.             case 1:  
47.                 Image.Operation(1);  
48.                 break;  
49.             case 2:  
50.                 Image.Operation(2);  
51.                 break;  
52.             case 3:  
53.                 Image.Operation(3);  
54.                 break;  
55.             case 4:  
56.                 Image.makeGray();  
57.                 break;  
58.             case 5:  
59.                 Image.Binarization();  
60.                 break;  
61.             default:  
62.                 cout << "错误选择！" << endl;  
63.             }  
64.         }  
65.         else cout << "位图读取错误！" << endl;  
66.     }  
67.     else cout << "错误深度输入！" << endl;  
68.     cin.get();  
69.     cin.get();  
70. }  

调试及测试（由于8位位图的处理和24位位图的处理在结果上差别不大，所以只用24位图做测试）

1.平滑处理

 

平滑处理前：                                                                                                             平滑处理后：

                              

对比可以看出，平滑处理使图像更加模糊。

2.锐化处理（平滑后再锐化效果更好，所以使用平滑后的位图锐化。8邻域锐化比4邻域锐化效果好，所以只使用8邻域锐化）

8邻域锐化前：                                                    8邻域锐化后：

                              

对比可以看出，锐化后，图像的边缘更加明显

3.二值化

二值化处理前：                                                                     二值化处理后：

                              

对比可以看出，二值化使图像只有黑白两色，没有灰色的过渡

4.彩色位图灰度化

灰度化处理前：                                                                      灰度化处理后：

                              

对比可以看出，灰度化使彩色图像转换成灰度图像