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

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

图形图像处理

开发平台：

Visual C++

LikelyHood.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. // LikelyHood.cpp: 类CLikelyHood的接口
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "FaceDetect.h"
  7. #include "LikelyHood.h"
  8. #include "DIB.h"
  9. //////////////////////////////////////////////////////////////////////
  10. // 构造函数/析构函数
  11. //////////////////////////////////////////////////////////////////////
  13. CLikelyHood::CLikelyHood()
  14. {
  15. m_pLikeliHoodArray = NULL;
  16. m_pBinaryArray = NULL;
  18. bmean =  B_Mean;
  19. rmean =  R_Mean;
  20. brcov[0][0] =  Brcov00;
  21. brcov[0][1] =  Brcov01;
  22. brcov[1][0] =  Brcov10;
  23. brcov[1][1] =  Brcov11;
  24. }
  26. //////////////////////////////////////////////////////////////////////
  27. //构造函数：
  28. //参数：    source－输入图像数据
  29. //          width－图像宽度
  30. //          height－图像高度
  31. //////////////////////////////////////////////////////////////////////
  32. CLikelyHood::CLikelyHood(RGBQUAD ** source,int width,int height)
  33. {
  34. int i;
  36. bmean =  B_Mean;
  37. rmean =  R_Mean;
  38. brcov[0][0] =  Brcov00;
  39. brcov[0][1] =  Brcov01;
  40. brcov[1][0] =  Brcov10;
  41. brcov[1][1] =  Brcov11;
  43. m_nWidth = width;
  44. m_nHeight= height;
  46. m_bLikeliHoodReady = false;
  47. m_bBinaryReady = false;
  49. //初始化各数组
  50. m_pSourceData = source;
  52. m_pLikeliHoodArray = new  double*[height];
  53. for(i=0;i <height; i++)
  54. m_pLikeliHoodArray[i] = new double[width];
  56. m_pBinaryArray = new  BYTE*[height];
  57. for(i=0;i <height; i++)
  58. m_pBinaryArray[i] = new BYTE[width];
  59. }
  61. ////////////////////////////////////////////////////////////////////////
  62. //析构函数
  63. ////////////////////////////////////////////////////////////////////////
  64. CLikelyHood::~CLikelyHood()
  65. {
  66. if(m_pLikeliHoodArray!=NULL)
  67. {
  68. for(int i=0;i<m_nHeight;i++)
  69. if(m_pLikeliHoodArray[i]!=NULL) delete m_pLikeliHoodArray[i];
  70. delete m_pLikeliHoodArray;
  71. }
  72. if(m_pBinaryArray!=NULL)
  73. {
  74. for(int i=0;i<m_nHeight;i++)
  75. if(m_pBinaryArray[i]!=NULL) delete m_pBinaryArray[i];
  76. delete m_pBinaryArray;
  77. }
  78. }
  80. //////////////////////////////////////////////////////////////////////////
  81. //计算相似度
  82. //////////////////////////////////////////////////////////////////////////
  83. void CLikelyHood::CalLikeHood()
  84. {
  85. int i,j;
  87. for(i=0; i<m_nHeight; i++)
  88. {
  89. for(j=0; j<m_nWidth; j++)
  90. {
  91. double x1,x2;
  92. TCbCr temp = CalCbCr(m_pSourceData[i][j].rgbRed,m_pSourceData[i][j].rgbGreen,m_pSourceData[i][j].rgbBlue);
  93. x1 = temp.Cb-bmean;
  94. x2 = temp.Cr-rmean;
  95. double t;
  96. t = x1*(x1*brcov[1][1]-x2*brcov[1][0])+x2*(-x1*brcov[0][1]+x2*brcov[0][0]);
  97. t /= (brcov[0][0]*brcov[1][1]-brcov[0][1]*brcov[1][0]);
  98. t /= (-2);
  99. m_pLikeliHoodArray[i][j] = exp(t);
  100. }
  101. }
  103. filter(m_pLikeliHoodArray,m_nWidth,m_nHeight);
  105. double max = 0.0;
  106. for(i=0; i<m_nHeight; i++)
  107. for(j=0; j<m_nWidth; j++)
  108. if(m_pLikeliHoodArray[i][j] > max) 
  109. max = m_pLikeliHoodArray[i][j];
  111. for(i=0; i<m_nHeight; i++)
  112. {
  113. for(j=0; j<m_nWidth; j++)
  114. {
  115. m_pLikeliHoodArray[i][j] /= max;
  116. }
  117. }
  119. m_bLikeliHoodReady = true;
  120. }
  122. ///////////////////////////////////////////////////////////////////////////////
  123. //计算Cb，Cr
  124. ///////////////////////////////////////////////////////////////////////////////
  125. TCbCr CLikelyHood::CalCbCr(int R, int G, int B)
  126. {
  127. TCbCr res;
  128. res.Cb =( 128 - 37.797 * R/255 - 74.203 * G/255 +   112 * B/255);
  129. res.Cr =( 128 + 112    * R/255 - 93.786 * G/255 -18.214 * B/255);
  130. return res;
  131. }
  133. ///////////////////////////////////////////////////////////////////////////////
  134. //滤波
  135. ///////////////////////////////////////////////////////////////////////////////
  136. void CLikelyHood::filter(double** source,int m_nWidth,int m_nHeight)
  137. {
  138. int i,j;
  139. double **temp;
  140. //申请一个临时二维数组
  141. temp = new  double*[m_nHeight+2];
  142. for(i=0;i <=m_nHeight+1; i++)
  143. temp[i] = new double[m_nWidth+2];
  145. //边界均设为0
  146. for(i=0; i<=m_nHeight+1; i++)
  147. {
  148. temp[i][0] = 0;
  149. temp[i][m_nWidth+1] = 0;
  150. }
  151. for(j=0; j<=m_nWidth+1; j++)
  152. {
  153. temp[0][j] = 0;
  154. temp[m_nHeight+1][j] = 0;
  155. }
  157. //将原数组的值赋予临时数组
  158. for(i=0; i<m_nHeight; i++)
  159. for(j=0; j<m_nWidth; j++)
  160. temp[i+1][j+1] = source[i][j];
  162. //均值滤波
  163. for(i=0; i<m_nHeight; i++)
  164. {
  165. for(j=0; j<m_nWidth; j++)
  166. {
  167. source[i][j] = 0;
  168. for(int k=0;k<=2;k++)
  169. for(int l=0;l<=2;l++)
  170. source[i][j] += temp[i+k][j+l];
  172. source[i][j] /= 9;
  173. }
  174. }
  176. if(temp!=NULL)
  177. {
  178. for(int i=0;i<=m_nHeight+1;i++)
  179. if(temp[i]!=NULL) delete temp[i];
  180. delete temp;
  181. }
  182. }
  184. //////////////////////////////////////////////////////////////////////////
  185. //二值化图像
  186. //////////////////////////////////////////////////////////////////////////
  187. bool CLikelyHood::CalBinary()
  188. {
  189. if(!m_bLikeliHoodReady) 
  190. return false;
  191. int i,j;
  192. BYTE **temp;
  193. temp = new  BYTE*[m_nHeight];
  194. for(i=0;i <m_nHeight; i++)
  195. {
  196. temp[i] = new BYTE[m_nWidth];
  197. for(j=0; j<m_nWidth; j++) 
  198. temp[i][j] = 0;
  199. }
  202. double min = 10000000000000000.0;
  203. int index = -1;
  204. int a,b;
  205. a=0;b=0;
  206. for(int k=5;k>=0;k--)
  207. {
  208. double sum = 0;
  209. for(i=0; i<m_nHeight; i++)
  210. for(j=0; j<m_nWidth; j++)
  211. {
  212.    
  213. if(m_pLikeliHoodArray[i][j]>k*0.1+0.05)
  214. {m_pBinaryArray[i][j] = 1;a++;}
  215. else
  216. {m_pBinaryArray[i][j] = 0;b++;}
  217. sum += (m_pBinaryArray[i][j]-temp[i][j]);
  218. }
  220. if(sum < min)
  221. {
  222. min = sum;
  223. index = 6-k;
  224. }
  226.     for(i=0; i<m_nHeight; i++)
  227.     for(j=0; j<m_nWidth; j++)
  228. temp[i][j] = m_pBinaryArray[i][j];
  229. }
  231. double optimalThreshold = (7-index)*0.1;
  232. for(i=0; i<m_nHeight; i++)
  233. for(j=0; j<m_nWidth; j++)
  234. {
  235. if(m_pLikeliHoodArray[i][j]>optimalThreshold)
  236.      m_pBinaryArray[i][j] = 1;
  237. else
  238. m_pBinaryArray[i][j] = 0;
  239. }
  241. if(temp!=NULL)
  242. {
  243. for(int i=0;i<=m_nHeight-1;i++)
  244. if(temp[i]!=NULL) delete temp[i];
  245. delete temp;
  246. }
  248. m_bBinaryReady = true;
  249. ///////
  251. return true;
  252. }
  254. /////////////////////////////////////////////////////////////////////////
  255. //功能：训练参数
  256. //参数：DirectPath－Bmp文件路径
  257. /////////////////////////////////////////////////////////////////////////
  258. int CLikelyHood::CalParameter(CString DirectPath)
  259. {
  260. WIN32_FIND_DATA FindFileData;
  261. HANDLE hFind;
  262. BOOL  FINDOVER=TRUE;
  263. hFind = FindFirstFile(DirectPath+"\*.bmp", &FindFileData);
  265. if (hFind == INVALID_HANDLE_VALUE)
  266. {
  267. return 0;
  268. }
  270. int filenum = 0;
  271. while(FINDOVER)
  272. {
  273. CString m_sOpenFileName=DirectPath+FindFileData.cFileName;
  274. filenum ++;
  275. FINDOVER=FindNextFile(hFind,&FindFileData);
  276. }
  277. FindClose(hFind);
  279. double **CrList,**CbList;
  280. CrList = new double*[filenum];
  281. CbList = new double*[filenum];
  283. int* mapLength = new int[filenum];
  285. FINDOVER=TRUE;
  286. BOOL FileOK=true;
  287. int index = 0;
  288. hFind = FindFirstFile(DirectPath+"\*.bmp", &FindFileData);
  289. while(FINDOVER && FileOK)
  290. {
  291. CString m_sOpenFileName=DirectPath+"\"+FindFileData.cFileName;
  292. DIB * dib;
  293. dib = new DIB();
  295. if(FileOK)
  296. {
  297. int m_nBitMapWidth = dib->GetWidth();
  298. int m_nBitMapHeight= dib->GetHeight();
  299. CrList[index] = new double[m_nBitMapWidth*m_nBitMapHeight];
  300. CbList[index] = new double[m_nBitMapWidth*m_nBitMapHeight];
  301. mapLength[index] = m_nBitMapWidth*m_nBitMapHeight;
  303. BYTE *colorTable;
  304. DIB *m_pMainDib=new DIB();
  305.             BYTE *m_pDib=m_pMainDib->GetBits();
  306. colorTable = (BYTE *)m_pDib;
  307. int byteBitCount  = dib->GetBiBitCount()/8;
  308. int count = 0;
  309. double **tempCr,**tempCb;
  310. tempCr = new  double*[m_nBitMapHeight];
  311. tempCb = new  double*[m_nBitMapHeight];
  312. for(int i=0;i <m_nBitMapHeight; i++)
  313. {
  314. tempCr[i] = new double[m_nBitMapWidth];
  315. tempCb[i] = new double[m_nBitMapWidth];
  316. }
  318. for(i=m_nBitMapHeight-1; i>=0; i--)
  319. {
  320. for(int j=0; j<m_nBitMapWidth; j++)
  321. {
  322. TCbCr temp = CalCbCr(colorTable[count+2],colorTable[count+1],colorTable[count]);
  323. tempCr[i][j] = temp.Cr;
  324. tempCb[i][j] = temp.Cb;
  325. //int q = m_nBitMapWidth*(m_nBitMapHeight-1-i)+j;
  326. //CrList[index][q]= temp.Cr;
  327. //CbList[index][q]= temp.Cb;
  328. count += byteBitCount;
  329. }
  330. count += (4-(m_nBitMapWidth*byteBitCount)%4)%4;
  331. }
  332. filter(tempCr,m_nBitMapWidth,m_nBitMapHeight);
  333. filter(tempCb,m_nBitMapWidth,m_nBitMapHeight);
  334. for(i=0 ; i<m_nBitMapHeight; i++)
  335. {
  336. for(int j=0; j<m_nBitMapWidth; j++)
  337. {
  338. int q = m_nBitMapWidth*i+j;
  339. CrList[index][q]= tempCr[i][j];
  340. CbList[index][q]= tempCb[i][j];
  341. }
  342. }
  343. for(i=0;i<m_nBitMapHeight;i++)
  344. {
  345. delete tempCr[i];
  346. delete tempCb[i];
  347. }
  348. delete tempCr;
  349. delete tempCb;
  351. index++;
  352. }
  353. delete dib;
  354. FINDOVER=FindNextFile(hFind,&FindFileData);
  355. }
  356. FindClose(hFind);
  358. double avgCr = 0;
  359. double avgCb = 0;
  360. double cov00,cov01,cov10,cov11;
  361. cov00 = cov01 = cov10 = cov11 = 0.0;
  362. int totallen = 0;
  364. if(FileOK)
  365. {
  366. for(int i=0;i<filenum;i++)
  367. {
  368. totallen+=mapLength[i];
  369. for(int j=0;j<mapLength[i];j++)
  370. {
  371. avgCr += CrList[i][j];
  372. avgCb += CbList[i][j];
  373. }
  374. }
  375. avgCr /= totallen;
  376. avgCb /= totallen;
  378. for(i=0;i<filenum;i++)
  379. {
  380. for(int j=0;j<mapLength[i];j++)
  381. {
  382. cov11 += (CrList[i][j]-avgCr)*(CrList[i][j]-avgCr);
  383. cov00 += (CbList[i][j]-avgCb)*(CbList[i][j]-avgCb);
  384. cov01 += (CrList[i][j]-avgCr)*(CbList[i][j]-avgCb);
  385. }
  386. }
  387. cov00 /= totallen;
  388. cov01 /= totallen;
  389. cov10 = cov01;
  390. cov11 /= totallen;
  391. }
  393. for(int i=0;i<filenum;i++)
  394. {
  395. if(CrList[i]!=NULL) delete CrList[i];
  396. if(CbList[i]!=NULL) delete CbList[i];
  397. }
  398. delete mapLength;
  399. if(!FileOK) return 1;
  401. if((cov00*cov11-cov01*cov01) == 0) return 2;
  403. bmean =  avgCb;
  404. rmean =  avgCr;
  405. brcov[0][0] =  cov00;
  406. brcov[0][1] =  cov01;
  407. brcov[1][0] =  cov10;
  408. brcov[1][1] =  cov11;
  409. return 3;
  410. }