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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
edgecontour.cpp
资源名称：vc图像处理比较全面的程序.rar　[点击查看]
上传用户：alisonmail
上传日期：2013-02-28
资源大小：500k
文件大小：38k
源码类别：

图片显示

开发平台：

Visual C++

edgecontour.cpp：源码内容
  1. // ************************************************************************
  2. //  文件名：edgecontour.cpp
  3. //
  4. //  图像边缘与轮廓运算API函数库：
  5. //
  6. //  RobertDIB() - robert边缘检测运算
  7. //  SobelDIB() - sobel边缘检测运算
  8. //  PrewittDIB() - prewitt边缘检测运算
  9. //  KirschDIB() - kirsch边缘检测运算
  10. //  GaussDIB() - gauss边缘检测运算
  11. //  HoughDIB() - 利用Hough变换检测平行直线
  12. //  ContourDIB() - 轮廓提取
  13. //  TraceDIB() - 轮廓跟踪
  14. //  FillDIB() - 种子填充算法1
  15. //  Fill2DIB() - 种子填充算法2
  17. //
  18. // ************************************************************************
  20. #include "stdafx.h"
  21. #include "edgecontour.h"
  22. #include "TemplateTrans.h"
  23. #include "DIBAPI.h"
  25. #include <math.h>
  26. #include <direct.h>
  28. /*************************************************************************
  29.  *
  30.  * 函数名称：
  31.  *   RobertDIB()
  32.  *
  33.  * 参数:
  34.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  35.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  36.  *   LONG  lHeight      - 源图像高度（象素数）
  37.  * 返回值:
  38.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  39.  *
  40.  * 说明:
  41.  * 该函数用Robert边缘检测算子对图像进行边缘检测运算。
  42.  * 
  43.  * 要求目标图像为灰度图像。
  44.  ************************************************************************/
  46. BOOL WINAPI RobertDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  47. {
  49. // 指向源图像的指针
  50. LPSTR lpSrc;
  52. // 指向缓存图像的指针
  53. LPSTR lpDst;
  55. // 指向缓存DIB图像的指针
  56. LPSTR lpNewDIBBits;
  57. HLOCAL hNewDIBBits;
  59. //循环变量
  60. long i;
  61. long j;
  63. //像素值
  64. double result;
  65. unsigned char pixel[4];
  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. //使用水平方向的结构元素进行腐蚀
  85. for(j = lHeight-1; j > 0; j--)
  86. {
  87. for(i = 0;i <lWidth-1; i++)
  88. {
  89. //由于使用2×2的模板，为防止越界，所以不处理最下边和最右边的两列像素
  91. // 指向源图像第j行，第i个象素的指针
  92. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  94. // 指向目标图像第j行，第i个象素的指针
  95. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  97. //取得当前指针处2*2区域的像素值，注意要转换为unsigned char型
  98. pixel[0] = (unsigned char)*lpSrc;
  99. pixel[1] = (unsigned char)*(lpSrc + 1);
  100. pixel[2] = (unsigned char)*(lpSrc - lWidth);
  101. pixel[3] = (unsigned char)*(lpSrc - lWidth + 1);
  103. //计算目标图像中的当前点
  104.  result = sqrt(( pixel[0] - pixel[3] )*( pixel[0] - pixel[3] ) + 
  105.   ( pixel[1] - pixel[2] )*( pixel[1] - pixel[2] ));
  106. *lpDst = (unsigned char)result;
  108. }
  109. }
  111. // 复制腐蚀后的图像
  112. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  114. // 释放内存
  115. LocalUnlock(hNewDIBBits);
  116. LocalFree(hNewDIBBits);
  118. // 返回
  119. return TRUE;
  120. }
  122. /*************************************************************************
  123.  *
  124.  * 函数名称：
  125.  *   SobelDIB()
  126.  *
  127.  * 参数:
  128.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  129.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  130.  *   LONG  lHeight      - 源图像高度（象素数）
  131.  * 返回值:
  132.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  133.  *
  134.  * 说明:
  135.  * 该函数用Sobel边缘检测算子对图像进行边缘检测运算。
  136.  * 
  137.  * 要求目标图像为灰度图像。
  138.  ************************************************************************/
  140. BOOL WINAPI SobelDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  141. {
  143. // 指向缓存图像的指针
  144. LPSTR lpDst1;
  145. LPSTR lpDst2;
  147. // 指向缓存DIB图像的指针
  148. LPSTR lpNewDIBBits1;
  149. HLOCAL hNewDIBBits1;
  150. LPSTR lpNewDIBBits2;
  151. HLOCAL hNewDIBBits2;
  153. //循环变量
  154. long i;
  155. long j;
  157. // 模板高度
  158. int iTempH;
  160. // 模板宽度
  161. int iTempW;
  163. // 模板系数
  164. FLOAT fTempC;
  166. // 模板中心元素X坐标
  167. int iTempMX;
  169. // 模板中心元素Y坐标
  170. int iTempMY;
  172. //模板数组
  173. FLOAT aTemplate[9];
  175. // 暂时分配内存，以保存新图像
  176. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  178. if (hNewDIBBits1 == NULL)
  179. {
  180. // 分配内存失败
  181. return FALSE;
  182. }
  184. // 锁定内存
  185. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  187. // 暂时分配内存，以保存新图像
  188. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  190. if (hNewDIBBits2 == NULL)
  191. {
  192. // 分配内存失败
  193. return FALSE;
  194. }
  196. // 锁定内存
  197. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  199. // 拷贝源图像到缓存图像中
  200. lpDst1 = (char *)lpNewDIBBits1;
  201. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  202. lpDst2 = (char *)lpNewDIBBits2;
  203. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  205. // 设置Sobel模板参数
  206. iTempW = 3;
  207. iTempH = 3;
  208. fTempC = 1.0;
  209. iTempMX = 1;
  210. iTempMY = 1;
  211. aTemplate[0] = -1.0;
  212. aTemplate[1] = -2.0;
  213. aTemplate[2] = -1.0;
  214. aTemplate[3] = 0.0;
  215. aTemplate[4] = 0.0;
  216. aTemplate[5] = 0.0;
  217. aTemplate[6] = 1.0;
  218. aTemplate[7] = 2.0;
  219. aTemplate[8] = 1.0;
  221. // 调用Template()函数
  222. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  223. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  224. {
  225. return FALSE;
  226. }
  228. // 设置Sobel模板参数
  229. aTemplate[0] = -1.0;
  230. aTemplate[1] = 0.0;
  231. aTemplate[2] = 1.0;
  232. aTemplate[3] = -2.0;
  233. aTemplate[4] = 0.0;
  234. aTemplate[5] = 2.0;
  235. aTemplate[6] = -1.0;
  236. aTemplate[7] = 0.0;
  237. aTemplate[8] = 1.0;
  239. // 调用Template()函数
  240. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  241. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  242. {
  243. return FALSE;
  244. }
  246. //求两幅缓存图像的最大值
  247. for(j = 0; j <lHeight; j++)
  248. {
  249. for(i = 0;i <lWidth-1; i++)
  250. {
  252. // 指向缓存图像1倒数第j行，第i个象素的指针
  253. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  255. // 指向缓存图像2倒数第j行，第i个象素的指针
  256. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  258. if(*lpDst2 > *lpDst1)
  259. *lpDst1 = *lpDst2;
  261. }
  262. }
  264. // 复制经过模板运算后的图像到源图像
  265. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  267. // 释放内存
  268. LocalUnlock(hNewDIBBits1);
  269. LocalFree(hNewDIBBits1);
  271. LocalUnlock(hNewDIBBits2);
  272. LocalFree(hNewDIBBits2);
  273. // 返回
  274. return TRUE;
  275. }
  277. /*************************************************************************
  278.  *
  279.  * 函数名称：
  280.  *   PrewittDIB()
  281.  *
  282.  * 参数:
  283.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  284.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  285.  *   LONG  lHeight      - 源图像高度（象素数）
  286.  * 返回值:
  287.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  288.  *
  289.  * 说明:
  290.  * 该函数用Prewitt边缘检测算子对图像进行边缘检测运算。
  291.  * 
  292.  * 要求目标图像为灰度图像。
  293.  ************************************************************************/
  295. BOOL WINAPI PrewittDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  296. {
  298. // 指向缓存图像的指针
  299. LPSTR lpDst1;
  300. LPSTR lpDst2;
  302. // 指向缓存DIB图像的指针
  303. LPSTR lpNewDIBBits1;
  304. HLOCAL hNewDIBBits1;
  305. LPSTR lpNewDIBBits2;
  306. HLOCAL hNewDIBBits2;
  308. //循环变量
  309. long i;
  310. long j;
  312. // 模板高度
  313. int iTempH;
  315. // 模板宽度
  316. int iTempW;
  318. // 模板系数
  319. FLOAT fTempC;
  321. // 模板中心元素X坐标
  322. int iTempMX;
  324. // 模板中心元素Y坐标
  325. int iTempMY;
  327. //模板数组
  328. FLOAT aTemplate[9];
  330. // 暂时分配内存，以保存新图像
  331. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  333. if (hNewDIBBits1 == NULL)
  334. {
  335. // 分配内存失败
  336. return FALSE;
  337. }
  339. // 锁定内存
  340. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  342. // 暂时分配内存，以保存新图像
  343. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  345. if (hNewDIBBits2 == NULL)
  346. {
  347. // 分配内存失败
  348. return FALSE;
  349. }
  351. // 锁定内存
  352. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  354. // 拷贝源图像到缓存图像中
  355. lpDst1 = (char *)lpNewDIBBits1;
  356. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  357. lpDst2 = (char *)lpNewDIBBits2;
  358. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  361. // 设置Prewitt模板参数
  362. iTempW = 3;
  363. iTempH = 3;
  364. fTempC = 1.0;
  365. iTempMX = 1;
  366. iTempMY = 1;
  367. aTemplate[0] = -1.0;
  368. aTemplate[1] = -1.0;
  369. aTemplate[2] = -1.0;
  370. aTemplate[3] = 0.0;
  371. aTemplate[4] = 0.0;
  372. aTemplate[5] = 0.0;
  373. aTemplate[6] = 1.0;
  374. aTemplate[7] = 1.0;
  375. aTemplate[8] = 1.0;
  377. // 调用Template()函数
  378. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  379. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  380. {
  381. return FALSE;
  382. }
  384. // 设置Prewitt模板参数
  385. aTemplate[0] = 1.0;
  386. aTemplate[1] = 0.0;
  387. aTemplate[2] = -1.0;
  388. aTemplate[3] = 1.0;
  389. aTemplate[4] = 0.0;
  390. aTemplate[5] = -1.0;
  391. aTemplate[6] = 1.0;
  392. aTemplate[7] = 0.0;
  393. aTemplate[8] = -1.0;
  395. // 调用Template()函数
  396. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  397. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  398. {
  399. return FALSE;
  400. }
  402. //求两幅缓存图像的最大值
  403. for(j = 0; j <lHeight; j++)
  404. {
  405. for(i = 0;i <lWidth-1; i++)
  406. {
  408. // 指向缓存图像1倒数第j行，第i个象素的指针
  409. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  411. // 指向缓存图像2倒数第j行，第i个象素的指针
  412. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  414. if(*lpDst2 > *lpDst1)
  415. *lpDst1 = *lpDst2;
  417. }
  418. }
  420. // 复制经过模板运算后的图像到源图像
  421. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  423. // 释放内存
  424. LocalUnlock(hNewDIBBits1);
  425. LocalFree(hNewDIBBits1);
  427. LocalUnlock(hNewDIBBits2);
  428. LocalFree(hNewDIBBits2);
  429. // 返回
  430. return TRUE;
  431. }
  433. /*************************************************************************
  434.  *
  435.  * 函数名称：
  436.  *   KirschDIB()
  437.  *
  438.  * 参数:
  439.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  440.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  441.  *   LONG  lHeight      - 源图像高度（象素数）
  442.  * 返回值:
  443.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  444.  *
  445.  * 说明:
  446.  * 该函数用kirsch边缘检测算子对图像进行边缘检测运算。
  447.  * 
  448.  * 要求目标图像为灰度图像。
  449.  ************************************************************************/
  451. BOOL WINAPI KirschDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  452. {
  454. // 指向缓存图像的指针
  455. LPSTR lpDst1;
  456. LPSTR lpDst2;
  458. // 指向缓存DIB图像的指针
  459. LPSTR lpNewDIBBits1;
  460. HLOCAL hNewDIBBits1;
  461. LPSTR lpNewDIBBits2;
  462. HLOCAL hNewDIBBits2;
  464. //循环变量
  465. long i;
  466. long j;
  468. // 模板高度
  469. int iTempH;
  471. // 模板宽度
  472. int iTempW;
  474. // 模板系数
  475. FLOAT fTempC;
  477. // 模板中心元素X坐标
  478. int iTempMX;
  480. // 模板中心元素Y坐标
  481. int iTempMY;
  483. //模板数组
  484. FLOAT aTemplate[9];
  486. // 暂时分配内存，以保存新图像
  487. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  489. if (hNewDIBBits1 == NULL)
  490. {
  491. // 分配内存失败
  492. return FALSE;
  493. }
  495. // 锁定内存
  496. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  498. // 暂时分配内存，以保存新图像
  499. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  501. if (hNewDIBBits2 == NULL)
  502. {
  503. // 分配内存失败
  504. return FALSE;
  505. }
  507. // 锁定内存
  508. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  510. // 拷贝源图像到缓存图像中
  511. lpDst1 = (char *)lpNewDIBBits1;
  512. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  513. lpDst2 = (char *)lpNewDIBBits2;
  514. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  517. // 设置Kirsch模板1参数
  518. iTempW = 3;
  519. iTempH = 3;
  520. fTempC = 1.0;
  521. iTempMX = 1;
  522. iTempMY = 1;
  523. aTemplate[0] = 5.0;
  524. aTemplate[1] = 5.0;
  525. aTemplate[2] = 5.0;
  526. aTemplate[3] = -3.0;
  527. aTemplate[4] = 0.0;
  528. aTemplate[5] = -3.0;
  529. aTemplate[6] = -3.0;
  530. aTemplate[7] = -3.0;
  531. aTemplate[8] = -3.0;
  533. // 调用Template()函数
  534. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  535. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  536. {
  537. return FALSE;
  538. }
  540. // 设置Kirsch模板2参数
  541. aTemplate[0] = -3.0;
  542. aTemplate[1] = 5.0;
  543. aTemplate[2] = 5.0;
  544. aTemplate[3] = -3.0;
  545. aTemplate[4] = 0.0;
  546. aTemplate[5] = 5.0;
  547. aTemplate[6] = -3.0;
  548. aTemplate[7] = -3.0;
  549. aTemplate[8] = -3.0;
  551. // 调用Template()函数
  552. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  553. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  554. {
  555. return FALSE;
  556. }
  558. //求两幅缓存图像的最大值
  559. for(j = 0; j <lHeight; j++)
  560. {
  561. for(i = 0;i <lWidth-1; i++)
  562. {
  564. // 指向缓存图像1倒数第j行，第i个象素的指针
  565. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  567. // 指向缓存图像2倒数第j行，第i个象素的指针
  568. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  570. if(*lpDst2 > *lpDst1)
  571. *lpDst1 = *lpDst2;
  573. }
  574. }
  576. // 拷贝源图像到缓存图像中
  577. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  579. // 设置Kirsch模板3参数
  580. aTemplate[0] = -3.0;
  581. aTemplate[1] = -3.0;
  582. aTemplate[2] = 5.0;
  583. aTemplate[3] = -3.0;
  584. aTemplate[4] = 0.0;
  585. aTemplate[5] = 5.0;
  586. aTemplate[6] = -3.0;
  587. aTemplate[7] = -3.0;
  588. aTemplate[8] = 5.0;
  590. // 调用Template()函数
  591. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  592. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  593. {
  594. return FALSE;
  595. }
  597. //求两幅缓存图像的最大值
  598. for(j = 0; j <lHeight; j++)
  599. {
  600. for(i = 0;i <lWidth-1; i++)
  601. {
  603. // 指向缓存图像1倒数第j行，第i个象素的指针
  604. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  606. // 指向缓存图像2倒数第j行，第i个象素的指针
  607. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  609. if(*lpDst2 > *lpDst1)
  610. *lpDst1 = *lpDst2;
  612. }
  613. }
  615. // 拷贝源图像到缓存图像中
  616. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  618. // 设置Kirsch模板4参数
  619. aTemplate[0] = -3.0;
  620. aTemplate[1] = -3.0;
  621. aTemplate[2] = -3.0;
  622. aTemplate[3] = -3.0;
  623. aTemplate[4] = 0.0;
  624. aTemplate[5] = 5.0;
  625. aTemplate[6] = -3.0;
  626. aTemplate[7] = 5.0;
  627. aTemplate[8] = 5.0;
  629. // 调用Template()函数
  630. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  631. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  632. {
  633. return FALSE;
  634. }
  636. //求两幅缓存图像的最大值
  637. for(j = 0; j <lHeight; j++)
  638. {
  639. for(i = 0;i <lWidth-1; i++)
  640. {
  642. // 指向缓存图像1倒数第j行，第i个象素的指针
  643. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  645. // 指向缓存图像2倒数第j行，第i个象素的指针
  646. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  648. if(*lpDst2 > *lpDst1)
  649. *lpDst1 = *lpDst2;
  651. }
  652. }
  654. // 拷贝源图像到缓存图像中
  655. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  657. // 设置Kirsch模板5参数
  658. aTemplate[0] = -3.0;
  659. aTemplate[1] = -3.0;
  660. aTemplate[2] = -3.0;
  661. aTemplate[3] = -3.0;
  662. aTemplate[4] = 0.0;
  663. aTemplate[5] = -3.0;
  664. aTemplate[6] = 5.0;
  665. aTemplate[7] = 5.0;
  666. aTemplate[8] = 5.0;
  668. // 调用Template()函数
  669. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  670. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  671. {
  672. return FALSE;
  673. }
  675. // 拷贝源图像到缓存图像中
  676. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  677. //求两幅缓存图像的最大值
  678. for(j = 0; j <lHeight; j++)
  679. {
  680. for(i = 0;i <lWidth-1; i++)
  681. {
  683. // 指向缓存图像1倒数第j行，第i个象素的指针
  684. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  686. // 指向缓存图像2倒数第j行，第i个象素的指针
  687. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  689. if(*lpDst2 > *lpDst1)
  690. *lpDst1 = *lpDst2;
  692. }
  693. }
  695. // 拷贝源图像到缓存图像中
  696. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  698. // 设置Kirsch模板6参数
  699. aTemplate[0] = -3.0;
  700. aTemplate[1] = -3.0;
  701. aTemplate[2] = -3.0;
  702. aTemplate[3] = 5.0;
  703. aTemplate[4] = 0.0;
  704. aTemplate[5] = -3.0;
  705. aTemplate[6] = 5.0;
  706. aTemplate[7] = 5.0;
  707. aTemplate[8] = -3.0;
  709. // 调用Template()函数
  710. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  711. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  712. {
  713. return FALSE;
  714. }
  716. //求两幅缓存图像的最大值
  717. for(j = 0; j <lHeight; j++)
  718. {
  719. for(i = 0;i <lWidth-1; i++)
  720. {
  722. // 指向缓存图像1倒数第j行，第i个象素的指针
  723. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  725. // 指向缓存图像2倒数第j行，第i个象素的指针
  726. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  728. if(*lpDst2 > *lpDst1)
  729. *lpDst1 = *lpDst2;
  731. }
  732. }
  734. // 拷贝源图像到缓存图像中
  735. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  737. // 设置Kirsch模板7参数
  738. aTemplate[0] = 5.0;
  739. aTemplate[1] = -3.0;
  740. aTemplate[2] = -3.0;
  741. aTemplate[3] = 5.0;
  742. aTemplate[4] = 0.0;
  743. aTemplate[5] = -3.0;
  744. aTemplate[6] = 5.0;
  745. aTemplate[7] = -3.0;
  746. aTemplate[8] = -3.0;
  748. // 调用Template()函数
  749. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  750. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  751. {
  752. return FALSE;
  753. }
  755. //求两幅缓存图像的最大值
  756. for(j = 0; j <lHeight; j++)
  757. {
  758. for(i = 0;i <lWidth-1; i++)
  759. {
  761. // 指向缓存图像1倒数第j行，第i个象素的指针
  762. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  764. // 指向缓存图像2倒数第j行，第i个象素的指针
  765. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  767. if(*lpDst2 > *lpDst1)
  768. *lpDst1 = *lpDst2;
  770. }
  771. }
  773. // 拷贝源图像到缓存图像中
  774. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  776. // 设置Kirsch模板8参数
  777. aTemplate[0] = 5.0;
  778. aTemplate[1] = 5.0;
  779. aTemplate[2] = -3.0;
  780. aTemplate[3] = 5.0;
  781. aTemplate[4] = 0.0;
  782. aTemplate[5] = -3.0;
  783. aTemplate[6] = -3.0;
  784. aTemplate[7] = -3.0;
  785. aTemplate[8] = -3.0;
  787. // 调用Template()函数
  788. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  789. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  790. {
  791. return FALSE;
  792. }
  794. //求两幅缓存图像的最大值
  795. for(j = 0; j <lHeight; j++)
  796. {
  797. for(i = 0;i <lWidth-1; i++)
  798. {
  800. // 指向缓存图像1倒数第j行，第i个象素的指针
  801. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  803. // 指向缓存图像2倒数第j行，第i个象素的指针
  804. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  806. if(*lpDst2 > *lpDst1)
  807. *lpDst1 = *lpDst2;
  809. }
  810. }
  812. // 复制经过模板运算后的图像到源图像
  813. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  815. // 释放内存
  816. LocalUnlock(hNewDIBBits1);
  817. LocalFree(hNewDIBBits1);
  819. LocalUnlock(hNewDIBBits2);
  820. LocalFree(hNewDIBBits2);
  821. // 返回
  822. return TRUE;
  823. }
  825. /*************************************************************************
  826.  *
  827.  * 函数名称：
  828.  *  GaussDIB()
  829.  *
  830.  * 参数:
  831.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  832.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  833.  *   LONG  lHeight      - 源图像高度（象素数）
  834.  * 返回值:
  835.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  836.  *
  837.  * 说明:
  838.  * 该函数用高斯拉普拉斯边缘检测算子对图像进行边缘检测运算。
  839.  * 
  840.  * 要求目标图像为灰度图像。
  841.  ************************************************************************/
  843. BOOL WINAPI GaussDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  844. {
  846. // 指向缓存图像的指针
  847. LPSTR lpDst1;
  848. LPSTR lpDst2;
  850. // 指向缓存DIB图像的指针
  851. LPSTR lpNewDIBBits1;
  852. HLOCAL hNewDIBBits1;
  853. LPSTR lpNewDIBBits2;
  854. HLOCAL hNewDIBBits2;
  856. // 模板高度
  857. int iTempH;
  859. // 模板宽度
  860. int iTempW;
  862. // 模板系数
  863. FLOAT fTempC;
  865. // 模板中心元素X坐标
  866. int iTempMX;
  868. // 模板中心元素Y坐标
  869. int iTempMY;
  871. //模板数组
  872. FLOAT aTemplate[25];
  874. // 暂时分配内存，以保存新图像
  875. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  877. if (hNewDIBBits1 == NULL)
  878. {
  879. // 分配内存失败
  880. return FALSE;
  881. }
  883. // 锁定内存
  884. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  886. // 暂时分配内存，以保存新图像
  887. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  889. if (hNewDIBBits2 == NULL)
  890. {
  891. // 分配内存失败
  892. return FALSE;
  893. }
  895. // 锁定内存
  896. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  898. // 拷贝源图像到缓存图像中
  899. lpDst1 = (char *)lpNewDIBBits1;
  900. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  901. lpDst2 = (char *)lpNewDIBBits2;
  902. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  905. // 设置Gauss模板参数
  906. iTempW = 5;
  907. iTempH = 5;
  908. fTempC = 1.0;
  909. iTempMX = 3;
  910. iTempMY = 3;
  911. aTemplate[0] = -2.0;
  912. aTemplate[1] = -4.0;
  913. aTemplate[2] = -4.0;
  914. aTemplate[3] = -4.0;
  915. aTemplate[4] = -2.0;
  916. aTemplate[5] = -4.0;
  917. aTemplate[6] = 0.0;
  918. aTemplate[7] = 8.0;
  919. aTemplate[8] = 0.0;
  920. aTemplate[9] = -4.0;
  921. aTemplate[10] = -4.0;
  922. aTemplate[11] = 8.0;
  923. aTemplate[12] = 24.0;
  924. aTemplate[13] = 8.0;
  925. aTemplate[14] = -4.0;
  926. aTemplate[15] = -4.0;
  927. aTemplate[16] = 0.0;
  928. aTemplate[17] = 8.0;
  929. aTemplate[18] = 0.0;
  930. aTemplate[19] = -4.0;
  931. aTemplate[20] = -2.0;
  932. aTemplate[21] = -4.0;
  933. aTemplate[22] = -4.0;
  934. aTemplate[23] = -4.0;
  935. aTemplate[24] = -2.0;
  937. // 调用Template()函数
  938. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  939. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  940. {
  941. return FALSE;
  942. }
  944. // 复制经过模板运算后的图像到源图像
  945. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  947. // 释放内存
  948. LocalUnlock(hNewDIBBits1);
  949. LocalFree(hNewDIBBits1);
  951. LocalUnlock(hNewDIBBits2);
  952. LocalFree(hNewDIBBits2);
  953. // 返回
  954. return TRUE;
  955. }
  957. /*************************************************************************
  958.  *
  959.  * 函数名称：
  960.  *   HoughDIB()
  961.  *
  962.  * 参数:
  963.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  964.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  965.  *   LONG  lHeight      - 源图像高度（象素数）
  966.  * 返回值:
  967.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  968.  *
  969.  * 说明:
  970.  * 该函数用于对检测图像中的平行直线。如果图像中有两条平行的直线，则将这两条平行直线
  971.  * 提取出来。
  972.  * 
  973.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  974.  ************************************************************************/
  976. BOOL WINAPI HoughDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  977. {
  979. // 指向源图像的指针
  980. LPSTR lpSrc;
  982. // 指向缓存图像的指针
  983. LPSTR lpDst;
  985. // 指向变换域的指针
  986. LPSTR   lpTrans;
  988. // 图像每行的字节数
  989. LONG lLineBytes;
  991. // 指向缓存DIB图像的指针
  992. LPSTR lpNewDIBBits;
  993. HLOCAL hNewDIBBits;
  995. //指向变换域的指针
  996. LPSTR lpTransArea;
  997. HLOCAL hTransArea;
  999. //变换域的尺寸
  1000. int iMaxDist;
  1001. int iMaxAngleNumber;
  1003. //变换域的坐标
  1004. int iDist;
  1005. int iAngleNumber;
  1007. //循环变量
  1008. long i;
  1009. long j;
  1011. //像素值
  1012. unsigned char pixel;
  1014. //存储变换域中的两个最大值
  1015. MaxValue MaxValue1;
  1016. MaxValue MaxValue2;
  1018. // 暂时分配内存，以保存新图像
  1019. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  1021. if (hNewDIBBits == NULL)
  1022. {
  1023. // 分配内存失败
  1024. return FALSE;
  1025. }
  1027. // 锁定内存
  1028. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1030. // 初始化新分配的内存，设定初始值为255
  1031. lpDst = (char *)lpNewDIBBits;
  1032. memset(lpDst, (BYTE)255, lWidth * lHeight);
  1034. //计算变换域的尺寸
  1035. //最大距离
  1036. iMaxDist = (int) sqrt(lWidth*lWidth + lHeight*lHeight);
  1038. //角度从0－180，每格2度
  1039. iMaxAngleNumber = 90;
  1041. //为变换域分配内存
  1042. hTransArea = LocalAlloc(LHND, lWidth * lHeight * sizeof(int));
  1044. if (hNewDIBBits == NULL)
  1045. {
  1046. // 分配内存失败
  1047. return FALSE;
  1048. }
  1050. // 锁定内存
  1051. lpTransArea = (char * )LocalLock(hTransArea);
  1053. // 初始化新分配的内存，设定初始值为0
  1054. lpTrans = (char *)lpTransArea;
  1055. memset(lpTrans, 0, lWidth * lHeight * sizeof(int));
  1057. // 计算图像每行的字节数
  1058. lLineBytes = WIDTHBYTES(lWidth * 8);
  1060. for(j = 0; j <lHeight; j++)
  1061. {
  1062. for(i = 0;i <lWidth; i++)
  1063. {
  1065. // 指向源图像倒数第j行，第i个象素的指针
  1066. lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
  1068. //取得当前指针处的像素值，注意要转换为unsigned char型
  1069. pixel = (unsigned char)*lpSrc;
  1071. //目标图像中含有0和255外的其它灰度值
  1072. if(pixel != 255 && *lpSrc != 0)
  1073. return FALSE;
  1075. //如果是黑点，则在变换域的对应各点上加1
  1076. if(pixel == 0)
  1077. {
  1078. //注意步长是2度
  1079. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1080. {
  1081. iDist = (int) fabs(i*cos(iAngleNumber*2*pi/180.0) + 
  1082. j*sin(iAngleNumber*2*pi/180.0));
  1084. //变换域的对应点上加1
  1085. *(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) = 
  1086. *(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) +1;
  1087. }
  1088. }
  1090. }
  1091. }
  1093. //找到变换域中的两个最大值点
  1094. MaxValue1.Value=0;
  1095. MaxValue2.Value=0;
  1097. //找到第一个最大值点
  1098. for (iDist=0; iDist<iMaxDist;iDist++)
  1099. {
  1100. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1101. {
  1102. if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue1.Value)
  1103. {
  1104. MaxValue1.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
  1105. MaxValue1.Dist = iDist;
  1106. MaxValue1.AngleNumber = iAngleNumber;
  1107. }
  1109. }
  1110. }
  1112. //将第一个最大值点附近清零
  1113. for (iDist = -9;iDist < 10;iDist++)
  1114. {
  1115. for(iAngleNumber=-1; iAngleNumber<2; iAngleNumber++)
  1116. {
  1117. if(iDist+MaxValue1.Dist>=0 && iDist+MaxValue1.Dist<iMaxDist 
  1118. && iAngleNumber+MaxValue1.AngleNumber>=0 && iAngleNumber+MaxValue1.AngleNumber<=iMaxAngleNumber)
  1119. {
  1120. *(lpTransArea+(iDist+MaxValue1.Dist)*iMaxAngleNumber+
  1121. (iAngleNumber+MaxValue1.AngleNumber))=0;
  1122. }
  1123. }
  1124. }
  1126. //找到第二个最大值点
  1127. for (iDist=0; iDist<iMaxDist;iDist++)
  1128. {
  1129. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1130. {
  1131. if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue2.Value)
  1132. {
  1133. MaxValue2.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
  1134. MaxValue2.Dist = iDist;
  1135. MaxValue2.AngleNumber = iAngleNumber;
  1136. }
  1138. }
  1139. }
  1142. //判断两直线是否平行
  1143. if(abs(MaxValue1.AngleNumber-MaxValue2.AngleNumber)<=2)
  1144. {
  1145. //两直线平行，在缓存图像中重绘这两条直线
  1146. for(j = 0; j <lHeight; j++)
  1147. {
  1148. for(i = 0;i <lWidth; i++)
  1149. {
  1151. // 指向缓存图像倒数第j行，第i个象素的指针
  1152. lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
  1154. //如果该点在某一条平行直线上，则在缓存图像上将该点赋为黑
  1156. //在第一条直线上
  1157. iDist = (int) fabs(i*cos(MaxValue1.AngleNumber*2*pi/180.0) + 
  1158. j*sin(MaxValue1.AngleNumber*2*pi/180.0));
  1159. if (iDist == MaxValue1.Dist)
  1160. *lpDst = (unsigned char)0;
  1162. //在第二条直线上
  1163. iDist = (int) fabs(i*cos(MaxValue2.AngleNumber*2*pi/180.0) + 
  1164. j*sin(MaxValue2.AngleNumber*2*pi/180.0));
  1165. if (iDist == MaxValue2.Dist)
  1166. *lpDst = (unsigned char)0;
  1167. }
  1168. }
  1169. }
  1171. // 复制腐蚀后的图像
  1172. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1174. // 释放内存
  1175. LocalUnlock(hNewDIBBits);
  1176. LocalFree(hNewDIBBits);
  1178. // 释放内存
  1179. LocalUnlock(hTransArea);
  1180. LocalFree(hTransArea);
  1182. // 返回
  1183. return TRUE;
  1185. }
  1187. /*************************************************************************
  1188.  *
  1189.  * 函数名称：
  1190.  *   Fill2DIB()
  1191.  *
  1192.  * 参数:
  1193.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1194.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1195.  *   LONG  lHeight      - 源图像高度（象素数）
  1196.  * 返回值:
  1197.  *   BOOL               - 种子填充成功返回TRUE，否则返回FALSE。
  1198.  *
  1199.  * 说明:
  1200.  * 该函数用于对图像进行种子填充运算。
  1201.  * 
  1202.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1203.  ************************************************************************/
  1205. BOOL WINAPI Fill2DIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1206. {
  1208. // 指向源图像的指针
  1209. LPSTR lpSrc;
  1211. //循环变量
  1212. long i;
  1214. //像素值
  1215. unsigned char pixel;
  1217. //左右边界像素位置
  1218. int xl,xr;
  1220. //是否已填充至边界
  1221. BOOL bFilll,bFillr;
  1223. //种子堆栈及指针
  1224. Seed Seeds[10];
  1225. int StackPoint;
  1227. //当前像素位置
  1228. int iCurrentPixelx,iCurrentPixely;
  1229. int iBufferPixelx,iBufferPixely;
  1231. //初始化种子
  1232. Seeds[1].Height = lHeight / 2;
  1233. Seeds[1].Width = lWidth / 2;
  1234. StackPoint = 1;
  1236. while( StackPoint != 0)
  1237. {
  1238. //取出种子
  1239. iCurrentPixelx = Seeds[StackPoint].Width;
  1240. iCurrentPixely = Seeds[StackPoint].Height;
  1241. StackPoint--;
  1242. // if(Seed2.Height== 75)
  1243. // {
  1244. // return true;
  1245. // i++;
  1246. // }
  1247. bFilll = true;
  1248. bFillr = true;
  1249. //填充种子所在的行
  1250. //保存种子像素的位置
  1251. iBufferPixelx = iCurrentPixelx;
  1252. iBufferPixely = iCurrentPixely;
  1253. //先向左填充
  1254. while(bFilll)
  1255. {
  1256. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1257. //取得当前指针处的像素值，注意要转换为unsigned char型
  1258. pixel = (unsigned char)*lpSrc;
  1260. //目标图像中含有0和255外的其它灰度值
  1261. if(pixel != 255 && pixel != 0)
  1262. return FALSE;
  1263. //遇到边界
  1264. if(pixel == 0)
  1265. {
  1266. bFilll = false;
  1267. xl=iCurrentPixelx+1;
  1268. }
  1269. else
  1270. {
  1271. *lpSrc = (unsigned char)0;
  1272. iCurrentPixelx--;
  1273. //防止越界
  1274. if(iCurrentPixelx<0)
  1275. {
  1276. bFilll = false;
  1277. iCurrentPixelx = 0;
  1278. xl = 0; 
  1279. }
  1280. }
  1281. }
  1282. //再向右填充
  1283. //取回种子像素的位置
  1284. iCurrentPixelx = iBufferPixelx+1;
  1285. if(iCurrentPixelx>lWidth)
  1286. {
  1287. bFillr = false;
  1288. iCurrentPixelx = lWidth;
  1289. xr = lWidth; 
  1290. }
  1291. iCurrentPixely = iBufferPixely;
  1292. while(bFillr)
  1293. {
  1294. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1295. //取得当前指针处的像素值，注意要转换为unsigned char型
  1296. pixel = (unsigned char)*lpSrc;
  1298. //目标图像中含有0和255外的其它灰度值
  1299. if(pixel != 255 && pixel != 0)
  1300. return FALSE;
  1301. //遇到边界
  1302. if(pixel == 0)
  1303. {
  1304. bFillr = false;
  1305. xr=iCurrentPixelx-1;
  1306. }
  1307. else
  1308. {
  1309. *lpSrc = (unsigned char)0;
  1310. iCurrentPixelx++;
  1311. //防止越界
  1312. if(iCurrentPixelx>lWidth)
  1313. {
  1314. bFillr = false;
  1315. iCurrentPixelx = lWidth;
  1316. xr = lWidth; 
  1317. }
  1318. }
  1319. }
  1320. //上、下两条扫描线是否全为边界象素或已填充过
  1321. //先看上面的扫描线
  1322. iCurrentPixely--;
  1323. if(iCurrentPixely < 0)
  1324. {
  1325. iCurrentPixely = 0;
  1326. }
  1327. for (i = xr; i>= xl;i--)
  1328. {
  1329. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + i;
  1330. //取得当前指针处的像素值，注意要转换为unsigned char型
  1331. pixel = (unsigned char)*lpSrc;
  1333. //有未填充的像素，将新的种子压入堆栈
  1334. if (pixel == 255)
  1335. {
  1336. StackPoint++;
  1337. Seeds[StackPoint].Height = iCurrentPixely;
  1338. Seeds[StackPoint].Width = i;
  1339. break;
  1340. }
  1341. }
  1342. //再看下面的扫描线
  1343. iCurrentPixely+=2;
  1344. if(iCurrentPixely > lHeight)
  1345. {
  1346. iCurrentPixely = lHeight;
  1347. }
  1348. for (i = xr; i>= xl;i--)
  1349. {
  1350. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + i;
  1351. //取得当前指针处的像素值，注意要转换为unsigned char型
  1352. pixel = (unsigned char)*lpSrc;
  1354. //有未填充的像素，将新的种子压入堆栈
  1355. if (pixel == 255)
  1356. {
  1357. StackPoint++;
  1358. Seeds[StackPoint].Height = iCurrentPixely;
  1359. Seeds[StackPoint].Width = i;
  1360. break;
  1361. }
  1362. }
  1365. }
  1367. // 返回
  1368. return TRUE;
  1369. }
  1371. /*************************************************************************
  1372.  *
  1373.  * 函数名称：
  1374.  *   FillDIB()
  1375.  *
  1376.  * 参数:
  1377.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1378.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1379.  *   LONG  lHeight      - 源图像高度（象素数）
  1380.  * 返回值:
  1381.  *   BOOL               - 种子填充成功返回TRUE，否则返回FALSE。
  1382.  *
  1383.  * 说明:
  1384.  * 该函数用于对图像进行种子填充运算。
  1385.  * 
  1386.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1387.  ************************************************************************/
  1389. BOOL WINAPI FillDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1390. {
  1392. // 指向源图像的指针
  1393. LPSTR lpSrc;
  1395. //像素值
  1396. unsigned char pixel;
  1398. //种子堆栈及指针
  1399. Seed *Seeds;
  1400. int StackPoint;
  1402. //当前像素位置
  1403. int iCurrentPixelx,iCurrentPixely;
  1405. //初始化种子
  1406. Seeds = new Seed[lWidth*lHeight];
  1407. Seeds[1].Height = lHeight / 2;
  1408. Seeds[1].Width = lWidth / 2;
  1409. StackPoint = 1;
  1411. while( StackPoint != 0)
  1412. {
  1413. //取出种子
  1414. iCurrentPixelx = Seeds[StackPoint].Width;
  1415. iCurrentPixely = Seeds[StackPoint].Height;
  1416. StackPoint--;
  1418. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1419. //取得当前指针处的像素值，注意要转换为unsigned char型
  1420. pixel = (unsigned char)*lpSrc;
  1422. //目标图像中含有0和255外的其它灰度值
  1423. if(pixel != 255 && pixel != 0)
  1424. return FALSE;
  1426. //将当前点涂黑
  1427. *lpSrc = (unsigned char)0;
  1429. //判断左面的点，如果为白，则压入堆栈
  1430. //注意防止越界
  1431. if(iCurrentPixelx > 0)
  1432. {
  1433. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx - 1;
  1434. //取得当前指针处的像素值，注意要转换为unsigned char型
  1435. pixel = (unsigned char)*lpSrc;
  1436. if (pixel == 255)
  1437. {
  1438. StackPoint++;
  1439. Seeds[StackPoint].Height = iCurrentPixely;
  1440. Seeds[StackPoint].Width = iCurrentPixelx - 1;
  1441. }
  1442. //目标图像中含有0和255外的其它灰度值
  1443. if(pixel != 255 && pixel != 0)
  1444. return FALSE;
  1445. }
  1447. //判断上面的点，如果为白，则压入堆栈
  1448. //注意防止越界
  1449. if(iCurrentPixely < lHeight - 1)
  1450. {
  1451. lpSrc = (char *)lpDIBBits + lWidth * (iCurrentPixely + 1) + iCurrentPixelx;
  1452. //取得当前指针处的像素值，注意要转换为unsigned char型
  1453. pixel = (unsigned char)*lpSrc;
  1454. if (pixel == 255)
  1455. {
  1456. StackPoint++;
  1457. Seeds[StackPoint].Height = iCurrentPixely + 1;
  1458. Seeds[StackPoint].Width = iCurrentPixelx;
  1459. }
  1460. //目标图像中含有0和255外的其它灰度值
  1461. if(pixel != 255 && pixel != 0)
  1462. return FALSE;
  1463. }
  1465. //判断右面的点，如果为白，则压入堆栈
  1466. //注意防止越界
  1467. if(iCurrentPixelx < lWidth - 1)
  1468. {
  1469. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx + 1;
  1470. //取得当前指针处的像素值，注意要转换为unsigned char型
  1471. pixel = (unsigned char)*lpSrc;
  1472. if (pixel == 255)
  1473. {
  1474. StackPoint++;
  1475. Seeds[StackPoint].Height = iCurrentPixely;
  1476. Seeds[StackPoint].Width = iCurrentPixelx + 1;
  1477. }
  1478. //目标图像中含有0和255外的其它灰度值
  1479. if(pixel != 255 && pixel != 0)
  1480. return FALSE;
  1481. }
  1483. //判断下面的点，如果为白，则压入堆栈
  1484. //注意防止越界
  1485. if(iCurrentPixely > 0)
  1486. {
  1487. lpSrc = (char *)lpDIBBits + lWidth * (iCurrentPixely - 1) + iCurrentPixelx;
  1488. //取得当前指针处的像素值，注意要转换为unsigned char型
  1489. pixel = (unsigned char)*lpSrc;
  1490. if (pixel == 255)
  1491. {
  1492. StackPoint++;
  1493. Seeds[StackPoint].Height = iCurrentPixely - 1;
  1494. Seeds[StackPoint].Width = iCurrentPixelx;
  1495. }
  1496. //目标图像中含有0和255外的其它灰度值
  1497. if(pixel != 255 && pixel != 0)
  1498. return FALSE;
  1499. }
  1500. }
  1502. //释放堆栈
  1503. delete Seeds;
  1504. // 返回
  1505. return TRUE;
  1506. }
  1508. /*************************************************************************
  1509.  *
  1510.  * 函数名称：
  1511.  *   ContourDIB()
  1512.  *
  1513.  * 参数:
  1514.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1515.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1516.  *   LONG  lHeight      - 源图像高度（象素数）
  1517.  * 返回值:
  1518.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  1519.  *
  1520.  * 说明:
  1521.  * 该函数用于对图像进行轮廓提取运算。
  1522.  * 
  1523.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1524.  ************************************************************************/
  1526. BOOL WINAPI ContourDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1527. {
  1529. // 指向源图像的指针
  1530. LPSTR lpSrc;
  1532. // 指向缓存图像的指针
  1533. LPSTR lpDst;
  1535. // 指向缓存DIB图像的指针
  1536. LPSTR lpNewDIBBits;
  1537. HLOCAL hNewDIBBits;
  1539. //循环变量
  1540. long i;
  1541. long j;
  1542. unsigned char n,e,s,w,ne,se,nw,sw;
  1544. //像素值
  1545. unsigned char pixel;
  1547. // 暂时分配内存，以保存新图像
  1548. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  1550. if (hNewDIBBits == NULL)
  1551. {
  1552. // 分配内存失败
  1553. return FALSE;
  1554. }
  1556. // 锁定内存
  1557. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1559. // 初始化新分配的内存，设定初始值为255
  1560. lpDst = (char *)lpNewDIBBits;
  1561. memset(lpDst, (BYTE)255, lWidth * lHeight);
  1562. for(j = 1; j <lHeight-1; j++)
  1563. {
  1564. for(i = 1;i <lWidth-1; i++)
  1565. {
  1567. // 指向源图像倒数第j行，第i个象素的指针
  1568. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  1570. // 指向目标图像倒数第j行，第i个象素的指针
  1571. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  1573. //取得当前指针处的像素值，注意要转换为unsigned char型
  1574. pixel = (unsigned char)*lpSrc;
  1576. //目标图像中含有0和255外的其它灰度值
  1577. // if(pixel != 255 && pixel != 0)
  1578. // return FALSE;
  1579. if(pixel == 0)
  1580. {
  1581. *lpDst = (unsigned char)0;
  1582. nw = (unsigned char)*(lpSrc + lWidth -1);
  1583. n  = (unsigned char)*(lpSrc + lWidth );
  1584. ne = (unsigned char)*(lpSrc + lWidth +1);
  1585. w = (unsigned char)*(lpSrc -1);
  1586. e = (unsigned char)*(lpSrc +1);
  1587. sw = (unsigned char)*(lpSrc - lWidth -1);
  1588. s  = (unsigned char)*(lpSrc - lWidth );
  1589. se = (unsigned char)*(lpSrc - lWidth +1);
  1590. //如果相邻的八个点都是黑点
  1591. if(nw+n+ne+w+e+sw+s+se==0)
  1592. {
  1593. *lpDst = (unsigned char)255;
  1594. }
  1595. }
  1596. }
  1597. }
  1599. // 复制腐蚀后的图像
  1600. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1602. // 释放内存
  1603. LocalUnlock(hNewDIBBits);
  1604. LocalFree(hNewDIBBits);
  1606. // 返回
  1607. return TRUE;
  1608. }
  1610. /*************************************************************************
  1611.  *
  1612.  * 函数名称：
  1613.  *   TraceDIB()
  1614.  *
  1615.  * 参数:
  1616.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1617.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1618.  *   LONG  lHeight      - 源图像高度（象素数）
  1619.  * 返回值:
  1620.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  1621.  *
  1622.  * 说明:
  1623.  * 该函数用于对图像进行轮廓跟踪运算。
  1624.  * 
  1625.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1626.  ************************************************************************/
  1628. BOOL WINAPI TraceDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1629. {
  1631. // 指向源图像的指针
  1632. LPSTR lpSrc;
  1634. // 指向缓存图像的指针
  1635. LPSTR lpDst;
  1637. // 指向缓存DIB图像的指针
  1638. LPSTR lpNewDIBBits;
  1639. HLOCAL hNewDIBBits;
  1641. // 图像每行的字节数
  1642. LONG lLineBytes;
  1644. //循环变量
  1645. long i;
  1646. long j;
  1648. //像素值
  1649. unsigned char pixel;
  1651. //是否找到起始点及回到起始点
  1652. bool bFindStartPoint;
  1654. //是否扫描到一个边界点
  1655. bool bFindPoint;
  1657. //起始边界点与当前边界点
  1658. Point StartPoint,CurrentPoint;
  1660. //八个方向和起始扫描方向
  1661. int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};
  1662. int BeginDirect;
  1664. // 计算图像每行的字节数
  1665. lLineBytes = WIDTHBYTES(lWidth * 8);
  1667. // 暂时分配内存，以保存新图像
  1668. hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
  1670. if (hNewDIBBits == NULL)
  1671. {
  1672. // 分配内存失败
  1673. return FALSE;
  1674. }
  1676. // 锁定内存
  1677. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1679. // 初始化新分配的内存，设定初始值为255
  1680. lpDst = (char *)lpNewDIBBits;
  1681. memset(lpDst, (BYTE)255, lLineBytes * lHeight);
  1683. //先找到最左上方的边界点
  1684. bFindStartPoint = false;
  1685. for (j = 0;j < lHeight && !bFindStartPoint;j++)
  1686. {
  1687. for(i = 0;i < lWidth && !bFindStartPoint;i++)
  1688. {
  1689. // 指向源图像倒数第j行，第i个象素的指针
  1690. lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
  1692. //取得当前指针处的像素值，注意要转换为unsigned char型
  1693. pixel = (unsigned char)*lpSrc;
  1695. if(pixel == 0)
  1696. {
  1697. bFindStartPoint = true;
  1699. StartPoint.Height = j;
  1700. StartPoint.Width = i;
  1702. // 指向目标图像倒数第j行，第i个象素的指针
  1703. lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
  1704. *lpDst = (unsigned char)0;
  1705. }
  1706. }
  1707. }
  1709. //由于起始点是在左下方，故起始扫描沿左上方向
  1710. BeginDirect = 0;
  1711. //跟踪边界
  1712. bFindStartPoint = false;
  1713. //从初始点开始扫描
  1714. CurrentPoint.Height = StartPoint.Height;
  1715. CurrentPoint.Width = StartPoint.Width;
  1716. while(!bFindStartPoint)
  1717. {
  1718. bFindPoint = false;
  1719. while(!bFindPoint)
  1720. {
  1721. //沿扫描方向查看一个像素
  1722. lpSrc = (char *)lpDIBBits + lLineBytes * ( CurrentPoint.Height + Direction[BeginDirect][1])
  1723. + (CurrentPoint.Width + Direction[BeginDirect][0]);
  1724. pixel = (unsigned char)*lpSrc;
  1725. if(pixel == 0)
  1726. {
  1727. bFindPoint = true;
  1728. CurrentPoint.Height = CurrentPoint.Height + Direction[BeginDirect][1];
  1729. CurrentPoint.Width = CurrentPoint.Width + Direction[BeginDirect][0];
  1730. if(CurrentPoint.Height == StartPoint.Height && CurrentPoint.Width == StartPoint.Width)
  1731. {
  1732. bFindStartPoint = true;
  1733. }
  1734. lpDst = (char *)lpNewDIBBits + lLineBytes * CurrentPoint.Height + CurrentPoint.Width;
  1735. *lpDst = (unsigned char)0;
  1736. //扫描的方向逆时针旋转两格
  1737. BeginDirect--;
  1738. if(BeginDirect == -1)
  1739. BeginDirect = 7;
  1740. BeginDirect--;
  1741. if(BeginDirect == -1)
  1742. BeginDirect = 7;
  1743. }
  1744. else
  1745. {
  1746. //扫描方向顺时针旋转一格
  1747. BeginDirect++;
  1748. if(BeginDirect == 8)
  1749. BeginDirect = 0;
  1751. }
  1753. }
  1754. }
  1756. // 复制腐蚀后的图像
  1757. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1759. // 释放内存
  1760. LocalUnlock(hNewDIBBits);
  1761. LocalFree(hNewDIBBits);
  1763. // 返回
  1764. return TRUE;
  1765. }