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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
ImageAnalysis.cpp
资源名称：VC_ImageProcessing.rar　[点击查看]
上传用户：panpan8800
上传日期：2013-06-29
资源大小：274k
文件大小：24k
源码类别：

图形图像处理

开发平台：

Visual C++

ImageAnalysis.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "GlobalApi.h"
  3. #include "Cdib.h"
  5. #include <io.h>
  6. #include <errno.h>
  8. #include <math.h>
  9. #include <direct.h>
  12. /*************************************************************************
  13.  *
  14.  * 函数名称：
  15.  *   DIBHOLENUMBER()
  16.  *
  17.  * 参数:
  18.  *   CDib * pDib        - 指向CDib类的指针
  19.  *
  20.  * 返回值:
  21.  *   BOOL               - 成功返回True，否则返回False。
  22.  *
  23.  * 说明:
  24.  *   该函数将消去图象中面积小于阈值的小区域
  25.  *
  26.  *************************************************************************/
  28. BOOL DIBHOLENUMBER(CDib *pDib)
  29. {
  30. // 指向源图像的指针
  31. BYTE * lpSrc;
  33. //图象的宽度和高度
  34. LONG    lWidth;
  35. LONG    lHeight;
  37. // 图像每行的字节数
  38. LONG lLineBytes;
  40. //得到图象的宽度和高度
  41. CSize   SizeDim;
  42. SizeDim = pDib->GetDimensions();
  43. lWidth  = SizeDim.cx;
  44. lHeight = SizeDim.cy;
  46. //得到实际的Dib图象存储大小
  47. CSize   SizeRealDim;
  48. SizeRealDim = pDib->GetDibSaveDim();
  50. // 计算图像每行的字节数
  51. lLineBytes = SizeRealDim.cx;
  53. //图像数据的指针
  54. LPBYTE  lpDIBBits = pDib->m_lpImage;
  56. // 循环变量
  57. int i, j, s, n;
  59. // 空穴的数目以及面积阈值
  60. int nHoleNum, nMinArea;
  62. int nBlackPix, temp;
  64. // 正向和反响传播标志
  65. int nDir1,nDir2;
  67. // 用来存储的一位数组
  68. int *pnBinary;
  70. pnBinary =new int[lHeight*lLineBytes];
  72. // 小区域的阈值面积为20个象素点
  73. nMinArea = 50;
  75. // 将图象二值化
  76. for (j = 0; j < lHeight; j++)
  77. {
  78. for(i = 0; i < lWidth; i++)
  79. {
  80. // 指向源图像倒数第j行，第i个象素的指针
  81. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  83. // 白色象素为背景，存成0
  84. if(*lpSrc > 200)
  85. {
  86. pnBinary[lLineBytes * j + i] = 0;
  87. }
  88. // 黑象素存成-1
  89. else
  90. {
  91. pnBinary[lLineBytes * j + i] = -1;
  92. }
  93. }
  94. }
  96. // 空穴数赋初值
  97. nHoleNum = 1;
  99. do
  100. {
  101. s=0;
  103. // 寻找每个空穴的初始象素值 
  104. for (j = 1; j < lHeight - 1; j++)
  105. {
  106. for(i = 1; i < lWidth - 1; i++)
  107. {
  108. // 找到初始象素
  109. if(pnBinary[lLineBytes * j + i] == -1)
  110. {
  111. s = 1;
  112. // 将象素值改成当前的空穴数值
  113. pnBinary[lLineBytes * j + i] = nHoleNum;
  115. // 跳出循环
  116. j = lHeight;
  117. i = lLineBytes;
  118. }
  119. }
  120. }
  122. //没有初始象素，跳出循环
  123. if(s == 0)
  124. break;
  125. else
  126. {
  127. do
  128. {
  129. // 正向和反响传播系数赋初值0
  130. nDir1 = 0;
  131. nDir2 = 0;
  133. // 正向扫描
  134. for (j = 1; j < lHeight-1; j++)
  135. {
  136. for(i = 1; i < lWidth-1; i++)
  137. {
  138. nBlackPix = pnBinary[lLineBytes * j + i];
  140. // 如果象素已经被扫描，或者是背景色，进行下一个循环
  141. if(nBlackPix != -1)
  142. continue;
  144. // 如果上侧或者左侧的象素值已经被扫描，且属于当前的空穴，当前的象素值
  145. // 改成空穴的数值
  146. nBlackPix=pnBinary[lLineBytes * (j-1) + i];
  147. if(nBlackPix == nHoleNum)
  148. {
  149. pnBinary[lLineBytes * j + i] = nHoleNum;
  150. nDir1 = 1;
  152. continue;
  153. }
  155. nBlackPix =pnBinary[lLineBytes * j + i - 1];
  156. if(nBlackPix == nHoleNum)
  157. {
  158. pnBinary[lLineBytes * j + i] = nHoleNum;
  159. nDir1 = 1;
  160. }
  162. }
  163. }
  165. // 正向象素全部被扫描，跳出循环
  166. if(nDir1 == 0)
  167. break;
  169. // 反向扫描
  170. for (j = lHeight-2; j >= 1 ; j--)
  171. {
  172. for(i = lWidth-2; i >= 1 ; i--)
  173. {
  174. nBlackPix = pnBinary[lLineBytes * j + i];
  176. // 如果象素已经被扫描，或者是背景色，进行下一个循环
  177. if(nBlackPix != -1)
  178. continue;
  180. // 如果下侧或者右侧的象素值已经被扫描，且属于当前的空穴，当前的象素值
  181. // 改成空穴的数值
  182. nBlackPix=pnBinary[lLineBytes * (j+1) + i];
  183. if(nBlackPix == nHoleNum)
  184. {
  185. pnBinary[lLineBytes * j + i] = nHoleNum;
  186. nDir2 = 1;
  188. continue;
  189. }
  191. nBlackPix =pnBinary[lLineBytes * j + i + 1];
  192. if(nBlackPix == nHoleNum)
  193. {
  194. pnBinary[lLineBytes * j + i] = nHoleNum;
  195. nDir2 = 1;
  196. }
  197. }
  198. }
  200. if(nDir2 == 0)
  201. break;
  202. }
  203. while(1);
  204. }
  205. // 空穴数增加
  206. nHoleNum++;
  207. }
  208. while(1);
  210. nHoleNum -- ;
  212. // 寻找面积小于阈值的空穴区域
  213. for(n = 1; n <= nHoleNum; n++)
  214. {
  215. s = 0;
  217. for (j = 0; j < lHeight - 1; j++)
  218. {
  219. for(i = 0; i < lWidth - 1; i++)
  220. {
  221. nBlackPix =pnBinary[lLineBytes * j + i];
  223. if(nBlackPix == n)
  224. s++;
  226. // 如果区域面积已经大于阈值，跳出循环
  227. if(s > nMinArea)
  228. break;
  229. }
  231. if(s > nMinArea)
  232. break;
  233. }
  235. // 小于阈值的区域，赋以与背景一样的颜色，进行消去
  236. if(s <= nMinArea)
  237. {
  238. for (j = 0; j < lHeight - 1; j++)
  239. {
  240. for(i = 0; i < lWidth - 1; i++)
  241. {
  242. nBlackPix =pnBinary[lLineBytes * j + i + 1];
  244. if(nBlackPix == n)
  245. {
  246. pnBinary[lLineBytes * j + i + 1] = 0;
  247. }
  249. }
  250. }
  252. }
  254. }
  256. // 存储象素值，输出
  257. for(j = 0; j < lHeight; j++)
  258. {
  259. // 列
  260. for(i = 0; i < lWidth; i++)
  261. {
  262. // 二值图象
  263.     temp = pnBinary[j * lLineBytes + i] ;
  265. // 指向位图i行j列象素的指针
  266. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * j + i;
  268. // 更新源图像
  269. if(temp != 0)
  270. * (lpSrc) = 0;
  271. else
  272. * (lpSrc) = 255;
  273. }
  274. }
  276. delete pnBinary;
  278. return true;
  279. }
  281. /*************************************************************************
  282.  *
  283.  * 函数名称：
  284.  *   DIBMOMENT()
  285.  *
  286.  * 参数:
  287.  *   CDib * pDib        - 指向CDib类的指针
  288.  *
  289.  * 返回值:
  290.  *   BOOL               - 成功返回True，否则返回False。
  291.  *
  292.  * 说明:
  293.  *   该函数计算图象的力矩。
  294.  *
  295.  *************************************************************************/
  296. BOOL DIBMOMENT(CDib *pDib)
  297. {
  298. // 指向源图像的指针
  299. BYTE * lpSrc;
  301. //图象的宽度和高度
  302. LONG    lWidth;
  303. LONG    lHeight;
  305. // 图像每行的字节数
  306. LONG lLineBytes;
  308. //得到图象的宽度和高度
  309. CSize   SizeDim;
  310. SizeDim = pDib->GetDimensions();
  311. lWidth  = SizeDim.cx;
  312. lHeight = SizeDim.cy;
  314. //得到实际的Dib图象存储大小
  315. CSize   SizeRealDim;
  316. SizeRealDim = pDib->GetDibSaveDim();
  318. // 计算图像每行的字节数
  319. lLineBytes = SizeRealDim.cx;
  321. //图像数据的指针
  322. LPBYTE  lpDIBBits = pDib->m_lpImage;
  324. // 图象的矩
  325. long nImageMoment;
  327. // 循环变量
  328. int i,j;
  330. int ip,jq;
  332. // 临时变量
  333. double temp;
  335. nImageMoment = 0;
  337. // 计算一阶矩
  338. ip = jq = 1;
  340. // 力矩的计算
  341. for (j = 0; j < lHeight; j++)
  342. {
  343. for(i = 0; i < lWidth; i++)
  344. {
  345. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  347. temp = pow((double)i,ip)*pow(double(j),jq);
  348. temp = temp * (*lpSrc);
  350. nImageMoment = nImageMoment + (int)temp;
  351. }
  352. }
  354. // 将结果进行输出
  355. CString CView;
  356. CView.Format("图象的力矩为：%d",nImageMoment);
  357. MessageBox(NULL,CView, "计算结果" , MB_ICONINFORMATION | MB_OK);
  359. return true;
  360. }
  362. /*************************************************************************
  363.  *
  364.  * 函数名称：
  365.  *   DIBBARYCENTERMOMENT()
  366.  *
  367.  * 参数:
  368.  *   CDib * pDib        - 指向CDib类的指针
  369.  *
  370.  * 返回值:
  371.  *   BOOL               - 成功返回True，否则返回False。
  372.  *
  373.  * 说明:
  374.  *   该函数计算图象的重心矩。
  375.  *
  376.  *************************************************************************/
  378. BOOL DIBBARYCENTERMOMENT(CDib *pDib)
  379. {
  380. // 指向源图像的指针
  381. BYTE * lpSrc;
  383. //图象的宽度和高度
  384. LONG    lWidth;
  385. LONG    lHeight;
  387. // 图像每行的字节数
  388. LONG lLineBytes;
  390. //得到图象的宽度和高度
  391. CSize   SizeDim;
  392. SizeDim = pDib->GetDimensions();
  393. lWidth  = SizeDim.cx;
  394. lHeight = SizeDim.cy;
  396. //得到实际的Dib图象存储大小
  397. CSize   SizeRealDim;
  398. SizeRealDim = pDib->GetDibSaveDim();
  400. // 计算图像每行的字节数
  401. lLineBytes = SizeRealDim.cx;
  403. //图像数据的指针
  404. LPBYTE  lpDIBBits = pDib->m_lpImage;
  406. // 图象象素值
  407. int  nPixelValue;
  409. // 图象重心矩
  410. long nBarycenterMoment;
  412. // 0次矩m00,x方向的一次矩m01和y方向的一次矩m10
  413. long m00, m10, m01;
  415. // 重心x，y坐标值
  416. int nBarycenterX,nBarycenterY;
  418. // 循环变量
  419. int i,j;
  421. // 临时变量
  422. double temp;
  424. // 赋初值为零
  425. m00 = 0;
  426. m01 = 0;
  427. m10 = 0;
  428. nBarycenterMoment = 0;
  430. // 求0次矩m00,x方向的一次矩m01和y方向的一次矩m10
  431. for (j = 0; j < lHeight; j++)
  432. {
  433. for(i = 0; i < lWidth; i++)
  434. {
  435. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  436. nPixelValue = *lpSrc;
  438. m00 = m00 + nPixelValue;
  440. temp = i * nPixelValue;
  441. m01  = m01 + temp;
  443. temp = j * nPixelValue;
  444. m10  = m10 + temp;
  445. }
  446. }
  448. // 重心x，y坐标值
  449. nBarycenterX = (int)(m01 / m00 + 0.5);
  450. nBarycenterY = (int)(m10 / m00 + 0.5);
  453. // 计算重心矩
  454. for (j = 0; j < lHeight; j++)
  455. {
  456. for(i = 0; i < lWidth; i++)
  457. {
  458. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  459. nPixelValue = *lpSrc;
  461. temp = (i - nBarycenterX) * (j - nBarycenterY);
  463. temp = temp * nPixelValue;
  465. nBarycenterMoment = nBarycenterMoment + (int)temp;
  466. }
  467. }
  469. // 将结果进行输出
  470. CString CView;
  471. CView.Format("图象的重心矩为（%d,%d），重心矩为%d"
  472. ,nBarycenterX,nBarycenterY,nBarycenterMoment);
  473. MessageBox(NULL,CView, "计算结果" , MB_ICONINFORMATION | MB_OK);
  475. return true;
  477. }
  479. /*************************************************************************
  480.  *
  481.  * 函数名称：
  482.  *   DIBSTREETDIS()
  483.  *
  484.  * 参数:
  485.  *   CDib * pDib        - 指向CDib类的指针
  486.  *
  487.  * 返回值:
  488.  *   BOOL               - 成功返回True，否则返回False。
  489.  *
  490.  * 说明:
  491.  *   该函数利用棋盘距离对图象进行变换。
  492.  *
  493.  *************************************************************************/
  495. BOOL DIBSTREETDIS(CDib *pDib)
  496. {
  497. // 指向源图像的指针
  498. BYTE * lpSrc;
  500. //图象的宽度和高度
  501. LONG    lWidth;
  502. LONG    lHeight;
  504. // 图像每行的字节数
  505. LONG lLineBytes;
  507. //得到图象的宽度和高度
  508. CSize   SizeDim;
  509. SizeDim = pDib->GetDimensions();
  510. lWidth  = SizeDim.cx;
  511. lHeight = SizeDim.cy;
  513. //得到实际的Dib图象存储大小
  514. CSize   SizeRealDim;
  515. SizeRealDim = pDib->GetDibSaveDim();
  517. // 计算图像每行的字节数
  518. lLineBytes = SizeRealDim.cx;
  520. //图像数据的指针
  521. LPBYTE  lpDIBBits = pDib->m_lpImage;
  523. // 循环和临时变量
  524. int i,j;
  525. int temp, s;
  527. // 存储象素值的数组
  528. int *pnBinary, *pnStore;
  530. int nImageValue;
  532. pnBinary = new int[lHeight*lLineBytes];
  533. pnStore  = new int[lHeight*lLineBytes];
  535. // 将图象二值化
  536. for (j = 0; j < lHeight; j++)
  537. {
  538. for(i = 0; i < lWidth; i++)
  539. {
  540. // 指向源图像倒数第j行，第i个象素的指针
  541. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  543. // 白色象素为背景，存成0
  544. if(*lpSrc > 200)
  545. {
  546. pnBinary[lLineBytes * j + i] = 0;
  547. pnStore [lLineBytes * j + i] = 0;
  548. }
  549. // 黑象素存成1
  550. else
  551. {
  552. pnBinary[lLineBytes * j + i] = 1;
  553. pnStore [lLineBytes * j + i] = 1;
  554. }
  555. }
  556. }
  558. s = 1;
  560. while(s == 1)
  561. {
  562. s = 0;
  564. // 进行距离的累加
  565. for (j = 1; j < lHeight - 1; j++)
  566. {
  567. for(i = 1; i < lWidth - 1; i++)
  568. {
  569. nImageValue = pnBinary[lLineBytes * j + i];
  571. // 如果是背景，进行下一个循环
  572. if(nImageValue == 0)
  573. continue;
  575. // 如果当前象素值和四周的值一样，象素值增加一
  576. if(nImageValue==pnBinary[lLineBytes * (j-1) + i] && nImageValue==pnBinary[lLineBytes * (j+1) + i])
  577. if(nImageValue==pnBinary[lLineBytes * j + i-1] && nImageValue==pnBinary[lLineBytes * j + i+1])
  578. {
  579. pnStore[lLineBytes * j + i]++;
  580. s=1;
  581. }
  582. }
  583. }
  585. // 在进行下一轮循环前将当前的结果储存
  586. for (j = 0; j < lHeight; j++)
  587. for(i = 1; i < lWidth; i++)
  588. pnBinary[lLineBytes * j + i] = pnStore[lLineBytes * j + i];
  589. }
  591. // 存储象素值，输出
  592. for(j = 0; j < lHeight; j++)
  593. {
  594. // 列
  595. for(i = 0; i < lWidth; i++)
  596. {
  597. // 骨架的象素值
  598.     temp = pnStore[j * lLineBytes + i] ;
  600. // 指向位图i行j列象素的指针
  601. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * j + i;
  603. // 更新源图像
  604. * (lpSrc) = (BYTE)((25 - temp) * 10 + 5);
  605. }
  606. }
  608. delete pnStore;
  609. delete pnBinary;
  611. return true;
  612. }
  614. /*************************************************************************
  615.  *
  616.  * 函数名称：
  617.  *   DIBFREAMEWORK()
  618.  *
  619.  * 参数:
  620.  *   CDib * pDib        - 指向CDib类的指针
  621.  *
  622.  * 返回值:
  623.  *   BOOL               - 成功返回True，否则返回False。
  624.  *
  625.  * 说明:
  626.  *   该函数利用棋盘距离，生成图象的骨架。
  627.  *
  628.  *************************************************************************/
  630. BOOL DIBFREAMEWORK(CDib *pDib)
  631. {
  632. // 指向源图像的指针
  633. BYTE * lpSrc;
  635. //图象的宽度和高度
  636. LONG    lWidth;
  637. LONG    lHeight;
  639. // 图像每行的字节数
  640. LONG lLineBytes;
  642. //得到图象的宽度和高度
  643. CSize   SizeDim;
  644. SizeDim = pDib->GetDimensions();
  645. lWidth  = SizeDim.cx;
  646. lHeight = SizeDim.cy;
  648. //得到实际的Dib图象存储大小
  649. CSize   SizeRealDim;
  650. SizeRealDim = pDib->GetDibSaveDim();
  652. // 计算图像每行的字节数
  653. lLineBytes = SizeRealDim.cx;
  655. //图像数据的指针
  656. LPBYTE  lpDIBBits = pDib->m_lpImage;
  658. // 循环和临时变量
  659. int i,j;
  660. int temp, s;
  662. // 存储象素值的数组
  663. int *pnBinary, *pnStore;
  665. int nImageValue;
  667. pnBinary = new int[lHeight*lLineBytes];
  668. pnStore  = new int[lHeight*lLineBytes];
  670. // 将图象二值化
  671. for (j = 0; j < lHeight; j++)
  672. {
  673. for(i = 0; i < lWidth; i++)
  674. {
  675. // 指向源图像倒数第j行，第i个象素的指针
  676. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  678. // 白色象素为背景，存成0
  679. if(*lpSrc > 200)
  680. {
  681. pnBinary[lLineBytes * j + i] = 0;
  682. pnStore [lLineBytes * j + i] = 0;
  683. }
  684. // 黑象素存成1
  685. else
  686. {
  687. pnBinary[lLineBytes * j + i] = 1;
  688. pnStore [lLineBytes * j + i] = 1;
  689. }
  690. }
  691. }
  693. s = 1;
  695. while(s == 1)
  696. {
  697. s = 0;
  699. // 进行距离的累加
  700. for (j = 1; j < lHeight - 1; j++)
  701. {
  702. for(i = 1; i < lWidth - 1; i++)
  703. {
  704. nImageValue = pnBinary[lLineBytes * j + i];
  706. // 如果是背景，进行下一个循环
  707. if(nImageValue == 0)
  708. continue;
  710. // 如果当前象素值和四周的值一样，象素值增加一
  711. if(nImageValue==pnBinary[lLineBytes * (j-1) + i] && nImageValue==pnBinary[lLineBytes * (j+1) + i])
  712. if(nImageValue==pnBinary[lLineBytes * j + i-1] && nImageValue==pnBinary[lLineBytes * j + i+1])
  713. {
  714. pnStore[lLineBytes * j + i]++;
  715. s=1;
  716. }
  717. }
  718. }
  720. // 在进行下一轮循环前将当前的结果储存
  721. for (j = 0; j < lHeight; j++)
  722. for(i = 1; i < lWidth; i++)
  723. pnBinary[lLineBytes * j + i] = pnStore[lLineBytes * j + i];
  724. }
  726. for (j = 0; j < lHeight; j++)
  727. for(i = 0; i < lWidth; i++)
  728. pnStore[lLineBytes * j + i] = 0;
  730. // 如果当前的象素值比周围的都要高，做为骨架
  731. for (j = 1; j < lHeight - 1; j++)
  732. for(i = 1; i < lWidth - 1; i++)
  733. {
  734. nImageValue = pnBinary[lLineBytes * j + i] + 1;
  736. // 在四连通域进行比较
  737. if(nImageValue!=pnBinary[lLineBytes * (j-1) + i] && nImageValue!=pnBinary[lLineBytes * (j+1) + i])
  738. if(nImageValue!=pnBinary[lLineBytes * j + i-1] && nImageValue!=pnBinary[lLineBytes * j + i+1])
  739. pnStore[lLineBytes * j + i] = pnBinary[lLineBytes * j + i];
  740. }
  743. // 存储象素值，输出
  744. for(j = 0; j < lHeight; j++)
  745. {
  746. // 列
  747. for(i = 0; i < lWidth; i++)
  748. {
  749. // 骨架的象素值
  750.     temp = pnStore[j * lLineBytes + i] ;
  752. // 指向位图i行j列象素的指针
  753. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * j + i;
  755. // 更新源图像，并将象素值进行变换，以便输出
  756. if(temp != 0)
  757. * (lpSrc) = temp;
  758. else
  759. * (lpSrc) = 255;
  760. }
  761. }
  763. delete pnStore;
  764. delete pnBinary;
  766. return true;
  767. }
  769. /*************************************************************************
  770.  *
  771.  * 函数名称：
  772.  *   DIBCHESSBOARDDISRESTORE()
  773.  *
  774.  * 参数:
  775.  *   CDib * pDib        - 指向CDib类的指针
  776.  *
  777.  * 返回值:
  778.  *   BOOL               - 成功返回True，否则返回False。
  779.  *
  780.  * 说明:
  781.  *   该函数利用骨架对原图象进行恢复。
  782.  *
  783.  *************************************************************************/
  784. BOOL DIBCHESSBOARDDISRESTORE(CDib *pDib)
  785. {
  786. // 指向源图像的指针
  787. BYTE * lpSrc;
  789. //图象的宽度和高度
  790. LONG    lWidth;
  791. LONG    lHeight;
  793. // 图像每行的字节数
  794. LONG lLineBytes;
  796. //得到图象的宽度和高度
  797. CSize   SizeDim;
  798. SizeDim = pDib->GetDimensions();
  799. lWidth  = SizeDim.cx;
  800. lHeight = SizeDim.cy;
  802. //得到实际的Dib图象存储大小
  803. CSize   SizeRealDim;
  804. SizeRealDim = pDib->GetDibSaveDim();
  806. // 计算图像每行的字节数
  807. lLineBytes = SizeRealDim.cx;
  809. //图像数据的指针
  810. LPBYTE  lpDIBBits = pDib->m_lpImage;
  812. // 循环变量
  813. int i, j, n, m;
  815. // 临时变量
  816. int temp, s;
  818. // 用来存放象素值的数组
  819. int *pnBinary, *pnStore;
  821. int nImageValue;
  823. pnBinary = new int[lHeight*lLineBytes];
  824. pnStore  = new int[lHeight*lLineBytes];
  826. // 数组赋值
  827. for (j = 0; j < lHeight; j++)
  828. {
  829. for(i = 0; i < lWidth; i++)
  830. {
  831. // 指向源图像倒数第j行，第i个象素的指针
  832. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  834. pnBinary[lLineBytes * j + i] = 0;
  835. if((*lpSrc) != 255)
  836. pnStore [lLineBytes * j + i] = (*lpSrc);
  837. else
  838. pnStore [lLineBytes * j + i] = 0;
  839. }
  840. }
  843. // 进行图象的恢复
  844. for (j = 1; j < lHeight - 1; j++)
  845. {
  846. for(i = 1; i < lWidth - 1; i++)
  847. {
  848. nImageValue = pnStore[lLineBytes * j + i];
  849. if(nImageValue == 0)
  850. continue;
  852. if(nImageValue == 1)
  853. {
  854. pnBinary[lLineBytes * j + i] = 1;
  855. continue;
  856. }
  858. // 如果象素值大于等于2，将以（2×nImageValue）＋1的菱形范围的象素值赋1
  859. s = nImageValue;
  861. // 菱形的主轴
  862. for(m = -s; m <= s; m++)
  863. {
  864. pnBinary[lLineBytes * j + i + m] = 1;
  866. }
  868. // 菱形的上半部分
  869. for(n = -s; n < 0; n++)
  870. for(m = -s - n; m <=s + n; m++)
  871. pnBinary[lLineBytes * (j+n) + i+m] = 1;
  873. // 菱形的下半部分
  874. for(n = 1; n <= s; n++)
  875. for(m = -s + n; m <= s - n; m++)
  876. pnBinary[lLineBytes * (j+n) + i+m] = 1;
  878. }
  879. }
  881. // 存储象素值，输出
  882. for(j = 0; j < lHeight; j++)
  883. {
  884. // 列
  885. for(i = 0; i < lWidth; i++)
  886. {
  887. // 骨架的象素值
  888.     temp = pnBinary[j * lLineBytes + i] ;
  890. // 指向位图i行j列象素的指针
  891. lpSrc = (unsigned char*)lpDIBBits + lLineBytes * j + i;
  893. // 更新源图像
  894. if(temp != 0)
  895. // 黑色象素输出
  896. * (lpSrc) = 0;
  897. else
  898. // 白色象素输出
  899. * (lpSrc) = 255;
  900. }
  901. }
  903. delete pnStore;
  904. delete pnBinary;
  906. return true;
  907. }
  909. /*************************************************************************
  910.  *
  911.  * 函数名称：
  912.  *   DIBOUTLINE()
  913.  *
  914.  * 参数:
  915.  *   CDib * pDib        - 指向CDib类的指针
  916.  *
  917.  * 返回值:
  918.  *   BOOL               - 成功返回True，否则返回False。
  919.  *
  920.  * 说明:
  921.  *   该函数对二值图象进行轮廓检出。
  922.  *
  923.  *************************************************************************
  924.  */
  926. BOOL DIBOUTLINE(CDib *pDib)
  927. {
  929. // 指向源图像的指针
  930. BYTE * lpSrc;
  932. //图象的宽度和高度
  933. LONG    lWidth;
  934. LONG    lHeight;
  936. // 图像每行的字节数
  937. LONG lLineBytes;
  939. //得到图象的宽度和高度
  940. CSize   SizeDim;
  941. SizeDim = pDib->GetDimensions();
  942. lWidth  = SizeDim.cx;
  943. lHeight = SizeDim.cy;
  945. //得到实际的Dib图象存储大小
  946. CSize   SizeRealDim;
  947. SizeRealDim = pDib->GetDibSaveDim();
  949. // 计算图像每行的字节数
  950. lLineBytes = SizeRealDim.cx;
  952. //图像数据的指针
  953. LPBYTE  lpDIBBits = pDib->m_lpImage;
  955. // 循环变量
  956. int i, j;
  958. int nPixelValue;
  960. int n1,n2,n3,n4,n5,n6,n7,n8;
  962. // 用来存放象素值的数组
  963. int *pnBinary;
  965. pnBinary = new int[lHeight*lLineBytes];
  967. // 将图象二值化
  968. for (j = 0; j < lHeight; j++)
  969. {
  970. for(i = 0; i < lWidth; i++)
  971. {
  972. // 指向源图像倒数第j行，第i个象素的指针
  973. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  975. // 白色象素为背景，存成0
  976. if(*lpSrc > 200)
  977. {
  978. pnBinary[lLineBytes * j + i] = 0;
  979. }
  980. // 黑象素存成1
  981. else
  982. {
  983. pnBinary[lLineBytes * j + i] = 1;
  984. }
  985. }
  986. }
  988. for (j = 1; j < lHeight - 1; j++)
  989. {
  990. for(i = 1; i < lWidth - 1; i++)
  991. {
  992. nPixelValue = pnBinary[lLineBytes * j + i];
  993. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  995. // 如果当前象素是白色，进入下一个循环
  996. if(nPixelValue == 0)
  997. {
  998. // 将相应的象素值改成零
  1000. *lpSrc = 255;
  1001. continue;
  1002. }
  1004. // 如果当前象素是黑色
  1005. else
  1006. {
  1007. // 检查周边的8连通域
  1008. n1 = pnBinary[lLineBytes * (j+1) + i + 1];
  1009. n2 = pnBinary[lLineBytes * (j+1) + i - 1];
  1010. n3 = pnBinary[lLineBytes * (j+1) + i];
  1011. n4 = pnBinary[lLineBytes * (j-1)+ i + 1];
  1012. n5 = pnBinary[lLineBytes * (j-1) + i - 1];
  1013. n6 = pnBinary[lLineBytes * (j-1) + i];
  1014. n7 = pnBinary[lLineBytes * j + i + 1];
  1015. n8 = pnBinary[lLineBytes * j + i - 1];
  1017. //如果相邻的八个点都是黑点
  1018. if(n1&&n2&&n3&&n4&&n5&&n6&&n7&&n8 == 1)
  1019. {
  1020. *lpSrc = (unsigned char)255;
  1021. }
  1022. }
  1023. }
  1024. }
  1026. delete pnBinary;
  1028. // 返回
  1029. return TRUE;
  1030. }
  1033. /*************************************************************************
  1034.  *
  1035.  * 函数名称：
  1036.  *   DIBTrace()
  1037.  *
  1038.  * 参数:
  1039.  *   CDib * pDib        - 指向CDib类的指针
  1040.  *
  1041.  * 返回值:
  1042.  *   BOOL               - 成功返回True，否则返回False。
  1043.  *
  1044.  * 说明:
  1045.  * 该函数用于对图像进行轮廓跟踪运算。
  1046.  *
  1047.  *************************************************************************
  1048.  */
  1050. BOOL WINAPI DIBTrace(CDib *pDib)
  1051. {
  1053. // 指向源图像的指针
  1054. BYTE * lpSrc;
  1056. //图象的宽度和高度
  1057. LONG    lWidth;
  1058. LONG    lHeight;
  1060. // 图像每行的字节数
  1061. LONG lLineBytes;
  1063. //得到图象的宽度和高度
  1064. CSize   SizeDim;
  1065. SizeDim = pDib->GetDimensions();
  1066. lWidth  = SizeDim.cx;
  1067. lHeight = SizeDim.cy;
  1069. //得到实际的Dib图象存储大小
  1070. CSize   SizeRealDim;
  1071. SizeRealDim = pDib->GetDibSaveDim();
  1073. // 计算图像每行的字节数
  1074. lLineBytes = SizeRealDim.cx;
  1076. //图像数据的指针
  1077. LPBYTE  lpDIBBits = pDib->m_lpImage;
  1079. //循环变量
  1080. long i;
  1081. long j;
  1083. //像素值
  1084. int nPixelValue;
  1086. //是否找到起始点及回到起始点
  1087. bool bFindStartPoint;
  1089. //是否扫描到一个边界点
  1090. bool bFindPoint;
  1092. // 用来边界起点和所有边界点的数组
  1093. int nStartPointX, nStartPointY;
  1094. int *nCurrPointX, *nCurrPointY;
  1096. // 边界点的数目
  1097. long lNum;
  1099. // 用来存储二值象素的数组
  1100. int *pnBinary;
  1102. //八个方向和起始扫描方向
  1103. int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};
  1104. int BeginDirect;
  1106. // 分配内存
  1107. pnBinary =new int[lLineBytes*lHeight];
  1108. nCurrPointX = new int[lLineBytes*lHeight/4];
  1109. nCurrPointY = new int[lLineBytes*lHeight/4];
  1111. // 将图象二值化
  1112. for (j = 0; j < lHeight; j++)
  1113. {
  1114. for(i = 0; i < lWidth; i++)
  1115. {
  1116. // 指向源图像倒数第j行，第i个象素的指针
  1117. lpSrc = (unsigned char *)lpDIBBits + lLineBytes * j + i;
  1119. // 白色象素为背景，存成0
  1120. if(*lpSrc > 200)
  1121. {
  1122. pnBinary[lLineBytes * j + i] = 0;
  1124. }
  1125. // 黑象素存成1
  1126. else
  1127. {
  1128. pnBinary[lLineBytes * j + i] = 1;
  1129. }
  1131. // 将已经扫描过的象素存成白色背景
  1132. *lpSrc = 255;
  1133. }
  1134. }
  1136. //先找到最左上方的边界点
  1137. bFindStartPoint = false;
  1139. for (j = 0; j < lHeight; j++)
  1140. {
  1141. for(i = 0;i < lWidth ;i++)
  1142. {
  1143. nPixelValue = pnBinary[lLineBytes * j + i];
  1145. if(nPixelValue == 1)
  1146. {
  1147. bFindStartPoint = true;
  1149. // 储存边界起始点
  1150. nStartPointY = j;
  1151. nStartPointX  = i;
  1153. // 跳出循环
  1154. j = lHeight;
  1155. i = lLineBytes ;
  1156. }
  1157. }
  1158. }
  1160. // 没有起始点，跳出
  1161. if(bFindStartPoint == false)
  1162. return false;
  1164. //由于起始点是在左上方，起始扫描沿右侧方向
  1165. BeginDirect = 0;
  1166. //跟踪边界
  1167. bFindStartPoint = false;
  1169. //从初始点开始扫描
  1170. lNum = 0;
  1171. nCurrPointY[0] = nStartPointY;
  1172. nCurrPointX[0] = nStartPointX;
  1174. while(!bFindStartPoint)
  1175. {
  1176. bFindPoint = false;
  1178. while(!bFindPoint)
  1179. {
  1180. nPixelValue = pnBinary[(nCurrPointY[lNum] + Direction[BeginDirect][1])*lLineBytes
  1181. + nCurrPointX[lNum] + Direction[BeginDirect][0]];
  1183. // 找到下一个边界点
  1184. if(nPixelValue == 1)
  1185. {
  1186. bFindPoint = true;
  1188. // 位置存储
  1189. nCurrPointY[lNum+1] = nCurrPointY[lNum] + Direction[BeginDirect][1];
  1190. nCurrPointX[lNum+1] = nCurrPointX[lNum] + Direction[BeginDirect][0];
  1191. lNum ++;
  1193. if(nCurrPointY[lNum] == nStartPointY && nCurrPointX[lNum] == nStartPointX)
  1194. {
  1195. bFindStartPoint = true;
  1196. }
  1198. //扫描的方向逆时针旋转两格
  1199. BeginDirect--;
  1200. if(BeginDirect == -1)
  1201. BeginDirect = 7;
  1202. BeginDirect--;
  1203. if(BeginDirect == -1)
  1204. BeginDirect = 7;
  1205. }
  1206. else
  1207. {
  1208. //扫描方向顺时针旋转一格
  1209. BeginDirect++;
  1210. if(BeginDirect == 8)
  1211. BeginDirect = 0;
  1213. }
  1215. }
  1216. }
  1218. // 存储显示边界点
  1219. for(i = 0; i <= lNum; i++)
  1220. {
  1221. lpSrc  = (unsigned char *)lpDIBBits + nCurrPointY[i] *lLineBytes  + nCurrPointX[i];
  1222. *lpSrc = 0;
  1223. }
  1225. delete pnBinary;
  1227. // 返回
  1228. return TRUE;
  1229. }