Category

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

Special Effects

Development Platform:

Visual C++

BianTiDib.cpp：Code Content
  1. #include "stdafx.h"
  2. #include "windowsx.h"
  3. #include "math.h"
  4. #include "BianTiDib.h"
  5. #include "MainFrm.h"
  6. #include "DynSplitView2.h"
  8.  
  9.  
  10. BianTiDib::BianTiDib()
  11. {
  12.  
  13. }
  14. BianTiDib::~BianTiDib()
  15. {
  16. }
  18.  
  20. ///***************************************************************/           
  21. /*函数名称：Xihua()                                       
  22. /*函数类型：void                                      
  23. /*功能：对图像进行细化处理。            
  24. /***************************************************************/
  25. void BianTiDib::Xihua()
  26. {
  27.    // 循环变量
  28. LONG i;
  29. LONG j;
  30. LONG m;
  31. LONG n;
  32. // 5×5相邻区域像素值
  33. unsigned char S[5][5];
  34. // 计数器
  35. unsigned char Num;
  36. // 循环跳出标志
  37. BOOL fp=TRUE;
  38. // 指向DIB象素指针
  39. LPBYTE  p_data;
  40. // 指向源图像的指针
  41. LPBYTE lpSrc;
  42. // 指向缓存图像的指针
  43. LPBYTE lpDst;
  44. // 指向缓存DIB图像的指针
  45. LPBYTE temp;
  46. // 找到DIB图像象素起始位置
  47. p_data = this->GetData ();  
  48.     if(m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  49. { 
  50. // DIB的宽度
  51. LONG wide = this->GetWidth ();
  52. // DIB的高度
  53. LONG height = this->GetHeight ();
  54. // 暂时分配内存，以保存新图像
  55. temp = new BYTE [wide *height];
  56. // 初始化新分配的内存，设定初始值为255
  57. lpDst = temp;
  58. memset(lpDst, (BYTE)255, wide  * height);
  59. while (fp)
  60. {
  61. fp = FALSE;
  62. // 初始化新分配的内存，设定初始值为255
  63. lpDst = temp;
  64. memset(lpDst, (BYTE)255, wide  * height);
  65. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  66. for (j = 2; j < height - 2; j++)
  67. {
  68. for (i = 2 ; i < wide  - 2 ; i ++)
  69. {
  70. // 指向源图像倒数第j行，第i个象素的指针
  71. lpSrc = (LPBYTE)(p_data + wide  *j + i);
  72. // 指向目标图像倒数第j行，第i个象素的指针
  73. lpDst = (LPBYTE)(temp + wide  * j + i);
  74. // 如果源图像中当前点为白色，则跳过
  75. if (*lpSrc > 127)
  76. continue;
  77. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  78. for (m = 0; m < 5; m++)
  79. {
  80. for (n = 0; n < 5; n++)
  81. {
  82. if (*(lpSrc + (2- m) * wide  + (n - 2)*2 ) > 127)
  83. S[m][n] = 0;
  84. else
  85. S[m][n] = 1;
  86. }
  87. }
  88. // 判断条件一是否成立：
  89. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  90. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  91. if (Num < 2 || Num >6)
  92. {
  93. *lpDst = 0;
  94. continue;
  95. }
  96. // 判断条件二是否成立：
  97. Num = 0;
  98. if (S[1][2] == 0 && S[1][1] == 1) 
  99. Num++;
  100. if (S[1][1] == 0 && S[2][1] == 1)
  101. Num++;
  102. if (S[2][1] == 0 && S[3][1] == 1)
  103. Num++;
  104. if (S[3][1] == 0 && S[3][2] == 1)
  105. Num++;
  106. if (S[3][2] == 0 && S[3][3] == 1)
  107. Num++;
  108. if (S[3][3] == 0 && S[2][3] == 1)
  109. Num++;
  110. if (S[2][3] == 0 && S[1][3] == 1)
  111. Num++;
  112. if (S[1][3] == 0 && S[1][2] == 1)
  113. Num++;
  114. if (Num != 1)
  115. {
  116. *lpDst = 0;
  117. continue;
  118. }
  119. // 判断条件三是否成立；
  120. if (S[1][2] * S[2][1] * S[2][3] != 0)
  121. {
  122. Num = 0;
  123. if (S[0][2] == 0 && S[0][1] == 1)
  124. Num++;
  125. if (S[0][1] == 0 && S[1][1] == 1)
  126. Num++;
  127. if (S[1][1] == 0 && S[2][1] == 1)
  128. Num++;
  129. if (S[2][1] == 0 && S[2][2] == 1)
  130. Num++;
  131. if (S[2][2] == 0 && S[2][3] == 1)
  132. Num++;
  133. if (S[2][3] == 0 && S[1][3] == 1)
  134. Num++;
  135. if (S[1][3] == 0 && S[0][3] == 1)
  136. Num++;
  137. if (S[0][3] == 0 && S[0][2] == 1)
  138. Num++;
  139. if (Num == 1)
  140. {
  141. *lpDst = 0;
  142. continue;
  143. }
  144. }
  145. // 判断条件四是否成立：
  146. if (S[1][2] * S[2][1] * S[3][2] != 0)
  147. {
  148. Num = 0;
  149. if (S[1][1] == 0 && S[1][0] == 1)
  150. Num++;
  151. if (S[1][0] == 0 && S[2][0] == 1)
  152. Num++;
  153. if (S[2][0] == 0 && S[3][0] == 1)
  154. Num++;
  155. if (S[3][0] == 0 && S[3][1] == 1)
  156. Num++;
  157. if (S[3][1] == 0 && S[3][2] == 1)
  158. Num++;
  159. if (S[3][2] == 0 && S[2][2] == 1)
  160. Num++;
  161. if (S[2][2] == 0 && S[1][2] == 1)
  162. Num++;
  163. if (S[1][2] == 0 && S[1][1] == 1)
  164. Num++;
  165. if (Num == 1)
  166. {
  167. *lpDst = 0;
  168. continue;
  169. }
  170. }
  171. // 如果条件均满足则删除该点
  172. *lpDst = 255;
  173. fp = TRUE;
  174. }
  175. }
  176. // 复制细化后的图像
  177. memcpy(p_data, temp, wide  * height);
  178. }
  179.  // 复制细化后的图像
  180. memcpy(p_data, temp, wide  * height);
  181. // 释放内存
  182. delete temp ;
  183. }
  184. else//24位真彩色
  185. {
  186. // DIB的宽度
  187. LONG wide = this->GetDibWidthBytes();
  188. // DIB的高度
  189. LONG height = this->GetHeight ();
  190. // 暂时分配内存，以保存新图像
  191. temp = new BYTE [wide *height];
  192. // 初始化新分配的内存，设定初始值为255
  193. lpDst = temp;
  194. memset(lpDst, (BYTE)255, wide  * height);
  195. while (fp)
  196. {
  197. fp = FALSE;
  198. // 初始化新分配的内存，设定初始值为255
  199. lpDst = temp;
  200. memset(lpDst, (BYTE)255, wide  * height);
  201. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  202. for (j = 2; j < height - 2; j++)
  203. {
  204. for (i = 2 *3; i < wide  - 2 *3; i=i +3)
  205. {
  206. // 指向源图像倒数第j行，第i个象素的指针
  207. lpSrc = (LPBYTE)(p_data + wide  *j + i);
  208. // 指向目标图像倒数第j行，第i个象素的指针
  209. lpDst = (LPBYTE)(temp + wide  * j + i);
  210. // 如果源图像中当前点为白色，则跳过
  211. if (*lpSrc > 245)
  212. continue;
  213. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  214. for (m = 0; m < 5; m++)
  215. {
  216. for (n = 0; n < 5; n++)
  217. {
  218. if (*(lpSrc + (2- m) * wide  + (n - 2)*3 ) > 245)
  219. S[m][n] = 0;
  220. else
  221. S[m][n] = 1;
  222. }
  223. }
  224. // 判断条件一是否成立：
  225. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  226. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  227. if (Num < 2 || Num >6)
  228. {
  229. *lpDst = 0;
  230. *(lpDst+1) = 0;
  231. *(lpDst+2) = 0;
  232. continue;
  233. }
  234. // 判断条件二是否成立：
  235. Num = 0;
  236. if (S[1][2] == 0 && S[1][1] == 1) 
  237. Num++;
  238. if (S[1][1] == 0 && S[2][1] == 1)
  239. Num++;
  240. if (S[2][1] == 0 && S[3][1] == 1)
  241. Num++;
  242. if (S[3][1] == 0 && S[3][2] == 1)
  243. Num++;
  244. if (S[3][2] == 0 && S[3][3] == 1)
  245. Num++;
  246. if (S[3][3] == 0 && S[2][3] == 1)
  247. Num++;
  248. if (S[2][3] == 0 && S[1][3] == 1)
  249. Num++;
  250. if (S[1][3] == 0 && S[1][2] == 1)
  251. Num++;
  252. if (Num != 1)
  253. {
  254. *lpDst = 0;
  255. *(lpDst+1) = 0;
  256. *(lpDst+2) = 0;
  257. continue;
  258. }
  259. // 判断条件三是否成立；
  260. if (S[1][2] * S[2][1] * S[2][3] != 0)
  261. {
  262. Num = 0;
  263. if (S[0][2] == 0 && S[0][1] == 1)
  264. Num++;
  265. if (S[0][1] == 0 && S[1][1] == 1)
  266. Num++;
  267. if (S[1][1] == 0 && S[2][1] == 1)
  268. Num++;
  269. if (S[2][1] == 0 && S[2][2] == 1)
  270. Num++;
  271. if (S[2][2] == 0 && S[2][3] == 1)
  272. Num++;
  273. if (S[2][3] == 0 && S[1][3] == 1)
  274. Num++;
  275. if (S[1][3] == 0 && S[0][3] == 1)
  276. Num++;
  277. if (S[0][3] == 0 && S[0][2] == 1)
  278. Num++;
  279. if (Num == 1)
  280. {
  281. *lpDst = 0;
  282. *(lpDst+1) = 0;
  283. *(lpDst+2) = 0;
  284. continue;
  285. }
  286. }
  287. // 判断条件四是否成立：
  288. if (S[1][2] * S[2][1] * S[3][2] != 0)
  289. {
  290. Num = 0;
  291. if (S[1][1] == 0 && S[1][0] == 1)
  292. Num++;
  293. if (S[1][0] == 0 && S[2][0] == 1)
  294. Num++;
  295. if (S[2][0] == 0 && S[3][0] == 1)
  296. Num++;
  297. if (S[3][0] == 0 && S[3][1] == 1)
  298. Num++;
  299. if (S[3][1] == 0 && S[3][2] == 1)
  300. Num++;
  301. if (S[3][2] == 0 && S[2][2] == 1)
  302. Num++;
  303. if (S[2][2] == 0 && S[1][2] == 1)
  304. Num++;
  305. if (S[1][2] == 0 && S[1][1] == 1)
  306. Num++;
  307. if (Num == 1)
  308. {
  309. *lpDst = 0;
  310. *(lpDst+1) = 0;
  311. *(lpDst+2) = 0;
  312. continue;
  313. }
  314. }
  315. // 如果条件均满足则删除该点
  316. *lpDst = 255;
  317. *(lpDst+1) = 255;
  318. *(lpDst+2) = 255;  
  319. fp = TRUE;
  320. }
  321. }
  322. // 复制细化后的图像
  323. memcpy(p_data, temp, wide  * height);
  324. }
  325. // 复制细化后的图像
  326. memcpy(p_data, temp, wide  * height);
  327. // 释放内存
  328. delete temp ;
  329. }
  330. }
  334. ///***************************************************************/           
  335. /*函数名称：Cuhua()                                       
  336. /*函数类型：void                                      
  337. /*功能：对图像进行粗化处理。            
  338. /***************************************************************/
  339. void BianTiDib::Cuhua()
  340. {
  341. // 循环变量
  342. LONG i;
  343. LONG j;
  344. // 指向DIB象素指针
  345. LPBYTE p_data;
  346. // 找到DIB图像象素起始位置
  347. p_data = this->GetData();
  348. if(m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  349. {
  350. // DIB的宽度
  351. LONG wide = GetWidth();
  352. // DIB的高度
  353. LONG height = GetHeight();
  354. // 对各像素进行灰度转换
  355. for (j = 0; j < height; j ++)
  356. {
  357. for (i = 0; i < wide; i ++)
  358. {
  359. // 对像素各颜色分量进行二值化求补处理
  360. unsigned char temp = *((unsigned char *)p_data + wide * j +i);
  361. if (temp > 127)
  362. *((unsigned char *)p_data + wide * j + i) = 0;
  363. else
  364. *((unsigned char *)p_data + wide * j + i) = 255;
  365. }
  366. }
  367. // 在求补后再对图象进行细化
  368. Xihua(); 
  369. }
  370. else//24位真彩色
  371. {
  372. // DIB的宽度
  373. LONG wide = GetDibWidthBytes();
  374. // DIB的高度
  375. LONG height = GetHeight();
  376. // 对各像素进行灰度转换
  377. for (j = 0; j < height; j ++)
  378. {
  379. for (i = 0; i < wide; i ++)
  380. {
  381. // 对像素各颜色分量进行二值化求补处理
  382. unsigned char temp = *((unsigned char *)p_data + wide * j +i);
  383. if (temp > 127)
  384. *((unsigned char *)p_data + wide * j + i) = 0;
  385. else
  386. *((unsigned char *)p_data + wide * j + i) = 255;    
  387. }
  388. }
  389. // 在求补后再对图象进行细化
  390. Xihua(); 
  391. }
  392. }
  396. ///***************************************************************/           
  397. /*函数名称：Zhongzhoubianhuan()                                       
  398. /*函数类型：void                                      
  399. /*功能：对图像进行中轴变换。            
  400. /***************************************************************/
  401. void BianTiDib::Zhongzhoubianhuan()
  402. {
  403. // 循环变量 
  404. LONG i;
  405. LONG j;
  406. LONG m;
  407. LONG n;
  408. // 5×5相邻区域像素值
  409. unsigned char S[5][5];
  410. // 计数器
  411. unsigned char Num;
  412. // 循环跳出标志 
  413. BOOL fp=TRUE;
  414. // 指向DIB象素指针
  415. LPBYTE p_data;
  416. // 指向源图像的指针
  417. LPBYTE lpSrc;
  418. // 指向缓存图像的指针
  419. LPBYTE lpDst;
  420. // 指向缓存DIB图像的指针
  421. LPBYTE temp;
  422. // 找到DIB图像象素起始位置
  423. p_data = GetData();
  424. if(m_pBitmapInfoHeader->biBitCount<9)//灰度图像
  425. {
  426. // DIB的宽度
  427. LONG wide = GetWidth();
  428. // DIB的高度 
  429. LONG height = GetHeight();
  430. // 暂时分配内存，以保存新图像
  431. temp =  new BYTE [wide*height];
  432. // 初始化新分配的内存，设定初始值为255
  433. lpDst = (LPBYTE)temp;
  434. memset(lpDst, (BYTE)255, wide * height);
  435. while (fp)
  436. {
  437. fp = FALSE;
  438. // 初始化新分配的内存，设定初始值为255
  439. lpDst = (LPBYTE)temp;
  440. memset(lpDst, (BYTE)255, wide * height);
  441. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  442. for (j= 2; j < height - 2; j++)
  443. {
  444. for (i = 2  ; i < wide - 2  ; i ++)
  445. {
  446. // 指向源图像倒数第j行，第i个象素的指针
  447. lpSrc = (LPBYTE)(p_data + wide * j + i);
  448. // 指向目标图像倒数第j行，第i个象素的指针
  449. lpDst = (LPBYTE)(temp + wide * j + i);
  450. // 如果源图像中当前点为白色，则跳过
  451. if (*lpSrc > 127)
  452. continue;
  453. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  454. for (m = 0; m < 5; m++)
  455. {
  456. for (n = 0; n < 5; n++)
  457. {
  458. if (*(lpSrc + (2 - m) * wide + (n - 2)  ) > 127)
  459. S[m][n] = 0;
  460. else
  461. S[m][n] = 1;
  462. }
  463. }
  464. // 判断条件1-1是否成立：
  465. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  466. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  467. if (Num < 2 || Num >6)
  468. {
  469. *lpDst = 0;  
  470. continue;
  471. }
  472. // 判断条件1-2是否成立：
  473. Num = 0;
  474. if (S[1][2] == 0 && S[1][1] == 1) 
  475. Num++;
  476. if (S[1][1] == 0 && S[2][1] == 1)
  477. Num++;
  478. if (S[2][1] == 0 && S[3][1] == 1)
  479. Num++;
  480. if (S[3][1] == 0 && S[3][2] == 1)
  481. Num++;
  482. if (S[3][2] == 0 && S[3][3] == 1)
  483. Num++;
  484. if (S[3][3] == 0 && S[2][3] == 1)
  485. Num++;
  486. if (S[2][3] == 0 && S[1][3] == 1)
  487. Num++;
  488. if (S[1][3] == 0 && S[1][2] == 1)
  489. Num++;
  490. if (Num != 1)
  491. {
  492. *lpDst = 0;  
  493. continue;
  494. }
  495. // 判断条件1-3是否成立；
  496. if (S[1][2] * S[2][1] * S[3][2] != 0)
  497. {
  498. *lpDst = 0;  
  499. continue;
  500. }
  501. // 判断条件1-4是否成立：
  502. if (S[2][1] * S[3][2] * S[2][3] != 0)
  503. {
  504. *lpDst = 0;  
  505. continue;
  506. }
  507. // 如果条件均满足则删除该点
  508. *lpDst = 255;  
  509. }
  510. }
  511. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  512. for (j = 2; j < height - 2; j++)
  513. {
  514. for (i = 2  ; i < wide - 2  ; i ++)
  515. {
  516. // 指向源图像倒数第j行，第i个象素的指针
  517. lpSrc = (LPBYTE)(p_data + wide * j + i);
  518. // 指向目标图像倒数第j行，第i个象素的指针
  519. lpDst = (LPBYTE)(temp + wide *j + i);
  520. // 如果源图像中当前点为白色，则跳过
  521. if (*lpSrc > 127)
  522. continue;
  523. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  524. for (m = 0; m < 5; m++)
  525. {
  526. for (n = 0; n < 5; n++)
  527. {
  528. if (*(lpSrc + (2 - m) * wide + (n - 2)  ) > 200)
  529. S[m][n] = 0;
  530. else
  531. S[m][n] = 1;
  532. }
  533. }
  534. // 判断条件2-1是否成立：
  535. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  536. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  537. if (Num < 2 || Num >6)
  538. {
  539. *lpDst = 0;  
  540. continue;
  541. }
  542. // 判断条件2-2是否成立：
  543. Num = 0;
  544. if (S[1][2] == 0 && S[1][1] == 1) 
  545. Num++;
  546. if (S[1][1] == 0 && S[2][1] == 1)
  547. Num++;
  548. if (S[2][1] == 0 && S[3][1] == 1)
  549. Num++;
  550. if (S[3][1] == 0 && S[3][2] == 1)
  551. Num++;
  552. if (S[3][2] == 0 && S[3][3] == 1)
  553. Num++;
  554. if (S[3][3] == 0 && S[2][3] == 1)
  555. Num++;
  556. if (S[2][3] == 0 && S[1][3] == 1)
  557. Num++;
  558. if (S[1][3] == 0 && S[1][2] == 1)
  559. Num++;
  560. if (Num != 1)
  561. {
  562. *lpDst = 0;  
  563. continue;
  564. }
  565. // 判断条件2-3是否成立；
  566. if (S[1][2] * S[2][1] * S[2][3] != 0)
  567. {
  568. *lpDst = 0;  
  569. continue;
  570. }
  571. // 判断条件2-4是否成立：
  572. if (S[1][2] * S[3][2] * S[2][3] != 0)
  573. {
  574. *lpDst = 0;  
  575. continue;
  576. }
  577. // 如果条件均满足则删除该点
  578. *lpDst = 255;  
  579. fp = TRUE;
  580. }
  581. }
  582. // 复制变换后的图像
  583. memcpy(p_data, temp, wide * height);
  584. }
  585. // 复制变换后的图像
  586. memcpy(p_data, temp, wide * height);
  587. //  释放内存
  588. delete temp; 
  589. }
  590. else//24位真彩色
  591. {
  592. // DIB的宽度
  593. LONG wide = GetDibWidthBytes();
  594. // DIB的高度 
  595. LONG height = GetHeight();
  596. // 暂时分配内存，以保存新图像
  597. temp =  new BYTE [wide*height];
  598. // 初始化新分配的内存，设定初始值为255
  599. lpDst = (LPBYTE)temp;
  600. memset(lpDst, (BYTE)255, wide * height);
  601. while (fp)
  602. {
  603. fp = FALSE;
  604. // 初始化新分配的内存，设定初始值为255
  605. lpDst = (LPBYTE)temp;
  606. memset(lpDst, (BYTE)255, wide * height);
  607. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  608. for (j= 2; j < height - 2; j++)
  609. {
  610. for (i = 2*3  ; i < wide - 2 *3 ; i =i+3)
  611. {
  612. // 指向源图像倒数第j行，第i个象素的指针
  613. lpSrc = (LPBYTE)(p_data + wide * j + i);
  614. // 指向目标图像倒数第j行，第i个象素的指针
  615. lpDst = (LPBYTE)(temp + wide * j + i);
  616. // 如果源图像中当前点为白色，则跳过
  617. if (*lpSrc > 127)
  618. continue;
  619. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  620. for (m = 0; m < 5; m++)
  621. {
  622. for (n = 0; n < 5; n++)
  623. {
  624. if (*(lpSrc + (2 - m) * wide + (n - 2) *3 ) > 200)
  625. S[m][n] = 0;
  626. else
  627. S[m][n] = 1;
  628. }
  629. }
  630. // 判断条件1-1是否成立：
  631. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  632. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  633. if (Num < 2 || Num >6)
  634. {
  635. *lpDst = 0;
  636. *(lpDst+1) = 0;
  637. *(lpDst+2) = 0;
  638. continue;
  639. }
  640. // 判断条件1-2是否成立：
  641. Num = 0;
  642. if (S[1][2] == 0 && S[1][1] == 1) 
  643. Num++;
  644. if (S[1][1] == 0 && S[2][1] == 1)
  645. Num++;
  646. if (S[2][1] == 0 && S[3][1] == 1)
  647. Num++;
  648. if (S[3][1] == 0 && S[3][2] == 1)
  649. Num++;
  650. if (S[3][2] == 0 && S[3][3] == 1)
  651. Num++;
  652. if (S[3][3] == 0 && S[2][3] == 1)
  653. Num++;
  654. if (S[2][3] == 0 && S[1][3] == 1)
  655. Num++;
  656. if (S[1][3] == 0 && S[1][2] == 1)
  657. Num++;
  658. if (Num != 1)
  659. {
  660. *lpDst = 0;
  661. *(lpDst+1) = 0;
  662. *(lpDst+2) = 0;
  663. continue;
  664. }
  665. // 判断条件1-3是否成立；
  666. if (S[1][2] * S[2][1] * S[3][2] != 0)
  667. {
  668. *lpDst = 0;
  669. *(lpDst+1) = 0;
  670. *(lpDst+2) = 0;
  671. continue;
  672. }
  673. // 判断条件1-4是否成立：
  674. if (S[2][1] * S[3][2] * S[2][3] != 0)
  675. {
  676. *lpDst = 0;
  677. *(lpDst+1) = 0;
  678. *(lpDst+2) = 0;
  679. continue;
  680. }
  681. // 如果条件均满足则删除该点
  682. *lpDst = 255;
  683. *(lpDst+1) = 255;
  684. *(lpDst+2) = 255;
  685. }
  686. }
  687. // 由于使用5×5的结构元素，为防越界，不处理外围的2行、2列像素
  688. for (j = 2; j < height - 2; j++)
  689. {
  690. for (i = 2*3  ; i < wide - 2*3  ; i=i +3)
  691. {
  692. // 指向源图像倒数第j行，第i个象素的指针
  693. lpSrc = (LPBYTE)(p_data + wide * j + i);
  694. // 指向目标图像倒数第j行，第i个象素的指针
  695. lpDst = (LPBYTE)(temp + wide *j + i);
  696. // 如果源图像中当前点为白色，则跳过
  697. if (*lpSrc > 127)
  698. continue;
  699. // 获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  700. for (m = 0; m < 5; m++)
  701. {
  702. for (n = 0; n < 5; n++)
  703. {
  704. if (*(lpSrc + (2 - m) * wide + (n - 2)*3  ) > 200)
  705. S[m][n] = 0;
  706. else
  707. S[m][n] = 1;
  708. }
  709. }
  710. // 判断条件2-1是否成立：
  711. Num =  S[1][1] + S[1][2] + S[1][3] + S[2][1] 
  712. + S[2][3] + S[3][1] + S[3][2] + S[3][3];
  713. if (Num < 2 || Num >6)
  714. {
  715. *lpDst = 0;
  716. *(lpDst+1) = 0;
  717. *(lpDst+2) = 0;
  718. continue;
  719. }
  720. // 判断条件2-2是否成立：
  721. Num = 0;
  722. if (S[1][2] == 0 && S[1][1] == 1) 
  723. Num++;
  724. if (S[1][1] == 0 && S[2][1] == 1)
  725. Num++;
  726. if (S[2][1] == 0 && S[3][1] == 1)
  727. Num++;
  728. if (S[3][1] == 0 && S[3][2] == 1)
  729. Num++;
  730. if (S[3][2] == 0 && S[3][3] == 1)
  731. Num++;
  732. if (S[3][3] == 0 && S[2][3] == 1)
  733. Num++;
  734. if (S[2][3] == 0 && S[1][3] == 1)
  735. Num++;
  736. if (S[1][3] == 0 && S[1][2] == 1)
  737. Num++;
  738. if (Num != 1)
  739. {
  740. *lpDst = 0;
  741. *(lpDst+1) = 0;
  742. *(lpDst+2) = 0;
  743. continue;
  744. }
  745. // 判断条件2-3是否成立；
  746. if (S[1][2] * S[2][1] * S[2][3] != 0)
  747. {
  748. *lpDst = 0;
  749. *(lpDst+1) = 0;
  750. *(lpDst+2) = 0;
  751. continue;
  752. }
  753. // 判断条件2-4是否成立：
  754. if (S[1][2] * S[3][2] * S[2][3] != 0)
  755. {
  756. *lpDst = 0;
  757. *(lpDst+1) = 0;
  758. *(lpDst+2) = 0;
  759. continue;
  760. }
  761. // 如果条件均满足则删除该点
  762. *lpDst = 255;
  763. *(lpDst+1) = 255;
  764. *(lpDst+2) = 255;
  765. fp = TRUE;
  766. }
  767. }
  768. // 复制变换后的图像
  769. memcpy(p_data, temp, wide * height);
  770. }
  771. // 复制变换后的图像
  772. memcpy(p_data, temp, wide * height);
  773. //  释放内存
  774. delete temp; 
  775. }
  776. }
  777.