Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
IP.cpp
Package: RWJpegExp.rar　[view]
Upload User: hbtiangong
Upload Date: 2009-03-29
Package Size: 255k
Code Size: 50k
Category:

Windows Develop

Development Platform:

Visual C++

IP.cpp：Code Content
  1. #include "stdafx.h"
  2. #include <math.h>
  4. #include "dibapi.h"
  6. // Definitions required for convolution image filtering
  7. #define KERNELCOLS 3
  8. #define KERNELROWS 3
  9. #define KERNELELEMENTS (KERNELCOLS * KERNELROWS)
  11. // struct for convolute kernel 
  12. typedef struct 
  13. {
  14.   int Element[KERNELELEMENTS];
  15.   int Divisor;
  16. } KERNEL;
  18. // The following kernel definitions are for convolution filtering.
  19. // Kernel entries are specified with a divisor to get around the
  20. // requirement for floating point numbers in the low pass filters. 
  22. KERNEL HP1 = {                    // HP filter #1
  23.   {-1, -1, -1,
  24.    -1,  9, -1,
  25.    -1, -1, -1},
  26.     1                             // Divisor = 1
  27. };
  29. KERNEL HP2 = {                    // HP filter #2
  30.   { 0, -1,  0,
  31.    -1,  5, -1,
  32.     0, -1,  0},
  33.     1                             // Divisor = 1
  34. };
  36. KERNEL HP3 = {                    // HP filter #3
  37.   { 1, -2,  1,
  38.    -2,  5, -2,
  39.     1, -2,  1},
  40.     1                             // Divisor = 1
  41. };
  43. KERNEL LP1 = {                    // LP filter #1
  44.   { 1,  1,  1,
  45.     1,  1,  1,
  46.     1,  1,  1},
  47.     9                             // Divisor = 9
  48. };
  50. KERNEL LP2 = {                    // LP filter #2
  51.   { 1,  1,  1,
  52.     1,  2,  1,
  53.     1,  1,  1},
  54.     10                            // Divisor = 10
  55. };
  57. KERNEL LP3 = {                    // LP filter #3
  58.   { 1,  2,  1,
  59.     2,  4,  2,
  60.     1,  2,  1},
  61.     16                            // Divisor = 16
  62. };
  64. KERNEL VertEdge = {              // Vertical edge
  65.   { 0,  0,  0,
  66.     -1, 1,  0,
  67.     0,  0,  0},
  68.     1                             // Divisor = 1
  69. };
  71. KERNEL HorzEdge = {              // Horizontal edge
  72.   { 0,  -1,  0,
  73.     0,  1,  0,
  74.     0,  0,  0},
  75.     1                             // Divisor = 1
  76. };
  78. KERNEL VertHorzEdge = {           // Vertical Horizontal edge
  79.   { -1, 0,  0,
  80.     0,  1,  0,
  81.     0,  0,  0},
  82.     1                             // Divisor = 1
  83. };
  85. KERNEL EdgeNorth = {              // North gradient
  86.   { 1,  1,  1,
  87.     1, -2,  1,
  88.    -1, -1, -1},
  89.     1                             // Divisor = 1
  90. };
  92. KERNEL EdgeNorthEast = {          // North East gradient
  93.   { 1,  1,  1,
  94.    -1, -2,  1,
  95.    -1, -1,  1},
  96.     1                             // Divisor = 1
  97. };
  99. KERNEL EdgeEast = {               // East gradient
  100.   {-1,  1,  1,
  101.    -1, -2,  1,
  102.    -1,  1,  1},
  103.     1                             // Divisor = 1
  104. };
  106. KERNEL EdgeSouthEast = {          // South East gradient
  107.   {-1, -1,  1,
  108.    -1, -2,  1,
  109.     1,  1,  1},
  110.     1                             // Divisor = 1
  111. };
  113. KERNEL EdgeSouth = {              // South gadient
  114.   {-1, -1, -1,
  115.     1, -2,  1,
  116.     1,  1,  1},
  117.     1                             // Divisor = 1
  118. };
  120. KERNEL EdgeSouthWest = {          // South West gradient
  121.   { 1, -1, -1,
  122.     1, -2, -1,
  123.     1,  1,  1},
  124.     1                             // Divisor = 1
  125. };
  127. KERNEL EdgeWest = {               // West gradient
  128.   { 1,  1, -1,
  129.     1, -2, -1,
  130.     1,  1, -1},
  131.     1                             // Divisor = 1
  132. };
  134. KERNEL EdgeNorthWest = {          // North West gradient
  135.   { 1,  1,  1,
  136.     1, -2, -1,
  137.     1, -1, -1},
  138.     1                             // Divisor = 1
  139. };
  141. KERNEL Lap1 = {   // Laplace filter 1
  142.   { 0,  1,  0,
  143.     1, -4,  1,
  144.     0,  1,  0},
  145.     1                             // Divisor = 1
  146. };
  148. KERNEL Lap2 = {   // Laplace filter 2
  149.   { -1, -1, -1,
  150.     -1,  8, -1,
  151.     -1, -1, -1},
  152.     1                             // Divisor = 1
  153. };
  155. KERNEL Lap3 = {   // Laplace filter 3
  156.   { -1, -1, -1,
  157.     -1,  9, -1,
  158.     -1, -1, -1},
  159.     1                             // Divisor = 1
  160. };
  162. KERNEL Lap4 = {   // Laplace filter 4
  163.   { 1, -2, 1,
  164.     -2, 4, -2,
  165.     1, -2, 1},
  166.     1                             // Divisor = 1
  167. };
  169. KERNEL Sobel[4] = {
  170. {                    // Sobel1
  171. {-1, 0, 1,
  172.  -2, 0, 2,
  173.  -1, 0, 1},
  174. 1                             // Divisor = 1
  175. },
  176. {                    // Sobel2
  177. {-1, -2, -1,
  178.   0,  0,  0,
  179.   1,  2,  1},
  180. 1                             // Divisor = 1
  181. },
  182. {                    // Sobel3
  183. {-2, -1, 0,
  184.  -1,  0, 1,
  185.   0,  1, 2},
  186. 1                             // Divisor = 1
  187. },
  188. {                    // Sobel4
  189. {0, -1, -2,
  190.  1,  0, -1,
  191.  2,  1, 0},
  192. 1                             // Divisor = 1
  193. }
  194. };
  196. KERNEL Hough[4] = {
  197. {                    // Hough1
  198. {-1, 0, 1,
  199.  -1, 0, 1,
  200.  -1, 0, 1},
  201. 1                             // Divisor = 1
  202. },
  203. {                    // Hough2
  204. {-1, -1, 0,
  205.  -1,  0, 1,
  206.   0,  1, 1},
  207. 1                             // Divisor = 1
  208. },
  209. {                    // Hough3
  210. {-1, -1, -1,
  211.   0,  0, 0,
  212.   1,  1, 1},
  213. 1                             // Divisor = 1
  214. },
  215. {                    // Hough4
  216. {0, -1, -1,
  217.  1,  0, -1,
  218.  1,  1, 0},
  219. 1                             // Divisor = 1
  220. }
  221. };
  223. // local use macro
  224. #define PIXEL_OFFSET(i, j, nWidthBytes)
  225. (LONG)((LONG)(i)*(LONG)(nWidthBytes) + (LONG)(j)*3)
  227. // local function prototype
  228. int compare(const void *e1, const void *e2);
  229. void DoMedianFilterDIB(int *red, int *green, int *blue, int i, int j, 
  230. WORD wBytesPerLine, LPBYTE lpDIBits);
  231. void DoConvoluteDIB(int *red, int *green, int *blue, int i, int j, 
  232. WORD wBytesPerLine, LPBYTE lpDIBits, KERNEL *lpKernel);
  233. BOOL ConvoluteDIB(HDIB hDib, KERNEL *lpKernel, int Strength, int nKernelNum=1);
  236. // function body
  238. /************************************************************************* 
  239.  * 
  240.  * HighPassDIB() 
  241.  * 
  242.  * Parameters: 
  243.  * 
  244.  * HDIB hDib        - objective DIB handle
  245.  * int nAlgorithm   - specify the filter to use
  246.  * int Strength     - operation strength set to the convolute
  247.  * 
  248.  * Return Value: 
  249.  * 
  250.  * BOOL             - True is success, else False
  251.  * 
  252.  * Description: 
  253.  * 
  254.  * High pass filtering to sharp DIB
  255.  * 
  256.  ************************************************************************/ 
  257. BOOL HighPassDIB(HDIB hDib, int Strength, int nAlgorithm) 
  258. {
  259. switch (nAlgorithm)
  260. {
  261. case FILTER1:
  262. return ConvoluteDIB(hDib, &HP1, Strength);
  263. case FILTER2:
  264. return ConvoluteDIB(hDib, &HP2, Strength);
  265. case FILTER3:
  266. return ConvoluteDIB(hDib, &HP3, Strength);
  267. }
  269. return FALSE;
  270. }
  272. /************************************************************************* 
  273.  * 
  274.  * LowPassDIB() 
  275.  * 
  276.  * Parameters: 
  277.  * 
  278.  * HDIB hDib        - objective DIB handle
  279.  * int nAlgorithm   - specify the filter to use
  280.  * int Strength     - operation strength set to the convolute
  281.  * 
  282.  * Return Value: 
  283.  * 
  284.  * BOOL             - True is success, else False
  285.  * 
  286.  * Description: 
  287.  * 
  288.  * Low pass filtering to blur DIB
  289.  * 
  290.  ************************************************************************/ 
  291. BOOL LowPassDIB(HDIB hDib, int Strength, int nAlgorithm) 
  292. {
  293. switch (nAlgorithm)
  294. {
  295. case FILTER1:
  296. return ConvoluteDIB(hDib, &LP1, Strength);
  297. case FILTER2:
  298. return ConvoluteDIB(hDib, &LP2, Strength);
  299. case FILTER3:
  300. return ConvoluteDIB(hDib, &LP3, Strength);
  301. }
  303. return FALSE;
  304. }
  306. /************************************************************************* 
  307.  * 
  308.  * EdgeEnhanceDIB() 
  309.  * 
  310.  * Parameters: 
  311.  * 
  312.  * HDIB hDib        - objective DIB handle
  313.  * int nAlgorithm   - specify the filter to use
  314.  * int Strength     - operation strength set to the convolute
  315.  * 
  316.  * Return Value: 
  317.  * 
  318.  * BOOL             - True is success, else False
  319.  * 
  320.  * Description: 
  321.  * 
  322.  * Edge enhance DIB
  323.  * 
  324.  ************************************************************************/ 
  325. BOOL EdgeEnhanceDIB(HDIB hDib, int Strength, int nAlgorithm)
  326. {
  327. switch (nAlgorithm)
  328. {
  329. case VERT:
  330. return ConvoluteDIB(hDib, &VertEdge, Strength);
  331. case HORZ:
  332. return ConvoluteDIB(hDib, &HorzEdge, Strength);
  333. case VERTHORZ:
  334. return ConvoluteDIB(hDib, &VertHorzEdge, Strength);
  335. case NORTH:
  336. return ConvoluteDIB(hDib, &EdgeNorth, Strength);
  337. case NORTHEAST:
  338. return ConvoluteDIB(hDib, &EdgeNorthEast, Strength);
  339. case EAST:
  340. return ConvoluteDIB(hDib, &EdgeEast, Strength);
  341. case SOUTH:
  342. return ConvoluteDIB(hDib, &EdgeSouth, Strength);
  343. case SOUTHEAST:
  344. return ConvoluteDIB(hDib, &EdgeSouthEast, Strength);
  345. case SOUTHWEST:
  346. return ConvoluteDIB(hDib, &EdgeSouthWest, Strength);
  347. case WEST:
  348. return ConvoluteDIB(hDib, &EdgeWest, Strength);
  349. case NORTHWEST:
  350. return ConvoluteDIB(hDib, &EdgeNorthWest, Strength);
  351. case LAP1:
  352. return ConvoluteDIB(hDib, &Lap1, Strength);
  353. case LAP2:
  354. return ConvoluteDIB(hDib, &Lap2, Strength);
  355. case LAP3:
  356. return ConvoluteDIB(hDib, &Lap3, Strength);
  357. case LAP4:
  358. return ConvoluteDIB(hDib, &Lap4, Strength);
  359. case SOBEL:
  360. return ConvoluteDIB(hDib, Sobel, Strength, 4);
  361. case HOUGH:
  362. return ConvoluteDIB(hDib, Hough, Strength, 4);
  363. }
  365. return FALSE;
  366. }
  368. /************************************************************************* 
  369.  * 
  370.  * MedianFilterDIB() 
  371.  * 
  372.  * Parameters: 
  373.  * 
  374.  * HDIB hDib        - objective DIB handle
  375.  * 
  376.  * Return Value: 
  377.  * 
  378.  * BOOL             - True is success, else False
  379.  * 
  380.  * Description: 
  381.  * 
  382.  * This is the media filtering function to DIB
  383.  * 
  384.  ************************************************************************/ 
  385. BOOL MedianFilterDIB(HDIB hDib) 
  386. {
  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. LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits);
  418. // get bits address in DIB
  419. LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  420. LPBYTE 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((LPBYTE)GlobalLock(hDib), (LPBYTE)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 ConvoluteDIB(HDIB hDib, KERNEL *lpKernel, int Strength, int nKernelNum) 
  482. {
  483. WaitCursorBegin();
  485. HDIB hNewDib = NULL;
  486. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  487. WORD wBitCount = DIBBitCount(hDib);
  488. if (wBitCount != 24)
  489. hNewDib = ConvertDIBFormat(hDib, 24, NULL);
  490. else
  491. hNewDib = CopyHandle(hDib);
  493. if (! hNewDib)
  494. {
  495. WaitCursorEnd();
  496. return FALSE;
  497. }
  499. // new DIB attributes
  500. WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
  501. WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
  502. WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);
  503. DWORD dwImageSize = wBytesPerLine * wDIBHeight;
  505. // Allocate and lock memory for filtered image data
  506. HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize);
  507. if (!hFilteredBits) 
  508. {
  509. WaitCursorEnd();
  510. return FALSE;
  511. }
  512. LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits);
  514. // get bits address in DIB
  515. LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  516. LPBYTE lpDIBits = FindDIBBits(lpDIB);
  518. // convolute...
  519. for (int i=1; i<wDIBHeight-1; i++) 
  520. for (int j=1; j<wDIBWidth-1; j++) 
  521. {
  522. int  red=0, green=0, blue=0; 
  524. for (int k=0; k<nKernelNum; ++k)
  525. {
  526. int r=0, g=0, b=0; 
  527. DoConvoluteDIB(&r, &g, &b, i, j, 
  528. wBytesPerLine, lpDIBits, lpKernel+k);
  529. if (r > red)
  530. red = r;
  531. if (g > green)
  532. green = g;
  533. if (b > blue)
  534. blue = b;
  535. //red += r; green += g; blue += b;
  536. }
  538. // original RGB value in center pixel  (j, i)
  539. LONG lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  540. BYTE OldB = *(lpDIBits + lOffset++);
  541. BYTE OldG = *(lpDIBits + lOffset++);
  542. BYTE OldR = *(lpDIBits + lOffset);
  543. // When we get here, red, green and blue have the new RGB value.
  544. if (Strength != 10) 
  545. {
  546. // Interpolate pixel data
  547. red   = OldR + (((red - OldR) * Strength) / 10);
  548. green = OldG + (((green - OldG) * Strength) / 10);
  549. blue  = OldB + (((blue - OldB) * Strength) / 10);
  550. }
  552. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  553. *(lpDestImage + lOffset++) = BOUND(blue, 0, 255);
  554. *(lpDestImage + lOffset++) = BOUND(green, 0, 255);
  555. *(lpDestImage + lOffset)   = BOUND(red, 0, 255);
  556. }
  558. // a filtered image is available in lpDestImage
  559. // copy it to DIB bits
  560. memcpy(lpDIBits, lpDestImage, dwImageSize);
  562. // cleanup temp buffers
  563. GlobalUnlock(hFilteredBits);
  564. GlobalFree(hFilteredBits);
  565. GlobalUnlock(hNewDib);
  567. // rebuild hDib
  568. HDIB hTmp = NULL;
  569. if (wBitCount != 24)
  570. hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL);
  571. else
  572. hTmp = CopyHandle(hNewDib);
  573. GlobalFree(hNewDib);
  574. DWORD dwSize = GlobalSize(hTmp);
  575. memcpy((LPBYTE)GlobalLock(hDib), (LPBYTE)GlobalLock(hTmp), dwSize);
  576. GlobalUnlock(hTmp);
  577. GlobalFree(hTmp);
  578. GlobalUnlock(hDib);
  579. WaitCursorEnd();
  581. return TRUE;
  582. }
  584. // local function: perform convolution to DIB with a kernel
  585. void DoConvoluteDIB(int *red, int *green, int *blue, int i, int j, 
  586. WORD wBytesPerLine, LPBYTE lpDIBits, KERNEL *lpKernel)
  587. {
  588. BYTE b[9], g[9], r[9];
  589. LONG lOffset;
  591. lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
  592. b[0] = *(lpDIBits + lOffset++);
  593. g[0] = *(lpDIBits + lOffset++);
  594. r[0] = *(lpDIBits + lOffset);
  596. lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
  597. b[1] = *(lpDIBits + lOffset++);
  598. g[1] = *(lpDIBits + lOffset++);
  599. r[1] = *(lpDIBits + lOffset);
  601. lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
  602. b[2] = *(lpDIBits + lOffset++);
  603. g[2] = *(lpDIBits + lOffset++);
  604. r[2] = *(lpDIBits + lOffset);
  606. lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
  607. b[3] = *(lpDIBits + lOffset++);
  608. g[3] = *(lpDIBits + lOffset++);
  609. r[3] = *(lpDIBits + lOffset);
  611. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  612. b[4] = *(lpDIBits + lOffset++);
  613. g[4] = *(lpDIBits + lOffset++);
  614. r[4] = *(lpDIBits + lOffset);
  616. lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
  617. b[5] = *(lpDIBits + lOffset++);
  618. g[5] = *(lpDIBits + lOffset++);
  619. r[5] = *(lpDIBits + lOffset);
  621. lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
  622. b[6] = *(lpDIBits + lOffset++);
  623. g[6] = *(lpDIBits + lOffset++);
  624. r[6] = *(lpDIBits + lOffset);
  626. lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
  627. b[7] = *(lpDIBits + lOffset++);
  628. g[7] = *(lpDIBits + lOffset++);
  629. r[7] = *(lpDIBits + lOffset);
  631. lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
  632. b[8] = *(lpDIBits + lOffset++);
  633. g[8] = *(lpDIBits + lOffset++);
  634. r[8] = *(lpDIBits + lOffset);
  636. *red = *green = *blue = 0;
  637. for (int k=0; k<8; ++k)
  638. {
  639. *red   += lpKernel->Element[k]*r[k];
  640. *green += lpKernel->Element[k]*g[k];
  641. *blue  += lpKernel->Element[k]*b[k];
  642. }
  644. if (lpKernel->Divisor != 1) 
  645. {
  646. *red   /= lpKernel->Divisor;
  647. *green /= lpKernel->Divisor;
  648. *blue  /= lpKernel->Divisor;
  649. }
  651. // getoff opposite
  652. *red   = abs(*red);
  653. *green = abs(*green);
  654. *blue  = abs(*blue);
  655. }
  657. // local function: perform median filter to DIB
  658. void DoMedianFilterDIB(int *red, int *green, int *blue, int i, int j, 
  659. WORD wBytesPerLine, LPBYTE lpDIBits)
  660. {
  661. BYTE b[9], g[9], r[9];
  662. LONG lOffset;
  664. lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
  665. b[0] = *(lpDIBits + lOffset++);
  666. g[0] = *(lpDIBits + lOffset++);
  667. r[0] = *(lpDIBits + lOffset);
  669. lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
  670. b[1] = *(lpDIBits + lOffset++);
  671. g[1] = *(lpDIBits + lOffset++);
  672. r[1] = *(lpDIBits + lOffset);
  674. lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
  675. b[2] = *(lpDIBits + lOffset++);
  676. g[2] = *(lpDIBits + lOffset++);
  677. r[2] = *(lpDIBits + lOffset);
  679. lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
  680. b[3] = *(lpDIBits + lOffset++);
  681. g[3] = *(lpDIBits + lOffset++);
  682. r[3] = *(lpDIBits + lOffset);
  684. lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
  685. b[4] = *(lpDIBits + lOffset++);
  686. g[4] = *(lpDIBits + lOffset++);
  687. r[4] = *(lpDIBits + lOffset);
  689. lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
  690. b[5] = *(lpDIBits + lOffset++);
  691. g[5] = *(lpDIBits + lOffset++);
  692. r[5] = *(lpDIBits + lOffset);
  694. lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
  695. b[6] = *(lpDIBits + lOffset++);
  696. g[6] = *(lpDIBits + lOffset++);
  697. r[6] = *(lpDIBits + lOffset);
  699. lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
  700. b[7] = *(lpDIBits + lOffset++);
  701. g[7] = *(lpDIBits + lOffset++);
  702. r[7] = *(lpDIBits + lOffset);
  704. lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
  705. b[8] = *(lpDIBits + lOffset++);
  706. g[8] = *(lpDIBits + lOffset++);
  707. r[8] = *(lpDIBits + lOffset);
  709.     qsort(r, 9, 1, compare);
  710.     qsort(g, 9, 1, compare);
  711.     qsort(b, 9, 1, compare);
  713. *red   = r[0];
  714. *green = g[0];
  715. *blue  = b[0];
  716. }
  718. // function used to sort in the call of qsort
  719. int compare(const void *e1, const void *e2)
  720. {
  721. if (*(BYTE *)e1 < *(BYTE *)e2)
  722. return -1;
  723. if (*(BYTE *)e1 > *(BYTE *)e2)
  724. return 1;
  726. return 0;
  727. }
  729. /************************************************************************* 
  730.  * 
  731.  * ReverseDIB() 
  732.  * 
  733.  * Parameters: 
  734.  * 
  735.  * HDIB hDib        - objective DIB handle
  736.  * 
  737.  * Return Value: 
  738.  * 
  739.  * BOOL             - True is success, else False
  740.  * 
  741.  * Description: 
  742.  * 
  743.  * This function reverse DIB
  744.  * 
  745.  ************************************************************************/ 
  746. BOOL ReverseDIB(HDIB hDib) 
  747. {
  748. WaitCursorBegin();
  750. HDIB hNewDib = NULL;
  751. // only support 256 grayscale image
  752. WORD wBitCount = DIBBitCount(hDib);
  753. if (wBitCount != 8)
  754. {
  755. WaitCursorEnd();
  756. return FALSE;
  757. }
  759. // the maxium pixel value
  760. int  nMaxValue = 256;
  762. // source pixel data
  763.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  764. if (! lpSrcDIB)
  765. {
  766. WaitCursorBegin();
  767. return FALSE;
  768. }
  770. // new DIB attributes
  771. LPSTR lpPtr;
  772. LONG lHeight = DIBHeight(lpSrcDIB);
  773. LONG lWidth = DIBWidth(lpSrcDIB);
  774. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  775. int nLineBytes = BytesPerLine(lpSrcDIB);
  777. // convolute...
  778. for (long i=0; i<lHeight; i++) 
  779. for (long j=0; j<lWidth; j++) 
  780. {
  781. lpPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-i*nLineBytes)+j;
  782. *lpPtr = nMaxValue - *lpPtr;
  783. }
  785. // cleanup
  786. GlobalUnlock(hDib);
  787. WaitCursorEnd();
  789. return TRUE;
  790. }
  792. /************************************************************************* 
  793.  * 
  794.  * ErosionDIB() 
  795.  * 
  796.  * Parameters: 
  797.  * 
  798.  * HDIB hDib        - objective DIB handle
  799.  * BOOL bHori     - erosion direction
  800.  * 
  801.  * Return Value: 
  802.  * 
  803.  * BOOL             - True is success, else False
  804.  * 
  805.  * Description: 
  806.  * 
  807.  * This function do erosion with the specified direction
  808.  * 
  809.  ************************************************************************/ 
  810. BOOL ErosionDIB(HDIB hDib, BOOL bHori)
  811. {
  812. // start wait cursor
  813. WaitCursorBegin();
  815.     // Old DIB buffer
  816. if (hDib == NULL)
  817. {
  818. WaitCursorEnd();
  819.         return FALSE;
  820. }
  822. // only support 256 color image
  823. WORD wBitCount = DIBBitCount(hDib);
  824. if (wBitCount != 8)
  825. {
  826. WaitCursorEnd();
  827.         return FALSE;
  828. }
  830. // new DIB
  831. HDIB hNewDIB = CopyHandle(hDib);
  832. if (! hNewDIB)
  833. {
  834. WaitCursorEnd();
  835.         return FALSE;
  836. }
  838. // source dib buffer
  839.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  840. if (! lpSrcDIB)
  841. {
  842. WaitCursorBegin();
  843. return FALSE;
  844. }
  845.     // New DIB buffer
  846.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  847. if (! lpbmi)
  848. {
  849. WaitCursorBegin();
  850. return FALSE;
  851. }
  853. // start erosion...
  854. LPSTR lpPtr;
  855. LPSTR lpTempPtr;
  856. LONG  x,y;
  857. BYTE  num, num0;
  858. int   i;
  859. LONG lHeight = DIBHeight(lpSrcDIB);
  860. LONG lWidth = DIBWidth(lpSrcDIB);
  861. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  862. int nLineBytes = BytesPerLine(lpSrcDIB);
  863. if(bHori)
  864. {
  865. for (y=0; y<lHeight; y++)
  866. {
  867. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  868. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  869. for (x=1; x<lWidth-1; x++)
  870. {
  871. num0 = num = 0 ;
  872. for(i=0;i<3;i++)
  873. {
  874. num=(unsigned char)*(lpPtr+i-1);
  875. if(num > num0)
  876. num0 = num;
  877. }
  878. *lpTempPtr=(unsigned char)num0;
  879. /*
  880. num=(unsigned char)*lpPtr;
  881. if (num==0)
  882. {
  883. *lpTempPtr=(unsigned char)0;
  884. for(i=0;i<3;i++)
  885. {
  886. num=(unsigned char)*(lpPtr+i-1);
  887. if(num==255)
  888. {
  889. *lpTempPtr=(unsigned char)255;
  890. break;
  891. }
  892. }
  893. }
  894. else 
  895. *lpTempPtr=(unsigned char)255;
  896. */
  897. lpPtr++;
  898. lpTempPtr++;
  899. }
  900. }
  901. }
  902. else // Vertical
  903. {
  904. for (y=1; y<lHeight-1; y++)
  905. {
  906. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  907. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  908. for (x=0; x<lWidth; x++)
  909. {
  910. num0 = num = 0 ;
  911. for(i=0;i<3;i++)
  912. {
  913. num=(unsigned char)*(lpPtr+i-1);
  914. if(num > num0)
  915. num0 = num;
  916. }
  917. *lpTempPtr=(unsigned char)num0;
  918. /*
  919. num=(unsigned char)*lpPtr;
  920. if (num==0)
  921. {
  922. *lpTempPtr=(unsigned char)0;
  923. for(i=0;i<3;i++)
  924. {
  925. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  926. if(num==255)
  927. {
  928. *lpTempPtr=(unsigned char)255;
  929. break;
  930. }
  931. }
  932. }
  933. else 
  934. *lpTempPtr=(unsigned char)255;
  935. */
  936. lpPtr++;
  937. lpTempPtr++;
  938. }
  939. }
  940. }
  942. // cleanup
  943. GlobalUnlock(hDib);
  944. GlobalUnlock(hNewDIB);
  945. GlobalFree(hNewDIB);
  946. WaitCursorEnd();
  948. return TRUE;
  949. }
  951. /************************************************************************* 
  952.  * 
  953.  * DilationDIB() 
  954.  * 
  955.  * Parameters: 
  956.  * 
  957.  * HDIB hDib        - objective DIB handle
  958.  * BOOL bHori     - dilation direction
  959.  * 
  960.  * Return Value: 
  961.  * 
  962.  * BOOL             - True is success, else False
  963.  * 
  964.  * Description: 
  965.  * 
  966.  * This function do dilation with the specified direction
  967.  * 
  968.  ************************************************************************/ 
  969. BOOL DilationDIB(HDIB hDib, BOOL bHori)
  970. {
  971. // start wait cursor
  972. WaitCursorBegin();
  974.     // Old DIB buffer
  975. if (hDib == NULL)
  976. {
  977. WaitCursorEnd();
  978.         return FALSE;
  979. }
  981. // only support 256 color image
  982. WORD wBitCount = DIBBitCount(hDib);
  983. if (wBitCount != 8)
  984. {
  985. WaitCursorEnd();
  986.         return FALSE;
  987. }
  989. // new DIB
  990. HDIB hNewDIB = CopyHandle(hDib);
  991. if (! hNewDIB)
  992. {
  993. WaitCursorEnd();
  994.         return FALSE;
  995. }
  997. // source dib buffer
  998.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  999. if (! lpSrcDIB)
  1000. {
  1001. WaitCursorBegin();
  1002. return FALSE;
  1003. }
  1004.     // New DIB buffer
  1005.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1006. if (! lpbmi)
  1007. {
  1008. WaitCursorBegin();
  1009. return FALSE;
  1010. }
  1012. // start erosion...
  1013. LPSTR lpPtr;
  1014. LPSTR lpTempPtr;
  1015. LONG  x,y;
  1016. BYTE  num, num0;
  1017. int   i;
  1018. LONG lHeight = DIBHeight(lpSrcDIB);
  1019. LONG lWidth = DIBWidth(lpSrcDIB);
  1020. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1021. int nLineBytes = BytesPerLine(lpSrcDIB);
  1022. if(bHori)
  1023. {
  1024. for(y=0;y<lHeight;y++)
  1025. {
  1026. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1027. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1028. for(x=1;x<lWidth-1;x++)
  1029. {
  1030. num0 = num = 255;
  1031. for(i=0;i<3;i++)
  1032. {
  1033. num=(unsigned char)*(lpPtr+i-1);
  1034. if(num < num0)
  1035. num0 = num;
  1036. }
  1037. *lpTempPtr=(unsigned char)num0;
  1038. /*
  1039. num=(unsigned char)*lpPtr;
  1040. if (num==255)
  1041. {
  1042. *lpTempPtr=(unsigned char)255;
  1043. for(i=0;i<3;i++)
  1044. {
  1045. num=(unsigned char)*(lpPtr+i-1);
  1046. if(num==0)
  1047. {
  1048. *lpTempPtr=(unsigned char)0;
  1049. break;
  1050. }
  1051. }
  1052. }
  1053. else 
  1054. *lpTempPtr=(unsigned char)0;
  1055. */
  1056. lpPtr++;
  1057. lpTempPtr++;
  1058. }
  1059. }
  1060. }
  1061. else
  1062. {
  1063. for(y=1;y<lHeight-1;y++)
  1064. {
  1065. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1066. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1067. for(x=0;x<lWidth;x++)
  1068. {
  1069. num0 = num = 255;
  1070. for(i=0;i<3;i++)
  1071. {
  1072. num=(unsigned char)*(lpPtr+i-1);
  1073. if(num < num0)
  1074. num0 = num;
  1075. }
  1076. *lpTempPtr=(unsigned char)num0;
  1077. /*
  1078. num=(unsigned char)*lpPtr;
  1079. if (num==255)
  1080. {
  1081. *lpTempPtr=(unsigned char)255;
  1082. for(i=0;i<3;i++)
  1083. {
  1084. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  1085. if(num==0)
  1086. {
  1087. *lpTempPtr=(unsigned char)0;
  1088. break;
  1089. }
  1090. }
  1091. }
  1092. else 
  1093. *lpTempPtr=(unsigned char)0;
  1094. */
  1095. lpPtr++;
  1096. lpTempPtr++;
  1097. }
  1098. }
  1099. }
  1101. // cleanup
  1102. GlobalUnlock(hDib);
  1103. GlobalUnlock(hNewDIB);
  1104. GlobalFree(hNewDIB);
  1105. WaitCursorEnd();
  1107. return TRUE;
  1108. }
  1110. /************************************************************************* 
  1111.  * 
  1112.  * MorphOpenDIB() 
  1113.  * 
  1114.  * Parameters: 
  1115.  * 
  1116.  * HDIB hDib        - objective DIB handle
  1117.  * BOOL bHori     - open direction
  1118.  * 
  1119.  * Return Value: 
  1120.  * 
  1121.  * BOOL             - True is success, else False
  1122.  * 
  1123.  * Description: 
  1124.  * 
  1125.  * This function do open with the specified direction
  1126.  * 
  1127.  ************************************************************************/ 
  1128. BOOL MorphOpenDIB(HDIB hDib, BOOL bHori)
  1129. {
  1130. // Step 1: erosion
  1131. if (! ErosionDIB(hDib, bHori))
  1132. return FALSE;
  1134. // Step 2: dilation
  1135. if (! DilationDIB(hDib, bHori))
  1136. return FALSE;
  1138. return TRUE;
  1139. }
  1141. /************************************************************************* 
  1142.  * 
  1143.  * MorphCloseDIB() 
  1144.  * 
  1145.  * Parameters: 
  1146.  * 
  1147.  * HDIB hDib        - objective DIB handle
  1148.  * BOOL bHori     - close direction
  1149.  * 
  1150.  * Return Value: 
  1151.  * 
  1152.  * BOOL             - True is success, else False
  1153.  * 
  1154.  * Description: 
  1155.  * 
  1156.  * This function do close with the specified direction
  1157.  * 
  1158.  ************************************************************************/ 
  1159. BOOL MorphCloseDIB(HDIB hDib, BOOL bHori)
  1160. {
  1161. // Step 1: dilation
  1162. if (! DilationDIB(hDib, bHori))
  1163. return FALSE;
  1165. // Step 2: erosion
  1166. if (! ErosionDIB(hDib, bHori))
  1167. return FALSE;
  1169. return TRUE;
  1170. }
  1172. /************************************************************************* 
  1173.  * 
  1174.  * ContourDIB() 
  1175.  * 
  1176.  * Parameters: 
  1177.  * 
  1178.  * HDIB hDib        - objective DIB handle
  1179.  * BOOL bHori     - open direction
  1180.  * 
  1181.  * Return Value: 
  1182.  * 
  1183.  * BOOL             - True is success, else False
  1184.  * 
  1185.  * Description: 
  1186.  * 
  1187.  * This function contour DIB with the specified direction
  1188.  * 
  1189.  ************************************************************************/ 
  1190. BOOL ContourDIB(HDIB hDib, BOOL bHori)
  1191. {
  1192. // start wait cursor
  1193. WaitCursorBegin();
  1195.     // Old DIB buffer
  1196. if (hDib == NULL)
  1197. {
  1198. WaitCursorEnd();
  1199.         return FALSE;
  1200. }
  1202. // only support 256 color image
  1203. WORD wBitCount = DIBBitCount(hDib);
  1204. if (wBitCount != 8)
  1205. {
  1206. WaitCursorEnd();
  1207.         return FALSE;
  1208. }
  1210. // new DIB
  1211. HDIB hNewDIB = CopyHandle(hDib);
  1212. if (! hNewDIB)
  1213. {
  1214. WaitCursorEnd();
  1215.         return FALSE;
  1216. }
  1218. // source dib buffer
  1219.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  1220. if (! lpSrcDIB)
  1221. {
  1222. WaitCursorBegin();
  1223. return FALSE;
  1224. }
  1225.     // New DIB buffer
  1226.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1227. if (! lpbmi)
  1228. {
  1229. WaitCursorBegin();
  1230. return FALSE;
  1231. }
  1233. // start erosion...
  1234. LPBYTE lpPtr;
  1235. LPBYTE lpTempPtr;
  1236. LONG  x,y;
  1237. BYTE  num, num0;
  1238. int   i;
  1239. LONG lHeight = DIBHeight(lpSrcDIB);
  1240. LONG lWidth = DIBWidth(lpSrcDIB);
  1241. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1242. int nLineBytes = BytesPerLine(lpSrcDIB);
  1244. // Step 1: erosion
  1245. if(bHori)
  1246. {
  1247. for (y=0; y<lHeight; y++)
  1248. {
  1249. lpPtr=(BYTE *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1250. lpTempPtr=(BYTE *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1251. for (x=1; x<lWidth-1; x++)
  1252. {
  1253. num0 = num = 0 ;
  1254. for(i=0;i<3;i++)
  1255. {
  1256. num=(unsigned char)*(lpPtr+i-1);
  1257. if(num > num0)
  1258. num0 = num;
  1259. }
  1260. *lpTempPtr=(unsigned char)num0;
  1261. /*
  1262. num=(unsigned char)*lpPtr;
  1263. if (num==0)
  1264. {
  1265. *lpTempPtr=(unsigned char)0;
  1266. for(i=0;i<3;i++)
  1267. {
  1268. num=(unsigned char)*(lpPtr+i-1);
  1269. if(num==255)
  1270. {
  1271. *lpTempPtr=(unsigned char)255;
  1272. break;
  1273. }
  1274. }
  1275. }
  1276. else 
  1277. *lpTempPtr=(unsigned char)255;
  1278. */
  1279. lpPtr++;
  1280. lpTempPtr++;
  1281. }
  1282. }
  1283. }
  1284. else // Vertical
  1285. {
  1286. for (y=1; y<lHeight-1; y++)
  1287. {
  1288. lpPtr=(BYTE *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1289. lpTempPtr=(BYTE *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1290. for (x=0; x<lWidth; x++)
  1291. {
  1292. num0 = num = 0 ;
  1293. for(i=0;i<3;i++)
  1294. {
  1295. num=(unsigned char)*(lpPtr+i-1);
  1296. if(num > num0)
  1297. num0 = num;
  1298. }
  1299. *lpTempPtr=(unsigned char)num0;
  1300. /*
  1301. num=(unsigned char)*lpPtr;
  1302. if (num==0)
  1303. {
  1304. *lpTempPtr=(unsigned char)0;
  1305. for(i=0;i<3;i++)
  1306. {
  1307. num=(unsigned char)*(lpPtr+(i-1)*nLineBytes);
  1308. if(num==255)
  1309. {
  1310. *lpTempPtr=(unsigned char)255;
  1311. break;
  1312. }
  1313. }
  1314. }
  1315. else 
  1316. *lpTempPtr=(unsigned char)255;
  1317. */
  1318. lpPtr++;
  1319. lpTempPtr++;
  1320. }
  1321. }
  1322. }
  1324. // Step 2: original image minues dilation image
  1325. if(bHori)
  1326. {
  1327. for(y=0;y<lHeight;y++)
  1328. {
  1329. lpPtr=(BYTE *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1330. lpTempPtr=(BYTE *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1;
  1331. for(x=1;x<lWidth-1;x++)
  1332. {
  1333. if (*lpTempPtr == *lpPtr)
  1334. *lpTempPtr = (BYTE)255;
  1335. else
  1336. *lpTempPtr = *lpTempPtr - *lpPtr;
  1338. lpPtr++;
  1339. lpTempPtr++;
  1340. }
  1341. }
  1342. }
  1343. else
  1344. {
  1345. for(y=1;y<lHeight-1;y++)
  1346. {
  1347. lpPtr=(BYTE *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1348. lpTempPtr=(BYTE *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1349. for(x=0;x<lWidth;x++)
  1350. {
  1351. if (*lpTempPtr == *lpPtr)
  1352. *lpTempPtr = (BYTE)255;
  1353. else
  1354. *lpTempPtr = *lpTempPtr - *lpPtr;
  1356. lpPtr++;
  1357. lpTempPtr++;
  1358. }
  1359. }
  1360. }
  1362. // cleanup
  1363. GlobalUnlock(hDib);
  1364. GlobalUnlock(hNewDIB);
  1365. GlobalFree(hNewDIB);
  1367. return TRUE;
  1368. }
  1370. /************************************************************************* 
  1371.  * 
  1372.  * ThinningDIB() 
  1373.  * 
  1374.  * Parameters: 
  1375.  * 
  1376.  * HDIB hDib        - objective DIB handle
  1377.  * 
  1378.  * Return Value: 
  1379.  * 
  1380.  * BOOL             - True is success, else False
  1381.  * 
  1382.  * Description: 
  1383.  * 
  1384.  * This function thins a DIB
  1385.  * 
  1386.  ************************************************************************/ 
  1387. BOOL ThinningDIB(HDIB hDib)
  1388. {
  1389. static int erasetable[256]=
  1390. {
  1391. 0,0,1,1,0,0,1,1,
  1392. 1,1,0,1,1,1,0,1,
  1393. 1,1,0,0,1,1,1,1,
  1394. 0,0,0,0,0,0,0,1,
  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. 1,1,0,0,1,1,0,0,
  1402. 0,0,0,0,0,0,0,0,
  1403. 0,0,0,0,0,0,0,0,
  1404. 0,0,0,0,0,0,0,0,
  1406. 1,1,0,0,1,1,0,0,
  1407. 1,1,0,1,1,1,0,1,
  1408. 0,0,0,0,0,0,0,0,
  1409. 0,0,0,0,0,0,0,0,
  1411. 0,0,1,1,0,0,1,1,
  1412. 1,1,0,1,1,1,0,1,
  1413. 1,1,0,0,1,1,1,1,
  1414. 0,0,0,0,0,0,0,1,
  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,0,
  1421. 1,1,0,0,1,1,0,0,
  1422. 0,0,0,0,0,0,0,0,
  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. 1,1,0,1,1,1,0,0,
  1428. 1,1,0,0,1,1,1,0,
  1429. 1,1,0,0,1,0,0,0
  1430. };
  1432. // start wait cursor
  1433. WaitCursorBegin();
  1435.     // Old DIB buffer
  1436. if (hDib == NULL)
  1437. {
  1438. WaitCursorEnd();
  1439.         return FALSE;
  1440. }
  1442. // only support 256 color image
  1443. WORD wBitCount = DIBBitCount(hDib);
  1444. if (wBitCount != 8)
  1445. {
  1446. WaitCursorEnd();
  1447.         return FALSE;
  1448. }
  1450. // new DIB
  1451. HDIB hNewDIB = CopyHandle(hDib);
  1452. if (! hNewDIB)
  1453. {
  1454. WaitCursorEnd();
  1455.         return FALSE;
  1456. }
  1458. // source dib buffer
  1459.     LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib);
  1460. if (! lpSrcDIB)
  1461. {
  1462. WaitCursorBegin();
  1463. return FALSE;
  1464. }
  1465.     // New DIB buffer
  1466.     LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB);
  1467. if (! lpbmi)
  1468. {
  1469. WaitCursorBegin();
  1470. return FALSE;
  1471. }
  1473. // start erosion...
  1474. LPSTR lpPtr;
  1475. LPSTR lpTempPtr;
  1476. LONG  x,y;
  1477. BYTE  num;
  1478. LONG lHeight = DIBHeight(lpSrcDIB);
  1479. LONG lWidth = DIBWidth(lpSrcDIB);
  1480. DWORD dwBufferSize = GlobalSize(lpSrcDIB);
  1481. int nLineBytes = BytesPerLine(lpSrcDIB);
  1482. int nw,n,ne,w,e,sw,s,se;
  1484. BOOL Finished=FALSE;
  1485.     while(!Finished)
  1486. {
  1487.      Finished=TRUE;
  1488. for (y=1;y<lHeight-1;y++)
  1489. { 
  1490. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1491. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1492. x=1; 
  1493. while(x<lWidth-1)
  1494. {
  1495. if(*(lpPtr+x)==0)
  1496. {
  1497. w=(unsigned char)*(lpPtr+x-1);
  1498. e=(unsigned char)*(lpPtr+x+1);
  1499. if( (w==255)|| (e==255))
  1500. {
  1501. nw=(unsigned char)*(lpPtr+x+nLineBytes-1);
  1502. n=(unsigned char)*(lpPtr+x+nLineBytes);
  1503. ne=(unsigned char)*(lpPtr+x+nLineBytes+1);
  1504. sw=(unsigned char)*(lpPtr+x-nLineBytes-1);
  1505. s=(unsigned char)*(lpPtr+x-nLineBytes);
  1506. se=(unsigned char)*(lpPtr+x-nLineBytes+1);
  1507. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  1508. if(erasetable[num]==1)
  1509. {
  1510. *(lpPtr+x)=(BYTE)255;
  1511. *(lpTempPtr+x)=(BYTE)255;
  1512. Finished=FALSE;
  1513. x++;
  1514. }
  1515. }
  1516. }
  1517. x++;
  1518. }
  1519. }
  1521. for (x=1;x<lWidth-1;x++)
  1522. { 
  1523. y=1;
  1524. while(y<lHeight-1)
  1525. {
  1526. lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes);
  1527. lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes);
  1528. if(*(lpPtr+x)==0)
  1529. {
  1530. n=(unsigned char)*(lpPtr+x+nLineBytes);
  1531. s=(unsigned char)*(lpPtr+x-nLineBytes);
  1532. if( (n==255)|| (s==255))
  1533. {
  1534. nw=(unsigned char)*(lpPtr+x+nLineBytes-1);
  1535. ne=(unsigned char)*(lpPtr+x+nLineBytes+1);
  1536. w=(unsigned char)*(lpPtr+x-1);
  1537. e=(unsigned char)*(lpPtr+x+1);
  1538. sw=(unsigned char)*(lpPtr+x-nLineBytes-1);
  1539. se=(unsigned char)*(lpPtr+x-nLineBytes+1);
  1540. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  1541. if(erasetable[num]==1)
  1542. {
  1543. *(lpPtr+x)=(BYTE)255;
  1544. *(lpTempPtr+x)=(BYTE)255;
  1545. Finished=FALSE;
  1546. y++;
  1547. }
  1548. }
  1549. }
  1550. y++;
  1551. }
  1552. } 
  1553. }
  1555. // cleanup
  1556. GlobalUnlock(hDib);
  1557. GlobalUnlock(hNewDIB);
  1558. GlobalFree(hNewDIB);
  1560. return TRUE;
  1561. }
  1563. //////////////////////////////////////////////////////////
  1564. // internal definitions
  1566. #define PI (double)3.14159265359
  1568. /*complex number*/
  1569. typedef struct
  1570. {
  1571. double re;
  1572. double im;
  1573. }COMPLEX;
  1575. /*complex add*/
  1576. COMPLEX Add(COMPLEX c1, COMPLEX c2)
  1577. {
  1578. COMPLEX c;
  1579. c.re=c1.re+c2.re;
  1580. c.im=c1.im+c2.im;
  1581. return c;
  1582. }
  1584. /*complex substract*/
  1585. COMPLEX Sub(COMPLEX c1, COMPLEX c2)
  1586. {
  1587. COMPLEX c;
  1588. c.re=c1.re-c2.re;
  1589. c.im=c1.im-c2.im;
  1590. return c;
  1591. }
  1593. /*complex multiple*/
  1594. COMPLEX Mul(COMPLEX c1, COMPLEX c2)
  1595. {
  1596. COMPLEX c;
  1597. c.re=c1.re*c2.re-c1.im*c2.im;
  1598. c.im=c1.re*c2.im+c2.re*c1.im;
  1599. return c;
  1600. }
  1601. //////////////////////////////////////////////////////////
  1603. /*
  1604. void FFT(COMPLEX * TD, COMPLEX * FD, int power);
  1605. void IFFT(COMPLEX * FD, COMPLEX * TD, int power);
  1606. void DCT(double *f, double *F, int power);
  1607. void IDCT(double *F, double *f, int power);
  1608. void WALh(double *f, double *W, int power);
  1609. void IWALh(double *W, double *f, int power);
  1610. */
  1612. /****************************************************
  1613. FFT()
  1615. 参数：
  1617. TD为时域值
  1618. FD为频域值
  1619. power为2的幂数
  1621. 返回值：
  1623. 无
  1625. 说明：
  1627. 本函数实现快速傅立叶变换
  1628. ****************************************************/
  1629. void FFT(COMPLEX * TD, COMPLEX * FD, int power)
  1630. {
  1631. int count;
  1632. int i,j,k,bfsize,p;
  1633. double angle;
  1634. COMPLEX *W,*X1,*X2,*X;
  1636. /*计算傅立叶变换点数*/
  1637. count=1<<power;
  1639. /*分配运算所需存储器*/
  1640. W=(COMPLEX *)malloc(sizeof(COMPLEX)*count/2);
  1641. X1=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  1642. X2=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  1644. /*计算加权系数*/
  1645. for(i=0;i<count/2;i++)
  1646. {
  1647. angle=-i*PI*2/count;
  1648. W[i].re=cos(angle);
  1649. W[i].im=sin(angle);
  1650. }
  1652. /*将时域点写入存储器*/
  1653. memcpy(X1,TD,sizeof(COMPLEX)*count);
  1655. /*蝶形运算*/
  1656. for(k=0;k<power;k++)
  1657. {
  1658. for(j=0;j<1<<k;j++)
  1659. {
  1660. bfsize=1<<(power-k);
  1661. for(i=0;i<bfsize/2;i++)
  1662. {
  1663. p=j*bfsize;
  1664. X2[i+p]=Add(X1[i+p],X1[i+p+bfsize/2]);
  1665. X2[i+p+bfsize/2]=Mul(Sub(X1[i+p],X1[i+p+bfsize/2]),W[i*(1<<k)]);
  1666. }
  1667. }
  1668. X=X1;
  1669. X1=X2;
  1670. X2=X;
  1671. }
  1673. /*重新排序*/
  1674. for(j=0;j<count;j++)
  1675. {
  1676. p=0;
  1677. for(i=0;i<power;i++)
  1678. {
  1679. if (j&(1<<i)) p+=1<<(power-i-1);
  1680. }
  1681. FD[j]=X1[p];
  1682. }
  1684. /*释放存储器*/
  1685. free(W);
  1686. free(X1);
  1687. free(X2);
  1688. }
  1690. /****************************************************
  1691. IFFT()
  1693. 参数：
  1695. FD为频域值
  1696. TD为时域值
  1697. power为2的幂数
  1699. 返回值：
  1701. 无
  1703. 说明：
  1705. 本函数利用快速傅立叶变换实现傅立叶反变换
  1706. ****************************************************/
  1707. void IFFT(COMPLEX * FD, COMPLEX * TD, int power)
  1708. {
  1709. int i, count;
  1710. COMPLEX *x;
  1712. /*计算傅立叶反变换点数*/
  1713. count=1<<power;
  1715. /*分配运算所需存储器*/
  1716. x=(COMPLEX *)malloc(sizeof(COMPLEX)*count);
  1718. /*将频域点写入存储器*/
  1719. memcpy(x,FD,sizeof(COMPLEX)*count);
  1721. /*求频域点的共轭*/
  1722. for(i=0;i<count;i++)
  1723. x[i].im = -x[i].im;
  1725. /*调用FFT*/
  1726. FFT(x, TD, power);
  1728. /*求时域点的共轭*/
  1729. for(i=0;i<count;i++)
  1730. {
  1731. TD[i].re /= count;
  1732. TD[i].im = -TD[i].im / count;
  1733. }
  1735. /*释放存储器*/
  1736. free(x);
  1737. }
  1739. /*******************************************************
  1740. DCT()
  1742. 参数：
  1744. f为时域值
  1745. F为频域值
  1746. power为2的幂数
  1748. 返回值：
  1750. 无
  1752. 说明：
  1754. 本函数利用快速傅立叶变换实现快速离散余弦变换
  1755. ********************************************************/
  1756. void DCT(double *f, double *F, int power)
  1757. {
  1758. int i,count;
  1759. COMPLEX *X;
  1760. double s;
  1762. /*计算离散余弦变换点数*/
  1763. count=1<<power;
  1765. /*分配运算所需存储器*/
  1766. X=(COMPLEX *)malloc(sizeof(COMPLEX)*count*2);
  1768. /*延拓*/
  1769. memset(X,0,sizeof(COMPLEX)*count*2);
  1771. /*将时域点写入存储器*/
  1772. for(i=0;i<count;i++)
  1773. {
  1774. X[i].re=f[i];
  1775. }
  1777. /*调用快速傅立叶变换*/
  1778. FFT(X,X,power+1);
  1780. /*调整系数*/
  1781. s=1/sqrt(count);
  1782. F[0]=X[0].re*s;
  1783. s*=sqrt(2);
  1784. for(i=1;i<count;i++)
  1785. {
  1786. F[i]=(X[i].re*cos(i*PI/(count*2))+X[i].im*sin(i*PI/(count*2)))*s;
  1787. }
  1789. /*释放存储器*/
  1790. free(X);
  1791. }
  1793. /************************************************************
  1794. IDCT()
  1796. 参数：
  1798. F为频域值
  1799. f为时域值
  1800. power为2的幂数
  1802. 返回值：
  1804. 无
  1806. 说明：
  1808. 本函数利用快速傅立叶反变换实现快速离散反余弦变换
  1809. *************************************************************/
  1810. void IDCT(double *F, double *f, int power)
  1811. {
  1812. int i,count;
  1813. COMPLEX *X;
  1814. double s;
  1816. /*计算离散反余弦变换点数*/
  1817. count=1<<power;
  1819. /*分配运算所需存储器*/
  1820. X=(COMPLEX *)malloc(sizeof(COMPLEX)*count*2);
  1822. /*延拓*/
  1823. memset(X,0,sizeof(COMPLEX)*count*2);
  1825. /*调整频域点，写入存储器*/
  1826. for(i=0;i<count;i++)
  1827. {
  1828. X[i].re=F[i]*cos(i*PI/(count*2));
  1829. X[i].im=F[i]*sin(i*PI/(count*2));
  1830. }
  1832. /*调用快速傅立叶反变换*/
  1833. IFFT(X,X,power+1);
  1835. /*调整系数*/
  1836. s=1/sqrt(count);
  1837. for(i=1;i<count;i++)
  1838. {
  1839. f[i]=(1-sqrt(2))*s*F[0]+sqrt(2)*s*X[i].re*count*2;
  1840. }
  1842. /*释放存储器*/
  1843. free(X);
  1844. }
  1846. /**********************************************************
  1847. WALh()
  1849. 参数：
  1851. f为时域值
  1852. W为频域值
  1853. power为2的幂数
  1855. 返回值：
  1857. 无
  1859. 说明：
  1861. 本函数利用快速傅立叶变换实现快速沃尔什-哈达玛变换
  1862. *************************************************************/
  1863. void WALh(double *f, double *W, int power)
  1864. {
  1865. int count;
  1866. int i,j,k,bfsize,p;
  1867. double *X1,*X2,*X;
  1869. /*计算快速沃尔什变换点数*/
  1871. count=1<<power;
  1873. /*分配运算所需存储器*/
  1874. X1=(double *)malloc(sizeof(double)*count);
  1875. X2=(double *)malloc(sizeof(double)*count);
  1877. /*将时域点写入存储器*/
  1878. memcpy(X1,f,sizeof(double)*count);
  1880. /*蝶形运算*/
  1881. for(k=0;k<power;k++)
  1882. {
  1883. for(j=0;j<1<<k;j++)
  1884. {
  1885. bfsize=1<<(power-k);
  1886. for(i=0;i<bfsize/2;i++)
  1887. {
  1888. p=j*bfsize;
  1889. X2[i+p]=X1[i+p]+X1[i+p+bfsize/2];
  1890. X2[i+p+bfsize/2]=X1[i+p]-X1[i+p+bfsize/2];
  1891. }
  1892. }
  1893. X=X1;
  1894. X1=X2;
  1895. X2=X;
  1896. }
  1897. /*调整系数*/
  1898. // for(i=0;i<count;i++)
  1899. // {
  1900. // W[i]=X1[i]/count;
  1901. // }
  1902. for(j=0;j<count;j++)
  1903. {
  1904. p=0;
  1905. for(i=0;i<power;i++)
  1906. {
  1907. if (j&(1<<i)) p+=1<<(power-i-1);
  1908. }
  1909. W[j]=X1[p]/count;
  1910. }
  1912. /*释放存储器*/
  1913. free(X1);
  1914. free(X2);
  1915. }
  1917. /*********************************************************************
  1918. IWALh()
  1920. 参数：
  1922. W为频域值
  1923. f为时域值
  1924. power为2的幂数
  1926. 返回值：
  1928. 无
  1930. 说明：
  1932. 本函数利用快速沃尔什-哈达玛变换实现快速沃尔什-哈达玛反变换
  1933. **********************************************************************/
  1934. void IWALh(double *W, double *f, int power)
  1935. {
  1936. int i, count;
  1938. /*计算快速沃尔什反变换点数*/
  1939. count=1<<power;
  1941. /*调用快速沃尔什-哈达玛变换*/
  1942. WALh(W, f, power);
  1944. /*调整系数*/
  1945. for(i=0;i<count;i++)
  1946. {
  1947. f[i] *= count;
  1948. }
  1949. }
  1951. //////////////////////////////////////////////////////////////////////////////////
  1952. // internal functions
  1954. #define Point(x,y) lpPoints[(x)+(y)*nWidth]
  1956. void GetPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  1957. {
  1958. int x,y,p;
  1959. int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
  1960. //if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1962. for(y=0;y<nHeight;y++)
  1963. {
  1964. for(x=0;x<nWidth;x++)
  1965. {
  1966. p=x*3+y*nByteWidth;
  1967. lpPoints[x+y*nWidth]=(BYTE)(0.299*(float)lpBits[p+2]+0.587*(float)lpBits[p+1]+0.114*(float)lpBits[p]+0.1);
  1968. }
  1969. }
  1970. }
  1972. void PutPoints(int nWidth,int nHeight,BYTE *lpBits,BYTE *lpPoints)
  1973. {
  1974. int x,y,p,p1;
  1975. int nByteWidth = WIDTHBYTES(nWidth*24); //nWidth*3;
  1976. //if (nByteWidth%4) nByteWidth+=4-(nByteWidth%4);
  1978. for(y=0;y<nHeight;y++)
  1979. {
  1980. for(x=0;x<nWidth;x++)
  1981. {
  1982. p=x*3+y*nByteWidth;
  1983. p1=x+y*nWidth;
  1984. lpBits[p]=lpPoints[p1];
  1985. lpBits[p+1]=lpPoints[p1];
  1986. lpBits[p+2]=lpPoints[p1];
  1987. }
  1988. }
  1989. }
  1990. //////////////////////////////////////////////////////////////////////////////
  1992. /****************************************************
  1993. FFTDIB()
  1995. 参数：
  1997. hDIB为输入的DIB句柄
  1999. 返回值：
  2001. 成功为TRUE；失败为FALSE
  2003. 说明：
  2005. 本函数实现DIB位图的快速傅立叶变换
  2006. ****************************************************/
  2007. BOOL FFTDIB(HDIB hDIB)
  2008. {
  2009. if (hDIB == NULL)
  2010. return FALSE;
  2012. // start wait cursor
  2013. WaitCursorBegin();
  2015. HDIB hDib = NULL;
  2016. HDIB hNewDib = NULL;
  2017. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  2018. WORD wBitCount = DIBBitCount(hDIB);
  2019. if (wBitCount != 24)
  2020. {
  2021. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  2022. hDib = CopyHandle(hNewDib);
  2023. }
  2024. else
  2025. {
  2026. hNewDib = CopyHandle(hDIB);
  2027. hDib = CopyHandle(hDIB);
  2028. }
  2030. if (hNewDib == NULL && hDib == NULL)
  2031. {
  2032. WaitCursorEnd();
  2033. return FALSE;
  2034. }
  2036. // process!
  2037. LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDib);
  2038. LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2039. LPBYTE lpInput = FindDIBBits(lpSrcDIB);
  2040. LPBYTE lpOutput = FindDIBBits(lpDIB);
  2041. int nWidth = DIBWidth(lpSrcDIB);
  2042. int nHeight = DIBHeight(lpSrcDIB);
  2044. int w=1,h=1,wp=0,hp=0;
  2045. while(w*2<=nWidth)
  2046. {
  2047. w*=2;
  2048. wp++;
  2049. }
  2050. while(h*2<=nHeight)
  2051. {
  2052. h*=2;
  2053. hp++;
  2054. }
  2055. int x,y;
  2056. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  2057. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  2059. COMPLEX *TD=new COMPLEX[w*h];
  2060. COMPLEX *FD=new COMPLEX[w*h];
  2062. for(y=0;y<h;y++)
  2063. {
  2064. for(x=0;x<w;x++)
  2065. {
  2066. TD[x+w*y].re=Point(x,y);
  2067. TD[x+w*y].im=0;
  2068. }
  2069. }
  2071. for(y=0;y<h;y++)
  2072. {
  2073. FFT(&TD[w*y],&FD[w*y],wp);
  2074. }
  2075. for(y=0;y<h;y++)
  2076. {
  2077. for(x=0;x<w;x++)
  2078. {
  2079. TD[y+h*x]=FD[x+w*y];
  2080. // TD[x+w*y]=FD[x*h+y];
  2081. }
  2082. }
  2083. for(x=0;x<w;x++)
  2084. {
  2085. FFT(&TD[x*h],&FD[x*h],hp);
  2086. }
  2088. memset(lpPoints,0,nWidth*nHeight);
  2089. double m;
  2090. for(y=0;y<h;y++)
  2091. {
  2092. for(x=0;x<w;x++)
  2093. {
  2094. m=sqrt(FD[x*h+y].re*FD[x*h+y].re+FD[x*h+y].im*FD[x*h+y].im)/100;
  2095. if (m>255) m=255;
  2096. Point((x<w/2?x+w/2:x-w/2),nHeight-1-(y<h/2?y+h/2:y-h/2))=(BYTE)(m);
  2097. }
  2098. }
  2099. delete TD;
  2100. delete FD;
  2101. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  2102. delete lpPoints;
  2104. // recover
  2105. DWORD dwSize = GlobalSize(hDib);
  2106. memcpy(lpSrcDIB, lpDIB, dwSize);
  2107. GlobalUnlock(hDib);
  2108. GlobalUnlock(hNewDib);
  2109. if (wBitCount != 24)
  2110. {
  2111. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  2113. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2114. lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2115. dwSize = GlobalSize(hNewDib);
  2116. memcpy(lpSrcDIB, lpDIB, dwSize);
  2117. GlobalUnlock(hDIB);
  2118. GlobalUnlock(hNewDib);
  2119. }
  2120. else
  2121. {
  2122. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2123. lpDIB = (LPBYTE)GlobalLock(hDib);
  2124. dwSize = GlobalSize(hDib);
  2125. memcpy(lpSrcDIB, lpDIB, dwSize);
  2126. GlobalUnlock(hDIB);
  2127. GlobalUnlock(hDib);
  2128. }
  2130. // cleanup
  2131. GlobalFree(hDib);
  2132. GlobalFree(hNewDib);
  2134. // return
  2135. WaitCursorEnd();
  2136. return TRUE;
  2137. }
  2139. /****************************************************
  2140. DCTDIB()
  2142. 参数：
  2144. hDIB为输入的DIB句柄
  2146. 返回值：
  2148. 成功为TRUE；失败为FALSE
  2150. 说明：
  2152. 本函数实现DIB位图的快速余弦变换
  2153. ****************************************************/
  2154. BOOL DCTDIB(HDIB hDIB)
  2155. {
  2156. if (hDIB == NULL)
  2157. return FALSE;
  2159. // start wait cursor
  2160. WaitCursorBegin();
  2162. HDIB hDib = NULL;
  2163. HDIB hNewDib = NULL;
  2164. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  2165. WORD wBitCount = DIBBitCount(hDIB);
  2166. if (wBitCount != 24)
  2167. {
  2168. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  2169. hDib = CopyHandle(hNewDib);
  2170. }
  2171. else
  2172. {
  2173. hNewDib = CopyHandle(hDIB);
  2174. hDib = CopyHandle(hDIB);
  2175. }
  2177. if (hNewDib == NULL && hDib == NULL)
  2178. {
  2179. WaitCursorEnd();
  2180. return FALSE;
  2181. }
  2183. // process!
  2184. LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDib);
  2185. LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2186. LPBYTE lpInput = FindDIBBits(lpSrcDIB);
  2187. LPBYTE lpOutput = FindDIBBits(lpDIB);
  2188. int nWidth = DIBWidth(lpSrcDIB);
  2189. int nHeight = DIBHeight(lpSrcDIB);
  2191. int w=1,h=1,wp=0,hp=0;
  2192. while(w*2<=nWidth)
  2193. {
  2194. w*=2;
  2195. wp++;
  2196. }
  2197. while(h*2<=nHeight)
  2198. {
  2199. h*=2;
  2200. hp++;
  2201. }
  2202. int x,y;
  2203. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  2204. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  2206. double *f=new double[w*h];
  2207. double *W=new double[w*h];
  2209. for(y=0;y<h;y++)
  2210. {
  2211. for(x=0;x<w;x++)
  2212. {
  2213. f[x+y*w]=Point(x,y);
  2214. }
  2215. }
  2217. for(y=0;y<h;y++)
  2218. {
  2219. DCT(&f[w*y],&W[w*y],wp);
  2220. }
  2221. for(y=0;y<h;y++)
  2222. {
  2223. for(x=0;x<w;x++)
  2224. {
  2225. f[x*h+y]=W[x+w*y];
  2226. }
  2227. }
  2228. for(x=0;x<w;x++)
  2229. {
  2230. DCT(&f[x*h],&W[x*h],hp);
  2231. }
  2232. double a;
  2233. memset(lpPoints,0,nWidth*nHeight);
  2235. for(y=0;y<h;y++)
  2236. {
  2237. for(x=0;x<w;x++)
  2238. {
  2239. a=fabs(W[x*h+y]);
  2240. if (a>255) a=255;
  2241. Point(x,nHeight-y-1)=(BYTE)(a);
  2242. }
  2243. }
  2244. delete f;
  2245. delete W;
  2246. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  2247. delete lpPoints;
  2249. // recover
  2250. DWORD dwSize = GlobalSize(hDib);
  2251. memcpy(lpSrcDIB, lpDIB, dwSize);
  2252. GlobalUnlock(hDib);
  2253. GlobalUnlock(hNewDib);
  2254. if (wBitCount != 24)
  2255. {
  2256. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  2258. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2259. lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2260. dwSize = GlobalSize(hNewDib);
  2261. memcpy(lpSrcDIB, lpDIB, dwSize);
  2262. GlobalUnlock(hDIB);
  2263. GlobalUnlock(hNewDib);
  2264. }
  2265. else
  2266. {
  2267. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2268. lpDIB = (LPBYTE)GlobalLock(hDib);
  2269. dwSize = GlobalSize(hDib);
  2270. memcpy(lpSrcDIB, lpDIB, dwSize);
  2271. GlobalUnlock(hDIB);
  2272. GlobalUnlock(hDib);
  2273. }
  2275. // cleanup
  2276. GlobalFree(hDib);
  2277. GlobalFree(hNewDib);
  2279. // return
  2280. WaitCursorEnd();
  2281. return TRUE;
  2282. }
  2284. /****************************************************
  2285. WALhDIB()
  2287. 参数：
  2289. hDIB为输入的DIB句柄
  2291. 返回值：
  2293. 成功为TRUE；失败为FALSE
  2295. 说明：
  2297. 本函数实现DIB位图的快速沃尔什-哈达玛变换
  2298. ****************************************************/
  2299. BOOL WALhDIB(HDIB hDIB)
  2300. {
  2301. if (hDIB == NULL)
  2302. return FALSE;
  2304. // start wait cursor
  2305. WaitCursorBegin();
  2307. HDIB hDib = NULL;
  2308. HDIB hNewDib = NULL;
  2309. // we only convolute 24bpp DIB, so first convert DIB to 24bpp
  2310. WORD wBitCount = DIBBitCount(hDIB);
  2311. if (wBitCount != 24)
  2312. {
  2313. hNewDib = ConvertDIBFormat(hDIB, 24, NULL);
  2314. hDib = CopyHandle(hNewDib);
  2315. }
  2316. else
  2317. {
  2318. hNewDib = CopyHandle(hDIB);
  2319. hDib = CopyHandle(hDIB);
  2320. }
  2322. if (hNewDib == NULL && hDib == NULL)
  2323. {
  2324. WaitCursorEnd();
  2325. return FALSE;
  2326. }
  2328. // process!
  2329. LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDib);
  2330. LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2331. LPBYTE lpInput = FindDIBBits(lpSrcDIB);
  2332. LPBYTE lpOutput = FindDIBBits(lpDIB);
  2333. int nWidth = DIBWidth(lpSrcDIB);
  2334. int nHeight = DIBHeight(lpSrcDIB);
  2336. int w=1,h=1,wp=0,hp=0;
  2337. while(w*2<=nWidth)
  2338. {
  2339. w*=2;
  2340. wp++;
  2341. }
  2342. while(h*2<=nHeight)
  2343. {
  2344. h*=2;
  2345. hp++;
  2346. }
  2347. int x,y;
  2348. BYTE *lpPoints=new BYTE[nWidth*nHeight];
  2349. GetPoints(nWidth,nHeight,lpInput,lpPoints);
  2351. double *f=new double[w*h];
  2352. double *W=new double[w*h];
  2354. for(y=0;y<h;y++)
  2355. {
  2356. for(x=0;x<w;x++)
  2357. {
  2358. f[x+y*w]=Point(x,y);
  2359. }
  2360. }
  2362. for(y=0;y<h;y++)
  2363. {
  2364. WALh(f+w*y,W+w*y,wp);
  2365. }
  2366. for(y=0;y<h;y++)
  2367. {
  2368. for(x=0;x<w;x++)
  2369. {
  2370. f[x*h+y]=W[x+w*y];
  2371. }
  2372. }
  2373. for(x=0;x<w;x++)
  2374. {
  2375. WALh(f+x*h,W+x*h,hp);
  2376. }
  2377. double a;
  2378. memset(lpPoints,0,nWidth*nHeight);
  2380. for(y=0;y<h;y++)
  2381. {
  2382. for(x=0;x<w;x++)
  2383. {
  2384. a=fabs(W[x*h+y]*1000);
  2385. if (a>255) a=255;
  2386. Point(x,nHeight-y-1)=(BYTE)a;
  2387. }
  2388. }
  2389. delete f;
  2390. delete W;
  2391. PutPoints(nWidth,nHeight,lpOutput,lpPoints);
  2392. delete lpPoints;
  2394. // recover
  2395. DWORD dwSize = GlobalSize(hDib);
  2396. memcpy(lpSrcDIB, lpDIB, dwSize);
  2397. GlobalUnlock(hDib);
  2398. GlobalUnlock(hNewDib);
  2399. if (wBitCount != 24)
  2400. {
  2401. hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL);
  2403. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2404. lpDIB = (LPBYTE)GlobalLock(hNewDib);
  2405. dwSize = GlobalSize(hNewDib);
  2406. memcpy(lpSrcDIB, lpDIB, dwSize);
  2407. GlobalUnlock(hDIB);
  2408. GlobalUnlock(hNewDib);
  2409. }
  2410. else
  2411. {
  2412. lpSrcDIB = (LPBYTE)GlobalLock(hDIB);
  2413. lpDIB = (LPBYTE)GlobalLock(hDib);
  2414. dwSize = GlobalSize(hDib);
  2415. memcpy(lpSrcDIB, lpDIB, dwSize);
  2416. GlobalUnlock(hDIB);
  2417. GlobalUnlock(hDib);
  2418. }
  2420. // cleanup
  2421. GlobalFree(hDib);
  2422. GlobalFree(hNewDib);
  2424. // return
  2425. WaitCursorEnd();
  2426. return TRUE;
  2427. }