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

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

图形图像处理

开发平台：

Visual C++

geotrans.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:geotrans.c
  3. //Purpose: To perform geometric transform
  4. //Author: phoenix, CS, TshingHua, Beijing, P.R.C.
  5. //Email: bjlufengjun@www.163.net or lufengjun@hotmail.com
  6. //Date:April 3, 1998
  8. //header file
  9. #include "bmp.h"
  10. #include "memory.h"
  11. #include "math.h"
  13. //macro definition
  14. #define WIDTHBYTES(i)    ((i+31)/32*4)
  15. #define PI 3.1415926535
  16. #define RADIAN(angle) ((angle)*PI/180.0) //convert angle to radian
  18. //function declaration
  19. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  20. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  21. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName);
  22. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam );
  23. BOOL Translation(HWND hWnd);
  24. BOOL Rotation(HWND hWnd);
  25. BOOL Mirror(HWND hWnd,BOOL XDirection);
  26. BOOL Transpose(HWND hWnd);
  27. BOOL Zoom(HWND hWnd);
  29. //global variable declaration
  30. BITMAPFILEHEADER   bf;
  31. BITMAPINFOHEADER   bi;
  32. HPALETTE           hPalette=NULL;
  33. HBITMAP            hBitmap=NULL;
  34. HGLOBAL            hImgData=NULL;
  35. DWORD              NumColors;
  36. DWORD              LineBytes;
  37. HWND               hWnd;
  38. HINSTANCE          ghInst;
  39. int                xOffset=0,yOffset=0;
  40. float    RotateAngle=0.0f;
  41. float              ZoomRatio=0.25f;
  42. DWORD              ImgWidth=0 , ImgHeight=0;
  43. ///////////////////////////////////////////////////////////
  44. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  45.     LPSTR lpszCmdLine, int nCmdShow)
  46. {
  47. MSG       msg;
  48. WNDCLASS  wndclass;
  50. ghInst=hInstance;
  51. if ( ! hPrevInstance ){
  52. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  53. wndclass.lpfnWndProc = MainWndProc;
  54. wndclass.cbClsExtra = 0;
  55. wndclass.cbWndExtra = 0;
  56. wndclass.hInstance = hInstance;
  57. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  58. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  59. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  60. wndclass.lpszMenuName =  "BMPMENU";
  61. wndclass.lpszClassName = "phoenix ip system";
  62.     }
  64.     if ( ! RegisterClass (&wndclass) )
  65.     return FALSE;
  66.  
  67. hWnd = CreateWindow ("phoenix ip system","geometric transform",
  68.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  69.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  70.  hInstance, NULL);
  71. if (!hWnd)
  72. return FALSE;
  73. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  74. UpdateWindow (hWnd);
  76. while ( GetMessage (&msg, NULL, 0, 0) ){
  77. TranslateMessage (&msg);
  78. DispatchMessage (&msg);
  79.     }
  80. return msg.wParam;
  81. }
  83. ////////////////////////////////////////////////////////////////
  84. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  85. {
  86.     static  HDC    hDC,hMemDC;
  87.     PAINTSTRUCT    ps;
  89.     switch (message){
  90.     case WM_PAINT:
  91. {         
  92. hDC = BeginPaint(hWnd, &ps);
  93. if (hBitmap)
  94. { 
  95. hMemDC = CreateCompatibleDC(hDC);
  96. if (hPalette)
  97. {           
  98. SelectPalette (hDC, hPalette, FALSE); 
  99. SelectPalette (hMemDC, hPalette, FALSE);
  100. RealizePalette (hDC);
  101. }   
  102. SelectObject(hMemDC, hBitmap); 
  103. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  104. DeleteDC(hMemDC);
  105. }
  106. EndPaint(hWnd, &ps);
  107. break;
  108. }
  109. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  110.         if(hBitmap!=NULL)
  111.         DeleteObject(hBitmap);
  112.     
  113. if(hPalette!=NULL)                     
  114.         DeleteObject(hPalette);
  116. if(hImgData!=NULL){
  117. GlobalUnlock(hImgData);
  118. GlobalFree(hImgData);
  119. }         
  120.     PostQuitMessage (0);
  121.     return 0;
  122. case WM_COMMAND:
  123.     switch (wParam){
  124.     case IDM_LOADBMP: 
  125. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  126.         if(hBitmap!=NULL){     
  127. DeleteObject(hBitmap);
  128.             hBitmap=NULL;
  129.         }
  130.         if(hPalette!=NULL){                     
  131. DeleteObject(hPalette);
  132.             hPalette=NULL;
  133.         }
  134. if(hImgData!=NULL){
  135. GlobalUnlock(hImgData);
  136. GlobalFree(hImgData);  
  137. hImgData=NULL;
  138. }         
  139. if(LoadBmpFile(hWnd,"c:\test.bmp")) //成功，则重画窗口
  140.                 InvalidateRect(hWnd,NULL,TRUE);
  141.         break;
  142. case IDM_TRANSLATION: 
  143. if(hImgData!=NULL){
  144. if(Translation(hWnd))
  145. InvalidateRect(hWnd,NULL,TRUE);
  146. }
  147. else
  148. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  149. break;
  150. case IDM_ROTATION: 
  151. if(hImgData!=NULL){
  152. if(Rotation(hWnd))
  153. InvalidateRect(hWnd,NULL,TRUE);
  154. }
  155. else
  156. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  157. break;
  158. case IDM_MIRRORX: 
  159. if(hImgData!=NULL){
  160. if(Mirror(hWnd,TRUE))
  161. InvalidateRect(hWnd,NULL,TRUE);
  162. }
  163. else
  164. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  165. break;
  166. case IDM_MIRRORY: 
  167. if(hImgData!=NULL){
  168. if(Mirror(hWnd,FALSE))
  169. InvalidateRect(hWnd,NULL,TRUE);
  170. }
  171. else
  172. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  173. break;
  174. case IDM_TRANSPOSE: 
  175. if(hImgData!=NULL){
  176. if(Transpose(hWnd))
  177. InvalidateRect(hWnd,NULL,TRUE);
  178. }
  179. else
  180. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  181. break;
  182. case IDM_ZOOM: 
  183. if(hImgData!=NULL){
  184. if(Zoom(hWnd))
  185. InvalidateRect(hWnd,NULL,TRUE);
  186. }
  187. else
  188. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  189. break;
  190. case IDM_EXIT:
  191.         SendMessage(hWnd,WM_DESTROY,0,0L);
  192.         break;
  193.     }
  194. break;                
  195.     }
  196.     return DefWindowProc (hWnd, message, wParam, lParam);
  197. }
  199. ////////////////////////////////////////////////////////////////
  200. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName)
  201. {   
  202.     HFILE              hf;
  203.     LPBITMAPINFOHEADER lpImgData;
  204.     LOGPALETTE         *pPal;
  205.     LPRGBQUAD          lpRGB;
  206.     HPALETTE           hPrevPalette; 
  207.     HDC                hDc;
  208. HLOCAL             hPal;
  209. DWORD         ImgSize;
  210. DWORD              i;
  212.     if((hf=_lopen("test.bmp",OF_READ))==HFILE_ERROR){
  213.         MessageBox(hWnd,"File c:\test.bmp not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  214.         return FALSE;
  215. }
  216. _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  217. _lread(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER));
  218. ImgWidth=bi.biWidth;
  219. ImgHeight=bi.biHeight;
  220. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  221. ImgSize=(DWORD)LineBytes*bi.biHeight;
  222.     if(bi.biClrUsed!=0)
  223. NumColors=(DWORD)bi.biClrUsed;
  224. else
  225.         switch(bi.biBitCount){
  226.         case 1:
  227.              NumColors=2;
  228.              break;
  229.          case 4:
  230.              NumColors=16;
  231.              break;
  232.          case 8:
  233.              NumColors=256;
  234.              break;
  235.          case 24:
  236.              NumColors=0;
  237.              break;
  238.               default:
  239.                   MessageBox(hWnd,"Invalid color numbers!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  240.                   _lclose(hf);
  241.                   return FALSE; 
  242.         }
  243. if(bf.bfOffBits!=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  244. +sizeof(BITMAPINFOHEADER)))
  245. {
  246.      MessageBox(hWnd,"Invalid color numbers!","Error Message" ,MB_OK|
  247.                MB_ICONEXCLAMATION);
  248. _lclose(hf);
  249. return FALSE; 
  250. }
  251.         bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  252. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  253.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  254. {
  255.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  256.                    MB_ICONEXCLAMATION);
  257.     _lclose(hf);
  258. return FALSE;
  259. }
  260.   
  261. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  262.     _llseek(hf,sizeof(BITMAPFILEHEADER),SEEK_SET);
  263. _hread(hf,(char *)lpImgData,(long)sizeof(BITMAPINFOHEADER)
  264.            +(long)NumColors*sizeof(RGBQUAD)+ImgSize);
  265. _lclose(hf);
  266.     if(NumColors!=0)
  267. {                    
  268.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  269.     pPal =(LOGPALETTE *)LocalLock(hPal);
  270.     pPal->palNumEntries =(WORD) NumColors;
  271. pPal->palVersion    = 0x300;
  272.     lpRGB = (LPRGBQUAD)((LPSTR)lpImgData + (DWORD)sizeof(BITMAPINFOHEADER));
  273. for (i = 0; i < NumColors; i++) {
  274.       pPal->palPalEntry[i].peRed=lpRGB->rgbRed;
  275. pPal->palPalEntry[i].peGreen=lpRGB->rgbGreen;
  276. pPal->palPalEntry[i].peBlue=lpRGB->rgbBlue;
  277. pPal->palPalEntry[i].peFlags=(BYTE)0;
  278. lpRGB++;
  279. }
  280. hPalette=CreatePalette(pPal);
  281. LocalUnlock(hPal);
  282. LocalFree(hPal);
  283. }
  284. hDc=GetDC(hWnd);
  285. if(hPalette){
  286.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  287. RealizePalette(hDc);
  288. }
  289. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  290. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  291.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  292. if(hPalette && hPrevPalette){
  293. SelectPalette(hDc,hPrevPalette,FALSE);
  294. RealizePalette(hDc);
  295. }
  296.  
  297. ReleaseDC(hWnd,hDc);
  298. GlobalUnlock(hImgData);
  299. return TRUE; 
  300. }
  301. ////////////////////////////////////////////////////////////////
  302. BOOL CALLBACK InputBox( HWND hDlg, UINT message,WPARAM wParam, LPARAM lParam )
  303. { 
  304. char str[80];
  306.     switch  ( message ){
  307.     case WM_INITDIALOG:    
  308.       SetDlgItemText(hDlg,ID_XOFFSET,"0");
  309.       SetDlgItemText(hDlg,ID_YOFFSET,"0");
  310.       SetDlgItemText(hDlg,ID_ANGLE,"0");
  311.       SetDlgItemText(hDlg,ID_ZOOMRATIO,"0.25");
  312.      return TRUE;
  313.     case WM_COMMAND:    
  314.      if ( wParam == IDOK || wParam == IDCANCEL )
  315.         {
  316.          GetDlgItemText(hDlg,ID_XOFFSET,str,80);
  317. xOffset=atoi(str);
  318.          GetDlgItemText(hDlg,ID_YOFFSET,str,80);
  319. yOffset=atoi(str);
  320.          GetDlgItemText(hDlg,ID_ANGLE,str,80);
  321. RotateAngle=(float)atof(str);
  322.          GetDlgItemText(hDlg,ID_ZOOMRATIO,str,80);
  323. ZoomRatio=(float)atof(str);
  324.             EndDialog ( hDlg, TRUE );
  325.             return  TRUE;
  326.         }
  327.         break;
  328.     }
  329. return FALSE;      
  330. }
  331. ////////////////////////////////////////////////////////////////
  332. BOOL Translation(HWND hWnd)
  333. {
  334. DLGPROC            dlgInputBox = NULL;
  335. DWORD              OffBits,BufSize;
  336.     LPBITMAPINFOHEADER lpImgData;
  337. LPSTR              lpPtr;
  338. HLOCAL             hTempImgData;
  339. LPBITMAPINFOHEADER lpTempImgData;
  340. LPSTR              lpTempPtr;
  341. int    SrcX0,SrcY0,SrcX1,SrcY1,DstX0,DstY0,DstX1,DstY1;
  342. int                RectWidth,RectHeight;
  343. BOOL               xVisible,yVisible;
  344. HDC                hDc;
  345. HFILE              hf;
  346. int                i;
  348. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  349. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  350. FreeProcInstance ( (FARPROC) dlgInputBox );
  352. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  353. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  355. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  356.     {
  357.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  358.         return FALSE;
  359.     }
  361.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  362. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  364. lpPtr=(char *)lpImgData;
  365. lpTempPtr=(char *)lpTempImgData;
  367. memset(lpTempPtr,(BYTE)255,BufSize);
  368. memcpy(lpTempPtr,lpPtr,OffBits);
  370. xVisible=TRUE;
  371. if( xOffset<= -bi.biWidth )
  372. xVisible=FALSE;
  373. else if( xOffset<=0){
  374. DstX0=0;
  375. DstX1=bi.biWidth+xOffset;
  376. }
  377. else if ( xOffset<bi.biWidth){
  378. DstX0=xOffset;
  379. DstX1=bi.biWidth;
  380. }
  381. else
  382. xVisible=FALSE;
  383. SrcX0=DstX0-xOffset;
  384. SrcX1=DstX1-xOffset;
  385. RectWidth=DstX1-DstX0;
  387. yVisible=TRUE;
  388. if( yOffset<= -bi.biHeight )
  389. yVisible=FALSE;
  390. else if( yOffset<=0){
  391. DstY0=0;
  392. DstY1=bi.biHeight+yOffset;
  393. }
  394. else if ( yOffset<bi.biHeight){
  395. DstY0=yOffset;
  396. DstY1=bi.biHeight;
  397. }
  398. else
  399. yVisible=FALSE;
  400. SrcY0=DstY0-yOffset;
  401. SrcY1=DstY1-yOffset;
  402. RectHeight=DstY1-DstY0;
  404. if( xVisible && yVisible){
  405. for(i=0;i<RectHeight;i++){
  406. lpPtr=(char *)lpImgData+(BufSize-LineBytes-(i+SrcY0)*LineBytes)+SrcX0;
  407. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-(i+DstY0)*LineBytes)+DstX0;
  408. memcpy(lpTempPtr,lpPtr,RectWidth);
  409. }
  410. }
  412. hDc=GetDC(hWnd);
  413.     if(hBitmap!=NULL)
  414.     DeleteObject(hBitmap);
  416. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  417. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  418.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  420.     hf=_lcreat("c:\translation.bmp",0);
  421. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  422. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  423. _lclose(hf);
  425.   ReleaseDC(hWnd,hDc);
  426. LocalUnlock(hTempImgData);
  427. LocalFree(hTempImgData);
  428. GlobalUnlock(hImgData);
  429. return TRUE;
  430. }
  431. ////////////////////////////////////////////////////////////////
  432. BOOL Rotation(HWND hWnd)
  433. {
  434. DLGPROC            dlgInputBox = NULL;
  435. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  436.     LPBITMAPINFOHEADER lpImgData;
  437. LPSTR              lpPtr;
  438. HLOCAL             hTempImgData;
  439. LPBITMAPINFOHEADER lpTempImgData;
  440. LPSTR              lpTempPtr;
  441. float    SrcX1,SrcY1,SrcX2,SrcY2,SrcX3,SrcY3,SrcX4,SrcY4;
  442. float    DstX1,DstY1,DstX2,DstY2,DstX3,DstY3,DstX4,DstY4;
  443. DWORD              Wold,Hold,Wnew,Hnew;
  444. HDC                hDc;
  445. HFILE              hf;
  446. DWORD              x0,y0,x1,y1;
  447. float              cosa,sina; //cos(a),sin(a)
  448. float    num1,num2;
  449. BITMAPFILEHEADER   DstBf;
  450. BITMAPINFOHEADER   DstBi;
  452. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  453. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  454. FreeProcInstance ( (FARPROC) dlgInputBox );
  456. RotateAngle=(float)RADIAN(RotateAngle);
  457. cosa=(float)cos((double)RotateAngle);
  458. sina=(float)sin((double)RotateAngle);
  460. Wold=bi.biWidth;
  461. Hold=bi.biHeight;
  462. SrcX1=(float)(-0.5*Wold);
  463. SrcY1=(float)(0.5*Hold);
  464. SrcX2=(float)(0.5*Wold);
  465. SrcY2=(float)(0.5*Hold);
  466. SrcX3=(float)(-0.5*Wold);
  467. SrcY3=(float)(-0.5*Hold);
  468. SrcX4=(float)(0.5*Wold);
  469. SrcY4=(float)(-0.5*Hold);
  471. DstX1=cosa*SrcX1+sina*SrcY1;
  472. DstY1=-sina*SrcX1+cosa*SrcY1;
  473. DstX2=cosa*SrcX2+sina*SrcY2;
  474. DstY2=-sina*SrcX2+cosa*SrcY2;
  475. DstX3=cosa*SrcX3+sina*SrcY3;
  476. DstY3=-sina*SrcX3+cosa*SrcY3;
  477. DstX4=cosa*SrcX4+sina*SrcY4;
  478. DstY4=-sina*SrcX4+cosa*SrcY4;
  480. Wnew = (DWORD)(max(fabs(DstX4-DstX1), fabs(DstX3-DstX2))+0.5);
  481.     Hnew = (DWORD)(max(fabs(DstY4-DstY1), fabs(DstY3-DstY2))+0.5);
  482. num1=(float)( -0.5*Wnew*cosa-0.5*Hnew*sina+0.5*Wold);
  483. num2=(float)(0.5*Wnew*sina-0.5*Hnew*cosa+0.5*Hold);
  485. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  486. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  488. ImgWidth=Wnew;
  489. ImgHeight=Hnew;
  491. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  492. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  494. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  495.     {
  496.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  497.         return FALSE;
  498.     }
  500.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  501. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  503. lpPtr=(char *)lpImgData;
  504. lpTempPtr=(char *)lpTempImgData;
  506. memset(lpTempPtr,(BYTE)255,DstBufSize);
  507. memcpy(lpTempPtr,lpPtr,OffBits);
  509. //get new bitmapfileheader and bitmapinfoheader
  510. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  511. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  512. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  513. DstBi.biWidth=Wnew;
  514. DstBi.biHeight=Hnew;
  516. //overwrite bitmapinfoheader with the new one
  517. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  519. for(y1=0;y1<Hnew;y1++)
  520. for(x1=0;x1<Wnew;x1++){
  521. x0= (DWORD)(x1*cosa+y1*sina+num1);
  522. y0= (DWORD)(-1.0f*x1*sina+y1*cosa+num2);
  523. if( (x0>=0) && (x0<Wold) && (y0>=0) && (y0<Hold))
  524. {
  525. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  526. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  527. *lpTempPtr=*lpPtr;
  528. }
  529. }
  531. hDc=GetDC(hWnd);
  532.     if(hBitmap!=NULL)
  533.     DeleteObject(hBitmap);
  535. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  536. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  537.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  539.     hf=_lcreat("c:\rotation.bmp",0);
  540. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  541. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  542. _lclose(hf);
  544.   ReleaseDC(hWnd,hDc);
  545. LocalUnlock(hTempImgData);
  546. LocalFree(hTempImgData);
  547. GlobalUnlock(hImgData);
  548. return TRUE;
  549. }
  550. ////////////////////////////////////////////////////////////////
  551. BOOL Mirror(HWND hWnd,BOOL XDirection)
  552. {
  553. DWORD              OffBits,BufSize;
  554.     LPBITMAPINFOHEADER lpImgData;
  555. LPSTR              lpPtr;
  556. HLOCAL             hTempImgData;
  557. LPBITMAPINFOHEADER lpTempImgData;
  558. LPSTR              lpTempPtr;
  559. HDC                hDc;
  560. HFILE              hf;
  561. LONG               x0,y0,x1,y1;
  563. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  564. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  566. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  567.     {
  568.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  569.         return FALSE;
  570.     }
  572.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  573. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  575. lpPtr=(char *)lpImgData;
  576. lpTempPtr=(char *)lpTempImgData;
  578. memset(lpTempPtr,(BYTE)255,BufSize);
  579. memcpy(lpTempPtr,lpPtr,OffBits);
  581. if( XDirection){
  582. for(y1=0;y1<bi.biHeight;y1++)
  583. for(x1=0;x1<bi.biWidth;x1++){
  584. x0=bi.biWidth-1-x1;
  585. y0=y1;
  586. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y0*LineBytes)+x0;
  587. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y1*LineBytes)+x1;
  588. *lpTempPtr=*lpPtr;
  589. }
  590. }
  591. else{
  592. for(y1=0;y1<bi.biHeight;y1++)
  593. for(x1=0;x1<bi.biWidth;x1++){
  594. x0=x1;
  595. y0=bi.biHeight-1-y1;
  596. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y0*LineBytes)+x0;
  597. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y1*LineBytes)+x1;
  598. *lpTempPtr=*lpPtr;
  599. }
  600. }
  602. hDc=GetDC(hWnd);
  603.     if(hBitmap!=NULL)
  604.     DeleteObject(hBitmap);
  606. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  607. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  608.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  609. if( XDirection)
  610. hf=_lcreat("c:\mirrorx.bmp",0);
  611. else
  612. hf=_lcreat("c:\mirrory.bmp",0);
  614. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  615. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  616. _lclose(hf);
  618.   ReleaseDC(hWnd,hDc);
  619. LocalUnlock(hTempImgData);
  620. LocalFree(hTempImgData);
  621. GlobalUnlock(hImgData);
  622. return TRUE;
  623. }
  624. ////////////////////////////////////////////////////////////////
  625. BOOL Transpose(HWND hWnd)
  626. {
  627. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  628.     LPBITMAPINFOHEADER lpImgData;
  629. LPSTR              lpPtr;
  630. HLOCAL             hTempImgData;
  631. LPBITMAPINFOHEADER lpTempImgData;
  632. LPSTR              lpTempPtr;
  633. DWORD              Wnew,Hnew;
  634. HDC                hDc;
  635. HFILE              hf;
  636. DWORD              x0,y0,x1,y1;
  637. BITMAPFILEHEADER   DstBf;
  638. BITMAPINFOHEADER   DstBi;
  640. Wnew = (DWORD)bi.biHeight;
  641.     Hnew = (DWORD)bi.biWidth;
  643. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  644. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  646. ImgWidth=Wnew;
  647. ImgHeight=Hnew;
  649. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  650. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  652. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  653.     {
  654.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  655.         return FALSE;
  656.     }
  658.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  659. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  661. lpPtr=(char *)lpImgData;
  662. lpTempPtr=(char *)lpTempImgData;
  664. memset(lpTempPtr,(BYTE)255,DstBufSize);
  665. memcpy(lpTempPtr,lpPtr,OffBits);
  667. //get new bitmapfileheader and bitmapinfoheader
  668. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  669. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  670. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  671. DstBi.biWidth=Wnew;
  672. DstBi.biHeight=Hnew;
  674. //overwrite bitmapinfoheader with the new one
  675. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  677. for(y1=0;y1<Hnew;y1++)
  678. for(x1=0;x1<Wnew;x1++){
  679. x0= y1;
  680. y0= x1;
  681. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  682. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  683. *lpTempPtr=*lpPtr;
  684. }
  686. hDc=GetDC(hWnd);
  687.     if(hBitmap!=NULL)
  688.     DeleteObject(hBitmap);
  690. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  691. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  692.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  694.     hf=_lcreat("c:\transpose.bmp",0);
  695. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  696. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  697. _lclose(hf);
  699.   ReleaseDC(hWnd,hDc);
  700. LocalUnlock(hTempImgData);
  701. LocalFree(hTempImgData);
  702. GlobalUnlock(hImgData);
  703. return TRUE;
  704. }
  705. ////////////////////////////////////////////////////////////////
  706. BOOL Zoom(HWND hWnd)
  707. {
  708. DLGPROC            dlgInputBox = NULL;
  709. DWORD              OffBits,SrcBufSize,DstBufSize,DstLineBytes;
  710.     LPBITMAPINFOHEADER lpImgData;
  711. LPSTR              lpPtr;
  712. HLOCAL             hTempImgData;
  713. LPBITMAPINFOHEADER lpTempImgData;
  714. LPSTR              lpTempPtr;
  715. DWORD              Wold,Hold,Wnew,Hnew;
  716. HDC                hDc;
  717. HFILE              hf;
  718. DWORD              x0,y0,x1,y1;
  719. float    num1;
  720. BITMAPFILEHEADER   DstBf;
  721. BITMAPINFOHEADER   DstBi;
  723. dlgInputBox = (DLGPROC) MakeProcInstance ( (FARPROC)InputBox, ghInst );
  724. DialogBox (ghInst, "INPUTBOX", hWnd, dlgInputBox);
  725. FreeProcInstance ( (FARPROC) dlgInputBox );
  727. num1=(float)(1.0/ZoomRatio);
  728. Wold=bi.biWidth;
  729. Hold=bi.biHeight;
  730. Wnew = (DWORD)(Wold*ZoomRatio+0.5);
  731.     Hnew = (DWORD)(Hold*ZoomRatio+0.5);
  733. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  734. SrcBufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  736. ImgWidth=Wnew;
  737. ImgHeight=Hnew;
  739. DstLineBytes=(DWORD)WIDTHBYTES(Wnew*bi.biBitCount);
  740. DstBufSize=(DWORD)(sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+(DWORD)DstLineBytes*Hnew);
  742. if((hTempImgData=LocalAlloc(LHND,DstBufSize))==NULL)
  743.     {
  744.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  745.         return FALSE;
  746.     }
  748.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  749. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  751. lpPtr=(char *)lpImgData;
  752. lpTempPtr=(char *)lpTempImgData;
  754. memset(lpTempPtr,(BYTE)255,DstBufSize);
  755. memcpy(lpTempPtr,lpPtr,OffBits);
  757. //get new bitmapfileheader and bitmapinfoheader
  758. memcpy((char *)&DstBf,(char *)&bf,sizeof(BITMAPFILEHEADER));
  759. memcpy((char *)&DstBi,(char *)&bi,sizeof(BITMAPINFOHEADER));
  760. DstBf.bfSize=DstBufSize+sizeof(BITMAPFILEHEADER);
  761. DstBi.biWidth=Wnew;
  762. DstBi.biHeight=Hnew;
  764. //overwrite bitmapinfoheader with the new one
  765. memcpy(lpTempPtr,(char *)&DstBi,sizeof(BITMAPINFOHEADER));
  767. for(y1=0;y1<Hnew;y1++)
  768. for(x1=0;x1<Wnew;x1++){
  769. x0= (DWORD)(x1*num1);
  770. y0= (DWORD)(y1*num1);
  771. if( (x0>=0) && (x0<Wold) && (y0>=0) && (y0<Hold))
  772. {
  773. lpPtr=(char *)lpImgData+(SrcBufSize-LineBytes-y0*LineBytes)+x0;
  774. lpTempPtr=(char *)lpTempImgData+(DstBufSize-DstLineBytes-y1*DstLineBytes)+x1;
  775. *lpTempPtr=*lpPtr;
  776. }
  777. }
  779. hDc=GetDC(hWnd);
  780.     if(hBitmap!=NULL)
  781.     DeleteObject(hBitmap);
  783. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  784. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  785.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  787.     hf=_lcreat("c:\zoom.bmp",0);
  788. _lwrite(hf,(LPSTR)&DstBf,sizeof(BITMAPFILEHEADER)); 
  789. _lwrite(hf,(LPSTR)lpTempImgData,DstBufSize);
  790. _lclose(hf);
  792.   ReleaseDC(hWnd,hDc);
  793. LocalUnlock(hTempImgData);
  794. LocalFree(hTempImgData);
  795. GlobalUnlock(hImgData);
  796. return TRUE;
  797. }