Category

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

Special Effects

Development Platform:

Visual C++

TuXiangHeChengDib.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "windowsx.h"
  3. #include "math.h"
  4. #include "TuXiangHeChengDib.h"
  5. #include "MainFrm.h"
  6. #include "DynSplitView2.h"
  8.  
  9.  
  10. TuXiangHeChengDib::TuXiangHeChengDib()
  11. {
  12. bool m_valid=true;
  13. }
  14. TuXiangHeChengDib::~TuXiangHeChengDib()
  15. {
  16. }
  20. ///***************************************************************/           
  21. /*函数名称：Add(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  22. /*函数类型：void 
  23. /*参数说明：p_data       原图像首地址
  24. /*          p_dataBK     背景图像首地址
  25. /*          wide，height 原图像的高和宽                                   
  26. /*功能：对图像进行加运算。            
  27. /***************************************************************/ 
  28. void TuXiangHeChengDib::Add(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)
  29. {
  30. LPBYTE lpSrc;  //原图像像素指针
  31.     LPBYTE lpDst;   //目标像素指针
  32.     LPBYTE lpSrcBK;  //背景像素指针
  33. if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  34. {
  35. int i,j;  //循环变量
  36. LPBYTE  temp=new BYTE[wide*height];    //新图像缓冲区
  37. //初始化新分配的内存为255
  38. memset(temp,255,wide*height);
  39. //进行每个像素的加运算
  40. for(j=1;j<height-1;j++)
  41. {
  42. for(i=1;i<wide-1;i++)
  43. {
  44. //获得原像素指针
  45. lpSrc=p_data+wide*j+i;
  46. //获得目标像素指针
  47. lpDst=temp+wide*j+i;
  48. //获得背景像素指针
  49. lpSrcBK=p_dataBK+wide*j+i;
  50. //进行加运算
  51. if((*lpSrc+*lpSrcBK)>255)
  52. *lpDst=255;
  53. else
  54. *lpDst=(*lpSrc+*lpSrcBK);
  55. }
  56. }
  57. memcpy(p_data, temp,wide*height);   //复制处理后的图像
  58. delete  temp;
  59. }
  60. else //24位真彩色
  61. {
  62. LONG wide,height,DibWidth;    //原图长、宽
  63. p_data=this->GetData ();   //取得原图的数据区指针
  64. wide=this->GetWidth ();  //取得原图的数据区宽度
  65. height=this->GetHeight ();   //取得原图的数据区高度
  66. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  67. BYTE *p_temp=new BYTE[height*DibWidth];
  68. //进行每个像素的加运算
  69. for(int j=1;j<height-1;j++)
  70. {
  71. for(int i=3;i<DibWidth-3;i++)
  72. {
  73. //获得原像素指针
  74. lpSrc=p_data+DibWidth*j+i;
  75. //获得目标像素指针
  76. lpDst=p_temp+DibWidth*j+i;
  77. //获得背景像素指针
  78. lpSrcBK=p_dataBK+DibWidth*j+i;
  79. //进行加运算
  80. if((*lpSrc+*lpSrcBK)>255)
  81. *lpDst=255;
  82. else
  83. *lpDst=(*lpSrc+*lpSrcBK);
  84. }
  85. }
  86. memcpy(p_data, p_temp,DibWidth*height);   //复制处理后的图像
  87. delete  []p_temp;
  88. }
  89. }
  93. ///***************************************************************/           
  94. /*函数名称：Sub(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  95. /*函数类型：void 
  96. /*参数说明：p_data       原图像首地址
  97. /*          p_dataBK     背景图像首地址
  98. /*          wide，height 原图像的高和宽                                   
  99. /*功能：对图像进行减运算。            
  100. /***************************************************************/ 
  101. void TuXiangHeChengDib::Sub(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  102. {
  103. LPBYTE lpSrc;  //原图像像素指针
  104.     LPBYTE lpDst;   //目标像素指针
  105.     LPBYTE lpSrcBK;  //背景像素指针
  106.     if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  107. {
  108. int i,j;  //循环变量
  109. LPBYTE  temp=new BYTE[wide*height];    //新图像缓冲区
  110. //初始化新分配的内存为255
  111. memset(temp,255,wide*height);
  112. //进行每个像素的减运算
  113. for(j=1;j<height-1;j++)
  114. {
  115. for(i=1;i<wide-1;i++)
  116. {
  117. //获得原像素指针
  118. lpSrc=p_data+wide*j+i;
  119. //获得目标像素指针
  120. lpDst=temp+wide*j+i;
  121. //获得背景像素指针
  122. lpSrcBK=p_dataBK+wide*j+i;
  123. //进行减运算
  124. if((*lpSrc-*lpSrcBK)<0)
  125. *lpDst=0;
  126. else
  127. *lpDst=(*lpSrc-*lpSrcBK);
  128. }
  129. }
  130. memcpy(p_data, temp,wide*height);   //复制处理后的图像
  131. delete  temp;
  132. }
  133. else//24位真彩色
  134. {
  135. int wide,height,DibWidth;    //原图长、宽
  136. p_data=this->GetData ();   //取得原图的数据区指针
  137. wide=this->GetWidth ();  //取得原图的数据区宽度
  138. height=this->GetHeight ();   //取得原图的数据区高度
  139. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  140. BYTE *p_temp=new BYTE[height*DibWidth];
  141. //进行每个像素的减运算
  142. for(int j=1;j<height-1;j++)
  143. {
  144. for(int i=1;i<DibWidth-1;i++)
  145. {
  146. //获得原像素指针
  147. lpSrc=p_data+DibWidth*j+i;
  148. //获得目标像素指针
  149. lpDst=p_temp+DibWidth*j+i;
  150. //获得背景像素指针
  151. lpSrcBK=p_dataBK+DibWidth*j+i;
  152. //进行减运算
  153. if((*lpSrc-*lpSrcBK)<0)
  154. *lpDst=0;
  155. else
  156. *lpDst=(*lpSrc-*lpSrcBK);
  157. }
  158. }
  159. memcpy(p_data, p_temp,DibWidth*height);   //复制处理后的图像
  160. delete  []p_temp;
  161. }
  162. }
  166. ///***************************************************************/           
  167. /*函数名称：Yuyunsuan(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  168. /*函数类型：void 
  169. /*参数说明：p_data       原图像首地址
  170. /*          p_dataBK     背景图像首地址
  171. /*          wide，height 原图像的高和宽                                   
  172. /*功能：对图像进行与运算。            
  173. /***************************************************************/
  174. void TuXiangHeChengDib::Yuyunsuan(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  175. {
  176.     if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  177. {
  178. int i,j;  //循环变量   
  179. LPBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
  180. LPBYTE  temp2=new BYTE[wide*height]; 
  181. memset( temp1,0,wide*height);
  182. memset( temp2,0,wide*height);
  183. //对原图二值化
  184. for(j=0;j<height;j++)
  185. {
  186. for(i=0;i<wide;i++)
  187. {
  188. if(p_data[wide*j+i]>128)
  189. temp1[wide*j+i]=1; 
  190. }
  191. }
  192. //对背景二值化
  193. for(j=0;j<height;j++)
  194. {
  195. for(i=0;i<wide;i++)
  196. {
  197. if(p_dataBK[wide*j+i]>128)
  198. temp2[wide*j+i]=1; 
  199. }
  200. }
  201. //进行每个像素的与运算
  202. for(j=1;j<height-1;j++)
  203. {
  204. for(i=1;i<wide-1;i++)
  205. {   
  206. if( temp2[wide*j+i]==1&& temp1[wide*j+i]==1)
  207. temp1[wide*j+i]=255;
  208. else 
  209. temp1[wide*j+i]=0;
  210. }
  211. }
  212. memcpy(p_data, temp1,wide*height);   //复制处理后的图像
  213. delete  temp1;
  214. delete  temp2;
  215. }
  216. else//24位真彩色
  217. {
  218. int i,j;  //循环变量
  219. LPBYTE  p_data;     //原图数据区指针
  220. int wide,height,DibWidth;    //原图长、宽
  221. p_data=this->GetData ();   //取得原图的数据区指针
  222. wide=this->GetWidth ();  //取得原图的数据区宽度
  223. height=this->GetHeight ();   //取得原图的数据区高度
  224. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  225. BYTE *p_temp1=new BYTE[height*DibWidth];
  226. BYTE *p_temp2=new BYTE[height*DibWidth];
  227. //对原图二值化
  228. for(j=0;j<height;j++)
  229. {
  230. for(i=0;i<DibWidth;i++)
  231. {
  232. if(p_data[DibWidth*j+i]>128)
  233. p_temp1[DibWidth*j+i]=1; 
  234. }
  235. }
  236. //对背景二值化
  237. for(j=0;j<height;j++)
  238. {
  239. for(i=0;i<DibWidth;i++)
  240. {
  241. if(p_dataBK[DibWidth*j+i]>128)
  242. p_temp2[DibWidth*j+i]=1; 
  243. }
  244. }
  245. //进行每个像素的与运算
  246. for(j=1;j<height-1;j++)
  247. {
  248. for(i=1;i<DibWidth-1;i++)
  249. {   
  250. if( p_temp2[DibWidth*j+i]==1&& p_temp1[DibWidth*j+i]==1)
  251. p_temp1[DibWidth*j+i]=255;
  252. else 
  253. p_temp1[DibWidth*j+i]=0;
  254. }
  255. }
  256. memcpy(p_data, p_temp1,DibWidth*height);   //复制处理后的图像
  257. delete  []p_temp1;
  258. delete  []p_temp2;
  259. }
  260. }
  261. ///***************************************************************/           
  262. /*函数名称：Huoyunsuan(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  263. /*函数类型：void 
  264. /*参数说明：p_data       原图像首地址
  265. /*          p_dataBK     背景图像首地址
  266. /*          wide，height 原图像的高和宽                                   
  267. /*功能：对图像进行或运算。            
  268. /***************************************************************/ 
  269. void TuXiangHeChengDib::Huoyunsuan(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  270. {
  271.     if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  272. {
  273. int i,j;  //循环变量  
  274. LPBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
  275. LPBYTE  temp2=new BYTE[wide*height]; 
  276. memset(temp1,0,wide*height);
  277. memset(temp2,0,wide*height);
  278. //对原图二值化
  279. for(j=0;j<height;j++)
  280. {
  281. for(i=0;i<wide;i++)
  282. {
  283. if(p_data[wide*j+i]>128)
  284. temp1[wide*j+i]=1; 
  285. }
  286. }
  287. //对背景二值化
  288. for(j=0;j<height;j++)
  289. {
  290. for(i=0;i<wide;i++)
  291. {
  292. if(p_dataBK[wide*j+i]>128)
  293. temp2[wide*j+i]=1; 
  294. }
  295. }
  296. //进行每个像素的与运算
  297. for(j=1;j<height-1;j++)
  298. {
  299. for(i=1;i<wide-1;i++)
  300. {   
  301. if( temp2[wide*j+i]==0&& temp1[wide*j+i]==0)
  302. temp1[wide*j+i]=0;
  303. else 
  304. temp1[wide*j+i]=255;
  305. }
  306. }
  307. memcpy(p_data, temp1,wide*height);   //复制处理后的图像
  308. delete  temp1;
  309. delete  temp2;
  310. }
  311. else//24位真彩色
  312. {
  313. int i,j;  //循环变量
  314. LPBYTE  p_data;     //原图数据区指针
  315. int wide,height,DibWidth;    //原图长、宽
  316. p_data=this->GetData ();   //取得原图的数据区指针
  317. wide=this->GetWidth ();  //取得原图的数据区宽度
  318. height=this->GetHeight ();   //取得原图的数据区高度
  319. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  320. BYTE *p_temp1=new BYTE[height*DibWidth];
  321. BYTE *p_temp2=new BYTE[height*DibWidth];
  322. //对原图二值化
  323. for(j=0;j<height;j++)
  324. {
  325. for(i=0;i<DibWidth;i++)
  326. {
  327. if(p_data[DibWidth*j+i]>128)
  328. p_temp1[DibWidth*j+i]=1; 
  329. }
  330. }
  331. //对背景二值化
  332. for(j=0;j<height;j++)
  333. {
  334. for(i=0;i<DibWidth;i++)
  335. {
  336. if(p_dataBK[DibWidth*j+i]>128)
  337. p_temp2[DibWidth*j+i]=1; 
  338. }
  339. }
  340. //进行每个像素的与运算
  341. for(j=1;j<height-1;j++)
  342. {
  343. for(i=1;i<DibWidth-1;i++)
  344. {   
  345. if( p_temp2[DibWidth*j+i]==0&& p_temp1[DibWidth*j+i]==0)
  346. p_temp1[DibWidth*j+i]=0;
  347. else 
  348. p_temp1[DibWidth*j+i]=255;
  349. }
  350. }
  351.         memcpy(p_data, p_temp1,DibWidth*height);   //复制处理后的图像
  352. delete  []p_temp1;
  353. delete  []p_temp2;
  354. }
  355. }
  359. ///***************************************************************/           
  360. /*函数名称：Feiyunsuan()                                        
  361. /*函数类型：void                                   
  362. /*功能：对图像进行非运算。            
  363. /***************************************************************/ 
  364. void TuXiangHeChengDib::Feiyunsuan()
  365. {
  366. int i,j;  //循环变量
  367. BYTE* p_data;//图像指针
  368. int wide,height;  //原图的高和宽
  369. p_data=GetData();
  370.     if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像     
  371.    wide=GetWidth();
  372. else//24位真彩色
  373.    wide=GetDibWidthBytes();
  374. height=GetHeight();
  375. LPBYTE p_temp1=new BYTE[wide*height]; //新图像缓冲区         
  376. memset(p_temp1,0,wide*height); //初始化为0
  377. //对原图二值化
  378. for(j=0;j<height;j++)
  379. {
  380. for(i=0;i<wide;i++)
  381. {
  382. if(p_data[wide*j+i]>128)
  383. p_temp1[wide*j+i]=1; 
  384. }
  385. }
  386.  
  387. //进行每个像素的与运算
  388.     for(j=1;j<height-1;j++)
  389. {
  390. for(i=1;i<wide-1;i++)
  391. {   
  392. if(p_temp1[wide*j+i]==0 )
  393.  p_temp1[wide*j+i]=255;
  394. else 
  395.  p_temp1[wide*j+i]=0;
  396. }
  397. }
  398.     memcpy(p_data,p_temp1,wide*height);   //复制处理后的图像
  399. delete p_temp1;
  400. }
  404. ///***************************************************************/           
  405. /*函数名称：Huofei(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  406. /*函数类型：void 
  407. /*参数说明：p_data       原图像首地址
  408. /*          p_dataBK     背景图像首地址
  409. /*          wide，height 原图像的高和宽                                   
  410. /*功能：对图像进行或非运算。            
  411. /***************************************************************/ 
  412. void TuXiangHeChengDib::Huofei(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  413. {
  414. if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  415. {
  416. int i,j;  //循环变量  
  417. LPBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
  418. LPBYTE  temp2=new BYTE[wide*height]; 
  419. memset( temp1,0,wide*height);
  420. memset( temp2,0,wide*height);
  421. //对原图二值化
  422. for(j=0;j<height;j++)
  423. {
  424. for(i=0;i<wide;i++)
  425. {
  426. if(p_data[wide*j+i]>128)
  427. temp1[wide*j+i]=1; 
  428. }
  429. }
  430. //对背景二值化
  431. for(j=0;j<height;j++)
  432. {
  433. for(i=0;i<wide;i++)
  434. {
  435. if(p_dataBK[wide*j+i]>128)
  436. temp2[wide*j+i]=1; 
  437. }
  438. }
  439. //进行每个像素的与运算
  440. for(j=1;j<height-1;j++)
  441. {
  442. for(i=1;i<wide-1;i++)
  443. {   
  444. if( temp2[wide*j+i]==0&& temp1[wide*j+i]==0)
  445. temp1[wide*j+i]=255;
  446. else 
  447. temp1[wide*j+i]=0;
  448. }
  449. }
  450. memcpy(p_data, temp1,wide*height);   //复制处理后的图像
  451. delete  temp1;
  452. delete  temp2;
  453. }
  454. else//24位真彩色
  455. {
  456. int i,j;  //循环变量
  457. LPBYTE  p_data;     //原图数据区指针
  458. int wide,height,DibWidth;    //原图长、宽
  459. p_data=this->GetData ();   //取得原图的数据区指针
  460. wide=this->GetWidth ();  //取得原图的数据区宽度
  461. height=this->GetHeight ();   //取得原图的数据区高度
  462. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  463. BYTE *p_temp1=new BYTE[height*DibWidth];
  464. BYTE *p_temp2=new BYTE[height*DibWidth];
  465. //对原图二值化
  466. for(j=0;j<height;j++)
  467. {
  468. for(i=0;i<DibWidth;i++)
  469. {
  470. if(p_data[DibWidth*j+i]>128)
  471. p_temp1[DibWidth*j+i]=1; 
  472. }
  473. }
  474. //对背景二值化
  475. for(j=0;j<height;j++)
  476. {
  477. for(i=0;i<DibWidth;i++)
  478. {
  479. if(p_dataBK[DibWidth*j+i]>128)
  480. p_temp2[DibWidth*j+i]=1; 
  481. }
  482. }
  483. //进行每个像素的与运算
  484. for(j=1;j<height-1;j++)
  485. {
  486. for(i=3;i<DibWidth-3;i++)
  487. {   
  488. if( p_temp2[DibWidth*j+i]==0&& p_temp1[DibWidth*j+i]==0)
  489. p_temp1[DibWidth*j+i]=255;
  490. else 
  491. p_temp1[DibWidth*j+i]=0;
  492. }
  493. }
  494. memcpy(p_data, p_temp1,DibWidth*height);   //复制处理后的图像
  495. delete  []p_temp1;
  496. delete  []p_temp2;
  497. }
  498. }
  502. ///***************************************************************/           
  503. /*函数名称：Yufei(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  504. /*函数类型：void 
  505. /*参数说明：p_data       原图像首地址
  506. /*          p_dataBK     背景图像首地址
  507. /*          wide，height 原图像的高和宽                                   
  508. /*功能：对图像进行与非运算。            
  509. /***************************************************************/
  510. void TuXiangHeChengDib::Yufei(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  511. {
  512. if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  513. {
  514. int i,j;  //循环变量  
  515. PBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
  516. LPBYTE  temp2=new BYTE[wide*height]; 
  517. memset( temp1,0,wide*height);
  518. memset( temp2,0,wide*height);
  519. //对原图二值化
  520. for(j=0;j<height;j++)
  521. {
  522. for(i=0;i<wide;i++)
  523. {
  524. if(p_data[wide*j+i]>128)
  525. temp1[wide*j+i]=1; 
  526. }
  527. }
  528. //对背景二值化
  529. for(j=0;j<height;j++)
  530. {
  531. for(i=0;i<wide;i++)
  532. {
  533. if(p_dataBK[wide*j+i]>128)
  534. temp2[wide*j+i]=1; 
  535. }
  536. }
  537. //进行每个像素的与非运算
  538. for(j=1;j<height-1;j++)
  539. {
  540. for(i=1;i<wide-1;i++)
  541. {   
  542. if( temp2[wide*j+i]==1&& temp1[wide*j+i]==1)
  543. temp1[wide*j+i]=0;
  544. else 
  545. temp1[wide*j+i]=255;
  546. }
  547. }
  548. memcpy(p_data, temp1,wide*height);   //复制处理后的图像
  549. delete  temp1;
  550. delete  temp2;
  551. }
  552. else//24位真彩色
  553. {
  554. int i,j;  //循环变量
  555. LPBYTE  p_data;     //原图数据区指针
  556. int wide,height,DibWidth;    //原图长、宽
  557. p_data=this->GetData ();   //取得原图的数据区指针
  558. wide=this->GetWidth ();  //取得原图的数据区宽度
  559. height=this->GetHeight ();   //取得原图的数据区高度
  560. DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  561. BYTE *p_temp1=new BYTE[height*DibWidth];
  562. BYTE *p_temp2=new BYTE[height*DibWidth];
  563. //对原图二值化
  564. for(j=0;j<height;j++)
  565. {
  566. for(i=0;i<DibWidth;i++)
  567. {
  568. if(p_data[DibWidth*j+i]>128)
  569. p_temp1[DibWidth*j+i]=1; 
  570. }
  571. }
  572. //对背景二值化
  573. for(j=0;j<height;j++)
  574. {
  575. for(i=0;i<DibWidth;i++)
  576. {
  577. if(p_dataBK[DibWidth*j+i]>128)
  578. p_temp2[DibWidth*j+i]=1; 
  579. }
  580. }
  581. //进行每个像素的与非运算
  582. for(j=1;j<height-1;j++)
  583. {
  584. for(i=3;i<DibWidth-3;i++)
  585. {   
  586. if( p_temp2[wide*j+i]==1&& p_temp1[DibWidth*j+i]==1)
  587. p_temp1[DibWidth*j+i]=0;
  588. else 
  589. p_temp1[DibWidth*j+i]=255;
  590. }
  591. }
  592. memcpy(p_data, p_temp1,DibWidth*height);   //复制处理后的图像
  593. delete  []p_temp1;
  594. delete  []p_temp2;
  595. }
  596. }
  599. ///***************************************************************/           
  600. /*函数名称：Yihuo(LPBYTE p_data, LPBYTE p_dataBK,int wide,int height)                                        
  601. /*函数类型：void 
  602. /*参数说明：p_data       原图像首地址
  603. /*          p_dataBK     背景图像首地址
  604. /*          wide，height 原图像的高和宽                                   
  605. /*功能：对图像进行异或运算。            
  606. /***************************************************************/
  607. void TuXiangHeChengDib::Yihuo(LPBYTE p_data, LPBYTE p_dataBK, int wide, int height)
  608. {
  609. if (m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  610. {
  611.        int i,j;  //循环变量 
  612.    LPBYTE  temp1=new BYTE[wide*height]; //新图像缓冲区
  613.        LPBYTE  temp2=new BYTE[wide*height]; 
  614.    memset( temp1,0,wide*height);
  615.        memset( temp2,0,wide*height);
  616.    //对原图二值化
  617.    for(j=0;j<height;j++)
  618.    {
  619. for(i=0;i<wide;i++)
  620. {
  621. if(p_data[wide*j+i]>128)
  622.  temp1[wide*j+i]=1; 
  623. }
  624. }
  625. //对背景二值化
  626. for(j=0;j<height;j++)
  627. {
  628. for(i=0;i<wide;i++)
  629. {
  630. if(p_dataBK[wide*j+i]>128)
  631.    temp2[wide*j+i]=1; 
  632. }
  633. }
  634. //进行每个像素的异或运算
  635.         for(j=1;j<height-1;j++)
  636. {
  637. for(i=1;i<wide-1;i++)
  638. {   
  639. if( temp2[wide*j+i]+ temp1[wide*j+i]==1)
  640.   temp1[wide*j+i]=255;
  641. else 
  642.   temp1[wide*j+i]=0;
  643. }
  644. }
  645.         memcpy(p_data, temp1,wide*height);   //复制处理后的图像
  646. delete  temp1;
  647. delete  temp2;
  648. }
  649. else//24位真彩色
  650. {
  651.         int i,j;  //循环变量
  652.     LPBYTE  p_data;     //原图数据区指针
  653.     int wide,height,DibWidth;    //原图长、宽
  654.     p_data=this->GetData ();   //取得原图的数据区指针
  655.         wide=this->GetWidth ();  //取得原图的数据区宽度
  656.         height=this->GetHeight ();   //取得原图的数据区高度
  657.     DibWidth=this->GetDibWidthBytes();   //取得原图的每行字节数
  658.     BYTE *p_temp1=new BYTE[height*DibWidth];
  659.     BYTE *p_temp2=new BYTE[height*DibWidth];
  660. //对原图二值化
  661. for(j=0;j<height;j++)
  662. {
  663. for(i=0;i<DibWidth;i++)
  664. {
  665. if(p_data[DibWidth*j+i]>128)
  666.  p_temp1[DibWidth*j+i]=1; 
  667. }
  668. }
  669. //对背景二值化
  670. for(j=0;j<height;j++)
  671. {
  672. for(i=0;i<DibWidth;i++)
  673. {
  674. if(p_dataBK[DibWidth*j+i]>128)
  675.    p_temp2[DibWidth*j+i]=1; 
  676. }
  677. }
  678. //进行每个像素的异或运算
  679.         for(j=1;j<height-1;j++)
  680. {
  681. for(i=3;i<DibWidth-3;i++)
  682. {   
  683. if( p_temp2[DibWidth*j+i]+ p_temp1[DibWidth*j+i]==1)
  684. p_temp1[DibWidth*j+i]=255;
  685. else 
  686. p_temp1[DibWidth*j+i]=0;
  687. }
  688. }
  689.         memcpy(p_data, p_temp1,DibWidth*height);   //复制处理后的图像
  690. delete  []p_temp1;
  691. delete  []p_temp2;
  692. }
  693. }