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

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

图形图像处理

开发平台：

Visual C++

dither.c：源码内容
  1. //////////////////////////////////////////////////////////////
  2. //Name:dither.c
  3. //Purpose: Pattern and Dithering
  4. //Author: phoenix, CS, TshingHua, Beijing, P.R.C.
  5. //Email: bjlufengjun@www.163.net or lufengjun@hotmail.com
  6. //Date:April 3, 1998
  8. //header file
  9. #include "bmp.h"
  10. #include "memory.h"
  11. #include "math.h"
  12. #include "stdio.h"
  13. //macro definition
  14. #define WIDTHBYTES(i)    ((i+31)/32*4)
  15. //function declaration
  16. int PASCAL WinMain (HANDLE, HANDLE, LPSTR, int);
  17. LRESULT CALLBACK MainWndProc(HWND , UINT,WPARAM, LPARAM);
  18. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName);
  19. BOOL LimbPatternM3(HWND hWnd);
  20. BOOL LimbPatternM4(HWND hWnd);
  21. BOOL Steinberg(HWND hWnd);
  22. BOOL Bmp2Txt(HWND hWnd);
  23. //global variable declaration
  24. BITMAPFILEHEADER   bf;
  25. BITMAPINFOHEADER   bi;
  26. HPALETTE           hPalette=NULL;
  27. HBITMAP            hBitmap=NULL;
  28. HGLOBAL            hImgData=NULL;
  29. DWORD              NumColors;
  30. DWORD              LineBytes;
  31. HINSTANCE          ghInst;
  32. DWORD              ImgWidth=0 , ImgHeight=0;
  33. //template array
  34. BYTE BayerPattern[8][8]={0,32,8,40,2,34,10,42,
  35.  48,16,56,24,50,18,58,26,
  36.  12,44,4,36,14,46,6,38,
  37.  60,28,52,20,62,30,54,22,
  38.  3,35,11,43,1,33,9,41,
  39.  51,19,59,27,49,17,57,25,
  40.  15,47,7,39,13,45,5,37,
  41.  63,31,55,23,61,29,53,21};
  42. static char ch[95]= {
  43. ' ',
  44. '`','1','2','3','4','5','6','7','8','9','0','-','=','\',
  45. 'q','w','e','r','t','y','u','i','o','p','[',']',
  46. 'a','s','d','f','g','h','j','k','l',';',''',
  47. 'z','x','c','v','b','n','m',',','.','/',
  48. '~','!','@','#','$','%','^','&','*','(',')','_','+','|',
  49. 'Q','W','E','R','T','Y','U','I','O','P','{','}',
  50. 'A','S','D','F','G','H','J','K','L',':','"',
  51. 'Z','X','C','V','B','N','M','<','>','?'
  52. };
  53. static int  gr[95]= {
  54.  0,
  55.  7,22,28,31,31,27,32,22,38,32,40, 6,12,20,38,32,26,20,24,40,
  56.     29,24,28,38,32,32,26,22,34,24,44,33,32,32,24,16, 6,22,26,22,
  57.  26,34,29,35,10, 6,20,14,22,47,42,34,40,10,35,21,22,22,16,14,
  58.  26,40,39,29,38,22,28,36,22,36,30,22,22,36,26,36,25,34,38,24,
  59.  36,22,12,12,26,30,30,34,39,42,41,18,18,22
  60.  };
  61. ///////////////////////////////////////////////////////////
  62. int PASCAL WinMain (HANDLE hInstance, HANDLE hPrevInstance,
  63.     LPSTR lpszCmdLine, int nCmdShow)
  64. {
  65. MSG       msg;
  66. WNDCLASS  wndclass;
  67. HWND      hWnd;
  69. ghInst=hInstance;
  70. if ( ! hPrevInstance ){
  71. wndclass.style = CS_HREDRAW | CS_VREDRAW;
  72. wndclass.lpfnWndProc = MainWndProc;
  73. wndclass.cbClsExtra = 0;
  74. wndclass.cbWndExtra = 0;
  75. wndclass.hInstance = hInstance;
  76. wndclass.hIcon = LoadIcon (NULL, IDI_APPLICATION);
  77. wndclass.hCursor = LoadCursor (NULL, IDC_ARROW);
  78. wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
  79. wndclass.lpszMenuName =  "BMPMENU";
  80. wndclass.lpszClassName = "phoenix ip system";
  81.     }
  83.     if ( ! RegisterClass (&wndclass) )
  84.     return FALSE;
  86. hWnd = CreateWindow ("phoenix ip system","Pattern and Dithering",
  87.  WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
  88.  CW_USEDEFAULT, CW_USEDEFAULT, NULL,NULL,
  89.  hInstance, NULL);
  90. if (!hWnd)
  91. return FALSE;
  92. ShowWindow (hWnd, SW_SHOWMAXIMIZED);
  93. UpdateWindow (hWnd);
  95. while ( GetMessage (&msg, NULL, 0, 0) ){
  96. TranslateMessage (&msg);
  97. DispatchMessage (&msg);
  98.     }
  100. return msg.wParam;
  101. }
  102. ////////////////////////////////////////////////////////////////
  103. LRESULT CALLBACK MainWndProc(HWND hWnd, UINT message,WPARAM wParam, LPARAM lParam)
  104. {
  105.     static  HDC    hDC,hMemDC;
  106.     PAINTSTRUCT    ps;
  108.     switch (message){
  109.     case WM_PAINT:
  110. {         
  111. hDC = BeginPaint(hWnd, &ps);
  112. if (hBitmap)
  113. { 
  114. hMemDC = CreateCompatibleDC(hDC);
  115. if (hPalette)
  116. {           
  117. SelectPalette (hDC, hPalette, FALSE); 
  118. SelectPalette (hMemDC, hPalette, FALSE);
  119. RealizePalette (hDC);
  120. }   
  121. SelectObject(hMemDC, hBitmap); 
  122. BitBlt(hDC, 0, 0, ImgWidth,ImgHeight, hMemDC, 0, 0, SRCCOPY);
  123. DeleteDC(hMemDC);
  124. }
  125. EndPaint(hWnd, &ps);
  126. break;
  127. }
  128. case WM_DESTROY: //注意释放内存和位图，调色板句柄
  129.         if(hBitmap!=NULL)
  130.         DeleteObject(hBitmap);
  131.     
  132. if(hPalette!=NULL)                     
  133.         DeleteObject(hPalette);
  135. if(hImgData!=NULL){
  136. GlobalUnlock(hImgData);
  137. GlobalFree(hImgData);
  138. }         
  139.     PostQuitMessage (0);
  140.     return 0;
  141. case WM_COMMAND:
  142.     switch (wParam){
  143.     case IDM_LOADBMP: 
  144. //注意重新分配内存和调色板，位图句柄时，先释放原来的
  145.         if(hBitmap!=NULL){     
  146. DeleteObject(hBitmap);
  147.             hBitmap=NULL;
  148.         }
  149.         if(hPalette!=NULL){                     
  150. DeleteObject(hPalette);
  151.             hPalette=NULL;
  152.         }
  153. if(hImgData!=NULL){
  154. GlobalUnlock(hImgData);
  155. GlobalFree(hImgData);  
  156. hImgData=NULL;
  157. }         
  158. if(LoadBmpFile(hWnd,"c:\test.bmp")) //成功，则重画窗口
  159.                 InvalidateRect(hWnd,NULL,TRUE);
  160.         break;
  161. case IDM_LIMBPATTERNM3:
  162. if(hImgData!=NULL){
  163. if(LimbPatternM3(hWnd))
  164. InvalidateRect(hWnd,NULL,TRUE);
  165. }
  166. else
  167. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  168. break;
  169. case IDM_LIMBPATTERNM4:
  170. if(hImgData!=NULL){
  171. if(LimbPatternM4(hWnd))
  172. InvalidateRect(hWnd,NULL,TRUE);
  173. }
  174. else
  175. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  176. break;
  177. case IDM_STEINBERG:
  178. if(hImgData!=NULL){
  179. if(Steinberg(hWnd));
  180. InvalidateRect(hWnd,NULL,TRUE);
  181. }
  182. else
  183. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  184. break;
  185. case IDM_BMP2TXT:
  186. if(hImgData!=NULL){
  187. if(Bmp2Txt(hWnd))
  188.      MessageBox(hWnd,"Finished!","Success Message",MB_OK);
  189. }
  190. else
  191. MessageBox(hWnd,"File not loaded yet!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  192. break;
  193. case IDM_EXIT:
  194.         SendMessage(hWnd,WM_DESTROY,0,0L);
  195.         break;
  196.     }
  197. break;                
  198.     }
  199.     return DefWindowProc (hWnd, message, wParam, lParam);
  200. }
  201. ////////////////////////////////////////////////////////////////
  202. BOOL LoadBmpFile (HWND hWnd,char *BmpFileName)
  203. {   
  204.     HFILE              hf;
  205.     LPBITMAPINFOHEADER lpImgData;
  206.     LOGPALETTE         *pPal;
  207.     LPRGBQUAD          lpRGB;
  208.     HPALETTE           hPrevPalette; 
  209.     HDC                hDc;
  210. HLOCAL             hPal;
  211. DWORD         ImgSize;
  212. DWORD              i;
  214.     if((hf=_lopen(BmpFileName,OF_READ))==HFILE_ERROR){
  215.         MessageBox(hWnd,"File c:\test.bmp not found!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  216.         return FALSE;
  217. }
  218. _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  219. _lread(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER));
  220. ImgWidth=bi.biWidth;
  221. ImgHeight=bi.biHeight;
  222. LineBytes=(DWORD)WIDTHBYTES(bi.biWidth*bi.biBitCount);
  223. ImgSize=(DWORD)LineBytes*bi.biHeight;
  224.     if(bi.biClrUsed!=0)
  225. NumColors=(DWORD)bi.biClrUsed;
  226. else
  227.         switch(bi.biBitCount){
  228.         case 1:
  229.              NumColors=2;
  230.              break;
  231.          case 4:
  232.              NumColors=16;
  233.              break;
  234.          case 8:
  235.              NumColors=256;
  236.              break;
  237.          case 24:
  238.              NumColors=0;
  239.              break;
  240.               default:
  241.                   MessageBox(hWnd,"Invalid color numbers!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  242.                   _lclose(hf);
  243.                   return FALSE; 
  244.         }
  245. if(bf.bfOffBits!=(DWORD)(NumColors*sizeof(RGBQUAD)+sizeof(BITMAPFILEHEADER)
  246. +sizeof(BITMAPINFOHEADER)))
  247. {
  248.      MessageBox(hWnd,"Invalid color numbers!","Error Message" ,MB_OK|
  249.                MB_ICONEXCLAMATION);
  250. _lclose(hf);
  251. return FALSE; 
  252. }
  253. bf.bfSize=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+NumColors*sizeof(RGBQUAD)+ImgSize;
  254. if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)+
  255.      NumColors*sizeof(RGBQUAD)+ImgSize)))==NULL)
  256. {
  257.      MessageBox(hWnd,"Error alloc memory!","ErrorMessage",MB_OK|
  258.                    MB_ICONEXCLAMATION);
  259.     _lclose(hf);
  260. return FALSE;
  261. }
  262.   
  263. lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData); 
  264.     _llseek(hf,sizeof(BITMAPFILEHEADER),FILE_BEGIN);
  265. _hread(hf,(char *)lpImgData,(long)sizeof(BITMAPINFOHEADER)
  266.            +(long)NumColors*sizeof(RGBQUAD)+ImgSize);
  267. _lclose(hf);
  268.     if(NumColors!=0)
  269. {                    
  270.     hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) + NumColors* sizeof(PALETTEENTRY));
  271.     pPal =(LOGPALETTE *)LocalLock(hPal);
  272.     pPal->palNumEntries =(WORD) NumColors;
  273. pPal->palVersion    = 0x300;
  274.     lpRGB = (LPRGBQUAD)((LPSTR)lpImgData + (DWORD)sizeof(BITMAPINFOHEADER));
  275. for (i = 0; i < NumColors; i++) {
  276.       pPal->palPalEntry[i].peRed=lpRGB->rgbRed;
  277. pPal->palPalEntry[i].peGreen=lpRGB->rgbGreen;
  278. pPal->palPalEntry[i].peBlue=lpRGB->rgbBlue;
  279. pPal->palPalEntry[i].peFlags=(BYTE)0;
  280. lpRGB++;
  281. }
  282. hPalette=CreatePalette(pPal);
  283. LocalUnlock(hPal);
  284. LocalFree(hPal);
  285. }
  286. hDc=GetDC(hWnd);
  287. if(hPalette){
  288.         hPrevPalette=SelectPalette(hDc,hPalette,FALSE);
  289. RealizePalette(hDc);
  290. }
  291. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpImgData, (LONG)CBM_INIT,
  292. (LPSTR)lpImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  293.     (LPBITMAPINFO)lpImgData, DIB_RGB_COLORS);
  294. if(hPalette && hPrevPalette){
  295. SelectPalette(hDc,hPrevPalette,FALSE);
  296. RealizePalette(hDc);
  297. }
  298.  
  299. ReleaseDC(hWnd,hDc);
  300. GlobalUnlock(hImgData);
  301. return TRUE; 
  302. }
  303. ////////////////////////////////////////////////////////////////
  304. BOOL LimbPatternM3(HWND hWnd)
  305. {
  306. DWORD              BufSize;
  307.     LPBITMAPINFOHEADER lpImgData;
  308. LPSTR              lpPtr;
  309. HLOCAL             hTempImgData;
  310. LPBITMAPINFOHEADER lpTempImgData;
  311. LPSTR              lpTempPtr;
  312. HDC                hDc;
  313. HFILE              hf;
  314. LONG               x,y;
  315. unsigned char      num;
  317. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  319. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  320.     {
  321.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  322.         return FALSE;
  323.     }
  325.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  326. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  328. //copy image data
  329. memcpy(lpTempImgData,lpImgData,BufSize);
  331. for(y=0;y<bi.biHeight;y++){
  332. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  333. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  334. for(x=0;x<bi.biWidth;x++){
  335. num=(unsigned char)*lpPtr++;
  336. if ( (num>>2) > BayerPattern[y&7][x&7])
  337. *(lpTempPtr++)=(unsigned char)255;
  338. else *(lpTempPtr++)=(unsigned char)0;
  339. }
  340. }
  342.     if(hBitmap!=NULL)
  343.     DeleteObject(hBitmap);
  344. hDc=GetDC(hWnd);
  345. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  346. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  347.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  349.     hf=_lcreat("c:\limbm3.bmp",0);
  350. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  351. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  352. _lclose(hf);
  354.   ReleaseDC(hWnd,hDc);
  355. LocalUnlock(hTempImgData);
  356. LocalFree(hTempImgData);
  357. GlobalUnlock(hImgData);
  358. return TRUE;
  359. }
  360. ////////////////////////////////////////////////////////////////
  361. BOOL LimbPatternM4(HWND hWnd)
  362. {
  363. DWORD              BufSize;
  364.     LPBITMAPINFOHEADER lpImgData;
  365. LPSTR              lpPtr;
  366. HLOCAL             hTempImgData;
  367. LPBITMAPINFOHEADER lpTempImgData;
  368. LPSTR              lpTempPtr;
  369. HDC                hDc;
  370. HFILE              hf;
  371. LONG               x,y;
  372. DWORD              i,j;
  373. unsigned char      num;
  374. BYTE    M4Pattern[16][16];
  376. for(i=0;i<8;i++)
  377. for(j=0;j<8;j++)
  378. M4Pattern[i][j]=4*BayerPattern[i][j];
  380. for(i=8;i<16;i++)
  381. for(j=0;j<8;j++)
  382. M4Pattern[i][j]=4*BayerPattern[i-8][j]+2;
  384. for(i=0;i<8;i++)
  385. for(j=8;j<16;j++)
  386. M4Pattern[i][j]=4*BayerPattern[i][j-8]+3;
  388. for(i=8;i<16;i++)
  389. for(j=8;j<16;j++)
  390. M4Pattern[i][j]=4*BayerPattern[i-8][j-8]+1;
  392. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  394. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  395.     {
  396.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  397.         return FALSE;
  398.     }
  400.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  401. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  403. //copy image data
  404. memcpy(lpTempImgData,lpImgData,BufSize);
  406. for(y=0;y<bi.biHeight;y++){
  407. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  408. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  409. for(x=0;x<bi.biWidth;x++){
  410. num=(unsigned char)*lpPtr++;
  411. if ( num > M4Pattern[y&15][x&15])
  412. *(lpTempPtr++)=(unsigned char)255;
  413. else *(lpTempPtr++)=(unsigned char)0;
  414. }
  415. }
  417.     if(hBitmap!=NULL)
  418.     DeleteObject(hBitmap);
  419. hDc=GetDC(hWnd);
  420. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  421. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  422.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  424.     hf=_lcreat("c:\limbm4.bmp",0);
  425. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  426. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  427. _lclose(hf);
  429.   ReleaseDC(hWnd,hDc);
  430. LocalUnlock(hTempImgData);
  431. LocalFree(hTempImgData);
  432. GlobalUnlock(hImgData);
  433. return TRUE;
  434. }
  435. ////////////////////////////////////////////////////////////////
  436. BOOL Steinberg(HWND hWnd)
  437. {
  438. DWORD              OffBits,BufSize,IntBufSize;
  439.     LPBITMAPINFOHEADER lpImgData;
  440. HLOCAL             hTempImgData;
  441. LPBITMAPINFOHEADER lpTempImgData;
  442. LPSTR              lpPtr;
  443. LPSTR              lpTempPtr;
  444. HDC                hDc;
  445. HFILE              hf;
  446. LONG               x,y;
  447. unsigned char      num;
  448. float              e,f;
  449. HLOCAL             hIntBuf;
  450. int                *lpIntBuf,*lpIntPtr;
  451. int                tempnum;
  453. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  454. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  456. if((hTempImgData=LocalAlloc(LHND,BufSize))==NULL)
  457.     {
  458.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  459.         return FALSE;
  460.     }
  462. IntBufSize=(DWORD)bi.biHeight*LineBytes*sizeof(int);
  463. if((hIntBuf=LocalAlloc(LHND,IntBufSize))==NULL)
  464.     {
  465.      MessageBox(hWnd,"Error alloc memory!","Error Message",MB_OK|MB_ICONEXCLAMATION);
  466. LocalFree(hTempImgData);
  467.         return FALSE;
  468.     }
  470.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);    
  471. lpTempImgData=(LPBITMAPINFOHEADER)LocalLock(hTempImgData);
  472. lpIntBuf=(int *)LocalLock(hIntBuf);
  474. //copy header data
  475. memcpy(lpTempImgData,lpImgData,OffBits);
  477. //copy image data to int buffer
  478. for(y=0;y<bi.biHeight;y++){
  479. lpPtr=(char *)lpImgData+(BufSize-LineBytes-y*LineBytes);
  480. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes;
  481. for(x=0;x<bi.biWidth;x++)
  482. *(lpIntPtr++)=(unsigned char)*(lpPtr++);
  483. }
  485. for(y=0;y<bi.biHeight;y++){  
  486. for(x=0;x<bi.biWidth;x++){
  487. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes+x;
  488. num=(unsigned char)*lpIntPtr;
  489. if ( num > 128 ){
  490. *lpIntPtr=255;
  491. e=(float)(num-255.0);
  492. }
  493. else{
  494. *lpIntPtr=0;
  495. e=(float)num;
  496. }
  497. if(x<bi.biWidth-1){
  498. f=(float)*(lpIntPtr+1);
  499. f+=(float)( (3.0/8.0) * e);
  500. *(lpIntPtr+1)=(int)f;
  501. }
  502. if(y<bi.biHeight-1){
  503. f=(float)*(lpIntPtr-LineBytes);
  504. f+=(float)( (3.0/8.0) * e);
  505. *(lpIntPtr-LineBytes)=(int)f;
  507. f=(float)*(lpIntPtr-LineBytes+1);
  508. f+=(float)( (1.0/4.0) * e);
  509. *(lpIntPtr-LineBytes+1)=(int)f;
  510. }
  511. }
  512. }
  514. //copy new image data from int buffer
  515. for(y=0;y<bi.biHeight;y++){
  516. lpTempPtr=(char *)lpTempImgData+(BufSize-LineBytes-y*LineBytes);
  517. lpIntPtr=(int *)lpIntBuf+(bi.biHeight-1-y)*LineBytes;
  518. for(x=0;x<bi.biWidth;x++){
  519. tempnum=*(lpIntPtr++);
  520. if(tempnum>255) tempnum=255;
  521. else if (tempnum<0) tempnum=0;
  522. *(lpTempPtr++)=(unsigned char)tempnum;
  523. }
  524. }
  526.     if(hBitmap!=NULL)
  527.     DeleteObject(hBitmap);
  528. hDc=GetDC(hWnd);
  529. hBitmap=CreateDIBitmap(hDc, (LPBITMAPINFOHEADER)lpTempImgData, (LONG)CBM_INIT,
  530. (LPSTR)lpTempImgData+sizeof(BITMAPINFOHEADER) +NumColors*sizeof(RGBQUAD),
  531.     (LPBITMAPINFO)lpTempImgData, DIB_RGB_COLORS);
  533.     hf=_lcreat("c:\steinberg.bmp",0);
  534. _lwrite(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)); 
  535. _lwrite(hf,(LPSTR)lpTempImgData,BufSize);
  536. _lclose(hf);
  538.   ReleaseDC(hWnd,hDc);
  539. GlobalUnlock(hImgData);
  540. LocalUnlock(hTempImgData);
  541. LocalFree(hTempImgData);
  542. LocalUnlock(hIntBuf);
  543. LocalFree(hIntBuf);
  544. return TRUE;
  545. }
  546. ////////////////////////////////////////////////////////////////
  547. BOOL Bmp2Txt(HWND hWnd)
  548. {
  549. DWORD              OffBits,BufSize;
  550.     LPBITMAPINFOHEADER lpImgData;
  551. LPSTR              lpPtr;
  552. HFILE              hf;
  553. int    i, j, k,h,tint,grayindex;
  554. char               tchar;
  555. int                TransHeight, TransWidth;
  557. for(i=0;i<94;i++)
  558. for(j=i+1;j<95;j++){
  559. if(gr[i]>gr[j]){
  560. tchar=ch[i],tint=gr[i];
  561. ch[i]=ch[j],gr[i]=gr[j];
  562. ch[j]=tchar,gr[j]=tint;
  563. }
  564. }
  566. OffBits=bf.bfOffBits-sizeof(BITMAPFILEHEADER);
  567. BufSize=bf.bfSize-sizeof(BITMAPFILEHEADER);
  568.     lpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
  569. TransWidth = bi.biWidth/8;
  570. TransHeight = bi.biHeight/16;
  571.     hf=_lcreat("c:\bmp2txt.txt",0);
  573. for(i=0;i<TransHeight;i++){
  574. for(j=0;j<TransWidth;j++){
  575. grayindex=0;
  576. for(k=0;k<16;k++)
  577. for(h=0;h<8;h++){
  578. lpPtr=(char *)lpImgData+BufSize-LineBytes-(i*16+k)*LineBytes+j*8+h;
  579. grayindex+=(unsigned char)*lpPtr;
  580. }
  581. grayindex/=16*8;
  582. grayindex=gr[94]*grayindex/255;
  583. k=0;
  584. while(gr[k+1]<grayindex)
  585. k++;
  586. _lwrite(hf,(char *)&ch[k],sizeof(char)); 
  587. }
  588. tchar=(char)13;
  589. _lwrite(hf,(char *)&tchar,sizeof(char)); 
  590. tchar=(char)10;
  591. _lwrite(hf,(char *)&tchar,sizeof(char));
  592. }
  593. _lclose(hf);
  594. GlobalUnlock(hImgData);
  595. return TRUE;
  596. }