Category

Development Platform
Home > SourceCode/Document > Graph program > Special Effects > View Code
WeiFenDib.cpp
Package: tuxiang.rar　[view]
Upload User: szkelitina
Upload Date: 2022-05-21
Package Size: 6797k
Code Size: 14k
Category:

Special Effects

Development Platform:

Visual C++

WeiFenDib.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "windowsx.h"
  3. #include "math.h"
  4. #include "WeiFenDib.h"
  5. #include "MainFrm.h"
  6. #include "DynSplitView2.h"
  7. #include "CDIB.h"
  9. WeiFenDib::WeiFenDib()
  10. {
  11. }
  13. WeiFenDib::~WeiFenDib()
  14. {
  15. }
  17. /***************************************************************/           
  18. /*函数名称：ZongXiang()                                        */
  19. /*函数类型：void                                               */
  20. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  21. /*功能：对图像进行纵向微分                                     */
  22. /***************************************************************/
  23. void WeiFenDib::ZongXiang()
  24. {    
  25.     BYTE  *p_data;     //原图数据区指针
  26. int wide,height;    //原图长、宽
  27. p_data=this->GetData ();
  28.     wide=this->GetWidth ();
  29.     height=this->GetHeight ();
  30. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  31. {     
  32.         LPBYTE   temp=new BYTE [wide*height];    //开辟图像一缓冲区
  33. memset(temp,255,wide*height);
  34. for(int j=1;j<height-1;j++)
  35. for(int i=1;i<wide-1;i++)
  36. //当前像素的灰度值等于其和左方像素灰度值之差的绝对值
  37. temp[wide*j+i]=abs(p_data[wide*j+i]-p_data[wide*j+(i-1)]);
  38. //将缓冲区中的图像复制回原图数据区
  39. memcpy(p_data, temp,wide*height);
  40. //删除缓冲区
  41. delete  temp;
  42. }
  43. else //24位彩色
  44. {    
  45. int DibWidth;    //原图长、宽
  46. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  47. BYTE *p_temp=new BYTE[height*DibWidth];
  48. for(int j=1;j<height-1;j++) // 每行
  49. {
  50. for(int i=3;i<DibWidth-3;i++) // 每列
  51. {
  52. int pby_pt=0;
  53. pby_pt=*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i-3);
  54.                 *(p_temp+(height-j-1)*DibWidth+i)=abs(pby_pt);
  55. }
  56. }
  57. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  58.         delete []p_temp;  //删除暂时分配内存
  59. }    
  60. }
  62. /***************************************************************/           
  63. /*函数名称：HengXiang()                                        */
  64. /*函数类型：void                                               */
  65. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  66. /*功能：对图像进行横向微分                                     */
  67. /***************************************************************/
  68. void WeiFenDib::HengXiang()
  69. {
  70.     LPBYTE p_data;     //原图数据区指针
  71.     int wide,height;    //原图长、宽
  72. p_data=this->GetData ();
  73.     wide=this->GetWidth ();
  74.     height=this->GetHeight ();
  75. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  76. {     
  77.         LPBYTE  temp=new BYTE [wide*height];    //开辟图像一缓冲区
  78. memset(temp,255,wide*height);
  79. for(int j=1;j<height-1;j++)
  80.     for(int i=1;i<wide-1;i++)
  81. //当前像素的灰度值等于其和上方像素灰度值之差的绝对值
  82. temp[wide*j+i]=abs(p_data[wide*j+i]-p_data[wide*(j-1)+i]);
  83.         //将缓冲区中的图像复制回原图数据区
  84. memcpy(p_data, temp,wide*height);
  85. //删除缓冲区
  86. delete  temp;
  87. }
  88. else  //24位彩色
  89. {    
  90. int DibWidth;    //原图长、宽
  91. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  92. BYTE *p_temp=new BYTE[height*DibWidth];
  93. for(int j=1;j<height-1;j++) // 每行
  94. {
  95. for(int i=3;i<DibWidth-3;i++) // 每列
  96. {
  97. int pby_pt=0;
  98. pby_pt=*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j)*DibWidth+i);
  99.                 *(p_temp+(height-j-1)*DibWidth+i)=abs(pby_pt);
  100. }
  101. }
  102. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  103.         delete []p_temp;  //删除暂时分配内存
  104. }    
  105. }
  107. /***************************************************************/           
  108. /*函数名称：ShuangXiang()                                      */
  109. /*函数类型：void                                               */
  110. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  111. /*功能：对图像进行双向一次微分                                 */
  112. /***************************************************************/
  113. void WeiFenDib::ShuangXiang()
  114. {
  115.     LPBYTE  p_data;     //原图数据区指针
  116. int wide,height;    //原图长、宽 
  117. p_data=this->GetData ();
  118.     wide=this->GetWidth ();
  119.     height=this->GetHeight ();
  120. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  121. {     
  122.         LPBYTE temp=new BYTE [wide*height];    //开辟图像一缓冲区
  123. memset(temp,255,wide*height);
  124. for(int j=1;j<height-1;j++)
  125. for(int i=1;i<wide-1;i++)
  126. //根据双向一次微分公式计算当前像素的灰度值
  127. temp[wide*j+i]=(int)sqrt((p_data[wide*j+i]-p_data[wide*j+(i-1)])*(p_data[wide*j+i]-p_data[wide*j+(i-1)])+(p_data[wide*j+i]-p_data[wide*(j-1)+i])*(p_data[wide*j+i]-p_data[wide*(j-1)+i]));
  128.         //将缓冲区中的图像复制回原图数据区
  129. memcpy(p_data, temp,wide*height);
  130. //删除缓冲区
  131. delete  temp;
  132. }
  133. else //24位彩色
  134. {    
  135. int DibWidth;    //原图长、宽
  136. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  137. BYTE *p_temp=new BYTE[height*DibWidth];
  138. for(int j=1;j<height-1;j++) // 每行
  139. {
  140. for(int i=3;i<DibWidth-3;i++) // 每列
  141. {
  142. int pby_pt1=0,pby_pt2=0;
  143. pby_pt1=*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j-1)*DibWidth+i-3);
  144.                 pby_pt2=*(p_data+(height-j-1)*DibWidth+i)-*(p_data+(height-j)*DibWidth+i);
  145.                 *(p_temp+(height-j-1)*DibWidth+i)=(int)sqrt(pby_pt1*pby_pt1+pby_pt2*pby_pt2);
  146. }
  147. }
  148. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  149.         delete []p_temp;  //删除暂时分配内存
  150. }
  151. }
  153. /***************************************************************/           
  154. /*函数名称：ErCi1()                                            */
  155. /*函数类型：void                                               */
  156. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  157. /*功能：对图像进行二次微分                                     */
  158. /*算子如下：       +1  -2  +1                                  */
  159. /*                 -2  +4  -2                                  */
  160. /*                 +1  -2  +1                                  */
  161. /*                                                             */
  162. /***************************************************************/
  163. void WeiFenDib::ErCi1()
  164. {
  165.     LPBYTE p_data;     //原图数据区指针
  166. int wide,height;    //原图长、宽
  167. p_data=this->GetData ();
  168.     wide=this->GetWidth ();
  169.     height=this->GetHeight ();
  170. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  171. {     
  172.         LPBYTE   temp=new BYTE [wide*height];    //开辟图像一缓冲区
  173. memset(temp,255,wide*height);   //初始化为255
  174. for(int j=1;j<height-1;j++)
  175.     for(int i=1;i<wide-1;i++)
  176. //根据算子计算每个像素的灰度值
  177. temp[wide*j+i]=abs(p_data[wide*(j-1)+(i-1)]-2*p_data[wide*(j-1)+i]+p_data[wide*(j-1)+(i+1)]-2*p_data[wide*j+(i-1)]+4*p_data[wide*j+i]-2*p_data[wide*j+(i+1)]+p_data[wide*(j+1)+(i-1)]-2*p_data[wide*(j+1)+i]+p_data[wide*(j+1)+(i+1)]);
  178.         //将缓冲区中的图像复制回原图数据区
  179. memcpy(p_data, temp,wide*height);
  180.         //删除缓冲区
  181. delete  temp;
  182. }
  183. else  //24位彩色
  184. {
  185. int DibWidth;    //原图长、宽
  186. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  187. BYTE *p_temp=new BYTE[height*DibWidth];
  188. for(int j=1;j<height-2;j++) // 每行
  189. {
  190. for(int i=3;i<DibWidth-8;i++) // 每列
  191. {
  192. int pby_pt=0;
  193. pby_pt=*(p_data+(height-j)*DibWidth+i-3)-2*(*(p_data+(height-j)*DibWidth+i))
  194. +*(p_data+(height-j)*DibWidth+i+3)-2*(*(p_data+(height-j-1)*DibWidth+i-3))
  195. +4*(*(p_data+(height-j-1)*DibWidth+i))-2*(*(p_data+(height-j-1)*DibWidth+i+3))
  196. +*(p_data+(height-j-2)*DibWidth+i-3)-2*(*(p_data+(height-j-2)*DibWidth+i))
  197. +*(p_data+(height-j-2)*DibWidth+i+3);
  198.                 *(p_temp+(height-j-1)*DibWidth+i)=abs(pby_pt);
  199. }
  200.     }
  201. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  202. delete []p_temp;  //删除暂时分配内存
  203. }
  204. }
  206. /***************************************************************/           
  207. /*函数名称：ErCi2()                                            */
  208. /*函数类型：void                                               */
  209. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  210. /*功能：对图像进行二次微分                                     */
  211. /*算子如下：    +1  +1  +1                                     */
  212. /*              +1  -8  +1                                     */
  213. /*              +1  +1  +1                                     */
  214. /*                                                             */
  215. /***************************************************************/
  216. void WeiFenDib::ErCi2()
  217. {
  218.     LPBYTE  p_data;     //原图数据区指针
  219. int wide,height;    //原图长、宽
  220. p_data=this->GetData ();
  221.     wide=this->GetWidth ();
  222.     height=this->GetHeight ();
  223. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  224. {     
  225.         LPBYTE  temp=new BYTE [wide*height];    //开辟图像一缓冲区
  226. memset(temp,255,wide*height);
  227. for(int j=1;j<height-1;j++)
  228. for(int i=1;i<wide-1;i++)
  229. temp[wide*j+i]=abs(p_data[wide*(j-1)+(i-1)]+p_data[wide*(j-1)+i]+p_data[wide*(j-1)+(i+1)]+p_data[wide*j+(i-1)]-8*p_data[wide*j+i]+p_data[wide*j+(i+1)]+p_data[wide*(j+1)+(i-1)]+p_data[wide*(j+1)+i]+p_data[wide*(j+1)+(i+1)]);
  230.         memcpy(p_data, temp,wide*height);
  231. delete  temp;
  232. }
  233. else //24位彩色
  234. {    
  235. int DibWidth;    //原图长、宽
  236. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  237. BYTE *p_temp=new BYTE[height*DibWidth];
  238. for(int j=1;j<height-2;j++) // 每行
  239. {
  240. for(int i=3;i<DibWidth-8;i++) // 每列
  241. {
  242. int pby_pt=0;
  243. pby_pt=*(p_data+(height-j)*DibWidth+i-3)+*(p_data+(height-j)*DibWidth+i)
  244. +*(p_data+(height-j)*DibWidth+i+3)+*(p_data+(height-j-1)*DibWidth+i-3)
  245. -8*(*(p_data+(height-j-1)*DibWidth+i))+*(p_data+(height-j-1)*DibWidth+i+3)
  246. +*(p_data+(height-j-2)*DibWidth+i-3)+*(p_data+(height-j-2)*DibWidth+i)
  247. +*(p_data+(height-j-2)*DibWidth+i+3);
  248.                 *(p_temp+(height-j-1)*DibWidth+i)=abs(pby_pt);
  249. }
  250. }
  251. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  252.         delete []p_temp;  //删除暂时分配内存
  253. }
  254. }
  256. /***************************************************************/           
  257. /*函数名称：ErCi3()                                            */
  258. /*函数类型：void                                               */
  259. /*返回值：处理成功返回TRUE;处理失败返回FALSE。                 */                                       
  260. /*功能：对图像进行二次微分                                     */
  261. /*算子如下：    +1+1+1                                         */
  262. /*              +1+1+1                                         */
  263. /*              +1+1+1                                         */
  264. /*        +1+1+1-4-4-4 +1+1+1                                  */
  265. /*        +1+1+1-4-4-4 +1+1+1                                  */
  266. /*        +1+1+1-4-4-4 +1+1+1                                  */
  267. /*              +1+1+1                                         */
  268. /*              +1+1+1                                         */
  269. /*              +1+1+1                                         */
  270. /*                                                             */
  271. /***************************************************************/
  272. void WeiFenDib::ErCi3()
  273. {
  274.     LPBYTE  p_data;     //原图数据区指针
  275. int wide,height;//原图长、宽
  276.     p_data=this->GetData ();
  277.     wide=this->GetWidth ();
  278.     height=this->GetHeight ();
  279. if (m_pBitmapInfoHeader->biBitCount<9) //灰度图像
  280. {
  281.     int x,y;   //循环变量
  282.         int cent3x3,up3x3,down3x3,right3x3,left3x3;   //中心的上下左右四个区域积的和
  283.         BYTE**  temp1=new BYTE*  [height+8];
  284.     BYTE** temp2=new BYTE*  [height];
  285.     for (y=0;y<height;y++)
  286.     temp2[y]=new BYTE [wide];
  287.     for (y=0;y<height+8;y++)
  288.      temp1[y]=new BYTE [wide+8];
  289.     for (y=0;y<height;y++)
  290.     for(x=0;x<wide;x++)
  291.     temp2[y][x]=0;
  292.     for (y=0;y<height+8;y++)
  293.      for(x=0;x<wide+8;x++)
  294.      temp1[y][x]=0;
  295. for (y=0;y<height;y++)
  296.     for(x=0;x<wide;x++)
  297.     temp1[y+4][x+4]=p_data[wide*y+x];
  298. for (y=4;y<height+4;y++)
  299. for(x=4;x<wide+4;x++)
  300. {
  301. cent3x3=-4* temp1[y-1][x-1]-4* temp1[y-1][x]-4* temp1[y-1][x+1]-4* temp1[y][x-1]-4* temp1[y][x]-4* temp1[y][x+1]-4* temp1[y+1][x-1]-4* temp1[y+1][x]-4* temp1[y+1][x+1];
  302. up3x3= temp1[y-4][x-1]+ temp1[y-4][x]+ temp1[y-4][x+1]+ temp1[y-3][x-1]+ temp1[y-3][x]+ temp1[y-3][x+1]+ temp1[y-2][x-1]+ temp1[y-2][x]+ temp1[y-2][x+1];
  303. down3x3= temp1[y+2][x-1]+ temp1[y+2][x]+ temp1[y+2][x+1]+ temp1[y+3][x-1]+ temp1[y+3][x]+ temp1[y+3][x+1]+ temp1[y+4][x-1]+ temp1[y+4][x]+ temp1[y+4][x+1];
  304. right3x3=temp1[y-1][x+2]+ temp1[y-1][x+3]+ temp1[y-1][x+4]+ temp1[y][x+2]+ temp1[y][x+3]+ temp1[y][x+4]+ temp1[y+1][x+2]+ temp1[y+1][x+3]+ temp1[y+1][x+4];
  305. left3x3=temp1[y-1][x-4]+ temp1[y-1][x-3]+ temp1[y-1][x-2]+ temp1[y][x-4]+ temp1[y][x-3]+ temp1[y][x-2]+ temp1[y+1][x-4]+ temp1[y+1][x-3]+ temp1[y+1][x-2];
  306. temp2[y-4][x-4]=abs(cent3x3+up3x3+down3x3+right3x3+left3x3);
  307. }
  308. for (y=0;y<height;y++)
  309.  for(x=0;x<wide;x++)
  310.     p_data[wide*y+x]=temp2[y][x];
  311. }
  312. else  //24位彩色
  313. {
  314. int DibWidth;    //原图长、宽
  315. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  316. BYTE *p_temp=new BYTE[height*DibWidth];
  317. for(int j=1;j<height-2;j++) // 每行
  318. {
  319. for(int i=3;i<DibWidth-8;i++) // 每列
  320. {
  321. int pby_pt=0;
  322. pby_pt=*(p_data+(height-j)*DibWidth+i-3)-2*(*(p_data+(height-j)*DibWidth+i))
  323. +*(p_data+(height-j)*DibWidth+i+3)-2*(*(p_data+(height-j-1)*DibWidth+i-3))
  324. +4*(*(p_data+(height-j-1)*DibWidth+i))-2*(*(p_data+(height-j-1)*DibWidth+i+3))
  325. +*(p_data+(height-j-2)*DibWidth+i-3)-2*(*(p_data+(height-j-2)*DibWidth+i))
  326. +*(p_data+(height-j-2)*DibWidth+i+3);
  327.                 *(p_temp+(height-j-1)*DibWidth+i)=abs(pby_pt);
  328. }
  329. }
  330. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  331. delete []p_temp;  //删除暂时分配内存
  332. BYTE *p_temp1=new BYTE[height*DibWidth];
  333. for(int a=1;a<height-2;a++) // 每行
  334. {
  335. for(int b=3;b<DibWidth-8;b++) // 每列
  336. {
  337. int pby_pt=0;
  338. pby_pt=*(p_data+(height-a)*DibWidth+b-3)+*(p_data+(height-a)*DibWidth+b)
  339. +*(p_data+(height-a)*DibWidth+b+3)+*(p_data+(height-a-1)*DibWidth+b-3)
  340. -8*(*(p_data+(height-a-1)*DibWidth+b))+*(p_data+(height-a-1)*DibWidth+b+3)
  341. +*(p_data+(height-a-2)*DibWidth+b-3)+*(p_data+(height-a-2)*DibWidth+b)
  342. +*(p_data+(height-a-2)*DibWidth+b+3);
  343.                 *(p_temp1+(height-a-1)*DibWidth+b)=abs(pby_pt);
  344. }
  345. }
  346. memcpy(p_data,p_temp,height*DibWidth);  // 复制处理后的图像
  347. delete []p_temp1;  //删除暂时分配内存
  348. }
  349. }