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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
ImgProcess.cpp
资源名称：QuickImage.rar　[点击查看]
上传用户：gzboli
上传日期：2013-04-10
资源大小：471k
文件大小：44k
源码类别：

图片显示

开发平台：

Visual C++

ImgProcess.cpp：源码内容
  1. // ImgProcess.cpp: implementation of the CImgProcess class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "QuickImage.h"
  7. #include "ImgProcess.h"
  8. #include "MathEx.h"
  9. #include <math.h>
  11. #ifdef _DEBUG
  12. #undef THIS_FILE
  13. static char THIS_FILE[]=__FILE__;
  14. #define new DEBUG_NEW
  15. #endif
  17. //////////////////////////////////////////////////////////////////////
  18. // Construction/Destruction
  19. //////////////////////////////////////////////////////////////////////
  20. // The following kernel definitions are for convolution filtering.
  21. // Kernel entries are specified with a divisor to get around the
  22. // requirement for floating point numbers in the low pass filters. 
  24. KERNEL HP1 = {                    // HP filter #1
  25. {-1, -1, -1,
  26. -1,  9, -1,
  27. -1, -1, -1},
  28. 1                             // Divisor = 1
  29. };
  31. KERNEL HP2 = {                    // HP filter #2
  32. { 0, -1,  0,
  33. -1,  5, -1,
  34. 0, -1,  0},
  35. 1                             // Divisor = 1
  36. };
  38. KERNEL HP3 = {                    // HP filter #3
  39. { 1, -2,  1,
  40. -2,  5, -2,
  41. 1, -2,  1},
  42. 1                             // Divisor = 1
  43. };
  45. KERNEL LP1 = {                    // LP filter #1
  46. { 1,  1,  1,
  47. 1,  1,  1,
  48. 1,  1,  1},
  49. 9                             // Divisor = 9
  50. };
  52. KERNEL LP2 = {                    // LP filter #2
  53. { 1,  1,  1,
  54. 1,  2,  1,
  55. 1,  1,  1},
  56. 10                            // Divisor = 10
  57. };
  59. KERNEL LP3 = {                    // LP filter #3
  60. { 1,  2,  1,
  61. 2,  4,  2,
  62. 1,  2,  1},
  63. 16                            // Divisor = 16
  64. };
  66. KERNEL VertEdge = {              // Vertical edge
  67. { 0,  0,  0,
  68. -1, 1,  0,
  69. 0,  0,  0},
  70. 1                             // Divisor = 1
  71. };
  73. KERNEL HorzEdge = {              // Horizontal edge
  74. { 0,  -1,  0,
  75. 0,  1,  0,
  76. 0,  0,  0},
  77. 1                             // Divisor = 1
  78. };
  80. KERNEL VertHorzEdge = {           // Vertical Horizontal edge
  81. { -1, 0,  0,
  82. 0,  1,  0,
  83. 0,  0,  0},
  84. 1                             // Divisor = 1
  85. };
  87. KERNEL EdgeNorth = {              // North gradient
  88. { 1,  1,  1,
  89. 1, -2,  1,
  90. -1, -1, -1},
  91. 1                             // Divisor = 1
  92. };
  94. KERNEL EdgeNorthEast = {          // North East gradient
  95. { 1,  1,  1,
  96. -1, -2,  1,
  97. -1, -1,  1},
  98. 1                             // Divisor = 1
  99. };
  101. KERNEL EdgeEast = {               // East gradient
  102. {-1,  1,  1,
  103. -1, -2,  1,
  104. -1,  1,  1},
  105. 1                             // Divisor = 1
  106. };
  108. KERNEL EdgeSouthEast = {          // South East gradient
  109. {-1, -1,  1,
  110. -1, -2,  1,
  111. 1,  1,  1},
  112. 1                             // Divisor = 1
  113. };
  115. KERNEL EdgeSouth = {              // South gadient
  116. {-1, -1, -1,
  117. 1, -2,  1,
  118. 1,  1,  1},
  119. 1                             // Divisor = 1
  120. };
  122. KERNEL EdgeSouthWest = {          // South West gradient
  123. { 1, -1, -1,
  124. 1, -2, -1,
  125. 1,  1,  1},
  126. 1                             // Divisor = 1
  127. };
  129. KERNEL EdgeWest = {               // West gradient
  130. { 1,  1, -1,
  131. 1, -2, -1,
  132. 1,  1, -1},
  133. 1                             // Divisor = 1
  134. };
  136. KERNEL EdgeNorthWest = {          // North West gradient
  137. { 1,  1,  1,
  138. 1, -2, -1,
  139. 1, -1, -1},
  140. 1                             // Divisor = 1
  141. };
  143. KERNEL Lap1 = {   // Laplace filter 1
  144. { 0,  1,  0,
  145. 1, -4,  1,
  146. 0,  1,  0},
  147. 1                             // Divisor = 1
  148. };
  150. KERNEL Lap2 = {   // Laplace filter 2
  151. { -1, -1, -1,
  152. -1,  8, -1,
  153. -1, -1, -1},
  154. 1                             // Divisor = 1
  155. };
  157. KERNEL Lap3 = {   // Laplace filter 3
  158. { -1, -1, -1,
  159. -1,  9, -1,
  160. -1, -1, -1},
  161. 1                             // Divisor = 1
  162. };
  164. KERNEL Lap4 = {   // Laplace filter 4
  165. { 1, -2, 1,
  166. -2, 4, -2,
  167. 1, -2, 1},
  168. 1                             // Divisor = 1
  169. };
  171. KERNEL Sobel[4] = {
  172. {                    // Sobel1
  173. {-1, 0, 1,
  174. -2, 0, 2,
  175. -1, 0, 1},
  176. 1                             // Divisor = 1
  177. },
  178. {                    // Sobel2
  179. {-1, -2, -1,
  180. 0,  0,  0,
  181. 1,  2,  1},
  182. 1                             // Divisor = 1
  183. },
  184. {                    // Sobel3
  185. {-2, -1, 0,
  186. -1,  0, 1,
  187. 0,  1, 2},
  188. 1                             // Divisor = 1
  189. },
  190. {                    // Sobel4
  191. {0, -1, -2,
  192. 1,  0, -1,
  193. 2,  1, 0},
  194. 1                             // Divisor = 1
  195. }
  196. };
  198. KERNEL Hough[4] = {
  199. {                    // Hough1
  200. {-1, 0, 1,
  201. -1, 0, 1,
  202. -1, 0, 1},
  203. 1                             // Divisor = 1
  204. },
  205. {                    // Hough2
  206. {-1, -1, 0,
  207. -1,  0, 1,
  208. 0,  1, 1},
  209. 1                             // Divisor = 1
  210. },
  211. {                    // Hough3
  212. {-1, -1, -1,
  213. 0,  0, 0,
  214. 1,  1, 1},
  215. 1                             // Divisor = 1
  216. },
  217. {                    // Hough4
  218. {0, -1, -1,
  219. 1,  0, -1,
  220. 1,  1, 0},
  221. 1                             // Divisor = 1
  222. }
  223. };
  225. CImgProcess::CImgProcess()
  226. {
  228. }
  230. CImgProcess::~CImgProcess()
  231. {
  233. }
  234. // function body
  236. /************************************************************************* 
  237.  * 
  238.  * HighPassDIB() 
  239.  * 
  240.  * Parameters: 
  241.  * 
  242.  * HDIB hDib        - objective DIB handle
  243.  * int nAlgorithm   - specify the filter to use
  244.  * int Strength     - operation strength set to the convolute
  245.  * 
  246.  * Return Value: 
  247.  * 
  248.  * BOOL             - True is success, else False
  249.  * 
  250.  * Description: 
  251.  * 
  252.  * High pass filtering to sharp DIB
  253.  * 
  254.  ************************************************************************/ 
  255. BOOL CImgProcess::HighPassDIB(HDIB hDib, int Strength, int nAlgorithm) 
  256. {
  257. switch (nAlgorithm)
  258. {
  259. case FILTER1:
  260. return ConvoluteDIB(hDib, &HP1, Strength);
  261. case FILTER2:
  262. return ConvoluteDIB(hDib, &HP2, Strength);
  263. case FILTER3:
  264. return ConvoluteDIB(hDib, &HP3, Strength);
  265. }
  267. return FALSE;
  268. }
  270. /************************************************************************* 
  271.  * 
  272.  * LowPassDIB() 
  273.  * 
  274.  * Parameters: 
  275.  * 
  276.  * HDIB hDib        - objective DIB handle
  277.  * int nAlgorithm   - specify the filter to use
  278.  * int Strength     - operation strength set to the convolute
  279.  * 
  280.  * Return Value: 
  281.  * 
  282.  * BOOL             - True is success, else False
  283.  * 
  284.  * Description: 
  285.  * 
  286.  * Low pass filtering to blur DIB
  287.  * 
  288.  ************************************************************************/ 
  289. BOOL CImgProcess::LowPassDIB(HDIB hDib, int Strength, int nAlgorithm) 
  290. {
  291. ASSERT(NULL != hDib);
  292. switch (nAlgorithm)
  293. {
  294. case FILTER1:
  295. return ConvoluteDIB(hDib, &LP1, Strength);
  296. case FILTER2:
  297. return ConvoluteDIB(hDib, &LP2, Strength);
  298. case FILTER3:
  299. return ConvoluteDIB(hDib, &LP3, Strength);
  300. }
  302. return FALSE;
  303. }
  305. /************************************************************************* 
  306.  * 
  307.  * EdgeEnhanceDIB() 
  308.  * 
  309.  * Parameters: 
  310.  * 
  311.  * HDIB hDib        - objective DIB handle
  312.  * int nAlgorithm   - specify the filter to use
  313.  * int Strength     - operation strength set to the convolute
  314.  * 
  315.  * Return Value: 
  316.  * 
  317.  * BOOL             - True is success, else False
  318.  * 
  319.  * Description: 
  320.  * 
  321.  * Edge enhance DIB
  322.  * 
  323.  ************************************************************************/ 
  324. BOOL CImgProcess::EdgeEnhanceDIB(HDIB hDib, int Strength, int nAlgorithm)
  325. {
  326. switch (nAlgorithm)
  327. {
  328. case VERT:
  329. return ConvoluteDIB(hDib, &VertEdge, Strength);
  330. case HORZ:
  331. return ConvoluteDIB(hDib, &HorzEdge, Strength);
  332. case VERTHORZ:
  333. return ConvoluteDIB(hDib, &VertHorzEdge, Strength);
  334. case NORTH:
  335. return ConvoluteDIB(hDib, &EdgeNorth, Strength);
  336. case NORTHEAST:
  337. return ConvoluteDIB(hDib, &EdgeNorthEast, Strength);
  338. case EAST:
  339. return ConvoluteDIB(hDib, &EdgeEast, Strength);
  340. case SOUTH:
  341. return ConvoluteDIB(hDib, &EdgeSouth, Strength);
  342. case SOUTHEAST:
  343. return ConvoluteDIB(hDib, &EdgeSouthEast, Strength);
  344. case SOUTHWEST:
  345. return ConvoluteDIB(hDib, &EdgeSouthWest, Strength);
  346. case WEST:
  347. return ConvoluteDIB(hDib, &EdgeWest, Strength);
  348. case NORTHWEST:
  349. return ConvoluteDIB(hDib, &EdgeNorthWest, Strength);
  350. case LAP1:
  351. return ConvoluteDIB(hDib, &Lap1, Strength);
  352. case LAP2:
  353. return ConvoluteDIB(hDib, &Lap2, Strength);
  354. case LAP3:
  355. return ConvoluteDIB(hDib, &Lap3, Strength);
  356. case LAP4:
  357. return ConvoluteDIB(hDib, &Lap4, Strength);
  358. case SOBEL:
  359. return ConvoluteDIB(hDib, Sobel, Strength, 4);
  360. case HOUGH:
  361. return ConvoluteDIB(hDib, Hough, Strength, 4);
  362. }
  364. return FALSE;
  365. }
  367. /************************************************************************* 
  368.  * 
  369.  * MedianFilterDIB() 
  370.  * 
  371.  * Parameters: 
  372.  * 
  373.  * HDIB hDib        - objective DIB handle
  374.  * 
  375.  * Return Value: 
  376.  * 
  377.  * BOOL             - True is success, else False
  378.  * 
  379.  * Description: 
  380.  * 
  381.  * This is the media filtering function to DIB
  382.  * 
  383.  ************************************************************************/ 
  384. BOOL CImgProcess::MedianFilterDIB(HDIB hDib) 
  385. {
  386. ASSERT(NULL != hDib);
  387. WaitCursorBegin();
  389. HDIB hNewDib = NULL;
  390. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  391. WORD wBitCount = DIBBitCount(hDib);
  392. if (wBitCount != 24)
  393. hNewDib = ConvertDIBFormat(hDib, 24, NULL);
  394. else
  395. hNewDib = CopyHandle(hDib);
  397. if (! hNewDib)
  398. {
  399. WaitCursorEnd();
  400. return FALSE;
  401. }
  403. // new DIB attributes
  404. WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
  405. WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
  406. WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);
  407. DWORD dwImageSize = wBytesPerLine * wDIBHeight;
  409. // Allocate and lock memory for filtered image data
  410. HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize);
  411. if (!hFilteredBits) 
  412. {
  413. WaitCursorEnd();
  414. return FALSE;
  415. }
  416. LPSTR lpDestImage = (LPSTR)GlobalLock(hFilteredBits);
  418. // get bits address in DIB
  419. LPSTR lpDIB = (LPSTR)GlobalLock(hNewDib);
  420. LPSTR lpDIBits = ::FindDIBBits(lpDIB);
  422. // convolute...
  423. for (int i=1; i<wDIBHeight-1; i++) 
  424. for (int j=1; j<wDIBWidth-1; j++) 
  425. {
  426. int  red=0, green=0, blue=0; 
  427. DoMedianFilterDIB(&red, &green, &blue, i, j, wBytesPerLine, lpDIBits);
  429. LONG lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  430. *(lpDestImage + lOffset++) = BOUND(blue, 0, 255);
  431. *(lpDestImage + lOffset++) = BOUND(green, 0, 255);
  432. *(lpDestImage + lOffset)   = BOUND(red, 0, 255);
  433. }
  435. // a filtered image is available in lpDestImage
  436. // copy it to DIB bits
  437. memcpy(lpDIBits, lpDestImage, dwImageSize);
  439. // cleanup temp buffers
  440. GlobalUnlock(hFilteredBits);
  441. GlobalFree(hFilteredBits);
  442. GlobalUnlock(hNewDib);
  444. // rebuild hDib
  445. HDIB hTmp = NULL;
  446. if (wBitCount != 24)
  447. hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL);
  448. else
  449. hTmp = CopyHandle(hNewDib);
  450. GlobalFree(hNewDib);
  451. DWORD dwSize = GlobalSize(hTmp);
  452. memcpy((LPSTR)GlobalLock(hDib), (LPSTR)GlobalLock(hTmp), dwSize);
  453. GlobalUnlock(hTmp);
  454. GlobalFree(hTmp);
  455. GlobalUnlock(hDib);
  456. WaitCursorEnd();
  458. return TRUE;
  459. }
  461. /************************************************************************* 
  462.  * 
  463.  * ConvoluteDIB() 
  464.  * 
  465.  * Parameters: 
  466.  * 
  467.  * HDIB hDib        - objective DIB handle
  468.  * KERNEL *lpKernel - pointer of kernel used to convolute with DIB
  469.  * int Strength     - operation strength set to the convolute
  470.  * int nKernelNum   - kernel number used to convolute
  471.  * 
  472.  * Return Value: 
  473.  * 
  474.  * BOOL             - True is success, else False
  475.  * 
  476.  * Description: 
  477.  * 
  478.  * This is the generic convolute function to DIB
  479.  * 
  480.  ************************************************************************/ 
  481. BOOL CImgProcess::ConvoluteDIB(HDIB hDib, KERNEL *lpKernel, int Strength, int nKernelNum) 
  482. {
  483. ASSERT(NULL != hDib);
  484. ASSERT(NULL != lpKernel);
  486. WaitCursorBegin();
  488. HDIB hNewDib = NULL;
  489. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  490. WORD wBitCount = DIBBitCount(hDib);
  491. if (wBitCount != 24)
  492. hNewDib = ConvertDIBFormat(hDib, 24, NULL);
  493. else
  494. hNewDib = CopyHandle(hDib);
  496. if (! hNewDib)
  497. {
  498. WaitCursorEnd();
  499. return FALSE;
  500. }
  502. // new DIB attributes
  503. WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
  504. WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
  505. WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);
  506. DWORD dwImageSize = wBytesPerLine * wDIBHeight;
  508. // Allocate and lock memory for filtered image data
  509. HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize);
  510. if (!hFilteredBits) 
  511. {
  512. WaitCursorEnd();
  513. return FALSE;
  514. }
  515. LPSTR lpDestImage = (LPSTR)GlobalLock(hFilteredBits);
  517. // get bits address in DIB
  518. LPSTR lpDIB = (LPSTR)GlobalLock(hNewDib);
  519. LPSTR lpDIBits = ::FindDIBBits(lpDIB);
  521. // convolute...
  522. for (int i=1; i<wDIBHeight-1; i++) 
  523. {
  524. for (int j=1; j<wDIBWidth-1; j++) 
  525. {
  526. int  red=0, green=0, blue=0; 
  528. for (int k=0; k<nKernelNum; ++k)
  529. {
  530. int r=0, g=0, b=0; 
  531. DoConvoluteDIB(&r, &g, &b, i, j, 
  532. wBytesPerLine, lpDIBits, lpKernel+k);
  533. if (r > red)
  534. red = r;
  535. if (g > green)
  536. green = g;
  537. if (b > blue)
  538. blue = b;
  539. //red += r; green += g; blue += b;
  540. }
  542. // original RGB value in center pixel  (j, i)
  543. LONG lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  544. BYTE OldB = *(lpDIBits + lOffset++);
  545. BYTE OldG = *(lpDIBits + lOffset++);
  546. BYTE OldR = *(lpDIBits + lOffset);
  547. // When we get here, red, green and blue have the new RGB value.
  548. if (Strength != 10) 
  549. {
  550. // Interpolate pixel data
  551. red   = OldR + (((red - OldR) * Strength) / 10);
  552. green = OldG + (((green - OldG) * Strength) / 10);
  553. blue  = OldB + (((blue - OldB) * Strength) / 10);
  554. }
  556. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  557. *(lpDestImage + lOffset++) = BOUND(blue, 0, 255);
  558. *(lpDestImage + lOffset++) = BOUND(green, 0, 255);
  559. *(lpDestImage + lOffset)   = BOUND(red, 0, 255);
  560. }
  561. }
  563. // a filtered image is available in lpDestImage
  564. // copy it to DIB bits
  565. memcpy(lpDIBits, lpDestImage, dwImageSize);
  567. // cleanup temp buffers
  568. GlobalUnlock(hFilteredBits);
  569. GlobalFree(hFilteredBits);
  570. GlobalUnlock(hNewDib);
  572. // rebuild hDib
  573. HDIB hTmp = NULL;
  574. if (wBitCount != 24)
  575. hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL);
  576. else
  577. hTmp = CopyHandle(hNewDib);
  578. GlobalFree(hNewDib);
  579. DWORD dwSize = GlobalSize(hTmp);
  580. memcpy((LPSTR)GlobalLock(hDib), (LPSTR)GlobalLock(hTmp), dwSize);
  581. GlobalUnlock(hTmp);
  582. GlobalFree(hTmp);
  583. GlobalUnlock(hDib);
  584. WaitCursorEnd();
  586. return TRUE;
  587. }
  589. // local function: perform convolution to DIB with a kernel
  590. void CImgProcess::DoConvoluteDIB(int *red, int *green, int *blue, int i, int j, 
  591. WORD wBytesPerLine, LPSTR lpDIBits, KERNEL *lpKernel)
  592. {
  593. BYTE b[9], g[9], r[9];
  594. LONG lOffset;
  596. lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
  597. b[0] = *(lpDIBits + lOffset++);
  598. g[0] = *(lpDIBits + lOffset++);
  599. r[0] = *(lpDIBits + lOffset);
  601. lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
  602. b[1] = *(lpDIBits + lOffset++);
  603. g[1] = *(lpDIBits + lOffset++);
  604. r[1] = *(lpDIBits + lOffset);
  606. lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
  607. b[2] = *(lpDIBits + lOffset++);
  608. g[2] = *(lpDIBits + lOffset++);
  609. r[2] = *(lpDIBits + lOffset);
  611. lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
  612. b[3] = *(lpDIBits + lOffset++);
  613. g[3] = *(lpDIBits + lOffset++);
  614. r[3] = *(lpDIBits + lOffset);
  616. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  617. b[4] = *(lpDIBits + lOffset++);
  618. g[4] = *(lpDIBits + lOffset++);
  619. r[4] = *(lpDIBits + lOffset);
  621. lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
  622. b[5] = *(lpDIBits + lOffset++);
  623. g[5] = *(lpDIBits + lOffset++);
  624. r[5] = *(lpDIBits + lOffset);
  626. lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
  627. b[6] = *(lpDIBits + lOffset++);
  628. g[6] = *(lpDIBits + lOffset++);
  629. r[6] = *(lpDIBits + lOffset);
  631. lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
  632. b[7] = *(lpDIBits + lOffset++);
  633. g[7] = *(lpDIBits + lOffset++);
  634. r[7] = *(lpDIBits + lOffset);
  636. lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
  637. b[8] = *(lpDIBits + lOffset++);
  638. g[8] = *(lpDIBits + lOffset++);
  639. r[8] = *(lpDIBits + lOffset);
  641. *red = *green = *blue = 0;
  642. for (int k=0; k<8; ++k)
  643. {
  644. *red   += lpKernel->Element[k]*r[k];
  645. *green += lpKernel->Element[k]*g[k];
  646. *blue  += lpKernel->Element[k]*b[k];
  647. }
  649. if (lpKernel->Divisor != 1) 
  650. {
  651. *red   /= lpKernel->Divisor;
  652. *green /= lpKernel->Divisor;
  653. *blue  /= lpKernel->Divisor;
  654. }
  656. // getoff opposite
  657. *red   = abs(*red);
  658. *green = abs(*green);
  659. *blue  = abs(*blue);
  660. }
  662. // local function: perform median filter to DIB
  663. void CImgProcess::DoMedianFilterDIB(int *red, int *green, int *blue, int i, int j, 
  664. WORD wBytesPerLine, LPSTR lpDIBits)
  665. {
  666. BYTE b[9], g[9], r[9];
  667. LONG lOffset;
  669. lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
  670. b[0] = *(lpDIBits + lOffset++);
  671. g[0] = *(lpDIBits + lOffset++);
  672. r[0] = *(lpDIBits + lOffset);
  674. lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
  675. b[1] = *(lpDIBits + lOffset++);
  676. g[1] = *(lpDIBits + lOffset++);
  677. r[1] = *(lpDIBits + lOffset);
  679. lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
  680. b[2] = *(lpDIBits + lOffset++);
  681. g[2] = *(lpDIBits + lOffset++);
  682. r[2] = *(lpDIBits + lOffset);
  684. lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
  685. b[3] = *(lpDIBits + lOffset++);
  686. g[3] = *(lpDIBits + lOffset++);
  687. r[3] = *(lpDIBits + lOffset);
  689. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  690. b[4] = *(lpDIBits + lOffset++);
  691. g[4] = *(lpDIBits + lOffset++);
  692. r[4] = *(lpDIBits + lOffset);
  694. lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
  695. b[5] = *(lpDIBits + lOffset++);
  696. g[5] = *(lpDIBits + lOffset++);
  697. r[5] = *(lpDIBits + lOffset);
  699. lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
  700. b[6] = *(lpDIBits + lOffset++);
  701. g[6] = *(lpDIBits + lOffset++);
  702. r[6] = *(lpDIBits + lOffset);
  704. lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
  705. b[7] = *(lpDIBits + lOffset++);
  706. g[7] = *(lpDIBits + lOffset++);
  707. r[7] = *(lpDIBits + lOffset);
  709. lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
  710. b[8] = *(lpDIBits + lOffset++);
  711. g[8] = *(lpDIBits + lOffset++);
  712. r[8] = *(lpDIBits + lOffset);
  714. //    qsort(r, 9, 1, compare);
  715. //    qsort(g, 9, 1, compare);
  716.  //   qsort(b, 9, 1, compare);
  718. *red   = r[0];
  719. *green = g[0];
  720. *blue  = b[0];
  721. }
  723. // function used to sort in the call of qsort
  724. int CImgProcess::compare(const void *e1, const void *e2)
  725. {
  726. if (*(BYTE *)e1 < *(BYTE *)e2)
  727. return -1;
  728. if (*(BYTE *)e1 > *(BYTE *)e2)
  729. return 1;
  731. return 0;
  732. }
  734. /************************************************************************* 
  735.  * 
  736.  * ReverseDIB() 
  737.  * 
  738.  * Parameters: 
  739.  * 
  740.  * HDIB hDib        - objective DIB handle
  741.  * 
  742.  * Return Value: 
  743.  * 
  744.  * BOOL             - True is success, else False
  745.  * 
  746.  * Description: 
  747.  * 
  748.  * This function reverse DIB
  749.  * 
  750.  ************************************************************************/ 
  751. BOOL CImgProcess::ReverseDIB(HDIB hDib) 
  752. {
  753. WaitCursorBegin();
  755. HDIB hNewDib = NULL;
  756. // only support 256 grayscale image
  757. WORD wBitCount = DIBBitCount(hDib);
  758. if (wBitCount != 8)
  759. {
  760. WaitCursorEnd();
  761. return FALSE;
  762. }
  764. // the maxium pixel value
  765. int  nMaxValue = 256;
  767. // source pixel data
  768.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  769. if (! lpSrcDIB)
  770. {
  771. WaitCursorBegin();
  772. return FALSE;
  773. }
  775. // new DIB attributes
  776. LPSTR lpPtr;
  777. LONG lHeight = DIBHeight(lpSrcDIB);
  778. LONG lWidth = DIBWidth(lpSrcDIB);
  779. DWORD dwBufferSize = GlobalSize(hDib);
  780. int nLineBytes = BytesPerLine(lpSrcDIB);
  782. // convolute...
  783. for (long i=0; i<lHeight; i++) 
  784. for (long j=0; j<lWidth; j++) 
  785. {
  786. lpPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-i*nLineBytes)+j;
  787. *lpPtr = nMaxValue - *lpPtr;
  788. }
  790. // cleanup
  791. GlobalUnlock(hDib);
  792. WaitCursorEnd();
  794. return TRUE;
  795. }
  797. /************************************************************************* 
  798.  * 
  799.  * ErosionDIB() 
  800.  * 
  801.  * Parameters: 
  802.  * 
  803.  * HDIB hDib        - objective DIB handle
  804.  * BOOL bHori     - erosion direction
  805.  * 
  806.  * Return Value: 
  807.  * 
  808.  * BOOL             - True is success, else False
  809.  * 
  810.  * Description: 
  811.  * 
  812.  * This function do erosion with the specified direction
  813.  * 
  814.  ************************************************************************/ 
  815. BOOL CImgProcess::ErosionDIB(HDIB hDib, BOOL bHori)
  816. {
  817. // start wait cursor
  818. WaitCursorBegin();
  820.     // Old DIB buffer
  821. if (hDib == NULL)
  822. {
  823. WaitCursorEnd();
  824.         return FALSE;
  825. }
  827. // only support 256 color image
  828. WORD wBitCount = DIBBitCount(hDib);
  829. if (wBitCount != 8)
  830. {
  831. WaitCursorEnd();
  832.         return FALSE;
  833. }
  835. // new DIB
  836. HDIB hNewDIB = CopyHandle(hDib);
  837. if (! hNewDIB)
  838. {
  839. WaitCursorEnd();
  840.         return FALSE;
  841. }
  843. // source dib buffer
  844.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  845. if (! lpSrcDIB)
  846. {
  847. WaitCursorBegin();
  848. return FALSE;
  849. }
  850.     // New DIB buffer
  851.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  852. if (! lpbmi)
  853. {
  854. WaitCursorBegin();
  855. return FALSE;
  856. }
  858. // start erosion...
  859. LPSTR lpPtr;
  860. LPSTR lpTempPtr;
  861. LONG  x,y;
  862. BYTE  num, num0;
  863. int   i;
  864. LONG lHeight = DIBHeight(lpSrcDIB);
  865. LONG lWidth = DIBWidth(lpSrcDIB);
  866. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  867. int nLineBytes = BytesPerLine(lpSrcDIB);
  868. if(bHori)
  869. {
  870. for (y=0; y<lHeight; y++)
  871. {
  872. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  873. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  874. for (x=1; x<lWidth-1; x++)
  875. {
  876. num0 = num = 0 ;
  877. for(i=0;i<3;i++)
  878. {
  879. num=(unsigned char)*(lpPtr+i-1);
  880. if(num > num0)
  881. num0 = num;
  882. }
  883. *lpTempPtr=(unsigned char)num0;
  884. /*
  885. num=(unsigned char)*lpPtr;
  886. if (num==0)
  887. {
  888. *lpTempPtr=(unsigned char)0;
  889. for(i=0;i<3;i++)
  890. {
  891. num=(unsigned char)*(lpPtr+i-1);
  892. if(num==255)
  893. {
  894. *lpTempPtr=(unsigned char)255;
  895. break;
  896. }
  897. }
  898. }
  899. else 
  900. *lpTempPtr=(unsigned char)255;
  901. */
  902. lpPtr++;
  903. lpTempPtr++;
  904. }
  905. }
  906. }
  907. else // Vertical
  908. {
  909. for (y=1; y<lHeight-1; y++)
  910. {
  911. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  912. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  913. for (x=0; x<lWidth; x++)
  914. {
  915. num0 = num = 0 ;
  916. for(i=0;i<3;i++)
  917. {
  918. num=(unsigned char)*(lpPtr+i-1);
  919. if(num > num0)
  920. num0 = num;
  921. }
  922. *lpTempPtr=(unsigned char)num0;
  923. /*
  924. num=(unsigned char)*lpPtr;
  925. if (num==0)
  926. {
  927. *lpTempPtr=(unsigned char)0;
  928. for(i=0;i<3;i++)
  929. {
  930. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  931. if(num==255)
  932. {
  933. *lpTempPtr=(unsigned char)255;
  934. break;
  935. }
  936. }
  937. }
  938. else 
  939. *lpTempPtr=(unsigned char)255;
  940. */
  941. lpPtr++;
  942. lpTempPtr++;
  943. }
  944. }
  945. }
  947. // cleanup
  948. GlobalUnlock(hDib);
  949. GlobalUnlock(hNewDIB);
  950. GlobalFree(hNewDIB);
  951. WaitCursorEnd();
  953. return TRUE;
  954. }
  956. /************************************************************************* 
  957.  * 
  958.  * DilationDIB() 
  959.  * 
  960.  * Parameters: 
  961.  * 
  962.  * HDIB hDib        - objective DIB handle
  963.  * BOOL bHori     - dilation direction
  964.  * 
  965.  * Return Value: 
  966.  * 
  967.  * BOOL             - True is success, else False
  968.  * 
  969.  * Description: 
  970.  * 
  971.  * This function do dilation with the specified direction
  972.  * 
  973.  ************************************************************************/ 
  974. BOOL CImgProcess::DilationDIB(HDIB hDib, BOOL bHori)
  975. {
  976. // start wait cursor
  977. WaitCursorBegin();
  979.     // Old DIB buffer
  980. if (hDib == NULL)
  981. {
  982. WaitCursorEnd();
  983.         return FALSE;
  984. }
  986. // only support 256 color image
  987. WORD wBitCount = DIBBitCount(hDib);
  988. if (wBitCount != 8)
  989. {
  990. WaitCursorEnd();
  991.         return FALSE;
  992. }
  994. // new DIB
  995. HDIB hNewDIB = CopyHandle(hDib);
  996. if (! hNewDIB)
  997. {
  998. WaitCursorEnd();
  999.         return FALSE;
  1000. }
  1002. // source dib buffer
  1003.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  1004. if (! lpSrcDIB)
  1005. {
  1006. WaitCursorBegin();
  1007. return FALSE;
  1008. }
  1009.     // New DIB buffer
  1010.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1011. if (! lpbmi)
  1012. {
  1013. WaitCursorBegin();
  1014. return FALSE;
  1015. }
  1017. // start erosion...
  1018. LPSTR lpPtr;
  1019. LPSTR lpTempPtr;
  1020. LONG  x,y;
  1021. BYTE  num, num0;
  1022. int   i;
  1023. LONG lHeight = DIBHeight(lpSrcDIB);
  1024. LONG lWidth = DIBWidth(lpSrcDIB);
  1025. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1026. int nLineBytes = BytesPerLine(lpSrcDIB);
  1027. if(bHori)
  1028. {
  1029. for(y=0;y<lHeight;y++)
  1030. {
  1031. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1032. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1033. for(x=1;x<lWidth-1;x++)
  1034. {
  1035. num0 = num = 255;
  1036. for(i=0;i<3;i++)
  1037. {
  1038. num=(unsigned char)*(lpPtr+i-1);
  1039. if(num < num0)
  1040. num0 = num;
  1041. }
  1042. *lpTempPtr=(unsigned char)num0;
  1043. /*
  1044. num=(unsigned char)*lpPtr;
  1045. if (num==255)
  1046. {
  1047. *lpTempPtr=(unsigned char)255;
  1048. for(i=0;i<3;i++)
  1049. {
  1050. num=(unsigned char)*(lpPtr+i-1);
  1051. if(num==0)
  1052. {
  1053. *lpTempPtr=(unsigned char)0;
  1054. break;
  1055. }
  1056. }
  1057. }
  1058. else 
  1059. *lpTempPtr=(unsigned char)0;
  1060. */
  1061. lpPtr++;
  1062. lpTempPtr++;
  1063. }
  1064. }
  1065. }
  1066. else
  1067. {
  1068. for(y=1;y<lHeight-1;y++)
  1069. {
  1070. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1071. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1072. for(x=0;x<lWidth;x++)
  1073. {
  1074. num0 = num = 255;
  1075. for(i=0;i<3;i++)
  1076. {
  1077. num=(unsigned char)*(lpPtr+i-1);
  1078. if(num < num0)
  1079. num0 = num;
  1080. }
  1081. *lpTempPtr=(unsigned char)num0;
  1082. /*
  1083. num=(unsigned char)*lpPtr;
  1084. if (num==255)
  1085. {
  1086. *lpTempPtr=(unsigned char)255;
  1087. for(i=0;i<3;i++)
  1088. {
  1089. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  1090. if(num==0)
  1091. {
  1092. *lpTempPtr=(unsigned char)0;
  1093. break;
  1094. }
  1095. }
  1096. }
  1097. else 
  1098. *lpTempPtr=(unsigned char)0;
  1099. */
  1100. lpPtr++;
  1101. lpTempPtr++;
  1102. }
  1103. }
  1104. }
  1106. // cleanup
  1107. GlobalUnlock(hDib);
  1108. GlobalUnlock(hNewDIB);
  1109. GlobalFree(hNewDIB);
  1110. WaitCursorEnd();
  1112. return TRUE;
  1113. }
  1115. /************************************************************************* 
  1116.  * 
  1117.  * MorphOpenDIB() 
  1118.  * 
  1119.  * Parameters: 
  1120.  * 
  1121.  * HDIB hDib        - objective DIB handle
  1122.  * BOOL bHori     - open direction
  1123.  * 
  1124.  * Return Value: 
  1125.  * 
  1126.  * BOOL             - True is success, else False
  1127.  * 
  1128.  * Description: 
  1129.  * 
  1130.  * This function do open with the specified direction
  1131.  * 
  1132.  ************************************************************************/ 
  1133. BOOL CImgProcess::MorphOpenDIB(HDIB hDib, BOOL bHori)
  1134. {
  1135. // Step 1: erosion
  1136. if (! ErosionDIB(hDib, bHori))
  1137. return FALSE;
  1139. // Step 2: dilation
  1140. if (! DilationDIB(hDib, bHori))
  1141. return FALSE;
  1143. return TRUE;
  1144. }
  1146. /************************************************************************* 
  1147.  * 
  1148.  * MorphCloseDIB() 
  1149.  * 
  1150.  * Parameters: 
  1151.  * 
  1152.  * HDIB hDib        - objective DIB handle
  1153.  * BOOL bHori     - close direction
  1154.  * 
  1155.  * Return Value: 
  1156.  * 
  1157.  * BOOL             - True is success, else False
  1158.  * 
  1159.  * Description: 
  1160.  * 
  1161.  * This function do close with the specified direction
  1162.  * 
  1163.  ************************************************************************/ 
  1164. BOOL CImgProcess::MorphCloseDIB(HDIB hDib, BOOL bHori)
  1165. {
  1166. // Step 1: dilation
  1167. if (! DilationDIB(hDib, bHori))
  1168. return FALSE;
  1170. // Step 2: erosion
  1171. if (! ErosionDIB(hDib, bHori))
  1172. return FALSE;
  1174. return TRUE;
  1175. }
  1177. /************************************************************************* 
  1178.  * 
  1179.  * ContourDIB() 
  1180.  * 
  1181.  * Parameters: 
  1182.  * 
  1183.  * HDIB hDib        - objective DIB handle
  1184.  * BOOL bHori     - open direction
  1185.  * 
  1186.  * Return Value: 
  1187.  * 
  1188.  * BOOL             - True is success, else False
  1189.  * 
  1190.  * Description: 
  1191.  * 
  1192.  * This function contour DIB with the specified direction
  1193.  * 
  1194.  ************************************************************************/ 
  1195. BOOL CImgProcess::ContourDIB(HDIB hDib, BOOL bHori)
  1196. {
  1197. // start wait cursor
  1198. WaitCursorBegin();
  1200.     // Old DIB buffer
  1201. if (hDib == NULL)
  1202. {
  1203. WaitCursorEnd();
  1204.         return FALSE;
  1205. }
  1207. // only support 256 color image
  1208. WORD wBitCount = DIBBitCount(hDib);
  1209. if (wBitCount != 8)
  1210. {
  1211. WaitCursorEnd();
  1212.         return FALSE;
  1213. }
  1215. // new DIB
  1216. HDIB hNewDIB = CopyHandle(hDib);
  1217. if (! hNewDIB)
  1218. {
  1219. WaitCursorEnd();
  1220.         return FALSE;
  1221. }
  1223. // source dib buffer
  1224.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  1225. if (! lpSrcDIB)
  1226. {
  1227. WaitCursorBegin();
  1228. return FALSE;
  1229. }
  1230.     // New DIB buffer
  1231.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1232. if (! lpbmi)
  1233. {
  1234. WaitCursorBegin();
  1235. return FALSE;
  1236. }
  1238. // start erosion...
  1239. LPSTR lpPtr;
  1240. LPSTR lpTempPtr;
  1241. LONG  x,y;
  1242. BYTE  num, num0;
  1243. int   i;
  1244. LONG lHeight = DIBHeight(lpSrcDIB);
  1245. LONG lWidth = DIBWidth(lpSrcDIB);
  1246. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1247. int nLineBytes = BytesPerLine(lpSrcDIB);
  1249. // Step 1: erosion
  1250. if(bHori)
  1251. {
  1252. for (y=0; y<lHeight; y++)
  1253. {
  1254. lpPtr=(LPSTR)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1255. lpTempPtr=(LPSTR)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1256. for (x=1; x<lWidth-1; x++)
  1257. {
  1258. num0 = num = 0 ;
  1259. for(i=0;i<3;i++)
  1260. {
  1261. num=(unsigned char)*(lpPtr+i-1);
  1262. if(num > num0)
  1263. num0 = num;
  1264. }
  1265. *lpTempPtr=(unsigned char)num0;
  1266. /*
  1267. num=(unsigned char)*lpPtr;
  1268. if (num==0)
  1269. {
  1270. *lpTempPtr=(unsigned char)0;
  1271. for(i=0;i<3;i++)
  1272. {
  1273. num=(unsigned char)*(lpPtr+i-1);
  1274. if(num==255)
  1275. {
  1276. *lpTempPtr=(unsigned char)255;
  1277. break;
  1278. }
  1279. }
  1280. }
  1281. else 
  1282. *lpTempPtr=(unsigned char)255;
  1283. */
  1284. lpPtr++;
  1285. lpTempPtr++;
  1286. }
  1287. }
  1288. }
  1289. else // Vertical
  1290. {
  1291. for (y=1; y<lHeight-1; y++)
  1292. {
  1293. lpPtr=(LPSTR)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1294. lpTempPtr=(LPSTR)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1295. for (x=0; x<lWidth; x++)
  1296. {
  1297. num0 = num = 0 ;
  1298. for(i=0;i<3;i++)
  1299. {
  1300. num=(unsigned char)*(lpPtr+i-1);
  1301. if(num > num0)
  1302. num0 = num;
  1303. }
  1304. *lpTempPtr=(unsigned char)num0;
  1305. /*
  1306. num=(unsigned char)*lpPtr;
  1307. if (num==0)
  1308. {
  1309. *lpTempPtr=(unsigned char)0;
  1310. for(i=0;i<3;i++)
  1311. {
  1312. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  1313. if(num==255)
  1314. {
  1315. *lpTempPtr=(unsigned char)255;
  1316. break;
  1317. }
  1318. }
  1319. }
  1320. else 
  1321. *lpTempPtr=(unsigned char)255;
  1322. */
  1323. lpPtr++;
  1324. lpTempPtr++;
  1325. }
  1326. }
  1327. }
  1329. // Step 2: original image minues dilation image
  1330. if(bHori)
  1331. {
  1332. for(y=0;y<lHeight;y++)
  1333. {
  1334. lpPtr=(LPSTR)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1335. lpTempPtr=(LPSTR)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1336. for(x=1;x<lWidth-1;x++)
  1337. {
  1338. if (*lpTempPtr == *lpPtr)
  1339. *lpTempPtr = (BYTE)255;
  1340. else
  1341. *lpTempPtr = *lpTempPtr - *lpPtr;
  1343. lpPtr++;
  1344. lpTempPtr++;
  1345. }
  1346. }
  1347. }
  1348. else
  1349. {
  1350. for(y=1;y<lHeight-1;y++)
  1351. {
  1352. lpPtr=(LPSTR)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1353. lpTempPtr=(LPSTR)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1354. for(x=0;x<lWidth;x++)
  1355. {
  1356. if (*lpTempPtr == *lpPtr)
  1357. *lpTempPtr = (BYTE)255;
  1358. else
  1359. *lpTempPtr = *lpTempPtr - *lpPtr;
  1361. lpPtr++;
  1362. lpTempPtr++;
  1363. }
  1364. }
  1365. }
  1367. // cleanup
  1368. GlobalUnlock(hDib);
  1369. GlobalUnlock(hNewDIB);
  1370. GlobalFree(hNewDIB);
  1372. return TRUE;
  1373. }
  1375. /************************************************************************* 
  1376.  * 
  1377.  * ThinningDIB() 
  1378.  * 
  1379.  * Parameters: 
  1380.  * 
  1381.  * HDIB hDib        - objective DIB handle
  1382.  * 
  1383.  * Return Value: 
  1384.  * 
  1385.  * BOOL             - True is success, else False
  1386.  * 
  1387.  * Description: 
  1388.  * 
  1389.  * This function thins a DIB
  1390.  * 
  1391.  ************************************************************************/ 
  1392. BOOL CImgProcess::ThinningDIB(HDIB hDib)
  1393. {
  1394. static int erasetable[256]=
  1395. {
  1396. 0,0,1,1,0,0,1,1,
  1397. 1,1,0,1,1,1,0,1,
  1398. 1,1,0,0,1,1,1,1,
  1399. 0,0,0,0,0,0,0,1,
  1401. 0,0,1,1,0,0,1,1,
  1402. 1,1,0,1,1,1,0,1,
  1403. 1,1,0,0,1,1,1,1,
  1404. 0,0,0,0,0,0,0,1,
  1406. 1,1,0,0,1,1,0,0,
  1407. 0,0,0,0,0,0,0,0,
  1408. 0,0,0,0,0,0,0,0,
  1409. 0,0,0,0,0,0,0,0,
  1411. 1,1,0,0,1,1,0,0,
  1412. 1,1,0,1,1,1,0,1,
  1413. 0,0,0,0,0,0,0,0,
  1414. 0,0,0,0,0,0,0,0,
  1416. 0,0,1,1,0,0,1,1,
  1417. 1,1,0,1,1,1,0,1,
  1418. 1,1,0,0,1,1,1,1,
  1419. 0,0,0,0,0,0,0,1,
  1421. 0,0,1,1,0,0,1,1,
  1422. 1,1,0,1,1,1,0,1,
  1423. 1,1,0,0,1,1,1,1,
  1424. 0,0,0,0,0,0,0,0,
  1426. 1,1,0,0,1,1,0,0,
  1427. 0,0,0,0,0,0,0,0,
  1428. 1,1,0,0,1,1,1,1,
  1429. 0,0,0,0,0,0,0,0,
  1431. 1,1,0,0,1,1,0,0,
  1432. 1,1,0,1,1,1,0,0,
  1433. 1,1,0,0,1,1,1,0,
  1434. 1,1,0,0,1,0,0,0
  1435. };
  1437. // start wait cursor
  1438. WaitCursorBegin();
  1440.     // Old DIB buffer
  1441. if (hDib == NULL)
  1442. {
  1443. WaitCursorEnd();
  1444.         return FALSE;
  1445. }
  1447. // only support 256 color image
  1448. WORD wBitCount = DIBBitCount(hDib);
  1449. if (wBitCount != 8)
  1450. {
  1451. WaitCursorEnd();
  1452.         return FALSE;
  1453. }
  1455. // new DIB
  1456. HDIB hNewDIB = CopyHandle(hDib);
  1457. if (! hNewDIB)
  1458. {
  1459. WaitCursorEnd();
  1460.         return FALSE;
  1461. }
  1463. // source dib buffer
  1464.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  1465. if (! lpSrcDIB)
  1466. {
  1467. WaitCursorBegin();
  1468. return FALSE;
  1469. }
  1470.     // New DIB buffer
  1471.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1472. if (! lpbmi)
  1473. {
  1474. WaitCursorBegin();
  1475. return FALSE;
  1476. }
  1478. // start erosion...
  1479. LPSTR lpPtr;
  1480. LPSTR lpTempPtr;
  1481. LONG  x,y;
  1482. BYTE  num;
  1483. LONG lHeight = DIBHeight(lpSrcDIB);
  1484. LONG lWidth = DIBWidth(lpSrcDIB);
  1485. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1486. int nLineBytes = BytesPerLine(lpSrcDIB);
  1487. int nw,n,ne,w,e,sw,s,se;
  1489. BOOL Finished=FALSE;
  1490.     while(!Finished)
  1491. {
  1492.      Finished=TRUE;
  1493. for (y=1;y<lHeight-1;y++)
  1494. { 
  1495. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1496. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1497. x=1; 
  1498. while(x<lWidth-1)
  1499. {
  1500. if(*(lpPtr+x)==0)
  1501. {
  1502. w=(unsigned char)*(lpPtr+x-1);
  1503. e=(unsigned char)*(lpPtr+x+1);
  1504. if( (w==255)|| (e==255))
  1505. {
  1506. nw=(unsigned char)*(lpPtr+x+nLineBytes-1);
  1507. n=(unsigned char)*(lpPtr+x+nLineBytes);
  1508. ne=(unsigned char)*(lpPtr+x+nLineBytes+1);
  1509. sw=(unsigned char)*(lpPtr+x-nLineBytes-1);
  1510. s=(unsigned char)*(lpPtr+x-nLineBytes);
  1511. se=(unsigned char)*(lpPtr+x-nLineBytes+1);
  1512. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  1513. if(erasetable[num]==1)
  1514. {
  1515. *(lpPtr+x)=(BYTE)255;
  1516. *(lpTempPtr+x)=(BYTE)255;
  1517. Finished=FALSE;
  1518. x++;
  1519. }
  1520. }
  1521. }
  1522. x++;
  1523. }
  1524. }
  1526. for (x=1;x<lWidth-1;x++)
  1527. { 
  1528. y=1;
  1529. while(y<lHeight-1)
  1530. {
  1531. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1532. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1533. if(*(lpPtr+x)==0)
  1534. {
  1535. n=(unsigned char)*(lpPtr+x+nLineBytes);
  1536. s=(unsigned char)*(lpPtr+x-nLineBytes);
  1537. if( (n==255)|| (s==255))
  1538. {
  1539. nw=(unsigned char)*(lpPtr+x+nLineBytes-1);
  1540. ne=(unsigned char)*(lpPtr+x+nLineBytes+1);
  1541. w=(unsigned char)*(lpPtr+x-1);
  1542. e=(unsigned char)*(lpPtr+x+1);
  1543. sw=(unsigned char)*(lpPtr+x-nLineBytes-1);
  1544. se=(unsigned char)*(lpPtr+x-nLineBytes+1);
  1545. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  1546. if(erasetable[num]==1)
  1547. {
  1548. *(lpPtr+x)=(BYTE)255;
  1549. *(lpTempPtr+x)=(BYTE)255;
  1550. Finished=FALSE;
  1551. y++;
  1552. }
  1553. }
  1554. }
  1555. y++;
  1556. }
  1557. } 
  1558. }
  1560. // cleanup
  1561. GlobalUnlock(hDib);
  1562. GlobalUnlock(hNewDIB);
  1563. GlobalFree(hNewDIB);
  1565. return TRUE;
  1566. }
  1568. //////////////////////////////////////////////////////////
  1569. // internal definitions
  1571. //#define PAI (double)3.14159265359
  1573. //////////////////////////////////////////////////////////////////////////////////
  1574. // internal functions
  1575. void CImgProcess::GetPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  1576. {
  1577. int x,y,p;
  1578. int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
  1579. //if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1581. for(y=0;y<nHeight;y++)
  1582. {
  1583. for(x=0;x<nWidth;x++)
  1584. {
  1585. p=x*3+y*nByteWidth;
  1586. lpPoints[x+y*nWidth]=(BYTE)(0.299*(float)lpBits[p+2]+0.587*(float)lpBits[p+1]+0.114*(float)lpBits[p]+0.1);
  1587. }
  1588. }
  1589. }
  1591. void CImgProcess::PutPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  1592. {
  1593. int x,y,p,p1;
  1594. int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
  1595. //if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1597. for(y=0;y<nHeight;y++)
  1598. {
  1599. for(x=0;x<nWidth;x++)
  1600. {
  1601. p=x*3+y*nByteWidth;
  1602. p1=x+y*nWidth;
  1603. lpBits[p]=lpPoints[p1];
  1604. lpBits[p+1]=lpPoints[p1];
  1605. lpBits[p+2]=lpPoints[p1];
  1606. }
  1607. }
  1608. }
  1609. //////////////////////////////////////////////////////////////////////////////
  1611. /****************************************************
  1612. FFTDIB()
  1614. 参数：
  1616. hDIB为输入的DIB句柄
  1618. 返回值：
  1620. 成功为TRUE；失败为FALSE
  1622. 说明：
  1624. 本函数实现DIB位图的快速傅立叶变换
  1625. ****************************************************/
  1626. BOOL CImgProcess::FFTDIB(HDIB hDIB)
  1627. {
  1628. if (hDIB == NULL)
  1629. return FALSE;
  1631. // start wait cursor
  1632. WaitCursorBegin();
  1634. HDIB hDib = NULL;
  1635. HDIB hNewDib = NULL;
  1636. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  1637. WORD wBitCount = DIBBitCount(hDIB);
  1638. if (wBitCount != 24)
  1639. {
  1640. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  1641. hDib = CopyHandle(hNewDib);
  1642. }
  1643. else
  1644. {
  1645. hNewDib = CopyHandle(hDIB);
  1646. hDib = CopyHandle(hDIB);
  1647. }
  1649. if (hNewDib == NULL && hDib == NULL)
  1650. {
  1651. WaitCursorEnd();
  1652. return FALSE;
  1653. }
  1655. // process!
  1656. LPSTR lpSrcDIB = (LPSTR)GlobalLock(hDib);
  1657. LPSTR lpDIB = (LPSTR)GlobalLock(hNewDib);
  1658. LPSTR lpInput = FindDIBBits(lpSrcDIB);
  1659. LPSTR lpOutput = FindDIBBits(lpDIB);
  1660. int nWidth = DIBWidth(lpSrcDIB);
  1661. int nHeight = DIBHeight(lpSrcDIB);
  1663. int w=1,h=1,wp=0,hp=0;
  1664. while(w*2<=nWidth)
  1665. {
  1666. w*=2;
  1667. wp++;
  1668. }
  1669. while(h*2<=nHeight)
  1670. {
  1671. h*=2;
  1672. hp++;
  1673. }
  1674. int x,y;
  1675. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1676. GetPoints(nWidth,nHeight,(BYTE*)lpInput,lpPoints);
  1678. COMPLEX *TD=new COMPLEX[w*h];
  1679. COMPLEX *FD=new COMPLEX[w*h];
  1681. for(y=0;y<h;y++)
  1682. {
  1683. for(x=0;x<w;x++)
  1684. {
  1685. TD[x+w*y].re = lpPoints[x + y * nWidth];
  1686. TD[x+w*y].im = 0;
  1687. }
  1688. }
  1690. for(y=0;y<h;y++)
  1691. {
  1692. if(!CMathEx::FFT(&TD[w*y],&FD[w*y],wp))
  1693. {
  1694. GlobalFree(hDib);
  1695. GlobalFree(hNewDib);
  1696. delete TD;
  1697. delete FD;
  1698. delete lpPoints;
  1699. return FALSE;
  1700. }
  1701. }
  1702. for(y=0;y<h;y++)
  1703. {
  1704. for(x=0;x<w;x++)
  1705. {
  1706. TD[y+h*x]=FD[x+w*y];
  1707. // TD[x+w*y]=FD[x*h+y];
  1708. }
  1709. }
  1710. for(x=0;x<w;x++)
  1711. {
  1712. if(!CMathEx::FFT(&TD[x*h],&FD[x*h],hp))
  1713. {
  1714. GlobalFree(hDib);
  1715. GlobalFree(hNewDib);
  1716. delete TD;
  1717. delete FD;
  1718. delete lpPoints;
  1719. return FALSE;
  1720. }
  1721. }
  1723. memset(lpPoints,0,nWidth*nHeight);
  1724. double m;
  1725. for(y=0;y<h;y++)
  1726. {
  1727. for(x=0;x<w;x++)
  1728. {
  1729. m = sqrt(FD[x*h+y].re*FD[x*h+y].re+FD[x*h+y].im*FD[x*h+y].im)/100;
  1730. if (m>255) m=255;
  1731. // Point((x<w/2?x+w/2:x-w/2),nHeight-1-(y<h/2?y+h/2:y-h/2))=(BYTE)(m);
  1732. lpPoints[(x < w/2 ? x+w/2 : x-w/2) + (nHeight-1-(y<h/2 ? y+h/2 : y-h/2)) * nWidth] = (BYTE)(m);
  1733. }
  1734. }
  1735. delete TD;
  1736. delete FD;
  1737. PutPoints(nWidth,nHeight,(BYTE*)lpOutput,lpPoints);
  1738. delete lpPoints;
  1740. // recover
  1741. DWORD dwSize = GlobalSize(hDib);
  1742. memcpy(lpSrcDIB, lpDIB, dwSize);
  1743. GlobalUnlock(hDib);
  1744. GlobalUnlock(hNewDib);
  1745. if (wBitCount != 24)
  1746. {
  1747. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  1749. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  1750. lpDIB = (LPSTR)GlobalLock(hNewDib);
  1751. dwSize = GlobalSize(hNewDib);
  1752. memcpy(lpSrcDIB, lpDIB, dwSize);
  1753. GlobalUnlock(hDIB);
  1754. GlobalUnlock(hNewDib);
  1755. }
  1756. else
  1757. {
  1758. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  1759. lpDIB = (LPSTR)GlobalLock(hDib);
  1760. dwSize = GlobalSize(hDib);
  1761. memcpy(lpSrcDIB, lpDIB, dwSize);
  1762. GlobalUnlock(hDIB);
  1763. GlobalUnlock(hDib);
  1764. }
  1766. // cleanup
  1767. GlobalFree(hDib);
  1768. GlobalFree(hNewDib);
  1770. // return
  1771. WaitCursorEnd();
  1772. return TRUE;
  1773. }
  1775. /****************************************************
  1776. DCTDIB()
  1778. 参数：
  1780. hDIB为输入的DIB句柄
  1782. 返回值：
  1784. 成功为TRUE；失败为FALSE
  1786. 说明：
  1788. 本函数实现DIB位图的快速余弦变换
  1789. ****************************************************/
  1790. BOOL CImgProcess::DCTDIB(HDIB hDIB)
  1791. {
  1792. if (hDIB == NULL)
  1793. return FALSE;
  1795. // start wait cursor
  1796. WaitCursorBegin();
  1798. HDIB hDib = NULL;
  1799. HDIB hNewDib = NULL;
  1800. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  1801. WORD wBitCount = DIBBitCount(hDIB);
  1802. if (wBitCount != 24)
  1803. {
  1804. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  1805. hDib = CopyHandle(hNewDib);
  1806. }
  1807. else
  1808. {
  1809. hNewDib = CopyHandle(hDIB);
  1810. hDib = CopyHandle(hDIB);
  1811. }
  1813. if (hNewDib == NULL && hDib == NULL)
  1814. {
  1815. WaitCursorEnd();
  1816. return FALSE;
  1817. }
  1819. // process!
  1820. LPSTR lpSrcDIB = (LPSTR)GlobalLock(hDib);
  1821. LPSTR lpDIB = (LPSTR)GlobalLock(hNewDib);
  1822. LPSTR lpInput = FindDIBBits(lpSrcDIB);
  1823. LPSTR lpOutput = FindDIBBits(lpDIB);
  1824. int nWidth = DIBWidth(lpSrcDIB);
  1825. int nHeight = DIBHeight(lpSrcDIB);
  1827. int w=1,h=1,wp=0,hp=0;
  1828. while(w*2<=nWidth)
  1829. {
  1830. w*=2;
  1831. wp++;
  1832. }
  1833. while(h*2<=nHeight)
  1834. {
  1835. h*=2;
  1836. hp++;
  1837. }
  1838. int x,y;
  1839. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1840. GetPoints(nWidth,nHeight,(BYTE*)lpInput,lpPoints);
  1842. double *f=new double[w*h];
  1843. double *W=new double[w*h];
  1845. for(y=0;y<h;y++)
  1846. {
  1847. for(x=0;x<w;x++)
  1848. {
  1849. f[x+y*w] = lpPoints[x + y * nWidth];
  1850. }
  1851. }
  1853. for(y=0;y<h;y++)
  1854. {
  1855. CMathEx::DCT(&f[w*y],&W[w*y],wp);
  1856. }
  1857. for(y=0;y<h;y++)
  1858. {
  1859. for(x=0;x<w;x++)
  1860. {
  1861. f[x*h+y]=W[x+w*y];
  1862. }
  1863. }
  1864. for(x=0;x<w;x++)
  1865. {
  1866. CMathEx::DCT(&f[x*h],&W[x*h],hp);
  1867. }
  1868. double a;
  1869. memset(lpPoints,0,nWidth*nHeight);
  1871. for(y=0;y<h;y++)
  1872. {
  1873. for(x=0;x<w;x++)
  1874. {
  1875. a=fabs(W[x*h+y]);
  1876. if (a>255) a=255;
  1877. lpPoints[x + (nHeight-y-1) * nWidth] = (BYTE)(a);
  1878. }
  1879. }
  1880. delete f;
  1881. delete W;
  1882. PutPoints(nWidth,nHeight,(BYTE*)lpOutput,lpPoints);
  1883. delete lpPoints;
  1885. // recover
  1886. DWORD dwSize = GlobalSize(hDib);
  1887. memcpy(lpSrcDIB, lpDIB, dwSize);
  1888. GlobalUnlock(hDib);
  1889. GlobalUnlock(hNewDib);
  1890. if (wBitCount != 24)
  1891. {
  1892. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  1894. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  1895. lpDIB = (LPSTR)GlobalLock(hNewDib);
  1896. dwSize = GlobalSize(hNewDib);
  1897. memcpy(lpSrcDIB, lpDIB, dwSize);
  1898. GlobalUnlock(hDIB);
  1899. GlobalUnlock(hNewDib);
  1900. }
  1901. else
  1902. {
  1903. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  1904. lpDIB = (LPSTR)GlobalLock(hDib);
  1905. dwSize = GlobalSize(hDib);
  1906. memcpy(lpSrcDIB, lpDIB, dwSize);
  1907. GlobalUnlock(hDIB);
  1908. GlobalUnlock(hDib);
  1909. }
  1911. // cleanup
  1912. GlobalFree(hDib);
  1913. GlobalFree(hNewDib);
  1915. // return
  1916. WaitCursorEnd();
  1917. return TRUE;
  1918. }
  1920. /****************************************************
  1921. WALhDIB()
  1923. 参数：
  1925. hDIB为输入的DIB句柄
  1927. 返回值：
  1929. 成功为TRUE；失败为FALSE
  1931. 说明：
  1933. 本函数实现DIB位图的快速沃尔什-哈达玛变换
  1934. ****************************************************/
  1935. BOOL CImgProcess::WALhDIB(HDIB hDIB)
  1936. {
  1937. if (hDIB == NULL)
  1938. return FALSE;
  1940. // start wait cursor
  1941. WaitCursorBegin();
  1943. HDIB hDib = NULL;
  1944. HDIB hNewDib = NULL;
  1945. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  1946. WORD wBitCount = DIBBitCount(hDIB);
  1947. if (wBitCount != 24)
  1948. {
  1949. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  1950. hDib = CopyHandle(hNewDib);
  1951. }
  1952. else
  1953. {
  1954. hNewDib = CopyHandle(hDIB);
  1955. hDib = CopyHandle(hDIB);
  1956. }
  1958. if (hNewDib == NULL && hDib == NULL)
  1959. {
  1960. WaitCursorEnd();
  1961. return FALSE;
  1962. }
  1964. // process!
  1965. LPSTR lpSrcDIB = (LPSTR)GlobalLock(hDib);
  1966. LPSTR lpDIB = (LPSTR)GlobalLock(hNewDib);
  1967. LPSTR lpInput = FindDIBBits(lpSrcDIB);
  1968. LPSTR lpOutput = FindDIBBits(lpDIB);
  1969. int nWidth = DIBWidth(lpSrcDIB);
  1970. int nHeight = DIBHeight(lpSrcDIB);
  1972. int w=1,h=1,wp=0,hp=0;
  1973. while(w*2<=nWidth)
  1974. {
  1975. w*=2;
  1976. wp++;
  1977. }
  1978. while(h*2<=nHeight)
  1979. {
  1980. h*=2;
  1981. hp++;
  1982. }
  1983. int x,y;
  1984. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  1985. GetPoints(nWidth,nHeight,(BYTE*)lpInput,lpPoints);
  1987. double *f=new double[w*h];
  1988. double *W=new double[w*h];
  1990. for(y=0;y<h;y++)
  1991. {
  1992. for(x=0;x<w;x++)
  1993. {
  1994. f[x+y*w] = lpPoints[x + y * nWidth];
  1995. }
  1996. }
  1998. for(y=0;y<h;y++)
  1999. {
  2000. CMathEx::WALh(f+w*y,W+w*y,wp);
  2001. }
  2002. for(y=0;y<h;y++)
  2003. {
  2004. for(x=0;x<w;x++)
  2005. {
  2006. f[x*h+y]=W[x+w*y];
  2007. }
  2008. }
  2009. for(x=0;x<w;x++)
  2010. {
  2011. CMathEx::WALh(f+x*h,W+x*h,hp);
  2012. }
  2013. double a;
  2014. memset(lpPoints,0,nWidth*nHeight);
  2016. for(y=0;y<h;y++)
  2017. {
  2018. for(x=0;x<w;x++)
  2019. {
  2020. a=fabs(W[x*h+y]*1000);
  2021. if (a>255) a=255;
  2022. lpPoints[x + (nHeight-y-1) * nWidth] = (BYTE)a;
  2023. }
  2024. }
  2025. delete f;
  2026. delete W;
  2027. PutPoints(nWidth,nHeight,(BYTE*)lpOutput,lpPoints);
  2028. delete lpPoints;
  2030. // recover
  2031. DWORD dwSize = GlobalSize(hDib);
  2032. memcpy(lpSrcDIB, lpDIB, dwSize);
  2033. GlobalUnlock(hDib);
  2034. GlobalUnlock(hNewDib);
  2035. if (wBitCount != 24)
  2036. {
  2037. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  2039. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  2040. lpDIB = (LPSTR)GlobalLock(hNewDib);
  2041. dwSize = GlobalSize(hNewDib);
  2042. memcpy(lpSrcDIB, lpDIB, dwSize);
  2043. GlobalUnlock(hDIB);
  2044. GlobalUnlock(hNewDib);
  2045. }
  2046. else
  2047. {
  2048. lpSrcDIB = (LPSTR)GlobalLock(hDIB);
  2049. lpDIB = (LPSTR)GlobalLock(hDib);
  2050. dwSize = GlobalSize(hDib);
  2051. memcpy(lpSrcDIB, lpDIB, dwSize);
  2052. GlobalUnlock(hDIB);
  2053. GlobalUnlock(hDib);
  2054. }
  2056. // cleanup
  2057. GlobalFree(hDib);
  2058. GlobalFree(hNewDib);
  2060. // return
  2061. WaitCursorEnd();
  2062. return TRUE;
  2063. }