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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 书籍源码 > 查看源码
DIB.cpp
资源名称：一个人脸检测的VC++源代码.rar　[点击查看]
上传用户：yipeng6868
上传日期：2013-02-16
资源大小：222k
文件大小：47k
源码类别：

书籍源码

开发平台：

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. #define WIDTHBYTES(bits)  ((bits+31)/32*4)
  9. #define RECTWIDTH(x) (x->right-x->left)
  10. #define RECTHEIGHT(x) (x->bottom-x->top)
  11. #define THRESHOLDCONTRAST  40
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[]=__FILE__;
  15. #define new DEBUG_NEW
  16. #endif
  17. #define PI 3.1415926
  18. extern int locax,locay;
  19. #define m_WIDTH 600
  20. #define m_HEIGHT 600
  22. //////////////////////////////////////////////////////////////////////
  23. // Construction/Destruction
  24. /////////////////////////////////////////////////////////////////////
  25. HDIB DIB::ReadDIBFile(HANDLE hFile)
  26. {
  27. BITMAPFILEHEADER bmfHeader;
  28. DWORD dwBitsSize;
  29. HANDLE hDIB;
  30. HANDLE hDIBtmp;
  31. LPBITMAPINFOHEADER lpbi;
  32. DWORD dwRead;
  33.     //得到文件大小
  34. dwBitsSize = GetFileSize(hFile,NULL);
  35. hDIB =  GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER)));
  37. if(!hDIB)
  38. return NULL;
  40. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  41. if(!lpbi)
  42. {
  43. GlobalFree(hDIB);
  44. return NULL;
  45. }
  47. if(!ReadFile(hFile,(LPBYTE)&bmfHeader,sizeof(BITMAPFILEHEADER),&dwRead,NULL))
  48. goto ErrExit;
  49. if(sizeof(BITMAPFILEHEADER)!=dwRead)//读取文件出错
  50. goto ErrExit;
  51. if(bmfHeader.bfType != 0x4d42)//文件类型不匹配
  52. goto ErrExit;
  53. if(!ReadFile(hFile,(LPBYTE)lpbi,sizeof(BITMAPINFOHEADER),&dwRead,NULL))
  54. goto ErrExit;
  55. if(sizeof(BITMAPINFOHEADER)!= dwRead)//读取数据出错
  56. goto ErrExit;
  58. GlobalUnlock(hDIB);
  59. if(lpbi->biSizeImage==0)
  60. lpbi->biSizeImage = (this->BytePerLine(hDIB))*lpbi->biHeight;
  61. hDIBtmp = GlobalReAlloc(hDIB,lpbi->biSize+lpbi->biSizeImage,0);
  62. if(!hDIBtmp)
  63. goto ErrExitNoUnlock;
  64. else
  65. hDIB = hDIBtmp;
  66. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  67. //根据情况设定文件指针
  68. if(bmfHeader.bfOffBits != 0L)
  69. SetFilePointer(hFile,bmfHeader.bfOffBits,NULL,FILE_BEGIN);
  70.     //读取文件的象素颜色数据
  71. if(ReadFile(hFile,(LPBYTE)lpbi+lpbi->biSize,lpbi->biSizeImage,&dwRead,NULL))
  72. goto OKExit;
  74. ErrExit:
  75. GlobalUnlock(hDIB);
  77. ErrExitNoUnlock:
  78. GlobalFree(hDIB); //释放内存
  79. return NULL;
  81. OKExit:
  82. GlobalUnlock(hDIB);
  83. return hDIB;
  85. }
  87. HDIB DIB::LoadDIB(LPCTSTR lpFileName)
  88. {
  89. HANDLE hDIB;
  90. HANDLE hFile;
  91. //创建文件句柄
  92. if((hFile = CreateFile(lpFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL))!= INVALID_HANDLE_VALUE)
  93. {  
  94. //读取数据
  95. hDIB = ReadDIBFile(hFile);
  96. //关闭文件句柄
  97. CloseHandle(hFile);
  98. return hDIB;
  99. }
  100. return NULL;
  101. }
  103. BOOL DIB::PaintDIBTrue(HDC hDC,LPRECT lpDCRect,HANDLE hDIB,LPRECT lpDIBRect ,DWORD dwRop)
  104. {
  105. LPBYTE lpDIBHdr;
  106. LPBYTE lpDIBBits;
  107. BOOL bSuccess = FALSE;
  109. if(!hDIB)
  110. return FALSE;
  111. lpDIBHdr = (LPBYTE)GlobalLock(hDIB);
  112. lpDIBBits = lpDIBHdr + sizeof(BITMAPINFOHEADER);
  113. bSuccess = StretchDIBits(hDC,lpDCRect->left,
  114.  lpDCRect->top,
  115.  RECTWIDTH(lpDCRect),
  116.  RECTHEIGHT(lpDCRect),
  117.  lpDIBRect->left,
  118.  ((LPBITMAPINFOHEADER)lpDIBHdr)->biHeight-lpDIBRect->top-RECTHEIGHT(lpDIBRect),
  119.  RECTWIDTH(lpDIBRect),
  120.  RECTHEIGHT(lpDIBRect),
  121.  lpDIBBits,
  122.  (LPBITMAPINFO)lpDIBHdr,
  123.  DIB_RGB_COLORS,
  124.  SRCCOPY);
  125. GlobalUnlock(hDIB);
  126. return bSuccess;
  127. }
  129. WORD DIB::BytePerLine(HANDLE hDIB)
  130. {
  131. WORD i;
  132. LPBITMAPINFOHEADER lpbi;
  133. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  134. i = WIDTHBYTES((lpbi->biWidth)*24);
  135. GlobalUnlock(hDIB);
  136. return i;
  137. }
  140. //函数实现图片从彩色到黑白的转换
  141. HDIB DIB::ToGray(HANDLE hDIB)
  142. {
  143. HDIB hNewDIB = NULL;
  144. LPBITMAPINFOHEADER lpSrc,lpDest;
  145. LPBYTE lpS,lpD;
  146. DWORD dwBytesPerLine;
  147. DWORD dwImgSize;
  148. WORD wBytesPerLine;
  149. unsigned i ,j,height,width;
  150. if(!hDIB)
  151. return NULL;
  153. lpSrc = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  155. dwBytesPerLine = WIDTHBYTES(24*(lpSrc->biWidth));
  156. dwImgSize = lpSrc->biHeight * dwBytesPerLine;
  157. //申请新的内存，大小等于原来图象的大小
  158. hNewDIB = GlobalAlloc(GHND,sizeof(BITMAPINFOHEADER)+dwImgSize);
  160. lpDest = (LPBITMAPINFOHEADER)GlobalLock(hNewDIB);
  161. //保存图片的长宽、颜色深度等信息
  162. memcpy((void*)lpDest,(void*)lpSrc,sizeof(BITMAPINFOHEADER));
  163. DWORD dwSBytesPerLine;
  164. dwSBytesPerLine = (24*(lpSrc->biWidth)+31)/32*4;
  165. height = lpDest->biHeight;
  166. width = lpDest->biWidth;
  167. lpS = (LPBYTE)lpSrc;
  168. wBytesPerLine = this->BytePerLine(hDIB);
  169. lpD = (LPBYTE)lpDest;
  170. lpS = lpS + sizeof(BITMAPINFOHEADER);
  171. lpD = lpD + sizeof(BITMAPINFOHEADER);
  172. unsigned  r , g ,b,gray ;
  173. //扫描整个图片，实现灰度化
  174. for(i = 0 ;i<height; i++)
  175. {
  176. for(j = 0 ;j<(unsigned )lpDest->biWidth;j++)
  177. {
  178.         //获得原来图片的颜色值
  179. r = *(lpS++);
  180. g = *(lpS++);
  181. b  = *(lpS++);
  182. //计算灰度值
  183. gray = (g*50+r*39+b*11)/100;
  184. //保存灰度值到目标图片
  185. *(lpD++)=gray;
  186. *(lpD++) = gray;
  187. *(lpD++) = gray;
  190. }
  191. //处理四字节对齐问题
  192. unsigned  k ;
  193. for(k=0;k<dwSBytesPerLine-lpSrc->biWidth*3;k++)
  194. {
  195. lpS++;
  196. lpD++;
  197. }
  199. }
  201. GlobalUnlock(hDIB);
  202. GlobalUnlock(hNewDIB);
  203.     return hNewDIB;
  207. }
  211. LPBYTE  DIB::FindDIBBits(HANDLE hDIB)
  212. {
  213. LPBYTE lpDIB,lpDIBtmp;
  214. LPBITMAPINFOHEADER lpbi;
  215. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  216. lpDIBtmp = (LPBYTE)lpbi;
  217. lpDIB = lpDIBtmp + sizeof(BITMAPINFOHEADER);
  218. GlobalUnlock(hDIB);
  219. return lpDIB;
  220. }
  222. long DIB::PixelOffset(int i,int j,WORD wBytePerLine)
  223. {
  224. long   Offset;
  225. Offset = i*wBytePerLine + j*3;
  226. return Offset;
  227. }
  233. int DIB::BOUND(int a ,int b ,int rgb)
  234. {
  235. if(rgb<0)
  236. return BOUND(a,b,abs(rgb));
  237. if(rgb>b)
  238. return b;
  239. return rgb;
  240. }
  245. //实现图片的黑白二值化
  246. void DIB::WhiteBlack(HANDLE hDIB,unsigned n)
  247. {
  249. LPBITMAPINFOHEADER  lpbi;
  250. LPBYTE lpS;
  251. int width,height;
  252. long lOffset;
  253. WORD                wBytesPerLine;
  255. if(!hDIB)
  256. return ;
  257. wBytesPerLine = this->BytePerLine(hDIB);
  258. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  259.     //得到图片的长宽信息
  260. width = lpbi->biWidth;
  261. height = lpbi->biHeight;
  263. lpS = (LPBYTE)lpbi;
  264. //lps指向数据区
  265. lpS = lpS + sizeof(BITMAPINFOHEADER);
  266.    //扫描整个图片，实现二值化
  267. for(int i = 0;i<height;i++)
  268. for(int j = 0 ;j<width;j++)
  269. {   //得到象素数据在数据区中的偏移
  270. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  271. if(*(lpS+lOffset)<n)//象素值小于临界值
  272. {   //把象素填充为黑色
  273. *(lpS+lOffset++) = 0;
  274. *(lpS+lOffset++) = 0;
  275. *(lpS+lOffset)   = 0;
  276. }
  277. else //象素值大于临界值
  278. {   
  279. //把象素填充为白色
  280. *(lpS+lOffset++) = 255;
  281. *(lpS+lOffset++) = 255;
  282. *(lpS+lOffset)   = 255;
  283. }
  284. }
  286. GlobalUnlock(hDIB);
  288. }
  292. DIB::DIB()
  293. {
  294. for(int i=0;i<ImgRange; i++)
  295. for (int j=0; j<ImgRange; j++)
  296. this->lab[i][j] = false;
  298. }
  299. DIB::~DIB()
  300. {
  302. }
  308. BOOL DIB:: SaveDIB(HANDLE hDib, CFile& file)
  309. {
  310. // Bitmap文件头
  311. BITMAPFILEHEADER bmfHdr;
  313. // 指向BITMAPINFOHEADER的指针
  314. LPBITMAPINFOHEADER lpBI;
  316. // DIB大小
  317. DWORD dwDIBSize =0;
  319. if (hDib == NULL)
  320. {
  321. // 如果DIB为空，返回FALSE
  322. return FALSE;
  323. }
  325. // 读取BITMAPINFO结构，并锁定
  326. lpBI = (LPBITMAPINFOHEADER) ::GlobalLock((HGLOBAL) hDib);
  328. if (lpBI == NULL)
  329. {
  330. // 为空，返回FALSE
  331. return FALSE;
  332. }
  334. // 判断是否是WIN3.0 DIB
  335. // if (!IS_WIN30_DIB(lpBI))
  336. // {
  337. // 不支持其它类型的DIB保存
  339. // 解除锁定
  340. // ::GlobalUnlock((HGLOBAL) hDib);
  342. // 返回FALSE
  343. // return FALSE;
  344. // }
  346. // 填充文件头
  348. // 文件类型"BM"
  349. bmfHdr.bfType =  0x4d42; //DIB_HEADER_MARKER;
  351. // 计算DIB大小时，最简单的方法是调用GlobalSize()函数。但是全局内存大小并
  352. // 不是DIB真正的大小，它总是多几个字节。这样就需要计算一下DIB的真实大小。
  354. // 文件头大小＋颜色表大小
  355. // （BITMAPINFOHEADER和BITMAPCOREHEADER结构的第一个DWORD都是该结构的大小）
  356. // dwDIBSize = *(LPDWORD)lpBI; //+ ::PaletteSize((LPSTR)lpBI);
  357. dwDIBSize = sizeof(BITMAPINFOHEADER);//+lpBI->biSizeImage;
  358. // 计算图像大小
  359. if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4))
  360. {
  361. // 对于RLE位图，没法计算大小，只能信任biSizeImage内的值
  362. dwDIBSize += lpBI->biSizeImage;
  363. }
  364. else
  365. {
  366. // 象素的大小
  367. DWORD dwBmBitsSize;
  369. // 大小为Width * Height
  370. dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*24) * lpBI->biHeight;
  372. // 计算出DIB真正的大小
  373. dwDIBSize += dwBmBitsSize;
  375. // 更新biSizeImage（很多BMP文件头中biSizeImage的值是错误的）
  376. lpBI->biSizeImage = dwBmBitsSize;
  377. }
  380. // 计算文件大小：DIB大小＋BITMAPFILEHEADER结构大小
  381. bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER);
  383. // 两个保留字
  384. bmfHdr.bfReserved1 = 0;
  385. bmfHdr.bfReserved2 = 0;
  387. // 计算偏移量bfOffBits，它的大小为Bitmap文件头大小＋DIB头大小＋颜色表大小
  388. bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize;
  389.  // + PaletteSize((LPSTR)lpBI);
  390. // 尝试写文件
  391. // TRY
  392. {
  393. // 写文件头
  394. file.Write((LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER));
  396. // 写DIB头和象素
  397. file.WriteHuge(lpBI, dwDIBSize);
  398. }
  399. // CATCH (CFileException, e)
  400. // {
  401. // 解除锁定
  402. // ::GlobalUnlock((HGLOBAL) hDib);
  404. // 抛出异常
  405. /// THROW_LAST();
  406. // }
  407. // END_CATCH
  409. // 解除锁定
  410. ::GlobalUnlock((HGLOBAL) hDib);
  412. // 返回TRUE
  413. return TRUE;
  414. }
  417. HANDLE DIB::CopyHandle( HANDLE hSrc)
  418. {
  419. HANDLE hDst;
  420. LPBITMAPINFOHEADER lpbi;
  421. int width,height;
  422. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hSrc);
  423. width = lpbi->biWidth;
  424. height = lpbi->biHeight;
  425. hDst = GlobalAlloc(GMEM_MOVEABLE,lpbi->biSize+lpbi->biSizeImage);
  426. if(!hDst)
  427. return NULL;
  428. LPBYTE lpDest;
  429. lpDest = (LPBYTE)GlobalLock(hDst);
  430. memcpy(lpDest,(LPBYTE)lpbi,lpbi->biSize+lpbi->biSizeImage);
  431. GlobalUnlock(hSrc);
  432. GlobalUnlock(hDst);
  433. return hDst;
  435. }
  438. //函数寻找图片中的特征区域的中心点
  442. #define THRESHOLD (RADIUS*2+1)*(RADIUS*2+1)*15
  443. //函数在一幅图片中寻找匹配的中心点
  444. BOOL DIB::MatchImportantPoint(HANDLE hDIB,int CharaterInfo[RADIUS*2+1][RADIUS*2+1][3],CPoint *ImPoint)
  445. {
  446. LPBITMAPINFOHEADER lpbi;
  447. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  448. int width = lpbi->biWidth;
  449. int height = lpbi->biHeight;
  450. LPBYTE lpData = this->FindDIBBits(hDIB);
  451.     WORD wBytesPerLine = this->BytePerLine(hDIB);
  452. long lOffset;
  453. long sum =100000,tempsum;
  454. //扫描整个图片（边缘点）除外
  455. for(int i=RADIUS ;i<height-RADIUS;i++)
  456. for(int j=RADIUS;j<width-RADIUS;j++)
  457. {
  458. tempsum =0;
  459. //扫描以RADIUS*2+1为边长的正方形区域
  460. for(int k=-RADIUS;k<=RADIUS;k++)
  461. for(int kk=-RADIUS;kk<=RADIUS;kk++)
  462. {
  463. //计算当前正方形和已知特征区域的颜色差值
  465. lOffset = this->PixelOffset(i+k,j+kk,wBytesPerLine);
  466. int colorblue = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][0]);
  467. int colorgreen = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][1]);
  468. int colorred = abs(*(lpData+lOffset++)-CharaterInfo[k+RADIUS][kk+RADIUS][2]);
  469. tempsum +=colorgreen+colorblue+colorred;
  470. }
  471. if(tempsum<sum)
  472. {  //更新差值
  473. sum = tempsum;
  474. //更改特征坐标点
  475. ImPoint->x = j;
  476. ImPoint->y = i;
  477. }
  478. }
  480. if(sum <THRESHOLD){//找到满足条件的区域
  481. //下面的代码把找到的区域的边框设置成为白色
  482. for(i =-RADIUS;i<=RADIUS;i++)
  483. {
  484. lOffset = this->PixelOffset(ImPoint->y-RADIUS,ImPoint->x+i,wBytesPerLine);
  485. *(lpData+lOffset++) = 255;
  486. *(lpData+lOffset++) = 255;
  487. *(lpData+lOffset++) = 255;
  489. }
  491. for(i =-RADIUS;i<=RADIUS;i++)
  492. {
  493. lOffset = this->PixelOffset(ImPoint->y+RADIUS,ImPoint->x+i,wBytesPerLine);
  494. *(lpData+lOffset++) = 255;
  495. *(lpData+lOffset++) = 255;
  496. *(lpData+lOffset++) = 255;
  498. }
  499. for(i =-RADIUS;i<=RADIUS;i++)
  500. {
  501. lOffset = this->PixelOffset(ImPoint->y+i,ImPoint->x+RADIUS,wBytesPerLine);
  502. *(lpData+lOffset++) = 255;
  503. *(lpData+lOffset++) = 255;
  504. *(lpData+lOffset++) = 255;
  506. }
  507. for(i =-RADIUS;i<=RADIUS;i++)
  508. {
  509. lOffset = this->PixelOffset(ImPoint->y+i,ImPoint->x-RADIUS,wBytesPerLine);
  510. *(lpData+lOffset++) = 255;
  511. *(lpData+lOffset++) = 255;
  512. *(lpData+lOffset++) = 255;
  514. }
  515. GlobalUnlock(hDIB);
  516. return true;
  517. }
  518. else AfxMessageBox("Can't find the corresponding point!");
  519. GlobalUnlock(hDIB);
  520. return false;
  521. }
  522. //比较两张图片的相似度
  527. BOOL DIB::IsScaterPoint(int x, int y, int width, int height, LPBYTE lpData,WORD wBytesPerLine,  int threshold,bool lab[m_HEIGHT][m_WIDTH])
  528. {
  529. long lOffset;
  530. //得到数据的偏移
  531. lOffset = this->PixelOffset(y,x,wBytesPerLine);
  532. //判断该点是否为白色以及是否计算过了
  533. if(*(lpData+lOffset) == 255 && lab[y][x] == false)
  534. {
  535. //链长度加一
  536. this->lenth++;
  537. //更改标志位
  538. lab[y][x] = true;
  539. //如果链长度达到临界值则返回真
  540. if(this->lenth >= threshold)
  541. return true;
  542. //对右边点的边界判断以及标志位判断
  543. if(x+1<width && lab[y][x+1] == false)
  544. {
  545. //递归调用本函数，对右边的点进行判断
  546. IsScaterPoint(x+1,y,width,height,lpData,wBytesPerLine,threshold,lab);
  547. if(this->lenth>=threshold)
  548. return true;
  550. }
  551. //处理左边的点
  552. if(x-1>=0 && lab[y][x-1] == false)
  553. {
  554. (IsScaterPoint(x-1,y,width,height,lpData,wBytesPerLine,threshold,lab));
  555. if(this->lenth>=threshold)
  556. return true;
  558. }
  559. //处理上面的点
  560. if(y-1>=0 && lab[y-1][x]==false)
  561. {
  562. (IsScaterPoint(x,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  563. if(this->lenth>=threshold)
  564. return true;
  566. }
  567. //处理下面的点
  568. if(y+1<height && lab[y+1][x]==false)
  569. { (IsScaterPoint(x,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  570. if(this->lenth>=threshold)
  571. return true;
  573. }
  574. //处理右下的点
  575. if(y+1<height  && x+1 <width && lab[y+1][x+1]==false)
  576. { (IsScaterPoint(x+1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  577. if(this->lenth>=threshold)
  578. return true;
  580. }
  581. //处理左下的点
  582. if(y+1<height && x-1 >=0 && lab[y+1][x-1]==false)
  583. { (IsScaterPoint(x-1,y+1,width,height,lpData,wBytesPerLine,threshold,lab));
  584. if(this->lenth>=threshold)
  585. return true;
  587. }
  588. //处理左上的点
  589. if(y-1>=0 && x-1 >=0 &&lab[y-1][x-1]==false)
  590. { (IsScaterPoint(x-1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  591. if(this->lenth>=threshold)
  592. return true;
  594. }
  595. //处理右上的点
  596. if(y-1<height && x+1<width && lab[y+1][x]==false)
  597. { (IsScaterPoint(x+1,y-1,width,height,lpData,wBytesPerLine,threshold,lab));
  598. if(this->lenth>=threshold)
  599. return true;
  601. }
  602. }
  603. //如果递归结束，长度达不到临界值，返回假
  604. return false;
  605. }
  609. BOOL DIB::LightingCompensate(HANDLE hDIB)
  610. {
  611. if(!hDIB)
  612. return FALSE;
  613. LPBITMAPINFOHEADER lpbi;
  614. int width,height;
  615. LPBYTE lpData;
  616. WORD wBytesPerLine;
  617. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  618. //得到图片宽和高
  619. width = lpbi->biWidth;
  620. height = lpbi->biHeight;
  621. //得到图片数据区
  622. lpData = this->FindDIBBits(hDIB);
  623. //得到图片每行的象素所占字节个数
  624. wBytesPerLine = this->BytePerLine(hDIB);
  625. //比例系数
  626. const float thresholdco = 0.05;
  627. //象素个数的临界常数
  628. const int thresholdnum = 100;
  629. //灰度级数组
  630. int histogram[256];
  631. for(int i =0;i<256;i++)
  632. histogram[i] = 0;
  633. //对于过于小的图片的判断
  634. if(width*height*thresholdco < thresholdnum)
  635. return false;
  636. int colorr,colorg,colorb;
  637. long lOffset;
  638. //考察整个图片
  639. for( i=0;i<height;i++)
  640. for(int j=0;j<width;j++)
  641. {
  642. //得到象素数据的偏移
  643. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  644. //得到rgb值
  645. colorb = *(lpData+lOffset++);
  646. colorg = *(lpData+lOffset++);
  647. colorr = *(lpData+lOffset++);
  648. //计算灰度值
  649. int gray = (colorr * 299 + colorg * 587 + colorb * 114)/1000;
  650. histogram[gray]++;
  651. }
  652. int calnum =0;
  653. int total = width*height;
  654. int num;
  655. //下面的循环得到满足系数thresholdco的临界灰度级
  656. for(i =0;i<256;i++)
  657. {
  658. if((float)calnum/total < thresholdco)
  659. {
  660. calnum+= histogram[255-i];
  661. num = i;
  662. }
  663. else
  664. break;
  665. }
  666. int averagegray = 0;
  667. calnum =0;
  668. //得到满足条件的象素总的灰度值
  669. for(i = 255;i>=255-num;i--)
  670. {
  671. averagegray += histogram[i]*i;
  672. calnum += histogram[i];
  673. }
  674. averagegray /=calnum;
  675. //得到光线补偿的系数
  676. float co = 255.0/(float)averagegray;
  677. //下面的循环对图象进行光线补偿
  678. for(i =0;i<height;i++)
  679. for(int j=0;j<width;j++)
  680. {
  681. //得到数据便宜
  682. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  683. //得到蓝色分量
  684. colorb = *(lpData+lOffset);
  685. //调整
  686. colorb *=co;
  687. //临界判断
  688. if(colorb >255)
  689. colorb = 255;
  690. //保存
  691. *(lpData+lOffset) = colorb;
  692. //绿色分量
  693. colorb = *(lpData+lOffset+1);
  694. colorb *=co;
  695. if(colorb >255)
  696. colorb = 255;
  697. *(lpData+lOffset+1) = colorb;
  698. //红色分量
  699. colorb = *(lpData+lOffset+2);
  700. colorb *=co;
  701. if(colorb >255)
  702. colorb = 255;
  703. *(lpData+lOffset+2) = colorb;
  705. }
  706. return TRUE;
  707. }
  709. BOOL DIB::FaceModeling(int Cr,int Cb)
  710. {
  711. //Cb的系数常量
  712. const float cx = 114.38;
  713. //cr的系数常量
  714. const float cy = 160.02;
  715. //角度常量
  716. const float theta = 2.53;
  717. //x轴线和y轴线的两个常量
  718. const float ecx = 1.60;
  719. const float ecy = 2.41;
  720. //长轴
  721. const float a = 25.39;
  722. //短轴
  723. const float b = 14.03;
  724. //相似度常量
  725. const float judge = 0.5;
  726. //计算得到x轴数值
  727. float  x = cos(theta)*(Cb-cx)+sin(theta)*(Cr-cy);
  728. //y轴数值
  729. float  y = -sin(theta)*(Cb -cx)+cos(theta)*(Cr-cy);
  730. //计算离心率
  731. float temp = pow(x-ecx,2)/pow(a,2)+pow(y-ecy,2)/pow(b,2);
  732. //如果满足要求返回真，否则假
  733. if(fabs(temp-1.0)<judge)
  734. return TRUE;
  735. else
  736. return FALSE;
  738. }
  740. LPBYTE DIB::YcctoRgb(LPBYTE lpYcc,WORD wBytesPerLine,int height,int width)
  741. {
  742. LPBYTE lpRGB;
  743. //申请内存
  744. lpRGB = new BYTE[wBytesPerLine*height];
  745. //检查内容分配
  746. if(lpRGB == NULL)
  747. {
  748. AfxMessageBox("not enought memory");
  749. return NULL;
  750. }
  751. long lOffset;
  752. //下面的循环实现从ycc到rgb的转换
  753. for(int i=0;i<height;i++)
  754. for(int j=0;j<width;j++)
  755. {
  756. //得到数据便宜
  757. lOffset = PixelOffset(i,j,wBytesPerLine);
  758. //得到y，Cr，Cb的数值
  759. int Y = *(lpYcc+lOffset);
  760. int Cr = *(lpYcc+lOffset+1);
  761. int Cb = *(lpYcc+lOffset+2);
  762. //利用公式进行计算，并把结果保存到动态数组里面
  763. *(lpRGB+lOffset+2) = (1164*(Y-16)+1596*(Cr-128))/1000;
  764. *(lpRGB+lOffset+1) = (1164*(Y-16) - 813*(Cr-128) - 392*(Cb-128))/1000;
  765. *(lpRGB+lOffset)   = (1164*(Y-16) +2017*(Cb-128))/1000;
  766. }
  767. return lpRGB;
  768. }
  771. int DIB::_Cb(int Y)
  772. {
  773. int Cb;
  774. //如果亮度很小的情况
  775. if(Y<Kl)
  776. Cb = 108 + ((Kl-Y)*10)/(Kl-Ymin);
  777. //亮度很大的情况
  778. else if(Y>Kh)
  779. Cb = 108 + ((Y-Kh)*10)/(Ymax - Kh);
  780. else 
  781. Cb = -1;
  782. return Cb;
  783. }
  785. int DIB::_Cr(int Y)
  786. {
  787. int Cr;
  788. //亮度很小的情况
  789. if(Y<Kl)
  790. Cr = 154 - ((Kl-Y)*10)/(Kl-Ymin);
  791. //亮度很大的情况
  792. else if(Y>Kh)
  793. Cr = 154 - ((Y-Kh)*22)/(Ymax - Kh);
  794. else
  795. Cr = -1;
  796. return Cr;
  797. }
  798. int DIB::_WCr(int Y)
  799. {
  800. int WCr;
  801. if(Y<Kl)
  802. //亮度很小的情况
  803. WCr = WLcr + ((Y-Ymin)*(Wcr-WLcr))/(Kl-Ymin);
  804. else if(Y>Kh)
  805. //亮度很大的情况
  806. WCr = WHcr + ((Ymax-Y)*(Wcr-WHcr))/(Ymax-Kh);
  807. else WCr = -1;
  808. return WCr;
  809. }
  811. int DIB:: _WCb(int Y)
  812. {
  813. int WCb;
  814. if(Y<Kl)
  815. //亮度很小的情况
  816. WCb = WLcb + ((Y-Ymin)*(Wcb-WLcb))/(Kl-Ymin);
  817. else if(Y>Kh)
  818. //亮度很大的情况
  819. WCb = WHcb + ((Ymax-Y)*(Wcb-WHcb))/(Ymax-Kh);
  820. else WCb = -1;
  821. return WCb;
  822. }
  823. void DIB::YccTransform(LPBYTE lpYcc,WORD wBytesPerLine,int height,int width)
  824. {
  825. int Y,Cr,Cb;
  826. long lOffset;
  827. //下面的循环实现ycc色彩空间的非线性转换
  828. for(int i=0;i<height;i++)
  829. for(int j=0;j<width;j++)
  830. {
  831. //得到数据偏移
  832. lOffset = PixelOffset(i,j,wBytesPerLine);
  833. //得到y，Cr，Cb数值
  834. Y = *(lpYcc+lOffset);
  835. Cr = *(lpYcc+lOffset+1);
  836. Cb = *(lpYcc+lOffset+2);
  837. //如果y数值在两个临界值之间，保持不变
  838. if(Y>=Kl && Y<=Kh)
  839. continue;
  840. //调用非线性转换函数调整Cr，Cb的数值
  841. Cr = (Cr-_Cr(Y))*(Wcr/_WCr(Y))+_Cr(Kh);
  842. Cb = (Cb-_Cb(Y))*(Wcb/_WCb(Y))+_Cb(Kh);
  843. *(lpYcc+lOffset+1) = Cr;
  844. *(lpYcc+lOffset+2) = Cb;
  845. }
  846. }
  848. void DIB::faceear(LPBYTE lpYcc, WORD wBytesPerLine, int height,int width, bool flag[ImgRange][ImgRange])
  849. {
  850. //初始化标志位
  851. for (int i=0; i<ImgRange; i++)
  852. for (int j=0; j<ImgRange; j++)
  853. {
  854. flag[i][j] = false;
  855. }
  857. long lOffset;
  858. int Cr;
  859. int Cb;
  860. for (i=0; i<height; i++)
  861. for (int j=0; j<width; j++)
  862. {
  863. //得到偏移
  864. lOffset = PixelOffset(i,j,wBytesPerLine);
  865. //得到Cr，Cb数值
  866. Cr = *(lpYcc+lOffset+1);
  867. Cb = *(lpYcc+lOffset+2);
  868. //人脸颜色建模
  869. if(FaceModeling(Cr,Cb))
  870. {
  871. //修改标志位
  872. flag[i][j] = true;
  873. }
  874. }
  876. }
  878. void  DIB::FaceLocate(HANDLE hDIB, CRect faceLocation[10], int &faceNum)
  879. {
  881. HANDLE hDIBTemp;
  882. //保存当前数据
  883. hDIBTemp = this->CopyHandle(hDIB);
  884. LPBITMAPINFOHEADER lpbi;
  885. LPBYTE lpData;
  886. WORD wBytesPerLine;
  887. int height;
  888. int width;
  889. long lOffset;
  890. //得到图象的基本信息
  891. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  892. height = lpbi->biHeight;
  893. width  = lpbi->biWidth;
  894. lpData = FindDIBBits(hDIB);
  895. wBytesPerLine = BytePerLine(hDIB);
  897. //人脸数目初始化为0
  898. faceNum =0;
  899. for(int k=0; k<10; k++)
  900. {
  901. //初始化区域
  902. faceLocation[k].bottom = -1;
  903. faceLocation[k].top = height;
  904. faceLocation[k].right = -1;
  905. faceLocation[k].left = width;
  906. }
  908. for(int i=0; i<height; i++)
  909. for (int j=0; j<width; j++)
  910. {
  911. //偏移
  912. lOffset = PixelOffset(i,j,wBytesPerLine);
  913. int num;
  914. //当前点的数值
  915. num = *(lpData + lOffset);
  916. if (num !=0)//不是黑色
  917. {
  918. //递归计算
  919. RecursiveLocateRect(lpData, wBytesPerLine, i, j, num, faceLocation[faceNum]);
  920. faceNum++;
  921. }
  922. }
  923. GlobalUnlock(hDIB);
  924. GlobalFree(hDIB);
  925. //数值还原
  926. hDIB = this->CopyHandle(hDIBTemp);
  927. lpData = FindDIBBits(hDIB);
  928. wBytesPerLine = BytePerLine(hDIB);
  929. for (i=0; i<faceNum; i++)
  930. for (int j=faceLocation[i].top; j<faceLocation[i].bottom; j++)
  931. {
  932. //把得到的人脸区域用绿色矩形标注，处理竖直的两条边
  933. lOffset = this->PixelOffset(j, faceLocation[i].left, wBytesPerLine);
  934. *(lpData + lOffset++) = 0;
  935. *(lpData + lOffset++) = 255;
  936. *(lpData + lOffset++) = 0;
  937. lOffset = this->PixelOffset(j, faceLocation[i].right, wBytesPerLine);
  938. *(lpData + lOffset++) = 0;
  939. *(lpData + lOffset++) = 255;
  940. *(lpData + lOffset++) = 0;
  942. }
  944. for (i=0; i<faceNum; i++)
  945. for (int j=faceLocation[i].left; j<faceLocation[i].right; j++)
  946. {
  947. //处理水平的两天矩形边
  948. lOffset = this->PixelOffset(faceLocation[i].top, j, wBytesPerLine);
  949. *(lpData + lOffset++) = 0;
  950. *(lpData + lOffset++) = 255;
  951. *(lpData + lOffset++) = 0;
  952. lOffset = this->PixelOffset(faceLocation[i].bottom, j, wBytesPerLine);
  953. *(lpData + lOffset++) = 0;
  954. *(lpData + lOffset++) = 255;
  955. *(lpData + lOffset++) = 0;
  957. }
  961. GlobalFree(hDIBTemp);
  962. GlobalUnlock(hDIB);
  963. }
  965. void DIB::RecursiveLocateRect(LPBYTE lpData,WORD wBytesPerLine, int y, int x, int num, CRect &faceRect)
  966. {
  967. long lOffset;
  968. //得到偏移
  969. lOffset = PixelOffset(y,x,wBytesPerLine);
  970. //数值判断
  971. if(*(lpData + lOffset) == num)
  972. {
  973. //更改颜色为黑色
  974. *(lpData + lOffset++) = 0;
  975. *(lpData + lOffset++) = 0;
  976. *(lpData + lOffset++) = 0;
  977. //修改矩形的上下左右四个点位置
  978. if(faceRect.bottom < y)
  979. {
  980. faceRect.bottom = y;
  981. }
  983. if(faceRect.top > y)
  984. {
  985. faceRect.top = y;
  986. }
  988. if(faceRect.right < x)
  989. {
  990. faceRect.right = x;
  991. }
  993. if(faceRect.left > x)
  994. {
  995. faceRect.left = x;
  996. }
  997. //上下左右调用本函数进行区域判定
  998. RecursiveLocateRect(lpData, wBytesPerLine, y-1, x, num,faceRect);
  999. RecursiveLocateRect(lpData, wBytesPerLine, y+1, x, num, faceRect);
  1000. RecursiveLocateRect(lpData, wBytesPerLine, y, x-1, num, faceRect);
  1001. RecursiveLocateRect(lpData, wBytesPerLine, y, x+1, num, faceRect);
  1002. }
  1004. }
  1006. void DIB::EyeMapC(LPBYTE lpRgb, const LPBYTE lpYcc,  WORD wBytesPerLine, CRect faceLocation)
  1007. {
  1008. long lOffset;
  1009. int cr;
  1010. int cb;
  1011. //根据传进来的矩形区域进行眼睛的色度匹配
  1012. for(int i=faceLocation.top; i<=faceLocation.bottom; i++)
  1013. for (int j=faceLocation.left; j<=faceLocation.right; j++)
  1014. {
  1015. //得到Cr，Cb数值
  1016. lOffset = PixelOffset(i, j, wBytesPerLine);
  1017. cr = *(lpYcc + lOffset +1);
  1018. cb = *(lpYcc + lOffset +2);
  1019. //标志
  1020. bool lab;
  1021. //判断Cb分量的数值，并修改标志
  1022. int cmap = cb -116 ;
  1023. if(cmap >-1 && cmap <4)
  1024. lab = true;
  1025. else
  1026. lab = false;
  1027. //判断Cr分量的数值，并修改标志
  1028.  cmap =  cr- 144  ;
  1029. if(cmap <=-2 || cmap>= 2)
  1030. {
  1031. lab = false;
  1033. }
  1034. //根据标志设定图像颜色
  1035. if(lab)
  1036. cmap = 255;
  1037. else
  1038. cmap = 0;
  1039. //保存图象颜色
  1040. *(lpRgb + lOffset++) = cmap;
  1041. *(lpRgb + lOffset++) = cmap;
  1042. *(lpRgb + lOffset++) = cmap;
  1043. }
  1045. }
  1047. void DIB::EyeMapb(LPBYTE lpRgb, const LPBYTE lpYcc,  WORD wBytesPerLine, CRect faceLocation)
  1048. {
  1049. long lOffset;
  1050. int cr;
  1051. int cb;
  1053. for(int i=faceLocation.top; i<=faceLocation.bottom; i++)
  1054. for (int j=faceLocation.left; j<=faceLocation.right; j++)
  1055. {
  1056. lOffset = PixelOffset(i, j, wBytesPerLine);
  1057. cb = *(lpYcc + lOffset +2);
  1060. *(lpRgb + lOffset++) = cb;
  1061. *(lpRgb + lOffset++) = cb;
  1062. *(lpRgb + lOffset++) = cb;
  1063. }
  1065. }
  1067. void DIB::EyeMapR(LPBYTE lpRgb, const LPBYTE lpYcc,  WORD wBytesPerLine, CRect faceLocation)
  1068. {
  1069. long lOffset;
  1070. int cr;
  1071. int cb;
  1073. for(int i=faceLocation.top; i<=faceLocation.bottom; i++)
  1074. for (int j=faceLocation.left; j<=faceLocation.right; j++)
  1075. {
  1076. lOffset = PixelOffset(i, j, wBytesPerLine);
  1077. cr = *(lpYcc + lOffset +1);
  1078. cb = *(lpYcc + lOffset +2);
  1081. *(lpRgb + lOffset++) = cr;
  1082. *(lpRgb + lOffset++) = cr;
  1083. *(lpRgb + lOffset++) = cr;
  1084. }
  1086. }
  1088. void DIB::ErasionFalseArea(HANDLE hDIB)
  1089. {
  1090. int PixelNum[255];
  1091. LPBITMAPINFOHEADER lpbi;
  1092. int width;
  1093. int height;
  1094. LPBYTE lpData;
  1095. WORD wBytesPerLine;
  1096. long lOffset;
  1097. //得到长宽信息
  1098. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1099. height = lpbi->biHeight;
  1100. width  = lpbi->biWidth;
  1101. //得到数据区指针和每行字节数
  1102. lpData = FindDIBBits(hDIB);
  1103. wBytesPerLine = BytePerLine(hDIB);
  1104. //初始化象素累计数组
  1105. for (int i=0; i<255; i++)
  1106. {
  1107. PixelNum[i] = 0;
  1108. }
  1110. int calNum =1;
  1111. for (i=0; i<height; i++)
  1112. for (int j=0; j<width; j++)
  1113. {
  1114. lOffset = PixelOffset(i,j,wBytesPerLine);
  1115. //如果象素为白色
  1116. if (*(lpData + lOffset)==255)
  1117. {
  1118. //递归统计该区域连续的白色点象素点个数
  1119. RecursiveCal(lpData, i,j,wBytesPerLine, PixelNum[calNum],calNum);
  1120. calNum++;
  1121. }
  1122. }
  1124. for (i=0; i<calNum; i++)
  1125. {
  1126. //如果象素点个数小于一定数目则把这个标志设置为0
  1127. if (PixelNum[i] < AREAPIXEL)
  1128. {
  1129. PixelNum[i] = 0;
  1130. }
  1131. }
  1132. //下面的循环根据标志数组来最终设定图象的颜色
  1133. for(i=0; i<height; i++)
  1134. for (int j=0; j<width; j++)
  1135. {
  1136. lOffset = PixelOffset( i,j,wBytesPerLine);
  1137. int num = *(lpData + lOffset);
  1138. //如果当前点不是黑色点
  1139. if(num != 0)
  1140. {
  1141. //如果标志数组为0，则设置为黑色
  1142. if(PixelNum[num] == 0)
  1143. {
  1144. *(lpData+lOffset++) =0;
  1145. *(lpData+lOffset++) =0;
  1146. *(lpData+lOffset++) =0;
  1147. }
  1148. //否则设置为白色
  1149. else
  1150. {
  1151. *(lpData+lOffset++) =255;
  1152. *(lpData+lOffset++) =255;
  1153. *(lpData+lOffset++) =255;
  1154. }
  1155. }
  1156. }
  1157. }
  1160. void DIB::RecursiveCal(LPBYTE lpData, int y, int x, WORD wBytesPerLine, int &pixelNum, int num)
  1161. {
  1162. long lOffset;
  1164. lOffset = PixelOffset(y,x,wBytesPerLine);
  1165. //如果当前点为白色点
  1166. if(*(lpData+lOffset) == 255)
  1167. {
  1168. //把当前点大小设置成为序号值
  1169. *(lpData+lOffset++) = num;
  1170. *(lpData+lOffset++) = num;
  1171. *(lpData+lOffset++) = num;
  1172. //象素个数加一
  1173. pixelNum++;
  1175. int tempx;
  1176. int tempy;
  1178. //递归当前点上面的点
  1179. tempy = y-1;
  1180. tempx = x;
  1181. RecursiveCal(lpData,tempy,tempx,wBytesPerLine,pixelNum,num);
  1183. //下面的点
  1184. tempy = y+1;
  1185. tempx = x;
  1186. RecursiveCal(lpData,tempy,tempx,wBytesPerLine,pixelNum,num);
  1188. //左边的点
  1189. tempy = y;
  1190. tempx = x-1;
  1191. RecursiveCal(lpData,tempy,tempx,wBytesPerLine,pixelNum,num);
  1192. //右边的点
  1193. tempy = y;
  1194. tempx = x+1;
  1195. RecursiveCal(lpData,tempy,tempx,wBytesPerLine,pixelNum,num);
  1197. }
  1199. }
  1201. void DIB::eyeMap(LPBYTE lpResult, bool eyemapc[][ImgRange], bool eyemapl[][ImgRange], bool lab[][ImgRange], WORD wBytesPerLine, CRect faceLocation)
  1202. {
  1203. long lOffset;
  1204. //根据得到的亮度和色度信息对眼睛进行综合匹配
  1205. for(int i=faceLocation.top; i<=faceLocation.bottom; i++)
  1206. for (int j=faceLocation.left; j<faceLocation.right; j++)
  1207. {
  1208. lOffset = PixelOffset(i, j, wBytesPerLine);
  1209. //如果当前点的亮度和色度匹配都为真，并且在人脸区域内
  1210. //就设置为白色，否则设置为黑色
  1211. if((eyemapc[i][j]) && (eyemapl[i][j]) && lab[i][j])
  1212. {
  1213. *(lpResult + lOffset++) = 255;
  1214. *(lpResult + lOffset++) = 255;
  1215. *(lpResult + lOffset++) = 255;
  1216. }
  1218. else
  1219. {
  1220. *(lpResult + lOffset++) = 0;
  1221. *(lpResult + lOffset++) = 0;
  1222. *(lpResult + lOffset++) = 0;
  1223. }
  1224. }
  1225. }
  1227. void DIB::EyeMapL(LPBYTE lpRgb, WORD wBytesPerLine, CRect faceLocation)
  1228. {
  1229. int r;
  1230. int g;
  1231. int b;
  1232. int gray ;
  1233. long lOffset;
  1234. //下面的循环实现眼睛的亮度匹配
  1235. for (int i=faceLocation.top; i<=faceLocation.bottom; i++)
  1236. for (int j=faceLocation.left; j<=faceLocation.right; j++)
  1237. {
  1238. lOffset = PixelOffset(i, j, wBytesPerLine);
  1239. //得到rgb值
  1240. b = *(lpRgb + lOffset);
  1241. g = *(lpRgb + lOffset+1);
  1242. r = *(lpRgb + lOffset+2);
  1243. //计算得到灰度
  1244. gray = (r*10+g*30+b*60)/100;
  1245. //根据眼睛的亮度区域来设定图象的数值
  1246. if(100<gray && 125>gray)
  1247. gray =255;
  1248. else
  1249. gray = 0;
  1250. *(lpRgb + lOffset++) = gray;
  1251. *(lpRgb + lOffset++) = gray;
  1252. *(lpRgb + lOffset++) = gray;
  1253. }
  1254. }
  1256. void  DIB::RgbtoYcb(HANDLE hDIB, LPBYTE lpYcb)
  1257. {
  1258. LPBITMAPINFOHEADER lpbi;
  1259. int width,height;
  1260. WORD wBytesPerLine;
  1261. LPBYTE lpData;
  1262. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1263. //得到图象的基本信息
  1264. width = lpbi->biWidth;
  1265. height = lpbi->biHeight;
  1266. lpData = FindDIBBits(hDIB);
  1267. wBytesPerLine = BytePerLine(hDIB);
  1269. long lOffset;
  1270. //下面的循环实现从rgb到ycc的转化
  1271. for(int i=0;i<height;i++)
  1272. for(int j=0;j<width;j++)
  1273. {
  1274. lOffset = PixelOffset(i,j,wBytesPerLine);
  1275. //得到rgb数值
  1276. int b = *(lpData + lOffset);
  1277. int g = *(lpData + lOffset+1);
  1278. int r = *(lpData + lOffset+2);
  1279. //计算得到y，cr，cb的数值
  1280. int Y = (257*r+504*g+98*b)/1000+16;
  1281. int Cr = (439*r-368*g-71*b)/1000+128;
  1282. int Cb = (-148*r-291*g+439*b)/1000+128;
  1283. //保存计算得到的数值
  1284. *(lpYcb+lOffset++) = Y;
  1285. *(lpYcb+lOffset++) = Cr;
  1286. *(lpYcb+lOffset++) = Cb;
  1288. }
  1289. GlobalUnlock(hDIB);
  1291. }
  1293. void DIB::Erasion(HANDLE hDIB)
  1294. {
  1295. LPBITMAPINFOHEADER lpbi;
  1296. LPBYTE lpData;
  1297. WORD wBytesPerLine;
  1298. long lOffset;
  1299. long lOffsetJudge;
  1300. int height;
  1301. int width;
  1303. //得到基本数据
  1304. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1305. height = lpbi->biHeight;
  1306. width = lpbi->biWidth;
  1307. wBytesPerLine = BytePerLine(hDIB);
  1308. lpData = FindDIBBits(hDIB);
  1310. HANDLE hTempDIB;
  1311. LPBYTE lpTemp;
  1312. //申请同样大小的内存
  1313. hTempDIB =   GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER) + wBytesPerLine*height));
  1314. //判断内存情况
  1315. if(!hTempDIB)
  1316. {
  1317. GlobalFree(hTempDIB);
  1318. GlobalFree(hDIB);
  1319. return;
  1320. }
  1321. lpTemp = (LPBYTE)GlobalLock(hTempDIB);
  1322. lpTemp+= sizeof(BITMAPINFOHEADER);
  1323. //下面的循环实现腐蚀功能
  1324. for (int i=1; i<height-1; i++)
  1325. for (int j=1; j<width-1; j++)
  1326. {
  1327. lOffset = PixelOffset(i,j,wBytesPerLine);
  1328. //如果为白色点
  1329. if (*(lpData+lOffset) == 255)
  1330. {
  1331. //考察上面的点
  1332. lOffsetJudge = PixelOffset(i-1, j, wBytesPerLine);
  1333. //如果是黑色就把原来的点设置为黑色，并接着循环
  1334. if (*(lpData + lOffsetJudge) ==0)
  1335. {
  1336. *(lpTemp + lOffset++) = 0;
  1337. *(lpTemp + lOffset++) = 0;
  1338. *(lpTemp + lOffset++) = 0;
  1339. continue;
  1340. }
  1341. //考察下面的点
  1342. lOffsetJudge = PixelOffset(i+1, j, wBytesPerLine);
  1343. if (*(lpData + lOffsetJudge) ==0)
  1344. {
  1345. *(lpTemp + lOffset++) = 0;
  1346. *(lpTemp + lOffset++) = 0;
  1347. *(lpTemp + lOffset++) = 0;
  1348. continue;
  1349. }
  1350. //左面的点
  1351. lOffsetJudge = PixelOffset(i, j-1, wBytesPerLine);
  1352. if (*(lpData + lOffsetJudge) ==0)
  1353. {
  1354. *(lpTemp + lOffset++) = 0;
  1355. *(lpTemp + lOffset++) = 0;
  1356. *(lpTemp + lOffset++) = 0;
  1357. continue;
  1358. }
  1359. //右面的点
  1360. lOffsetJudge = PixelOffset(i, j+1, wBytesPerLine);
  1361. if (*(lpData + lOffsetJudge) ==0)
  1362. {
  1363. *(lpTemp + lOffset++) = 0;
  1364. *(lpTemp + lOffset++) = 0;
  1365. *(lpTemp + lOffset++) = 0;
  1366. continue;
  1367. }
  1368. //如果上下左右四个点都是白色，则设置为白色
  1369. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1370. *(lpTemp + lOffset)   = 255;
  1371. *(lpTemp + lOffset+1) = 255;
  1372. *(lpTemp + lOffset+2) = 255;
  1374. }
  1375. //如果当前点为黑色，则在暂时的目标区域中设置为黑色
  1376. else
  1377. {
  1378. *(lpTemp + lOffset)   = 0;
  1379. *(lpTemp + lOffset+1) = 0;
  1380. *(lpTemp + lOffset+2) = 0;
  1381. }
  1382. }
  1384. //把图象周边的点全部设置为黑色
  1385. for(i=0; i<height; i++)
  1386. {
  1387. lOffset = PixelOffset(i, 0, wBytesPerLine);
  1388. *(lpTemp + lOffset)   = 0;
  1389. *(lpTemp + lOffset+1) = 0;
  1390. *(lpTemp + lOffset+2) = 0;
  1392. }
  1394. for(i=0; i<height; i++)
  1395. {
  1396. lOffset = PixelOffset(i, width-1, wBytesPerLine);
  1397. *(lpTemp + lOffset)   = 0;
  1398. *(lpTemp + lOffset+1) = 0;
  1399. *(lpTemp + lOffset+2) = 0;
  1401. }
  1403. for (i=0; i<width; i++)
  1404. {
  1405. lOffset = PixelOffset(0, i, wBytesPerLine);
  1406. *(lpTemp + lOffset)   = 0;
  1407. *(lpTemp + lOffset+1) = 0;
  1408. *(lpTemp + lOffset+2) = 0;
  1410. }
  1412. for (i=0; i<width; i++)
  1413. {
  1414. lOffset = PixelOffset(height-1, i, wBytesPerLine);
  1415. *(lpTemp + lOffset)   = 0;
  1416. *(lpTemp + lOffset+1) = 0;
  1417. *(lpTemp + lOffset+2) = 0;
  1419. }
  1420. //把暂时区域的数值拷贝到原来的句柄下面
  1421. memcpy(lpData,lpTemp,wBytesPerLine*height);
  1422. GlobalUnlock(hDIB);
  1423. GlobalUnlock(hTempDIB);
  1424. GlobalFree(hTempDIB);
  1426. }
  1429. void DIB::Erasion2(HANDLE hDIB)
  1430. {
  1431. LPBITMAPINFOHEADER lpbi;
  1432. LPBYTE lpData;
  1433. WORD wBytesPerLine;
  1434. long lOffset;
  1435. long lOffsetJudge;
  1436. int height;
  1437. int width;
  1439. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1440. height = lpbi->biHeight;
  1441. width = lpbi->biWidth;
  1442. wBytesPerLine = BytePerLine(hDIB);
  1443. lpData = FindDIBBits(hDIB);
  1445. HANDLE hTempDIB;
  1446. LPBYTE lpTemp;
  1447. //申请相同大小的内存
  1448. hTempDIB =   GlobalAlloc(GMEM_MOVEABLE,(DWORD)(sizeof(BITMAPINFOHEADER) + wBytesPerLine*height));
  1449. if(!hTempDIB)
  1450. {
  1451. GlobalFree(hTempDIB);
  1452. GlobalFree(hDIB);
  1453. return;
  1454. }
  1455. lpTemp = (LPBYTE)GlobalLock(hTempDIB);
  1456. lpTemp+= sizeof(BITMAPINFOHEADER);
  1457. //下面的代码实现腐蚀功能
  1458. for (int i=1; i<height-1; i++)
  1459. for (int j=1; j<width-1; j++)
  1460. {
  1461. //如果当前点为白色
  1462. lOffset = PixelOffset(i,j,wBytesPerLine);
  1463. if (*(lpData+lOffset) == 255)
  1464. {
  1466. //判断左边的带你，如果是黑色的就把暂时区域中的对应点设置为黑色
  1467. lOffsetJudge = PixelOffset(i, j-1, wBytesPerLine);
  1468. if (*(lpData + lOffsetJudge) ==0)
  1469. {
  1470. *(lpTemp + lOffset++) = 0;
  1471. *(lpTemp + lOffset++) = 0;
  1472. *(lpTemp + lOffset++) = 0;
  1473. continue;
  1474. }
  1475. //考察右边的点
  1476. lOffsetJudge = PixelOffset(i, j+1, wBytesPerLine);
  1477. if (*(lpData + lOffsetJudge) ==0)
  1478. {
  1479. *(lpTemp + lOffset++) = 0;
  1480. *(lpTemp + lOffset++) = 0;
  1481. *(lpTemp + lOffset++) = 0;
  1482. continue;
  1483. }
  1485. //如果左右两边的点都是白色把点设置为白色
  1486. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1487. *(lpTemp + lOffset)   = 255;
  1488. *(lpTemp + lOffset+1) = 255;
  1489. *(lpTemp + lOffset+2) = 255;
  1491. }
  1492. //如果当前点为黑色，则把暂时区域中对应点设置为黑色
  1493. else
  1494. {
  1495. *(lpTemp + lOffset)   = 0;
  1496. *(lpTemp + lOffset+1) = 0;
  1497. *(lpTemp + lOffset+2) = 0;
  1498. }
  1499. }
  1500. //把图象四周的点设置为黑色
  1501. for(i=0; i<height; i++)
  1502. {
  1503. lOffset = PixelOffset(i, 0, wBytesPerLine);
  1504. *(lpTemp + lOffset)   = 0;
  1505. *(lpTemp + lOffset+1) = 0;
  1506. *(lpTemp + lOffset+2) = 0;
  1508. }
  1510. for(i=0; i<height; i++)
  1511. {
  1512. lOffset = PixelOffset(i, width-1, wBytesPerLine);
  1513. *(lpTemp + lOffset)   = 0;
  1514. *(lpTemp + lOffset+1) = 0;
  1515. *(lpTemp + lOffset+2) = 0;
  1517. }
  1519. for (i=0; i<width; i++)
  1520. {
  1521. lOffset = PixelOffset(0, i, wBytesPerLine);
  1522. *(lpTemp + lOffset)   = 0;
  1523. *(lpTemp + lOffset+1) = 0;
  1524. *(lpTemp + lOffset+2) = 0;
  1526. }
  1528. for (i=0; i<width; i++)
  1529. {
  1530. lOffset = PixelOffset(height-1, i, wBytesPerLine);
  1531. *(lpTemp + lOffset)   = 0;
  1532. *(lpTemp + lOffset+1) = 0;
  1533. *(lpTemp + lOffset+2) = 0;
  1535. }
  1536. //把暂时区域的点拷贝到原句柄下
  1537. memcpy(lpData,lpTemp,wBytesPerLine*height);
  1538. GlobalUnlock(hDIB);
  1539. GlobalUnlock(hTempDIB);
  1540. GlobalFree(hTempDIB);
  1542. }
  1543. void DIB::Dilation(HANDLE hDIB)
  1544. {
  1545. LPBITMAPINFOHEADER lpbi;
  1546. int height;
  1547. int width;
  1548. WORD wBytesPerLine;
  1549. LPBYTE lpData;
  1550. LPBYTE lpTemp;
  1551. long lOffset;
  1552. //得到图象的基本信息
  1553. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1554. height = lpbi->biHeight;
  1555. width = lpbi->biWidth;
  1556. wBytesPerLine = this->BytePerLine(hDIB);
  1557. lpData = this->FindDIBBits(hDIB);
  1558. //申请一块和数据区大小相同的内存
  1559. lpTemp = (LPBYTE) new BYTE[wBytesPerLine * height];
  1562. long lOffsetJudge;
  1563. for (int i=1; i<height-1; i++)
  1564. for (int j=1; j<width-1; j++)
  1565. {
  1566. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1567. //如果当前点为白色，接着循环
  1568. if(*(lpData + lOffset) == 255)
  1569. {
  1570. *(lpTemp + lOffset++) = 255;
  1571. *(lpTemp + lOffset++) = 255;
  1572. *(lpTemp + lOffset++) = 255;
  1573. continue;
  1574. }
  1575. //否则考察上下左右四个点
  1576. else
  1577. {
  1578. lOffsetJudge = this->PixelOffset(i-1, j, wBytesPerLine);
  1579. //如果上面的点为白色
  1580. if(*(lpData + lOffsetJudge) == 255)
  1581. { //设置为白色，并继续循环
  1582. *(lpTemp + lOffset++) = 255;
  1583. *(lpTemp + lOffset++) = 255;
  1584. *(lpTemp + lOffset++) = 255;
  1585. continue;
  1586. }
  1588. //考察下面的点
  1589. lOffsetJudge = this->PixelOffset(i+1,j, wBytesPerLine);
  1590. if(*(lpData + lOffsetJudge) == 255)
  1591. {
  1592. *(lpTemp + lOffset++) = 255;
  1593. *(lpTemp + lOffset++) = 255;
  1594. *(lpTemp + lOffset++) = 255;
  1595. continue;
  1596. }
  1598. //考察左边的点
  1599. lOffsetJudge = this->PixelOffset(i,j-1, wBytesPerLine);
  1600. if(*(lpData + lOffsetJudge) == 255)
  1601. {
  1602. *(lpTemp + lOffset++) = 255;
  1603. *(lpTemp + lOffset++) = 255;
  1604. *(lpTemp + lOffset++) = 255;
  1605. continue;
  1606. }
  1607. //考察右边的点
  1608. lOffsetJudge = this->PixelOffset(i,j+1, wBytesPerLine);
  1609. if(*(lpData + lOffsetJudge) == 255)
  1610. {
  1611. *(lpTemp + lOffset++) = 255;
  1612. *(lpTemp + lOffset++) = 255;
  1613. *(lpTemp + lOffset++) = 255;
  1614. continue;
  1615. }
  1616. //如果上下左右都是黑色点，则把暂时区域的点设置为黑色
  1617. lOffset = this->PixelOffset(i,j,wBytesPerLine);
  1618. *(lpTemp + lOffset++) = 0;
  1619. *(lpTemp + lOffset++) = 0;
  1620. *(lpTemp + lOffset++) = 0;
  1622. }
  1624. }
  1625. //处理图象四周的点，设置为黑色
  1626. for(i=0; i<height; i++)
  1627. {
  1628. lOffset = this->PixelOffset(i, 0, wBytesPerLine);
  1629. {
  1630. *(lpTemp + lOffset++) = 0;
  1631. *(lpTemp + lOffset++) = 0;
  1632. *(lpTemp + lOffset++) = 0;
  1633. }
  1634. }
  1636. for(i=0; i<height; i++)
  1637. {
  1638. lOffset = this->PixelOffset(i, width-1, wBytesPerLine);
  1639. {
  1640. *(lpTemp + lOffset++) = 0;
  1641. *(lpTemp + lOffset++) = 0;
  1642. *(lpTemp + lOffset++) = 0;
  1643. }
  1644. }
  1646. for(i=0; i<width; i++)
  1647. {
  1648. lOffset = this->PixelOffset(0, i, wBytesPerLine);
  1649. {
  1650. *(lpTemp + lOffset++) = 0;
  1651. *(lpTemp + lOffset++) = 0;
  1652. *(lpTemp + lOffset++) = 0;
  1653. }
  1654. }
  1656. for(i=0; i<width; i++)
  1657. {
  1658. lOffset = this->PixelOffset(height-1, i, wBytesPerLine);
  1659. {
  1660. *(lpTemp + lOffset++) = 0;
  1661. *(lpTemp + lOffset++) = 0;
  1662. *(lpTemp + lOffset++) = 0;
  1663. }
  1664. }
  1665. //把暂时区域的点拷贝到原句柄区域下面
  1666. memcpy(lpData, lpTemp, wBytesPerLine*height);
  1667. delete [] lpTemp;
  1668. GlobalUnlock(hDIB);
  1670. }
  1672. void DIB::DeleteFasleEye(HANDLE hDIB, CRect facelocation)
  1673. {
  1674. LPBYTE lpData;
  1675. LPBITMAPINFOHEADER lpbi;
  1676. int height;
  1677. int width;
  1678. long lOffset;
  1679. WORD wBytesPerLine;
  1681. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1682. height = lpbi->biHeight;
  1683. width = lpbi->biWidth;
  1684. lpData = this->FindDIBBits(hDIB);
  1685. wBytesPerLine = this->BytePerLine(hDIB);
  1686. for (int i=0; i<height; i++)
  1687. for (int j=0; j<width; j++)
  1688. {
  1689. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1690. if(*(lpData + lOffset) == 255)
  1691. {
  1692. if(i<(facelocation.bottom+facelocation.top)/2)
  1693. {
  1694. *(lpData + lOffset++) = 0;
  1695. *(lpData + lOffset++) = 0;
  1696. *(lpData + lOffset++) = 0;
  1697. }
  1698. }
  1699. }
  1700. GlobalUnlock(hDIB);
  1701. }
  1703. void DIB::DeleteScatePoint(HANDLE hDIB)
  1704. {
  1705. LPBITMAPINFOHEADER lpbi;
  1706. int height;
  1707. int width;
  1708. LPBYTE lpData;
  1709. WORD wBytesPerLine;
  1710. long lOffset;
  1712. //得到图象的基本信息
  1713. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1714. height = lpbi->biHeight;
  1715. width  = lpbi->biWidth;
  1716. wBytesPerLine = this->BytePerLine(hDIB);
  1717. lpData = this->FindDIBBits(hDIB);
  1719. for (int i=0; i<height; i++)
  1720. for(int j=0; j<width; j++)
  1721. {
  1722. //得到偏移
  1723. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1724. //如果当前点为白色点
  1725. if(*(lpData + lOffset) == 255)
  1726. {
  1727. //设定判断数组
  1728. for(int ii = 0;ii<ImgRange;ii++)
  1729. for (int jj=0; jj<ImgRange; jj++)
  1730. this->lab[ii][jj] = false;
  1731. //设定判断长度
  1732. this->lenth=0;
  1733. //判断是否为离散点
  1734. bool judge = this->IsScaterPoint(j, i, width,height,lpData,wBytesPerLine,3,this->lab);
  1735. if(!judge)
  1736. {
  1737. //是离散点则把该点设置为黑色
  1738. *(lpData + lOffset++) = 0;
  1739. *(lpData + lOffset++) = 0;
  1740. *(lpData + lOffset++) = 0;
  1741. }
  1742. }
  1743. }
  1744. GlobalUnlock(hDIB);
  1745. }
  1747. void  DIB::  MouseMap(LPBYTE lpRgb, const LPBYTE lpYcc,  WORD wBytesPerLine, CRect faceLocation)
  1748. {
  1749. //下面的循环在人脸的区域内实现嘴巴的匹配
  1750. for (int i=faceLocation.top; i<faceLocation.bottom; i++)
  1751. for (int j=faceLocation.left; j<faceLocation.right; j++)
  1752. {
  1753. //得到偏移
  1754. long lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1755. //得到cr，cb的数值
  1756. int cr = *(lpYcc+lOffset+1);
  1757. int cb = *(lpYcc+lOffset+2);
  1758. //标志
  1759. bool lab;
  1760. int mapm;
  1761. //根据cr的数值设定标志
  1762. cr = cr-143;
  1763. if(cr <-5 || cr>5)
  1764. {
  1765. cr = 0;
  1767. }
  1769. cr *=cr;
  1771. if(cr>16)
  1772.  lab = true;
  1773. else
  1774. lab = false;
  1775. //根据cb的时值设定标志
  1776. cb= cb-120;
  1777. if(cb<-5 || cb >5)
  1779. {
  1780. cb = 0;
  1781. if(lab = true)
  1782. lab = false;
  1783. }
  1784. //如果cr，cb两项数值都在设定的范围之内，则设定颜色位白色，否则黑色
  1785. if(lab)
  1786. mapm = 255;
  1787. else
  1788. mapm = 0;
  1789.  
  1790. *(lpRgb + lOffset++) = mapm;
  1791. *(lpRgb + lOffset++) = mapm;
  1792. *(lpRgb + lOffset++) = mapm;
  1795. }
  1796. }
  1798. void DIB::MouthCenter(HANDLE hDIB, CRect faceLocation, CPoint &mouthLocation)
  1799. {
  1800. LPBITMAPINFOHEADER lpbi;
  1801. int height;
  1802. int width;
  1803. long lOffset;
  1804. WORD wBytesPerLine;
  1805. LPBYTE lpData;
  1807. //得到图象的基本信息
  1808. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1809. height = lpbi->biHeight;
  1810. width  = lpbi->biWidth;
  1811. wBytesPerLine = this->BytePerLine(hDIB);
  1812. lpData = this->FindDIBBits(hDIB);
  1814. //下面的三个变量用来累计嘴巴区域的象素的x，y和象素点数
  1815. int xnum = 0 ;
  1816. int ynum = 0 ;
  1817. int count = 0;
  1818. for (int i=faceLocation.top; i<faceLocation.bottom; i++)
  1819. for (int j=faceLocation.left; j<faceLocation.right; j++)
  1820. {
  1821. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1822. //白色点
  1823. if(*(lpData + lOffset) == 255)
  1824. {
  1825. //x值加
  1826. xnum +=j;
  1827. //y值加
  1828. ynum +=i;
  1829. //点数加
  1830. count++;
  1831. }
  1832. }
  1833. //得到中心点位置
  1834. mouthLocation.x = xnum/count;
  1835. mouthLocation.y = ynum/count;
  1837. //把中心点设置位绿色
  1838. lOffset = this->PixelOffset(mouthLocation.y, mouthLocation.x, wBytesPerLine);
  1839. *(lpData + lOffset++) =0;
  1840. *(lpData + lOffset++) =255;
  1841. *(lpData + lOffset++) =0;
  1843. GlobalUnlock(hDIB);
  1844. }
  1846. void DIB::EyeCenter(HANDLE hDIB, CRect faceLocation, CPoint &eye1, CPoint &eye2)
  1847. {
  1848. LPBITMAPINFOHEADER lpbi;
  1849. LPBYTE lpData;
  1850. long lOffset;
  1851. WORD wBytesPerLine;
  1852. int height;
  1853. int width;
  1854. int pixelnum =0;
  1855. int num =0;
  1856. //得到图象基本信息
  1857. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1858. height = lpbi->biHeight;
  1859. width  = lpbi->biWidth;
  1860. lpData = this->FindDIBBits(hDIB);
  1861. wBytesPerLine  = this->BytePerLine(hDIB);
  1862. //考察人脸区域
  1863. for(int i=faceLocation.top; i<faceLocation.bottom; i++)
  1864. for (int j=faceLocation.left; j<faceLocation.right; j++)
  1865. {
  1866. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1867. //白色点
  1868. if(*(lpData + lOffset) == 255)
  1869. //递归统计象素并修改象素值
  1870. this->RecursiveCal(lpData,i,j,wBytesPerLine,pixelnum,++num);
  1871. }
  1872. //初始化眼睛的坐标
  1873. eye1.x =0;
  1874. eye1.y =0;
  1875. eye2.x =0;
  1876. eye2.y =0;
  1877. //初始化象素点个数
  1878. int eye1count=0;
  1879. int eye2count =0;
  1880. for (i=faceLocation.top; i<faceLocation.bottom; i++)
  1881. for (int j=faceLocation.left; j<faceLocation.right; j++)
  1882. {
  1883. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1884. //如果象素点的数值为1
  1885. if(*(lpData + lOffset) == 1)
  1886. {
  1887. //眼睛1的横坐标和纵坐标加上当前点的坐标值
  1888. eye1.x +=j;
  1889. eye1.y +=i;
  1890. eye1count++;
  1891. //把当前点改成白色
  1892. *(lpData + lOffset++) = 255;
  1893. *(lpData + lOffset++) = 255;
  1894. *(lpData + lOffset++) = 255;
  1896. }
  1897. //如果当前象素的数值为2
  1898. else if(*(lpData + lOffset) == 2)
  1899. {
  1900. //眼睛2的横坐标和纵坐标加上当前点的坐标值
  1901. eye2.x +=j;
  1902. eye2.y +=i;
  1903. //象素点个数加一
  1904. eye2count++;
  1905. //把当前点设置为白色
  1906. *(lpData + lOffset++) = 255;
  1907. *(lpData + lOffset++) = 255;
  1908. *(lpData + lOffset++) = 255;
  1909. }
  1910. }
  1911. //计算眼睛的中心点坐标
  1912. eye1.x /=eye1count;
  1913. eye1.y /=eye1count;
  1914. eye2.x /=eye2count;
  1915. eye2.y /=eye2count;
  1916. //把中心点设置为绿色
  1917. lOffset = this->PixelOffset(eye1.y, eye1.x ,wBytesPerLine);
  1918. *(lpData + lOffset++) = 0;
  1919. *(lpData + lOffset++) = 255;
  1920. *(lpData + lOffset++) = 0;
  1922. lOffset = this->PixelOffset(eye2.y, eye2.x ,wBytesPerLine);
  1923. *(lpData + lOffset++) = 0;
  1924. *(lpData + lOffset++) = 255;
  1925. *(lpData + lOffset++) = 0;
  1926. GlobalUnlock(hDIB);
  1927. }
  1929. void DIB::EllipseFace(HANDLE hDIB, CPoint mouth, CPoint eye1, CPoint eye2)
  1930. {
  1931. LPBYTE lpData;
  1932. LPBITMAPINFOHEADER lpbi;
  1933. int width;
  1934. int height;
  1935. WORD wBytesPerLine;
  1936. long lOffset;
  1937. //得到图象的基本信息
  1938. lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
  1939. height = lpbi->biHeight;
  1940. width  = lpbi->biWidth;
  1941. lpData = this->FindDIBBits(hDIB);
  1942. wBytesPerLine = this->BytePerLine(hDIB);
  1944. //用dda算法画三角形
  1945. this->DdaLine(mouth,eye1,lpData,wBytesPerLine);
  1946. this->DdaLine(mouth,eye2,lpData,wBytesPerLine);
  1947. this->DdaLine(eye1,eye2,lpData,wBytesPerLine);
  1949. //椭圆的中心点和两个焦点坐标
  1950. int ellipsecenter_x;
  1951. int ellipsecenter_y;
  1952. int ellipseFocusTop_x;
  1953. int ellipseFocusTop_y;
  1954. int ellipseFocusBottom_x;
  1955. int ellipseFocusBottom_y;
  1957. //根据眼睛和嘴巴的坐标计算椭圆的中心点坐标
  1958. ellipsecenter_x = (eye1.x + eye2.x + mouth.x )/3;
  1959. ellipsecenter_y = (eye1.y + eye2.y)/2 -abs(eye2.x - eye1.x)/2;
  1961. //上面的焦点
  1962. ellipseFocusTop_x = ellipsecenter_x;
  1963. ellipseFocusBottom_x = ellipsecenter_x;
  1965. //下面的焦点
  1966. ellipseFocusTop_y =  ellipsecenter_y + (eye1.y +eye2.y)/2 -mouth.y;
  1967. ellipseFocusBottom_y = ellipsecenter_y - ((eye1.y +eye2.y)/2 -mouth.y)+2;
  1969. //长轴
  1970. int a = (eye1.x-eye2.x)*2-2;
  1972. for (int i=0; i<height; i++)
  1973. for (int j=0; j<width; j++)
  1974. {
  1975. //得到一个点到两个焦点的距离和
  1976. int lenth = sqrt(pow(j-ellipseFocusTop_x,2)+pow(i-ellipseFocusTop_y,2))
  1977. +sqrt(pow(j-ellipseFocusBottom_x,2)+ pow(i-ellipseFocusBottom_y,2));
  1978. //判断距离和与长轴的关系
  1979. if(lenth<2*a+2 && lenth >2*a-2)
  1980. {
  1981. //把点设置为绿色
  1982. lOffset = this->PixelOffset(i, j, wBytesPerLine);
  1983. *(lpData + lOffset++) = 0;
  1984. *(lpData + lOffset++) = 255;
  1985. *(lpData + lOffset++) = 0;
  1986. }
  1987. }
  1990. GlobalUnlock(hDIB);
  1991. }
  1994. void DIB::DdaLine(CPoint from, CPoint end, LPBYTE lpData, WORD wBytesPerLine)
  1995. {
  1996. //x，y的增量
  1997. float delta_x;
  1998. float delta_y;
  1999. //x，y的坐标
  2000. float x;
  2001. float y;
  2002. //x，y上的差值
  2003. int dx;
  2004. int dy;
  2005. //总的步长
  2006. int steps;
  2007. int k;
  2008. //得到x，y的差值
  2009. dx = end.x - from.x;
  2010. dy = end.y - from.y;
  2011. //判断x，y上的差值大小，确定步长
  2012. if(abs(dx) > abs(dy))
  2013. {
  2014. steps = abs(dx);
  2015. }
  2016. else
  2017. {
  2018. steps = abs(dy);
  2019. }
  2021. //得到每次增量的大小
  2022. delta_x = (float)dx / (float)steps;
  2023. delta_y = (float)dy / (float)steps;
  2024. //设定x，y的起点
  2025. x = (float)from.x;
  2026. y = (float)from.y;
  2028. //设定初始点的颜色为绿色
  2029. long lOffset = this->PixelOffset(y, x, wBytesPerLine);
  2030. *(lpData + lOffset++) = 0;
  2031. *(lpData + lOffset++) = 255;
  2032. *(lpData + lOffset++) = 0;
  2034. //根据计算得到的步长，把直线上的点填充成绿色
  2035. for (k=1;k<=steps; k++)
  2036. {
  2037. //x，y分别加上各自的增量
  2038. x+=delta_x;
  2039. y+=delta_y;
  2040. //设置点的颜色
  2041. lOffset = this->PixelOffset(y, x, wBytesPerLine);
  2042. *(lpData + lOffset++) = 0;
  2043. *(lpData + lOffset++) = 255;
  2044. *(lpData + lOffset++) = 0;
  2046. }
  2049. }