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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > GDI/图象编程 > 查看源码
morph.c
资源名称：3390.rar　[点击查看]
上传用户：sales1818
上传日期：2022-03-31
资源大小：15k
文件大小：28k
源码类别：

GDI/图象编程

开发平台：

C/C++

morph.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:morph.c
  3. //Purpose: To perform morphological operation
  4. //Author: phoenix, CS, TshingHua, Beijing, P.R.C.
  5. //Email: bjlufengjun@www.163.net or lufengjun@hotmail.com
  6. //Date:April 3, 1998
  8. //header file
  9. #include "bmp.h"
  10. #include "memory.h"
  11. #include "math.h"
  12. #include "stdio.h"
  13. //owner defined stack
  14. typedef struct{
  15.   HGLOBAL hMem;
  16.      POINT *lpMyStack;
  17.   LONG  ElementsNum;
  18.   LONG  ptr;
  19.   }MYSTACK;
  20. //macro definition
  21. #define WIDTHBYTES(i)    ((i+31)/32*4)
  22. #define PI 3.1415926535
  23. #define RADIAN(angle) ((angle)*PI/180.0) //convert angle to radian
  25. //function declaration
  26. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  27. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  28. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName);
  29. BOOL Dilation(HWND hWnd,BOOL Hori);
  30. BOOL Erosion(HWND hWnd,BOOL Hori);
  31. BOOL MorphOpen(HWND hWnd,BOOL Hori);
  32. BOOL MorphClose(HWND hWnd,BOOL Hori);
  33. BOOL Thinning(HWND hWnd);
  34. //global variable declaration
  35. BITMAPFILEHEADER   bf;
  36. BITMAPINFOHEADER   bi;
  37. HPALETTE           hPalette=NULL;
  38. HBITMAP            hBitmap=NULL;
  39. HGLOBAL            hImgData=NULL;
  40. DWORD              NumColors;
  41. DWORD              LineBytes;
  42. HINSTANCE          ghInst;
  43. DWORD              ImgWidth=0 , ImgHeight=0;
  44. ///////////////////////////////////////////////////////////
  45. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  46.     LPSTR lpszCmdLine, int nCmdShow)
  47. {
  48. MSG       msg;
  49. WNDCLASS  wndclass;
  50. HWND      hWnd;
  52. ghInst=hInstance;
  53. if ( ! hPrevInstance ){
  54. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  55. wndclass.lpfnWndProc = MainWndProc;
  56. wndclass.cbClsExtra = 0;
  57. wndclass.cbWndExtra = 0;
  58. wndclass.hInstance = hInstance;
  59. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  60. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  61. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  62. wndclass.lpszMenuName =  "BMPMENU";
  63. wndclass.lpszClassName = "phoenix ip system";
  64.     }
  66.     if ( ! RegisterClass (&wndclass) )
  67. return FALSE;
  68.  
  69. hWnd = CreateWindow ("phoenix ip system","Morphological operation",
  70.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  71.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  72.  hInstance, NULL);
  73. if (!hWnd)
  74. return FALSE;
  75. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  76. UpdateWindow (hWnd);
  78. while ( GetMessage (&msg, NULL, 0, 0) ){
  79. TranslateMessage (&msg);
  80. DispatchMessage (&msg);
  81.     }
  83. return msg.wParam;
  84. }
  85. ////////////////////////////////////////////////////////////////
  86. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  87. {
  88.     static  HDC    hDC,hMemDC;
  89.     PAINTSTRUCT    ps;
  91.     switch (message){
  92.     case WM_PAINT:
  93. {         
  94. hDC = BeginPaint(hWnd, &ps);
  95. if (hBitmap)
  96. { 
  97. hMemDC = CreateCompatibleDC(hDC);
  98. if (hPalette)
  99. {           
  100. SelectPalette (hDC, hPalette, FALSE); 
  101. SelectPalette (hMemDC, hPalette, FALSE);
  102. RealizePalette (hDC);
  103. }   
  104. SelectObject(hMemDC, hBitmap); 
  105. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  106. DeleteDC(hMemDC);
  107. }
  108. EndPaint(hWnd, &ps);
  109. break;
  110. }
  111. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  112.         if(hBitmap!=NULL)
  113.         DeleteObject(hBitmap);
  114.     
  115. if(hPalette!=NULL)                     
  116.         DeleteObject(hPalette);
  118. if(hImgData!=NULL){
  119. GlobalUnlock(hImgData);
  120. GlobalFree(hImgData);
  121. }         
  122.     PostQuitMessage (0);
  123.     return 0;
  124. case WM_COMMAND:
  125.     switch (wParam){
  126.     case IDM_LOADBMP: 
  127. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  128.         if(hBitmap!=NULL){     
  129. DeleteObject(hBitmap);
  130.             hBitmap=NULL;
  131.         }
  132.         if(hPalette!=NULL){                     
  133. DeleteObject(hPalette);
  134.             hPalette=NULL;
  135.         }
  136. if(hImgData!=NULL){
  137. GlobalUnlock(hImgData);
  138. GlobalFree(hImgData);  
  139. hImgData=NULL;
  140. }         
  141. if(LoadBmpFile(hWnd,"c:\test.bmp")) //成功，则重画窗口
  142.                 InvalidateRect(hWnd,NULL,TRUE);
  143.         break;
  144. case IDM_HDILATION:
  145. if(hImgData!=NULL){
  146. if(Dilation(hWnd,TRUE))
  147. InvalidateRect(hWnd,NULL,TRUE);
  148. }
  149. else
  150. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  151. break;
  152. case IDM_VDILATION:
  153. if(hImgData!=NULL){
  154. if(Dilation(hWnd,FALSE))
  155. InvalidateRect(hWnd,NULL,TRUE);
  156. }
  157. else
  158. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  159. break;
  160. case IDM_HEROSION:
  161. if(hImgData!=NULL){
  162. if(Erosion(hWnd,TRUE))
  163. InvalidateRect(hWnd,NULL,TRUE);
  164. }
  165. else
  166. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  167. break;
  168. case IDM_VEROSION:
  169. if(hImgData!=NULL){
  170. if(Erosion(hWnd,FALSE))
  171. InvalidateRect(hWnd,NULL,TRUE);
  172. }
  173. else
  174. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  175. break;
  176. case IDM_HOPEN:
  177. if(hImgData!=NULL){
  178. if(MorphOpen(hWnd,TRUE))
  179. InvalidateRect(hWnd,NULL,TRUE);
  180. }
  181. else
  182. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  183. break;
  184. case IDM_VOPEN:
  185. if(hImgData!=NULL){
  186. if(MorphOpen(hWnd,FALSE))
  187. InvalidateRect(hWnd,NULL,TRUE);
  188. }
  189. else
  190. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  191. break;
  192. case IDM_HCLOSE:
  193. if(hImgData!=NULL){
  194. if(MorphClose(hWnd,TRUE))
  195. InvalidateRect(hWnd,NULL,TRUE);
  196. }
  197. else
  198. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  199. break;
  200. case IDM_VCLOSE:
  201. if(hImgData!=NULL){
  202. if(MorphClose(hWnd,FALSE))
  203. InvalidateRect(hWnd,NULL,TRUE);
  204. }
  205. else
  206. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  207. break;
  208. case IDM_THINNING:
  209. if(hImgData!=NULL){
  210. if(Thinning(hWnd))
  211. InvalidateRect(hWnd,NULL,TRUE);
  212. }
  213. else
  214. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  215. break;
  216. case IDM_EXIT:
  217.         SendMessage(hWnd,WM_DESTROY,0,0L);
  218.         break;
  219.     }
  220. break;                
  221.     }
  222.     return DefWindowProc (hWnd, message, wParam, lParam);
  223. }
  224. ////////////////////////////////////////////////////////////////
  225. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName)
  226. {   
  227.     HFILE              hf;
  228.     LPBITMAPINFOHEADER lpImgData;
  229.     LOGPALETTE         *pPal;
  230.     LPRGBQUAD          lpRGB;
  231.     HPALETTE           hPrevPalette; 
  232.     HDC                hDc;
  233. HLOCAL             hPal;
  234. DWORD         ImgSize;
  235. DWORD              i;
  237.     if((hf=_lopen(BmpFileName,OF_READ))==HFILE_ERROR){
  238.         MessageBox(hWnd,"File c:\test.bmp not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  239.         return FALSE;
  240. }
  241. _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  242. _lread(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER));
  243. ImgWidth=bi.biWidth;
  244. ImgHeight=bi.biHeight;
  245. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  246. ImgSize=(DWORD)LineBytes*bi.biHeight;
  247.     if(bi.biClrUsed!=0)
  248. NumColors=(DWORD)bi.biClrUsed;
  249. else
  250.         switch(bi.biBitCount){
  251.         case 1:
  252.              NumColors=2;
  253.              break;
  254.          case 4:
  255.              NumColors=16;
  256.              break;
  257.          case 8:
  258.              NumColors=256;
  259.              break;
  260.          case 24:
  261.              NumColors=0;
  262.              break;
  263.               default:
  264.                   MessageBox(hWnd,"Invalid color numbers!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  265.                   _lclose(hf);
  266.                   return FALSE; 
  267.         }
  268. if(bf.bfOffBits!=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  269. +sizeof(BITMAPINFOHEADER)))
  270. {
  271.      MessageBox(hWnd,"Invalid color numbers!","Error Message" ,MB_OK|
  272.                MB_ICONEXCLAMATION);
  273. _lclose(hf);
  274. return FALSE; 
  275. }
  276. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  277. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  278.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  279. {
  280.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  281.                    MB_ICONEXCLAMATION);
  282.     _lclose(hf);
  283. return FALSE;
  284. }
  285.   
  286. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  287.     _llseek(hf,sizeof(BITMAPFILEHEADER),FILE_BEGIN);
  288. _hread(hf,(char *)lpImgData,(long)sizeof(BITMAPINFOHEADER)
  289.            +(long)NumColors*sizeof(RGBQUAD)+ImgSize);
  290. _lclose(hf);
  291.     if(NumColors!=0)
  292. {                    
  293.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  294.     pPal =(LOGPALETTE *)LocalLock(hPal);
  295.     pPal->palNumEntries =(WORD) NumColors;
  296. pPal->palVersion    = 0x300;
  297.     lpRGB = (LPRGBQUAD)((LPSTR)lpImgData + (DWORD)sizeof(BITMAPINFOHEADER));
  298. for (i = 0; i < NumColors; i++) {
  299.       pPal->palPalEntry[i].peRed=lpRGB->rgbRed;
  300. pPal->palPalEntry[i].peGreen=lpRGB->rgbGreen;
  301. pPal->palPalEntry[i].peBlue=lpRGB->rgbBlue;
  302. pPal->palPalEntry[i].peFlags=(BYTE)0;
  303. lpRGB++;
  304. }
  305. hPalette=CreatePalette(pPal);
  306. LocalUnlock(hPal);
  307. LocalFree(hPal);
  308. }
  309. hDc=GetDC(hWnd);
  310. if(hPalette){
  311.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  312. RealizePalette(hDc);
  313. }
  314. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  315. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  316.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  317. if(hPalette && hPrevPalette){
  318. SelectPalette(hDc,hPrevPalette,FALSE);
  319. RealizePalette(hDc);
  320. }
  321.  
  322. ReleaseDC(hWnd,hDc);
  323. GlobalUnlock(hImgData);
  324. return TRUE; 
  325. }
  326. ////////////////////////////////////////////////////////////////
  327. BOOL Erosion(HWND hWnd,BOOL Hori)
  328. {
  329. DWORD              BufSize;
  330.     LPBITMAPINFOHEADER lpImgData;
  331. LPSTR              lpPtr;
  332. HLOCAL             hTempImgData;
  333. LPBITMAPINFOHEADER lpTempImgData;
  334. LPSTR              lpTempPtr;
  335. HDC                hDc;
  336. HFILE              hf;
  337. LONG               x,y;
  338. unsigned char      num;
  339. int                i;
  341. if( NumColors!=256){
  342.      MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  343.         return FALSE;
  344.     }
  345. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  346. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  347.     {
  348.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  349.         return FALSE;
  350.     }
  351.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  352. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  353. //copy image data
  354. memcpy(lpTempImgData,lpImgData,BufSize);
  355. if(Hori)
  356. {
  357. for(y=0;y<bi.biHeight;y++){
  358. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+1;
  359. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  360. for(x=1;x<bi.biWidth-1;x++){
  361. num=(unsigned char)*lpPtr;
  362. if (num==0){
  363. *lpTempPtr=(unsigned char)0;
  364. for(i=0;i<3;i++){
  365. num=(unsigned char)*(lpPtr+i-1);
  366. if(num==255){
  367. *lpTempPtr=(unsigned char)255;
  368. break;
  369. }
  370. }
  371. }
  372. else *lpTempPtr=(unsigned char)255;
  373. lpPtr++;
  374. lpTempPtr++;
  375. }
  376. }
  377. }
  378. else{
  379. for(y=1;y<bi.biHeight-1;y++){
  380. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  381. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  382. for(x=0;x<bi.biWidth;x++){
  383. num=(unsigned char)*lpPtr;
  384. if (num==0){
  385. *lpTempPtr=(unsigned char)0;
  386. for(i=0;i<3;i++){
  387. num=(unsigned char)*(lpPtr+(i-1)*LineBytes);
  388. if(num==255){
  389. *lpTempPtr=(unsigned char)255;
  390. break;
  391. }
  392. }
  393. }
  394. else *lpTempPtr=(unsigned char)255;
  395. lpPtr++;
  396. lpTempPtr++;
  397. }
  398. }
  399. }
  401.     if(hBitmap!=NULL)
  402.     DeleteObject(hBitmap);
  403. hDc=GetDC(hWnd);
  404. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  405. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  406.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  408. if(Hori)
  409. hf=_lcreat("c:\herosion.bmp",0);
  410. else
  411. hf=_lcreat("c:\verosion.bmp",0);
  413. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  414. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  415. _lclose(hf);
  417.   ReleaseDC(hWnd,hDc);
  418. LocalUnlock(hTempImgData);
  419. LocalFree(hTempImgData);
  420. GlobalUnlock(hImgData);
  421. return TRUE;
  422. }
  423. ////////////////////////////////////////////////////////////////
  424. BOOL Dilation(HWND hWnd,BOOL Hori)
  425. {
  426. DWORD              BufSize;
  427.     LPBITMAPINFOHEADER lpImgData;
  428. LPSTR              lpPtr;
  429. HLOCAL             hTempImgData;
  430. LPBITMAPINFOHEADER lpTempImgData;
  431. LPSTR              lpTempPtr;
  432. HDC                hDc;
  433. HFILE              hf;
  434. LONG               x,y;
  435. unsigned char      num;
  436. int                i;
  438. if( NumColors!=256){
  439.      MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  440.         return FALSE;
  441.     }
  442. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  443. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  444.     {
  445.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  446.         return FALSE;
  447.     }
  448.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  449. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  450. //copy image data
  451. memcpy(lpTempImgData,lpImgData,BufSize);
  452. if(Hori)
  453. {
  454. for(y=0;y<bi.biHeight;y++){
  455. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+1;
  456. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  457. for(x=1;x<bi.biWidth-1;x++){
  458. num=(unsigned char)*lpPtr;
  459. if (num==255){
  460. *lpTempPtr=(unsigned char)255;
  461. for(i=0;i<3;i++){
  462. num=(unsigned char)*(lpPtr+i-1);
  463. if(num==0){
  464. *lpTempPtr=(unsigned char)0;
  465. break;
  466. }
  467. }
  468. }
  469. else *lpTempPtr=(unsigned char)0;
  470. lpPtr++;
  471. lpTempPtr++;
  472. }
  473. }
  474. }
  475. else{
  476. for(y=1;y<bi.biHeight-1;y++){
  477. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  478. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  479. for(x=0;x<bi.biWidth;x++){
  480. num=(unsigned char)*lpPtr;
  481. if (num==255){
  482. *lpTempPtr=(unsigned char)255;
  483. for(i=0;i<3;i++){
  484. num=(unsigned char)*(lpPtr+(i-1)*LineBytes);
  485. if(num==0){
  486. *lpTempPtr=(unsigned char)0;
  487. break;
  488. }
  489. }
  490. }
  491. else *lpTempPtr=(unsigned char)0;
  492. lpPtr++;
  493. lpTempPtr++;
  494. }
  495. }
  496. }
  498.     if(hBitmap!=NULL)
  499.     DeleteObject(hBitmap);
  500. hDc=GetDC(hWnd);
  501. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  502. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  503.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  505. if(Hori)
  506. hf=_lcreat("c:\hdilation.bmp",0);
  507. else
  508. hf=_lcreat("c:\vdilation.bmp",0);
  510. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  511. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  512. _lclose(hf);
  514.   ReleaseDC(hWnd,hDc);
  515. LocalUnlock(hTempImgData);
  516. LocalFree(hTempImgData);
  517. GlobalUnlock(hImgData);
  518. return TRUE;
  519. }
  520. ////////////////////////////////////////////////////////////////
  521. BOOL MorphOpen(HWND hWnd,BOOL Hori)
  522. {
  523. DWORD              BufSize;
  524.     LPBITMAPINFOHEADER lpImgData;
  525. LPSTR              lpPtr;
  526. HLOCAL             hTempImgData;
  527. LPBITMAPINFOHEADER lpTempImgData;
  528. LPSTR              lpTempPtr;
  529. HLOCAL             hTempImgData1;
  530. LPBITMAPINFOHEADER lpTempImgData1;
  531. LPSTR              lpTempPtr1;
  532. HDC                hDc;
  533. HFILE              hf;
  534. LONG               x,y;
  535. unsigned char      num;
  536. int                i;
  538. if( NumColors!=256){
  539.      MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  540.         return FALSE;
  541.     }
  542. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  544. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  545.     {
  546.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  547.         return FALSE;
  548.     }
  550. if((hTempImgData1=LocalAlloc(LHND,BufSize))==NULL)
  551.     {
  552.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  553. LocalFree(hTempImgData);
  554.         return FALSE;
  555.     }
  556. //step 1: erosion,the result is stored in lpTempImgData
  557.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  558. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  559. //copy image data
  560. memcpy(lpTempImgData,lpImgData,BufSize);
  561. if(Hori)
  562. {
  563. for(y=0;y<bi.biHeight;y++){
  564. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+1;
  565. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  566. for(x=1;x<bi.biWidth-1;x++){
  567. num=(unsigned char)*lpPtr;
  568. if (num==0){
  569. *lpTempPtr=(unsigned char)0;
  570. for(i=0;i<3;i++){
  571. num=(unsigned char)*(lpPtr+i-1);
  572. if(num==255){
  573. *lpTempPtr=(unsigned char)255;
  574. break;
  575. }
  576. }
  577. }
  578. else *lpTempPtr=(unsigned char)255;
  579. lpPtr++;
  580. lpTempPtr++;
  581. }
  582. }
  583. }
  584. else{
  585. for(y=1;y<bi.biHeight-1;y++){
  586. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  587. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  588. for(x=0;x<bi.biWidth;x++){
  589. num=(unsigned char)*lpPtr;
  590. if (num==0){
  591. *lpTempPtr=(unsigned char)0;
  592. for(i=0;i<3;i++){
  593. num=(unsigned char)*(lpPtr+(i-1)*LineBytes);
  594. if(num==255){
  595. *lpTempPtr=(unsigned char)255;
  596. break;
  597. }
  598. }
  599. }
  600. else *lpTempPtr=(unsigned char)255;
  601. lpPtr++;
  602. lpTempPtr++;
  603. }
  604. }
  605. }
  606. //step 2: dilation,the result is stored in lpTempImgData1
  607. //copy image data
  608. lpTempImgData1=(LPBITMAPINFOHEADER)LocalLock(hTempImgData1);
  609. //copy image data
  610. memcpy(lpTempImgData1,lpTempImgData,BufSize);
  611. if(Hori)
  612. {
  613. for(y=0;y<bi.biHeight;y++){
  614. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  615. lpTempPtr1=(char *)lpTempImgData1+(BufSize-LineBytes-y*LineBytes)+1;
  616. for(x=1;x<bi.biWidth-1;x++){
  617. num=(unsigned char)*lpTempPtr;
  618. if (num==255){
  619. *lpTempPtr1=(unsigned char)255;
  620. for(i=0;i<3;i++){
  621. num=(unsigned char)*(lpTempPtr+i-1);
  622. if(num==0){
  623. *lpTempPtr1=(unsigned char)0;
  624. break;
  625. }
  626. }
  627. }
  628. else *lpTempPtr1=(unsigned char)0;
  629. lpTempPtr++;
  630. lpTempPtr1++;
  631. }
  632. }
  633. }
  634. else{
  635. for(y=1;y<bi.biHeight-1;y++){
  636. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  637. lpTempPtr1=(char *)lpTempImgData1+(BufSize-LineBytes-y*LineBytes);
  638. for(x=0;x<bi.biWidth;x++){
  639. num=(unsigned char)*lpTempPtr;
  640. if (num==255){
  641. *lpTempPtr1=(unsigned char)255;
  642. for(i=0;i<3;i++){
  643. num=(unsigned char)*(lpTempPtr+(i-1)*LineBytes);
  644. if(num==0){
  645. *lpTempPtr1=(unsigned char)0;
  646. break;
  647. }
  648. }
  649. }
  650. else *lpTempPtr1=(unsigned char)0;
  651. lpTempPtr++;
  652. lpTempPtr1++;
  653. }
  654. }
  655. }
  657.     if(hBitmap!=NULL)
  658.     DeleteObject(hBitmap);
  659. hDc=GetDC(hWnd);
  660. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData1, (LONG)CBM_INIT,
  661. (LPSTR)lpTempImgData1+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  662.     (LPBITMAPINFO)lpTempImgData1, DIB_RGB_COLORS);
  664. if(Hori)
  665. hf=_lcreat("c:\hmopen.bmp",0);
  666. else
  667. hf=_lcreat("c:\vmopen.bmp",0);
  669. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  670. _lwrite(hf,(LPSTR)lpTempImgData1,BufSize);
  671. _lclose(hf);
  673.   ReleaseDC(hWnd,hDc);
  674. LocalUnlock(hTempImgData);
  675. LocalFree(hTempImgData);
  676. LocalUnlock(hTempImgData1);
  677. LocalFree(hTempImgData1);
  678. GlobalUnlock(hImgData);
  679. return TRUE;
  680. }
  681. ////////////////////////////////////////////////////////////////
  682. BOOL MorphClose(HWND hWnd,BOOL Hori)
  683. {
  684. DWORD              BufSize;
  685.     LPBITMAPINFOHEADER lpImgData;
  686. LPSTR              lpPtr;
  687. HLOCAL             hTempImgData;
  688. LPBITMAPINFOHEADER lpTempImgData;
  689. LPSTR              lpTempPtr;
  690. HLOCAL             hTempImgData1;
  691. LPBITMAPINFOHEADER lpTempImgData1;
  692. LPSTR              lpTempPtr1;
  693. HDC                hDc;
  694. HFILE              hf;
  695. LONG               x,y;
  696. unsigned char      num;
  697. int                i;
  699. if( NumColors!=256){
  700.      MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  701.         return FALSE;
  702.     }
  703. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  705. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  706.     {
  707.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  708.         return FALSE;
  709.     }
  711. if((hTempImgData1=LocalAlloc(LHND,BufSize))==NULL)
  712.     {
  713.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  714. LocalFree(hTempImgData);
  715.         return FALSE;
  716.     }
  717. //step 1: dilation,the result is stored in lpTempImgData
  718.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  719. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  720. //copy image data
  721. memcpy(lpTempImgData,lpImgData,BufSize);
  722. if(Hori)
  723. {
  724. for(y=0;y<bi.biHeight;y++){
  725. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+1;
  726. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  727. for(x=1;x<bi.biWidth-1;x++){
  728. num=(unsigned char)*lpPtr;
  729. if (num==255){
  730. *lpTempPtr=(unsigned char)255;
  731. for(i=0;i<3;i++){
  732. num=(unsigned char)*(lpPtr+i-1);
  733. if(num==0){
  734. *lpTempPtr=(unsigned char)0;
  735. break;
  736. }
  737. }
  738. }
  739. else *lpTempPtr=(unsigned char)0;
  740. lpPtr++;
  741. lpTempPtr++;
  742. }
  743. }
  744. }
  745. else{
  746. for(y=1;y<bi.biHeight-1;y++){
  747. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  748. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  749. for(x=0;x<bi.biWidth;x++){
  750. num=(unsigned char)*lpPtr;
  751. if (num==255){
  752. *lpTempPtr=(unsigned char)255;
  753. for(i=0;i<3;i++){
  754. num=(unsigned char)*(lpPtr+(i-1)*LineBytes);
  755. if(num==0){
  756. *lpTempPtr=(unsigned char)0;
  757. break;
  758. }
  759. }
  760. }
  761. else *lpTempPtr=(unsigned char)0;
  762. lpPtr++;
  763. lpTempPtr++;
  764. }
  765. }
  766. }
  767. //step 2: erosion,the result is stored in lpTempImgData1
  768. //copy image data
  769. lpTempImgData1=(LPBITMAPINFOHEADER)LocalLock(hTempImgData1);
  770. //copy image data
  771. memcpy(lpTempImgData1,lpTempImgData,BufSize);
  772. if(Hori)
  773. {
  774. for(y=0;y<bi.biHeight;y++){
  775. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+1;
  776. lpTempPtr1=(char *)lpTempImgData1+(BufSize-LineBytes-y*LineBytes)+1;
  777. for(x=1;x<bi.biWidth-1;x++){
  778. num=(unsigned char)*lpTempPtr;
  779. if (num==0){
  780. *lpTempPtr1=(unsigned char)0;
  781. for(i=0;i<3;i++){
  782. num=(unsigned char)*(lpTempPtr+i-1);
  783. if(num==255){
  784. *lpTempPtr1=(unsigned char)255;
  785. break;
  786. }
  787. }
  788. }
  789. else *lpTempPtr1=(unsigned char)255;
  790. lpTempPtr++;
  791. lpTempPtr1++;
  792. }
  793. }
  794. }
  795. else{
  796. for(y=1;y<bi.biHeight-1;y++){
  797. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  798. lpTempPtr1=(char *)lpTempImgData1+(BufSize-LineBytes-y*LineBytes);
  799. for(x=0;x<bi.biWidth;x++){
  800. num=(unsigned char)*lpTempPtr;
  801. if (num==0){
  802. *lpTempPtr1=(unsigned char)0;
  803. for(i=0;i<3;i++){
  804. num=(unsigned char)*(lpTempPtr+(i-1)*LineBytes);
  805. if(num==255){
  806. *lpTempPtr1=(unsigned char)255;
  807. break;
  808. }
  809. }
  810. }
  811. else *lpTempPtr1=(unsigned char)255;
  812. lpTempPtr++;
  813. lpTempPtr1++;
  814. }
  815. }
  816. }
  818.     if(hBitmap!=NULL)
  819.     DeleteObject(hBitmap);
  820. hDc=GetDC(hWnd);
  821. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData1, (LONG)CBM_INIT,
  822. (LPSTR)lpTempImgData1+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  823.     (LPBITMAPINFO)lpTempImgData1, DIB_RGB_COLORS);
  825. if(Hori)
  826. hf=_lcreat("c:\hmclose.bmp",0);
  827. else
  828. hf=_lcreat("c:\vmclose.bmp",0);
  830. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  831. _lwrite(hf,(LPSTR)lpTempImgData1,BufSize);
  832. _lclose(hf);
  834.   ReleaseDC(hWnd,hDc);
  835. LocalUnlock(hTempImgData);
  836. LocalFree(hTempImgData);
  837. LocalUnlock(hTempImgData1);
  838. LocalFree(hTempImgData1);
  839. GlobalUnlock(hImgData);
  840. return TRUE;
  841. }
  842. ////////////////////////////////////////////////////////////////
  843. BOOL Thinning(HWND hWnd)
  844. {
  845. DWORD              BufSize;
  846.     LPBITMAPINFOHEADER lpImgData;
  847. LPSTR              lpPtr;
  848. HLOCAL             hTempImgData;
  849. LPBITMAPINFOHEADER lpTempImgData;
  850. LPSTR              lpTempPtr;
  851. HDC                hDc;
  852. HFILE              hf;
  853. LONG               x,y;
  854. int        num;
  855. BOOL               Finished;
  856. int                nw,n,ne,w,e,sw,s,se;
  857. static int erasetable[256]={
  858. 0,0,1,1,0,0,1,1,
  859. 1,1,0,1,1,1,0,1,
  860. 1,1,0,0,1,1,1,1,
  861. 0,0,0,0,0,0,0,1,
  863. 0,0,1,1,0,0,1,1,
  864. 1,1,0,1,1,1,0,1,
  865. 1,1,0,0,1,1,1,1,
  866. 0,0,0,0,0,0,0,1,
  868. 1,1,0,0,1,1,0,0,
  869. 0,0,0,0,0,0,0,0,
  870. 0,0,0,0,0,0,0,0,
  871. 0,0,0,0,0,0,0,0,
  873. 1,1,0,0,1,1,0,0,
  874. 1,1,0,1,1,1,0,1,
  875. 0,0,0,0,0,0,0,0,
  876. 0,0,0,0,0,0,0,0,
  878. 0,0,1,1,0,0,1,1,
  879. 1,1,0,1,1,1,0,1,
  880. 1,1,0,0,1,1,1,1,
  881. 0,0,0,0,0,0,0,1,
  883. 0,0,1,1,0,0,1,1,
  884. 1,1,0,1,1,1,0,1,
  885. 1,1,0,0,1,1,1,1,
  886. 0,0,0,0,0,0,0,0,
  888. 1,1,0,0,1,1,0,0,
  889. 0,0,0,0,0,0,0,0,
  890. 1,1,0,0,1,1,1,1,
  891. 0,0,0,0,0,0,0,0,
  893. 1,1,0,0,1,1,0,0,
  894. 1,1,0,1,1,1,0,0,
  895. 1,1,0,0,1,1,1,0,
  896. 1,1,0,0,1,0,0,0
  897.   };
  899. if( NumColors!=256){
  900.      MessageBox(hWnd,"Must be a mono bitmap with grayscale palette!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  901.         return FALSE;
  902.     }
  903. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  904. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  905.     {
  906.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  907.         return FALSE;
  908.     }
  909.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  910. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  911. //copy image data
  912. memcpy(lpTempImgData,lpImgData,BufSize);
  914. Finished=FALSE;
  915.     while(!Finished){
  916.      Finished=TRUE;
  917. for (y=1;y<bi.biHeight-1;y++){ 
  918. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  919. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  920. x=1; 
  921. while(x<bi.biWidth-1){
  922. if(*(lpPtr+x)==0){
  923. w=(unsigned char)*(lpPtr+x-1);
  924. e=(unsigned char)*(lpPtr+x+1);
  925. if( (w==255)|| (e==255)){
  926. nw=(unsigned char)*(lpPtr+x+LineBytes-1);
  927. n=(unsigned char)*(lpPtr+x+LineBytes);
  928. ne=(unsigned char)*(lpPtr+x+LineBytes+1);
  929. sw=(unsigned char)*(lpPtr+x-LineBytes-1);
  930. s=(unsigned char)*(lpPtr+x-LineBytes);
  931. se=(unsigned char)*(lpPtr+x-LineBytes+1);
  932. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  933. if(erasetable[num]==1){
  934. *(lpPtr+x)=(BYTE)255;
  935. *(lpTempPtr+x)=(BYTE)255;
  936. Finished=FALSE;
  937. x++;
  938. }
  939. }
  940. }
  941. x++;
  942. }
  943. }
  945. for (x=1;x<bi.biWidth-1;x++){ 
  946. y=1;
  947. while(y<bi.biHeight-1){
  948. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  949. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  950. if(*(lpPtr+x)==0){
  951. n=(unsigned char)*(lpPtr+x+LineBytes);
  952. s=(unsigned char)*(lpPtr+x-LineBytes);
  953. if( (n==255)|| (s==255)){
  954. nw=(unsigned char)*(lpPtr+x+LineBytes-1);
  955. ne=(unsigned char)*(lpPtr+x+LineBytes+1);
  956. w=(unsigned char)*(lpPtr+x-1);
  957. e=(unsigned char)*(lpPtr+x+1);
  958. sw=(unsigned char)*(lpPtr+x-LineBytes-1);
  959. se=(unsigned char)*(lpPtr+x-LineBytes+1);
  960. num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128;
  961. if(erasetable[num]==1){
  962. *(lpPtr+x)=(BYTE)255;
  963. *(lpTempPtr+x)=(BYTE)255;
  964. Finished=FALSE;
  965. y++;
  966. }
  967. }
  968. }
  969. y++;
  970. }
  971. } 
  972. }
  974.     if(hBitmap!=NULL)
  975.     DeleteObject(hBitmap);
  976. hDc=GetDC(hWnd);
  977. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  978. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  979.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  981. hf=_lcreat("c:\thinning.bmp",0);
  982. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  983. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  984. _lclose(hf);
  986.   ReleaseDC(hWnd,hDc);
  987. LocalUnlock(hTempImgData);
  988. LocalFree(hTempImgData);
  989. GlobalUnlock(hImgData);
  990. return TRUE;
  991. }