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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
myfile2.cpp
资源名称：myfile2.rar　[点击查看]
上传用户：gtl089a
上传日期：2013-09-05
资源大小：5k
文件大小：21k
源码类别：

图形图像处理

开发平台：

Visual C++

myfile2.cpp：源码内容
  1. #include "stdafx.h"
  2. #include <math.h>
  3. #include <io.h>
  4. #include <direct.h>
  5. #include "dibapi.h"
  6. #include <complex>
  7. #define DIB_HEADER_MARKER   ((WORD) ('M' << 8) | 'B')
  9. /////////////////////////////////////////////////////////////////////////////////////
  10. // DXF.2003.10.20
  11. // myfile2.cpp
  12. //
  13. // HGLOBAL WINAPI ZoomPixelreplication(HDIB hDib,unsigned char ** PixelData,
  14. // float hzoom,float vzoom)
  15. // 利用像素复制放大缩小图像
  16. // HGLOBAL WINAPI ZoomBilinear(HDIB hDib,unsigned char ** PixelData,
  17. // float hzoom,float vzoom)
  18. // 双线形插值放大缩小图像
  19. // BOOL WINAPI GrayReduce(HDIB hDib,unsigned char ** PixelData,long GrayLevel)
  20. // 图像gray的衰减 
  21. // BOOL WINAPI Reverse(HDIB hDib,unsigned char ** PixelData)
  22. // 灰度图像的反色处理
  23. // BOOL WINAPI TransHalftone(HDIB hDib,unsigned char ** PixelData)
  24. // 图像的halftone处理
  25. // BOOL WINAPI ArithmeticOpr (HDIB hDib,unsigned char ** PixelData,
  26. //    unsigned char ** PixelData2,const CString Opr,
  27. //    const int width,const int height,const double scale,const double factor)
  28. // 图像的算数处理
  29. // BOOL WINAPI TransBw(HDIB hDib,unsigned char ** PixelData);
  30. // 生成黑白图
  31. /////////////////////////////////////////////////////////////////////////////////////
  34. /*///////////////////////////////////////////////////////////////////////////
  35. // HGLOBAL WINAPI ZoomPixelreplication(HDIB hDib,unsigned char ** PixelData,
  36. // float hzoom,float vzoom)
  37. //  利用像素复制放大缩小图像
  38.  * 参数:
  39.  *   HDIB hDib    - 指向源DIB图像句柄
  40.  *  unsigned char ** PixelData 像素数组
  41.  *  float hzoom 水平缩放率
  42.  *  float vzoom 垂直缩放率
  43.  * 返回值:
  44.  *   HGLOBALL               - 运算成功返回缩放后的图像句柄，否则返回NULL。
  45. //////////////////////////////////////////////////////////////////////////*/
  46. HGLOBAL WINAPI ZoomPixelreplication(HDIB hDib,unsigned char ** PixelData,float hzoom,float vzoom)
  47. {
  49. LPBITMAPINFOHEADER lpBi;
  51. lpBi=(LPBITMAPINFOHEADER)::GlobalLock((HGLOBAL) hDib);
  53. // 缩放后新DIB句柄
  54. HDIB hNewDIB;
  55. // 缩放后图像的宽度和高度
  56. LONG lNewWidth=0,lNewHeight=0, lrgb,lNewLineBytes,ltruebit;
  59. // 指向缩放图像的指针
  60. LPSTR lpNewDIB;
  61. unsigned char * hNewData;
  63. LPBITMAPINFOHEADER lpbmi;
  65. // 循环变量（象素在新DIB中的坐标）
  66. LONG i,j,i0,j0,len;
  67. AfxGetApp()->BeginWaitCursor();    
  69. // 计算缩放后的图像实际宽度
  70. lNewWidth = (LONG) (lpBi->biWidth*hzoom);
  72.    if (8==lpBi->biBitCount) len=1;
  73.    if (24==lpBi->biBitCount) len=3;
  74. // 计算新图像每行的字节数
  75. lNewLineBytes = WIDTHBYTES(lNewWidth * 8 * len);
  77. // 计算缩放后的图像高度
  78. lNewHeight = (LONG) (lpBi->biHeight*vzoom);
  80. // 分配内存，以保存新DIB
  81. hNewDIB = (HDIB) ::GlobalAlloc(GHND, lNewLineBytes * lNewHeight + *(LPDWORD)(lpBi)  +
  82.                                ::PaletteSize((LPSTR)lpBi));
  84. // 判断是否内存分配失败
  85. if (hNewDIB == NULL)// 分配内存失败
  86. return NULL;
  88. // 锁定内存
  89. lpNewDIB =  (char * )::GlobalLock((HGLOBAL) hNewDIB);
  91. // 复制DIB信息头和调色板
  92. memcpy(lpNewDIB, (LPSTR)lpBi, *(LPDWORD)(lpBi) + ::PaletteSize((LPSTR)lpBi));
  94. // 找到新DIB象素起始位置
  95. hNewData = (unsigned char*)::FindDIBBits(lpNewDIB);
  97. // 获取指针
  98. lpbmi = (LPBITMAPINFOHEADER)lpNewDIB;
  100. // 更新DIB中图像的高度和宽度
  101. lpbmi->biWidth = lNewWidth;
  102. lpbmi->biHeight = lNewHeight;
  103.    
  104.    for (lrgb=0;lrgb<len;lrgb++)
  105. // 针对图像每行进行操作
  106. for(i = 0; i < lNewHeight; i++)
  107. {
  108. // 针对图像每列进行操作
  109. for(j = 0; j < lNewWidth; j++)
  110. {
  111. i0 = (LONG) (i / vzoom );
  112. j0 = (LONG) (j / hzoom );
  113.     
  114. ltruebit=j0*len+lrgb;
  116. // 判断是否在源图范围内
  117. if( (j0 >= 0) && (j0 < lpBi->biWidth) && (i0 >= 0) && (i0 < lpBi->biHeight))
  118. {
  119. // 为像素赋值
  120. *(hNewData+lNewLineBytes* i + j*len+lrgb) = PixelData[i0][ltruebit];
  121. }
  122. else
  123. { // 对于源图中没有的像素，直接赋值为255
  124. *(hNewData+lNewLineBytes*  i + j*len+lrgb) = 255;
  126. }
  127. }
  129. }
  132. AfxGetApp()->EndWaitCursor();
  133. ::GlobalUnlock((HGLOBAL)hDib);
  134. // 返回
  135. return hNewDIB;
  136. }
  137. /*///////////////////////////////////////////////////////////////////////////
  138. // HGLOBAL WINAPI ZoomBilinear(HDIB hDib,unsigned char ** PixelData,
  139. // float hzoom,float vzoom)
  140. //  双线形插值放大缩小图像
  141.  * 参数:
  142.  *   HDIB hDib    - 指向源DIB图像句柄
  143.  *  unsigned char ** PixelData 像素数组
  144.  *  float hzoom 水平缩放率
  145.  *  float vzoom 垂直缩放率
  146.  * 返回值:
  147.  *   HGLOBALL               - 运算成功返回缩放后的图像句柄，否则返回NULL。
  148. //////////////////////////////////////////////////////////////////////////*/
  150. HGLOBAL WINAPI ZoomBilinear(HDIB hDib,unsigned char ** PixelData,float hzoom,float vzoom){
  152. LPBITMAPINFOHEADER lpBi;
  154. lpBi=(LPBITMAPINFOHEADER)::GlobalLock((HGLOBAL) hDib);
  156. // 缩放后新DIB句柄
  157. HDIB hNewDIB;
  158. // 缩放后图像的宽度和高度
  159. LONG lNewWidth=0,lNewHeight=0, lNewLineBytes;
  162. // 缩放后图像的宽度（lNewWidth'，必须是4的倍数）
  164. // 指向缩放图像的指针
  165. LPSTR lpNewDIB;
  166. unsigned char * hNewData;
  168. // 指向BITMAPINFO结构的指针（Win3.0）
  169. LPBITMAPINFOHEADER lpbmi;
  171. // 循环变量（象素在新DIB中的坐标）
  172. LONG i,j,i0,j0,l1,l2,i2,j2;
  173. float  i1,j1;
  174.     
  175. AfxGetApp()->BeginWaitCursor();
  176. // 计算缩放后的图像实际宽度
  177. lNewWidth = (LONG) (lpBi->biWidth*hzoom);
  179. // 计算新图像每行的字节数
  180. lNewLineBytes = WIDTHBYTES(lNewWidth * 8);
  182. // 计算缩放后的图像高度
  183. lNewHeight = (LONG) (lpBi->biHeight*vzoom);
  185. // 分配内存，以保存新DIB
  186. hNewDIB = (HDIB) ::GlobalAlloc(GHND, lNewLineBytes * lNewHeight + *(LPDWORD)(lpBi)  +
  187.                                ::PaletteSize((LPSTR)lpBi));
  189. // 判断是否内存分配失败
  190. if (hNewDIB == NULL)// 分配内存失败
  191. return NULL;
  193. // 锁定内存
  194. lpNewDIB =  (char * )::GlobalLock((HGLOBAL) hNewDIB);
  196. // 复制DIB信息头和调色板
  197. memcpy(lpNewDIB, (LPSTR)lpBi, *(LPDWORD)(lpBi) + ::PaletteSize((LPSTR)lpBi));
  199. // 找到新DIB象素起始位置
  200. hNewData = (unsigned char*)::FindDIBBits(lpNewDIB);
  202. // 获取指针
  203. lpbmi = (LPBITMAPINFOHEADER)lpNewDIB;
  205. // 更新DIB中图像的高度和宽度
  206. lpbmi->biWidth = lNewWidth;
  207. lpbmi->biHeight = lNewHeight;
  209. //已知a,b,c,d四点的灰度，要求e点的灰度，
  210. //可以先在水平方向上由a,b线形插值求出g，c,d线形插值求出f，
  211. //然后在垂直方向上由g,f线形插值求出e 线形插值是基于这样的假设，
  212. //即原图的灰度在两个像素之间是线形变化的，一般情况下，
  213. //这种插值的效果还不错。更精确的方法是采用曲线插值（Curvilinear Interpolation），
  214. //即认为像素之间的灰度变化规律符合某种曲线，但这种处理的计算量是很大的。
  217. // 针对图像每行进行操作
  218. for(i = 0; i < lNewHeight; i++)
  219. {
  220. // 针对图像每列进行操作
  221. for(j = 0; j < lNewWidth; j++)
  222. {
  223. i0 = (LONG) (i / vzoom );
  224. j0 = (LONG) (j / hzoom );
  225. i1 = i / vzoom ;
  226. j1 = j / hzoom ;
  227. // 判断是否在源图范围内
  228.       if ((i0==i1)&&(j0==j1))
  229. *(hNewData+lNewLineBytes*  i + j) = PixelData[i0][j0];
  230.  else
  231.  {
  232. i2 = (LONG) (i / vzoom +0.5);
  233. j2 = (LONG) (j / hzoom +0.5);
  235. if (i2==lpBi->biHeight) i2=lpBi->biHeight-1;
  236. if (j2==lpBi->biWidth) j2=lpBi->biWidth-1;
  238. //f(x1)=(f(x2)-f(x0))*(x1-x0)/(x2-x0)+f(x0); 
  240. l1 = (PixelData[i0][j2]-PixelData[i0][j0])*(j1-j0)/(j2-j0)+PixelData[i0][j0];
  241. l2 = (PixelData[i2][j2]-PixelData[i2][j0])*(j1-j0)/(j2-j0)+PixelData[i2][j0];
  243. if ( (i2!=i0) && (j0!=j2) )
  244. l1 = (l2-l1)*(i1-i0)/(i2-i0)+l1;
  245. else 
  246. l1=PixelData[i0][j0];
  248. *(hNewData+lNewLineBytes*  i + j) = l1;
  249.  }
  250. }
  251. }
  254. ::GlobalUnlock((HGLOBAL)hDib);
  255. AfxGetApp()->EndWaitCursor();
  256. // 返回
  257. return hNewDIB;
  258. }
  261. //////////////////////////////////////////////////////////////////////
  262. //limb算法，生成二维数组
  263. ////////////////////////////////////////////////////////////////////
  264. BYTE **limb(int Level)
  265. {
  266. int i,j, i0,i1;
  267. BYTE ** gray;
  268. BYTE ** graytmp;
  270. i0 = pow(2,Level);
  271. gray = new BYTE*[i0];
  272. //初始化数组
  273. for (i=0;i<i0;i++)
  274. gray[i] = new BYTE[i0];
  276. //BYTE gray1[2][2]={{0,2},{3,1}};
  278. if (1==Level)
  279. {
  280. gray[0][0]=0;
  281. gray[0][1]=2;
  282. gray[1][0]=3;
  283. gray[1][1]=1;
  284. }
  285. else
  286. {
  287. ////////////////////////////////////////////////////////////////////
  288. //根据limb算法生成gray数组
  289. ////////////////////////////////////////////////////////////////////
  291. i1 = pow(2,Level-1);
  293. graytmp = new BYTE*[i1];
  294. //初始化数组
  295. for (i=0;i<i1;i++)
  296. graytmp[i] = new BYTE[i1];
  298. graytmp = limb(Level-1);
  300. for(i=0;i<i1;i++)
  301. for (j=0;j<i1;j++)
  302. gray[i][j] = 4*graytmp[i][j];
  304. for(i=0;i<i1;i++)
  305. for (j=i1;j<i0;j++)
  306. gray[i][j] = 4*graytmp[i][j-i1]+2;
  308. for(i=i1;i<i0;i++)
  309. for (j=0;j<i1;j++)
  310. gray[i][j] = 4*graytmp[i-i1][j]+3;
  312. for(i=i1;i<i0;i++)
  313. for (j=i1;j<i0;j++)
  314. gray[i][j] = 4*graytmp[i-i1][j-i1]+1;
  315.      
  317. }
  318. return gray;
  322. }
  324. /////////////////////////////////////////////////////////////////////
  325. //图像gray的衰减,
  326. //////////////////////////////////////////////////////////////////////
  327. BOOL WINAPI GrayReduce0(HDIB hDib,unsigned char ** PixelData,long GrayLevel)
  328. {
  329. /* LPBITMAPINFOHEADER lpBi;
  330. unsigned char * hData;
  332. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  334. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  337. int i,j, i0,tmp;
  338. BYTE * gray;
  340. i0 = pow(2,GrayLevel);
  341. gray = new BYTE[i0];
  342. i0--;
  343. ////////////////////////////////////////////////////////////////////
  344. //根据limb算法生成gray数组
  345. ////////////////////////////////////////////////////////////////////
  346.     for (i=0;i<i0;i++)
  347. gray[i]=0;
  349. tmp = 8- GrayLevel;
  350.   for(i=0; i<lpBi->biHeight; i++)
  351. for(j=0; j<lpBi->biWidth; j++) {
  352. ////////////////////////////////////////////////////////
  353.      if ( (PixelData[i][j]>>tmp) > 
  354.  gray[i&i0][j&i0]) //右移后做比较
  355.  *(hData+WIDTHBYTES(lpBi->biWidth*8)*i+j) = (unsigned char)255;
  356.  else
  357.  *(hData+WIDTHBYTES(lpBi->biWidth*8)*i+j) = (unsigned char)0;
  358.                    //根据算法得出结果，写回
  359.  }
  361. ::GlobalUnlock((HGLOBAL)hDib);
  363. i0 = pow(2,GrayLevel);
  365. for(i = 0; i <i0 ; i++) 
  366.     delete [] gray[i];
  367.         
  368. delete [] gray;
  370. ::GlobalUnlock((HGLOBAL)hDib);*/
  371. // 返回
  372. return true;
  373. }
  374. /*///////////////////////////////////////////////////////////////////////////
  375. // BOOL WINAPI GrayReduce(HDIB hDib,unsigned char ** PixelData,long GrayLevel)
  376. //  图像gray的衰减 
  377.  * 参数:
  378.  *   HDIB hDib    - 指向源DIB图像句柄
  379.  *  unsigned char ** PixelData 像素数组
  380.  *  long GrayLevel  灰度的值=2^GrayLevel
  381.  *   返回值:
  382.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  383. //////////////////////////////////////////////////////////////////////////*/
  384. BOOL WINAPI GrayReduce(HDIB hDib,unsigned char ** PixelData,long GrayLevel)
  385. {
  386. LPBITMAPINFOHEADER lpBi;
  387. unsigned char * hData;
  389. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  391. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  393. long i,j, i0,tmp,lLineBytes;
  394. lLineBytes = WIDTHBYTES(lpBi->biWidth*8);
  396. BYTE ** gray;
  398. i0 = pow(2,GrayLevel)-1;
  399. ////////////////////////////////////////////////////////////////////
  400. //根据limb算法生成gray数组
  401. ////////////////////////////////////////////////////////////////////
  402. gray = limb(GrayLevel);
  404. tmp = 8- (GrayLevel*2);
  405.   for(i=0; i<lpBi->biHeight; i++)
  406. for(j=0; j<lpBi->biWidth; j++) {
  407. ////////////////////////////////////////////////////////
  408.      if ( (PixelData[i][j]>>tmp) > 
  409.  gray[i&i0][j&i0]) //右移后做比较
  410.  *(hData+lLineBytes*i+j) = (unsigned char)255;
  411.  else
  412.  *(hData+lLineBytes*i+j) = (unsigned char)0;
  413.                    //根据算法得出结果，写回
  414.  }
  416. ::GlobalUnlock((HGLOBAL)hDib);
  418. i0 = pow(2,GrayLevel);
  420. for(i = 0; i <i0 ; i++) 
  421.     delete [] gray[i];
  422.         
  423. delete [] gray;
  425. ::GlobalUnlock((HGLOBAL)hDib);
  426. // 返回
  427. return true;
  428. }
  429. /*///////////////////////////////////////////////////////////////////////////
  430. // BOOL WINAPI Reverse(HDIB hDib,unsigned char ** PixelData)
  431. // //灰度图像的反色处理
  432.  * 参数:
  433.  *   HDIB hDib    - 指向源DIB图像句柄
  434.  *  unsigned char ** PixelData 像素数组
  435.  *   返回值:
  436.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  437. //////////////////////////////////////////////////////////////////////////*/
  438. BOOL WINAPI Reverse(HDIB hDib,unsigned char ** PixelData)
  439. {
  440. LPBITMAPINFOHEADER lpBi;
  441. unsigned char * hData;
  443. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  445. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  447. long i,j,lLineBytes,k;
  448.  
  449. if (lpBi->biBitCount==8) k=1;
  450. if (lpBi->biBitCount==24) k=3;
  452. lLineBytes = WIDTHBYTES(lpBi->biWidth*8*k);
  453. for(i=0; i<lpBi->biHeight; i++)
  454. for(j=0; j<lpBi->biWidth*k; j++) {
  455. *(hData+lLineBytes*i+j)=
  456. (unsigned char)(255-PixelData[i][j]);//根据算法得出结果，写回
  458.  }
  460. ::GlobalUnlock((HGLOBAL)hDib);
  462. return true;
  463. }
  464. /*///////////////////////////////////////////////////////////////////////////
  465. // BOOL WINAPI TransHalftone(HDIB hDib,unsigned char ** PixelData)
  466. // 图像的halftone处理
  467.  * 参数:
  468.  *   HDIB hDib    - 指向源DIB图像句柄
  469.  *  unsigned char ** PixelData 像素数组
  470.  *   返回值:
  471.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  472. //////////////////////////////////////////////////////////////////////////*/
  474. BOOL WINAPI TransHalftone (HDIB hDib,unsigned char ** PixelData)
  475. {
  476. static int  gr[3][3]= {{84,28,140},{224,252,168},{112,196,56}};
  477. LPBITMAPINFOHEADER lpZoomOutBi,lpBi;
  478. unsigned char * hData;
  479. unsigned char * hZoomOutData;
  480. unsigned char tmp;
  482. int lZoomOutLineBytes, lLineBytes;
  484. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  486. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  487. lLineBytes = WIDTHBYTES(lpBi->biWidth*8);
  489. HDIB hZoomOutDib;
  491. //首先缩小图像宽与高的1/3
  492. hZoomOutDib=(HDIB)ZoomPixelreplication(hDib,PixelData,(float)0.33,(float)0.33);
  495. lpZoomOutBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hZoomOutDib);
  497. hZoomOutData=(unsigned char*)FindDIBBits((LPSTR)lpZoomOutBi);
  498. lZoomOutLineBytes=WIDTHBYTES(lpZoomOutBi->biWidth*8);
  500. int i,j,i0,j0,ll=0;
  502. //每个像素对应9个新点
  503. for(i=0; i<lpZoomOutBi->biHeight; i++)
  504. for(j=0; j<lpZoomOutBi->biWidth; j++) 
  505. {
  506. tmp = *(hZoomOutData+i*lZoomOutLineBytes+j);
  507. for (i0=0;i0<3;i0++)
  508. for(j0=0;j0<3;j0++)
  509. if (tmp>=gr[i0][j0])
  510. *(hData+lLineBytes*(i*3+i0)+j*3+j0)=255;
  511. else
  512. *(hData+lLineBytes*(i*3+i0)+j*3+j0)=0;
  513. }
  516. ::GlobalUnlock((HGLOBAL)hZoomOutDib);
  517. ::GlobalFree((HGLOBAL)hZoomOutDib);
  518.     ::GlobalUnlock((HGLOBAL)hDib);
  520. return true;
  521. }
  523. /////////////////////////////////////////////////////////////////////
  524. //将24位的彩色图转为8位灰度图
  525. /////////////////////////////////////////////////////////////////////
  526. BOOL WINAPI Bmp2256 (HDIB hDib,unsigned char ** PixelData,const CString FileName1)
  527. {
  528. CFile file;
  529. CFileException fileException;
  530. LPBITMAPINFOHEADER lpOldBi;
  532. BITMAPINFOHEADER bi;
  533. BITMAPFILEHEADER bh;
  534. RGBQUAD lrgb[256];
  535. HLOCAL hNewDIBBits;
  536. LPSTR lpSrc,lpDst,lpNewDIBBits;
  538. unsigned char lGray;
  539. long lWidth,lHeight, lSize,lLineBytes;
  541. // 循环变量（象素在新DIB中的坐标）
  542. LONG i,j,j0;
  543. AfxGetApp()->BeginWaitCursor();    
  545. if (!file.Open(FileName1, CFile::modeCreate |
  546.       CFile::modeReadWrite | CFile::shareExclusive, &fileException))
  547.   return FALSE;
  549. lpSrc = (LPSTR)::GlobalLock((HGLOBAL) hDib);
  550. lpOldBi=(LPBITMAPINFOHEADER)lpSrc;
  552. lWidth = lpOldBi->biWidth;
  553. lHeight = lpOldBi->biHeight;
  555. // 计算新图像每行的字节数
  556. lLineBytes = WIDTHBYTES(lWidth * 8 );
  558. // 分配内存，以保存新DIB
  559. lSize = lLineBytes * lHeight;
  561. //更新文件头
  562. bh.bfType = DIB_HEADER_MARKER;;
  563. bh.bfSize = lSize+sizeof(bh)+sizeof(bi)+
  564. 256*sizeof(RGBQUAD);
  565. bh.bfReserved1=0;
  566. bh.bfReserved2=0;
  567. bh.bfOffBits = sizeof(bh)+sizeof(bi)+256*sizeof(RGBQUAD);
  568. file.Write(&bh,14);
  570. // 文件信息头
  571. bi.biWidth = lWidth;
  572. bi.biHeight = lHeight;
  573. bi.biBitCount=8;
  574. bi.biSizeImage = lLineBytes * lHeight;
  575. bi.biClrImportant=0;
  576. bi.biClrUsed=0;
  577. bi.biCompression=0;
  578. bi.biPlanes=1;
  579. bi.biSize=40;
  580. file.Write(&bi,40);
  582. ::GlobalUnlock((HGLOBAL)hDib);
  584. // 计算灰度映射表（保存各个颜色的灰度值），并更新DIB调色板
  585. for (i = 0; i < 256; i ++)
  586. {
  587. // 计算该颜色对应的灰度值
  588. lrgb[i].rgbRed = i;
  589. lrgb[i].rgbGreen = i;
  590. lrgb[i].rgbBlue = i;
  591. lrgb[i].rgbReserved = 0;
  592. file.Write(&lrgb[i],sizeof(RGBQUAD));
  593. }
  596. hNewDIBBits = LocalAlloc(LHND, lSize);
  598. if (hNewDIBBits == NULL)
  599. // 分配内存失败
  600. return FALSE;
  602. // 锁定内存
  603. lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
  604. // 初始化新分配的内存，设定初始值为255
  605. lpDst = (char *)lpNewDIBBits;
  606. memset(lpDst, (BYTE)255, lSize);
  608. // 针对图像每行进行操作
  609. for(i = 0; i < lHeight; i++)
  610. // 针对图像每列进行操作
  611. for(j = 0; j < lWidth; j++)
  612. // 为像素赋值
  613. {
  614. j0 = j*3;
  615. lGray =(299*PixelData[i][j0] +
  616. 587*PixelData[i][j0+1] + 
  617. 114*PixelData[i][j0+2])/1000;
  618. *(lpDst+lLineBytes* i + j) = (unsigned char)lGray;
  619. }
  621. file.Write(lpDst,lSize);
  622. file.Close();
  623. // 释放内存
  624. LocalUnlock(hNewDIBBits);
  625. LocalFree(hNewDIBBits);
  627. AfxGetApp()->EndWaitCursor();
  629. return true;
  630. }
  632. /*///////////////////////////////////////////////////////////////////////////
  633. // BOOL WINAPI ArithmeticOpr (HDIB hDib,unsigned char ** PixelData,
  634. //    unsigned char ** PixelData2,const CString Opr,
  635. //    const int width,const int height,const double scale,const double factor)
  636. // 图像的算数处理
  637.  * 参数:
  638.  *   HDIB hDib    - 指向源DIB图像句柄
  639.  *  unsigned char ** PixelData    BK像素数组
  640.  *   unsigned char ** PixelData2   前景像素数组
  641.  *   const CString Opr, 算术操作符号
  642.  *   const int width,           要处理的图像宽度
  643.  *   const int height, 要处理的图像高度
  644.  *   const double scale 加减时为scale
  645.  *   加减(source1+source2)/scale+offset
  646.  *   const double factor        乘法时为 乘法的乘数，加减时为offset
  647.  *   返回值:
  648.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  649. //////////////////////////////////////////////////////////////////////////*/
  652. BOOL WINAPI ArithmeticOpr (HDIB hDib,unsigned char ** PixelData,
  653.    unsigned char ** PixelData2,const CString Opr,
  654.    const int width,const int height,const double scale,
  655.    const double factor)
  656. {
  657. LPBITMAPINFOHEADER lpBi;
  658. unsigned char * hData;
  659. long lLineBytes,len,lrgb,ltruebit;
  661. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  663. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  665. if (8==lpBi->biBitCount) len=1;
  666.     if (24==lpBi->biBitCount) len=3;
  669. lLineBytes = WIDTHBYTES(lpBi->biWidth*8*len); 
  671. int i,j;
  672. float tmp;
  674. for (lrgb=0;lrgb<3;lrgb++)
  675. for(i=0; i<height; i++)
  676. for(j=0; j<width; j++) 
  677. {
  678. ltruebit=j*len+lrgb;
  679. if (Opr=="*")
  680. tmp = PixelData[i][ltruebit]*factor;
  681. if (Opr=="+")
  682. tmp = (PixelData[i][ltruebit]+PixelData2[i][ltruebit])/scale+factor;
  683. if (Opr=="-")
  684. tmp = (PixelData[i][ltruebit]-PixelData2[i][ltruebit])/scale+factor;
  686. if (tmp>255) tmp=255;
  687. if (tmp<0) tmp=0;
  688. *(hData+lLineBytes*i+ltruebit)=tmp;
  690. }
  692. // delete PixelData2;
  694. ::GlobalUnlock((HGLOBAL)hDib);
  695. return true;
  696. }
  697. /*///////////////////////////////////////////////////////////////////////////
  698. // BOOL WINAPI TransBw(HDIB hDib,unsigned char ** PixelData)
  699. // 生成黑白间隔图
  700.  * 参数:
  701.  *   HDIB hDib    - 指向源DIB图像句柄
  702.  *  unsigned char ** PixelData 像素数组
  703.  *   返回值:
  704.  *   BOOL               - 运算成功返回TRUE，否则返回FALSE。
  705. //////////////////////////////////////////////////////////////////////////*/
  706. HGLOBAL WINAPI TransBw(HDIB hDib)
  707. {
  708. LPBITMAPINFOHEADER lpBi;
  709. unsigned char * hData;
  711. lpBi=(LPBITMAPINFOHEADER)GlobalLock((HGLOBAL)hDib);
  713. hData=(unsigned char*)FindDIBBits((LPSTR)lpBi);
  715. int i,j;
  717. // 新DIB句柄
  718. HDIB hNewDIB;
  719. // 缩放后图像的宽度和高度
  720. LONG lNewWidth=0,lNewHeight=0, lNewLineBytes;
  723. // 图像的宽度（lNewWidth'，必须是4的倍数）
  725. // 指向缩放图像的指针
  726. LPSTR lpNewDIB;
  727. unsigned char * hNewData;
  729. // 指向BITMAPINFO结构的指针（Win3.0）
  730. LPBITMAPINFOHEADER lpbmi;
  732. // 循环变量（象素在新DIB中的坐标）
  733.     
  734. AfxGetApp()->BeginWaitCursor();
  735. // 计算缩放后的图像实际宽度
  736. lNewWidth = 256;
  738. // 计算新图像每行的字节数
  739. lNewLineBytes = WIDTHBYTES(lNewWidth * 8);
  741. // 计算缩放后的图像高度
  742. lNewHeight = 256;
  744. // 分配内存，以保存新DIB
  745. hNewDIB = (HDIB) ::GlobalAlloc(GHND, lNewLineBytes * lNewHeight + *(LPDWORD)(lpBi)  +
  746.                                ::PaletteSize((LPSTR)lpBi));
  748. // 判断是否内存分配失败
  749. if (hNewDIB == NULL)// 分配内存失败
  750. return NULL;
  752. // 锁定内存
  753. lpNewDIB =  (char * )::GlobalLock((HGLOBAL) hNewDIB);
  755. // 复制DIB信息头和调色板
  756. memcpy(lpNewDIB, (LPSTR)lpBi, *(LPDWORD)(lpBi) + ::PaletteSize((LPSTR)lpBi));
  758. ::GlobalUnlock((HGLOBAL)hDib);
  761. // 找到新DIB象素起始位置
  762. hNewData = (unsigned char*)::FindDIBBits(lpNewDIB);
  764. // 获取指针
  765. lpbmi = (LPBITMAPINFOHEADER)lpNewDIB;
  767. // 更新DIB中图像的高度和宽度
  768. lpbmi->biWidth = lNewWidth;
  769. lpbmi->biHeight = lNewHeight;
  772. for(i=0; i<lNewWidth; i++)
  773. for(j=0; j<lNewHeight; j++) 
  774. {
  775. if (div(i,2).rem==0)
  776. *(hNewData+lNewLineBytes*j+i)=(unsigned char)(0);
  777. else
  778. *(hNewData+lNewLineBytes*j+i)=(unsigned char)(255);
  779. //根据算法得出结果，写回
  780.  }
  782. AfxGetApp()->EndWaitCursor();
  783. // 返回
  784. return hNewDIB;
  785. }