开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 查看源码
morph.cpp
资源名称：VisualC++.rar　[点击查看]
上传用户：gdjinyi
上传日期：2013-02-01
资源大小：1701k
文件大小：23k
源码类别：

源码/资料

开发平台：

Visual C++

morph.cpp：源码内容
  1. // ************************************************************************
  2. //  文件名：morph.cpp
  3. //
  4. //  图像形态学变换API函数库：
  5. //
  6. //  ErosionDIB()    - 图像腐蚀
  7. //  DilationDIB() - 图像膨胀
  8. //  OpenDIB() - 图像开运算
  9. //  CloseDIB() - 图像闭运算
  10. //  ThiningDIB() - 图像细化
  11. //
  12. // ************************************************************************
  15. #include "stdafx.h"
  16. #include "morph.h"
  17. #include "DIBAPI.h"
  19. #include <math.h>
  20. #include <direct.h>
  22. /*************************************************************************
  23.  *
  24.  * 函数名称：
  25.  *   ErosiontionDIB()
  26.  *
  27.  * 参数:
  28.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  29.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  30.  *   LONG  lHeight      - 源图像高度（象素数）
  31.  *   int   nMode - 腐蚀方式，0表示水平方向，1表示垂直方向，2表示自定义结构元素。
  32.  *  int   structure[3][3]
  33. - 自定义的3×3结构元素。
  34.  *
  35.  * 返回值:
  36.  *   BOOL               - 腐蚀成功返回TRUE，否则返回FALSE。
  37.  *
  38.  * 说明:
  39.  * 该函数用于对图像进行腐蚀运算。结构元素为水平方向或垂直方向的三个点，中间点位于原点；
  40.  * 或者由用户自己定义3×3的结构元素。
  41.  * 
  42.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  43.  ************************************************************************/
  45. BOOL WINAPI ErosionDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, int nMode , int structure[3][3])
  46. {
  48. // 指向源图像的指针
  49. LPSTR lpSrc;
  51. // 指向缓存图像的指针
  52. LPSTR lpDst;
  54. // 指向缓存DIB图像的指针
  55. LPSTR lpNewDIBBits;
  56. HLOCAL hNewDIBBits;
  58. //循环变量
  59. long i;
  60. long j;
  61. int  n;
  62. int  m;
  64. //像素值
  65. unsigned char pixel;
  67. // 暂时分配内存，以保存新图像
  68. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  70. if (hNewDIBBits == NULL)
  71. {
  72. // 分配内存失败
  73. return FALSE;
  74. }
  76. // 锁定内存
  77. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  79. // 初始化新分配的内存，设定初始值为255
  80. lpDst = (char *)lpNewDIBBits;
  81. memset(lpDst, (BYTE)255, lWidth * lHeight);
  84. if(nMode == 0)
  85. {
  86. //使用水平方向的结构元素进行腐蚀
  87. for(j = 0; j <lHeight; j++)
  88. {
  89. for(i = 1;i <lWidth-1; i++)
  90. {
  91. //由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  93. // 指向源图像倒数第j行，第i个象素的指针
  94. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  96. // 指向目标图像倒数第j行，第i个象素的指针
  97. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  99. //取得当前指针处的像素值，注意要转换为unsigned char型
  100. pixel = (unsigned char)*lpSrc;
  102. //目标图像中含有0和255外的其它灰度值
  103. if(pixel != 255 && *lpSrc != 0)
  104. return FALSE;
  106. //目标图像中的当前点先赋成黑色
  107. *lpDst = (unsigned char)0;
  109. //如果源图像中当前点自身或者左右有一个点不是黑色，
  110. //则将目标图像中的当前点赋成白色
  111. for (n = 0;n < 3;n++ )
  112. {
  113. pixel = *(lpSrc+n-1);
  114. if (pixel == 255 )
  115. {
  116. *lpDst = (unsigned char)255;
  117. break;
  118. }
  119. }
  121. }
  122. }
  124. }
  125. else if(nMode == 1)
  126. {
  127. //使用垂直方向的结构元素进行腐蚀
  128. for(j = 1; j <lHeight-1; j++)
  129. {
  130. for(i = 0;i <lWidth; i++)
  131. {
  132. //由于使用1×3的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
  134. // 指向源图像倒数第j行，第i个象素的指针
  135. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  137. // 指向目标图像倒数第j行，第i个象素的指针
  138. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  140. //取得当前指针处的像素值，注意要转换为unsigned char型
  141. pixel = (unsigned char)*lpSrc;
  143. //目标图像中含有0和255外的其它灰度值
  144. if(pixel != 255 && *lpSrc != 0)
  145. return FALSE;
  147. //目标图像中的当前点先赋成黑色
  148. *lpDst = (unsigned char)0;
  150. //如果源图像中当前点自身或者上下有一个点不是黑色，
  151. //则将目标图像中的当前点赋成白色
  152. for (n = 0;n < 3;n++ )
  153. {
  154. pixel = *(lpSrc+(n-1)*lWidth);
  155. if (pixel == 255 )
  156. {
  157. *lpDst = (unsigned char)255;
  158. break;
  159. }
  160. }
  162. }
  163. }
  165. }
  166. else
  167. {
  168. //使用自定义的结构元素进行腐蚀
  169. for(j = 1; j <lHeight-1; j++)
  170. {
  171. for(i = 0;i <lWidth; i++)
  172. {
  173. //由于使用3×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  174. //和最上边和最下边的两列像素
  175. // 指向源图像倒数第j行，第i个象素的指针
  176. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  178. // 指向目标图像倒数第j行，第i个象素的指针
  179. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  181. //取得当前指针处的像素值，注意要转换为unsigned char型
  182. pixel = (unsigned char)*lpSrc;
  184. //目标图像中含有0和255外的其它灰度值
  185. if(pixel != 255 && *lpSrc != 0)
  186. return FALSE;
  188. //目标图像中的当前点先赋成黑色
  189. *lpDst = (unsigned char)0;
  191. //如果原图像中对应结构元素中为黑色的那些点中有一个不是黑色，
  192. //则将目标图像中的当前点赋成白色
  193. //注意在DIB图像中内容是上下倒置的
  194. for (m = 0;m < 3;m++ )
  195. {
  196. for (n = 0;n < 3;n++)
  197. {
  198. if( structure[m][n] == -1)
  199. continue;
  200. pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1));
  201. if (pixel == 255 )
  202. {
  203. *lpDst = (unsigned char)255;
  204. break;
  205. }
  206. }
  207. }
  209. }
  210. }
  212. }
  213. // 复制腐蚀后的图像
  214. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  216. // 释放内存
  217. LocalUnlock(hNewDIBBits);
  218. LocalFree(hNewDIBBits);
  220. // 返回
  221. return TRUE;
  222. }
  227. /*************************************************************************
  228.  *
  229.  * 函数名称：
  230.  *   DilationDIB()
  231.  *
  232.  * 参数:
  233.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  234.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  235.  *   LONG  lHeight      - 源图像高度（象素数）
  236.  *   int   nMode - 膨胀方式，0表示水平方向，1表示垂直方向，2表示自定义结构元素。
  237.  *  int   structure[3][3]
  238. - 自定义的3×3结构元素。
  239.  *
  240.  * 返回值:
  241.  *   BOOL               - 膨胀成功返回TRUE，否则返回FALSE。
  242.  *
  243.  * 说明:
  244.  * 该函数用于对图像进行膨胀运算。结构元素为水平方向或垂直方向的三个点，中间点位于原点；
  245.  * 或者由用户自己定义3×3的结构元素。
  246.  * 
  247.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  248.  ************************************************************************/
  251. BOOL WINAPI DilationDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, int nMode , int structure[3][3])
  252. {
  254. // 指向源图像的指针
  255. LPSTR lpSrc;
  257. // 指向缓存图像的指针
  258. LPSTR lpDst;
  260. // 指向缓存DIB图像的指针
  261. LPSTR lpNewDIBBits;
  262. HLOCAL hNewDIBBits;
  264. //循环变量
  265. long i;
  266. long j;
  267. int  n;
  268. int  m;
  270. //像素值
  271. unsigned char pixel;
  273. // 暂时分配内存，以保存新图像
  274. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  276. if (hNewDIBBits == NULL)
  277. {
  278. // 分配内存失败
  279. return FALSE;
  280. }
  282. // 锁定内存
  283. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  285. // 初始化新分配的内存，设定初始值为255
  286. lpDst = (char *)lpNewDIBBits;
  287. memset(lpDst, (BYTE)255, lWidth * lHeight);
  290. if(nMode == 0)
  291. {
  292. //使用水平方向的结构元素进行膨胀
  293. for(j = 0; j <lHeight; j++)
  294. {
  295. for(i = 1;i <lWidth-1; i++)
  296. {
  297. //由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  299. // 指向源图像倒数第j行，第i个象素的指针
  300. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  302. // 指向目标图像倒数第j行，第i个象素的指针
  303. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  305. //取得当前指针处的像素值，注意要转换为unsigned char型
  306. pixel = (unsigned char)*lpSrc;
  308. //目标图像中含有0和255外的其它灰度值
  309. if(pixel != 255 && pixel != 0)
  310. return FALSE;
  312. //目标图像中的当前点先赋成白色
  313. *lpDst = (unsigned char)255;
  315. //源图像中当前点自身或者左右只要有一个点是黑色，
  316. //则将目标图像中的当前点赋成黑色
  317. for (n = 0;n < 3;n++ )
  318. {
  319. pixel = *(lpSrc+n-1);
  320. if (pixel == 0 )
  321. {
  322. *lpDst = (unsigned char)0;
  323. break;
  324. }
  325. }
  327. }
  328. }
  330. }
  331. else if(nMode == 1)
  332. {
  333. //使用垂直方向的结构元素进行膨胀
  334. for(j = 1; j <lHeight-1; j++)
  335. {
  336. for(i = 0;i <lWidth; i++)
  337. {
  338. //由于使用1×3的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
  340. // 指向源图像倒数第j行，第i个象素的指针
  341. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  343. // 指向目标图像倒数第j行，第i个象素的指针
  344. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  346. //取得当前指针处的像素值，注意要转换为unsigned char型
  347. pixel = (unsigned char)*lpSrc;
  349. //目标图像中含有0和255外的其它灰度值
  350. if(pixel != 255 && *lpSrc != 0)
  351. return FALSE;
  353. //目标图像中的当前点先赋成白色
  354. *lpDst = (unsigned char)255;
  356. //源图像中当前点自身或者上下只要有一个点是黑色，
  357. //则将目标图像中的当前点赋成黑色
  358. for (n = 0;n < 3;n++ )
  359. {
  360. pixel = *(lpSrc+(n-1)*lWidth);
  361. if (pixel == 0 )
  362. {
  363. *lpDst = (unsigned char)0;
  364. break;
  365. }
  366. }
  368. }
  369. }
  371. }
  372. else
  373. {
  374. //使用自定义的结构元素进行膨胀
  375. for(j = 1; j <lHeight-1; j++)
  376. {
  377. for(i = 0;i <lWidth; i++)
  378. {
  379. //由于使用3×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  380. //和最上边和最下边的两列像素
  381. // 指向源图像倒数第j行，第i个象素的指针
  382. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  384. // 指向目标图像倒数第j行，第i个象素的指针
  385. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  387. //取得当前指针处的像素值，注意要转换为unsigned char型
  388. pixel = (unsigned char)*lpSrc;
  390. //目标图像中含有0和255外的其它灰度值
  391. if(pixel != 255 && *lpSrc != 0)
  392. return FALSE;
  394. //目标图像中的当前点先赋成白色
  395. *lpDst = (unsigned char)255;
  397. //原图像中对应结构元素中为黑色的那些点中只要有一个是黑色，
  398. //则将目标图像中的当前点赋成黑色
  399. //注意在DIB图像中内容是上下倒置的
  400. for (m = 0;m < 3;m++ )
  401. {
  402. for (n = 0;n < 3;n++)
  403. {
  404. if( structure[m][n] == -1)
  405. continue;
  406. pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1));
  407. if (pixel == 0 )
  408. {
  409. *lpDst = (unsigned char)0;
  410. break;
  411. }
  412. }
  413. }
  415. }
  416. }
  418. }
  419. // 复制膨胀后的图像
  420. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  422. // 释放内存
  423. LocalUnlock(hNewDIBBits);
  424. LocalFree(hNewDIBBits);
  426. // 返回
  427. return TRUE;
  428. }
  434. /*************************************************************************
  435.  *
  436.  * 函数名称：
  437.  *   OpenDIB()
  438.  *
  439.  * 参数:
  440.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  441.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  442.  *   LONG  lHeight      - 源图像高度（象素数）
  443.  *   int   nMode - 开运算方式，0表示水平方向，1表示垂直方向，2表示自定义结构元素。
  444.  *  int   structure[3][3]
  445. - 自定义的3×3结构元素。
  446.  *
  447.  * 返回值:
  448.  *   BOOL               - 开运算成功返回TRUE，否则返回FALSE。
  449.  *
  450.  * 说明:
  451.  * 该函数用于对图像进行开运算。结构元素为水平方向或垂直方向的三个点，中间点位于原点；
  452.  * 或者由用户自己定义3×3的结构元素。
  453.  * 
  454.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  455.  ************************************************************************/
  457. BOOL WINAPI OpenDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, int nMode , int structure[3][3])
  458. {
  460. // 指向源图像的指针
  461. LPSTR lpSrc;
  463. // 指向缓存图像的指针
  464. LPSTR lpDst;
  466. // 指向缓存DIB图像的指针
  467. LPSTR lpNewDIBBits;
  468. HLOCAL hNewDIBBits;
  470. //循环变量
  471. long i;
  472. long j;
  473. int  n;
  474. int  m;
  476. //像素值
  477. unsigned char pixel;
  479. // 暂时分配内存，以保存新图像
  480. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  482. if (hNewDIBBits == NULL)
  483. {
  484. // 分配内存失败
  485. return FALSE;
  486. }
  488. // 锁定内存
  489. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  491. // 初始化新分配的内存，设定初始值为255
  492. lpDst = (char *)lpNewDIBBits;
  493. memset(lpDst, (BYTE)255, lWidth * lHeight);
  496. if(nMode == 0)
  497. {
  498. //使用水平方向的结构元素进行腐蚀
  499. for(j = 0; j <lHeight; j++)
  500. {
  501. for(i = 1;i <lWidth-1; i++)
  502. {
  503. //由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  505. // 指向源图像倒数第j行，第i个象素的指针
  506. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  508. // 指向目标图像倒数第j行，第i个象素的指针
  509. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  511. //取得当前指针处的像素值，注意要转换为unsigned char型
  512. pixel = (unsigned char)*lpSrc;
  514. //目标图像中含有0和255外的其它灰度值
  515. if(pixel != 255 && *lpSrc != 0)
  516. return FALSE;
  518. //目标图像中的当前点先赋成黑色
  519. *lpDst = (unsigned char)0;
  521. //如果源图像中当前点自身或者左右有一个点不是黑色，
  522. //则将目标图像中的当前点赋成白色
  523. for (n = 0;n < 3;n++ )
  524. {
  525. pixel = *(lpSrc+n-1);
  526. if (pixel == 255 )
  527. {
  528. *lpDst = (unsigned char)255;
  529. break;
  530. }
  531. }
  533. }
  534. }
  536. }
  537. else if(nMode == 1)
  538. {
  539. //使用垂直方向的结构元素进行腐蚀
  540. for(j = 1; j <lHeight-1; j++)
  541. {
  542. for(i = 0;i <lWidth; i++)
  543. {
  544. //由于使用1×3的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
  546. // 指向源图像倒数第j行，第i个象素的指针
  547. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  549. // 指向目标图像倒数第j行，第i个象素的指针
  550. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  552. //取得当前指针处的像素值，注意要转换为unsigned char型
  553. pixel = (unsigned char)*lpSrc;
  555. //目标图像中含有0和255外的其它灰度值
  556. if(pixel != 255 && *lpSrc != 0)
  557. return FALSE;
  559. //目标图像中的当前点先赋成黑色
  560. *lpDst = (unsigned char)0;
  562. //如果源图像中当前点自身或者上下有一个点不是黑色，
  563. //则将目标图像中的当前点赋成白色
  564. for (n = 0;n < 3;n++ )
  565. {
  566. pixel = *(lpSrc+(n-1)*lWidth);
  567. if (pixel == 255 )
  568. {
  569. *lpDst = (unsigned char)255;
  570. break;
  571. }
  572. }
  574. }
  575. }
  577. }
  578. else
  579. {
  580. //使用自定义的结构元素进行腐蚀
  581. for(j = 1; j <lHeight-1; j++)
  582. {
  583. for(i = 0;i <lWidth; i++)
  584. {
  585. //由于使用3×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  586. //和最上边和最下边的两列像素
  587. // 指向源图像倒数第j行，第i个象素的指针
  588. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  590. // 指向目标图像倒数第j行，第i个象素的指针
  591. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  593. //取得当前指针处的像素值，注意要转换为unsigned char型
  594. pixel = (unsigned char)*lpSrc;
  596. //目标图像中含有0和255外的其它灰度值
  597. if(pixel != 255 && *lpSrc != 0)
  598. return FALSE;
  600. //目标图像中的当前点先赋成黑色
  601. *lpDst = (unsigned char)0;
  603. //如果原图像中对应结构元素中为黑色的那些点中有一个不是黑色，
  604. //则将目标图像中的当前点赋成白色
  605. //注意在DIB图像中内容是上下倒置的
  606. for (m = 0;m < 3;m++ )
  607. {
  608. for (n = 0;n < 3;n++)
  609. {
  610. if( structure[m][n] == -1)
  611. continue;
  612. pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1));
  613. if (pixel == 255 )
  614. {
  615. *lpDst = (unsigned char)255;
  616. break;
  617. }
  618. }
  619. }
  621. }
  622. }
  624. }
  625. // 复制腐蚀后的图像
  626. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  628. // 重新初始化新分配的内存，设定初始值为255
  629. //lpDst = (char *)lpNewDIBBits;
  630. //memset(lpDst, (BYTE)255, lWidth * lHeight);
  633. if(nMode == 0)
  634. {
  635. //使用水平方向的结构元素进行膨胀
  636. for(j = 0; j <lHeight; j++)
  637. {
  638. for(i = 1;i <lWidth-1; i++)
  639. {
  640. //由于使用1×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  642. // 指向源图像倒数第j行，第i个象素的指针
  643. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  645. // 指向目标图像倒数第j行，第i个象素的指针
  646. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  648. //取得当前指针处的像素值，注意要转换为unsigned char型
  649. pixel = (unsigned char)*lpSrc;
  651. //目标图像中含有0和255外的其它灰度值
  652. if(pixel != 255 && *lpSrc != 0)
  653. return FALSE;
  655. //目标图像中的当前点先赋成白色
  656. *lpDst = (unsigned char)255;
  658. //源图像中当前点自身或者左右只要有一个点是黑色，
  659. //则将目标图像中的当前点赋成黑色
  660. for (n = 0;n < 3;n++ )
  661. {
  662. pixel = *(lpSrc+n-1);
  663. if (pixel == 0 )
  664. {
  665. *lpDst = (unsigned char)0;
  666. break;
  667. }
  668. }
  670. }
  671. }
  673. }
  674. else if(nMode == 1)
  675. {
  676. //使用垂直方向的结构元素进行膨胀
  677. for(j = 1; j <lHeight-1; j++)
  678. {
  679. for(i = 0;i <lWidth; i++)
  680. {
  681. //由于使用1×3的结构元素，为防止越界，所以不处理最上边和最下边的两列像素
  683. // 指向源图像倒数第j行，第i个象素的指针
  684. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  686. // 指向目标图像倒数第j行，第i个象素的指针
  687. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  689. //取得当前指针处的像素值，注意要转换为unsigned char型
  690. pixel = (unsigned char)*lpSrc;
  692. //目标图像中含有0和255外的其它灰度值
  693. if(pixel != 255 && *lpSrc != 0)
  694. return FALSE;
  696. //目标图像中的当前点先赋成白色
  697. *lpDst = (unsigned char)255;
  699. //源图像中当前点自身或者上下只要有一个点是黑色，
  700. //则将目标图像中的当前点赋成黑色
  701. for (n = 0;n < 3;n++ )
  702. {
  703. pixel = *(lpSrc+(n-1)*lWidth);
  704. if (pixel == 0 )
  705. {
  706. *lpDst = (unsigned char)0;
  707. break;
  708. }
  709. }
  711. }
  712. }
  714. }
  715. else
  716. {
  717. //使用自定义的结构元素进行膨胀
  718. for(j = 1; j <lHeight-1; j++)
  719. {
  720. for(i = 0;i <lWidth; i++)
  721. {
  722. //由于使用3×3的结构元素，为防止越界，所以不处理最左边和最右边的两列像素
  723. //和最上边和最下边的两列像素
  724. // 指向源图像倒数第j行，第i个象素的指针
  725. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  727. // 指向目标图像倒数第j行，第i个象素的指针
  728. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  730. //取得当前指针处的像素值，注意要转换为unsigned char型
  731. pixel = (unsigned char)*lpSrc;
  733. //目标图像中含有0和255外的其它灰度值
  734. if(pixel != 255 && *lpSrc != 0)
  735. return FALSE;
  737. //目标图像中的当前点先赋成白色
  738. *lpDst = (unsigned char)255;
  740. //原图像中对应结构元素中为黑色的那些点中只要有一个是黑色，
  741. //则将目标图像中的当前点赋成黑色
  742. //注意在DIB图像中内容是上下倒置的
  743. for (m = 0;m < 3;m++ )
  744. {
  745. for (n = 0;n < 3;n++)
  746. {
  747. if( structure[m][n] == -1)
  748. continue;
  749. pixel = *(lpSrc + ((2-m)-1)*lWidth + (n-1));
  750. if (pixel == 0 )
  751. {
  752. *lpDst = (unsigned char)0;
  753. break;
  754. }
  755. }
  756. }
  758. }
  759. }
  761. }
  762. // 复制膨胀后的图像
  763. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  765. // 释放内存
  766. LocalUnlock(hNewDIBBits);
  767. LocalFree(hNewDIBBits);
  770. return TRUE;
  771. }
  774. /*************************************************************************
  775.  *
  776.  * 函数名称：
  777.  *   CloseDIB()
  778.  *
  779.  * 参数:
  780.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  781.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  782.  *   LONG  lHeight      - 源图像高度（象素数）
  783.  *   int   nMode - 闭运算方式，0表示水平方向，1表示垂直方向，2表示自定义结构元素。
  784.  *  int   structure[3][3]
  785. - 自定义的3×3结构元素。
  786.  *
  787.  * 返回值:
  788.  *   BOOL               - 闭运算成功返回TRUE，否则返回FALSE。
  789.  *
  790.  * 说明:
  791.  * 该函数用于对图像进行开运算。结构元素为水平方向或垂直方向的三个点，中间点位于原点；
  792.  * 或者由用户自己定义3×3的结构元素。
  793.  * 
  794.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  795.  ************************************************************************/
  797. /*************************************************************************
  798.  *
  799.  * 函数名称：
  800.  *   ThinDIB()
  801.  *
  802.  * 参数:
  803.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  804.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  805.  *   LONG  lHeight      - 源图像高度（象素数）
  806.  *
  807.  * 返回值:
  808.  *   BOOL               - 闭运算成功返回TRUE，否则返回FALSE。
  809.  *
  810.  * 说明:
  811.  * 该函数用于对图像进行细化运算。
  812.  * 
  813.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  814.  ************************************************************************/
  816. BOOL WINAPI CloseDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, int nMode , int structure[3][3])
  817. {
  818. if (DilationDIB(lpDIBBits, lWidth, lHeight, nMode , structure))
  819. {
  821. if (ErosionDIB(lpDIBBits, lWidth, lHeight, nMode , structure))
  822. {
  823. // 返回
  824. return TRUE;
  826. }
  827. }
  828. return FALSE;
  830. // 返回
  831. return TRUE;
  832. }
  834. BOOL WINAPI ThiningDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  835. {
  837. // 指向源图像的指针
  838. LPSTR lpSrc;
  840. // 指向缓存图像的指针
  841. LPSTR lpDst;
  843. // 指向缓存DIB图像的指针
  844. LPSTR lpNewDIBBits;
  845. HLOCAL hNewDIBBits;
  847. //脏标记
  848. BOOL bModified;
  850. //循环变量
  851. long i;
  852. long j;
  853. int  n;
  854. int  m;
  856. //四个条件
  857. BOOL bCondition1;
  858. BOOL bCondition2;
  859. BOOL bCondition3;
  860. BOOL bCondition4;
  862. //计数器
  863. unsigned char nCount;
  865. //像素值
  866. unsigned char pixel;
  868. //5×5相邻区域像素值
  869. unsigned char neighbour[5][5];
  871. // 暂时分配内存，以保存新图像
  872. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  874. if (hNewDIBBits == NULL)
  875. {
  876. // 分配内存失败
  877. return FALSE;
  878. }
  880. // 锁定内存
  881. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  883. // 初始化新分配的内存，设定初始值为255
  884. lpDst = (char *)lpNewDIBBits;
  885. memset(lpDst, (BYTE)255, lWidth * lHeight);
  887. bModified=TRUE;
  889. while(bModified)
  890. {
  892. bModified = FALSE;
  893. // 初始化新分配的内存，设定初始值为255
  894. lpDst = (char *)lpNewDIBBits;
  895. memset(lpDst, (BYTE)255, lWidth * lHeight);
  897. for(j = 2; j <lHeight-2; j++)
  898. {
  899. for(i = 2;i <lWidth-2; i++)
  900. {
  902. bCondition1 = FALSE;
  903. bCondition2 = FALSE;
  904. bCondition3 = FALSE;
  905. bCondition4 = FALSE;
  907. //由于使用5×5的结构元素，为防止越界，所以不处理外围的几行和几列像素
  909. // 指向源图像倒数第j行，第i个象素的指针
  910. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  912. // 指向目标图像倒数第j行，第i个象素的指针
  913. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  915. //取得当前指针处的像素值，注意要转换为unsigned char型
  916. pixel = (unsigned char)*lpSrc;
  918. //目标图像中含有0和255外的其它灰度值
  919. if(pixel != 255 && *lpSrc != 0)
  920. //return FALSE;
  921. continue;
  922. //如果源图像中当前点为白色，则跳过
  923. else if(pixel == 255)
  924. continue;
  926. //获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表
  927. for (m = 0;m < 5;m++ )
  928. {
  929. for (n = 0;n < 5;n++)
  930. {
  931. neighbour[m][n] =(255 - (unsigned char)*(lpSrc + ((4 - m) - 2)*lWidth + n - 2 )) / 255;
  932. }
  933. }
  934. // neighbour[][]
  935. //逐个判断条件。
  936. //判断2<=NZ(P1)<=6
  937. nCount =  neighbour[1][1] + neighbour[1][2] + neighbour[1][3] 
  938. + neighbour[2][1] + neighbour[2][3] + 
  939. + neighbour[3][1] + neighbour[3][2] + neighbour[3][3];
  940. if ( nCount >= 2 && nCount <=6)
  941. bCondition1 = TRUE;
  943. //判断Z0(P1)=1
  944. nCount = 0;
  945. if (neighbour[1][2] == 0 && neighbour[1][1] == 1)
  946. nCount++;
  947. if (neighbour[1][1] == 0 && neighbour[2][1] == 1)
  948. nCount++;
  949. if (neighbour[2][1] == 0 && neighbour[3][1] == 1)
  950. nCount++;
  951. if (neighbour[3][1] == 0 && neighbour[3][2] == 1)
  952. nCount++;
  953. if (neighbour[3][2] == 0 && neighbour[3][3] == 1)
  954. nCount++;
  955. if (neighbour[3][3] == 0 && neighbour[2][3] == 1)
  956. nCount++;
  957. if (neighbour[2][3] == 0 && neighbour[1][3] == 1)
  958. nCount++;
  959. if (neighbour[1][3] == 0 && neighbour[1][2] == 1)
  960. nCount++;
  961. if (nCount == 1)
  962. bCondition2 = TRUE;
  964. //判断P2*P4*P8=0 or Z0(p2)!=1
  965. if (neighbour[1][2]*neighbour[2][1]*neighbour[2][3] == 0)
  966. bCondition3 = TRUE;
  967. else
  968. {
  969. nCount = 0;
  970. if (neighbour[0][2] == 0 && neighbour[0][1] == 1)
  971. nCount++;
  972. if (neighbour[0][1] == 0 && neighbour[1][1] == 1)
  973. nCount++;
  974. if (neighbour[1][1] == 0 && neighbour[2][1] == 1)
  975. nCount++;
  976. if (neighbour[2][1] == 0 && neighbour[2][2] == 1)
  977. nCount++;
  978. if (neighbour[2][2] == 0 && neighbour[2][3] == 1)
  979. nCount++;
  980. if (neighbour[2][3] == 0 && neighbour[1][3] == 1)
  981. nCount++;
  982. if (neighbour[1][3] == 0 && neighbour[0][3] == 1)
  983. nCount++;
  984. if (neighbour[0][3] == 0 && neighbour[0][2] == 1)
  985. nCount++;
  986. if (nCount != 1)
  987. bCondition3 = TRUE;
  988. }
  990. //判断P2*P4*P6=0 or Z0(p4)!=1
  991. if (neighbour[1][2]*neighbour[2][1]*neighbour[3][2] == 0)
  992. bCondition4 = TRUE;
  993. else
  994. {
  995. nCount = 0;
  996. if (neighbour[1][1] == 0 && neighbour[1][0] == 1)
  997. nCount++;
  998. if (neighbour[1][0] == 0 && neighbour[2][0] == 1)
  999. nCount++;
  1000. if (neighbour[2][0] == 0 && neighbour[3][0] == 1)
  1001. nCount++;
  1002. if (neighbour[3][0] == 0 && neighbour[3][1] == 1)
  1003. nCount++;
  1004. if (neighbour[3][1] == 0 && neighbour[3][2] == 1)
  1005. nCount++;
  1006. if (neighbour[3][2] == 0 && neighbour[2][2] == 1)
  1007. nCount++;
  1008. if (neighbour[2][2] == 0 && neighbour[1][2] == 1)
  1009. nCount++;
  1010. if (neighbour[1][2] == 0 && neighbour[1][1] == 1)
  1011. nCount++;
  1012. if (nCount != 1)
  1013. bCondition4 = TRUE;
  1014. }
  1015. if(bCondition1 && bCondition2 && bCondition3 && bCondition4)
  1016. {
  1017. *lpDst = (unsigned char)255;
  1018. bModified = TRUE;
  1019. }
  1020. else
  1021. {
  1022. *lpDst = (unsigned char)0;
  1023. }
  1024. }
  1025. }
  1026. // 复制腐蚀后的图像
  1027. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1030. }
  1031. // 复制腐蚀后的图像
  1032. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1034. // 释放内存
  1035. LocalUnlock(hNewDIBBits);
  1036. LocalFree(hNewDIBBits);
  1038. // 返回
  1039. return TRUE;
  1040. }