设计CDib类

1. CDib类头文件
   
2. 
   
3. #ifndef _CDIB_H
4. #define _CDIB_H
5. class CDib:public CObject
6. {
7. public:
8.     RGBQUAD* m_pRGB;
9.     BYTE* m_pData,*m_pData2;
10.     UINT m_numberOfColors;
11.     BOOL m_valid;
12.     BITMAPFILEHEADER bitmapFileHeader;
13.     
14.     BITMAPINFOHEADER* m_pBitmapInfoHeader;
15.     BITMAPINFO* m_pBitmapInfo;
16.     int byBitCount;
17.     DWORD dwWidthBytes;
18.     BYTE* pDib;
19.     DWORD size;
20.     
21. public:
22.     CDib();
23.     ~CDib();
24.     
25.     char m_fileName[256];
26.     char* GetFileName();
27.     BOOL IsValid();
28.     DWORD GetSize();
29.     UINT GetWidth();
30.     UINT GetHeight();
31.     UINT GetNumberOfColors();
32.     RGBQUAD* GetRGB();
33.     BYTE*  GetData();
34.     BYTE* GetData2();
35.     DWORD GetDibWidthBytes();
36.     BITMAPINFO * GetInfo();
37.     WORD PaletteSize(LPBYTE lpDIB);
38.     WORD DIBNumColors(LPBYTE lpDIB);
39.     void SaveFile(const CString filename);
40.     
41. public:
42.     void GradetoRGB();
43.     void RGBtoGrade();
44.     void LoadFile(const char* dibFileName);
45. };
46. #endif

1. CDib类
2. 
   
3. #include "StdAfx.h"
4. #include "dib.h"
5. #include "windowsx.h"
6. #define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4)
7. 
   
8. CDib::CDib()
9. {
10. 
    
11. }
12. CDib::~CDib()
13.   {
14.     GlobalFreePtr(m_pBitmapInfo);
15.   }
16. 
    
17. void CDib::LoadFile(const char* dibFileName)
18. {
19.     strcpy(m_fileName,dibFileName);
20.     CFile dibFile(m_fileName,CFile::modeRead);
21. 
    
22.     dibFile.Read((void*)&bitmapFileHeader,sizeof(BITMAPFILEHEADER));
23. 
    
24.     if (bitmapFileHeader.bfType == 0x4d42)
25.     {
26.         DWORD fileLength=dibFile.GetLength();
27.         DWORD size=fileLength-sizeof(BITMAPFILEHEADER);
28.         BYTE* pDib=(BYTE*)GlobalAllocPtr(GMEM_MOVEABLE,size);
29.         dibFile.Read((void*)pDib,size);
30.         dibFile.Close();
31. 
    
32.         m_pBitmapInfo=(BITMAPINFO*)pDib;
33.         m_pBitmapInfoHeader=(BITMAPINFOHEADER*)pDib;
34.         m_pRGB=(RGBQUAD*)(pDib+m_pBitmapInfoHeader->biSize);
35.         int m_numberOfColors=GetNumberOfColors();
36.         if (m_pBitmapInfoHeader->biClrUsed==0)
37.             m_pBitmapInfoHeader->biClrUsed=m_numberOfColors;
38.         DWORD colorTableSize=m_numberOfColors * sizeof(RGBQUAD);
39.         m_pData=pDib+m_pBitmapInfoHeader->biSize+colorTableSize;
40.         if(m_pRGB==(RGBQUAD*)m_pData)
41.             m_pRGB=NULL;
42.         m_pBitmapInfoHeader->biSizeImage=GetSize();
43.         m_valid=TRUE;
44.     }
45.     else
46.     {
47.         m_valid=FALSE;
48.         AfxMessageBox("This isn't a bitmap file");
49.     }
50. }
51. 
    
52. BOOL CDib::IsValid()
53. {
54.     return m_valid;
55. }
56. 
    
57. char* CDib::GetFileName()
58. {
59.     return m_fileName;
60. }
61. 
    
62. UINT CDib::GetWidth()
63. {
64.     return (UINT)m_pBitmapInfoHeader->biWidth;
65. }
66. 
    
67. UINT CDib::GetHeight()
68. {
69.     return (UINT)m_pBitmapInfoHeader->biHeight;
70. }
71. 
    
72. DWORD CDib::GetSize()
73. {
74.     if (m_pBitmapInfoHeader->biSizeImage!=0)
75.     return m_pBitmapInfoHeader->biSizeImage;
76. 
    
77.     else
78.     {
79.         DWORD height=(DWORD) GetHeight();
80.         DWORD width=(DWORD) GetWidth();
81.         return height * width; 
82.     }
83. }
84. 
    
85. DWORD CDib::GetDibWidthBytes()
86. {
87.     byBitCount=m_pBitmapInfoHeader->biBitCount;
88.     LONG nWidth=m_pBitmapInfoHeader->biWidth;
89. 
    
90.     dwWidthBytes=(DWORD)m_pBitmapInfoHeader->biWidth;
91.     if(byBitCount==1) dwWidthBytes=(nWidth+7)/8;
92.     else if(byBitCount==4) dwWidthBytes=(nWidth+1)/2;
93.     else if(byBitCount==24) dwWidthBytes=3*nWidth;
94.     
95.     while ((dwWidthBytes&3)!=0)
96.     dwWidthBytes++;
97.     return dwWidthBytes;
98. }
99. 
    
100. UINT CDib::GetNumberOfColors()
101. {
102.     int numberOfColors;
103. 
     
104.     if((m_pBitmapInfoHeader->biClrUsed==0)&&(m_pBitmapInfoHeader->biBitCount<9))
105.     {
106.         switch(m_pBitmapInfoHeader->biBitCount)
107.         {
108.         case 1:numberOfColors=2;
109.             break;
110.         case 4:numberOfColors=16;
111.             break;
112.         case 8:numberOfColors=256;
113.         }
114.     }
115.     else
116.         numberOfColors=(int)m_pBitmapInfoHeader->biClrUsed;
117. 
     
118.     return numberOfColors;
119. }
120. 
     
121. BYTE* CDib::GetData()
122. {
123.     return m_pData;
124. }
125. 
     
126. BYTE* CDib::GetData2()
127. {
128.     if(GetRGB())
129.         m_pData2=m_pData;
130.     return m_pData2;
131. }
132. 
     
133. RGBQUAD* CDib::GetRGB()
134. {
135.     return m_pRGB;
136. }
137. 
     
138. BITMAPINFO* CDib::GetInfo()
139. {
140.     return m_pBitmapInfo;
141. }
142. 
     
143. WORD CDib::PaletteSize(LPBYTE lpDIB)
144. {
145.     return (DIBNumColors(lpDIB) * sizeof(RGBTRIPLE));
146. }
147. 
     
148. WORD CDib::DIBNumColors(LPBYTE lpDIB)
149. {
150.     WORD wBitCount;
151.     wBitCount=((LPBITMAPCOREHEADER)lpDIB)->bcBitCount;
152.     switch(wBitCount)
153.     {
154.     case 1:
155.         return 2;
156.     case 4:
157.         return 16;
158.     case 8: 
159.         return 256;
160.     default: 
161.         return 0;
162.     }
163. }
164. 
     
165. void CDib::SaveFile(const CString filename)
166. {
167.     BITMAPFILEHEADER bmfHdr;  //Header for Bitmap file
168.     LPBITMAPINFOHEADER lpBI;  //Pointer to DIB info structure
169.     DWORD dwDIBSize; 
170. 
     
171.     bmfHdr.bfType=0x4d42; //"BM"
172.     lpBI=(LPBITMAPINFOHEADER)m_pBitmapInfoHeader;
173.     dwDIBSize=*(LPDWORD)lpBI+PaletteSize((LPBYTE)lpBI);
174.     if((lpBI->biCompression==BI_RLE8)||(lpBI->biCompression==BI_RLE4))
175.         dwDIBSize+=lpBI->biSizeImage;
176.     else
177.     {
178.         DWORD dwBmBitsSize;  //Size of Bitmap Bits only
179.         dwBmBitsSize=WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount))*lpBI->biHeight;
180.         dwDIBSize += dwBmBitsSize;
181.         lpBI->biSizeImage=dwBmBitsSize;
182.     }
183.     bmfHdr.bfSize=dwDIBSize+sizeof(BITMAPFILEHEADER);
184.     bmfHdr.bfReserved1=0;
185.     bmfHdr.bfReserved2=0;
186.     bmfHdr.bfOffBits=(DWORD)sizeof(BITMAPFILEHEADER)+lpBI->biSize+PaletteSize((LPBYTE)lpBI);
187. 
     
188.     CFile dibFile(filename,CFile::modeWrite|CFile::modeCreate);
189.     dibFile.Write(&bmfHdr,sizeof(BITMAPFILEHEADER));
190.     dibFile.WriteHuge(lpBI,dwDIBSize);
191.     dibFile.Close();
192. }
193. 
     
194. void CDib::RGBtoGrade()
195. {
196.     if(GetRGB())
197.         m_pData2=m_pData;
198.     else
199.     {
200.         BYTE r,g,b;
201.         int height,wide,size;
202.         height=GetHeight();
203.         wide=GetWidth();
204.         size=height*wide;
205.         m_pData2=(BYTE*)GlobalAllocPtr(GMEM_MOVEABLE,size);
206.         LONG lLineBytes=GetDibWidthBytes();
207.         for (int j=0;j<height;j++)
208.         {
209.             for (int i=0;i<wide;i++)
210.             {
211.                 b=m_pData[j*lLineBytes+3*i];
212.                 g=m_pData[j*lLineBytes+3*i+1];
213.                 r=m_pData[j*lLineBytes+3*i+2];
214.                 m_pData2[j*wide+i]=(BYTE)(0.3*r+0.59*g+0.11*b);
215.             }
216.         }
217.     }
218. }
219. 
     
220. 
     
221. void CDib::GradetoRGB()
222. {
223.     if(GetRGB())
224.         m_pData2=m_pData;
225.     else
226.     {
227.         BYTE r,g,b;
228.         int height,wide;
229.         height=GetHeight();
230.         wide=GetWidth();
231.         LONG lLineBytes=GetDibWidthBytes();
232.         for(int j=0;j<height;j++)
233.         {
234.             for(int i=0;i<wide;i++)
235.             {
236.                 m_pData[(height-j-1*lLineBytes+3*i)]=m_pData2[(height-1-j)*wide+i];
237.                 m_pData[(height-j-1*lLineBytes+3*i+1)]=m_pData2[(height-1-j)*wide+i];
238.                 m_pData[(height-j-1*lLineBytes+3*i+2)]=m_pData2[(height-1-j)*wide+i];
239. 
     
240.             }
241.         }
242.     }
243. }