图像处理常用算法(C/C++)

查资料时看到的一篇博文，转下来先，原文：http://gaojinpeng1129.blog.163.com/blog/static/141659068201321194552695/

[cpp]  view plain  copy

1. /*函数名称：MakegGray()                                        */  
2. /*函数类型：void                                               */  
3. /*功能：真彩色转化成256色灰度图像。                            */  
4. /***************************************************************/  
5. void MakeColorDib::MakegGray()    //灰度变化  
6. {  
7.  BYTE *p_data;     //原图数据区指针  
8.  int wide,height,DibWidth;    //原图长、宽、字节宽  
9.  p_data=this->GetData ();   //取得原图的数据区指针  
10.     wide=this->GetWidth ();   //取得原图的数据区宽度  
11.     height=this->GetHeight ();   //取得原图的数据区高度  
12.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
13.  for(int j=0;j<height;j++) // 每行  
14.   for(int i=0;i<DibWidth;i+=3) // 每列  
15.   {  
16.    BYTE* pbyBlue = p_data++;   //得到蓝色值  
17.    BYTE* pbyGreen = p_data++;  //得到绿色值  
18.    BYTE* pbyRed = p_data++;    //得到红色值  
19.    BYTE r = *pbyRed;  
20.    BYTE g = *pbyGreen;  
21.    BYTE b = *pbyBlue;  
22.    //取到原r,g,b中的最大值作为像素三分量值的新值  
23.    int gray=0;  
24.    if(r>g)  
25.     gray=r;  
26.    else   
27.     gray=g;  
28.    if(gray<b)  
29.     gray=b;     
30.          *pbyBlue = gray;     //将取到的最大值赋给像素的蓝分量  
31.    *pbyGreen = gray;    //将取到的最大值赋给像素的绿分量  
32.    *pbyRed = gray;      //将取到的最大值赋给像素的红分量  
33.   }  
34. }  
35.   
36. /***************************************************************/  
37. /*函数名称：LightAlter(int m_Light)                            */  
38. /*函数类型：void                                               */  
39. /*参数：int m_Light，用户给定的阈值                            */  
40. /*功能：对图像使用阈值法进行亮度调整。                         */  
41. /***************************************************************/  
42. void MakeColorDib::LightAlter(int m_Light)    //亮度调整  
43. {  
44.  BYTE *p_data;     //原图数据区指针  
45.  int wide,height,DibWidth;    //原图长、宽、字节宽  
46.  p_data=this->GetData ();   //取得原图的数据区指针  
47.     wide=this->GetWidth ();  //取得原图的数据区宽度  
48.     height=this->GetHeight ();    //取得原图的数据区高度  
49.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
50.  for(int j=0;j<height;j++) // 每行  
51.  for(int i=0;i<DibWidth;i++) // 每列  
52.  {     
53.   int a=0;  
54.   a=int(*p_data*m_Light/100);   //调整当前点的亮度  
55.   *p_data=a;  
56.   //判断范围，取得合理的值  
57.   if(a<0)   
58.    *p_data=0;    
59.      if(a>255)  
60.    *p_data=255;  
61.         p_data++;   //指向下一指针  
62.  }  
63. }  
64.   
65. /***************************************************************/  
66. /*函数名称：LightReverse()                                     */  
67. /*函数类型：void                                               */  
68. /*功能：图像的亮度取反。                                       */  
69. /***************************************************************/  
70. void MakeColorDib::LightReverse()    //亮度取反  
71. {  
72.  BYTE *p_data;     //原图数据区指针  
73.  int wide,height,DibWidth;    //原图长、宽、字节宽  
74.  p_data=this->GetData ();   //取得原图的数据区指针  
75.     wide=this->GetWidth ();  //取得原图的数据区宽度  
76.     height=this->GetHeight ();   //取得原图的数据区高度  
77.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
78.  for(int j=0;j<height;j++) // 每行  
79.   for(int i=0;i<DibWidth;i++) // 每列  
80.   {  
81.    int a=*p_data;   //取得当前点的值  
82.    *p_data=255-a;    //取反  
83.    p_data++;  //指向下一指针    
84.   }  
85. }  
86.   
87. /***************************************************************/  
88. /*函数名称：ContrastAlter(int m_Increment)                     */  
89. /*函数类型：void                                               */  
90. /*参数：int m_Increment，用户给定的阈值                        */  
91. /*功能：对图像使用阈值法调整对比度处理。                       */  
92. /***************************************************************/  
93. void MakeColorDib::ContrastAlter(int m_Increment)   ///对比度处理  
94. {  
95.  int nHigh = 255 - m_Increment;  
96.  //对于极端情况加以处理  
97.  if(nHigh < m_Increment)  
98.  {  
99.   nHigh = 127;  
100.   m_Increment = 120;  
101.  }  
102.  if(m_Increment < -127)  
103.   m_Increment = -120;  
104.  //扩展或压缩区间的长度  
105.  int nStretch = 255;  
106.  if(m_Increment >= 0)  
107.   nStretch = 255 - 2 * m_Increment;  
108.  else  
109.   nStretch = 255 + 2 * m_Increment;  
110.  BYTE *p_data;     //原图数据区指针  
111.  int wide,height,DibWidth;    //原图长、宽、字节宽  
112.  p_data=this->GetData ();   //取得原图的数据区指针  
113.     wide=this->GetWidth ();  //取得原图的数据区宽度  
114.     height=this->GetHeight ();   //取得原图的数据区高度  
115.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
116.  if(m_Increment >= 0)   // m_Increment>=0时  
117.  {  
118.   for(int j=0;j<height;j++) // 每行  
119.    for(int i=0;i<DibWidth-3;i+=3) // 每列  
120.    {     
121.     //取得当前点（蓝色）的值，调整  
122.     BYTE* pbyBlue = p_data++;      
123.     if(*pbyBlue<=m_Increment)  
124.      *pbyBlue=0;  
125.     else if(*pbyBlue>nHigh)  
126.      *pbyBlue=255;  
127.     else  
128.      *pbyBlue=(BYTE)((((int)*pbyBlue - m_Increment) * 255) / nStretch );  
129.     //取得当前点（绿色）的值，调整  
130.     BYTE* pbyGreen = p_data++;  
131.     if(*pbyGreen<=m_Increment)  
132.      *pbyGreen=0;  
133.     else if(*pbyGreen>nHigh)  
134.      *pbyGreen=255;  
135.     else  
136.      *pbyGreen=(BYTE)((((int)*pbyGreen - m_Increment) * 255) / nStretch );  
137.     //取得当前点（红色）的值，调整  
138.     BYTE* pbyRed = p_data++;  
139.     if(*pbyRed<=m_Increment)  
140.      *pbyRed=0;  
141.     else if(*pbyRed>nHigh)  
142.      *pbyRed=255;  
143.     else  
144.      *pbyRed=(BYTE)((((int)*pbyRed - m_Increment) * 255) / nStretch );  
145.    }  
146.      
147.  }  
148.  else  // m_Increment < 0 时  
149.  {  
150.   for(int j=0;j<height;j++)  
151.    for(int i=0;i<DibWidth-3;i+=3)  
152.    { //取得当前点（蓝色）的值，调整  
153.     BYTE* pbyBlue = p_data++;  
154.     *pbyBlue = (BYTE)((((int)(*pbyBlue) * nStretch) / 255) - m_Increment);  
155.     //取得当前点（红色）的值，调整  
156.     BYTE* pbyGreen = p_data++;  
157.     *pbyGreen = (BYTE)((((int)(*pbyGreen) * nStretch) / 255) - m_Increment);  
158.     //取得当前点（红色）的值，调整  
159.     BYTE* pbyRed = p_data++;  
160.     *pbyRed = (BYTE)((((int)(*pbyRed) * nStretch) / 255) - m_Increment);      
161.    }  
162.  }  
163. }  
164.   
165. /***************************************************************/  
166. /*函数名称：Exposal()                                          */  
167. /*函数类型：void                                               */  
168. /*功能：图像曝光处理。                                         */  
169. /***************************************************************/  
170. void MakeColorDib::Exposal() //曝光处理  
171. {  
172.  BYTE *p_data;     //原图数据区指针  
173.  int wide,height,DibWidth;    //原图长、宽、字节宽  
174.  p_data=this->GetData ();   //取得原图的数据区指针  
175.     wide=this->GetWidth ();  //取得原图的数据区宽度  
176.     height=this->GetHeight ();   //取得原图的数据区高度  
177.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
178.  for(int j=0;j<height;j++) // 每行  
179.   for(int i=0;i<DibWidth;i++) // 每列  
180.   {  
181.    BYTE* pbydata = p_data++;  //取得当前点的值  
182.    BYTE a=*pbydata;   //传给临时变量  
183.    *pbydata=(a>128)?a:(255-a);   //调整  
184.   }  
185.     
186. }  
187.   
188. /***************************************************************/  
189. /*函数名称：PaintColor(int m_Red,int m_Green,int m_Blue)       */  
190. /*函数类型：void                                               */  
191. /*参数：int m_Red、m_Green、m_Blue，用户给定的红绿蓝值         */  
192. /*功能：对图像使用阈值法进行着色处理。                         */  
193. /***************************************************************/  
194. void MakeColorDib::PaintColor(int m_Red,int m_Green,int m_Blue) //着色处理  
195. {  
196.  BYTE *p_data;     //原图数据区指针  
197.  int wide,height,DibWidth;    //原图长、宽、字节宽  
198.  p_data=this->GetData ();   //取得原图的数据区指针  
199.     wide=this->GetWidth ();  //取得原图的数据区宽度  
200.     height=this->GetHeight ();   //取得原图的数据区高度  
201.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
202.  for(int j=0;j<height;j++) // 每行  
203.   for(int i=0;i<DibWidth;i+=3) // 每列  
204.   {     
205.    BYTE* pbyBlue = p_data++; //取得当前点（蓝色）的值       
206.    BYTE* pbyGreen = p_data++;  //取得当前点（绿色）的值  
207.    BYTE* pbyRed = p_data++;    //取得当前点（红色）的值  
208.    BYTE r = *pbyRed;  
209.    BYTE g = *pbyGreen;  
210.    BYTE b = *pbyBlue;  
211.       BYTE gray=(BYTE)(((WORD)r * 59 + (WORD)g * 30 + (WORD)b * 11) / 100);  
212.    *pbyBlue = (BYTE)((m_Blue * gray) / 255);    
213.    *pbyGreen = (BYTE)((m_Green * gray) / 255);  
214.    *pbyRed = (BYTE)((m_Red * gray) / 255);  
215.   }  
216. }  
217.   
218. /***************************************************************/  
219. /*函数名称：NeonLight()                                        */  
220. /*函数类型：void                                               */  
221. /*功能：使图像产生霓虹处理效果。                               */  
222. /***************************************************************/  
223. void MakeColorDib::NeonLight()   //霓虹处理  
224. {  
225.  BYTE *p_data;     //原图数据区指针  
226.  int wide,height,DibWidth;    //原图长、宽、字节宽  
227.  p_data=this->GetData ();   //取得原图的数据区指针  
228.     wide=this->GetWidth ();  //取得原图的数据区宽度  
229.     height=this->GetHeight ();   //取得原图的数据区高度  
230.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
231.     BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
232.  for(int j=0;j<height-4;j++) // 每行  
233.  {  
234.   for(int i=0;i<DibWidth-1;i++) // 每列  
235.   {  
236.     int pby_pt=0;  
237.     //对像素执行算法  
238.     pby_pt=(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i+3))  
239.        *(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i+3))  
240.        +(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-2)*DibWidth+i))  
241.        *(*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-2)*DibWidth+i));  
242.    *(p_temp+(height-j-1)*DibWidth+i)=2*int(sqrt(pby_pt));  
243.    //判断合法性  
244.    if(*(p_temp+(height-j-1)*DibWidth+i)<0)  
245.      *(p_temp+(height-j-1)*DibWidth+i)=0;  
246.    if(*(p_temp+(height-j-1)*DibWidth+i)>255)  
247.      *(p_temp+(height-j-1)*DibWidth+i)=255;  
248.   }  
249.  }  
250.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
251.     delete []p_temp;   //删除暂时分配内存  
252. }  
253.   
254. /***************************************************************/  
255. /*函数名称：Smoothness()                                       */  
256. /*函数类型：void                                               */  
257. /*功能：使图像平滑处理。                                       */  
258. /***************************************************************/  
259. void MakeColorDib::Smoothness()   //平滑处理  
260. {  
261.  BYTE *p_data;     //原图数据区指针  
262.  int wide,height,DibWidth;    //原图长、宽、字节宽  
263.  p_data=this->GetData ();   //取得原图的数据区指针  
264.     wide=this->GetWidth ();  //取得原图的数据区宽度  
265.     height=this->GetHeight ();   //取得原图的数据区高度  
266.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
267.     int h[3][3];定义(3x3)矩阵  
268.  h[0][0] = 1;  h[0][1] = 1; h[0][2] = 1;  
269.  h[1][0] = 1;  h[1][1] = 1; h[1][2] = 1;  
270.  h[2][0] = 1;  h[2][1] = 1; h[2][2] = 1;  
271.     BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
272.  for(int j=0;j<height-2;j++) // 每行  
273.  {  
274.   for(int i=0;i<DibWidth-8;i++) // 每列  
275.   {  
276.          double pby_pt=0;  
277.                     //对应的第0行的值乘以矩阵对应值，再相加  
278.        pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
279.         +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
280.         +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))  
281.                     //对应的第1行的值乘以矩阵对应值，再相加  
282.         +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
283.         +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))  
284.         +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))  
285.                     //对应的第2行的值乘以矩阵对应值，再相加  
286.               +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))  
287.      +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))  
288.      +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));  
289.    *(p_temp+(height-j-2)*DibWidth+i+3)=abs(int(pby_pt/9));//取总和的的平均值  
290.   }  
291.  }  
292.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
293.     delete []p_temp;//删除暂时分配内存  
294. }  
295.   
296. /***************************************************************/  
297. /*函数名称：Embossment()                                       */  
298. /*函数类型：void                                               */  
299. /*功能：产生图像浮雕处理效果。                                 */  
300. /***************************************************************/  
301. void MakeColorDib::Embossment()   //浮雕处理  
302. {  
303.  BYTE *p_data;     //原图数据区指针  
304.  int wide,height,DibWidth;    //原图长、宽、字节宽  
305.  p_data=this->GetData ();   //取得原图的数据区指针  
306.     wide=this->GetWidth ();  //取得原图的数据区宽度  
307.     height=this->GetHeight ();   //取得原图的数据区高度  
308.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
309.     BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
310.  for(int j=0;j<height;j++) // 每行  
311.  {  
312.   for(int i=0;i<DibWidth-4;i++) // 每列  
313.   {  
314.     int pby_pt=0;  
315.     //对像素得每个分量执行算法  
316.     pby_pt=*(p_data+(height-j-1)*DibWidth+i)  
317.        -*(p_data+(height-j-1)*DibWidth+i+3)+128;  
318.     *(p_temp+(height-j-1)*DibWidth+i+3)=pby_pt;  
319.    //检验合法性  
320.    if(*(p_temp+(height-j-1)*DibWidth+i+3)<0)  
321.     *(p_temp+(height-j-1)*DibWidth+i+3)=0;  
322.    else if(*(p_temp+(height-j-1)*DibWidth+i+3)>255)  
323.     *(p_temp+(height-j-1)*DibWidth+i+3)=255;  
324.   }  
325.  }  
326.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
327.     delete []p_temp;   //删除暂时分配内存  
328. }  
329.   
330. /***************************************************************/  
331. /*函数名称：Spread()                                           */  
332. /*函数类型：void                                               */  
333. /*功能：图像扩散处理。                                         */  
334. /***************************************************************/  
335. void MakeColorDib::Spread()   //扩散处理  
336. {   
337.  BYTE *p_data;     //原图数据区指针  
338.  int wide,height,DibWidth;    //原图长、宽、字节宽  
339.  p_data=this->GetData ();   //取得原图的数据区指针  
340.     wide=this->GetWidth ();  //取得原图的数据区宽度  
341.     height=this->GetHeight ();   //取得原图的数据区高度  
342.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
343.     BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
344.  for(int j=0;j<height-4;j++) // 每行  
345.  {  
346.   for(int i=0;i<DibWidth-14;i++) // 每列  
347.   {  
348.     int m=0,n=0;  
349.     m=rand()%5; //取得行随机数  
350.     n=rand()%5; //取得列随机数  
351.     int pby_pt=0;   
352.     pby_pt=*(p_data+(height-j-1-m)*DibWidth+i+3*n);//得到对应随机像素值  
353.     *(p_temp+(height-j-3)*DibWidth+i+6)=pby_pt;  
354.   }  
355.  }  
356.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
357.     delete []p_temp;   //删除暂时分配内存  
358. }  
359.   
360. /***************************************************************/  
361. /*函数名称：Sharp()                                            */  
362. /*函数类型：void                                               */  
363. /*功能：图像锐化处理。                                         */  
364. /***************************************************************/  
365. void MakeColorDib::Sharp()   //图像锐化  
366. {  
367.   BYTE *p_data;     //原图数据区指针  
368.  int wide,height,DibWidth;    //原图长、宽、字节宽  
369.  p_data=this->GetData ();   //取得原图的数据区指针  
370.     wide=this->GetWidth ();  //取得原图的数据区宽度  
371.     height=this->GetHeight ();   //取得原图的数据区高度  
372.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
373.     BYTE *p_temp=new BYTE[height*DibWidth];  
374.  for(int j=0;j<height-1;j++) // 每行  
375.  {  
376.   for(int i=0;i<DibWidth-5;i++) // 每列  
377.   {  
378.          int pby_pt=0;   
379.    pby_pt= *(p_data+(height-j-2)*DibWidth+i+3)  
380.           -*(p_data+(height-j-1)*DibWidth+i);  
381.    *(p_temp+(height-j-2)*DibWidth+i+3)=*(p_data+(height-j-2)*DibWidth+i+3)  
382.                                      +abs(int(pby_pt/4));  
383.    if(*(p_temp+(height-j-2)*DibWidth+i+3)>255)  
384.       *(p_temp+(height-j-2)*DibWidth+i+3)=255;  
385.   }  
386.  }  
387.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
388.     delete []p_temp;  //删除暂时分配内存  
389. }  
390.   
391. /***************************************************************/  
392. /*函数名称：HighLVBO(int m_GaoTong)                            */  
393. /*函数类型：void                                               */  
394. /*参数：int m_GaoTong，用户给定的阈值来选择矩阵                */  
395. /*功能：对图像使用阈值法进行高通滤波。                         */  
396. /***************************************************************/  
397. void MakeColorDib::HighLVBO(int m_GaoTong)   //高通滤波  
398. {  
399.  BYTE *p_data;     //原图数据区指针  
400.  int wide,height,DibWidth;    //原图长、宽、字节宽  
401.  p_data=this->GetData ();   //取得原图的数据区指针  
402.     wide=this->GetWidth ();  //取得原图的数据区宽度  
403.     height=this->GetHeight ();   //取得原图的数据区高度  
404.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
405.  int h[3][3];  定义(3x3)矩阵  
406.  if(m_GaoTong==1)  
407.  {   //矩阵1（基本高通）  
408.   h[0][0] =1;   h[0][1] =-2;  h[0][2] =1;  
409.   h[1][0] =-2;  h[1][1] =5;   h[1][2] =-2;  
410.   h[2][0] =1;   h[2][1] =-2;  h[2][2] =1;  
411.  }  
412.  else if(m_GaoTong==2)  
413.  {   //矩阵2（中等高通）  
414.   h[0][0] = 0;   h[0][1] = -1; h[0][2] = 0;  
415.   h[1][0] = -1;  h[1][1] =  5; h[1][2] = -1;  
416.   h[2][0] = 0;   h[2][1] = -1; h[2][2] = 0;  
417.  }  
418.  else  
419.  {   //矩阵3（过量高通）  
420.   h[0][0] = -1;  h[0][1] = -1; h[0][2] = -1;  
421.   h[1][0] = -1;  h[1][1] =  9; h[1][2] = -1;  
422.   h[2][0] = -1;  h[2][1] = -1; h[2][2] = -1;  
423.  }  
424.     BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
425.  for(int j=0;j<height-2;j++) // 每行  
426.  {  
427.   for(int i=0;i<DibWidth-8;i++) // 每列  
428.   {  
429.    int pby_pt=0;  
430.    //对应的第0行的值乘以矩阵对应值，再相加  
431.    pby_pt=  h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
432.     +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
433.     +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))  
434.     //对应的第1行的值乘以矩阵对应值，再相加  
435.     +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
436.     +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))  
437.     +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))  
438.     //对应的第2行的值乘以矩阵对应值，再相加  
439.     +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))  
440.     +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))  
441.     +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));  
442.    *(p_temp+(height-j-2)*DibWidth+i+3)=abs(pby_pt);  
443.    if(pby_pt>255) //判断是否越界  
444.     *(p_temp+(height-j-2)*DibWidth+i+3)=255;  
445.   }  
446.  }  
447.     memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
448.     delete []p_temp;  //删除暂时分配内存  
449. }  
450.   
451. /***************************************************************/  
452. /*函数名称：LowLVBO()                                          */  
453. /*函数类型：void                                               */  
454. /*功能：实现图像低通滤波(3x3)。                                */  
455. /***************************************************************/  
456. void MakeColorDib::LowLVBO()   //低通滤波(3x3)  
457. {  
458.  BYTE *p_data;     //原图数据区指针  
459.  int wide,height,DibWidth;    //原图长、宽、字节宽  
460.  p_data=this->GetData ();   //取得原图的数据区指针  
461.     wide=this->GetWidth ();  //取得原图的数据区宽度  
462.     height=this->GetHeight ();   //取得原图的数据区高度  
463.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
464.     double h[3][3];定义(3x3)矩阵  
465.  h[0][0] = 0.1;  h[0][1] = 0.1; h[0][2] = 0.1;  
466.  h[1][0] = 0.1;  h[1][1] = 0.2; h[1][2] = 0.1;  
467.  h[2][0] = 0.1;  h[2][1] = 0.1; h[2][2] = 0.1;  
468.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
469.  for(int j=0;j<height-2;j++) // 每行  
470.  {  
471.   for(int i=0;i<DibWidth-8;i++) // 每列  
472.   {  
473.    double pby_pt=0;  
474.             //对应的第0行的值乘以矩阵对应值，再相加   
475.    pby_pt=  h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
476.     +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
477.     +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))  
478.     //对应的第0行的值乘以矩阵对应值，再相加  
479.     +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
480.     +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))  
481.     +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))  
482.     //对应的第0行的值乘以矩阵对应值，再相加  
483.     +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))  
484.     +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))  
485.     +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));  
486.    *(p_temp+(height-j-2)*DibWidth+i+3)=abs(int(pby_pt));  
487.   }  
488.  }  
489.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
490.  delete []p_temp;  //删除暂时分配内存  
491. }  
492.   
493. /***************************************************************/  
494.   
495. 函数名称：LowVBObig()  
496.   
497. 函数类型：void  
498.   
499. 功能：实现函数低通滤波(5*5)  
500. /***************************************************************/  
501. void MakeColorDib::LowLVBObig()   //低通滤波(5x5)  
502. {  
503.  BYTE *p_data;     //原图数据区指针  
504.  int wide,height,DibWidth;    //原图长、宽、字节宽  
505.  p_data=this->GetData ();   //取得原图的数据区指针  
506.     wide=this->GetWidth ();  //取得原图的数据区宽度  
507.     height=this->GetHeight ();   //取得原图的数据区高度  
508.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
509.  int h[5][5];//定义(5x5)矩阵  
510.  h[0][0] = 1;  h[0][1] = 1; h[0][2] = 1; h[0][3] = 1; h[0][4] = 1;  
511.  h[1][0] = 1;  h[1][1] = 2; h[1][2] = 2; h[1][3] = 2; h[1][4] = 1;  
512.  h[2][0] = 1;  h[2][1] = 2; h[2][2] = 3; h[2][3] = 2; h[2][4] = 1;  
513.  h[3][0] = 1;  h[3][1] = 2; h[3][2] = 2; h[3][3] = 2; h[3][4] = 1;  
514.  h[4][0] = 1;  h[4][1] = 1; h[4][2] = 1; h[4][3] = 1; h[4][4] = 1;  
515.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
516.  for(int j=0;j<height-4;j++) // 每行  
517.  {  
518.   for(int i=0;i<DibWidth-14;i++) // 每列  
519.   {  
520.          int pby_pt=0;  
521.          //对应的第0行的值乘以矩阵对应值，再相加  
522.    pby_pt=h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
523.       +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
524.       +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))  
525.          +h[0][3]*(*(p_data+(height-j-1)*DibWidth+i+9))  
526.       +h[0][4]*(*(p_data+(height-j-1)*DibWidth+i+12))  
527.                   //对应的第1行的值乘以矩阵对应值，再相加  
528.          +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
529.          +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))  
530.       +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))  
531.       +h[1][3]*(*(p_data+(height-j-2)*DibWidth+i+9))  
532.       +h[1][4]*(*(p_data+(height-j-2)*DibWidth+i+12))  
533.                   //对应的第2行的值乘以矩阵对应值，再相加  
534.          +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))  
535.       +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))  
536.       +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6))  
537.       +h[2][3]*(*(p_data+(height-j-3)*DibWidth+i+9))  
538.       +h[2][4]*(*(p_data+(height-j-3)*DibWidth+i+12))  
539.                   //对应的第3行的值乘以矩阵对应值，再相加  
540.          +h[3][0]*(*(p_data+(height-j-4)*DibWidth+i))  
541.          +h[3][1]*(*(p_data+(height-j-4)*DibWidth+i+3))  
542.       +h[3][2]*(*(p_data+(height-j-4)*DibWidth+i+6))  
543.       +h[3][3]*(*(p_data+(height-j-4)*DibWidth+i+9))  
544.       +h[3][4]*(*(p_data+(height-j-4)*DibWidth+i+12))  
545.                   //对应的第4行的值乘以矩阵对应值，再相加  
546.          +h[4][0]*(*(p_data+(height-j-5)*DibWidth+i))  
547.       +h[4][1]*(*(p_data+(height-j-5)*DibWidth+i+3))  
548.       +h[4][2]*(*(p_data+(height-j-5)*DibWidth+i+6))  
549.       +h[4][3]*(*(p_data+(height-j-5)*DibWidth+i+9))  
550.       +h[4][4]*(*(p_data+(height-j-5)*DibWidth+i+12));  
551.                   //为了计算方便我们把除以35（矩阵权和）放在求总和之后  
552.    *(p_temp+(height-j-3)*DibWidth+i+6)=abs(int(pby_pt/35));  
553.   }  
554.  }  
555.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
556.  delete []p_temp;  //删除暂时分配内存  
557. }  
558.   
559. /***************************************************************/  
560. /*函数名称：ShuiPingGROW()                                     */  
561. /*函数类型：void                                               */  
562. /*功能：使图像水平增强。                                       */  
563. /***************************************************************/  
564. void MakeColorDib::ShuiPingGROW()   //水平增强  
565. {  
566.  BYTE *p_data;     //原图数据区指针  
567.  int wide,height,DibWidth;    //原图长、宽、字节宽  
568.  p_data=this->GetData ();   //取得原图的数据区指针  
569.     wide=this->GetWidth ();  //取得原图的数据区宽度  
570.     height=this->GetHeight ();   //取得原图的数据区高度  
571.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
572.  int h[3][1];//定义(3x1)矩阵  
573.  h[0][0] = -1;    
574.  h[1][0] = 2;   
575.  h[2][0] = -1;  
576.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
577.  for(int j=0;j<height-2;j++) // 每行  
578.  {  
579.   for(int i=0;i<DibWidth-8;i++) // 每列  
580.   {  
581.    int pby_pt=0;  
582.    //对应的3行的值乘分别以矩阵对应值，再相加  
583.    pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
584.     +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
585.     +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i));  
586.    if(pby_pt>20)  
587.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;  
588.    else  
589.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);  
590.   }  
591.  }  
592.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
593.     delete []p_temp;  //删除暂时分配内存  
594. }  
595.   
596. /***************************************************************/  
597. /*函数名称：ChuiZhiGROW()                                      */  
598. /*函数类型：void                                               */  
599. /*功能：使图像垂直增强。                                       */  
600. /***************************************************************/  
601. void MakeColorDib::ChuiZhiGROW()   //垂直增强  
602. {  
603.  BYTE *p_data;     //原图数据区指针  
604.  int wide,height,DibWidth;    //原图长、宽、字节宽  
605.  p_data=this->GetData ();   //取得原图的数据区指针  
606.     wide=this->GetWidth ();  //取得原图的数据区宽度  
607.     height=this->GetHeight ();   //取得原图的数据区高度  
608.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
609.  int h[1][3];//定义(1x3)矩阵  
610.  h[0][0] = -1;   
611.  h[0][1] = 2;  
612.  h[0][2] = -1;  
613.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
614.  for(int j=0;j<height-2;j++) // 每行  
615.  {  
616.   for(int i=0;i<DibWidth-8;i++) // 每列  
617.   {  
618.    int pby_pt=0;  
619.    //对应的第0行的值乘以矩阵对应值，再相加  
620.    pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
621.     +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
622.     +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6));  
623.    if(pby_pt>20)  
624.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;  
625.    else  
626.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);  
627.   }  
628.  }  
629.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
630.  delete []p_temp;  //删除暂时分配内存  
631. }  
632.   
633. /***************************************************************/  
634. /*函数名称：ShuangXiangGROW()                                  */  
635. /*函数类型：void                                               */  
636. /*功能：使图像双向增强。                                       */  
637. /***************************************************************/  
638. void MakeColorDib::ShuangXiangGROW()    //双向增强  
639. {  
640.  BYTE *p_data;     //原图数据区指针  
641.  int wide,height,DibWidth;    //原图长、宽、字节宽  
642.  p_data=this->GetData ();   //取得原图的数据区指针  
643.     wide=this->GetWidth ();  //取得原图的数据区宽度  
644.     height=this->GetHeight ();   //取得原图的数据区高度  
645.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
646.  int h[3][3];//定义(3x3)矩阵  
647.  h[0][0] = -1;  h[0][1] = -1; h[0][2] = -1;  
648.  h[1][0] = -1;  h[1][1] =  8; h[1][2] = -1;  
649.  h[2][0] = -1;  h[2][1] = -1; h[2][2] = -1;   
650.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
651.  for(int j=0;j<height-2;j++) // 每行  
652.  {   
653.   for(int i=0;i<DibWidth-8;i++) // 每列  
654.   {  
655.    int pby_pt=0;  
656.    //对应的第0行的值乘以矩阵对应值，再相加  
657.    pby_pt= h[0][0]*(*(p_data+(height-j-1)*DibWidth+i))  
658.     +h[0][1]*(*(p_data+(height-j-1)*DibWidth+i+3))  
659.     +h[0][2]*(*(p_data+(height-j-1)*DibWidth+i+6))  
660.     //对应的第1行的值乘以矩阵对应值，再相加  
661.     +h[1][0]*(*(p_data+(height-j-2)*DibWidth+i))  
662.     +h[1][1]*(*(p_data+(height-j-2)*DibWidth+i+3))  
663.     +h[1][2]*(*(p_data+(height-j-2)*DibWidth+i+6))  
664.     //对应的第2行的值乘以矩阵对应值，再相加  
665.     +h[2][0]*(*(p_data+(height-j-3)*DibWidth+i))  
666.     +h[2][1]*(*(p_data+(height-j-3)*DibWidth+i+3))  
667.     +h[2][2]*(*(p_data+(height-j-3)*DibWidth+i+6));  
668.    if(pby_pt>20)  
669.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt)+100;  
670.    else  
671.     *(p_temp+(height-j-2)*DibWidth+i)=abs(pby_pt);  
672.   }  
673.  }   
674.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
675.  delete []p_temp;  //删除暂时分配内存  
676. }  
677.   
678. /***************************************************************/  
679. /*函数名称：Mosaic()                                           */  
680. /*函数类型：void                                               */  
681. /*功能：使图像产生马赛克效果。                                 */  
682. /***************************************************************/  
683. void MakeColorDib::Mosaic()    //马赛克  
684. {  
685.  BYTE *p_data;     //原图数据区指针  
686.  int wide,height,DibWidth;    //原图长、宽、字节宽  
687.  p_data=this->GetData ();   //取得原图的数据区指针  
688.     wide=this->GetWidth ();  //取得原图的数据区宽度  
689.     height=this->GetHeight ();   //取得原图的数据区高度  
690.  DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数  
691.  BYTE *p_temp=new BYTE[height*DibWidth]; // 暂时分配内存，以保存新图像  
692.  for(int j=0;j<height-4;j+=5) // 每行  
693.  {   
694.      for(int i=0;i<DibWidth-14;i+=15) // 每列  
695.   {   //对应周围(5x5)矩阵蓝色值求和平均  
696.    int pby_pt=0;  
697.    for(int m=0;m<5;m++)  
698.     for(int n=0;n<15;n+=3)  
699.     {     
700.      pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n);  
701.     }  
702.       
703.    for(m=0;m<5;m++)  
704.     for(int n=0;n<14;n+=3)  
705.     {  
706.      *(p_temp+(height-j-1-m)*DibWidth+i+n)=int(pby_pt/25);  
707.     }   
708.             //对应周围(5x5)矩阵绿色值求和平均  
709.    pby_pt=0;  
710.    for(m=0;m<5;m++)  
711.     for(int n=0;n<15;n+=3)  
712.     {  
713.      pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n+1);  
714.     }  
715.    for(m=0;m<5;m++)  
716.     for(int n=0;n<14;n+=3)  
717.     {  
718.      *(p_temp+(height-j-1-m)*DibWidth+i+n+1)=int(pby_pt/25);  
719.     }  
720.             //对应周围(5x5)矩阵红色值求和平均  
721.    pby_pt=0;  
722.    for(m=0;m<5;m++)  
723.     for(int n=0;n<15;n+=3)  
724.     {  
725.      pby_pt+=*(p_data+(height-j-1-m)*DibWidth+i+n+2);  
726.     }  
727.    for(m=0;m<5;m++)  
728.     for(int n=0;n<14;n+=3)  
729.     {  
730.      *(p_temp+(height-j-1-m)*DibWidth+i+n+2)=int(pby_pt/25);  
731.     }  
732.   }     
733.  }  
734.  memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像  
735.  delete []p_temp;  //删除暂时分配内存  
736. }  
737.   
738.   
739.   
740.