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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
edgecontour.cpp
资源名称：车牌定位系统程序.zip　[点击查看]
上传用户：renhuadsj
上传日期：2008-11-19
资源大小：1466k
文件大小：42k
源码类别：

图形图象

开发平台：

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. //  spDIB()         - 水平   
  19. //  czDIB()         - 垂直 
  22. //
  23. // ************************************************************************
  25. #include "stdafx.h"
  26. #include "edgecontour.h"
  27. #include "TemplateTrans.h"
  28. #include "DIBAPI.h"
  30. #include <math.h>
  31. #include <direct.h>
  33. /*************************************************************************
  34.  *
  35.  * 函数名称：
  36.  *   RobertDIB()
  37.  *
  38.  * 参数:
  39.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  40.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  41.  *   LONG  lHeight      - 源图像高度（象素数）
  42.  * 返回值:
  43.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  44.  *
  45.  * 说明:
  46.  * 该函数用Robert边缘检测算子对图像进行边缘检测运算。
  47.  * 
  48.  * 要求目标图像为灰度图像。
  49.  ************************************************************************/
  51. BOOL WINAPI RobertDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  52. {
  54. // 指向源图像的指针
  55. LPSTR lpSrc;
  57. // 指向缓存图像的指针
  58. LPSTR lpDst;
  60. // 指向缓存DIB图像的指针
  61. LPSTR lpNewDIBBits;
  62. HLOCAL hNewDIBBits;
  64. //循环变量
  65. long i;
  66. long j;
  68. //像素值
  69. double result;
  70. unsigned char pixel[4];
  72. // 暂时分配内存，以保存新图像
  73. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  75. if (hNewDIBBits == NULL)
  76. {
  77. // 分配内存失败
  78. return FALSE;
  79. }
  81. // 锁定内存
  82. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  84. // 初始化新分配的内存，设定初始值为255
  85. lpDst = (char *)lpNewDIBBits;
  86. memset(lpDst, (BYTE)255, lWidth * lHeight);
  89. //使用水平方向的结构元素进行腐蚀
  90. for(j = lHeight-1; j > 0; j--)
  91. {
  92. for(i = 0;i <lWidth-1; i++)
  93. {
  94. //由于使用2×2的模板，为防止越界，所以不处理最下边和最右边的两列像素
  96. // 指向源图像第j行，第i个象素的指针
  97. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  99. // 指向目标图像第j行，第i个象素的指针
  100. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  102. //取得当前指针处2*2区域的像素值，注意要转换为unsigned char型
  103. pixel[0] = (unsigned char)*lpSrc;
  104. pixel[1] = (unsigned char)*(lpSrc + 1);
  105. pixel[2] = (unsigned char)*(lpSrc - lWidth);
  106. pixel[3] = (unsigned char)*(lpSrc - lWidth + 1);
  108. //计算目标图像中的当前点
  109.  result = sqrt(( pixel[0] - pixel[3] )*( pixel[0] - pixel[3] ) + 
  110.   ( pixel[1] - pixel[2] )*( pixel[1] - pixel[2] ));
  111. *lpDst = (unsigned char)result;
  113. }
  114. }
  116. // 复制腐蚀后的图像
  117. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  119. // 释放内存
  120. LocalUnlock(hNewDIBBits);
  121. LocalFree(hNewDIBBits);
  123. // 返回
  124. return TRUE;
  125. }
  127. /*************************************************************************
  128.  *
  129.  * 函数名称：
  130.  *   SobelDIB()
  131.  *
  132.  * 参数:
  133.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  134.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  135.  *   LONG  lHeight      - 源图像高度（象素数）
  136.  * 返回值:
  137.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  138.  *
  139.  * 说明:
  140.  * 该函数用Sobel边缘检测算子对图像进行边缘检测运算。
  141.  * 
  142.  * 要求目标图像为灰度图像。
  143.  ************************************************************************/
  145. BOOL WINAPI SobelDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  146. {
  148. // 指向缓存图像的指针
  149. LPSTR lpDst1;
  150. LPSTR lpDst2;
  152. // 指向缓存DIB图像的指针
  153. LPSTR lpNewDIBBits1;
  154. HLOCAL hNewDIBBits1;
  155. LPSTR lpNewDIBBits2;
  156. HLOCAL hNewDIBBits2;
  158. //循环变量
  159. long i;
  160. long j;
  162. // 模板高度
  163. int iTempH;
  165. // 模板宽度
  166. int iTempW;
  168. // 模板系数
  169. FLOAT fTempC;
  171. // 模板中心元素X坐标
  172. int iTempMX;
  174. // 模板中心元素Y坐标
  175. int iTempMY;
  177. //模板数组
  178. FLOAT aTemplate[9];
  180. // 暂时分配内存，以保存新图像
  181. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  183. if (hNewDIBBits1 == NULL)
  184. {
  185. // 分配内存失败
  186. return FALSE;
  187. }
  189. // 锁定内存
  190. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  192. // 暂时分配内存，以保存新图像
  193. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  195. if (hNewDIBBits2 == NULL)
  196. {
  197. // 分配内存失败
  198. return FALSE;
  199. }
  201. // 锁定内存
  202. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  204. // 拷贝源图像到缓存图像中
  205. lpDst1 = (char *)lpNewDIBBits1;
  206. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  207. lpDst2 = (char *)lpNewDIBBits2;
  208. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  210. // 设置Sobel模板参数
  211. iTempW = 3;
  212. iTempH = 3;
  213. fTempC = 1.0;
  214. iTempMX = 1;
  215. iTempMY = 1;
  216. aTemplate[0] = -1.0;
  217. aTemplate[1] = -2.0;
  218. aTemplate[2] = -1.0;
  219. aTemplate[3] = 0.0;
  220. aTemplate[4] = 0.0;
  221. aTemplate[5] = 0.0;
  222. aTemplate[6] = 1.0;
  223. aTemplate[7] = 2.0;
  224. aTemplate[8] = 1.0;
  226. // 调用Template()函数
  227. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  228. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  229. {
  230. return FALSE;
  231. }
  233. // 设置Sobel模板参数
  234. aTemplate[0] = -1.0;
  235. aTemplate[1] = 0.0;
  236. aTemplate[2] = 1.0;
  237. aTemplate[3] = -2.0;
  238. aTemplate[4] = 0.0;
  239. aTemplate[5] = 2.0;
  240. aTemplate[6] = -1.0;
  241. aTemplate[7] = 0.0;
  242. aTemplate[8] = 1.0;
  244. // 调用Template()函数
  245. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  246. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  247. {
  248. return FALSE;
  249. }
  251. //求两幅缓存图像的最大值
  252. for(j = 0; j <lHeight; j++)
  253. {
  254. for(i = 0;i <lWidth-1; i++)
  255. {
  257. // 指向缓存图像1倒数第j行，第i个象素的指针
  258. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  260. // 指向缓存图像2倒数第j行，第i个象素的指针
  261. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  263. if(*lpDst2 > *lpDst1)
  264. *lpDst1 = *lpDst2;
  266. }
  267. }
  269. // 复制经过模板运算后的图像到源图像
  270. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  272. // 释放内存
  273. LocalUnlock(hNewDIBBits1);
  274. LocalFree(hNewDIBBits1);
  276. LocalUnlock(hNewDIBBits2);
  277. LocalFree(hNewDIBBits2);
  278. // 返回
  279. return TRUE;
  280. }
  282. /*************************************************************************
  283.  *
  284.  * 函数名称：
  285.  *   PrewittDIB()
  286.  *
  287.  * 参数:
  288.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  289.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  290.  *   LONG  lHeight      - 源图像高度（象素数）
  291.  * 返回值:
  292.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  293.  *
  294.  * 说明:
  295.  * 该函数用Prewitt边缘检测算子对图像进行边缘检测运算。
  296.  * 
  297.  * 要求目标图像为灰度图像。
  298.  ************************************************************************/
  300. BOOL WINAPI PrewittDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  301. {
  303. // 指向缓存图像的指针
  304. LPSTR lpDst1;
  305. LPSTR lpDst2;
  307. // 指向缓存DIB图像的指针
  308. LPSTR lpNewDIBBits1;
  309. HLOCAL hNewDIBBits1;
  310. LPSTR lpNewDIBBits2;
  311. HLOCAL hNewDIBBits2;
  313. //循环变量
  314. long i;
  315. long j;
  317. // 模板高度
  318. int iTempH;
  320. // 模板宽度
  321. int iTempW;
  323. // 模板系数
  324. FLOAT fTempC;
  326. // 模板中心元素X坐标
  327. int iTempMX;
  329. // 模板中心元素Y坐标
  330. int iTempMY;
  332. //模板数组
  333. FLOAT aTemplate[9];
  335. // 暂时分配内存，以保存新图像
  336. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  338. if (hNewDIBBits1 == NULL)
  339. {
  340. // 分配内存失败
  341. return FALSE;
  342. }
  344. // 锁定内存
  345. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  347. // 暂时分配内存，以保存新图像
  348. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  350. if (hNewDIBBits2 == NULL)
  351. {
  352. // 分配内存失败
  353. return FALSE;
  354. }
  356. // 锁定内存
  357. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  359. // 拷贝源图像到缓存图像中
  360. lpDst1 = (char *)lpNewDIBBits1;
  361. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  362. lpDst2 = (char *)lpNewDIBBits2;
  363. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  366. // 设置Prewitt模板参数
  367. iTempW = 3;
  368. iTempH = 3;
  369. fTempC = 1.0;
  370. iTempMX = 1;
  371. iTempMY = 1;
  372. aTemplate[0] = -1.0;
  373. aTemplate[1] = -1.0;
  374. aTemplate[2] = -1.0;
  375. aTemplate[3] = 0.0;
  376. aTemplate[4] = 0.0;
  377. aTemplate[5] = 0.0;
  378. aTemplate[6] = 1.0;
  379. aTemplate[7] = 1.0;
  380. aTemplate[8] = 1.0;
  382. // 调用Template()函数
  383. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  384. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  385. {
  386. return FALSE;
  387. }
  389. // 设置Prewitt模板参数
  390. aTemplate[0] = 1.0;
  391. aTemplate[1] = 0.0;
  392. aTemplate[2] = -1.0;
  393. aTemplate[3] = 1.0;
  394. aTemplate[4] = 0.0;
  395. aTemplate[5] = -1.0;
  396. aTemplate[6] = 1.0;
  397. aTemplate[7] = 0.0;
  398. aTemplate[8] = -1.0;
  400. // 调用Template()函数
  401. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  402. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  403. {
  404. return FALSE;
  405. }
  407. //求两幅缓存图像的最大值
  408. for(j = 0; j <lHeight; j++)
  409. {
  410. for(i = 0;i <lWidth-1; i++)
  411. {
  413. // 指向缓存图像1倒数第j行，第i个象素的指针
  414. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  416. // 指向缓存图像2倒数第j行，第i个象素的指针
  417. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  419. if(*lpDst2 > *lpDst1)
  420. *lpDst1 = *lpDst2;
  422. }
  423. }
  425. // 复制经过模板运算后的图像到源图像
  426. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  428. // 释放内存
  429. LocalUnlock(hNewDIBBits1);
  430. LocalFree(hNewDIBBits1);
  432. LocalUnlock(hNewDIBBits2);
  433. LocalFree(hNewDIBBits2);
  434. // 返回
  435. return TRUE;
  436. }
  438. /*************************************************************************
  439.  *
  440.  * 函数名称：
  441.  *   KirschDIB()
  442.  *
  443.  * 参数:
  444.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  445.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  446.  *   LONG  lHeight      - 源图像高度（象素数）
  447.  * 返回值:
  448.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  449.  *
  450.  * 说明:
  451.  * 该函数用kirsch边缘检测算子对图像进行边缘检测运算。
  452.  * 
  453.  * 要求目标图像为灰度图像。
  454.  ************************************************************************/
  456. BOOL WINAPI KirschDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  457. {
  459. // 指向缓存图像的指针
  460. LPSTR lpDst1;
  461. LPSTR lpDst2;
  463. // 指向缓存DIB图像的指针
  464. LPSTR lpNewDIBBits1;
  465. HLOCAL hNewDIBBits1;
  466. LPSTR lpNewDIBBits2;
  467. HLOCAL hNewDIBBits2;
  469. //循环变量
  470. long i;
  471. long j;
  473. // 模板高度
  474. int iTempH;
  476. // 模板宽度
  477. int iTempW;
  479. // 模板系数
  480. FLOAT fTempC;
  482. // 模板中心元素X坐标
  483. int iTempMX;
  485. // 模板中心元素Y坐标
  486. int iTempMY;
  488. //模板数组
  489. FLOAT aTemplate[9];
  491. // 暂时分配内存，以保存新图像
  492. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  494. if (hNewDIBBits1 == NULL)
  495. {
  496. // 分配内存失败
  497. return FALSE;
  498. }
  500. // 锁定内存
  501. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  503. // 暂时分配内存，以保存新图像
  504. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  506. if (hNewDIBBits2 == NULL)
  507. {
  508. // 分配内存失败
  509. return FALSE;
  510. }
  512. // 锁定内存
  513. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  515. // 拷贝源图像到缓存图像中
  516. lpDst1 = (char *)lpNewDIBBits1;
  517. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  518. lpDst2 = (char *)lpNewDIBBits2;
  519. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  522. // 设置Kirsch模板1参数
  523. iTempW = 3;
  524. iTempH = 3;
  525. fTempC = 1.0;
  526. iTempMX = 1;
  527. iTempMY = 1;
  528. aTemplate[0] = 5.0;
  529. aTemplate[1] = 5.0;
  530. aTemplate[2] = 5.0;
  531. aTemplate[3] = -3.0;
  532. aTemplate[4] = 0.0;
  533. aTemplate[5] = -3.0;
  534. aTemplate[6] = -3.0;
  535. aTemplate[7] = -3.0;
  536. aTemplate[8] = -3.0;
  538. // 调用Template()函数
  539. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  540. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  541. {
  542. return FALSE;
  543. }
  545. // 设置Kirsch模板2参数
  546. aTemplate[0] = -3.0;
  547. aTemplate[1] = 5.0;
  548. aTemplate[2] = 5.0;
  549. aTemplate[3] = -3.0;
  550. aTemplate[4] = 0.0;
  551. aTemplate[5] = 5.0;
  552. aTemplate[6] = -3.0;
  553. aTemplate[7] = -3.0;
  554. aTemplate[8] = -3.0;
  556. // 调用Template()函数
  557. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  558. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  559. {
  560. return FALSE;
  561. }
  563. //求两幅缓存图像的最大值
  564. for(j = 0; j <lHeight; j++)
  565. {
  566. for(i = 0;i <lWidth-1; i++)
  567. {
  569. // 指向缓存图像1倒数第j行，第i个象素的指针
  570. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  572. // 指向缓存图像2倒数第j行，第i个象素的指针
  573. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  575. if(*lpDst2 > *lpDst1)
  576. *lpDst1 = *lpDst2;
  578. }
  579. }
  581. // 拷贝源图像到缓存图像中
  582. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  584. // 设置Kirsch模板3参数
  585. aTemplate[0] = -3.0;
  586. aTemplate[1] = -3.0;
  587. aTemplate[2] = 5.0;
  588. aTemplate[3] = -3.0;
  589. aTemplate[4] = 0.0;
  590. aTemplate[5] = 5.0;
  591. aTemplate[6] = -3.0;
  592. aTemplate[7] = -3.0;
  593. aTemplate[8] = 5.0;
  595. // 调用Template()函数
  596. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  597. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  598. {
  599. return FALSE;
  600. }
  602. //求两幅缓存图像的最大值
  603. for(j = 0; j <lHeight; j++)
  604. {
  605. for(i = 0;i <lWidth-1; i++)
  606. {
  608. // 指向缓存图像1倒数第j行，第i个象素的指针
  609. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  611. // 指向缓存图像2倒数第j行，第i个象素的指针
  612. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  614. if(*lpDst2 > *lpDst1)
  615. *lpDst1 = *lpDst2;
  617. }
  618. }
  620. // 拷贝源图像到缓存图像中
  621. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  623. // 设置Kirsch模板4参数
  624. aTemplate[0] = -3.0;
  625. aTemplate[1] = -3.0;
  626. aTemplate[2] = -3.0;
  627. aTemplate[3] = -3.0;
  628. aTemplate[4] = 0.0;
  629. aTemplate[5] = 5.0;
  630. aTemplate[6] = -3.0;
  631. aTemplate[7] = 5.0;
  632. aTemplate[8] = 5.0;
  634. // 调用Template()函数
  635. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  636. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  637. {
  638. return FALSE;
  639. }
  641. //求两幅缓存图像的最大值
  642. for(j = 0; j <lHeight; j++)
  643. {
  644. for(i = 0;i <lWidth-1; i++)
  645. {
  647. // 指向缓存图像1倒数第j行，第i个象素的指针
  648. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  650. // 指向缓存图像2倒数第j行，第i个象素的指针
  651. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  653. if(*lpDst2 > *lpDst1)
  654. *lpDst1 = *lpDst2;
  656. }
  657. }
  659. // 拷贝源图像到缓存图像中
  660. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  662. // 设置Kirsch模板5参数
  663. aTemplate[0] = -3.0;
  664. aTemplate[1] = -3.0;
  665. aTemplate[2] = -3.0;
  666. aTemplate[3] = -3.0;
  667. aTemplate[4] = 0.0;
  668. aTemplate[5] = -3.0;
  669. aTemplate[6] = 5.0;
  670. aTemplate[7] = 5.0;
  671. aTemplate[8] = 5.0;
  673. // 调用Template()函数
  674. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  675. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  676. {
  677. return FALSE;
  678. }
  680. // 拷贝源图像到缓存图像中
  681. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  682. //求两幅缓存图像的最大值
  683. for(j = 0; j <lHeight; j++)
  684. {
  685. for(i = 0;i <lWidth-1; i++)
  686. {
  688. // 指向缓存图像1倒数第j行，第i个象素的指针
  689. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  691. // 指向缓存图像2倒数第j行，第i个象素的指针
  692. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  694. if(*lpDst2 > *lpDst1)
  695. *lpDst1 = *lpDst2;
  697. }
  698. }
  700. // 拷贝源图像到缓存图像中
  701. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  703. // 设置Kirsch模板6参数
  704. aTemplate[0] = -3.0;
  705. aTemplate[1] = -3.0;
  706. aTemplate[2] = -3.0;
  707. aTemplate[3] = 5.0;
  708. aTemplate[4] = 0.0;
  709. aTemplate[5] = -3.0;
  710. aTemplate[6] = 5.0;
  711. aTemplate[7] = 5.0;
  712. aTemplate[8] = -3.0;
  714. // 调用Template()函数
  715. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  716. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  717. {
  718. return FALSE;
  719. }
  721. //求两幅缓存图像的最大值
  722. for(j = 0; j <lHeight; j++)
  723. {
  724. for(i = 0;i <lWidth-1; i++)
  725. {
  727. // 指向缓存图像1倒数第j行，第i个象素的指针
  728. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  730. // 指向缓存图像2倒数第j行，第i个象素的指针
  731. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  733. if(*lpDst2 > *lpDst1)
  734. *lpDst1 = *lpDst2;
  736. }
  737. }
  739. // 拷贝源图像到缓存图像中
  740. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  742. // 设置Kirsch模板7参数
  743. aTemplate[0] = 5.0;
  744. aTemplate[1] = -3.0;
  745. aTemplate[2] = -3.0;
  746. aTemplate[3] = 5.0;
  747. aTemplate[4] = 0.0;
  748. aTemplate[5] = -3.0;
  749. aTemplate[6] = 5.0;
  750. aTemplate[7] = -3.0;
  751. aTemplate[8] = -3.0;
  753. // 调用Template()函数
  754. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  755. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  756. {
  757. return FALSE;
  758. }
  760. //求两幅缓存图像的最大值
  761. for(j = 0; j <lHeight; j++)
  762. {
  763. for(i = 0;i <lWidth-1; i++)
  764. {
  766. // 指向缓存图像1倒数第j行，第i个象素的指针
  767. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  769. // 指向缓存图像2倒数第j行，第i个象素的指针
  770. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  772. if(*lpDst2 > *lpDst1)
  773. *lpDst1 = *lpDst2;
  775. }
  776. }
  778. // 拷贝源图像到缓存图像中
  779. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  781. // 设置Kirsch模板8参数
  782. aTemplate[0] = 5.0;
  783. aTemplate[1] = 5.0;
  784. aTemplate[2] = -3.0;
  785. aTemplate[3] = 5.0;
  786. aTemplate[4] = 0.0;
  787. aTemplate[5] = -3.0;
  788. aTemplate[6] = -3.0;
  789. aTemplate[7] = -3.0;
  790. aTemplate[8] = -3.0;
  792. // 调用Template()函数
  793. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  794. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  795. {
  796. return FALSE;
  797. }
  799. //求两幅缓存图像的最大值
  800. for(j = 0; j <lHeight; j++)
  801. {
  802. for(i = 0;i <lWidth-1; i++)
  803. {
  805. // 指向缓存图像1倒数第j行，第i个象素的指针
  806. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  808. // 指向缓存图像2倒数第j行，第i个象素的指针
  809. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  811. if(*lpDst2 > *lpDst1)
  812. *lpDst1 = *lpDst2;
  814. }
  815. }
  817. // 复制经过模板运算后的图像到源图像
  818. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  820. // 释放内存
  821. LocalUnlock(hNewDIBBits1);
  822. LocalFree(hNewDIBBits1);
  824. LocalUnlock(hNewDIBBits2);
  825. LocalFree(hNewDIBBits2);
  826. // 返回
  827. return TRUE;
  828. }
  830. /*************************************************************************
  831.  *
  832.  * 函数名称：
  833.  *  GaussDIB()
  834.  *
  835.  * 参数:
  836.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  837.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  838.  *   LONG  lHeight      - 源图像高度（象素数）
  839.  * 返回值:
  840.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  841.  *
  842.  * 说明:
  843.  * 该函数用高斯拉普拉斯边缘检测算子对图像进行边缘检测运算。
  844.  * 
  845.  * 要求目标图像为灰度图像。
  846.  ************************************************************************/
  848. BOOL WINAPI GaussDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  849. {
  851. // 指向缓存图像的指针
  852. LPSTR lpDst1;
  853. LPSTR lpDst2;
  855. // 指向缓存DIB图像的指针
  856. LPSTR lpNewDIBBits1;
  857. HLOCAL hNewDIBBits1;
  858. LPSTR lpNewDIBBits2;
  859. HLOCAL hNewDIBBits2;
  861. // 模板高度
  862. int iTempH;
  864. // 模板宽度
  865. int iTempW;
  867. // 模板系数
  868. FLOAT fTempC;
  870. // 模板中心元素X坐标
  871. int iTempMX;
  873. // 模板中心元素Y坐标
  874. int iTempMY;
  876. //模板数组
  877. FLOAT aTemplate[25];
  879. // 暂时分配内存，以保存新图像
  880. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  882. if (hNewDIBBits1 == NULL)
  883. {
  884. // 分配内存失败
  885. return FALSE;
  886. }
  888. // 锁定内存
  889. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  891. // 暂时分配内存，以保存新图像
  892. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  894. if (hNewDIBBits2 == NULL)
  895. {
  896. // 分配内存失败
  897. return FALSE;
  898. }
  900. // 锁定内存
  901. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  903. // 拷贝源图像到缓存图像中
  904. lpDst1 = (char *)lpNewDIBBits1;
  905. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  906. lpDst2 = (char *)lpNewDIBBits2;
  907. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  910. // 设置Gauss模板参数
  911. iTempW = 5;
  912. iTempH = 5;
  913. fTempC = 1.0;
  914. iTempMX = 3;
  915. iTempMY = 3;
  916. aTemplate[0] = -2.0;
  917. aTemplate[1] = -4.0;
  918. aTemplate[2] = -4.0;
  919. aTemplate[3] = -4.0;
  920. aTemplate[4] = -2.0;
  921. aTemplate[5] = -4.0;
  922. aTemplate[6] = 0.0;
  923. aTemplate[7] = 8.0;
  924. aTemplate[8] = 0.0;
  925. aTemplate[9] = -4.0;
  926. aTemplate[10] = -4.0;
  927. aTemplate[11] = 8.0;
  928. aTemplate[12] = 24.0;
  929. aTemplate[13] = 8.0;
  930. aTemplate[14] = -4.0;
  931. aTemplate[15] = -4.0;
  932. aTemplate[16] = 0.0;
  933. aTemplate[17] = 8.0;
  934. aTemplate[18] = 0.0;
  935. aTemplate[19] = -4.0;
  936. aTemplate[20] = -2.0;
  937. aTemplate[21] = -4.0;
  938. aTemplate[22] = -4.0;
  939. aTemplate[23] = -4.0;
  940. aTemplate[24] = -2.0;
  942. // 调用Template()函数
  943. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  944. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  945. {
  946. return FALSE;
  947. }
  949. // 复制经过模板运算后的图像到源图像
  950. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  952. // 释放内存
  953. LocalUnlock(hNewDIBBits1);
  954. LocalFree(hNewDIBBits1);
  956. LocalUnlock(hNewDIBBits2);
  957. LocalFree(hNewDIBBits2);
  958. // 返回
  959. return TRUE;
  960. }
  962. /*************************************************************************
  963.  *
  964.  * 函数名称：
  965.  *   HoughDIB()
  966.  *
  967.  * 参数:
  968.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  969.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  970.  *   LONG  lHeight      - 源图像高度（象素数）
  971.  * 返回值:
  972.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  973.  *
  974.  * 说明:
  975.  * 该函数用于对检测图像中的平行直线。如果图像中有两条平行的直线，则将这两条平行直线
  976.  * 提取出来。
  977.  * 
  978.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  979.  ************************************************************************/
  981. BOOL WINAPI HoughDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  982. {
  984. // 指向源图像的指针
  985. LPSTR lpSrc;
  987. // 指向缓存图像的指针
  988. LPSTR lpDst;
  990. // 指向变换域的指针
  991. LPSTR   lpTrans;
  993. // 图像每行的字节数
  994. LONG lLineBytes;
  996. // 指向缓存DIB图像的指针
  997. LPSTR lpNewDIBBits;
  998. HLOCAL hNewDIBBits;
  1000. //指向变换域的指针
  1001. LPSTR lpTransArea;
  1002. HLOCAL hTransArea;
  1004. //变换域的尺寸
  1005. int iMaxDist;
  1006. int iMaxAngleNumber;
  1008. //变换域的坐标
  1009. int iDist;
  1010. int iAngleNumber;
  1012. //循环变量
  1013. long i;
  1014. long j;
  1016. //像素值
  1017. unsigned char pixel;
  1019. //存储变换域中的两个最大值
  1020. MaxValue MaxValue1;
  1021. MaxValue MaxValue2;
  1023. // 暂时分配内存，以保存新图像
  1024. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  1026. if (hNewDIBBits == NULL)
  1027. {
  1028. // 分配内存失败
  1029. return FALSE;
  1030. }
  1032. // 锁定内存
  1033. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1035. // 初始化新分配的内存，设定初始值为255
  1036. lpDst = (char *)lpNewDIBBits;
  1037. memset(lpDst, (BYTE)255, lWidth * lHeight);
  1039. //计算变换域的尺寸
  1040. //最大距离
  1041. iMaxDist = (int) sqrt(lWidth*lWidth + lHeight*lHeight);
  1043. //角度从0－180，每格2度
  1044. iMaxAngleNumber = 90;
  1046. //为变换域分配内存
  1047. hTransArea = LocalAlloc(LHND, lWidth * lHeight * sizeof(int));
  1049. if (hNewDIBBits == NULL)
  1050. {
  1051. // 分配内存失败
  1052. return FALSE;
  1053. }
  1055. // 锁定内存
  1056. lpTransArea = (char * )LocalLock(hTransArea);
  1058. // 初始化新分配的内存，设定初始值为0
  1059. lpTrans = (char *)lpTransArea;
  1060. memset(lpTrans, 0, lWidth * lHeight * sizeof(int));
  1062. // 计算图像每行的字节数
  1063. lLineBytes = WIDTHBYTES(lWidth * 8);
  1065. for(j = 0; j <lHeight; j++)
  1066. {
  1067. for(i = 0;i <lWidth; i++)
  1068. {
  1070. // 指向源图像倒数第j行，第i个象素的指针
  1071. lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
  1073. //取得当前指针处的像素值，注意要转换为unsigned char型
  1074. pixel = (unsigned char)*lpSrc;
  1076. //目标图像中含有0和255外的其它灰度值
  1077. if(pixel != 255 && *lpSrc != 0)
  1078. return FALSE;
  1080. //如果是黑点，则在变换域的对应各点上加1
  1081. if(pixel == 0)
  1082. {
  1083. //注意步长是2度
  1084. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1085. {
  1086. iDist = (int) fabs(i*cos(iAngleNumber*2*pi/180.0) + 
  1087. j*sin(iAngleNumber*2*pi/180.0));
  1089. //变换域的对应点上加1
  1090. *(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) = 
  1091. *(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) +1;
  1092. }
  1093. }
  1095. }
  1096. }
  1098. //找到变换域中的两个最大值点
  1099. MaxValue1.Value=0;
  1100. MaxValue2.Value=0;
  1102. //找到第一个最大值点
  1103. for (iDist=0; iDist<iMaxDist;iDist++)
  1104. {
  1105. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1106. {
  1107. if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue1.Value)
  1108. {
  1109. MaxValue1.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
  1110. MaxValue1.Dist = iDist;
  1111. MaxValue1.AngleNumber = iAngleNumber;
  1112. }
  1114. }
  1115. }
  1117. //将第一个最大值点附近清零
  1118. for (iDist = -9;iDist < 10;iDist++)
  1119. {
  1120. for(iAngleNumber=-1; iAngleNumber<2; iAngleNumber++)
  1121. {
  1122. if(iDist+MaxValue1.Dist>=0 && iDist+MaxValue1.Dist<iMaxDist 
  1123. && iAngleNumber+MaxValue1.AngleNumber>=0 && iAngleNumber+MaxValue1.AngleNumber<=iMaxAngleNumber)
  1124. {
  1125. *(lpTransArea+(iDist+MaxValue1.Dist)*iMaxAngleNumber+
  1126. (iAngleNumber+MaxValue1.AngleNumber))=0;
  1127. }
  1128. }
  1129. }
  1131. //找到第二个最大值点
  1132. for (iDist=0; iDist<iMaxDist;iDist++)
  1133. {
  1134. for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)
  1135. {
  1136. if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue2.Value)
  1137. {
  1138. MaxValue2.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);
  1139. MaxValue2.Dist = iDist;
  1140. MaxValue2.AngleNumber = iAngleNumber;
  1141. }
  1143. }
  1144. }
  1147. //判断两直线是否平行
  1148. if(abs(MaxValue1.AngleNumber-MaxValue2.AngleNumber)<=2)
  1149. {
  1150. //两直线平行，在缓存图像中重绘这两条直线
  1151. for(j = 0; j <lHeight; j++)
  1152. {
  1153. for(i = 0;i <lWidth; i++)
  1154. {
  1156. // 指向缓存图像倒数第j行，第i个象素的指针
  1157. lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
  1159. //如果该点在某一条平行直线上，则在缓存图像上将该点赋为黑
  1161. //在第一条直线上
  1162. iDist = (int) fabs(i*cos(MaxValue1.AngleNumber*2*pi/180.0) + 
  1163. j*sin(MaxValue1.AngleNumber*2*pi/180.0));
  1164. if (iDist == MaxValue1.Dist)
  1165. *lpDst = (unsigned char)0;
  1167. //在第二条直线上
  1168. iDist = (int) fabs(i*cos(MaxValue2.AngleNumber*2*pi/180.0) + 
  1169. j*sin(MaxValue2.AngleNumber*2*pi/180.0));
  1170. if (iDist == MaxValue2.Dist)
  1171. *lpDst = (unsigned char)0;
  1172. }
  1173. }
  1174. }
  1176. // 复制腐蚀后的图像
  1177. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1179. // 释放内存
  1180. LocalUnlock(hNewDIBBits);
  1181. LocalFree(hNewDIBBits);
  1183. // 释放内存
  1184. LocalUnlock(hTransArea);
  1185. LocalFree(hTransArea);
  1187. // 返回
  1188. return TRUE;
  1190. }
  1192. /*************************************************************************
  1193.  *
  1194.  * 函数名称：
  1195.  *   Fill2DIB()
  1196.  *
  1197.  * 参数:
  1198.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1199.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1200.  *   LONG  lHeight      - 源图像高度（象素数）
  1201.  * 返回值:
  1202.  *   BOOL               - 种子填充成功返回TRUE，否则返回FALSE。
  1203.  *
  1204.  * 说明:
  1205.  * 该函数用于对图像进行种子填充运算。
  1206.  * 
  1207.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1208.  ************************************************************************/
  1210. BOOL WINAPI Fill2DIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1211. {
  1213. // 指向源图像的指针
  1214. LPSTR lpSrc;
  1216. //循环变量
  1217. long i;
  1219. //像素值
  1220. unsigned char pixel;
  1222. //左右边界像素位置
  1223. int xl,xr;
  1225. //是否已填充至边界
  1226. BOOL bFilll,bFillr;
  1228. //种子堆栈及指针
  1229. Seed Seeds[10];
  1230. int StackPoint;
  1232. //当前像素位置
  1233. int iCurrentPixelx,iCurrentPixely;
  1234. int iBufferPixelx,iBufferPixely;
  1236. //初始化种子
  1237. Seeds[1].Height = lHeight / 2;
  1238. Seeds[1].Width = lWidth / 2;
  1239. StackPoint = 1;
  1241. while( StackPoint != 0)
  1242. {
  1243. //取出种子
  1244. iCurrentPixelx = Seeds[StackPoint].Width;
  1245. iCurrentPixely = Seeds[StackPoint].Height;
  1246. StackPoint--;
  1247. // if(Seed2.Height== 75)
  1248. // {
  1249. // return true;
  1250. // i++;
  1251. // }
  1252. bFilll = true;
  1253. bFillr = true;
  1254. //填充种子所在的行
  1255. //保存种子像素的位置
  1256. iBufferPixelx = iCurrentPixelx;
  1257. iBufferPixely = iCurrentPixely;
  1258. //先向左填充
  1259. while(bFilll)
  1260. {
  1261. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1262. //取得当前指针处的像素值，注意要转换为unsigned char型
  1263. pixel = (unsigned char)*lpSrc;
  1265. //目标图像中含有0和255外的其它灰度值
  1266. if(pixel != 255 && pixel != 0)
  1267. return FALSE;
  1268. //遇到边界
  1269. if(pixel == 0)
  1270. {
  1271. bFilll = false;
  1272. xl=iCurrentPixelx+1;
  1273. }
  1274. else
  1275. {
  1276. *lpSrc = (unsigned char)0;
  1277. iCurrentPixelx--;
  1278. //防止越界
  1279. if(iCurrentPixelx<0)
  1280. {
  1281. bFilll = false;
  1282. iCurrentPixelx = 0;
  1283. xl = 0; 
  1284. }
  1285. }
  1286. }
  1287. //再向右填充
  1288. //取回种子像素的位置
  1289. iCurrentPixelx = iBufferPixelx+1;
  1290. if(iCurrentPixelx>lWidth)
  1291. {
  1292. bFillr = false;
  1293. iCurrentPixelx = lWidth;
  1294. xr = lWidth; 
  1295. }
  1296. iCurrentPixely = iBufferPixely;
  1297. while(bFillr)
  1298. {
  1299. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1300. //取得当前指针处的像素值，注意要转换为unsigned char型
  1301. pixel = (unsigned char)*lpSrc;
  1303. //目标图像中含有0和255外的其它灰度值
  1304. if(pixel != 255 && pixel != 0)
  1305. return FALSE;
  1306. //遇到边界
  1307. if(pixel == 0)
  1308. {
  1309. bFillr = false;
  1310. xr=iCurrentPixelx-1;
  1311. }
  1312. else
  1313. {
  1314. *lpSrc = (unsigned char)0;
  1315. iCurrentPixelx++;
  1316. //防止越界
  1317. if(iCurrentPixelx>lWidth)
  1318. {
  1319. bFillr = false;
  1320. iCurrentPixelx = lWidth;
  1321. xr = lWidth; 
  1322. }
  1323. }
  1324. }
  1325. //上、下两条扫描线是否全为边界象素或已填充过
  1326. //先看上面的扫描线
  1327. iCurrentPixely--;
  1328. if(iCurrentPixely < 0)
  1329. {
  1330. iCurrentPixely = 0;
  1331. }
  1332. for (i = xr; i>= xl;i--)
  1333. {
  1334. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + i;
  1335. //取得当前指针处的像素值，注意要转换为unsigned char型
  1336. pixel = (unsigned char)*lpSrc;
  1338. //有未填充的像素，将新的种子压入堆栈
  1339. if (pixel == 255)
  1340. {
  1341. StackPoint++;
  1342. Seeds[StackPoint].Height = iCurrentPixely;
  1343. Seeds[StackPoint].Width = i;
  1344. break;
  1345. }
  1346. }
  1347. //再看下面的扫描线
  1348. iCurrentPixely+=2;
  1349. if(iCurrentPixely > lHeight)
  1350. {
  1351. iCurrentPixely = lHeight;
  1352. }
  1353. for (i = xr; i>= xl;i--)
  1354. {
  1355. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + i;
  1356. //取得当前指针处的像素值，注意要转换为unsigned char型
  1357. pixel = (unsigned char)*lpSrc;
  1359. //有未填充的像素，将新的种子压入堆栈
  1360. if (pixel == 255)
  1361. {
  1362. StackPoint++;
  1363. Seeds[StackPoint].Height = iCurrentPixely;
  1364. Seeds[StackPoint].Width = i;
  1365. break;
  1366. }
  1367. }
  1370. }
  1372. // 返回
  1373. return TRUE;
  1374. }
  1376. /*************************************************************************
  1377.  *
  1378.  * 函数名称：
  1379.  *   FillDIB()
  1380.  *
  1381.  * 参数:
  1382.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1383.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1384.  *   LONG  lHeight      - 源图像高度（象素数）
  1385.  * 返回值:
  1386.  *   BOOL               - 种子填充成功返回TRUE，否则返回FALSE。
  1387.  *
  1388.  * 说明:
  1389.  * 该函数用于对图像进行种子填充运算。
  1390.  * 
  1391.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1392.  ************************************************************************/
  1394. BOOL WINAPI FillDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1395. {
  1397. // 指向源图像的指针
  1398. LPSTR lpSrc;
  1400. //像素值
  1401. unsigned char pixel;
  1403. //种子堆栈及指针
  1404. Seed *Seeds;
  1405. int StackPoint;
  1407. //当前像素位置
  1408. int iCurrentPixelx,iCurrentPixely;
  1410. //初始化种子
  1411. Seeds = new Seed[lWidth*lHeight];
  1412. Seeds[1].Height = lHeight / 2;
  1413. Seeds[1].Width = lWidth / 2;
  1414. StackPoint = 1;
  1416. while( StackPoint != 0)
  1417. {
  1418. //取出种子
  1419. iCurrentPixelx = Seeds[StackPoint].Width;
  1420. iCurrentPixely = Seeds[StackPoint].Height;
  1421. StackPoint--;
  1423. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx;
  1424. //取得当前指针处的像素值，注意要转换为unsigned char型
  1425. pixel = (unsigned char)*lpSrc;
  1427. //目标图像中含有0和255外的其它灰度值
  1428. if(pixel != 255 && pixel != 0)
  1429. return FALSE;
  1431. //将当前点涂黑
  1432. *lpSrc = (unsigned char)0;
  1434. //判断左面的点，如果为白，则压入堆栈
  1435. //注意防止越界
  1436. if(iCurrentPixelx > 0)
  1437. {
  1438. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx - 1;
  1439. //取得当前指针处的像素值，注意要转换为unsigned char型
  1440. pixel = (unsigned char)*lpSrc;
  1441. if (pixel == 255)
  1442. {
  1443. StackPoint++;
  1444. Seeds[StackPoint].Height = iCurrentPixely;
  1445. Seeds[StackPoint].Width = iCurrentPixelx - 1;
  1446. }
  1447. //目标图像中含有0和255外的其它灰度值
  1448. if(pixel != 255 && pixel != 0)
  1449. return FALSE;
  1450. }
  1452. //判断上面的点，如果为白，则压入堆栈
  1453. //注意防止越界
  1454. if(iCurrentPixely < lHeight - 1)
  1455. {
  1456. lpSrc = (char *)lpDIBBits + lWidth * (iCurrentPixely + 1) + iCurrentPixelx;
  1457. //取得当前指针处的像素值，注意要转换为unsigned char型
  1458. pixel = (unsigned char)*lpSrc;
  1459. if (pixel == 255)
  1460. {
  1461. StackPoint++;
  1462. Seeds[StackPoint].Height = iCurrentPixely + 1;
  1463. Seeds[StackPoint].Width = iCurrentPixelx;
  1464. }
  1465. //目标图像中含有0和255外的其它灰度值
  1466. if(pixel != 255 && pixel != 0)
  1467. return FALSE;
  1468. }
  1470. //判断右面的点，如果为白，则压入堆栈
  1471. //注意防止越界
  1472. if(iCurrentPixelx < lWidth - 1)
  1473. {
  1474. lpSrc = (char *)lpDIBBits + lWidth * iCurrentPixely + iCurrentPixelx + 1;
  1475. //取得当前指针处的像素值，注意要转换为unsigned char型
  1476. pixel = (unsigned char)*lpSrc;
  1477. if (pixel == 255)
  1478. {
  1479. StackPoint++;
  1480. Seeds[StackPoint].Height = iCurrentPixely;
  1481. Seeds[StackPoint].Width = iCurrentPixelx + 1;
  1482. }
  1483. //目标图像中含有0和255外的其它灰度值
  1484. if(pixel != 255 && pixel != 0)
  1485. return FALSE;
  1486. }
  1488. //判断下面的点，如果为白，则压入堆栈
  1489. //注意防止越界
  1490. if(iCurrentPixely > 0)
  1491. {
  1492. lpSrc = (char *)lpDIBBits + lWidth * (iCurrentPixely - 1) + iCurrentPixelx;
  1493. //取得当前指针处的像素值，注意要转换为unsigned char型
  1494. pixel = (unsigned char)*lpSrc;
  1495. if (pixel == 255)
  1496. {
  1497. StackPoint++;
  1498. Seeds[StackPoint].Height = iCurrentPixely - 1;
  1499. Seeds[StackPoint].Width = iCurrentPixelx;
  1500. }
  1501. //目标图像中含有0和255外的其它灰度值
  1502. if(pixel != 255 && pixel != 0)
  1503. return FALSE;
  1504. }
  1505. }
  1507. //释放堆栈
  1508. delete Seeds;
  1509. // 返回
  1510. return TRUE;
  1511. }
  1513. /*************************************************************************
  1514.  *
  1515.  * 函数名称：
  1516.  *   ContourDIB()
  1517.  *
  1518.  * 参数:
  1519.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1520.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1521.  *   LONG  lHeight      - 源图像高度（象素数）
  1522.  * 返回值:
  1523.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  1524.  *
  1525.  * 说明:
  1526.  * 该函数用于对图像进行轮廓提取运算。
  1527.  * 
  1528.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1529.  ************************************************************************/
  1531. BOOL WINAPI ContourDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1532. {
  1534. // 指向源图像的指针
  1535. LPSTR lpSrc;
  1537. // 指向缓存图像的指针
  1538. LPSTR lpDst;
  1540. // 指向缓存DIB图像的指针
  1541. LPSTR lpNewDIBBits;
  1542. HLOCAL hNewDIBBits;
  1544. //循环变量
  1545. long i;
  1546. long j;
  1547. unsigned char n,e,s,w,ne,se,nw,sw;
  1549. //像素值
  1550. unsigned char pixel;
  1552. // 暂时分配内存，以保存新图像
  1553. hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);
  1555. if (hNewDIBBits == NULL)
  1556. {
  1557. // 分配内存失败
  1558. return FALSE;
  1559. }
  1561. // 锁定内存
  1562. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1564. // 初始化新分配的内存，设定初始值为255
  1565. lpDst = (char *)lpNewDIBBits;
  1566. memset(lpDst, (BYTE)255, lWidth * lHeight);
  1567. for(j = 1; j <lHeight-1; j++)
  1568. {
  1569. for(i = 1;i <lWidth-1; i++)
  1570. {
  1572. // 指向源图像倒数第j行，第i个象素的指针
  1573. lpSrc = (char *)lpDIBBits + lWidth * j + i;
  1575. // 指向目标图像倒数第j行，第i个象素的指针
  1576. lpDst = (char *)lpNewDIBBits + lWidth * j + i;
  1578. //取得当前指针处的像素值，注意要转换为unsigned char型
  1579. pixel = (unsigned char)*lpSrc;
  1581. //目标图像中含有0和255外的其它灰度值
  1582. // if(pixel != 255 && pixel != 0)
  1583. // return FALSE;
  1584. if(pixel == 0)
  1585. {
  1586. *lpDst = (unsigned char)0;
  1587. nw = (unsigned char)*(lpSrc + lWidth -1);
  1588. n  = (unsigned char)*(lpSrc + lWidth );
  1589. ne = (unsigned char)*(lpSrc + lWidth +1);
  1590. w = (unsigned char)*(lpSrc -1);
  1591. e = (unsigned char)*(lpSrc +1);
  1592. sw = (unsigned char)*(lpSrc - lWidth -1);
  1593. s  = (unsigned char)*(lpSrc - lWidth );
  1594. se = (unsigned char)*(lpSrc - lWidth +1);
  1595. //如果相邻的八个点都是黑点
  1596. if(nw+n+ne+w+e+sw+s+se==0)
  1597. {
  1598. *lpDst = (unsigned char)255;
  1599. }
  1600. }
  1601. }
  1602. }
  1604. // 复制腐蚀后的图像
  1605. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1607. // 释放内存
  1608. LocalUnlock(hNewDIBBits);
  1609. LocalFree(hNewDIBBits);
  1611. // 返回
  1612. return TRUE;
  1613. }
  1615. /*************************************************************************
  1616.  *
  1617.  * 函数名称：
  1618.  *   TraceDIB()
  1619.  *
  1620.  * 参数:
  1621.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1622.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1623.  *   LONG  lHeight      - 源图像高度（象素数）
  1624.  * 返回值:
  1625.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  1626.  *
  1627.  * 说明:
  1628.  * 该函数用于对图像进行轮廓跟踪运算。
  1629.  * 
  1630.  * 要求目标图像为只有0和255两个灰度值的灰度图像。
  1631.  ************************************************************************/
  1633. BOOL WINAPI TraceDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1634. {
  1636. // 指向源图像的指针
  1637. LPSTR lpSrc;
  1639. // 指向缓存图像的指针
  1640. LPSTR lpDst;
  1642. // 指向缓存DIB图像的指针
  1643. LPSTR lpNewDIBBits;
  1644. HLOCAL hNewDIBBits;
  1646. // 图像每行的字节数
  1647. LONG lLineBytes;
  1649. //循环变量
  1650. long i;
  1651. long j;
  1653. //像素值
  1654. unsigned char pixel;
  1656. //是否找到起始点及回到起始点
  1657. bool bFindStartPoint;
  1659. //是否扫描到一个边界点
  1660. bool bFindPoint;
  1662. //起始边界点与当前边界点
  1663. Point StartPoint,CurrentPoint;
  1665. //八个方向和起始扫描方向
  1666. int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};
  1667. int BeginDirect;
  1669. // 计算图像每行的字节数
  1670. lLineBytes = WIDTHBYTES(lWidth * 8);
  1672. // 暂时分配内存，以保存新图像
  1673. hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
  1675. if (hNewDIBBits == NULL)
  1676. {
  1677. // 分配内存失败
  1678. return FALSE;
  1679. }
  1681. // 锁定内存
  1682. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  1684. // 初始化新分配的内存，设定初始值为255
  1685. lpDst = (char *)lpNewDIBBits;
  1686. memset(lpDst, (BYTE)255, lLineBytes * lHeight);
  1688. //先找到最左上方的边界点
  1689. bFindStartPoint = false;
  1690. for (j = 0;j < lHeight && !bFindStartPoint;j++)
  1691. {
  1692. for(i = 0;i < lWidth && !bFindStartPoint;i++)
  1693. {
  1694. // 指向源图像倒数第j行，第i个象素的指针
  1695. lpSrc = (char *)lpDIBBits + lLineBytes * j + i;
  1697. //取得当前指针处的像素值，注意要转换为unsigned char型
  1698. pixel = (unsigned char)*lpSrc;
  1700. if(pixel == 0)
  1701. {
  1702. bFindStartPoint = true;
  1704. StartPoint.Height = j;
  1705. StartPoint.Width = i;
  1707. // 指向目标图像倒数第j行，第i个象素的指针
  1708. lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;
  1709. *lpDst = (unsigned char)0;
  1710. }
  1711. }
  1712. }
  1714. //由于起始点是在左下方，故起始扫描沿左上方向
  1715. BeginDirect = 0;
  1716. //跟踪边界
  1717. bFindStartPoint = false;
  1718. //从初始点开始扫描
  1719. CurrentPoint.Height = StartPoint.Height;
  1720. CurrentPoint.Width = StartPoint.Width;
  1721. while(!bFindStartPoint)
  1722. {
  1723. bFindPoint = false;
  1724. while(!bFindPoint)
  1725. {
  1726. //沿扫描方向查看一个像素
  1727. lpSrc = (char *)lpDIBBits + lLineBytes * ( CurrentPoint.Height + Direction[BeginDirect][1])
  1728. + (CurrentPoint.Width + Direction[BeginDirect][0]);
  1729. pixel = (unsigned char)*lpSrc;
  1730. if(pixel == 0)
  1731. {
  1732. bFindPoint = true;
  1733. CurrentPoint.Height = CurrentPoint.Height + Direction[BeginDirect][1];
  1734. CurrentPoint.Width = CurrentPoint.Width + Direction[BeginDirect][0];
  1735. if(CurrentPoint.Height == StartPoint.Height && CurrentPoint.Width == StartPoint.Width)
  1736. {
  1737. bFindStartPoint = true;
  1738. }
  1739. lpDst = (char *)lpNewDIBBits + lLineBytes * CurrentPoint.Height + CurrentPoint.Width;
  1740. *lpDst = (unsigned char)0;
  1741. //扫描的方向逆时针旋转两格
  1742. BeginDirect--;
  1743. if(BeginDirect == -1)
  1744. BeginDirect = 7;
  1745. BeginDirect--;
  1746. if(BeginDirect == -1)
  1747. BeginDirect = 7;
  1748. }
  1749. else
  1750. {
  1751. //扫描方向顺时针旋转一格
  1752. BeginDirect++;
  1753. if(BeginDirect == 8)
  1754. BeginDirect = 0;
  1756. }
  1758. }
  1759. }
  1761. // 复制腐蚀后的图像
  1762. memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);
  1764. // 释放内存
  1765. LocalUnlock(hNewDIBBits);
  1766. LocalFree(hNewDIBBits);
  1768. // 返回
  1769. return TRUE;
  1770. }
  1772. /*************************************************************************
  1773.  *
  1774.  * 函数名称：
  1775.  *   MyDIB()
  1776.  *
  1777.  * 参数:
  1778.  *   LPSTR lpDIBBits    - 指向源DIB图像指针
  1779.  *   LONG  lWidth       - 源图像宽度（象素数，必须是4的倍数）
  1780.  *   LONG  lHeight      - 源图像高度（象素数）
  1781.  * 返回值:
  1782.  *   BOOL               - 边缘检测成功返回TRUE，否则返回FALSE。
  1783.  *
  1784.  * 说明:
  1785.  * 该函数用水平边缘检测算子对图像进行边缘检测运算。
  1786.  * 
  1787.  * 要求目标图像为灰度图像。
  1788.  ************************************************************************/
  1790. BOOL WINAPI MyDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
  1791. {
  1793. // 指向缓存图像的指针
  1794. LPSTR lpDst1;
  1795. LPSTR lpDst2;
  1797. // 指向缓存DIB图像的指针
  1798. LPSTR lpNewDIBBits1;
  1799. HLOCAL hNewDIBBits1;
  1800. LPSTR lpNewDIBBits2;
  1801. HLOCAL hNewDIBBits2;
  1803. //循环变量
  1804. long i;
  1805. long j;
  1807. // 模板高度
  1808. int iTempH;
  1810. // 模板宽度
  1811. int iTempW;
  1813. // 模板系数
  1814. FLOAT fTempC;
  1816. // 模板中心元素X坐标
  1817. int iTempMX;
  1819. // 模板中心元素Y坐标
  1820. int iTempMY;
  1822. //模板数组
  1823. FLOAT aTemplate[9];
  1825. // 暂时分配内存，以保存新图像
  1826. hNewDIBBits1 = LocalAlloc(LHND, lWidth * lHeight);
  1828. if (hNewDIBBits1 == NULL)
  1829. {
  1830. // 分配内存失败
  1831. return FALSE;
  1832. }
  1834. // 锁定内存
  1835. lpNewDIBBits1 = (char * )LocalLock(hNewDIBBits1);
  1837. // 暂时分配内存，以保存新图像
  1838. hNewDIBBits2 = LocalAlloc(LHND, lWidth * lHeight);
  1840. if (hNewDIBBits2 == NULL)
  1841. {
  1842. // 分配内存失败
  1843. return FALSE;
  1844. }
  1846. // 锁定内存
  1847. lpNewDIBBits2 = (char * )LocalLock(hNewDIBBits2);
  1849. // 拷贝源图像到缓存图像中
  1850. lpDst1 = (char *)lpNewDIBBits1;
  1851. memcpy(lpNewDIBBits1, lpDIBBits, lWidth * lHeight);
  1852. lpDst2 = (char *)lpNewDIBBits2;
  1853. memcpy(lpNewDIBBits2, lpDIBBits, lWidth * lHeight);
  1856. // 设置Prewitt模板参数
  1857. iTempW = 3;
  1858. iTempH = 3;
  1859. fTempC = 1.0;
  1860. iTempMX = 1;
  1861. iTempMY = 1;
  1862. aTemplate[0] = 0.0;
  1863. aTemplate[1] = 0.0;
  1864. aTemplate[2] = 0.0;
  1865. aTemplate[3] = -1.0;
  1866. aTemplate[4] = 1.0;
  1867. aTemplate[5] = 0.0;
  1868. aTemplate[6] = 0.0;
  1869. aTemplate[7] = 0.0;
  1870. aTemplate[8] = 0.0;
  1872. // 调用Template()函数
  1873. if (!Template(lpNewDIBBits1, lWidth, lHeight, 
  1874. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  1875. {
  1876. return FALSE;
  1877. }
  1879. // 设置Prewitt模板参数
  1880. aTemplate[0] = 0.0;
  1881. aTemplate[1] = -1.0;
  1882. aTemplate[2] = 0.0;
  1883. aTemplate[3] = 0.0;
  1884. aTemplate[4] = 1.0;
  1885. aTemplate[5] = 0.0;
  1886. aTemplate[6] = 0.0;
  1887. aTemplate[7] = 0.0;
  1888. aTemplate[8] = 0.0;
  1890. // 调用Template()函数
  1891. if (!Template(lpNewDIBBits2, lWidth, lHeight, 
  1892. iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC))
  1893. {
  1894. return FALSE;
  1895. }
  1897. //求两幅缓存图像的最大值
  1898. for(j = 0; j <lHeight; j++)
  1899. {
  1900. for(i = 0;i <lWidth-1; i++)
  1901. {
  1903. // 指向缓存图像1倒数第j行，第i个象素的指针
  1904. lpDst1 = (char *)lpNewDIBBits1 + lWidth * j + i;
  1906. // 指向缓存图像2倒数第j行，第i个象素的指针
  1907. lpDst2 = (char *)lpNewDIBBits2 + lWidth * j + i;
  1909. if(*lpDst2 > *lpDst1)
  1910. *lpDst1 = *lpDst2;
  1912. }
  1913. }
  1915. // 复制经过模板运算后的图像到源图像
  1916. memcpy(lpDIBBits, lpNewDIBBits1, lWidth * lHeight);
  1918. // 释放内存
  1919. LocalUnlock(hNewDIBBits1);
  1920. LocalFree(hNewDIBBits1);
  1922. LocalUnlock(hNewDIBBits2);
  1923. LocalFree(hNewDIBBits2);
  1924. // 返回
  1925. return TRUE;
  1926. }