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

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

图形图像处理

开发平台：

Visual C++

Bmp.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:bmp.c
  3. //Purpose: phoenix's image processing system
  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 "jpeg.h"
  11. #include "memory.h"
  12. #include "math.h"
  13. #include "stdio.h"
  14. //define return value of function
  15. #define FUNC_OK 0
  16. #define FUNC_MEMORY_ERROR 1
  17. #define FUNC_FILE_ERROR 2
  18. #define FUNC_FORMAT_ERROR 3
  19. //owner defined stack
  20. typedef struct{
  21.   HGLOBAL hMem;
  22.      POINT *lpMyStack;
  23.   LONG  ElementsNum;
  24.   LONG  ptr;
  25.   }MYSTACK;
  26. //macro definition
  27. #define WIDTHBYTES(i)    ((i+31)/32*4)
  28. #define PI 3.1415926535
  29. #define RADIAN(angle) ((angle)*PI/180.0) //convert angle to radian
  31. //function declaration
  32. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  33. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  34. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName);
  35. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam );
  36. BOOL Translation(HWND hWnd);
  37. BOOL Rotation(HWND hWnd);
  38. BOOL Mirror(HWND hWnd,BOOL XDirection);
  39. BOOL Transpose(HWND hWnd);
  40. BOOL Zoom(HWND hWnd);
  41. BOOL LimbPatternM3(HWND hWnd);
  42. BOOL LimbPatternM4(HWND hWnd);
  43. BOOL Steinberg(HWND hWnd);
  44. BOOL Bmp2Txt(HWND hWnd);
  45. BOOL Histogram(HWND hWnd);
  46. long FAR PASCAL PopupWndProc (HWND,UINT,WPARAM,LPARAM);
  47. BOOL ColortoGrayScale(HWND hWnd);
  48. BOOL Trueto256(HWND hWnd);
  49. BOOL Invert(HWND hWnd);
  50. BOOL TemplateOperation(HWND hWnd, int TemplateType);
  51. BOOL ContrastStretch(HWND hWnd);
  52. BOOL Cliping(HWND hWnd);
  53. BOOL Thresholding(HWND hWnd);
  54. BOOL Slice(HWND hWnd,BOOL WithBack);
  55. BOOL HistogramEqua(HWND hWnd);
  56. BOOL Dilation(HWND hWnd,BOOL Hori);
  57. BOOL Erosion(HWND hWnd,BOOL Hori);
  58. BOOL MorphOpen(HWND hWnd,BOOL Hori);
  59. BOOL MorphClose(HWND hWnd,BOOL Hori);
  60. BOOL Thinning(HWND hWnd);
  61. BOOL Outline(HWND hWnd);
  62. BOOL Hough(HWND hWnd);
  63. BOOL MedianFilter(HWND hWnd,BOOL Hori);
  64. BOOL LapOfGauss(HWND hWnd);
  65. BOOL Contour(HWND hWnd);
  66. BOOL IsContourP(LONG x,LONG y, char *lpPtr);
  67. BOOL SeedFill(HWND hWnd);
  68. BOOL InitStack(HWND hWnd,LONG StackLen);
  69. void DeInitStack();
  70. BOOL MyPush(POINT p);
  71. POINT MyPop();
  72. BOOL IsStackEmpty();
  73. BOOL Projection(HWND hWnd,BOOL Hori);
  74. BOOL Subtraction(HWND hWnd);
  75. BOOL LoadPcxFile(HWND hWnd,char *BmpFileName);
  76. void ReadPcxLine(unsigned char *p,FILE *fp);
  77. //////////////////////////////////////////////////
  78. //Jpeg functions
  79. BOOL LoadJpegFile(HWND hWnd,char *BmpFileName);
  80. void showerror(int funcret);
  81. int  InitTag();
  82. void InitTable();
  83. int  Decode();
  84. int  DecodeMCUBlock();
  85. int  HufBlock(BYTE dchufindex,BYTE achufindex);
  86. int  DecodeElement();
  87. void IQtIZzMCUComponent(short flag);
  88. void IQtIZzBlock(short  *s ,int * d,short flag);
  89. void GetYUV(short flag);
  90. void StoreBuffer();
  91. BYTE ReadByte();
  92. void Initialize_Fast_IDCT();
  93. void Fast_IDCT(int * block);
  94. void idctrow(int * blk);
  95. void idctcol(int * blk);
  96. //global variable declaration
  97. BITMAPFILEHEADER   bf;
  98. BITMAPINFOHEADER   bi;
  99. HPALETTE           hPalette=NULL;
  100. HBITMAP            hBitmap=NULL;
  101. HGLOBAL            hImgData=NULL;
  102. DWORD              NumColors;
  103. DWORD              LineBytes;
  104. HINSTANCE          ghInst;
  105. int                xOffset=0,yOffset=0;
  106. float    RotateAngle=0.0f;
  107. float              ZoomRatio=0.25f;
  108. DWORD              ImgWidth=0 , ImgHeight=0;
  109. //template array
  110. float Template_Smooth_Box[9]={1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f,1.0f};
  111. float Template_Smooth_Gauss[9]={1.0f,2.0f,1.0f,2.0f,4.0f,2.0f,1.0f,2.0f,1.0f};
  112. float Template_Sharpen_Laplacian[9]={-1.0f,-1.0f,-1.0f,-1.0f,9.0f,-1.0f,-1.0f,-1.0f,-1.0f};
  113. float Template_HSobel[9]={-1.0f,0.0f,1.0f,-2.0f,0.0f,2.0f,-1.0f,0.0f,1.0f};
  114. float Template_VSobel[9]={-1.0f,-2.0f,-1.0f,0.0f,0.0f,0.0f,1.0f,2.0f,1.0f};
  115. float Template_HIsoSobel[9]={-1.0f,0.0f,1.0f,-1.4142f,0.0f,1.4142f,-1.0f,0.0f,1.0f};
  116. float Template_VIsoSobel[9]={-1.0f,-1.4142f,-1.0f,0.0f,0.0f,0.0f,1.0f,1.4142f,1.0f};
  117. float Template_Log[25]={-2.0f,-4.0f,-4.0f,-4.0f,-2.0f,
  118.         -4.0f,0.0f,8.0f,0.0f,-4.0f,
  119. -4.0f,8.0f,24.0f,8.0f,-4.0f,
  120. -4.0f,0.0f,8.0f,0.0f,-4.0f,
  121. -2.0f,-4.0f,-4.0f,-4.0f,-2.0f};
  122. BYTE BayerPattern[8][8]={0,32,8,40,2,34,10,42,
  123.  48,16,56,24,50,18,58,26,
  124.  12,44,4,36,14,46,6,38,
  125.  60,28,52,20,62,30,54,22,
  126.  3,35,11,43,1,33,9,41,
  127.  51,19,59,27,49,17,57,25,
  128.  15,47,7,39,13,45,5,37,
  129.  63,31,55,23,61,29,53,21};
  130. static char ch[95]= {
  131. ' ',
  132. '`','1','2','3','4','5','6','7','8','9','0','-','=','\',
  133. 'q','w','e','r','t','y','u','i','o','p','[',']',
  134. 'a','s','d','f','g','h','j','k','l',';',''',
  135. 'z','x','c','v','b','n','m',',','.','/',
  136. '~','!','@','#','$','%','^','&','*','(',')','_','+','|',
  137. 'Q','W','E','R','T','Y','U','I','O','P','{','}',
  138. 'A','S','D','F','G','H','J','K','L',':','"',
  139. 'Z','X','C','V','B','N','M','<','>','?'
  140. };
  141. static int  gr[95]= {
  142.  0,
  143.  7,22,28,31,31,27,32,22,38,32,40, 6,12,20,38,32,26,20,24,40,
  144.     29,24,28,38,32,32,26,22,34,24,44,33,32,32,24,16, 6,22,26,22,
  145.  26,34,29,35,10, 6,20,14,22,47,42,34,40,10,35,21,22,22,16,14,
  146.  26,40,39,29,38,22,28,36,22,36,30,22,22,36,26,36,25,34,38,24,
  147.  36,22,12,12,26,30,30,34,39,42,41,18,18,22
  148.  };
  149. int GrayTable[256];
  150. int MaxGrayNum;
  151. int MinGrayNum;
  152. int FirstPoint=0, SecondPoint=255;
  153. float StretchRatio=2.0f;
  154. int EquaScale;
  155. MYSTACK SeedFillStack;
  156. POINT SeedPoint;
  157. BOOL IsSelecting;
  158. unsigned int  PcxBytesPerLine;
  159. LPSTR              lpPtr;
  160. //////////////////////////////////////////////////
  161. //variables used in jpeg function
  162. short SampRate_Y_H,SampRate_Y_V;
  163. short SampRate_U_H,SampRate_U_V;
  164. short SampRate_V_H,SampRate_V_V;
  165. short H_YtoU,V_YtoU,H_YtoV,V_YtoV;
  166. short Y_in_MCU,U_in_MCU,V_in_MCU;
  167. unsigned char   *lpJpegBuf;
  168. unsigned char   *lp;
  169. short qt_table[3][64];
  170. short comp_num;
  171. BYTE comp_index[3];
  172. BYTE     YDcIndex,YAcIndex,UVDcIndex,UVAcIndex;
  173. BYTE HufTabIndex;
  174. short     *YQtTable,*UQtTable,*VQtTable;
  175. BYTE And[9]={0,1,3,7,0xf,0x1f,0x3f,0x7f,0xff};
  176. short     code_pos_table[4][16],code_len_table[4][16];
  177. unsigned short code_value_table[4][256];
  178. unsigned short huf_max_value[4][16],huf_min_value[4][16];
  179. short BitPos,CurByte;
  180. short rrun,vvalue;
  181. short MCUBuffer[10*64];
  182. int QtZzMCUBuffer[10*64];
  183. short BlockBuffer[64];
  184. short ycoef,ucoef,vcoef;
  185. BOOL IntervalFlag;
  186. short interval=0;
  187. int Y[4*64],U[4*64],V[4*64];
  188. DWORD     sizei,sizej;
  189. short  restart;
  190. static  long iclip[1024];
  191. static  long *iclp;
  192. ///////////////////////////////////////////////////////////
  193. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  194.     LPSTR lpszCmdLine, int nCmdShow)
  195. {
  196. MSG       msg;
  197. WNDCLASS  wndclass;
  198. HWND      hWnd;
  200. ghInst=hInstance;
  201. if ( ! hPrevInstance ){
  202. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  203. wndclass.lpfnWndProc = MainWndProc;
  204. wndclass.cbClsExtra = 0;
  205. wndclass.cbWndExtra = 0;
  206. wndclass.hInstance = hInstance;
  207. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  208. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  209. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  210. wndclass.lpszMenuName =  "BMPMENU";
  211. wndclass.lpszClassName = "phoenix ip system";
  212.     }
  214.     if ( ! RegisterClass (&wndclass) )
  215.     return FALSE;
  217. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  218.     wndclass.lpfnWndProc = PopupWndProc;
  219.     wndclass.cbClsExtra = 0;
  220.     wndclass.cbWndExtra = 0;
  221.     wndclass.hInstance = ghInst;
  222.     wndclass.hIcon = NULL;
  223.     wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  224.     wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  225.     wndclass.lpszMenuName =  NULL;
  226.     wndclass.lpszClassName = "PopupWindowClass";
  228.     if ( ! RegisterClass (&wndclass) )
  229. return FALSE;
  230.  
  231. hWnd = CreateWindow ("phoenix ip system","Image Processing System",
  232.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  233.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  234.  hInstance, NULL);
  235. if (!hWnd)
  236. return FALSE;
  237. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  238. UpdateWindow (hWnd);
  240. while ( GetMessage (&msg, NULL, 0, 0) ){
  241. TranslateMessage (&msg);
  242. DispatchMessage (&msg);
  243.     }
  245. IsSelecting=FALSE;
  246. return msg.wParam;
  247. }
  248. ////////////////////////////////////////////////////////////////
  249. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  250. {
  251.     static  HDC    hDC,hMemDC;
  252.     PAINTSTRUCT    ps;
  254.     switch (message){
  255.     case WM_PAINT:
  256. {         
  257. hDC = BeginPaint(hWnd, &ps);
  258. if (hBitmap)
  259. { 
  260. hMemDC = CreateCompatibleDC(hDC);
  261. if (hPalette)
  262. {           
  263. SelectPalette (hDC, hPalette, FALSE); 
  264. SelectPalette (hMemDC, hPalette, FALSE);
  265. RealizePalette (hDC);
  266. }   
  267. SelectObject(hMemDC, hBitmap); 
  268. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  269. DeleteDC(hMemDC);
  270. }
  271. EndPaint(hWnd, &ps);
  272. break;
  273. }
  274. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  275.         if(hBitmap!=NULL)
  276.         DeleteObject(hBitmap);
  277.     
  278. if(hPalette!=NULL)                     
  279.         DeleteObject(hPalette);
  281. if(hImgData!=NULL){
  282. GlobalUnlock(hImgData);
  283. GlobalFree(hImgData);
  284. }         
  285.     PostQuitMessage (0);
  286.     return 0;
  287. case WM_LBUTTONDOWN:
  288. if(IsSelecting){
  289. SeedPoint.x = LOWORD(lParam);
  290. SeedPoint.y = HIWORD(lParam);
  291. IsSelecting=FALSE;
  292. if(SeedFill(hWnd))
  293. InvalidateRect(hWnd,NULL,TRUE);
  294. }
  295.   break;
  296. case WM_COMMAND:
  297.     switch (wParam){
  298.     case IDM_LOADBMP: 
  299. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  300.         if(hBitmap!=NULL){     
  301. DeleteObject(hBitmap);
  302.             hBitmap=NULL;
  303.         }
  304.         if(hPalette!=NULL){                     
  305. DeleteObject(hPalette);
  306.             hPalette=NULL;
  307.         }
  308. if(hImgData!=NULL){
  309. GlobalUnlock(hImgData);
  310. GlobalFree(hImgData);  
  311. hImgData=NULL;
  312. }         
  313. if(LoadBmpFile(hWnd,"c:\test.bmp")) //成功，则重画窗口
  314.                 InvalidateRect(hWnd,NULL,TRUE);
  315.         break;
  316. case IDM_TRANSLATION: 
  317. if(hImgData!=NULL){
  318. if(Translation(hWnd))
  319. InvalidateRect(hWnd,NULL,TRUE);
  320. }
  321. else
  322. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  323. break;
  324. case IDM_ROTATION: 
  325. if(hImgData!=NULL){
  326. if(Rotation(hWnd))
  327. InvalidateRect(hWnd,NULL,TRUE);
  328. }
  329. else
  330. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  331. break;
  332. case IDM_MIRRORX: 
  333. if(hImgData!=NULL){
  334. if(Mirror(hWnd,TRUE))
  335. InvalidateRect(hWnd,NULL,TRUE);
  336. }
  337. else
  338. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  339. break;
  340. case IDM_MIRRORY: 
  341. if(hImgData!=NULL){
  342. if(Mirror(hWnd,FALSE))
  343. InvalidateRect(hWnd,NULL,TRUE);
  344. }
  345. else
  346. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  347. break;
  348. case IDM_TRANSPOSE: 
  349. if(hImgData!=NULL){
  350. if(Transpose(hWnd))
  351. InvalidateRect(hWnd,NULL,TRUE);
  352. }
  353. else
  354. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  355. break;
  356. case IDM_ZOOM: 
  357. if(hImgData!=NULL){
  358. if(Zoom(hWnd))
  359. InvalidateRect(hWnd,NULL,TRUE);
  360. }
  361. else
  362. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  363. break;
  364. case IDM_SMOOTHING_BOX:
  365. if(hImgData!=NULL){
  366. if(TemplateOperation(hWnd,TEMPLATE_SMOOTH_BOX))
  367. InvalidateRect(hWnd,NULL,TRUE);
  368. }
  369. else
  370. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  371. break;
  372. case IDM_SMOOTHING_GAUSS:
  373. if(hImgData!=NULL){
  374. if(TemplateOperation(hWnd,TEMPLATE_SMOOTH_GAUSS))
  375. InvalidateRect(hWnd,NULL,TRUE);
  376. }
  377. else
  378. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  379. break;
  380. case IDM_SHARPENING_LAPLACIAN:
  381. if(hImgData!=NULL){
  382. if(TemplateOperation(hWnd,TEMPLATE_SHARPEN_LAPLACIAN))
  383. InvalidateRect(hWnd,NULL,TRUE);
  384. }
  385. else
  386. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  387. break;
  388. case IDM_LIMBPATTERNM3:
  389. if(hImgData!=NULL){
  390. if(LimbPatternM3(hWnd))
  391. InvalidateRect(hWnd,NULL,TRUE);
  392. }
  393. else
  394. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  395. break;
  396. case IDM_LIMBPATTERNM4:
  397. if(hImgData!=NULL){
  398. if(LimbPatternM4(hWnd))
  399. InvalidateRect(hWnd,NULL,TRUE);
  400. }
  401. else
  402. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  403. break;
  404. case IDM_STEINBERG:
  405. if(hImgData!=NULL){
  406. if(Steinberg(hWnd));
  407. InvalidateRect(hWnd,NULL,TRUE);
  408. }
  409. else
  410. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  411. break;
  412. case IDM_BMP2TXT:
  413. if(hImgData!=NULL){
  414. if(Bmp2Txt(hWnd))
  415.      MessageBox(hWnd,"Finished!","Success Message",MB_OK);
  416. }
  417. else
  418. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  419. break;
  420. case IDM_HISTOGRAM:
  421. if(hImgData!=NULL){
  422. if(Histogram(hWnd))
  423. InvalidateRect(hWnd,NULL,TRUE);
  424. }
  425. else
  426. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  427. break;
  428. case IDM_TRUE256:
  429. if(hImgData!=NULL){
  430. if(Trueto256(hWnd))
  431. InvalidateRect(hWnd,NULL,TRUE);
  432. }
  433. else
  434. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  435. break;
  436. case IDM_CLRGRAY:
  437. if(hImgData!=NULL){
  438. if(ColortoGrayScale(hWnd))
  439. InvalidateRect(hWnd,NULL,TRUE);
  440. }
  441. else
  442. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  443. break;
  444. case IDM_INVERT:
  445. if(hImgData!=NULL){
  446. if(Invert(hWnd))
  447. InvalidateRect(hWnd,NULL,TRUE);
  448. }
  449. else
  450. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  451. break;
  452. case IDM_CONTSTRETCH:
  453. if(hImgData!=NULL){
  454. if (ContrastStretch(hWnd))
  455. InvalidateRect(hWnd,NULL,TRUE);
  456. }
  457. else
  458. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  459. break;
  460. case IDM_CLIPING:
  461. if(hImgData!=NULL){
  462. if(Cliping(hWnd))
  463. InvalidateRect(hWnd,NULL,TRUE);
  464. }
  465. else
  466. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  467. break;
  468. case IDM_THRESHOLD:
  469. if(hImgData!=NULL){
  470. if(Thresholding(hWnd))
  471. InvalidateRect(hWnd,NULL,TRUE);
  472. }
  473. else
  474. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  475. break;
  476. case IDM_SLICEWITHOUTBACK:
  477. if(hImgData!=NULL){
  478. if(Slice(hWnd,FALSE))
  479. InvalidateRect(hWnd,NULL,TRUE);
  480. }
  481. else
  482. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  483. break;
  484. case IDM_SLICEWITHBACK:
  485. if(hImgData!=NULL){
  486. if(Slice(hWnd,TRUE))
  487. InvalidateRect(hWnd,NULL,TRUE);
  488. }
  489. else
  490. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  491. break;
  492. case IDM_HISTOGRAMEQUA:
  493. if(hImgData!=NULL){
  494. if(HistogramEqua(hWnd))
  495. InvalidateRect(hWnd,NULL,TRUE);
  496. }
  497. else
  498. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  499. break;
  500. case IDM_HDILATION:
  501. if(hImgData!=NULL){
  502. if(Dilation(hWnd,TRUE))
  503. InvalidateRect(hWnd,NULL,TRUE);
  504. }
  505. else
  506. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  507. break;
  508. case IDM_VDILATION:
  509. if(hImgData!=NULL){
  510. if(Dilation(hWnd,FALSE))
  511. InvalidateRect(hWnd,NULL,TRUE);
  512. }
  513. else
  514. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  515. break;
  516. case IDM_HEROSION:
  517. if(hImgData!=NULL){
  518. if(Erosion(hWnd,TRUE))
  519. InvalidateRect(hWnd,NULL,TRUE);
  520. }
  521. else
  522. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  523. break;
  524. case IDM_VEROSION:
  525. if(hImgData!=NULL){
  526. if(Erosion(hWnd,FALSE))
  527. InvalidateRect(hWnd,NULL,TRUE);
  528. }
  529. else
  530. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  531. break;
  532. case IDM_HOPEN:
  533. if(hImgData!=NULL){
  534. if(MorphOpen(hWnd,TRUE))
  535. InvalidateRect(hWnd,NULL,TRUE);
  536. }
  537. else
  538. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  539. break;
  540. case IDM_VOPEN:
  541. if(hImgData!=NULL){
  542. if(MorphOpen(hWnd,FALSE))
  543. InvalidateRect(hWnd,NULL,TRUE);
  544. }
  545. else
  546. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  547. break;
  548. case IDM_HCLOSE:
  549. if(hImgData!=NULL){
  550. if(MorphClose(hWnd,TRUE))
  551. InvalidateRect(hWnd,NULL,TRUE);
  552. }
  553. else
  554. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  555. break;
  556. case IDM_VCLOSE:
  557. if(hImgData!=NULL){
  558. if(MorphClose(hWnd,FALSE))
  559. InvalidateRect(hWnd,NULL,TRUE);
  560. }
  561. else
  562. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  563. break;
  564. case IDM_THINNING:
  565. if(hImgData!=NULL){
  566. if(Thinning(hWnd))
  567. InvalidateRect(hWnd,NULL,TRUE);
  568. }
  569. else
  570. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  571. break;
  572. case IDM_OUTLINE:
  573. if(hImgData!=NULL){
  574. if(Outline(hWnd))
  575. InvalidateRect(hWnd,NULL,TRUE);
  576. }
  577. else
  578. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  579. break;
  580. case IDM_HSOBEL:
  581. if(hImgData!=NULL){
  582. if(TemplateOperation(hWnd,TEMPLATE_SOBEL_H))
  583. InvalidateRect(hWnd,NULL,TRUE);
  584. }
  585. else
  586. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  587. break;
  588. case IDM_VSOBEL:
  589. if(hImgData!=NULL){
  590. if(TemplateOperation(hWnd,TEMPLATE_SOBEL_V))
  591. InvalidateRect(hWnd,NULL,TRUE);
  592. }
  593. else
  594. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  595. break;
  596. case IDM_HISOSOBEL:
  597. if(hImgData!=NULL){
  598. if(TemplateOperation(hWnd,TEMPLATE_ISOSOBEL_H))
  599. InvalidateRect(hWnd,NULL,TRUE);
  600. }
  601. else
  602. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  603. break;
  604. case IDM_VISOSOBEL:
  605. if(hImgData!=NULL){
  606. if(TemplateOperation(hWnd,TEMPLATE_ISOSOBEL_V))
  607. InvalidateRect(hWnd,NULL,TRUE);
  608. }
  609. else
  610. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  611. break;
  612. case IDM_HOUGH:
  613. if(hImgData!=NULL) 
  614. Hough(hWnd);
  615. else
  616. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  617. break;
  618. case IDM_HMEDIAN:
  619. if(hImgData!=NULL){
  620. if(MedianFilter(hWnd,TRUE))
  621. InvalidateRect(hWnd,NULL,TRUE);
  622. }
  623. else
  624. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  625. break;
  626. case IDM_VMEDIAN:
  627. if(hImgData!=NULL){
  628. if(MedianFilter(hWnd,FALSE))
  629. InvalidateRect(hWnd,NULL,TRUE);
  630. }
  631. else
  632. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  633. break;
  634. case IDM_LOG:
  635. if(hImgData!=NULL){
  636. if(LapOfGauss(hWnd))
  637. InvalidateRect(hWnd,NULL,TRUE);
  638. }
  639. else
  640. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  641. break;
  642. case IDM_CONTOUR:
  643. if(hImgData!=NULL){
  644. if(Contour(hWnd))
  645. InvalidateRect(hWnd,NULL,TRUE);
  646. }
  647. else
  648. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  649. break;
  650. case IDM_SEEDFILL:
  651. if(hImgData!=NULL){
  652. IsSelecting=TRUE;
  653. MessageBox(hWnd,"Please click the area to be filled!","Message",MB_OK|MB_ICONEXCLAMATION);
  654. }
  655. else
  656. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  657. break;
  658. case IDM_HPROJECTION:
  659. if(hImgData!=NULL){
  660. if(Projection(hWnd,TRUE))
  661. InvalidateRect(hWnd,NULL,TRUE);
  662. }
  663. else
  664. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  665. break;
  666. case IDM_VPROJECTION:
  667. if(hImgData!=NULL){
  668. if(Projection(hWnd,FALSE))
  669. InvalidateRect(hWnd,NULL,TRUE);
  670. }
  671. else
  672. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  673. break;
  674. case IDM_SUBTRACTION:
  675. if(hImgData!=NULL){
  676. MessageBox(hWnd,"Be sure that c:\test.bmp and c:\backgnd.bmp are both 256 grayscale bitmaps ! They must be same size and have same palette!","Important",MB_OK);
  677. if(Subtraction(hWnd))
  678. InvalidateRect(hWnd,NULL,TRUE);
  679. }
  680. else
  681. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  682. break;
  683. case IDM_RUNLENGTH:
  684. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  685.         if(hBitmap!=NULL){     
  686. DeleteObject(hBitmap);
  687.             hBitmap=NULL;
  688.         }
  689.         if(hPalette!=NULL){                     
  690. DeleteObject(hPalette);
  691.             hPalette=NULL;
  692.         }
  693. if(hImgData!=NULL){
  694. GlobalUnlock(hImgData);
  695. GlobalFree(hImgData);  
  696. hImgData=NULL;
  697. }         
  698. if(LoadPcxFile(hWnd,"c:\test.pcx")) //成功，则重画窗口
  699.                 InvalidateRect(hWnd,NULL,TRUE);
  700.         break;
  701. case IDM_JPEG:
  702. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  703.         if(hBitmap!=NULL){     
  704. DeleteObject(hBitmap);
  705.             hBitmap=NULL;
  706.         }
  707.         if(hPalette!=NULL){                     
  708. DeleteObject(hPalette);
  709.             hPalette=NULL;
  710.         }
  711. if(hImgData!=NULL){
  712. GlobalUnlock(hImgData);
  713. GlobalFree(hImgData);  
  714. hImgData=NULL;
  715. }         
  716. if(LoadJpegFile(hWnd,"c:\test.jpg")) //成功，则重画窗口
  717.                 InvalidateRect(hWnd,NULL,TRUE);
  718.         break;
  719. case IDM_EXIT:
  720.         SendMessage(hWnd,WM_DESTROY,0,0L);
  721.         break;
  722.     }
  723. break;                
  724.     }
  725.     return DefWindowProc (hWnd, message, wParam, lParam);
  726.  }
  727. ////////////////////////////////////////////////////////////////
  728. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName)
  729. {   
  730.     HFILE              hf;
  731.     LPBITMAPINFOHEADER lpImgData;
  732.     LOGPALETTE         *pPal;
  733.     LPRGBQUAD          lpRGB;
  734.     HPALETTE           hPrevPalette; 
  735.     HDC                hDc;
  736. HLOCAL             hPal;
  737. DWORD         ImgSize;
  738. DWORD              i;
  740.     if((hf=_lopen(BmpFileName,OF_READ))==HFILE_ERROR){
  741.         MessageBox(hWnd,"File c:\test.bmp not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  742.         return FALSE;
  743. }
  744. _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  745. _lread(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER));
  746. ImgWidth=bi.biWidth;
  747. ImgHeight=bi.biHeight;
  748. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  749. ImgSize=(DWORD)LineBytes*bi.biHeight;
  750.     if(bi.biClrUsed!=0)
  751. NumColors=(DWORD)bi.biClrUsed;
  752. else
  753.         switch(bi.biBitCount){
  754.         case 1:
  755.              NumColors=2;
  756.              break;
  757.          case 4:
  758.              NumColors=16;
  759.              break;
  760.          case 8:
  761.              NumColors=256;
  762.              break;
  763.          case 24:
  764.              NumColors=0;
  765.              break;
  766.               default:
  767.                   MessageBox(hWnd,"Invalid color numbers!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  768.                   _lclose(hf);
  769.                   return FALSE; 
  770.         }
  771. if(bf.bfOffBits!=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  772. +sizeof(BITMAPINFOHEADER)))
  773. {
  774.      MessageBox(hWnd,"Invalid color numbers!","Error Message" ,MB_OK|
  775.                MB_ICONEXCLAMATION);
  776. _lclose(hf);
  777. return FALSE; 
  778. }
  779. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  780. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  781.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  782. {
  783.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  784.                    MB_ICONEXCLAMATION);
  785.     _lclose(hf);
  786. return FALSE;
  787. }
  788.   
  789. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  790.     _llseek(hf,sizeof(BITMAPFILEHEADER),FILE_BEGIN);
  791. _hread(hf,(char *)lpImgData,(long)sizeof(BITMAPINFOHEADER)
  792.            +(long)NumColors*sizeof(RGBQUAD)+ImgSize);
  793. _lclose(hf);
  794.     if(NumColors!=0)
  795. {                    
  796.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  797.     pPal =(LOGPALETTE *)LocalLock(hPal);
  798.     pPal->palNumEntries =(WORD) NumColors;
  799. pPal->palVersion    = 0x300;
  800.     lpRGB = (LPRGBQUAD)((LPSTR)lpImgData + (DWORD)sizeof(BITMAPINFOHEADER));
  801. for (i = 0; i < NumColors; i++) {
  802.       pPal->palPalEntry[i].peRed=lpRGB->rgbRed;
  803. pPal->palPalEntry[i].peGreen=lpRGB->rgbGreen;
  804. pPal->palPalEntry[i].peBlue=lpRGB->rgbBlue;
  805. pPal->palPalEntry[i].peFlags=(BYTE)0;
  806. lpRGB++;
  807. }
  808. hPalette=CreatePalette(pPal);
  809. LocalUnlock(hPal);
  810. LocalFree(hPal);
  811. }
  812. hDc=GetDC(hWnd);
  813. if(hPalette){
  814.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  815. RealizePalette(hDc);
  816. }
  817. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  818. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  819.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  820. if(hPalette && hPrevPalette){
  821. SelectPalette(hDc,hPrevPalette,FALSE);
  822. RealizePalette(hDc);
  823. }
  824.  
  825. ReleaseDC(hWnd,hDc);
  826. GlobalUnlock(hImgData);
  827. return TRUE; 
  828. }
  829. ////////////////////////////////////////////////////////////////
  830. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam )
  831. { 
  832. char str[80];
  834.     switch  ( message ){
  835.     case WM_INITDIALOG:    
  836.       SetDlgItemText(hDlg,ID_XOFFSET,"0");
  837.       SetDlgItemText(hDlg,ID_YOFFSET,"0");
  838.       SetDlgItemText(hDlg,ID_ANGLE,"0");
  839.       SetDlgItemText(hDlg,ID_ZOOMRATIO,"0.25");
  840.       SetDlgItemText(hDlg,ID_FIRSTPOINT,"0");
  841.       SetDlgItemText(hDlg,ID_SECONDPOINT,"0");
  842.       SetDlgItemText(hDlg,ID_STRETCHRATIO,"2.0");
  843.       SetDlgItemText(hDlg,ID_EQUASCALE,"128");
  844.      return TRUE;
  845.     case WM_COMMAND:    
  846.      if ( wParam == IDOK || wParam == IDCANCEL )
  847.         {
  848.          GetDlgItemText(hDlg,ID_XOFFSET,str,80);
  849. xOffset=atoi(str);
  850.          GetDlgItemText(hDlg,ID_YOFFSET,str,80);
  851. yOffset=atoi(str);
  852.          GetDlgItemText(hDlg,ID_ANGLE,str,80);
  853. RotateAngle=(float)atof(str);
  854.          GetDlgItemText(hDlg,ID_ZOOMRATIO,str,80);
  855. ZoomRatio=(float)atof(str);
  856.          GetDlgItemText(hDlg,ID_FIRSTPOINT,str,80);
  857. FirstPoint=atoi(str);
  858.          GetDlgItemText(hDlg,ID_SECONDPOINT,str,80);
  859. SecondPoint=atoi(str);
  860.          GetDlgItemText(hDlg,ID_STRETCHRATIO,str,80);
  861. StretchRatio=(float)atof(str);
  862.          GetDlgItemText(hDlg,ID_EQUASCALE,str,80);
  863. EquaScale=atoi(str);
  864.             EndDialog ( hDlg, TRUE );
  865.             return  TRUE;
  866.         }
  867.         break;
  868.     }
  869. return FALSE;      
  870. }
  871. ////////////////////////////////////////////////////////////////
  872. BOOL Translation(HWND hWnd)
  873. {
  874. DLGPROC            dlgInputBox = NULL;
  875. DWORD              OffBits,BufSize;
  876.     LPBITMAPINFOHEADER lpImgData;
  877. LPSTR              lpPtr;
  878. HLOCAL             hTempImgData;
  879. LPBITMAPINFOHEADER lpTempImgData;
  880. LPSTR              lpTempPtr;
  881. int    SrcX0,SrcY0,SrcX1,SrcY1,DstX0,DstY0,DstX1,DstY1;
  882. int                RectWidth,RectHeight;
  883. BOOL               xVisible,yVisible;
  884. HDC                hDc;
  885. HFILE              hf;
  886. int                i;
  888. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  889. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  890. FreeProcInstance ( (FARPROC) dlgInputBox );
  892. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  893. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  895. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  896.     {
  897.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  898.         return FALSE;
  899.     }
  901.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  902. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  904. lpPtr=(char *)lpImgData;
  905. lpTempPtr=(char *)lpTempImgData;
  907. memset(lpTempPtr,(BYTE)255,BufSize);
  908. memcpy(lpTempPtr,lpPtr,OffBits);
  910. xVisible=TRUE;
  911. if( xOffset<= -bi.biWidth )
  912. xVisible=FALSE;
  913. else if( xOffset<=0){
  914. DstX0=0;
  915. DstX1=bi.biWidth+xOffset;
  916. }
  917. else if ( xOffset<bi.biWidth){
  918. DstX0=xOffset;
  919. DstX1=bi.biWidth;
  920. }
  921. else
  922. xVisible=FALSE;
  923. SrcX0=DstX0-xOffset;
  924. SrcX1=DstX1-xOffset;
  925. RectWidth=DstX1-DstX0;
  927. yVisible=TRUE;
  928. if( yOffset<= -bi.biHeight )
  929. yVisible=FALSE;
  930. else if( yOffset<=0){
  931. DstY0=0;
  932. DstY1=bi.biHeight+yOffset;
  933. }
  934. else if ( yOffset<bi.biHeight){
  935. DstY0=yOffset;
  936. DstY1=bi.biHeight;
  937. }
  938. else
  939. yVisible=FALSE;
  940. SrcY0=DstY0-yOffset;
  941. SrcY1=DstY1-yOffset;
  942. RectHeight=DstY1-DstY0;
  944. if( xVisible && yVisible){
  945. for(i=0;i<RectHeight;i++){
  946. lpPtr=(char *)lpImgData+(BufSize-LineBytes-(i+SrcY0)*LineBytes)+SrcX0;
  947. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-(i+DstY0)*LineBytes)+DstX0;
  948. memcpy(lpTempPtr,lpPtr,RectWidth);
  949. }
  950. }
  952. hDc=GetDC(hWnd);
  953.     if(hBitmap!=NULL)
  954.     DeleteObject(hBitmap);
  956. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  957. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  958.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  960.     hf=_lcreat("c:\translation.bmp",0);
  961. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  962. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  963. _lclose(hf);
  965.   ReleaseDC(hWnd,hDc);
  966. LocalUnlock(hTempImgData);
  967. LocalFree(hTempImgData);
  968. GlobalUnlock(hImgData);
  969. return TRUE;
  970. }
  971. ////////////////////////////////////////////////////////////////
  972. BOOL Rotation(HWND hWnd)
  973. {
  974. DLGPROC            dlgInputBox = NULL;
  975. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  976.     LPBITMAPINFOHEADER lpImgData;
  977. LPSTR              lpPtr;
  978. HLOCAL             hTempImgData;
  979. LPBITMAPINFOHEADER lpTempImgData;
  980. LPSTR              lpTempPtr;
  981. float    SrcX1,SrcY1,SrcX2,SrcY2,SrcX3,SrcY3,SrcX4,SrcY4;
  982. float    DstX1,DstY1,DstX2,DstY2,DstX3,DstY3,DstX4,DstY4;
  983. DWORD              Wold,Hold,Wnew,Hnew;
  984. HDC                hDc;
  985. HFILE              hf;
  986. DWORD              x0,y0,x1,y1;
  987. float              cosa,sina; //cos(a),sin(a)
  988. float    num1,num2;
  989. BITMAPFILEHEADER   DstBf;
  990. BITMAPINFOHEADER   DstBi;
  992. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  993. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  994. FreeProcInstance ( (FARPROC) dlgInputBox );
  996. RotateAngle=(float)RADIAN(RotateAngle);
  997. cosa=(float)cos((double)RotateAngle);
  998. sina=(float)sin((double)RotateAngle);
  1000. Wold=bi.biWidth;
  1001. Hold=bi.biHeight;
  1002. SrcX1=(float)(-0.5*Wold);
  1003. SrcY1=(float)(0.5*Hold);
  1004. SrcX2=(float)(0.5*Wold);
  1005. SrcY2=(float)(0.5*Hold);
  1006. SrcX3=(float)(-0.5*Wold);
  1007. SrcY3=(float)(-0.5*Hold);
  1008. SrcX4=(float)(0.5*Wold);
  1009. SrcY4=(float)(-0.5*Hold);
  1011. DstX1=cosa*SrcX1+sina*SrcY1;
  1012. DstY1=-sina*SrcX1+cosa*SrcY1;
  1013. DstX2=cosa*SrcX2+sina*SrcY2;
  1014. DstY2=-sina*SrcX2+cosa*SrcY2;
  1015. DstX3=cosa*SrcX3+sina*SrcY3;
  1016. DstY3=-sina*SrcX3+cosa*SrcY3;
  1017. DstX4=cosa*SrcX4+sina*SrcY4;
  1018. DstY4=-sina*SrcX4+cosa*SrcY4;
  1020. Wnew = (DWORD)(max(fabs(DstX4-DstX1), fabs(DstX3-DstX2))+0.5);
  1021.     Hnew = (DWORD)(max(fabs(DstY4-DstY1), fabs(DstY3-DstY2))+0.5);
  1022. num1=(float)( -0.5*Wnew*cosa-0.5*Hnew*sina+0.5*Wold);
  1023. num2=(float)(0.5*Wnew*sina-0.5*Hnew*cosa+0.5*Hold);
  1025. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1026. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1028. ImgWidth=Wnew;
  1029. ImgHeight=Hnew;
  1031. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  1032. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  1034. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  1035.     {
  1036.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1037.         return FALSE;
  1038.     }
  1040.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1041. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1043. lpPtr=(char *)lpImgData;
  1044. lpTempPtr=(char *)lpTempImgData;
  1046. memset(lpTempPtr,(BYTE)255,DstBufSize);
  1047. memcpy(lpTempPtr,lpPtr,OffBits);
  1049. //get new bitmapfileheader and bitmapinfoheader
  1050. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  1051. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  1052. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  1053. DstBi.biWidth=Wnew;
  1054. DstBi.biHeight=Hnew;
  1056. //overwrite bitmapinfoheader with the new one
  1057. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  1059. for(y1=0;y1<Hnew;y1++)
  1060. for(x1=0;x1<Wnew;x1++){
  1061. x0= (DWORD)(x1*cosa+y1*sina+num1);
  1062. y0= (DWORD)(-1.0f*x1*sina+y1*cosa+num2);
  1063. if( (x0>=0) && (x0<Wold) && (y0>=0) && (y0<Hold))
  1064. {
  1065. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  1066. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  1067. *lpTempPtr=*lpPtr;
  1068. }
  1069. }
  1071. hDc=GetDC(hWnd);
  1072.     if(hBitmap!=NULL)
  1073.     DeleteObject(hBitmap);
  1075. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1076. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1077.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1079.     hf=_lcreat("c:\rotation.bmp",0);
  1080. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  1081. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  1082. _lclose(hf);
  1084.   ReleaseDC(hWnd,hDc);
  1085. LocalUnlock(hTempImgData);
  1086. LocalFree(hTempImgData);
  1087. GlobalUnlock(hImgData);
  1088. return TRUE;
  1089. }
  1090. ////////////////////////////////////////////////////////////////
  1091. BOOL Mirror(HWND hWnd,BOOL XDirection)
  1092. {
  1093. DWORD              OffBits,BufSize;
  1094.     LPBITMAPINFOHEADER lpImgData;
  1095. LPSTR              lpPtr;
  1096. HLOCAL             hTempImgData;
  1097. LPBITMAPINFOHEADER lpTempImgData;
  1098. LPSTR              lpTempPtr;
  1099. HDC                hDc;
  1100. HFILE              hf;
  1101. LONG               x0,y0,x1,y1;
  1103. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1104. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1106. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1107.     {
  1108.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1109.         return FALSE;
  1110.     }
  1112.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1113. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1115. lpPtr=(char *)lpImgData;
  1116. lpTempPtr=(char *)lpTempImgData;
  1118. memset(lpTempPtr,(BYTE)255,BufSize);
  1119. memcpy(lpTempPtr,lpPtr,OffBits);
  1121. if( XDirection){
  1122. for(y1=0;y1<bi.biHeight;y1++)
  1123. for(x1=0;x1<bi.biWidth;x1++){
  1124. x0=bi.biWidth-1-x1;
  1125. y0=y1;
  1126. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y0*LineBytes)+x0;
  1127. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y1*LineBytes)+x1;
  1128. *lpTempPtr=*lpPtr;
  1129. }
  1130. }
  1131. else{
  1132. for(y1=0;y1<bi.biHeight;y1++)
  1133. for(x1=0;x1<bi.biWidth;x1++){
  1134. x0=x1;
  1135. y0=bi.biHeight-1-y1;
  1136. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y0*LineBytes)+x0;
  1137. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y1*LineBytes)+x1;
  1138. *lpTempPtr=*lpPtr;
  1139. }
  1140. }
  1142. hDc=GetDC(hWnd);
  1143.     if(hBitmap!=NULL)
  1144.     DeleteObject(hBitmap);
  1146. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1147. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1148.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1149. if( XDirection)
  1150. hf=_lcreat("c:\mirrorx.bmp",0);
  1151. else
  1152. hf=_lcreat("c:\mirrory.bmp",0);
  1154. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1155. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1156. _lclose(hf);
  1158.   ReleaseDC(hWnd,hDc);
  1159. LocalUnlock(hTempImgData);
  1160. LocalFree(hTempImgData);
  1161. GlobalUnlock(hImgData);
  1162. return TRUE;
  1163. }
  1164. ////////////////////////////////////////////////////////////////
  1165. BOOL Transpose(HWND hWnd)
  1166. {
  1167. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  1168.     LPBITMAPINFOHEADER lpImgData;
  1169. LPSTR              lpPtr;
  1170. HLOCAL             hTempImgData;
  1171. LPBITMAPINFOHEADER lpTempImgData;
  1172. LPSTR              lpTempPtr;
  1173. DWORD              Wnew,Hnew;
  1174. HDC                hDc;
  1175. HFILE              hf;
  1176. DWORD              x0,y0,x1,y1;
  1177. BITMAPFILEHEADER   DstBf;
  1178. BITMAPINFOHEADER   DstBi;
  1180. Wnew = (DWORD)bi.biHeight;
  1181.     Hnew = (DWORD)bi.biWidth;
  1183. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1184. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1186. ImgWidth=Wnew;
  1187. ImgHeight=Hnew;
  1189. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  1190. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  1192. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  1193.     {
  1194.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1195.         return FALSE;
  1196.     }
  1198.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1199. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1201. lpPtr=(char *)lpImgData;
  1202. lpTempPtr=(char *)lpTempImgData;
  1204. memset(lpTempPtr,(BYTE)255,DstBufSize);
  1205. memcpy(lpTempPtr,lpPtr,OffBits);
  1207. //get new bitmapfileheader and bitmapinfoheader
  1208. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  1209. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  1210. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  1211. DstBi.biWidth=Wnew;
  1212. DstBi.biHeight=Hnew;
  1214. //overwrite bitmapinfoheader with the new one
  1215. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  1217. for(y1=0;y1<Hnew;y1++)
  1218. for(x1=0;x1<Wnew;x1++){
  1219. x0= y1;
  1220. y0= x1;
  1221. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  1222. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  1223. *lpTempPtr=*lpPtr;
  1224. }
  1226. hDc=GetDC(hWnd);
  1227.     if(hBitmap!=NULL)
  1228.     DeleteObject(hBitmap);
  1230. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1231. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1232.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1234.     hf=_lcreat("c:\transpose.bmp",0);
  1235. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  1236. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  1237. _lclose(hf);
  1239.   ReleaseDC(hWnd,hDc);
  1240. LocalUnlock(hTempImgData);
  1241. LocalFree(hTempImgData);
  1242. GlobalUnlock(hImgData);
  1243. return TRUE;
  1244. }
  1245. ////////////////////////////////////////////////////////////////
  1246. BOOL Zoom(HWND hWnd)
  1247. {
  1248. DLGPROC            dlgInputBox = NULL;
  1249. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  1250.     LPBITMAPINFOHEADER lpImgData;
  1251. LPSTR              lpPtr;
  1252. HLOCAL             hTempImgData;
  1253. LPBITMAPINFOHEADER lpTempImgData;
  1254. LPSTR              lpTempPtr;
  1255. DWORD              Wold,Hold,Wnew,Hnew;
  1256. HDC                hDc;
  1257. HFILE              hf;
  1258. DWORD              x0,y0,x1,y1;
  1259. float    num1;
  1260. BITMAPFILEHEADER   DstBf;
  1261. BITMAPINFOHEADER   DstBi;
  1263. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  1264. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  1265. FreeProcInstance ( (FARPROC) dlgInputBox );
  1267. num1=(float)(1.0/ZoomRatio);
  1268. Wold=bi.biWidth;
  1269. Hold=bi.biHeight;
  1270. Wnew = (DWORD)(Wold*ZoomRatio+0.5);
  1271.     Hnew = (DWORD)(Hold*ZoomRatio+0.5);
  1273. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1274. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1276. ImgWidth=Wnew;
  1277. ImgHeight=Hnew;
  1279. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  1280. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  1282. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  1283.     {
  1284.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1285.         return FALSE;
  1286.     }
  1288.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1289. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1291. lpPtr=(char *)lpImgData;
  1292. lpTempPtr=(char *)lpTempImgData;
  1294. memset(lpTempPtr,(BYTE)255,DstBufSize);
  1295. memcpy(lpTempPtr,lpPtr,OffBits);
  1297. //get new bitmapfileheader and bitmapinfoheader
  1298. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  1299. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  1300. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  1301. DstBi.biWidth=Wnew;
  1302. DstBi.biHeight=Hnew;
  1304. //overwrite bitmapinfoheader with the new one
  1305. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  1307. for(y1=0;y1<Hnew;y1++)
  1308. for(x1=0;x1<Wnew;x1++){
  1309. x0= (DWORD)(x1*num1);
  1310. y0= (DWORD)(y1*num1);
  1311. if( (x0>=0) && (x0<Wold) && (y0>=0) && (y0<Hold))
  1312. {
  1313. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  1314. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  1315. *lpTempPtr=*lpPtr;
  1316. }
  1317. }
  1319. hDc=GetDC(hWnd);
  1320.     if(hBitmap!=NULL)
  1321.     DeleteObject(hBitmap);
  1323. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1324. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1325.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1327.     hf=_lcreat("c:\zoom.bmp",0);
  1328. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  1329. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  1330. _lclose(hf);
  1332.   ReleaseDC(hWnd,hDc);
  1333. LocalUnlock(hTempImgData);
  1334. LocalFree(hTempImgData);
  1335. GlobalUnlock(hImgData);
  1336. return TRUE;
  1337. }
  1338. ////////////////////////////////////////////////////////////////
  1339. BOOL TemplateOperation(HWND hWnd, int TemplateType)
  1340. {
  1341. DWORD              OffBits,BufSize;
  1342.     LPBITMAPINFOHEADER lpImgData;
  1343. LPSTR              lpPtr;
  1344. HLOCAL             hTempImgData;
  1345. LPBITMAPINFOHEADER lpTempImgData;
  1346. LPSTR              lpTempPtr;
  1347. HDC                hDc;
  1348. HFILE              hf;
  1349. LONG               x,y;
  1350. float              coef;
  1351. float              CoefArray[9];
  1352. float              TempNum;
  1353. char               filename[80];
  1355. switch(TemplateType){
  1356. case TEMPLATE_SMOOTH_BOX:
  1357. coef=(float)(1.0/9.0);
  1358. memcpy(CoefArray,Template_Smooth_Box,9*sizeof(float));
  1359. strcpy(filename,"c:\smbox.bmp");
  1360. break;
  1361. case TEMPLATE_SMOOTH_GAUSS:
  1362. coef=(float)(1.0/16.0);
  1363. memcpy(CoefArray,Template_Smooth_Gauss,9*sizeof(float));
  1364. strcpy(filename,"c:\smgauss.bmp");
  1365. break;
  1366. case TEMPLATE_SHARPEN_LAPLACIAN:
  1367. coef=(float)1.0;
  1368. memcpy(CoefArray,Template_Sharpen_Laplacian,9*sizeof(float));
  1369. strcpy(filename,"c:\shlaplac.bmp");
  1370. break;
  1371. case TEMPLATE_SOBEL_H:
  1372. coef=(float)1.0;
  1373. memcpy(CoefArray,Template_HSobel,9*sizeof(float));
  1374. strcpy(filename,"c:\hsobel.bmp");
  1375. break;
  1376. case TEMPLATE_SOBEL_V:
  1377. coef=(float)1.0;
  1378. memcpy(CoefArray,Template_VSobel,9*sizeof(float));
  1379. strcpy(filename,"c:\vsobel.bmp");
  1380. break;
  1381. case TEMPLATE_ISOSOBEL_H:
  1382. coef=(float)1.0;
  1383. memcpy(CoefArray,Template_HIsoSobel,9*sizeof(float));
  1384. strcpy(filename,"c:\hisobel.bmp");
  1385. break;
  1386. case TEMPLATE_ISOSOBEL_V:
  1387. coef=(float)1.0;
  1388. memcpy(CoefArray,Template_VIsoSobel,9*sizeof(float));
  1389. strcpy(filename,"c:\visobel.bmp");
  1390. break;
  1391. }
  1393. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1394. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1396. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1397.     {
  1398.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1399.         return FALSE;
  1400.     }
  1402.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1403. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1405. lpPtr=(char *)lpImgData;
  1406. lpTempPtr=(char *)lpTempImgData;
  1408. memcpy(lpTempPtr,lpPtr,BufSize);
  1410. for(y=1;y<bi.biHeight-1;y++)
  1411. for(x=1;x<bi.biWidth-1;x++){
  1412. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes)+x;
  1413. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes)+x;
  1414. TempNum=(float)((unsigned char)*(lpPtr+LineBytes-1))*CoefArray[0];
  1415. TempNum+=(float)((unsigned char)*(lpPtr+LineBytes))*CoefArray[1];
  1416. TempNum+=(float)((unsigned char)*(lpPtr+LineBytes+1))*CoefArray[2];
  1417. TempNum+=(float)((unsigned char)*(lpPtr-1))*CoefArray[3];
  1418. TempNum+=(float)((unsigned char)*lpPtr)*CoefArray[4];
  1419. TempNum+=(float)((unsigned char)*(lpPtr+1))*CoefArray[5];
  1420. TempNum+=(float)((unsigned char)*(lpPtr-LineBytes-1))*CoefArray[6];
  1421. TempNum+=(float)((unsigned char)*(lpPtr-LineBytes))*CoefArray[7];
  1422. TempNum+=(float)((unsigned char)*(lpPtr-LineBytes+1))*CoefArray[8];
  1423. TempNum*=coef;
  1424. if(TempNum>255.0) *lpTempPtr=(BYTE)255;
  1425. else if(TempNum<0.0) 
  1426. *lpTempPtr=(unsigned char)fabs(TempNum);
  1427. else *lpTempPtr=(BYTE)TempNum;
  1428. }
  1430. hDc=GetDC(hWnd);
  1431.     if(hBitmap!=NULL)
  1432.     DeleteObject(hBitmap);
  1434. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1435. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1436.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1438. hf=_lcreat(filename,0);
  1439. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1440. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1441. _lclose(hf);
  1443.   ReleaseDC(hWnd,hDc);
  1444. LocalUnlock(hTempImgData);
  1445. LocalFree(hTempImgData);
  1446. GlobalUnlock(hImgData);
  1447. return TRUE;
  1448. }
  1449. ////////////////////////////////////////////////////////////////
  1450. BOOL ColortoGrayScale(HWND hWnd)
  1451. {
  1452. DWORD              SrcBufSize,DstBufSize,DstLineBytes;
  1453.     LPBITMAPINFOHEADER lpImgData;
  1454. LPSTR              lpPtr;
  1455. HLOCAL             hTempImgData;
  1456. LPBITMAPINFOHEADER lpTempImgData;
  1457. LPSTR              lpTempPtr;
  1458. HDC                hDc;
  1459. HFILE              hf;
  1460. LONG               x,y;
  1461. BITMAPFILEHEADER   DstBf;
  1462. BITMAPINFOHEADER   DstBi;
  1463.     LOGPALETTE         *pPal;
  1464.     HPALETTE           hPrevPalette; 
  1465. HLOCAL             hPal;
  1466. DWORD    NewNumColors;
  1467. WORD    NewBitCount;
  1468. float              Y;
  1469. DWORD              i;
  1470. unsigned char      Red,Green,Blue,Gray;
  1472. NewNumColors=NumColors;
  1473. NewBitCount=bi.biBitCount;
  1474. if(NumColors==0) //true color
  1475. {
  1476. NewNumColors=256;
  1477. NewBitCount=8;
  1478. }
  1480. DstLineBytes=(DWORD)WIDTHBYTES(bi.biWidth*NewBitCount);
  1481. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NewNumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*bi.biHeight);
  1482. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  1483. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  1484. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  1485. DstBf.bfOffBits=(DWORD)(NewNumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  1486. +sizeof(BITMAPINFOHEADER));
  1487. DstBi.biClrUsed=0;
  1488. DstBi.biBitCount=NewBitCount;
  1490. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1492. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  1493.     {
  1494.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1495.         return FALSE;
  1496.     }
  1498.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1499. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1501. //copy image data
  1502. memcpy(lpTempImgData,lpImgData,DstBufSize);
  1503. //overwrite bitmapinfoheader with the new one
  1504. memcpy(lpTempImgData,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  1506. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  1507. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1509.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NewNumColors* sizeof(PALETTEENTRY));
  1510.     pPal =(LOGPALETTE *)LocalLock(hPal);
  1511.     pPal->palNumEntries =(WORD) NewNumColors;
  1512. pPal->palVersion    = 0x300;
  1514. if(NumColors==0) //true color
  1515. for (i = 0; i < 256; i++) {
  1516.       pPal->palPalEntry[i].peRed=(BYTE)i;
  1517. pPal->palPalEntry[i].peGreen=(BYTE)i;
  1518. pPal->palPalEntry[i].peBlue=(BYTE)i;
  1519. pPal->palPalEntry[i].peFlags=(BYTE)0;
  1520. *(lpTempPtr++)=(unsigned char)i;
  1521. *(lpTempPtr++)=(unsigned char)i;
  1522. *(lpTempPtr++)=(unsigned char)i;
  1523. *(lpTempPtr++)=0;
  1524. }
  1525. else 
  1526. for (i = 0; i < NewNumColors; i++) {
  1527. Blue=(unsigned char )(*lpPtr++);
  1528. Green=(unsigned char )(*lpPtr++);
  1529. Red=(unsigned char )(*lpPtr++);
  1530. Y=(float)(Red*0.299+Green*0.587+Blue*0.114);
  1531. Gray=(BYTE)Y;
  1532. lpPtr++;
  1533.       pPal->palPalEntry[i].peRed=Gray;
  1534. pPal->palPalEntry[i].peGreen=Gray;
  1535. pPal->palPalEntry[i].peBlue=Gray;
  1536. pPal->palPalEntry[i].peFlags=0;
  1537. *(lpTempPtr++)=(unsigned char)Gray;
  1538. *(lpTempPtr++)=(unsigned char)Gray;
  1539. *(lpTempPtr++)=(unsigned char)Gray;
  1540. *(lpTempPtr++)=0;
  1541. }
  1543. if(hPalette!=NULL)                     
  1544.         DeleteObject(hPalette);
  1546. hPalette=CreatePalette(pPal);
  1547. LocalUnlock(hPal);
  1548. LocalFree(hPal);
  1550. hDc=GetDC(hWnd);
  1551. if(hPalette){
  1552.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1553. RealizePalette(hDc);
  1554. }
  1556. if(NumColors==0)
  1557. for(y=0;y<bi.biHeight;y++){
  1558. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  1559. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y*DstLineBytes);
  1560. for(x=0;x<bi.biWidth;x++){
  1561. Blue=(unsigned char )(*lpPtr++);
  1562. Green=(unsigned char )(*lpPtr++);
  1563. Red=(unsigned char )(*lpPtr++);
  1564. Y=(float)(Red*0.299+Green*0.587+Blue*0.114);
  1565. Gray=(BYTE)Y;
  1566. *(lpTempPtr++)=(unsigned char)Gray;
  1567. }
  1568. }
  1570.     if(hBitmap!=NULL)
  1571.     DeleteObject(hBitmap);
  1573. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1574. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NewNumColors*sizeof(RGBQUAD),
  1575.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1577. if(hPalette && hPrevPalette){
  1578. SelectPalette(hDc,hPrevPalette,FALSE);
  1579. RealizePalette(hDc);
  1580. }
  1582.     hf=_lcreat("c:\gray.bmp",0);
  1583. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  1584. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  1585. _lclose(hf);
  1587.   ReleaseDC(hWnd,hDc);
  1588. LocalUnlock(hTempImgData);
  1589. LocalFree(hTempImgData);
  1590. GlobalUnlock(hImgData);
  1591. return TRUE;
  1592. }
  1593. ////////////////////////////////////////////////////////////////
  1594. BOOL Invert(HWND hWnd)
  1595. {
  1596. DWORD              BufSize;
  1597.     LPBITMAPINFOHEADER lpImgData;
  1598. LPSTR              lpPtr;
  1599. HLOCAL             hTempImgData;
  1600. LPBITMAPINFOHEADER lpTempImgData;
  1601. LPSTR              lpTempPtr;
  1602. HDC                hDc;
  1603. HFILE              hf;
  1604. LONG               x,y;
  1605.     LOGPALETTE         *pPal;
  1606.     HPALETTE           hPrevPalette=NULL; 
  1607. HLOCAL             hPal;
  1608. DWORD              i;
  1609. unsigned char      Red,Green,Blue;
  1611. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1613. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1614.     {
  1615.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1616.         return FALSE;
  1617.     }
  1619.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1620. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1622. //copy image data
  1623. memcpy(lpTempImgData,lpImgData,BufSize);
  1625. hDc=GetDC(hWnd);
  1626. if(NumColors!=0){
  1627. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  1628. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  1629.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  1630. pPal =(LOGPALETTE *)LocalLock(hPal);
  1631. pPal->palNumEntries =(WORD) NumColors;
  1632. pPal->palVersion    = 0x300;
  1633. for (i = 0; i < NumColors; i++) {
  1634. Blue=(unsigned char )(*lpPtr++);
  1635. Green=(unsigned char )(*lpPtr++);
  1636. Red=(unsigned char )(*lpPtr++);
  1637. lpPtr++;
  1638.       pPal->palPalEntry[i].peRed=(BYTE)(255-Red);
  1639. pPal->palPalEntry[i].peGreen=(BYTE)(255-Green);
  1640. pPal->palPalEntry[i].peBlue=(BYTE)(255-Blue);
  1641. pPal->palPalEntry[i].peFlags=0;
  1642. *(lpTempPtr++)=(unsigned char)(255-Blue);
  1643. *(lpTempPtr++)=(unsigned char)(255-Green);
  1644. *(lpTempPtr++)=(unsigned char)(255-Red);
  1645. *(lpTempPtr++)=0;
  1646. }
  1648. if(hPalette!=NULL)                     
  1649. DeleteObject(hPalette);
  1650. hPalette=CreatePalette(pPal);
  1651. LocalUnlock(hPal);
  1652. LocalFree(hPal);
  1653. if(hPalette){
  1654. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  1655. RealizePalette(hDc);
  1656. }
  1657. }
  1658. else{
  1659. for(y=0;y<bi.biHeight;y++){
  1660. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1661. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  1662. for(x=0;x<bi.biWidth;x++){
  1663. Blue=(unsigned char )(*lpPtr++);
  1664. Green=(unsigned char )(*lpPtr++);
  1665. Red=(unsigned char )(*lpPtr++);
  1666. *(lpTempPtr++)=(unsigned char)(255-Blue);
  1667. *(lpTempPtr++)=(unsigned char)(255-Green);
  1668. *(lpTempPtr++)=(unsigned char)(255-Red);
  1669. }
  1670. }
  1671. }
  1673.     if(hBitmap!=NULL)
  1674.     DeleteObject(hBitmap);
  1676. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1677. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1678.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1680. if(hPalette && hPrevPalette){
  1681. SelectPalette(hDc,hPrevPalette,FALSE);
  1682. RealizePalette(hDc);
  1683. }
  1685.     hf=_lcreat("c:\invert.bmp",0);
  1686. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1687. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1688. _lclose(hf);
  1690.   ReleaseDC(hWnd,hDc);
  1691. LocalUnlock(hTempImgData);
  1692. LocalFree(hTempImgData);
  1693. GlobalUnlock(hImgData);
  1694. return TRUE;
  1695. }
  1696. ////////////////////////////////////////////////////////////////
  1697. BOOL LimbPatternM3(HWND hWnd)
  1698. {
  1699. DWORD              BufSize;
  1700.     LPBITMAPINFOHEADER lpImgData;
  1701. LPSTR              lpPtr;
  1702. HLOCAL             hTempImgData;
  1703. LPBITMAPINFOHEADER lpTempImgData;
  1704. LPSTR              lpTempPtr;
  1705. HDC                hDc;
  1706. HFILE              hf;
  1707. LONG               x,y;
  1708. unsigned char      num;
  1710. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1712. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1713.     {
  1714.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1715.         return FALSE;
  1716.     }
  1718.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1719. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1721. //copy image data
  1722. memcpy(lpTempImgData,lpImgData,BufSize);
  1724. for(y=0;y<bi.biHeight;y++){
  1725. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1726. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  1727. for(x=0;x<bi.biWidth;x++){
  1728. num=(unsigned char)*lpPtr++;
  1729. if ( (num>>2) > BayerPattern[y&7][x&7])
  1730. *(lpTempPtr++)=(unsigned char)255;
  1731. else *(lpTempPtr++)=(unsigned char)0;
  1732. }
  1733. }
  1735.     if(hBitmap!=NULL)
  1736.     DeleteObject(hBitmap);
  1737. hDc=GetDC(hWnd);
  1738. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1739. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1740.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1742.     hf=_lcreat("c:\limbm3.bmp",0);
  1743. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1744. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1745. _lclose(hf);
  1747.   ReleaseDC(hWnd,hDc);
  1748. LocalUnlock(hTempImgData);
  1749. LocalFree(hTempImgData);
  1750. GlobalUnlock(hImgData);
  1751. return TRUE;
  1752. }
  1753. ////////////////////////////////////////////////////////////////
  1754. BOOL LimbPatternM4(HWND hWnd)
  1755. {
  1756. DWORD              BufSize;
  1757.     LPBITMAPINFOHEADER lpImgData;
  1758. LPSTR              lpPtr;
  1759. HLOCAL             hTempImgData;
  1760. LPBITMAPINFOHEADER lpTempImgData;
  1761. LPSTR              lpTempPtr;
  1762. HDC                hDc;
  1763. HFILE              hf;
  1764. LONG               x,y;
  1765. DWORD              i,j;
  1766. unsigned char      num;
  1767. BYTE    M4Pattern[16][16];
  1769. for(i=0;i<8;i++)
  1770. for(j=0;j<8;j++)
  1771. M4Pattern[i][j]=4*BayerPattern[i][j];
  1773. for(i=8;i<16;i++)
  1774. for(j=0;j<8;j++)
  1775. M4Pattern[i][j]=4*BayerPattern[i-8][j]+2;
  1777. for(i=0;i<8;i++)
  1778. for(j=8;j<16;j++)
  1779. M4Pattern[i][j]=4*BayerPattern[i][j-8]+3;
  1781. for(i=8;i<16;i++)
  1782. for(j=8;j<16;j++)
  1783. M4Pattern[i][j]=4*BayerPattern[i-8][j-8]+1;
  1785. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1787. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1788.     {
  1789.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1790.         return FALSE;
  1791.     }
  1793.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1794. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1796. //copy image data
  1797. memcpy(lpTempImgData,lpImgData,BufSize);
  1799. for(y=0;y<bi.biHeight;y++){
  1800. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1801. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  1802. for(x=0;x<bi.biWidth;x++){
  1803. num=(unsigned char)*lpPtr++;
  1804. if ( num > M4Pattern[y&15][x&15])
  1805. *(lpTempPtr++)=(unsigned char)255;
  1806. else *(lpTempPtr++)=(unsigned char)0;
  1807. }
  1808. }
  1810.     if(hBitmap!=NULL)
  1811.     DeleteObject(hBitmap);
  1812. hDc=GetDC(hWnd);
  1813. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1814. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1815.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1817.     hf=_lcreat("c:\limbm4.bmp",0);
  1818. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1819. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1820. _lclose(hf);
  1822.   ReleaseDC(hWnd,hDc);
  1823. LocalUnlock(hTempImgData);
  1824. LocalFree(hTempImgData);
  1825. GlobalUnlock(hImgData);
  1826. return TRUE;
  1827. }
  1828. ////////////////////////////////////////////////////////////////
  1829. BOOL Steinberg(HWND hWnd)
  1830. {
  1831. DWORD              OffBits,BufSize,IntBufSize;
  1832.     LPBITMAPINFOHEADER lpImgData;
  1833. HLOCAL             hTempImgData;
  1834. LPBITMAPINFOHEADER lpTempImgData;
  1835. LPSTR              lpPtr;
  1836. LPSTR              lpTempPtr;
  1837. HDC                hDc;
  1838. HFILE              hf;
  1839. LONG               x,y;
  1840. unsigned char      num;
  1841. float              e,f;
  1842. HLOCAL             hIntBuf;
  1843. int                *lpIntBuf,*lpIntPtr;
  1844. int                tempnum;
  1846. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1847. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1849. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  1850.     {
  1851.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1852.         return FALSE;
  1853.     }
  1855. IntBufSize=(DWORD)bi.biHeight*LineBytes*sizeof(int);
  1856. if((hIntBuf=LocalAlloc(LHND,IntBufSize))==NULL)
  1857.     {
  1858.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  1859. LocalFree(hTempImgData);
  1860.         return FALSE;
  1861.     }
  1863.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  1864. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  1865. lpIntBuf=(int *)LocalLock(hIntBuf);
  1867. //copy header data
  1868. memcpy(lpTempImgData,lpImgData,OffBits);
  1870. //copy image data to int buffer
  1871. for(y=0;y<bi.biHeight;y++){
  1872. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  1873. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes;
  1874. for(x=0;x<bi.biWidth;x++)
  1875. *(lpIntPtr++)=(unsigned char)*(lpPtr++);
  1876. }
  1878. for(y=0;y<bi.biHeight;y++){  
  1879. for(x=0;x<bi.biWidth;x++){
  1880. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes+x;
  1881. num=(unsigned char)*lpIntPtr;
  1882. if ( num > 128 ){
  1883. *lpIntPtr=255;
  1884. e=(float)(num-255.0);
  1885. }
  1886. else{
  1887. *lpIntPtr=0;
  1888. e=(float)num;
  1889. }
  1890. if(x<bi.biWidth-1){
  1891. f=(float)*(lpIntPtr+1);
  1892. f+=(float)( (3.0/8.0) * e);
  1893. *(lpIntPtr+1)=(int)f;
  1894. }
  1896. if(y<bi.biHeight-1){
  1897. f=(float)*(lpIntPtr-LineBytes);
  1898. f+=(float)( (3.0/8.0) * e);
  1899. *(lpIntPtr-LineBytes)=(int)f;
  1901. f=(float)*(lpIntPtr-LineBytes+1);
  1902. f+=(float)( (1.0/4.0) * e);
  1903. *(lpIntPtr-LineBytes+1)=(int)f;
  1904. }
  1905. }
  1906. }
  1908. //copy new image data from int buffer
  1909. for(y=0;y<bi.biHeight;y++){
  1910. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  1911. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes;
  1912. for(x=0;x<bi.biWidth;x++){
  1913. tempnum=*(lpIntPtr++);
  1914. if(tempnum>255) tempnum=255;
  1915. else if (tempnum<0) tempnum=0;
  1916. *(lpTempPtr++)=(unsigned char)tempnum;
  1917. }
  1918. }
  1920.     if(hBitmap!=NULL)
  1921.     DeleteObject(hBitmap);
  1922. hDc=GetDC(hWnd);
  1923. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  1924. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  1925.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  1927.     hf=_lcreat("c:\steinberg.bmp",0);
  1928. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  1929. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  1930. _lclose(hf);
  1932.   ReleaseDC(hWnd,hDc);
  1933. GlobalUnlock(hImgData);
  1934. LocalUnlock(hTempImgData);
  1935. LocalFree(hTempImgData);
  1936. LocalUnlock(hIntBuf);
  1937. LocalFree(hIntBuf);
  1938. return TRUE;
  1939. }
  1940. ////////////////////////////////////////////////////////////////
  1941. BOOL Bmp2Txt(HWND hWnd)
  1942. {
  1943. DWORD              OffBits,BufSize;
  1944.     LPBITMAPINFOHEADER lpImgData;
  1945. LPSTR              lpPtr;
  1946. HFILE              hf;
  1947. int    i, j, k,h,tint,grayindex;
  1948. char               tchar;
  1949. int                TransHeight, TransWidth;
  1951. for(i=0;i<94;i++)
  1952. for(j=i+1;j<95;j++){
  1953. if(gr[i]>gr[j]){
  1954. tchar=ch[i],tint=gr[i];
  1955. ch[i]=ch[j],gr[i]=gr[j];
  1956. ch[j]=tchar,gr[j]=tint;
  1957. }
  1958. }
  1960. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  1961. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  1962.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
  1963. TransWidth = bi.biWidth/8;
  1964. TransHeight = bi.biHeight/16;
  1965.     hf=_lcreat("c:\bmp2txt.txt",0);
  1967. for(i=0;i<TransHeight;i++){
  1968. for(j=0;j<TransWidth;j++){
  1969. grayindex=0;
  1970. for(k=0;k<16;k++)
  1971. for(h=0;h<8;h++){
  1972. lpPtr=(char *)lpImgData+BufSize-LineBytes-(i*16+k)*LineBytes+j*8+h;
  1973. grayindex+=(unsigned char)*lpPtr;
  1974. }
  1975. grayindex/=16*8;
  1976. grayindex=gr[94]*grayindex/255;
  1977. k=0;
  1978. while(gr[k+1]<grayindex)
  1979. k++;
  1980. _lwrite(hf,(char *)&ch[k],sizeof(char)); 
  1981. }
  1982. tchar=(char)13;
  1983. _lwrite(hf,(char *)&tchar,sizeof(char)); 
  1984. tchar=(char)10;
  1985. _lwrite(hf,(char *)&tchar,sizeof(char));
  1986. }
  1987. _lclose(hf);
  1988. GlobalUnlock(hImgData);
  1989. return TRUE;
  1990. }
  1991. ////////////////////////////////////////////////////////////////
  1992. BOOL Histogram(HWND hWnd)
  1993. {
  1994. DWORD              OffBits,BufSize;
  1995.     LPBITMAPINFOHEADER lpImgData;
  1996. LPSTR              lpPtr;
  1997. int    x,y;
  1998. int                grayindex;
  1999. HWND    hPopupWnd;
  2000. int                temp;
  2002. for(grayindex=0;grayindex<256;grayindex++)
  2003. GrayTable[grayindex]=0;
  2005. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  2006. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2007.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
  2009. for(y=0;y<bi.biHeight;y++){
  2010. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  2011. for(x=0;x<bi.biWidth;x++){
  2012. grayindex=(unsigned char)*(lpPtr++);
  2013. GrayTable[grayindex]++;
  2014. }
  2015. }
  2017. MaxGrayNum=0;
  2018. MinGrayNum=65535;
  2020. for(grayindex=0;grayindex<256;grayindex++){
  2021. temp=GrayTable[grayindex];
  2022. if(temp>MaxGrayNum)
  2023. MaxGrayNum=temp;
  2024. if( (temp<MinGrayNum) && (temp>0) )
  2025. MinGrayNum=temp;
  2026. }
  2028. GlobalUnlock(hImgData);
  2029.     hPopupWnd = CreateWindow (
  2030.   "PopupWindowClass",
  2031.   "Histogram Statistic Window",
  2032.        WS_OVERLAPPEDWINDOW,
  2033.        50,80,550,350,
  2034.        hWnd,NULL,ghInst,NULL
  2035.        );
  2036. if (hPopupWnd){
  2037. ShowWindow (hPopupWnd, SW_SHOW);
  2038.     UpdateWindow (hPopupWnd);
  2039.     }
  2040. return TRUE;
  2041. }
  2042. ////////////////////////////////////////////////////////////////
  2043. long FAR PASCAL PopupWndProc (HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
  2044. {
  2045. HDC  hdc;
  2046. PAINTSTRUCT  ps;   
  2047. DWORD   i;
  2048. int             xstart;   
  2049. static LOGPEN   blp={PS_SOLID,1,1,RGB(0,0,255)};
  2050. HPEN            bhp;
  2051. float           a,b,temp;
  2052. char            str[10];
  2054. a=(float)(265.0 /( MaxGrayNum - MinGrayNum) );
  2055. b=(float) (270.0-a* MaxGrayNum);
  2056.     switch (message)
  2057.      {
  2058.     case WM_PAINT:
  2059.         hdc = BeginPaint(hWnd, &ps);
  2060.     bhp = CreatePenIndirect(&blp);
  2061. SelectObject(hdc,bhp);
  2062.         MoveToEx(hdc,2,270,NULL);
  2063.         LineTo(hdc,518,270);
  2064.         xstart=2;
  2065.         for(i=0;i<256;i++){
  2066.          MoveToEx(hdc,xstart,270,NULL);
  2067. if (GrayTable[i]!=0) 
  2068. temp=(float)(a*GrayTable[i]+b);
  2069. else temp=0.0f;
  2070.          LineTo(hdc,xstart,270-(int)temp);
  2071. if (i%16 ==0){
  2072.          MoveToEx(hdc,xstart,270,NULL);
  2073.          LineTo(hdc,xstart,280);
  2074. _itoa(i,str,10);
  2075. TextOut(hdc,xstart,285,str,strlen(str));
  2076. }
  2077.          xstart+=2;
  2078.         }
  2079.     MoveToEx(hdc,xstart,270,NULL);
  2080.     LineTo(hdc,xstart,280);
  2081. TextOut(hdc,xstart,285,"256",strlen("256"));
  2082.         EndPaint(hWnd,&ps);
  2083.         DeleteObject(bhp);
  2084.         break;
  2085.     default:
  2086.      break;
  2087.      }
  2088.     return DefWindowProc (hWnd, message, wParam, lParam);
  2089. }
  2090. ////////////////////////////////////////////////////////////////
  2091. BOOL Trueto256(HWND hWnd)
  2092. {
  2093. DWORD              SrcBufSize,OffBits,DstBufSize,DstLineBytes;
  2094.     LPBITMAPINFOHEADER lpImgData;
  2095. LPSTR              lpPtr;
  2096. HLOCAL             hTempImgData;
  2097. LPBITMAPINFOHEADER lpTempImgData;
  2098. LPSTR              lpTempPtr;
  2099. HDC                hDc;
  2100. HFILE              hf;
  2101. LONG               x,y;
  2102. BITMAPFILEHEADER   DstBf;
  2103. BITMAPINFOHEADER   DstBi;
  2104.     LOGPALETTE         *pPal;
  2105.     HPALETTE           hPrevPalette; 
  2106. HLOCAL             hPal;
  2107. WORD               i,j;
  2108. int    Red,Green,Blue,ClrIndex;
  2109. DWORD              ColorHits[4096];
  2110. WORD               ColorIndex[4096];
  2111. DWORD              PalCounts,temp;
  2112. long    ColorError1,ColorError2;
  2114. if(NumColors!=0){
  2115.      MessageBox(hWnd,"Must be a true color bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2116.         return FALSE;
  2117.     }
  2119. DstLineBytes=(DWORD)WIDTHBYTES(bi.biWidth*8);
  2120. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+256*sizeof(RGBQUAD)+(DWORD)DstLineBytes*bi.biHeight);
  2121. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  2122. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  2123. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  2124. DstBf.bfOffBits=(DWORD)(256*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  2125. +sizeof(BITMAPINFOHEADER));
  2126. DstBi.biClrUsed=0;
  2127. DstBi.biBitCount=8;
  2129. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  2130. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2132. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  2133.     {
  2134.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2135.         return FALSE;
  2136.     }
  2138.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  2139. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  2141. //copy image data
  2142. memcpy(lpTempImgData,lpImgData,OffBits);
  2143. //overwrite bitmapinfoheader with the new one
  2144. memcpy(lpTempImgData,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  2146. memset(ColorHits,0,4096*sizeof(DWORD));
  2147. memset(ColorIndex,0,4096*sizeof(WORD));
  2148. for(y=0;y<bi.biHeight;y++){
  2149. lpPtr=(unsigned char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  2150. for(x=0;x<bi.biWidth;x++){
  2151. Blue=(int)(*(lpPtr++) & 0xf0);
  2152. Green=(int)(*(lpPtr++) & 0xf0);
  2153. Red=(int)(*(lpPtr++) & 0xf0);
  2154. ClrIndex=(Blue<<4) + Green +(Red >>4);
  2155. ColorHits[ClrIndex]++;
  2156. }
  2157. }
  2159. PalCounts=0;
  2160. //pack the color table
  2161.     for (ClrIndex = 0; ClrIndex < 4096; ClrIndex++)
  2162.     {
  2163. if(ColorHits[ClrIndex]!=0){
  2164. ColorHits[PalCounts]=ColorHits[ClrIndex];
  2165. ColorIndex[PalCounts]=ClrIndex;
  2166. PalCounts++;
  2167. }
  2168. }
  2169.     //sort the color table downsize
  2170.     for (i = 0; i < PalCounts-1; i++)
  2171. for (j = i + 1; j < PalCounts; j++){
  2172. if (ColorHits[j] > ColorHits[i]){
  2173. temp = ColorHits[i];
  2174. ColorHits[i] = ColorHits[j];
  2175. ColorHits[j] = temp;  
  2176.             temp = ColorIndex[i];
  2177.         ColorIndex[i] = ColorIndex[j];
  2178.     ColorIndex[j] = (WORD)temp;
  2179. }
  2180. }
  2182.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + 256* sizeof(PALETTEENTRY));
  2183.     pPal =(LOGPALETTE *)LocalLock(hPal);
  2184.     pPal->palNumEntries =(WORD) 256;
  2185. pPal->palVersion    = 0x300;
  2187. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  2188. for (i = 0; i < 256; i++) {
  2189.     pPal->palPalEntry[i].peRed=(BYTE)((ColorIndex[i] & 0x00f) << 4);
  2190. pPal->palPalEntry[i].peGreen=(BYTE)((ColorIndex[i] & 0x0f0));
  2191. pPal->palPalEntry[i].peBlue=(BYTE)((ColorIndex[i] & 0xf00) >> 4);
  2192. pPal->palPalEntry[i].peFlags=(BYTE)0;
  2193. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0xf00) >> 4);
  2194. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0x0f0));
  2195. *(lpTempPtr++)=(unsigned char)((ColorIndex[i] & 0x00f) << 4);
  2196. *(lpTempPtr++)=0;
  2197. ColorHits[i]=i;
  2198. }
  2200. //其余的颜色依据最小平方差近似为前256中最接近的一种
  2201.     if (PalCounts > 256){
  2202. for (i = 256; i < PalCounts; i++){
  2203. ColorError1=1000000000;
  2204. Blue = (long)((ColorIndex[i] & 0xf00) >> 4);
  2205. Green = (long)((ColorIndex[i] & 0x0f0));
  2206. Red = (long)((ColorIndex[i] & 0x00f) << 4);
  2207. ClrIndex = 0;
  2208. for (j = 0; j < 256; j++){
  2209. ColorError2=(long)(Blue-pPal->palPalEntry[j].peBlue)*(Blue-pPal->palPalEntry[j].peBlue)+ 
  2210.                         (long)(Green-pPal->palPalEntry[j].peGreen)*(Green-pPal->palPalEntry[j].peGreen)+
  2211.                         (long)(Red-pPal->palPalEntry[j].peRed)*(Red-pPal->palPalEntry[j].peRed); 
  2212.                 if (ColorError2 < ColorError1){
  2213. ColorError1 = ColorError2;
  2214. ClrIndex = j;
  2215.                 }
  2216. }                        
  2217. ColorHits[i] = ClrIndex;
  2218. }
  2219. }                
  2221. if(hPalette!=NULL)                     
  2222.         DeleteObject(hPalette);
  2224. //create new logic palette
  2225. hPalette=CreatePalette(pPal);
  2226. LocalUnlock(hPal);
  2227. LocalFree(hPal);
  2229. hDc=GetDC(hWnd);
  2230. if(hPalette){
  2231.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  2232. RealizePalette(hDc);
  2233. }
  2235. for(y=0;y<bi.biHeight;y++){
  2236. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y*LineBytes);
  2237. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y*DstLineBytes);
  2238. for(x=0;x<bi.biWidth;x++){
  2239. Blue=(int)(*(lpPtr++) & 0xf0);
  2240. Green=(int)(*(lpPtr++) & 0xf0);
  2241. Red=(int)(*(lpPtr++) & 0xf0);
  2242. ClrIndex=(Blue<<4) + Green +(Red >>4);
  2243.             for (i = 0; i < PalCounts;i++)
  2244. if (ClrIndex == ColorIndex[i]){
  2245. *(lpTempPtr++)=(unsigned char)ColorHits[i];
  2246.                     break;
  2247. }
  2248. }
  2249. }
  2251.     if(hBitmap!=NULL)
  2252.     DeleteObject(hBitmap);
  2254. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  2255. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +256*sizeof(RGBQUAD),
  2256.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  2258. if(hPalette && hPrevPalette){
  2259. SelectPalette(hDc,hPrevPalette,FALSE);
  2260. RealizePalette(hDc);
  2261. }
  2263.     hf=_lcreat("c:\256.bmp",0);
  2264. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  2265. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  2266. _lclose(hf);
  2268.   ReleaseDC(hWnd,hDc);
  2269. LocalUnlock(hTempImgData);
  2270. LocalFree(hTempImgData);
  2271. GlobalUnlock(hImgData);
  2272. return TRUE;
  2273. }
  2274. ////////////////////////////////////////////////////////////////
  2275. BOOL ContrastStretch(HWND hWnd)
  2276. {
  2277. DLGPROC            dlgInputBox = NULL;
  2278. DWORD              BufSize;
  2279.     LPBITMAPINFOHEADER lpImgData;
  2280. LPSTR              lpPtr;
  2281. HLOCAL             hTempImgData;
  2282. LPBITMAPINFOHEADER lpTempImgData;
  2283. LPSTR              lpTempPtr;
  2284. HDC                hDc;
  2285. HFILE              hf;
  2286.     LOGPALETTE         *pPal;
  2287.     HPALETTE           hPrevPalette=NULL; 
  2288. HLOCAL             hPal;
  2289. DWORD              i;
  2290. unsigned char      Gray;
  2291. float              a,g1,g2,g;
  2293. if( NumColors!=256){
  2294.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2295.         return FALSE;
  2296.     }
  2298. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  2299. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  2300. FreeProcInstance ( (FARPROC) dlgInputBox );
  2302. if( StretchRatio*(SecondPoint-FirstPoint) > 255.0){
  2303.      MessageBox(hWnd,"StretchRatio*(SecondPoint-FirstPoint)  can not be larger than 255!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2304.         return FALSE;
  2305.     }
  2306. if( (SecondPoint-FirstPoint) >=255){
  2307.      MessageBox(hWnd,"The area you selected can not be the whole scale!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2308.         return FALSE;
  2309.     }
  2310. a=(float)((255.0-StretchRatio*(SecondPoint-FirstPoint))/(255.0-(SecondPoint-FirstPoint))); 
  2311. g1=a*FirstPoint;
  2312. g2=StretchRatio*(SecondPoint-FirstPoint)+g1;
  2314. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2316. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  2317.     {
  2318.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2319.         return FALSE;
  2320.     }
  2322.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  2323. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  2325. //copy image data
  2326. memcpy(lpTempImgData,lpImgData,BufSize);
  2328. hDc=GetDC(hWnd);
  2330. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  2331. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  2332. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  2333. pPal =(LOGPALETTE *)LocalLock(hPal);
  2334. pPal->palNumEntries =(WORD) NumColors;
  2335. pPal->palVersion    = 0x300;
  2336. for (i = 0; i < 256; i++) {
  2337. Gray=(unsigned char )*lpPtr;
  2338. lpPtr+=4;
  2339. if(Gray<FirstPoint) g=(float)(a*Gray);
  2340. else if (Gray<SecondPoint) g=g1+StretchRatio*(Gray-FirstPoint);
  2341. else g=g2+a*(Gray-SecondPoint);
  2342.     pPal->palPalEntry[i].peRed=(BYTE)g;
  2343. pPal->palPalEntry[i].peGreen=(BYTE)g;
  2344. pPal->palPalEntry[i].peBlue=(BYTE)g;
  2345. pPal->palPalEntry[i].peFlags=0;
  2346. *(lpTempPtr++)=(unsigned char)g;
  2347. *(lpTempPtr++)=(unsigned char)g;
  2348. *(lpTempPtr++)=(unsigned char)g;
  2349. *(lpTempPtr++)=0;
  2350. }
  2352. if(hPalette!=NULL)                     
  2353. DeleteObject(hPalette);
  2354. hPalette=CreatePalette(pPal);
  2355. LocalUnlock(hPal);
  2356. LocalFree(hPal);
  2357. if(hPalette){
  2358. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  2359. RealizePalette(hDc);
  2360. }
  2362.     if(hBitmap!=NULL)
  2363.     DeleteObject(hBitmap);
  2365. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  2366. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  2367.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  2369. if(hPalette && hPrevPalette){
  2370. SelectPalette(hDc,hPrevPalette,FALSE);
  2371. RealizePalette(hDc);
  2372. }
  2374.     hf=_lcreat("c:\stretch.bmp",0);
  2375. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  2376. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  2377. _lclose(hf);
  2379.   ReleaseDC(hWnd,hDc);
  2380. LocalUnlock(hTempImgData);
  2381. LocalFree(hTempImgData);
  2382. GlobalUnlock(hImgData);
  2383. return TRUE;
  2384. }
  2385. ////////////////////////////////////////////////////////////////
  2386. BOOL Cliping(HWND hWnd)
  2387. {
  2388. DLGPROC            dlgInputBox = NULL;
  2389. DWORD              BufSize;
  2390.     LPBITMAPINFOHEADER lpImgData;
  2391. LPSTR              lpPtr;
  2392. HLOCAL             hTempImgData;
  2393. LPBITMAPINFOHEADER lpTempImgData;
  2394. LPSTR              lpTempPtr;
  2395. HDC                hDc;
  2396. HFILE              hf;
  2397.     LOGPALETTE         *pPal;
  2398.     HPALETTE           hPrevPalette=NULL; 
  2399. HLOCAL             hPal;
  2400. DWORD              i;
  2401. unsigned char      Gray;
  2402. float              a,g;
  2404. if( NumColors!=256){
  2405.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2406.         return FALSE;
  2407.     }
  2409. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  2410. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  2411. FreeProcInstance ( (FARPROC) dlgInputBox );
  2413. if( (SecondPoint-FirstPoint) >255){
  2414.      MessageBox(hWnd,"The area you selected must be within [0-255]!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2415.         return FALSE;
  2416.     }
  2417. a=(float)(255.0/(SecondPoint-FirstPoint)); 
  2419. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2421. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  2422.     {
  2423.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2424.         return FALSE;
  2425.     }
  2427.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  2428. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  2430. //copy image data
  2431. memcpy(lpTempImgData,lpImgData,BufSize);
  2433. hDc=GetDC(hWnd);
  2435. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  2436. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  2437. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  2438. pPal =(LOGPALETTE *)LocalLock(hPal);
  2439. pPal->palNumEntries =(WORD) NumColors;
  2440. pPal->palVersion    = 0x300;
  2441. for (i = 0; i < 256; i++) {
  2442. Gray=(unsigned char )*lpPtr;
  2443. lpPtr+=4;
  2444. if(Gray<FirstPoint) g=0.0f;
  2445. else if (Gray<SecondPoint) g=a*(Gray-FirstPoint);
  2446. else g=255.0f;
  2447.     pPal->palPalEntry[i].peRed=(BYTE)g;
  2448. pPal->palPalEntry[i].peGreen=(BYTE)g;
  2449. pPal->palPalEntry[i].peBlue=(BYTE)g;
  2450. pPal->palPalEntry[i].peFlags=0;
  2451. *(lpTempPtr++)=(unsigned char)g;
  2452. *(lpTempPtr++)=(unsigned char)g;
  2453. *(lpTempPtr++)=(unsigned char)g;
  2454. *(lpTempPtr++)=0;
  2455. }
  2457. if(hPalette!=NULL)                     
  2458. DeleteObject(hPalette);
  2459. hPalette=CreatePalette(pPal);
  2460. LocalUnlock(hPal);
  2461. LocalFree(hPal);
  2462. if(hPalette){
  2463. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  2464. RealizePalette(hDc);
  2465. }
  2467.     if(hBitmap!=NULL)
  2468.     DeleteObject(hBitmap);
  2470. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  2471. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  2472.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  2474. if(hPalette && hPrevPalette){
  2475. SelectPalette(hDc,hPrevPalette,FALSE);
  2476. RealizePalette(hDc);
  2477. }
  2479.     hf=_lcreat("c:\cliping.bmp",0);
  2480. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  2481. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  2482. _lclose(hf);
  2484.   ReleaseDC(hWnd,hDc);
  2485. LocalUnlock(hTempImgData);
  2486. LocalFree(hTempImgData);
  2487. GlobalUnlock(hImgData);
  2488. return TRUE;
  2489. }
  2490. ////////////////////////////////////////////////////////////////
  2491. BOOL Thresholding(HWND hWnd)
  2492. {
  2493. DLGPROC            dlgInputBox = NULL;
  2494. DWORD              BufSize;
  2495.     LPBITMAPINFOHEADER lpImgData;
  2496. LPSTR              lpPtr;
  2497. HLOCAL             hTempImgData;
  2498. LPBITMAPINFOHEADER lpTempImgData;
  2499. LPSTR              lpTempPtr;
  2500. HDC                hDc;
  2501. HFILE              hf;
  2502.     LOGPALETTE         *pPal;
  2503.     HPALETTE           hPrevPalette=NULL; 
  2504. HLOCAL             hPal;
  2505. DWORD              i;
  2506. unsigned char      Gray;
  2508. if( NumColors!=256){
  2509.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2510.         return FALSE;
  2511.     }
  2512. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  2513. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  2514. FreeProcInstance ( (FARPROC) dlgInputBox );
  2515. if( FirstPoint >255){
  2516.      MessageBox(hWnd,"The point you selected must be within [0-255]","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2517.         return FALSE;
  2518.     }
  2519. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2520. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  2521.     {
  2522.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2523.         return FALSE;
  2524.     }
  2525.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  2526. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  2527. //copy image data
  2528. memcpy(lpTempImgData,lpImgData,BufSize);
  2530. hDc=GetDC(hWnd);
  2532. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  2533. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  2534. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  2535. pPal =(LOGPALETTE *)LocalLock(hPal);
  2536. pPal->palNumEntries =(WORD) NumColors;
  2537. pPal->palVersion    = 0x300;
  2538. for (i = 0; i < 256; i++) {
  2539. Gray=(unsigned char )*lpPtr;
  2540. lpPtr+=4;
  2541. if(Gray<FirstPoint) Gray=0;
  2542. else Gray=255;
  2543.     pPal->palPalEntry[i].peRed=Gray;
  2544. pPal->palPalEntry[i].peGreen=Gray;
  2545. pPal->palPalEntry[i].peBlue=Gray;
  2546. pPal->palPalEntry[i].peFlags=0;
  2547. *(lpTempPtr++)=(unsigned char)Gray;
  2548. *(lpTempPtr++)=(unsigned char)Gray;
  2549. *(lpTempPtr++)=(unsigned char)Gray;
  2550. *(lpTempPtr++)=0;
  2551. }
  2553. if(hPalette!=NULL)                     
  2554. DeleteObject(hPalette);
  2555. hPalette=CreatePalette(pPal);
  2556. LocalUnlock(hPal);
  2557. LocalFree(hPal);
  2558. if(hPalette){
  2559. hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  2560. RealizePalette(hDc);
  2561. }
  2563.     if(hBitmap!=NULL)
  2564.     DeleteObject(hBitmap);
  2566. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  2567. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  2568.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  2570. if(hPalette && hPrevPalette){
  2571. SelectPalette(hDc,hPrevPalette,FALSE);
  2572. RealizePalette(hDc);
  2573. }
  2575.     hf=_lcreat("c:\threshold.bmp",0);
  2576. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  2577. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  2578. _lclose(hf);
  2580.   ReleaseDC(hWnd,hDc);
  2581. LocalUnlock(hTempImgData);
  2582. LocalFree(hTempImgData);
  2583. GlobalUnlock(hImgData);
  2584. return TRUE;
  2585. }
  2586. ////////////////////////////////////////////////////////////////
  2587. BOOL Slice(HWND hWnd,BOOL WithBack)
  2588. {
  2589. DLGPROC            dlgInputBox = NULL;
  2590. DWORD              BufSize;
  2591.     LPBITMAPINFOHEADER lpImgData;
  2592. LPSTR              lpPtr;
  2593. HLOCAL             hTempImgData;
  2594. LPBITMAPINFOHEADER lpTempImgData;
  2595. LPSTR              lpTempPtr;
  2596. HDC                hDc;
  2597. HFILE              hf;
  2598.     LOGPALETTE         *pPal;
  2599.     HPALETTE           hPrevPalette=NULL; 
  2600. HLOCAL             hPal;
  2601. DWORD              i;
  2602. unsigned char      Gray;
  2604. if( NumColors!=256){
  2605.      MessageBox(hWnd,"Must be a 256 grayscale bitmap!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2606.         return FALSE;
  2607.     }
  2608. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  2609. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  2610. FreeProcInstance ( (FARPROC) dlgInputBox );
  2612. if( (SecondPoint-FirstPoint) >255){
  2613.      MessageBox(hWnd,"The area you selected must be within [0-255]!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2614.         return FALSE;
  2615.     }
  2616. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  2617. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  2618.     {
  2619.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  2620.         return FALSE;
  2621.     }
  2622.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  2623. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  2624. //copy image data
  2625. memcpy(lpTempImgData,lpImgData,BufSize);
  2627. hDc=GetDC(hWnd);
  2628. lpPtr=(char *)lpImgData+sizeof(BITMAPINFOHEADER);
  2629. lpTempPtr=(char *)lpTempImgData+sizeof(BITMAPINFOHEADER);
  2630. hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  2631. pPal =(LOGPALETTE *)LocalLock(hPal);
  2632. pPal->palNumEntries =(WORD) NumColors;
  2633. pPal->palVersion    = 0x300;
  2634. for (i = 0; i < 256; i++) {
  2635. Gray=(unsigned char )*lpPtr;
  2636. lpPtr+=4;
  2637. if(WithBack){
  2638. if( (Gray>=FirstPoint) && (Gray<=SecondPoint))
  2639. Gray=255;
  2640. }
  2641. else{
  2642. if(Gray<FirstPoint) Gray=0;