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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图形图像处理 > 查看源码
DIB.cpp
资源名称：人脸识别系统设计—毕业设计.rar　[点击查看]
上传用户：sdsuchuang
上传日期：2013-01-12
资源大小：2228k
文件大小：18k
源码类别：

图形图像处理

开发平台：

Visual C++

DIB.cpp：源码内容
  1. // DIB.cpp: implementation of the DIB class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "DIB.h"
  7. #include"math.h"
  8. #include "LikelyHood.h"
  9. #define WIDTHBYTES(bits)  ((bits+31)/32*4)
  10. #define RECTWIDTH(x) (x->right-x->left)
  11. #define RECTHEIGHT(x) (x->bottom-x->top)
  12. #define THRESHOLDCONTRAST  40
  13. #ifdef _DEBUG
  14. #undef THIS_FILE
  15. static char THIS_FILE[]=__FILE__;
  16. #define new DEBUG_NEW
  17. #endif
  18. #define PI 3.1415926
  19. extern int locax,locay;
  20. #define m_WIDTH 600
  21. #define m_HEIGHT 600
  23. //////////////////////////////////////////////////////////////////////
  24. // Construction/Destruction
  25. /////////////////////////////////////////////////////////////////////
  26. HDIB DIB::ReadDIBFile(HANDLE hFile)
  27. {
  28. BITMAPFILEHEADER bmfHeader;
  29. DWORD dwBitsSize;
  30. HANDLE hDIB;
  31. HANDLE hDIBtmp;
  32. LPBITMAPINFOHEADER lpbi;
  33. DWORD dwRead;
  34.     //得到文件大小
  35. dwBitsSize = GetFileSize(hFile,NULL);
  36. hDIB =  GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)));
  38. if(!hDIB)
  39. return NULL;
  41. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  42. if(!lpbi)
  43. {
  44. GlobalFree(hDIB);
  45. return NULL;
  46. }
  48. if(!ReadFile(hFile,(LPBYTE)&bmfHeader,sizeof(BITMAPFILEHEADER),&dwRead,NULL))
  49. goto ErrExit;
  50. if(sizeof(BITMAPFILEHEADER)!=dwRead)//读取文件出错
  51. goto ErrExit;
  52. if(bmfHeader.bfType != 0x4d42)//文件类型不匹配
  53. goto ErrExit;
  54. if(!ReadFile(hFile,(LPBYTE)lpbi,sizeof(BITMAPINFOHEADER),&dwRead,NULL))
  55. goto ErrExit;
  56. if(sizeof(BITMAPINFOHEADER)!= dwRead)//读取数据出错
  57. goto ErrExit;
  59. GlobalUnlock(hDIB);
  60. if(lpbi->biSizeImage==0)
  61. lpbi->biSizeImage = (this->BytePerLine(hDIB))*lpbi->biHeight;
  62. hDIBtmp = GlobalReAlloc(hDIB,lpbi->biSize+lpbi->biSizeImage,0);
  63. if(!hDIBtmp)
  64. goto ErrExitNoUnlock;
  65. else
  66. hDIB = hDIBtmp;
  67. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  68. //根据情况设定文件指针
  69. if(bmfHeader.bfOffBits != 0L)
  70. SetFilePointer(hFile,bmfHeader.bfOffBits,NULL,FILE_BEGIN);
  71.     //读取文件的象素颜色数据
  72. if(ReadFile(hFile,(LPBYTE)lpbi+lpbi->biSize,lpbi->biSizeImage,&dwRead,NULL))
  73. goto OKExit;
  75. ErrExit:
  76. GlobalUnlock(hDIB);
  78. ErrExitNoUnlock:
  79. GlobalFree(hDIB); //释放内存
  80. return NULL;
  82. OKExit:
  83. GlobalUnlock(hDIB);
  84. return hDIB;
  86. }
  89. HDIB DIB::LoadDIB(LPCTSTR lpFileName)
  90. {
  91. HANDLE hDIB;
  92. HANDLE hFile;
  93. //创建文件句柄
  94. if((hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))!= INVALID_HANDLE_VALUE)
  95. {  
  96. //读取数据
  97. hDIB = ReadDIBFile(hFile);
  98. //关闭文件句柄
  99. CloseHandle(hFile);
  100. return hDIB;
  101. }
  102. return NULL;
  103. }
  105. BOOL DIB::PaintDIBTrue(HDC hDC,LPRECT lpDCRect,HANDLE hDIB,LPRECT lpDIBRect ,DWORD dwRop)
  106. {
  107. LPBYTE lpDIBHdr;
  108. LPBYTE lpDIBBits;
  109. BOOL bSuccess = FALSE;
  111. if(!hDIB)
  112. return FALSE;
  113. lpDIBHdr = (LPBYTE)GlobalLock(hDIB);
  114. lpDIBBits = lpDIBHdr + sizeof(BITMAPINFOHEADER);
  115. bSuccess = StretchDIBits(hDC,lpDCRect->left,
  116.  lpDCRect->top,
  117.  RECTWIDTH(lpDCRect),
  118.  RECTHEIGHT(lpDCRect),
  119.  lpDIBRect->left,
  120.  ((LPBITMAPINFOHEADER)lpDIBHdr)->biHeight-lpDIBRect->top-RECTHEIGHT(lpDIBRect),
  121.  RECTWIDTH(lpDIBRect),
  122.  RECTHEIGHT(lpDIBRect),
  123.  lpDIBBits,
  124.  (LPBITMAPINFO)lpDIBHdr,
  125.  DIB_RGB_COLORS,
  126.  SRCCOPY);
  127. GlobalUnlock(hDIB);
  128. return bSuccess;
  129. }
  132. BOOL DIB::PaintDIBTrue1(HDC hDC,LPRECT lpDCRect,HANDLE hDIB,LPRECT lpDIBRect ,DWORD dwRop)
  133. {
  134. LPBYTE lpDIBHdr;
  135. LPBYTE lpDIBBits;
  136. BOOL bSuccess = FALSE;
  138. if(!hDIB)
  139. return FALSE;
  140. lpDIBHdr = (LPBYTE)GlobalLock(hDIB);
  141. lpDIBBits = lpDIBHdr + sizeof(BITMAPINFOHEADER);
  142. bSuccess = StretchDIBits(hDC,lpDCRect->left,
  143.  lpDCRect->top,
  144.  RECTWIDTH(lpDCRect),
  145.  RECTHEIGHT(lpDCRect),
  146.  lpDIBRect->left,
  147.  ((LPBITMAPINFOHEADER)lpDIBHdr)->biHeight-lpDIBRect->top-RECTHEIGHT(lpDIBRect),
  148.  RECTWIDTH(lpDIBRect),
  149.  RECTHEIGHT(lpDIBRect),
  150.  lpDIBBits,
  151.  (LPBITMAPINFO)lpDIBHdr,
  152.  DIB_RGB_COLORS,
  153.  SRCCOPY);
  154. GlobalUnlock(hDIB);
  155. return bSuccess;
  156. }
  158. WORD DIB::BytePerLine(HANDLE hDIB)
  159. {
  160. WORD i;
  161. LPBITMAPINFOHEADER lpbi;
  162. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  163. i = WIDTHBYTES((lpbi->biWidth)*24);
  164. GlobalUnlock(hDIB);
  165. return i;
  166. }
  169. LPBYTE  DIB::FindDIBBits(HANDLE hDIB)
  170. {
  171. LPBYTE lpDIB,lpDIBtmp;
  172. LPBITMAPINFOHEADER lpbi;
  173. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  174. lpDIBtmp = (LPBYTE)lpbi;
  175. lpDIB = lpDIBtmp + sizeof(BITMAPINFOHEADER);
  176. GlobalUnlock(hDIB);
  177. return lpDIB;
  178. }
  180. long DIB::PixelOffset(int i,int j,WORD wBytePerLine)
  181. {
  182. long   Offset;
  183. Offset = i*wBytePerLine + j*3;
  184. return Offset;
  185. }
  192. DIB::DIB()
  193. {
  194. for(int i=0;i<ImgRange; i++)
  195. for (int j=0; j<ImgRange; j++)
  196. this->lab[i][j] = false;
  197. m_pDib=NULL;
  199. }
  200. DIB::~DIB()
  201. {
  203. }
  209. BOOL DIB:: SaveDIB(HANDLE hDib, CFile& file)
  210. {
  211. // Bitmap文件头
  212. BITMAPFILEHEADER bmfHdr;
  214. // 指向BITMAPINFOHEADER的指针
  215. LPBITMAPINFOHEADER lpBI;
  217. // DIB大小
  218. DWORD dwDIBSize =0;
  220. if (hDib == NULL)
  221. {
  222. // 如果DIB为空，返回FALSE
  223. return FALSE;
  224. }
  226. // 读取BITMAPINFO结构，并锁定
  227. lpBI = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);
  229. if (lpBI == NULL)
  230. {
  231. // 为空，返回FALSE
  232. return FALSE;
  233. }
  235. // 判断是否是WIN3.0 DIB
  236. // if (!IS_WIN30_DIB(lpBI))
  237. // {
  238. // 不支持其它类型的DIB保存
  240. // 解除锁定
  241. // ::GlobalUnlock((HGLOBAL) hDib);
  243. // 返回FALSE
  244. // return FALSE;
  245. // }
  247. // 填充文件头
  249. // 文件类型"BM"
  250. bmfHdr.bfType =  0x4d42; //DIB_HEADER_MARKER;
  252. // 计算DIB大小时，最简单的方法是调用GlobalSize()函数。但是全局内存大小并
  253. // 不是DIB真正的大小，它总是多几个字节。这样就需要计算一下DIB的真实大小。
  255. // 文件头大小＋颜色表大小
  256. // （BITMAPINFOHEADER和BITMAPCOREHEADER结构的第一个DWORD都是该结构的大小）
  257. // dwDIBSize = *(LPDWORD)lpBI; //+ ::PaletteSize((LPSTR)lpBI);
  258. dwDIBSize = sizeof(BITMAPINFOHEADER);//+lpBI->biSizeImage;
  259. // 计算图像大小
  260. if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
  261. {
  262. // 对于RLE位图，没法计算大小，只能信任biSizeImage内的值
  263. dwDIBSize += lpBI->biSizeImage;
  264. }
  265. else
  266. {
  267. // 象素的大小
  268. DWORD dwBmBitsSize;
  270. // 大小为Width * Height
  271. dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*24) * lpBI->biHeight;
  273. // 计算出DIB真正的大小
  274. dwDIBSize += dwBmBitsSize;
  276. // 更新biSizeImage（很多BMP文件头中biSizeImage的值是错误的）
  277. lpBI->biSizeImage = dwBmBitsSize;
  278. }
  281. // 计算文件大小：DIB大小＋BITMAPFILEHEADER结构大小
  282. bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
  284. // 两个保留字
  285. bmfHdr.bfReserved1 = 0;
  286. bmfHdr.bfReserved2 = 0;
  288. // 计算偏移量bfOffBits，它的大小为Bitmap文件头大小＋DIB头大小＋颜色表大小
  289. bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize;
  290.  // + PaletteSize((LPSTR)lpBI);
  291. // 尝试写文件
  292. // TRY
  293. {
  294. // 写文件头
  295. file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
  297. // 写DIB头和象素
  298. file.WriteHuge(lpBI, dwDIBSize);
  299. }
  300. // CATCH (CFileException, e)
  301. // {
  302. // 解除锁定
  303. // ::GlobalUnlock((HGLOBAL) hDib);
  305. // 抛出异常
  306. /// THROW_LAST();
  307. // }
  308. // END_CATCH
  310. // 解除锁定
  311. ::GlobalUnlock((HGLOBAL) hDib);
  313. // 返回TRUE
  314. return TRUE;
  315. }
  318. HANDLE DIB::CopyHandle( HANDLE hSrc)
  319. {
  320. HANDLE hDst;
  321. LPBITMAPINFOHEADER lpbi;
  322. int width,height;
  323. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hSrc);
  324. width = lpbi->biWidth;
  325. height = lpbi->biHeight;
  326. hDst = GlobalAlloc(GMEM_MOVEABLE,lpbi->biSize+lpbi->biSizeImage);
  327. if(!hDst)
  328. return NULL;
  329. LPBYTE lpDest;
  330. lpDest = (LPBYTE)GlobalLock(hDst);
  331. memcpy(lpDest,(LPBYTE)lpbi,lpbi->biSize+lpbi->biSizeImage);
  332. GlobalUnlock(hSrc);
  333. GlobalUnlock(hDst);
  334. return hDst;
  336. }
  339. BYTE * DIB::GetBits()
  340. {
  341. //the size of the color map is determined by the number
  342. //of RGBQUAD structures presend.
  343. //it also depends on the bit_depth of the Dib
  344. DWORD dwNumColors,dwColorTableSize;
  345. BITMAPINFOHEADER *lpDib=(BITMAPINFOHEADER *)m_pDib;
  346.           
  347. WORD wBitCount=lpDib->biBitCount;
  349. if(lpDib->biSize>=36)
  350. dwNumColors=lpDib->biClrUsed;
  351. else
  352. dwNumColors=0;
  353.       
  354. if(dwNumColors==0)
  355. {
  356. if(wBitCount!=24)
  357. dwNumColors=1L<<wBitCount;
  358. else 
  359. dwNumColors=0;
  360. }
  362. dwColorTableSize=dwNumColors*sizeof(RGBQUAD);
  364. return m_pDib+lpDib->biSize+dwColorTableSize;
  365. }
  367. int DIB::GetBiBitCount()
  368. {
  369. if(m_pDib!=NULL)
  370. return ((BITMAPINFOHEADER *)m_pDib)->biBitCount; 
  371. return 0;
  372. }
  374. LONG DIB::GetWidth()
  375. {
  376. return ((BITMAPINFOHEADER *)m_pDib)->biWidth;
  377. }
  379. LONG DIB::GetHeight()
  380. {
  381. return ((BITMAPINFOHEADER *)m_pDib)->biHeight;
  382. }
  384. //////////////////////光线补偿//////////////////////////////
  385. ////////////////////////////////////////////////////////////
  386. BOOL DIB::LightingCompensate(HANDLE hDIB)
  387. {
  388. if(!hDIB)
  389. return FALSE;
  390. LPBITMAPINFOHEADER lpbi;
  391. int width,height;
  392. LPBYTE lpData;
  393. WORD wBytesPerLine;
  394. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  395. //得到图片宽和高
  396. width = lpbi->biWidth;
  397. height = lpbi->biHeight;
  398. //得到图片数据区
  399. lpData = this->FindDIBBits(hDIB);
  400. //得到图片每行的象素所占字节个数
  401. wBytesPerLine = this->BytePerLine(hDIB);
  402. //比例系数
  403. const float thresholdco = 0.05;
  404. //象素个数的临界常数
  405. const int thresholdnum = 100;
  406. //灰度级数组
  407. int histogram[256];
  408. for(int i =0;i<256;i++)
  409. histogram[i] = 0;
  410. //对于过于小的图片的判断
  411. if(width*height*thresholdco < thresholdnum)
  412. return false;
  413. int colorr,colorg,colorb;
  414. long lOffset;
  415. //考察整个图片
  417. for( i=0;i<height;i++)
  418. for(int j=0;j<width;j++)
  419. {
  420. //得到象素数据的偏移
  421. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  422. //得到rgb值
  423. colorb = *(lpData+lOffset++);
  424. colorg = *(lpData+lOffset++);
  425. colorr = *(lpData+lOffset++);
  426. //计算灰度值
  427. int gray = (colorr * 299 + colorg * 587 + colorb * 114)/1000;
  428. histogram[gray]++;
  429. }
  430. int calnum =0;
  431. int total = width*height;
  432. int num;
  433. //下面的循环得到满足系数thresholdco的临界灰度级
  434. for(i =0;i<256;i++)
  435. {
  436. if((float)calnum/total < thresholdco)
  437. {
  438. calnum+= histogram[255-i];
  439. num = i;
  440. }
  441. else
  442. break;
  443. }
  444. int averagegray = 0;
  445. calnum =0;
  446. //得到满足条件的象素总的灰度值
  447. for(i = 255;i>=255-num;i--)
  448. {
  449. averagegray += histogram[i]*i;
  450. calnum += histogram[i];
  451. }
  452. averagegray /=calnum;
  453. //得到光线补偿的系数
  454. float co = 255.0/(float)averagegray;
  455. //下面的循环对图象进行光线补偿
  456. for(i =0;i<height;i++)
  457. for(int j=0;j<width;j++)
  458. {
  459. //得到数据偏移
  460. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  461. //得到蓝色分量
  462. colorb = *(lpData+lOffset);
  463. //调整
  464. colorb *=co;
  465. //临界判断
  466. if(colorb >255)
  467. colorb = 255;
  468. //保存
  469. *(lpData+lOffset) = colorb;
  470. //绿色分量
  471. colorb = *(lpData+lOffset+1);
  472. colorb *=co;
  473. if(colorb >255)
  474. colorb = 255;
  475. *(lpData+lOffset+1) = colorb;
  476. //红色分量
  477. colorb = *(lpData+lOffset+2);
  478. colorb *=co;
  479. if(colorb >255)
  480. colorb = 255;
  481. *(lpData+lOffset+2) = colorb;
  483. }
  485. return TRUE;
  486. }
  487. //////////////////////////////////////膨胀////////////////////////////////////////////
  488. /////////////////////////////////////////////////////////////////////////////////////
  489. void DIB::Dilation(HANDLE hDIB,int m_top,int m_bottom,int m_left,int m_right)
  490. {
  491. LPBITMAPINFOHEADER lpbi;
  492. int height;
  493. int width;
  494. WORD wBytesPerLine;
  495. LPBYTE lpData;
  496. LPBYTE lpTemp;
  497. long lOffset;
  498. //得到图象的基本信息
  499. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  500. height = m_top;
  501. width = m_right;
  502. wBytesPerLine = this->BytePerLine(hDIB);
  503. lpData = this->FindDIBBits(hDIB);
  504. //申请一块和数据区大小相同的内存
  505. lpTemp = (LPBYTE) new BYTE[wBytesPerLine * height];
  508. long lOffsetJudge;
  509. for (int i=1+m_bottom; i<height-1; i++)
  510. for (int j=1+m_left; j<width-1; j++)
  511. {
  512. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  513. //如果当前点为白色，接着循环
  514. if(*(lpData + lOffset) == 255)
  515. {
  516. *(lpTemp + lOffset++) = 255;
  517. *(lpTemp + lOffset++) = 255;
  518. *(lpTemp + lOffset++) = 255;
  519. continue;
  520. }
  521. //否则考察上下左右四个点
  522. else
  523. {
  524. lOffsetJudge = this->PixelOffset(i-1, j, wBytesPerLine);
  525. //如果上面的点为白色
  526. if(*(lpData + lOffsetJudge) == 255)
  527. { //设置为白色，并继续循环
  528. *(lpTemp + lOffset++) = 255;
  529. *(lpTemp + lOffset++) = 255;
  530. *(lpTemp + lOffset++) = 255;
  531. continue;
  532. }
  534. //考察下面的点
  535. lOffsetJudge = this->PixelOffset(i+1,j, wBytesPerLine);
  536. if(*(lpData + lOffsetJudge) == 255)
  537. {
  538. *(lpTemp + lOffset++) = 255;
  539. *(lpTemp + lOffset++) = 255;
  540. *(lpTemp + lOffset++) = 255;
  541. continue;
  542. }
  544. //考察左边的点
  545. lOffsetJudge = this->PixelOffset(i,j-1, wBytesPerLine);
  546. if(*(lpData + lOffsetJudge) == 255)
  547. {
  548. *(lpTemp + lOffset++) = 255;
  549. *(lpTemp + lOffset++) = 255;
  550. *(lpTemp + lOffset++) = 255;
  551. continue;
  552. }
  553. //考察右边的点
  554. lOffsetJudge = this->PixelOffset(i,j+1, wBytesPerLine);
  555. if(*(lpData + lOffsetJudge) == 255)
  556. {
  557. *(lpTemp + lOffset++) = 255;
  558. *(lpTemp + lOffset++) = 255;
  559. *(lpTemp + lOffset++) = 255;
  560. continue;
  561. }
  562. //如果上下左右都是黑色点，则把暂时区域的点设置为黑色
  563. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  564. *(lpTemp + lOffset++) = 0;
  565. *(lpTemp + lOffset++) = 0;
  566. *(lpTemp + lOffset++) = 0;
  568. }
  570. }
  571. //处理图象四周的点，设置为黑色
  572. for(i=m_bottom; i<height; i++)
  573. {
  574. lOffset = this->PixelOffset(i, 0, wBytesPerLine);
  575. {
  576. *(lpTemp + lOffset++) = 0;
  577. *(lpTemp + lOffset++) = 0;
  578. *(lpTemp + lOffset++) = 0;
  579. }
  580. }
  582. for(i=m_bottom; i<height; i++)
  583. {
  584. lOffset = this->PixelOffset(i, width-1, wBytesPerLine);
  585. {
  586. *(lpTemp + lOffset++) = 0;
  587. *(lpTemp + lOffset++) = 0;
  588. *(lpTemp + lOffset++) = 0;
  589. }
  590. }
  592. for(i=m_left; i<width; i++)
  593. {
  594. lOffset = this->PixelOffset(0, i, wBytesPerLine);
  595. {
  596. *(lpTemp + lOffset++) = 0;
  597. *(lpTemp + lOffset++) = 0;
  598. *(lpTemp + lOffset++) = 0;
  599. }
  600. }
  602. for(i=m_left; i<width; i++)
  603. {
  604. lOffset = this->PixelOffset(height-1, i, wBytesPerLine);
  605. {
  606. *(lpTemp + lOffset++) = 0;
  607. *(lpTemp + lOffset++) = 0;
  608. *(lpTemp + lOffset++) = 0;
  609. }
  610. }
  611. //把暂时区域的点拷贝到原句柄区域下面
  612. memcpy(lpData, lpTemp, wBytesPerLine*height);
  613. delete [] lpTemp;
  614. GlobalUnlock(hDIB);
  616. }
  617. ////////////////////////////////////////////////////////////////////////////////
  618. /////////////////////////////////////腐蚀///////////////////////////////////////
  619. void DIB::Erasion(HANDLE hDIB,int m_top,int m_bottom,int m_left,int m_right)
  620. {
  622. LPBITMAPINFOHEADER lpbi;
  623. LPBYTE lpData;
  624. WORD wBytesPerLine;
  625. long lOffset;
  626. long lOffsetJudge;
  627. int height;
  628. int width;
  630. //得到基本数据
  631. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  632. height = m_top;
  633. width = m_right;
  634. wBytesPerLine = BytePerLine(hDIB);
  635. lpData = FindDIBBits(hDIB);
  637. HANDLE hTempDIB;
  638. LPBYTE lpTemp;
  639. //申请同样大小的内存
  640. hTempDIB =   GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER) + wBytesPerLine*height));
  641. //判断内存情况
  642. if(!hTempDIB)
  643. {
  644. GlobalFree(hTempDIB);
  645. GlobalFree(hDIB);
  646. return;
  647. }
  648. lpTemp = (LPBYTE)GlobalLock(hTempDIB);
  649. lpTemp+= sizeof(BITMAPINFOHEADER);
  650. //下面的循环实现腐蚀功能
  651. for (int i=1+m_bottom; i<height-1; i++)
  652. for (int j=1+m_left; j<width-1; j++)
  653. {
  654. lOffset = PixelOffset(i,j,wBytesPerLine);
  655. //如果为白色点
  656. if (*(lpData+lOffset) == 255)
  657. {
  658. //考察上面的点
  659. lOffsetJudge = PixelOffset(i-1, j, wBytesPerLine);
  660. //如果是黑色就把原来的点设置为黑色，并接着循环
  661. if (*(lpData + lOffsetJudge) ==0)
  662. {
  663. *(lpTemp + lOffset++) = 0;
  664. *(lpTemp + lOffset++) = 0;
  665. *(lpTemp + lOffset++) = 0;
  666. continue;
  667. }
  668. //考察下面的点
  669. lOffsetJudge = PixelOffset(i+1, j, wBytesPerLine);
  670. if (*(lpData + lOffsetJudge) ==0)
  671. {
  672. *(lpTemp + lOffset++) = 0;
  673. *(lpTemp + lOffset++) = 0;
  674. *(lpTemp + lOffset++) = 0;
  675. continue;
  676. }
  677. //左面的点
  678. lOffsetJudge = PixelOffset(i, j-1, wBytesPerLine);
  679. if (*(lpData + lOffsetJudge) ==0)
  680. {
  681. *(lpTemp + lOffset++) = 0;
  682. *(lpTemp + lOffset++) = 0;
  683. *(lpTemp + lOffset++) = 0;
  684. continue;
  685. }
  686. //右面的点
  687. lOffsetJudge = PixelOffset(i, j+1, wBytesPerLine);
  688. if (*(lpData + lOffsetJudge) ==0)
  689. {
  690. *(lpTemp + lOffset++) = 0;
  691. *(lpTemp + lOffset++) = 0;
  692. *(lpTemp + lOffset++) = 0;
  693. continue;
  694. }
  695. //如果上下左右四个点都是白色，则设置为白色
  696. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  697. *(lpTemp + lOffset)   = 255;
  698. *(lpTemp + lOffset+1) = 255;
  699. *(lpTemp + lOffset+2) = 255;
  701. }
  702. //如果当前点为黑色，则在暂时的目标区域中设置为黑色
  703. else
  704. {
  705. *(lpTemp + lOffset)   = 0;
  706. *(lpTemp + lOffset+1) = 0;
  707. *(lpTemp + lOffset+2) = 0;
  708. }
  709. }
  711. //把图象周边的点全部设置为黑色
  712. for(i=m_bottom; i<height; i++)
  713. {
  714. lOffset = PixelOffset(i, 0, wBytesPerLine);
  715. *(lpTemp + lOffset)   = 0;
  716. *(lpTemp + lOffset+1) = 0;
  717. *(lpTemp + lOffset+2) = 0;
  719. }
  721. for(i=m_bottom; i<height; i++)
  722. {
  723. lOffset = PixelOffset(i, width-1, wBytesPerLine);
  724. *(lpTemp + lOffset)   = 0;
  725. *(lpTemp + lOffset+1) = 0;
  726. *(lpTemp + lOffset+2) = 0;
  728. }
  730. for (i=m_left; i<width; i++)
  731. {
  732. lOffset = PixelOffset(0, i, wBytesPerLine);
  733. *(lpTemp + lOffset)   = 0;
  734. *(lpTemp + lOffset+1) = 0;
  735. *(lpTemp + lOffset+2) = 0;
  737. }
  739. for (i=m_left; i<width; i++)
  740. {
  741. lOffset = PixelOffset(height-1, i, wBytesPerLine);
  742. *(lpTemp + lOffset)   = 0;
  743. *(lpTemp + lOffset+1) = 0;
  744. *(lpTemp + lOffset+2) = 0;
  746. }
  747. //把暂时区域的数值拷贝到原来的句柄下面
  748. memcpy(lpData,lpTemp,wBytesPerLine*height);
  749. GlobalUnlock(hDIB);
  750. GlobalUnlock(hTempDIB);
  751. GlobalFree(hTempDIB);
  752. }