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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
colorope.c
资源名称：VC++_image_Code.zip　[点击查看]
上传用户：s6549606
上传日期：2015-11-11
资源大小：12002k
文件大小：44k
源码类别：

图形图像处理

开发平台：

Visual C++

colorope.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:colorope.c
  3. //Purpose: histogram and color 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. //macro definition
  14. #define WIDTHBYTES(i)    ((i+31)/32*4)
  15. //function declaration
  16. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  17. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  18. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName);
  19. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam );
  20. BOOL Histogram(HWND hWnd);
  21. long FAR PASCAL PopupWndProc (HWND,UINT,WPARAM,LPARAM);
  22. BOOL ColortoGrayScale(HWND hWnd);
  23. BOOL Trueto256(HWND hWnd);
  24. BOOL Invert(HWND hWnd);
  25. BOOL ContrastStretch(HWND hWnd);
  26. BOOL Cliping(HWND hWnd);
  27. BOOL Thresholding(HWND hWnd);
  28. BOOL Slice(HWND hWnd,BOOL WithBack);
  29. BOOL HistogramEqua(HWND hWnd);
  30. //global variable declaration
  31. BITMAPFILEHEADER   bf;
  32. BITMAPINFOHEADER   bi;
  33. HPALETTE           hPalette=NULL;
  34. HBITMAP            hBitmap=NULL;
  35. HGLOBAL            hImgData=NULL;
  36. DWORD              NumColors;
  37. DWORD              LineBytes;
  38. HINSTANCE          ghInst;
  39. DWORD              ImgWidth=0 , ImgHeight=0;
  40. int GrayTable[256];
  41. int MaxGrayNum;
  42. int MinGrayNum;
  43. int FirstPoint=0, SecondPoint=255;
  44. float StretchRatio=2.0f;
  45. int EquaScale;
  46. ///////////////////////////////////////////////////////////
  47. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  48.     LPSTR lpszCmdLine, int nCmdShow)
  49. {
  50. MSG       msg;
  51. WNDCLASS  wndclass;
  52. HWND      hWnd;
  54. ghInst=hInstance;
  55. if ( ! hPrevInstance ){
  56. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  57. wndclass.lpfnWndProc = MainWndProc;
  58. wndclass.cbClsExtra = 0;
  59. wndclass.cbWndExtra = 0;
  60. wndclass.hInstance = hInstance;
  61. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  62. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  63. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  64. wndclass.lpszMenuName =  "BMPMENU";
  65. wndclass.lpszClassName = "phoenix ip system";
  66.     }
  68.     if ( ! RegisterClass (&wndclass) )
  69.     return FALSE;
  71. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  72.     wndclass.lpfnWndProc = PopupWndProc;
  73.     wndclass.cbClsExtra = 0;
  74.     wndclass.cbWndExtra = 0;
  75.     wndclass.hInstance = ghInst;
  76.     wndclass.hIcon = NULL;
  77.     wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  78.     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  79.     wndclass.lpszMenuName =  NULL;
  80.     wndclass.lpszClassName = "PopupWindowClass";
  82.     if ( ! RegisterClass (&wndclass) )
  83. return FALSE;
  84.  
  85. hWnd = CreateWindow ("phoenix ip system","Color Operation",
  86.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  87.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  88.  hInstance, NULL);
  89. if (!hWnd)
  90. return FALSE;
  91. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  92. UpdateWindow (hWnd);
  94. while ( GetMessage (&msg, NULL, 0, 0) ){
  95. TranslateMessage (&msg);
  96. DispatchMessage (&msg);
  97.     }
  98. return msg.wParam;
  99. }
  100. ////////////////////////////////////////////////////////////////
  101. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  102. {
  103.     static  HDC    hDC,hMemDC;
  104.     PAINTSTRUCT    ps;
  106.     switch (message){
  107.     case WM_PAINT:
  108. {         
  109. hDC = BeginPaint(hWnd, &ps);
  110. if (hBitmap)
  111. { 
  112. hMemDC = CreateCompatibleDC(hDC);
  113. if (hPalette)
  114. {           
  115. SelectPalette (hDC, hPalette, FALSE); 
  116. SelectPalette (hMemDC, hPalette, FALSE);
  117. RealizePalette (hDC);
  118. }   
  119. SelectObject(hMemDC, hBitmap); 
  120. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  121. DeleteDC(hMemDC);
  122. }
  123. EndPaint(hWnd, &ps);
  124. break;
  125. }
  126. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  127.         if(hBitmap!=NULL)
  128.         DeleteObject(hBitmap);
  129.     
  130. if(hPalette!=NULL)                     
  131.         DeleteObject(hPalette);
  133. if(hImgData!=NULL){
  134. GlobalUnlock(hImgData);
  135. GlobalFree(hImgData);
  136. }         
  137.     PostQuitMessage (0);
  138.     return 0;
  139. case WM_COMMAND:
  140.     switch (wParam){
  141.     case IDM_LOADBMP: 
  142. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  143.         if(hBitmap!=NULL){     
  144. DeleteObject(hBitmap);
  145.             hBitmap=NULL;
  146.         }
  147.         if(hPalette!=NULL){                     
  148. DeleteObject(hPalette);
  149.             hPalette=NULL;
  150.         }
  151. if(hImgData!=NULL){
  152. GlobalUnlock(hImgData);
  153. GlobalFree(hImgData);  
  154. hImgData=NULL;
  155. }         
  156. if(LoadBmpFile(hWnd,"c:\test.bmp")) //成功，则重画窗口
  157.                 InvalidateRect(hWnd,NULL,TRUE);
  158.         break;
  159. case IDM_HISTOGRAM:
  160. if(hImgData!=NULL){
  161. if(Histogram(hWnd))
  162. InvalidateRect(hWnd,NULL,TRUE);
  163. }
  164. else
  165. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  166. break;
  167. case IDM_TRUE256:
  168. if(hImgData!=NULL){
  169. if(Trueto256(hWnd))
  170. InvalidateRect(hWnd,NULL,TRUE);
  171. }
  172. else
  173. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  174. break;
  175. case IDM_CLRGRAY:
  176. if(hImgData!=NULL){
  177. if(ColortoGrayScale(hWnd))
  178. InvalidateRect(hWnd,NULL,TRUE);
  179. }
  180. else
  181. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  182. break;
  183. case IDM_INVERT:
  184. if(hImgData!=NULL){
  185. if(Invert(hWnd))
  186. InvalidateRect(hWnd,NULL,TRUE);
  187. }
  188. else
  189. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  190. break;
  191. case IDM_CONTSTRETCH:
  192. if(hImgData!=NULL){
  193. if (ContrastStretch(hWnd))
  194. InvalidateRect(hWnd,NULL,TRUE);
  195. }
  196. else
  197. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  198. break;
  199. case IDM_CLIPING:
  200. if(hImgData!=NULL){
  201. if(Cliping(hWnd))
  202. InvalidateRect(hWnd,NULL,TRUE);
  203. }
  204. else
  205. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  206. break;
  207. case IDM_THRESHOLD:
  208. if(hImgData!=NULL){
  209. if(Thresholding(hWnd))
  210. InvalidateRect(hWnd,NULL,TRUE);
  211. }
  212. else
  213. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  214. break;
  215. case IDM_SLICEWITHOUTBACK:
  216. if(hImgData!=NULL){
  217. if(Slice(hWnd,FALSE))
  218. InvalidateRect(hWnd,NULL,TRUE);
  219. }
  220. else
  221. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  222. break;
  223. case IDM_SLICEWITHBACK:
  224. if(hImgData!=NULL){
  225. if(Slice(hWnd,TRUE))
  226. InvalidateRect(hWnd,NULL,TRUE);
  227. }
  228. else
  229. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  230. break;
  231. case IDM_HISTOGRAMEQUA:
  232. if(hImgData!=NULL){
  233. if(HistogramEqua(hWnd))
  234. InvalidateRect(hWnd,NULL,TRUE);
  235. }
  236. else
  237. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  238. break;
  239. case IDM_EXIT:
  240.         SendMessage(hWnd,WM_DESTROY,0,0L);
  241.         break;
  242.     }
  243. break;                
  244.     }
  245.     return DefWindowProc (hWnd, message, wParam, lParam);
  246. }
  247. ////////////////////////////////////////////////////////////////
  248. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName)
  249. {   
  250.     HFILE              hf;
  251.     LPBITMAPINFOHEADER lpImgData;
  252.     LOGPALETTE         *pPal;
  253.     LPRGBQUAD          lpRGB;
  254.     HPALETTE           hPrevPalette; 
  255.     HDC                hDc;
  256. HLOCAL             hPal;
  257. DWORD         ImgSize;
  258. DWORD              i;
  260.     if((hf=_lopen(BmpFileName,OF_READ))==HFILE_ERROR){
  261.         MessageBox(hWnd,"File c:\test.bmp not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  262.         return FALSE;
  263. }
  264. _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  265. _lread(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER));
  266. ImgWidth=bi.biWidth;
  267. ImgHeight=bi.biHeight;
  268. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  269. ImgSize=(DWORD)LineBytes*bi.biHeight;
  270.     if(bi.biClrUsed!=0)
  271. NumColors=(DWORD)bi.biClrUsed;
  272. else
  273.         switch(bi.biBitCount){
  274.         case 1:
  275.              NumColors=2;
  276.              break;
  277.          case 4:
  278.              NumColors=16;
  279.              break;
  280.          case 8:
  281.              NumColors=256;
  282.              break;
  283.          case 24:
  284.              NumColors=0;
  285.              break;
  286.               default:
  287.                   MessageBox(hWnd,"Invalid color numbers!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  288.                   _lclose(hf);
  289.                   return FALSE; 
  290.         }
  291. if(bf.bfOffBits!=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  292. +sizeof(BITMAPINFOHEADER)))
  293. {
  294.      MessageBox(hWnd,"Invalid color numbers!","Error Message" ,MB_OK|
  295.                MB_ICONEXCLAMATION);
  296. _lclose(hf);
  297. return FALSE; 
  298. }
  299. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  300. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  301.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  302. {
  303.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  304.                    MB_ICONEXCLAMATION);
  305.     _lclose(hf);
  306. return FALSE;
  307. }
  308.   
  309. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  310.     _llseek(hf,sizeof(BITMAPFILEHEADER),FILE_BEGIN);
  311. _hread(hf,(char *)lpImgData,(long)sizeof(BITMAPINFOHEADER)
  312.            +(long)NumColors*sizeof(RGBQUAD)+ImgSize);
  313. _lclose(hf);
  314.     if(NumColors!=0)
  315. {                    
  316.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  317.     pPal =(LOGPALETTE *)LocalLock(hPal);
  318.     pPal->palNumEntries =(WORD) NumColors;
  319. pPal->palVersion    = 0x300;
  320.     lpRGB = (LPRGBQUAD)((LPSTR)lpImgData + (DWORD)sizeof(BITMAPINFOHEADER));
  321. for (i = 0; i < NumColors; i++) {
  322.       pPal->palPalEntry[i].peRed=lpRGB->rgbRed;
  323. pPal->palPalEntry[i].peGreen=lpRGB->rgbGreen;
  324. pPal->palPalEntry[i].peBlue=lpRGB->rgbBlue;
  325. pPal->palPalEntry[i].peFlags=(BYTE)0;
  326. lpRGB++;
  327. }
  328. hPalette=CreatePalette(pPal);
  329. LocalUnlock(hPal);
  330. LocalFree(hPal);
  331. }
  332. hDc=GetDC(hWnd);
  333. if(hPalette){
  334.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  335. RealizePalette(hDc);
  336. }
  337. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  338. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  339.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  340. if(hPalette && hPrevPalette){
  341. SelectPalette(hDc,hPrevPalette,FALSE);
  342. RealizePalette(hDc);
  343. }
  344.  
  345. ReleaseDC(hWnd,hDc);
  346. GlobalUnlock(hImgData);
  347. return TRUE; 
  348. }
  349. ////////////////////////////////////////////////////////////////
  350. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam )
  351. { 
  352. char str[80];
  354.     switch  ( message ){
  355.     case WM_INITDIALOG:    
  356.       SetDlgItemText(hDlg,ID_FIRSTPOINT,"0");
  357.       SetDlgItemText(hDlg,ID_SECONDPOINT,"0");
  358.       SetDlgItemText(hDlg,ID_STRETCHRATIO,"2.0");
  359.       SetDlgItemText(hDlg,ID_EQUASCALE,"128");
  360.      return TRUE;
  361.     case WM_COMMAND:    
  362.      if ( wParam == IDOK || wParam == IDCANCEL )
  363.         {
  364.          GetDlgItemText(hDlg,ID_FIRSTPOINT,str,80);
  365. FirstPoint=atoi(str);
  366.          GetDlgItemText(hDlg,ID_SECONDPOINT,str,80);
  367. SecondPoint=atoi(str);
  368.          GetDlgItemText(hDlg,ID_STRETCHRATIO,str,80);
  369. StretchRatio=(float)atof(str);
  370.          GetDlgItemText(hDlg,ID_EQUASCALE,str,80);
  371. EquaScale=atoi(str);
  372.             EndDialog ( hDlg, TRUE );
  373.             return  TRUE;
  374.         }
  375.         break;
  376.     }
  377. return FALSE;      
  378. }
  379. ////////////////////////////////////////////////////////////////
  380. BOOL ColortoGrayScale(HWND hWnd)
  381. {
  382. DWORD              SrcBufSize,DstBufSize,DstLineBytes;
  383.     LPBITMAPINFOHEADER lpImgData;
  384. LPSTR              lpPtr;
  385. HLOCAL             hTempImgData;
  386. LPBITMAPINFOHEADER lpTempImgData;
  387. LPSTR              lpTempPtr;
  388. HDC                hDc;
  389. HFILE              hf;
  390. LONG               x,y;
  391. BITMAPFILEHEADER   DstBf;
  392. BITMAPINFOHEADER   DstBi;
  393.     LOGPALETTE         *pPal;
  394.     HPALETTE           hPrevPalette; 
  395. HLOCAL             hPal;
  396. DWORD    NewNumColors;
  397. WORD    NewBitCount;
  398. float              Y;
  399. DWORD              i;
  400. unsigned char      Red,Green,Blue,Gray;
  402. NewNumColors=NumColors;
  403. NewBitCount=bi.biBitCount;
  404. if(NumColors==0) //true color
  405. {
  406. NewNumColors=256;
  407. NewBitCount=8;
  408. }
  410. DstLineBytes=(DWORD)WIDTHBYTES(bi.biWidth*NewBitCount);
  411. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NewNumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*bi.biHeight);
  412. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  413. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  414. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  415. DstBf.bfOffBits=(DWORD)(NewNumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  416. +sizeof(BITMAPINFOHEADER));
  417. DstBi.biClrUsed=0;
  418. DstBi.biBitCount=NewBitCount;
  420. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  422. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  423.     {
  424.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  425.         return FALSE;
  426.     }
  428.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  429. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  431. //copy image data
  432. memcpy(lpTempImgData,lpImgData,DstBufSize);
  433. //overwrite bitmapinfoheader with the new one
  434. memcpy(lpTempImgData,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  436. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  437. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  439.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NewNumColors* sizeof(PALETTEENTRY));
  440.     pPal =(LOGPALETTE *)LocalLock(hPal);
  441.     pPal->palNumEntries =(WORD) NewNumColors;
  442. pPal->palVersion    = 0x300;
  444. if(NumColors==0) //true color
  445. for (i = 0; i < 256; i++) {
  446.       pPal->palPalEntry[i].peRed=(BYTE)i;
  447. pPal->palPalEntry[i].peGreen=(BYTE)i;
  448. pPal->palPalEntry[i].peBlue=(BYTE)i;
  449. pPal->palPalEntry[i].peFlags=(BYTE)0;
  450. *(lpTempPtr++)=(unsigned char)i;
  451. *(lpTempPtr++)=(unsigned char)i;
  452. *(lpTempPtr++)=(unsigned char)i;
  453. *(lpTempPtr++)=0;
  454. }
  455. else 
  456. for (i = 0; i < NewNumColors; i++) {
  457. Blue=(unsigned char )(*lpPtr++);
  458. Green=(unsigned char )(*lpPtr++);
  459. Red=(unsigned char )(*lpPtr++);
  460. Y=(float)(Red*0.299+Green*0.587+Blue*0.114);
  461. Gray=(BYTE)Y;
  462. lpPtr++;
  463.       pPal->palPalEntry[i].peRed=Gray;
  464. pPal->palPalEntry[i].peGreen=Gray;
  465. pPal->palPalEntry[i].peBlue=Gray;
  466. pPal->palPalEntry[i].peFlags=0;
  467. *(lpTempPtr++)=(unsigned char)Gray;
  468. *(lpTempPtr++)=(unsigned char)Gray;
  469. *(lpTempPtr++)=(unsigned char)Gray;
  470. *(lpTempPtr++)=0;
  471. }
  473. if(hPalette!=NULL)                     
  474.         DeleteObject(hPalette);
  476. hPalette=CreatePalette(pPal);
  477. LocalUnlock(hPal);
  478. LocalFree(hPal);
  480. hDc=GetDC(hWnd);
  481. if(hPalette){
  482.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  483. RealizePalette(hDc);
  484. }
  486. if(NumColors==0)
  487. for(y=0;y<bi.biHeight;y++){
  488. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  489. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y*DstLineBytes);
  490. for(x=0;x<bi.biWidth;x++){
  491. Blue=(unsigned char )(*lpPtr++);
  492. Green=(unsigned char )(*lpPtr++);
  493. Red=(unsigned char )(*lpPtr++);
  494. Y=(float)(Red*0.299+Green*0.587+Blue*0.114);
  495. Gray=(BYTE)Y;
  496. *(lpTempPtr++)=(unsigned char)Gray;
  497. }
  498. }
  500.     if(hBitmap!=NULL)
  501.     DeleteObject(hBitmap);
  503. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  504. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NewNumColors*sizeof(RGBQUAD),
  505.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  507. if(hPalette && hPrevPalette){
  508. SelectPalette(hDc,hPrevPalette,FALSE);
  509. RealizePalette(hDc);
  510. }
  512.     hf=_lcreat("c:\gray.bmp",0);
  513. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  514. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  515. _lclose(hf);
  517.   ReleaseDC(hWnd,hDc);
  518. LocalUnlock(hTempImgData);
  519. LocalFree(hTempImgData);
  520. GlobalUnlock(hImgData);
  521. return TRUE;
  522. }
  523. ////////////////////////////////////////////////////////////////
  524. BOOL Invert(HWND hWnd)
  525. {
  526. DWORD              BufSize;
  527.     LPBITMAPINFOHEADER lpImgData;
  528. LPSTR              lpPtr;
  529. HLOCAL             hTempImgData;
  530. LPBITMAPINFOHEADER lpTempImgData;
  531. LPSTR              lpTempPtr;
  532. HDC                hDc;
  533. HFILE              hf;
  534. LONG               x,y;
  535.     LOGPALETTE         *pPal;
  536.     HPALETTE           hPrevPalette=NULL; 
  537. HLOCAL             hPal;
  538. DWORD              i;
  539. unsigned char      Red,Green,Blue;
  541. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  543. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  544.     {
  545.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  546.         return FALSE;
  547.     }
  549.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  550. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  552. //copy image data
  553. memcpy(lpTempImgData,lpImgData,BufSize);
  555. hDc=GetDC(hWnd);
  556. if(NumColors!=0){
  557. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  558. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  559.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  560. pPal =(LOGPALETTE *)LocalLock(hPal);
  561. pPal->palNumEntries =(WORD) NumColors;
  562. pPal->palVersion    = 0x300;
  563. for (i = 0; i < NumColors; i++) {
  564. Blue=(unsigned char )(*lpPtr++);
  565. Green=(unsigned char )(*lpPtr++);
  566. Red=(unsigned char )(*lpPtr++);
  567. lpPtr++;
  568.       pPal->palPalEntry[i].peRed=(BYTE)(255-Red);
  569. pPal->palPalEntry[i].peGreen=(BYTE)(255-Green);
  570. pPal->palPalEntry[i].peBlue=(BYTE)(255-Blue);
  571. pPal->palPalEntry[i].peFlags=0;
  572. *(lpTempPtr++)=(unsigned char)(255-Blue);
  573. *(lpTempPtr++)=(unsigned char)(255-Green);
  574. *(lpTempPtr++)=(unsigned char)(255-Red);
  575. *(lpTempPtr++)=0;
  576. }
  578. if(hPalette!=NULL)                     
  579. DeleteObject(hPalette);
  580. hPalette=CreatePalette(pPal);
  581. LocalUnlock(hPal);
  582. LocalFree(hPal);
  583. if(hPalette){
  584. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  585. RealizePalette(hDc);
  586. }
  587. }
  588. else{
  589. for(y=0;y<bi.biHeight;y++){
  590. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  591. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  592. for(x=0;x<bi.biWidth;x++){
  593. Blue=(unsigned char )(*lpPtr++);
  594. Green=(unsigned char )(*lpPtr++);
  595. Red=(unsigned char )(*lpPtr++);
  596. *(lpTempPtr++)=(unsigned char)(255-Blue);
  597. *(lpTempPtr++)=(unsigned char)(255-Green);
  598. *(lpTempPtr++)=(unsigned char)(255-Red);
  599. }
  600. }
  601. }
  603.     if(hBitmap!=NULL)
  604.     DeleteObject(hBitmap);
  606. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  607. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  608.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  610. if(hPalette && hPrevPalette){
  611. SelectPalette(hDc,hPrevPalette,FALSE);
  612. RealizePalette(hDc);
  613. }
  615.     hf=_lcreat("c:\invert.bmp",0);
  616. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  617. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  618. _lclose(hf);
  620.   ReleaseDC(hWnd,hDc);
  621. LocalUnlock(hTempImgData);
  622. LocalFree(hTempImgData);
  623. GlobalUnlock(hImgData);
  624. return TRUE;
  625. }
  626. ////////////////////////////////////////////////////////////////
  627. BOOL Histogram(HWND hWnd)
  628. {
  629. DWORD              OffBits,BufSize;
  630.     LPBITMAPINFOHEADER lpImgData;
  631. LPSTR              lpPtr;
  632. int    x,y;
  633. int                grayindex;
  634. HWND    hPopupWnd;
  635. int                temp;
  637. for(grayindex=0;grayindex<256;grayindex++)
  638. GrayTable[grayindex]=0;
  640. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  641. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  642.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
  644. for(y=0;y<bi.biHeight;y++){
  645. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  646. for(x=0;x<bi.biWidth;x++){
  647. grayindex=(unsigned char)*(lpPtr++);
  648. GrayTable[grayindex]++;
  649. }
  650. }
  652. MaxGrayNum=0;
  653. MinGrayNum=65535;
  655. for(grayindex=0;grayindex<256;grayindex++){
  656. temp=GrayTable[grayindex];
  657. if(temp>MaxGrayNum)
  658. MaxGrayNum=temp;
  659. if( (temp<MinGrayNum) && (temp>0) )
  660. MinGrayNum=temp;
  661. }
  663. GlobalUnlock(hImgData);
  664.     hPopupWnd = CreateWindow (
  665.   "PopupWindowClass",
  666.   "Histogram Statistic Window",
  667.        WS_OVERLAPPEDWINDOW,
  668.        50,80,550,350,
  669.        hWnd,NULL,ghInst,NULL
  670.        );
  671. if (hPopupWnd){
  672. ShowWindow (hPopupWnd, SW_SHOW);
  673.     UpdateWindow (hPopupWnd);
  674.     }
  675. return TRUE;
  676. }
  677. ////////////////////////////////////////////////////////////////
  678. long FAR PASCAL PopupWndProc (HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
  679. {
  680. HDC  hdc;
  681. PAINTSTRUCT  ps;   
  682. DWORD   i;
  683. int             xstart;   
  684. static LOGPEN   blp={PS_SOLID,1,1,RGB(0,0,255)};
  685. HPEN            bhp;
  686. float           a,b,temp;
  687. char            str[10];
  689. a=(float)(265.0 /( MaxGrayNum - MinGrayNum) );
  690. b=(float) (270.0-a* MaxGrayNum);
  691.     switch (message)
  692.      {
  693.     case WM_PAINT:
  694.         hdc = BeginPaint(hWnd, &ps);
  695.     bhp = CreatePenIndirect(&blp);
  696. SelectObject(hdc,bhp);
  697.         MoveToEx(hdc,2,270,NULL);
  698.         LineTo(hdc,518,270);
  699.         xstart=2;
  700.         for(i=0;i<256;i++){
  701.          MoveToEx(hdc,xstart,270,NULL);
  702. if (GrayTable[i]!=0) 
  703. temp=(float)(a*GrayTable[i]+b);
  704. else temp=0.0f;
  705.          LineTo(hdc,xstart,270-(int)temp);
  706. if (i%16 ==0){
  707.          MoveToEx(hdc,xstart,270,NULL);
  708.          LineTo(hdc,xstart,280);
  709. _itoa(i,str,10);
  710. TextOut(hdc,xstart,285,str,strlen(str));
  711. }
  712.          xstart+=2;
  713.         }
  714.     MoveToEx(hdc,xstart,270,NULL);
  715.     LineTo(hdc,xstart,280);
  716. TextOut(hdc,xstart,285,"256",strlen("256"));
  717.         EndPaint(hWnd,&ps);
  718.         DeleteObject(bhp);
  719.         break;
  720.     default:
  721.      break;
  722.      }
  723.     return DefWindowProc (hWnd, message, wParam, lParam);
  724. }
  725. ////////////////////////////////////////////////////////////////
  726. BOOL Trueto256(HWND hWnd)
  727. {
  728. DWORD              SrcBufSize,OffBits,DstBufSize,DstLineBytes;
  729.     LPBITMAPINFOHEADER lpImgData;
  730. LPSTR              lpPtr;
  731. HLOCAL             hTempImgData;
  732. LPBITMAPINFOHEADER lpTempImgData;
  733. LPSTR              lpTempPtr;
  734. HDC                hDc;
  735. HFILE              hf;
  736. LONG               x,y;
  737. BITMAPFILEHEADER   DstBf;
  738. BITMAPINFOHEADER   DstBi;
  739.     LOGPALETTE         *pPal;
  740.     HPALETTE           hPrevPalette; 
  741. HLOCAL             hPal;
  742. WORD               i,j;
  743. int    Red,Green,Blue,ClrIndex;
  744. DWORD              ColorHits[4096];
  745. WORD               ColorIndex[4096];
  746. DWORD              PalCounts,temp;
  747. long    ColorError1,ColorError2;
  749. if(NumColors!=0){
  750.      MessageBox(hWnd,"Must be a true color bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  751.         return FALSE;
  752.     }
  754. DstLineBytes=(DWORD)WIDTHBYTES(bi.biWidth*8);
  755. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)+(DWORD)DstLineBytes*bi.biHeight);
  756. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  757. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  758. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  759. DstBf.bfOffBits=(DWORD)(256*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  760. +sizeof(BITMAPINFOHEADER));
  761. DstBi.biClrUsed=0;
  762. DstBi.biBitCount=8;
  764. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  765. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  767. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  768.     {
  769.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  770.         return FALSE;
  771.     }
  773.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  774. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  776. //copy image data
  777. memcpy(lpTempImgData,lpImgData,OffBits);
  778. //overwrite bitmapinfoheader with the new one
  779. memcpy(lpTempImgData,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  781. memset(ColorHits,0,4096*sizeof(DWORD));
  782. memset(ColorIndex,0,4096*sizeof(WORD));
  783. for(y=0;y<bi.biHeight;y++){
  784. lpPtr=(unsigned char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  785. for(x=0;x<bi.biWidth;x++){
  786. Blue=(int)(*(lpPtr++) & 0xf0);
  787. Green=(int)(*(lpPtr++) & 0xf0);
  788. Red=(int)(*(lpPtr++) & 0xf0);
  789. ClrIndex=(Blue<<4) + Green +(Red >>4);
  790. ColorHits[ClrIndex]++;
  791. }
  792. }
  794. PalCounts=0;
  795. //pack the color table
  796.     for (ClrIndex = 0; ClrIndex < 4096; ClrIndex++)
  797.     {
  798. if(ColorHits[ClrIndex]!=0){
  799. ColorHits[PalCounts]=ColorHits[ClrIndex];
  800. ColorIndex[PalCounts]=ClrIndex;
  801. PalCounts++;
  802. }
  803. }
  804.     //sort the color table downsize
  805.     for (i = 0; i < PalCounts-1; i++)
  806. for (j = i + 1; j < PalCounts; j++){
  807. if (ColorHits[j] > ColorHits[i]){
  808. temp = ColorHits[i];
  809. ColorHits[i] = ColorHits[j];
  810. ColorHits[j] = temp;  
  811.             temp = ColorIndex[i];
  812.         ColorIndex[i] = ColorIndex[j];
  813.     ColorIndex[j] = (WORD)temp;
  814. }
  815. }
  817.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + 256* sizeof(PALETTEENTRY));
  818.     pPal =(LOGPALETTE *)LocalLock(hPal);
  819.     pPal->palNumEntries =(WORD) 256;
  820. pPal->palVersion    = 0x300;
  822. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  823. for (i = 0; i < 256; i++) {
  824.     pPal->palPalEntry[i].peRed=(BYTE)((ColorIndex[i] & 0x00f) << 4);
  825. pPal->palPalEntry[i].peGreen=(BYTE)((ColorIndex[i] & 0x0f0));
  826. pPal->palPalEntry[i].peBlue=(BYTE)((ColorIndex[i] & 0xf00) >> 4);
  827. pPal->palPalEntry[i].peFlags=(BYTE)0;
  828. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0xf00) >> 4);
  829. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0x0f0));
  830. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0x00f) << 4);
  831. *(lpTempPtr++)=0;
  832. ColorHits[i]=i;
  833. }
  835. //其余的颜色依据最小平方差近似为前256中最接近的一种
  836.     if (PalCounts > 256){
  837. for (i = 256; i < PalCounts; i++){
  838. ColorError1=1000000000;
  839. Blue = (long)((ColorIndex[i] & 0xf00) >> 4);
  840. Green = (long)((ColorIndex[i] & 0x0f0));
  841. Red = (long)((ColorIndex[i] & 0x00f) << 4);
  842. ClrIndex = 0;
  843. for (j = 0; j < 256; j++){
  844. ColorError2=(long)(Blue-pPal->palPalEntry[j].peBlue)*(Blue-pPal->palPalEntry[j].peBlue)+ 
  845.                         (long)(Green-pPal->palPalEntry[j].peGreen)*(Green-pPal->palPalEntry[j].peGreen)+
  846.                         (long)(Red-pPal->palPalEntry[j].peRed)*(Red-pPal->palPalEntry[j].peRed); 
  847.                 if (ColorError2 < ColorError1){
  848. ColorError1 = ColorError2;
  849. ClrIndex = j;
  850.                 }
  851. }                        
  852. ColorHits[i] = ClrIndex;
  853. }
  854. }                
  856. if(hPalette!=NULL)                     
  857.         DeleteObject(hPalette);
  859. //create new logic palette
  860. hPalette=CreatePalette(pPal);
  861. LocalUnlock(hPal);
  862. LocalFree(hPal);
  864. hDc=GetDC(hWnd);
  865. if(hPalette){
  866.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  867. RealizePalette(hDc);
  868. }
  870. for(y=0;y<bi.biHeight;y++){
  871. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  872. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y*DstLineBytes);
  873. for(x=0;x<bi.biWidth;x++){
  874. Blue=(int)(*(lpPtr++) & 0xf0);
  875. Green=(int)(*(lpPtr++) & 0xf0);
  876. Red=(int)(*(lpPtr++) & 0xf0);
  877. ClrIndex=(Blue<<4) + Green +(Red >>4);
  878.             for (i = 0; i < PalCounts;i++)
  879. if (ClrIndex == ColorIndex[i]){
  880. *(lpTempPtr++)=(unsigned char)ColorHits[i];
  881.                     break;
  882. }
  883. }
  884. }
  886.     if(hBitmap!=NULL)
  887.     DeleteObject(hBitmap);
  889. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  890. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +256*sizeof(RGBQUAD),
  891.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  893. if(hPalette && hPrevPalette){
  894. SelectPalette(hDc,hPrevPalette,FALSE);
  895. RealizePalette(hDc);
  896. }
  898.     hf=_lcreat("c:\256.bmp",0);
  899. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  900. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  901. _lclose(hf);
  903.   ReleaseDC(hWnd,hDc);
  904. LocalUnlock(hTempImgData);
  905. LocalFree(hTempImgData);
  906. GlobalUnlock(hImgData);
  907. return TRUE;
  908. }
  909. ////////////////////////////////////////////////////////////////
  910. BOOL ContrastStretch(HWND hWnd)
  911. {
  912. DLGPROC            dlgInputBox = NULL;
  913. DWORD              BufSize;
  914.     LPBITMAPINFOHEADER lpImgData;
  915. LPSTR              lpPtr;
  916. HLOCAL             hTempImgData;
  917. LPBITMAPINFOHEADER lpTempImgData;
  918. LPSTR              lpTempPtr;
  919. HDC                hDc;
  920. HFILE              hf;
  921.     LOGPALETTE         *pPal;
  922.     HPALETTE           hPrevPalette=NULL; 
  923. HLOCAL             hPal;
  924. DWORD              i;
  925. unsigned char      Gray;
  926. float              a,g1,g2,g;
  928. if( NumColors!=256){
  929.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  930.         return FALSE;
  931.     }
  933. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  934. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  935. FreeProcInstance ( (FARPROC) dlgInputBox );
  937. if( StretchRatio*(SecondPoint-FirstPoint) > 255.0){
  938.      MessageBox(hWnd,"StretchRatio*(SecondPoint-FirstPoint)  can not be larger than 255!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  939.         return FALSE;
  940.     }
  941. if( (SecondPoint-FirstPoint) >=255){
  942.      MessageBox(hWnd,"The area you selected can not be the whole scale!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  943.         return FALSE;
  944.     }
  945. a=(float)((255.0-StretchRatio*(SecondPoint-FirstPoint))/(255.0-(SecondPoint-FirstPoint))); 
  946. g1=a*FirstPoint;
  947. g2=StretchRatio*(SecondPoint-FirstPoint)+g1;
  949. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  951. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  952.     {
  953.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  954.         return FALSE;
  955.     }
  957.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  958. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  960. //copy image data
  961. memcpy(lpTempImgData,lpImgData,BufSize);
  963. hDc=GetDC(hWnd);
  965. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  966. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  967. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  968. pPal =(LOGPALETTE *)LocalLock(hPal);
  969. pPal->palNumEntries =(WORD) NumColors;
  970. pPal->palVersion    = 0x300;
  971. for (i = 0; i < 256; i++) {
  972. Gray=(unsigned char )*lpPtr;
  973. lpPtr+=4;
  974. if(Gray<FirstPoint) g=(float)(a*Gray);
  975. else if (Gray<SecondPoint) g=g1+StretchRatio*(Gray-FirstPoint);
  976. else g=g2+a*(Gray-SecondPoint);
  977.     pPal->palPalEntry[i].peRed=(BYTE)g;
  978. pPal->palPalEntry[i].peGreen=(BYTE)g;
  979. pPal->palPalEntry[i].peBlue=(BYTE)g;
  980. pPal->palPalEntry[i].peFlags=0;
  981. *(lpTempPtr++)=(unsigned char)g;
  982. *(lpTempPtr++)=(unsigned char)g;
  983. *(lpTempPtr++)=(unsigned char)g;
  984. *(lpTempPtr++)=0;
  985. }
  987. if(hPalette!=NULL)                     
  988. DeleteObject(hPalette);
  989. hPalette=CreatePalette(pPal);
  990. LocalUnlock(hPal);
  991. LocalFree(hPal);
  992. if(hPalette){
  993. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  994. RealizePalette(hDc);
  995. }
  997.     if(hBitmap!=NULL)
  998.     DeleteObject(hBitmap);
  1000. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1001. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1002.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1004. if(hPalette && hPrevPalette){
  1005. SelectPalette(hDc,hPrevPalette,FALSE);
  1006. RealizePalette(hDc);
  1007. }
  1009.     hf=_lcreat("c:\stretch.bmp",0);
  1010. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1011. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1012. _lclose(hf);
  1014.   ReleaseDC(hWnd,hDc);
  1015. LocalUnlock(hTempImgData);
  1016. LocalFree(hTempImgData);
  1017. GlobalUnlock(hImgData);
  1018. return TRUE;
  1019. }
  1020. ////////////////////////////////////////////////////////////////
  1021. BOOL Cliping(HWND hWnd)
  1022. {
  1023. DLGPROC            dlgInputBox = NULL;
  1024. DWORD              BufSize;
  1025.     LPBITMAPINFOHEADER lpImgData;
  1026. LPSTR              lpPtr;
  1027. HLOCAL             hTempImgData;
  1028. LPBITMAPINFOHEADER lpTempImgData;
  1029. LPSTR              lpTempPtr;
  1030. HDC                hDc;
  1031. HFILE              hf;
  1032.     LOGPALETTE         *pPal;
  1033.     HPALETTE           hPrevPalette=NULL; 
  1034. HLOCAL             hPal;
  1035. DWORD              i;
  1036. unsigned char      Gray;
  1037. float              a,g;
  1039. if( NumColors!=256){
  1040.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1041.         return FALSE;
  1042.     }
  1044. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  1045. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  1046. FreeProcInstance ( (FARPROC) dlgInputBox );
  1048. if( (SecondPoint-FirstPoint) >255){
  1049.      MessageBox(hWnd,"The area you selected must be within [0-255]!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1050.         return FALSE;
  1051.     }
  1052. a=(float)(255.0/(SecondPoint-FirstPoint)); 
  1054. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1056. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1057.     {
  1058.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1059.         return FALSE;
  1060.     }
  1062.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1063. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1065. //copy image data
  1066. memcpy(lpTempImgData,lpImgData,BufSize);
  1068. hDc=GetDC(hWnd);
  1070. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  1071. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1072. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  1073. pPal =(LOGPALETTE *)LocalLock(hPal);
  1074. pPal->palNumEntries =(WORD) NumColors;
  1075. pPal->palVersion    = 0x300;
  1076. for (i = 0; i < 256; i++) {
  1077. Gray=(unsigned char )*lpPtr;
  1078. lpPtr+=4;
  1079. if(Gray<FirstPoint) g=0.0f;
  1080. else if (Gray<SecondPoint) g=a*(Gray-FirstPoint);
  1081. else g=255.0f;
  1082.     pPal->palPalEntry[i].peRed=(BYTE)g;
  1083. pPal->palPalEntry[i].peGreen=(BYTE)g;
  1084. pPal->palPalEntry[i].peBlue=(BYTE)g;
  1085. pPal->palPalEntry[i].peFlags=0;
  1086. *(lpTempPtr++)=(unsigned char)g;
  1087. *(lpTempPtr++)=(unsigned char)g;
  1088. *(lpTempPtr++)=(unsigned char)g;
  1089. *(lpTempPtr++)=0;
  1090. }
  1092. if(hPalette!=NULL)                     
  1093. DeleteObject(hPalette);
  1094. hPalette=CreatePalette(pPal);
  1095. LocalUnlock(hPal);
  1096. LocalFree(hPal);
  1097. if(hPalette){
  1098. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1099. RealizePalette(hDc);
  1100. }
  1102.     if(hBitmap!=NULL)
  1103.     DeleteObject(hBitmap);
  1105. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1106. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1107.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1109. if(hPalette && hPrevPalette){
  1110. SelectPalette(hDc,hPrevPalette,FALSE);
  1111. RealizePalette(hDc);
  1112. }
  1114.     hf=_lcreat("c:\cliping.bmp",0);
  1115. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1116. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1117. _lclose(hf);
  1119.   ReleaseDC(hWnd,hDc);
  1120. LocalUnlock(hTempImgData);
  1121. LocalFree(hTempImgData);
  1122. GlobalUnlock(hImgData);
  1123. return TRUE;
  1124. }
  1125. ////////////////////////////////////////////////////////////////
  1126. BOOL Thresholding(HWND hWnd)
  1127. {
  1128. DLGPROC            dlgInputBox = NULL;
  1129. DWORD              BufSize;
  1130.     LPBITMAPINFOHEADER lpImgData;
  1131. LPSTR              lpPtr;
  1132. HLOCAL             hTempImgData;
  1133. LPBITMAPINFOHEADER lpTempImgData;
  1134. LPSTR              lpTempPtr;
  1135. HDC                hDc;
  1136. HFILE              hf;
  1137.     LOGPALETTE         *pPal;
  1138.     HPALETTE           hPrevPalette=NULL; 
  1139. HLOCAL             hPal;
  1140. DWORD              i;
  1141. unsigned char      Gray;
  1143. if( NumColors!=256){
  1144.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1145.         return FALSE;
  1146.     }
  1147. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  1148. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  1149. FreeProcInstance ( (FARPROC) dlgInputBox );
  1150. if( FirstPoint >255){
  1151.      MessageBox(hWnd,"The point you selected must be within [0-255]","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1152.         return FALSE;
  1153.     }
  1154. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1155. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1156.     {
  1157.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1158.         return FALSE;
  1159.     }
  1160.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1161. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1162. //copy image data
  1163. memcpy(lpTempImgData,lpImgData,BufSize);
  1165. hDc=GetDC(hWnd);
  1167. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  1168. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1169. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  1170. pPal =(LOGPALETTE *)LocalLock(hPal);
  1171. pPal->palNumEntries =(WORD) NumColors;
  1172. pPal->palVersion    = 0x300;
  1173. for (i = 0; i < 256; i++) {
  1174. Gray=(unsigned char )*lpPtr;
  1175. lpPtr+=4;
  1176. if(Gray<FirstPoint) Gray=0;
  1177. else Gray=255;
  1178.     pPal->palPalEntry[i].peRed=Gray;
  1179. pPal->palPalEntry[i].peGreen=Gray;
  1180. pPal->palPalEntry[i].peBlue=Gray;
  1181. pPal->palPalEntry[i].peFlags=0;
  1182. *(lpTempPtr++)=(unsigned char)Gray;
  1183. *(lpTempPtr++)=(unsigned char)Gray;
  1184. *(lpTempPtr++)=(unsigned char)Gray;
  1185. *(lpTempPtr++)=0;
  1186. }
  1188. if(hPalette!=NULL)                     
  1189. DeleteObject(hPalette);
  1190. hPalette=CreatePalette(pPal);
  1191. LocalUnlock(hPal);
  1192. LocalFree(hPal);
  1193. if(hPalette){
  1194. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1195. RealizePalette(hDc);
  1196. }
  1198.     if(hBitmap!=NULL)
  1199.     DeleteObject(hBitmap);
  1201. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1202. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1203.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1205. if(hPalette && hPrevPalette){
  1206. SelectPalette(hDc,hPrevPalette,FALSE);
  1207. RealizePalette(hDc);
  1208. }
  1210.     hf=_lcreat("c:\threshold.bmp",0);
  1211. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1212. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1213. _lclose(hf);
  1215.   ReleaseDC(hWnd,hDc);
  1216. LocalUnlock(hTempImgData);
  1217. LocalFree(hTempImgData);
  1218. GlobalUnlock(hImgData);
  1219. return TRUE;
  1220. }
  1221. ////////////////////////////////////////////////////////////////
  1222. BOOL Slice(HWND hWnd,BOOL WithBack)
  1223. {
  1224. DLGPROC            dlgInputBox = NULL;
  1225. DWORD              BufSize;
  1226.     LPBITMAPINFOHEADER lpImgData;
  1227. LPSTR              lpPtr;
  1228. HLOCAL             hTempImgData;
  1229. LPBITMAPINFOHEADER lpTempImgData;
  1230. LPSTR              lpTempPtr;
  1231. HDC                hDc;
  1232. HFILE              hf;
  1233.     LOGPALETTE         *pPal;
  1234.     HPALETTE           hPrevPalette=NULL; 
  1235. HLOCAL             hPal;
  1236. DWORD              i;
  1237. unsigned char      Gray;
  1239. if( NumColors!=256){
  1240.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1241.         return FALSE;
  1242.     }
  1243. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  1244. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  1245. FreeProcInstance ( (FARPROC) dlgInputBox );
  1247. if( (SecondPoint-FirstPoint) >255){
  1248.      MessageBox(hWnd,"The area you selected must be within [0-255]!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1249.         return FALSE;
  1250.     }
  1251. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1252. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1253.     {
  1254.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1255.         return FALSE;
  1256.     }
  1257.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1258. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1259. //copy image data
  1260. memcpy(lpTempImgData,lpImgData,BufSize);
  1262. hDc=GetDC(hWnd);
  1263. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  1264. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1265. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  1266. pPal =(LOGPALETTE *)LocalLock(hPal);
  1267. pPal->palNumEntries =(WORD) NumColors;
  1268. pPal->palVersion    = 0x300;
  1269. for (i = 0; i < 256; i++) {
  1270. Gray=(unsigned char )*lpPtr;
  1271. lpPtr+=4;
  1272. if(WithBack){
  1273. if( (Gray>=FirstPoint) && (Gray<=SecondPoint))
  1274. Gray=255;
  1275. }
  1276. else{
  1277. if(Gray<FirstPoint) Gray=0;
  1278. else if (Gray<SecondPoint) Gray=255;
  1279. else Gray=0;
  1280. }
  1281.     pPal->palPalEntry[i].peRed=Gray;
  1282. pPal->palPalEntry[i].peGreen=Gray;
  1283. pPal->palPalEntry[i].peBlue=Gray;
  1284. pPal->palPalEntry[i].peFlags=0;
  1285. *(lpTempPtr++)=(unsigned char)Gray;
  1286. *(lpTempPtr++)=(unsigned char)Gray;
  1287. *(lpTempPtr++)=(unsigned char)Gray;
  1288. *(lpTempPtr++)=0;
  1289. }
  1291. if(hPalette!=NULL)                     
  1292. DeleteObject(hPalette);
  1293. hPalette=CreatePalette(pPal);
  1294. LocalUnlock(hPal);
  1295. LocalFree(hPal);
  1296. if(hPalette){
  1297. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1298. RealizePalette(hDc);
  1299. }
  1301.     if(hBitmap!=NULL)
  1302.     DeleteObject(hBitmap);
  1304. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1305. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1306.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1308. if(hPalette && hPrevPalette){
  1309. SelectPalette(hDc,hPrevPalette,FALSE);
  1310. RealizePalette(hDc);
  1311. }
  1313. if(WithBack)
  1314. hf=_lcreat("c:\sliceb.bmp",0);
  1315. else
  1316. hf=_lcreat("c:\slice.bmp",0);
  1318. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1319. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1320. _lclose(hf);
  1322.   ReleaseDC(hWnd,hDc);
  1323. LocalUnlock(hTempImgData);
  1324. LocalFree(hTempImgData);
  1325. GlobalUnlock(hImgData);
  1326. return TRUE;
  1327. }
  1328. ////////////////////////////////////////////////////////////////
  1329. BOOL HistogramEqua(HWND hWnd)
  1330. {
  1331. DLGPROC            dlgInputBox = NULL;
  1332. DWORD              BufSize,OffBits;
  1333.     LPBITMAPINFOHEADER lpImgData;
  1334. LPSTR              lpPtr;
  1335. HLOCAL             hTempImgData;
  1336. LPBITMAPINFOHEADER lpTempImgData;
  1337. LPSTR              lpTempPtr;
  1338. HDC                hDc;
  1339. HFILE              hf;
  1340. LONG               x,y;
  1341.     LOGPALETTE         *pPal;
  1342.     HPALETTE           hPrevPalette; 
  1343. HLOCAL             hPal;
  1344. WORD               i;
  1345. int      Gray;
  1346. DWORD              GrayHits[256];
  1347. int    GrayIndex[256];
  1348. float              s[256];
  1350. if( NumColors!=256){
  1351.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1352.         return FALSE;
  1353.     }
  1354. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  1355. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  1356. FreeProcInstance ( (FARPROC) dlgInputBox );
  1357. if( EquaScale >=255){
  1358.      MessageBox(hWnd,"The new scale can not be larger than 255","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1359.         return FALSE;
  1360.     }
  1362. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1363. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1365. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1366.     {
  1367.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1368.         return FALSE;
  1369.     }
  1371.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1372. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1374. //copy image data
  1375. memcpy(lpTempImgData,lpImgData,OffBits);
  1377. memset(GrayHits,0,256*sizeof(DWORD));
  1378. memset(GrayIndex,0,256*sizeof(WORD));
  1379. for(y=0;y<bi.biHeight;y++){
  1380. lpPtr=(unsigned char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1381. for(x=0;x<bi.biWidth;x++){
  1382. Gray=(unsigned char )*(lpPtr++);
  1383. GrayHits[Gray]++;
  1384. }
  1385. }
  1387. for(i=0;i<256;i++)
  1388. s[i]=(float)GrayHits[i]/((float)bi.biWidth*(float)bi.biHeight);
  1390. for(i=1;i<256;i++)
  1391. s[i]+=s[i-1];
  1393. for(i=0;i<256;i++)
  1394. GrayIndex[i]=(int)(s[i]*(EquaScale-1));
  1396.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + 256* sizeof(PALETTEENTRY));
  1397.     pPal =(LOGPALETTE *)LocalLock(hPal);
  1398. memset(pPal,0,sizeof(LOGPALETTE) + 256* sizeof(PALETTEENTRY));
  1399.     pPal->palNumEntries =(WORD) 256;
  1400. pPal->palVersion    = 0x300;
  1401. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1402. for (i = 0; i < EquaScale; i++) {
  1403. Gray=(int)(i*255.0/(EquaScale-1));
  1404.     pPal->palPalEntry[i].peRed=(BYTE)Gray;
  1405. pPal->palPalEntry[i].peGreen=(BYTE)Gray;
  1406. pPal->palPalEntry[i].peBlue=(BYTE)Gray;
  1407. pPal->palPalEntry[i].peFlags=(BYTE)0;
  1408. *(lpTempPtr++)=(unsigned char)Gray;
  1409. *(lpTempPtr++)=(unsigned char)Gray;
  1410. *(lpTempPtr++)=(unsigned char)Gray;
  1411. *(lpTempPtr++)=0;
  1412. }
  1413. if(hPalette!=NULL)                     
  1414.         DeleteObject(hPalette);
  1416. //create new logic palette
  1417. hPalette=CreatePalette(pPal);
  1418. LocalUnlock(hPal);
  1419. LocalFree(hPal);
  1421. hDc=GetDC(hWnd);
  1422. if(hPalette){
  1423.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1424. RealizePalette(hDc);
  1425. }
  1427. for(y=0;y<bi.biHeight;y++){
  1428. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1429. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  1430. for(x=0;x<bi.biWidth;x++){
  1431. Gray=(unsigned char )*(lpPtr++);
  1432. Gray=GrayIndex[Gray];
  1433. *(lpTempPtr++)=(unsigned char)Gray;
  1434. }
  1435. }
  1437.     if(hBitmap!=NULL)
  1438.     DeleteObject(hBitmap);
  1440. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1441. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +256*sizeof(RGBQUAD),
  1442.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1444. if(hPalette && hPrevPalette){
  1445. SelectPalette(hDc,hPrevPalette,FALSE);
  1446. RealizePalette(hDc);
  1447. }
  1449.     hf=_lcreat("c:\equa.bmp",0);
  1450. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1451. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1452. _lclose(hf);
  1454.   ReleaseDC(hWnd,hDc);
  1455. LocalUnlock(hTempImgData);
  1456. LocalFree(hTempImgData);
  1457. GlobalUnlock(hImgData);
  1458. return TRUE;
  1459. }