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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
mydiblib.h
资源名称：gujiatiqu.rar　[点击查看]
上传用户：yianco
上传日期：2022-07-15
资源大小：2047k
文件大小：19k
源码类别：

图形图象

开发平台：

Visual C++

mydiblib.h：源码内容
  1. #include "dibapi.h"
  2. #include <iostream>
  3. #include <deque>
  4. #include <math.h>
  5. using namespace std;
  6. typedef deque<HDIB>  HDIBLink;
  7. HDIB m_hDIB;
  8. CString strPathName;
  9. CString strPathNameSave;
  12. //声明一些必要的全局变量
  13. int m_lianXuShu;
  14. bool fileloaded;
  15. bool gyhfinished;
  16. /********************************function declaration*************************************/
  18. //清楚屏幕
  19. void ClearAll(CDC* pDC);
  20. //在屏幕上显示位图
  21. void DisplayDIB(CDC* pDC,HDIB hDIB);
  22. //将灰度图二值化
  23. void ConvertGrayToWhiteBlack(HDIB hDIB);
  24. //判断是否是离散噪声点
  25. bool DeleteScaterJudge(LPSTR lpDIBBits,WORD lLineBytes, LPBYTE lplab, int lWidth, int lHeight, int x, int y, CPoint lab[], int lianXuShu);
  26. //细化
  27. void Thinning(HDIB hDIB);
  32. void DisplayDIB(CDC* pDC,HDIB hDIB)
  33. {
  34. BYTE* lpDIB=(BYTE*)::GlobalLock((HGLOBAL)hDIB);
  35. // 获取DIB宽度和高度
  36. int cxDIB =  ::DIBWidth((char*) lpDIB);
  37. int cyDIB =  ::DIBHeight((char*)lpDIB);
  38. CRect rcDIB,rcDest;
  39. rcDIB.top = rcDIB.left = 0;
  40. rcDIB.right = cxDIB;
  41. rcDIB.bottom = cyDIB;
  42. //设置目标客户区输出大小尺寸
  43. rcDest = rcDIB;
  44. //CDC* pDC=GetDC();
  45. ClearAll(pDC);
  46. //在客户区显示图像
  47. //for(int ii=0;ii<10;ii++)
  48. ::PaintDIB(pDC->m_hDC,rcDest,hDIB,rcDIB,NULL);
  49. ::GlobalUnlock((HGLOBAL)hDIB);
  50. }
  52. void ClearAll(CDC *pDC)
  53. {
  54. CRect rect;
  55. //GetClientRect(&rect);
  56. rect.left =0;rect.top =0;rect.right =2000;rect.bottom =1000;
  57. CPen pen;
  58. pen.CreatePen (PS_SOLID,1,RGB(255,255,255));
  59. pDC->SelectObject (&pen);
  60. pDC->Rectangle (&rect);
  61. ::DeleteObject (pen);
  62. }
  68. /****************************************************************
  69. * 函数名称：
  70. *      Convert256toGray()
  71. *
  72. * 参数：
  73. *     HDIB hDIB     －图像的句柄
  74. *
  75. *  返回值：
  76. *        无
  77. *
  78. *  功能：
  79. *     将256色位图转化为灰度图
  80. *
  81. ***************************************************************/
  83. void Convert256toGray(HDIB hDIB)
  84. {
  85. LPSTR lpDIB;
  87. // 由DIB句柄得到DIB指针并锁定DIB
  88. lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  90. // 指向DIB象素数据区的指针
  91. LPSTR   lpDIBBits;
  93. // 指向DIB象素的指针
  94. BYTE * lpSrc;
  96. // 图像宽度
  97. LONG lWidth;
  98. // 图像高度
  99. LONG   lHeight;
  101. // 图像每行的字节数
  102. LONG lLineBytes;
  104. // 指向BITMAPINFO结构的指针（Win3.0）
  105. LPBITMAPINFO lpbmi;
  107. // 指向BITMAPCOREINFO结构的指针
  108. LPBITMAPCOREINFO lpbmc;
  110. // 获取指向BITMAPINFO结构的指针（Win3.0）
  111. lpbmi = (LPBITMAPINFO)lpDIB;
  113. // 获取指向BITMAPCOREINFO结构的指针
  114. lpbmc = (LPBITMAPCOREINFO)lpDIB;
  116. // 灰度映射表
  117. BYTE bMap[256];
  119. // 计算灰度映射表（保存各个颜色的灰度值），并更新DIB调色板
  120. int i,j;
  121. for (i = 0; i < 256; i ++)
  122. {
  123. // 计算该颜色对应的灰度值
  124. bMap[i] = (BYTE)(0.299 * lpbmi->bmiColors[i].rgbRed +
  126.      0.587 * lpbmi->bmiColors[i].rgbGreen +
  128.          0.114 * lpbmi->bmiColors[i].rgbBlue + 0.5);
  129. // 更新DIB调色板红色分量
  130. lpbmi->bmiColors[i].rgbRed = i;
  132. // 更新DIB调色板绿色分量
  133. lpbmi->bmiColors[i].rgbGreen = i;
  135. // 更新DIB调色板蓝色分量
  136. lpbmi->bmiColors[i].rgbBlue = i;
  138. // 更新DIB调色板保留位
  139. lpbmi->bmiColors[i].rgbReserved = 0;
  141. }
  142. // 找到DIB图像象素起始位置
  143. lpDIBBits = ::FindDIBBits(lpDIB);
  145. // 获取图像宽度
  146. lWidth = ::DIBWidth(lpDIB);
  148. // 获取图像高度
  149. lHeight = ::DIBHeight(lpDIB);
  151. // 计算图像每行的字节数
  152. lLineBytes = WIDTHBYTES(lWidth * 8);
  154. // 更换每个象素的颜色索引（即按照灰度映射表换成灰度值）
  156. //逐行扫描
  157. for(i = 0; i < lHeight; i++)
  158. {
  160.   //逐列扫描
  161. for(j = 0; j < lWidth; j++)
  162. {
  163. // 指向DIB第i行，第j个象素的指针
  164. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;
  166. // 变换
  167. *lpSrc = bMap[*lpSrc];
  168. }
  169. }
  171. //解除锁定
  172. ::GlobalUnlock ((HGLOBAL)hDIB);
  173. }
  179. /******************************************************************
  180. *
  181. * 函数名称ConvertGrayToWhiteBlack()
  182. *
  183. * 参数 ：HDIB hDIB     －原图的句柄
  184. *
  185. * 返回值：无
  186. *
  187. * 功能: ConvertGrayToWhiteBlack函数采用硬阈值的方法，实现将图像二值化的功能。
  188. * 
  189. * 说明：
  190. 要求待处理的图片为256色
  191. ************************************************************************/
  193. void ConvertGrayToWhiteBlack(HDIB hDIB)
  194. {
  195. // 指向DIB的指针
  196. LPSTR lpDIB;
  198. // 由DIB句柄得到DIB指针并锁定DIB
  199. lpDIB = (LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  201. // 指向DIB象素数据区的指针
  202. LPSTR   lpDIBBits;
  204. // 指向DIB象素的指针
  205. BYTE * lpSrc;
  207. // 图像宽度
  208. LONG lWidth;
  210. // 图像高度
  211. LONG lHeight;
  212. // 图像每行的字节数
  213. LONG lLineBytes;
  215. // 找到DIB图像象素起始位置
  216. lpDIBBits = ::FindDIBBits(lpDIB);
  218. // 获取图像宽度
  219. lWidth = ::DIBWidth(lpDIB);
  221. // 获取图像高度
  222. lHeight = ::DIBHeight(lpDIB);
  224. // 计算图像每行的字节数
  225. lLineBytes = WIDTHBYTES(lWidth * 8);
  227. // 更换每个象素的颜色索引（即按照灰度映射表换成灰度值）
  228. int i,j;
  230.     //逐行扫描
  231. for(i = 0; i < lHeight; i++)
  232.  {
  234.    //逐列扫描
  235. for(j = 0; j < lWidth; j++)
  236. {
  238. // 指向DIB第i行，第j个象素的指针
  239. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * i + j;
  241. // 二值化处理
  243.    //大于220，设置为255，即白点
  244. if(*lpSrc>200) *lpSrc=255;
  246.   //否则设置为0，即黑点
  247. else *lpSrc=0;
  249. }
  251. }
  253.  //解除锁定
  254. ::GlobalUnlock((HGLOBAL)hDIB);
  255. }
  263. /************************************************************
  264. *
  265. *  函数名称：
  266. *       RemoveScatterNoise()
  267. *
  268. *  参数：
  269. *     HDIB    hDIB     －原图像的句柄
  270. *
  271. *  返回值:
  272. *       无
  273. *
  274. *  功能：
  275. *     通过对连续点长度的统计来去除离散杂点
  276. *
  277. *  说明：
  278. *      只能对2值图像进行处理
  279. ****************************************************************/
  280. void RemoveScatterNoise(HDIB hDIB)
  281. {
  283. // 指向DIB的指针
  284. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  286. // 指向DIB象素指针
  287. LPSTR    lpDIBBits;
  289. // 找到DIB图像象素数据区的起始位置
  290. lpDIBBits = ::FindDIBBits(lpDIB);
  292. //获得图像的长度
  293. LONG lWidth=::DIBWidth ((char*)lpDIB);
  295. //获得图像的高度
  296. LONG lHeight=::DIBHeight ((char*)lpDIB);
  298. //设置判定噪声的长度阈值为15
  299. //即如果与考察点相连接的黑点的数目小于15则认为考察点是噪声点
  300. int length=15;
  302. // 循环变量
  303. m_lianXuShu=0;
  304. LONG i;
  305. LONG j;
  306. LONG    k;
  308. // 图像每行的字节数
  309. LONG lLineBytes;
  311. // 计算图像每行的字节数
  312. lLineBytes = WIDTHBYTES(lWidth * 8);
  314.     
  315. LPSTR lpSrc;
  317. //开辟一块用来存放标志的内存数组
  318. LPBYTE lplab = new BYTE[lHeight * lWidth];
  320. //开辟一块用来保存离散判定结果的内存数组
  321. bool *lpTemp = new bool[lHeight * lWidth];
  323.     //初始化标志数组
  324. for (i=0;i<lHeight*lWidth;i++)
  325.     {
  327.     //将所有的标志位设置为非
  328. lplab[i] = false;
  330. }
  332. //用来存放离散点的坐标的数组
  333. CPoint lab[21];
  334.    
  335. //为循环变量赋初始值
  336. k=0;
  338. //扫描整个图像
  340. //逐行扫描
  341. for(i =0;i<lHeight;i++)
  342. {  
  343.        
  344.    //逐行扫描
  345. for(j=0;j<lWidth;j++)
  346. {
  347. //先把标志位置false
  348. for(k=0;k<m_lianXuShu;k++)
  349. lplab[lab[k].y * lWidth + lab[k].x] = false;
  351. //连续数置0
  352. m_lianXuShu =0;
  354.     //进行离散性判断
  355.     lpTemp[i*lWidth+j] = DeleteScaterJudge(lpDIBBits,(WORD)lLineBytes,lplab,lWidth,lHeight,j,i,lab,length);
  357. }
  358. }
  360. //扫描整个图像，把离散点填充成白色
  362. //逐行扫描
  363. for(i = 0;i<lHeight;i++)
  364. {
  366.       //逐列扫描
  367. for(j=0;j<lWidth;j++)
  368. {       
  369.     //查看标志位,如果为非则将此点设为白点
  370. if(lpTemp[i*lWidth+j] == false)
  371. {
  372.                    //指向第i行第j个象素的指针
  373. lpSrc=(char*)lpDIBBits + lLineBytes * i + j;
  375. //将此象素设为白点
  376. *lpSrc=BYTE(255);
  377. }
  378. }
  379. }
  381. //解除锁定
  382. ::GlobalUnlock ((HGLOBAL)hDIB);
  384. }
  395. /*****************************************************************
  396. *
  397. *  函数名称 
  398. *       DeleteScaterJudge()
  399. *
  400. *  参数：
  401. *     LPSTR   lpDIBBits      －指向象素起始位置的指针
  402. *   WORD    lLineBytes     －图像每行的字节数
  403. *     LPBYTE  lplab          －标志位数组
  404. *     int     lWidth         －图像的宽度
  405. *   int     lHeight        －图像的高度
  406. *     int     x              －当前点的横坐标
  407. *   int     y              －当前点的纵坐标 
  408. *     CPoint  lab[]          －存放议考察过的连续点坐标
  409. *     int     lianXuShu      －离散点的判定长度
  410. *
  411. *  返回值：
  412. *     Bool                   －是离散点返回false 不是离散点返回true
  413. *  
  414. *  功能：
  415. *     利用递归算法统计连续点的个数，通过阈值来判定是否为离散点
  416. *
  417. *  说明：
  418. *     只能对2值图像进行处理
  419. ******************************************************************/     
  422. bool DeleteScaterJudge(LPSTR lpDIBBits, WORD lLineBytes, LPBYTE lplab, int lWidth, int lHeight, int x, int y, CPoint lab[], int lianXuShu)
  423. {
  425. //如果连续长度满足要求，说明不是离散点，返回
  426. if(m_lianXuShu>=lianXuShu)
  427. return TRUE;
  429. //长度加一
  430. m_lianXuShu++;
  432. //设定访问标志
  433. lplab[lWidth * y +x] = true;
  435. //保存访问点坐标
  436. lab[m_lianXuShu-1].x = x;
  437. lab[m_lianXuShu-1].y = y;
  439. //象素的灰度值
  440. int gray;
  441.   
  442. //指向象素的指针
  443. LPSTR lpSrc;
  445. //长度判定
  446.     //如果连续长度满足要求，说明不是离散点，返回
  447. if(m_lianXuShu>=lianXuShu)
  448. return TRUE;
  450. //下面进入递归
  451. else
  452. {
  453. //考察上下左右以及左上、右上、左下、右下八个方向
  454. //如果是黑色点，则调用函数自身进行递归
  456. //考察下面点
  458. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x;
  460. //传递灰度值
  461. gray=*lpSrc;
  463. //如果点在图像内、颜色为黑色并且没有被访问过
  464. if(y-1 >=0 && gray == 0 && lplab[(y-1)*lWidth+x] == false)
  466. //进行递归处理
  467. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x,y-1,lab,lianXuShu);
  469. //判断长度
  470. //如果连续长度满足要求，说明不是离散点，返回
  471. if(m_lianXuShu>=lianXuShu)
  472. return TRUE;
  474. //左下点
  476. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x-1;
  478.         //传递灰度值
  479. gray=*lpSrc;
  481.         //如果点在图像内、颜色为黑色并且没有被访问过
  482. if(y-1 >=0 &&  x-1 >=0 && gray== 0 && lplab[(y-1)*lWidth+x-1] == false)
  484.        //进行递归处理
  485. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y-1,lab,lianXuShu);
  487.         //判断长度
  488. //如果连续长度满足要求，说明不是离散点，返回
  489. if(m_lianXuShu>=lianXuShu)
  490. return TRUE;
  492. //左边
  494. lpSrc=(char*)lpDIBBits + lLineBytes * y + x-1;
  496. //传递灰度值
  497. gray=*lpSrc;
  499.         //如果点在图像内、颜色为黑色并且没有被访问过
  500. if(x-1 >=0 &&  gray== 0 && lplab[y*lWidth+x-1] == false)
  502.         //进行递归处理
  503. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y,lab,lianXuShu);
  505.         //判断长度
  506. //如果连续长度满足要求，说明不是离散点，返回
  507. if(m_lianXuShu>=lianXuShu)
  508. return TRUE;
  510. //左上
  512. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x-1;
  514. //传递灰度值
  515. gray=*lpSrc;
  517.         //如果点在图像内、颜色为黑色并且没有被访问过
  518. if(y+1 <lHeight && x-1 >= 0 && gray == 0 && lplab[(y+1)*lWidth+x-1] == false)
  520. //进行递归处理
  522. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x-1,y+1,lab,lianXuShu);
  524.         //判断长度
  525. //如果连续长度满足要求，说明不是离散点，返回
  526. if(m_lianXuShu>=lianXuShu)
  527. return TRUE;
  529. //上面
  531. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x;
  533.         //传递灰度值
  534. gray=*lpSrc;
  536.         //如果点在图像内、颜色为黑色并且没有被访问过
  537. if(y+1 < lHeight && gray == 0 && lplab[(y+1)*lWidth+x] == false)
  539.         //进行递归处理
  541. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x,y+1,lab,lianXuShu);
  543.         //判断长度
  544. //如果连续长度满足要求，说明不是离散点，返回
  545. if(m_lianXuShu>=lianXuShu)
  546. return TRUE;
  548. //右上
  550. lpSrc=(char*)lpDIBBits + lLineBytes * (y+1) + x+1;
  551.         
  552. //传递灰度值
  553. gray=*lpSrc;
  555.         //如果点在图像内、颜色为黑色并且没有被访问过
  556. if(y+1 <lHeight && x+1 <lWidth &&  gray == 0 && lplab[(y+1)*lWidth+x+1] == false)
  558.         //进行递归处理
  559. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y+1,lab,lianXuShu);
  561.         //判断长度
  562. //如果连续长度满足要求，说明不是离散点，返回
  563. if(m_lianXuShu>=lianXuShu)
  564. return TRUE;
  566. //右边
  568. lpSrc=(char*)lpDIBBits + lLineBytes * y + x+1;
  570.         //传递灰度值
  571. gray=*lpSrc;
  573. //如果点在图像内、颜色为黑色并且没有被访问过
  574. if(x+1 <lWidth && gray==0 && lplab[y*lWidth+x+1] == false)
  576.         //进行递归处理
  577. DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y,lab,lianXuShu);
  579.         //判断长度
  581. //如果连续长度满足要求，说明不是离散点，返回
  582. if(m_lianXuShu>=lianXuShu)
  583. return TRUE;
  585. //右下
  587. lpSrc=(char*)lpDIBBits + lLineBytes * (y-1) + x+1;
  589.         //传递灰度值
  590. gray=*lpSrc;
  592.         //如果点在图像内、颜色为黑色并且没有被访问过
  593. if(y-1 >=0 && x+1 <lWidth && gray == 0 && lplab[(y-1)*lWidth+x+1] == false)
  595.        //进行递归处理
  596.    DeleteScaterJudge(lpDIBBits,lLineBytes,lplab,lWidth,lHeight,x+1,y-1,lab,lianXuShu);
  598.         //判断长度
  599. //如果连续长度满足要求，说明不是离散点，返回
  600. if(m_lianXuShu>=lianXuShu)
  601. return TRUE;
  602. }
  605. //如果递归结束，返回false，说明是离散点
  606. return FALSE;
  608. }
  613. //细化算法
  615. BOOL   WINAPI   ThiningDIB(LPSTR   lpDIBBits,   LONG   lWidth,   LONG   lHeight)   
  616.   {   
  617.     
  618.   //   指向源图像的指针   
  619.   LPSTR lpSrc;   
  620.     
  621.   //   指向缓存图像的指针   
  622.   LPSTR lpDst;   
  623.     
  624.   //   指向缓存DIB图像的指针   
  625.   LPSTR lpNewDIBBits;   
  626.   HLOCAL hNewDIBBits;   
  627.   LONG lLineBytes=WIDTHBYTES(lWidth   *   8);   
  628.   //脏标记   
  629.   BOOL   bModified;   
  630.     
  631.   //循环变量   
  632.   long   i;   
  633.   long   j;   
  634.   int     n;   
  635.   int     m;   
  636.     
  637.   //四个条件   
  638.   BOOL   bCondition1;   
  639.   BOOL   bCondition2;   
  640.   BOOL   bCondition3;   
  641.   BOOL   bCondition4;   
  642.   bool   bNotCondition5;   
  643.     
  644.   //计数器   
  645.   unsigned   char   nCount;   
  646.     
  647.   //像素值   
  648.   unsigned   char   pixel;   
  649.     
  650.   //5×5相邻区域像素值   
  651.   unsigned   char   neighbour[5][5];   
  652.     
  653.   //   暂时分配内存，以保存新图像   
  654.   hNewDIBBits   =   LocalAlloc(LHND,   lLineBytes   *   lHeight);   
  655.     
  656.   if   (hNewDIBBits   ==   NULL)   
  657.   {   
  658.   //   分配内存失败   
  659.   return   FALSE;   
  660.   }   
  661.     
  662.   //   锁定内存   
  663.   lpNewDIBBits   =   (char   *   )LocalLock(hNewDIBBits);   
  664.     
  665.   //   初始化新分配的内存，设定初始值为255   
  666.   lpDst   =   (char   *)lpNewDIBBits;   
  667.   memset(lpDst,   (BYTE)255,lLineBytes   *   lHeight);   
  668.     
  669.   bModified=TRUE;   
  670.     
  671.   while(bModified)   
  672.   {   
  673.     
  674.   bModified   =   FALSE;   
  675.   //   初始化新分配的内存，设定初始值为255   
  676.   lpDst   =   (char   *)lpNewDIBBits;   
  677.   memset(lpDst,   (BYTE)255,   lLineBytes*   lHeight);   
  678.     
  679.   for(j   =   2;   j   <lHeight-2;   j++)   
  680.   {   
  681.   for(i   =   2;i   <lWidth-2;   i++)   
  682.   {   
  683.     
  684.   bCondition1   =   FALSE;   
  685.   bCondition2   =   FALSE;   
  686.   bCondition3   =   FALSE;   
  687.   bCondition4   =   FALSE;   
  688.   bNotCondition5=true;   
  689.     
  690.   //由于使用5×5的结构元素，为防止越界，所以不处理外围的几行和几列像素   
  691.     
  692.   //   指向源图像倒数第j行，第i个象素的指针   
  693.   lpSrc   =   (char   *)lpDIBBits   +   lLineBytes   *   j   +   i;   
  694.     
  695.   //   指向目标图像倒数第j行，第i个象素的指针   
  696.   lpDst   =   (char   *)lpNewDIBBits   +   lLineBytes   *   j   +   i;   
  697.     
  698.   //取得当前指针处的像素值，注意要转换为unsigned   char型   
  699.   pixel   =   (unsigned   char)*lpSrc;   
  700.     
  701.   //目标图像中含有0和255外的其它灰度值   
  702.   if(pixel   !=   255   &&   *lpSrc   !=   0)   
  703.   //return   FALSE;   
  704.   continue;   
  705.   //如果源图像中当前点为白色，则跳过   
  706.   else   if(pixel   ==   255)   
  707.   continue;   
  708.     
  709.   //获得当前点相邻的5×5区域内像素值，白色用0代表，黑色用1代表   
  710.   for   (m   =   0;m   <   5;m++   )   
  711.   {   
  712.   for   (n   =   0;n   <   5;n++)   
  713.   {   
  714.   neighbour[m][n]   =(255   -   (unsigned   char)*(lpSrc   +   ((4   -   m)   -   2)*lLineBytes   +   n   -   2   ))   /   255;   
  715.   }   
  716.   }   
  717.   // neighbour[][]   
  718.   //逐个判断条件。   
  719.   //判断2<=NZ(P1)<=6   
  720.   nCount   =     neighbour[1][1]   +   neighbour[1][2]   +   neighbour[1][3]+   neighbour[2][1]   +   neighbour[2][3]   +    
  721.   +   neighbour[3][1]   +   neighbour[3][2]   +   neighbour[3][3];   
  722.   if   (   nCount   >=   2   &&   nCount   <=6)   
  723.   bCondition1   =   TRUE;   
  724.     
  725.   //判断Z0(P1)=1   
  726.   nCount   =   0;   
  727.   if   (neighbour[1][2]   ==   0   &&   neighbour[1][1]   ==   1)   
  728.   nCount++;   
  729.   if   (neighbour[1][1]   ==   0   &&   neighbour[2][1]   ==   1)   
  730.   nCount++;   
  731.   if   (neighbour[2][1]   ==   0   &&   neighbour[3][1]   ==   1)   
  732.   nCount++;   
  733.   if   (neighbour[3][1]   ==   0   &&   neighbour[3][2]   ==   1)   
  734.   nCount++;   
  735.   if   (neighbour[3][2]   ==   0   &&   neighbour[3][3]   ==   1)   
  736.   nCount++;   
  737.   if   (neighbour[3][3]   ==   0   &&   neighbour[2][3]   ==   1)   
  738.   nCount++;   
  739.   if   (neighbour[2][3]   ==   0   &&   neighbour[1][3]   ==   1)   
  740.   nCount++;   
  741.   if   (neighbour[1][3]   ==   0   &&   neighbour[1][2]   ==   1)   
  742.   nCount++;   
  743.   if   (nCount   ==   1)   
  744.   bCondition2   =   TRUE;   
  745.   if(neighbour[1][2]+neighbour[1][1]+neighbour[2][1]+   
  746.   neighbour[3][1]+neighbour[3][2]+neighbour[3][3]+   
  747.   neighbour[2][3]+neighbour[1][3]==1)   
  748.   bNotCondition5=false;   
  749.     
  750.   //判断P2*P4*P8=0   or   Z0(p2)!=1   
  751.   if   (neighbour[1][2]*neighbour[2][1]*neighbour[2][3]   ==   0)   
  752.   bCondition3   =   TRUE;   
  753.   else   
  754.   {   
  755.   nCount   =   0;   
  756.   if   (neighbour[0][2]   ==   0   &&   neighbour[0][1]   ==   1)   
  757.   nCount++;   
  758.   if   (neighbour[0][1]   ==   0   &&   neighbour[1][1]   ==   1)   
  759.   nCount++;   
  760.   if   (neighbour[1][1]   ==   0   &&   neighbour[2][1]   ==   1)   
  761.   nCount++;   
  762.   if   (neighbour[2][1]   ==   0   &&   neighbour[2][2]   ==   1)   
  763.   nCount++;   
  764.   if   (neighbour[2][2]   ==   0   &&   neighbour[2][3]   ==   1)   
  765.   nCount++;   
  766.   if   (neighbour[2][3]   ==   0   &&   neighbour[1][3]   ==   1)   
  767.   nCount++;   
  768.   if   (neighbour[1][3]   ==   0   &&   neighbour[0][3]   ==   1)   
  769.   nCount++;   
  770.   if   (neighbour[0][3]   ==   0   &&   neighbour[0][2]   ==   1)   
  771.   nCount++;   
  772.   if   (nCount   !=   1)   
  773.   bCondition3   =   TRUE;   
  774.   }   
  775.     
  776.   //判断P2*P4*P6=0   or   Z0(p4)!=1   
  777.   if   (neighbour[1][2]*neighbour[2][1]*neighbour[3][2]   ==   0)   
  778.   bCondition4   =   TRUE;   
  779.   else   
  780.   {   
  781.   nCount   =   0;   
  782.   if   (neighbour[1][1]   ==   0   &&   neighbour[1][0]   ==   1)   
  783.   nCount++;   
  784.   if   (neighbour[1][0]   ==   0   &&   neighbour[2][0]   ==   1)   
  785.   nCount++;   
  786.   if   (neighbour[2][0]   ==   0   &&   neighbour[3][0]   ==   1)   
  787.   nCount++;   
  788.   if   (neighbour[3][0]   ==   0   &&   neighbour[3][1]   ==   1)   
  789.   nCount++;   
  790.   if   (neighbour[3][1]   ==   0   &&   neighbour[3][2]   ==   1)   
  791.   nCount++;   
  792.   if   (neighbour[3][2]   ==   0   &&   neighbour[2][2]   ==   1)   
  793.   nCount++;   
  794.   if   (neighbour[2][2]   ==   0   &&   neighbour[1][2]   ==   1)   
  795.   nCount++;   
  796.   if   (neighbour[1][2]   ==   0   &&   neighbour[1][1]   ==   1)   
  797.   nCount++;   
  798.   if   (nCount   !=   1)   
  799.   bCondition4   =   TRUE;   
  800.     
  801.   }   
  802.   if(bCondition1   &&   bCondition2   &&   bCondition3   &&   bCondition4&&bNotCondition5)   
  803.   {   
  804.   *lpDst   =   (unsigned   char)255;   
  805.   bModified   =   TRUE;   
  806.   }   
  807.   else   
  808.   {   
  809.   *lpDst   =   (unsigned   char)0;   
  810.   }   
  811.   }   
  812.   }   
  813.   //   复制腐蚀后的图像   
  814.   memcpy(lpDIBBits,   lpNewDIBBits,   lLineBytes   *   lHeight);   
  815.     
  816.     
  817.   }   
  818.   //   复制腐蚀后的图像   
  819.   memcpy(lpDIBBits,   lpNewDIBBits,   lLineBytes   *   lHeight);   
  820.     
  821.   //   释放内存   
  822.   LocalUnlock(hNewDIBBits);   
  823.   LocalFree(hNewDIBBits);   
  824.     
  825.   //   返回   
  826.   return   TRUE;   
  827.   }   
  828.   
  832. void Thinning(HDIB hDIB)
  833. {
  834. // 指向DIB的指针
  835. LPSTR lpDIB=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
  837. // 指向DIB象素指针
  838. LPSTR    lpDIBBits;
  840. // 找到DIB图像象素起始位置
  841. lpDIBBits = ::FindDIBBits(lpDIB);
  844. //图像的高度和宽度
  845. LONG lWidth;
  846. LONG lHeight;
  848. //获取图像的宽度
  849. lWidth=::DIBWidth ((char*)lpDIB);
  851. //获取图像的高度
  852. lHeight=::DIBHeight ((char*)lpDIB);
  858.    ThiningDIB(lpDIBBits,lWidth,lHeight);
  864.  //清空内存
  865.    ::GlobalUnlock ((HGLOBAL)hDIB);
  867. return;
  868. }