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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
LikelyHood.cpp
资源名称：face.rar　[点击查看]
上传用户：joy_gong
上传日期：2020-11-30
资源大小：459k
文件大小：10k
源码类别：

生物技术

开发平台：

Visual C++

LikelyHood.cpp：源码内容
  1. //////////////////////////////////////////////////////////////////////
  2. // LikelyHood.cpp: 类CLikelyHood的接口
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "FaceDetect.h"
  7. #include "LikelyHood.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;
  51. m_pLikeliHoodArray = new  double*[height];
  52. for(i=0;i <height; i++)
  53. m_pLikeliHoodArray[i] = new double[width];
  54. m_pBinaryArray = new  BYTE*[height];
  55. for(i=0;i <height; i++)
  56. m_pBinaryArray[i] = new BYTE[width];
  57. }
  59. ////////////////////////////////////////////////////////////////////////
  60. //析构函数
  61. ////////////////////////////////////////////////////////////////////////
  62. CLikelyHood::~CLikelyHood()
  63. {
  64. if(m_pLikeliHoodArray!=NULL)
  65. {
  66. for(int i=0;i<m_nHeight;i++)
  67. if(m_pLikeliHoodArray[i]!=NULL) delete m_pLikeliHoodArray[i];
  68. delete m_pLikeliHoodArray;
  69. }
  70. if(m_pBinaryArray!=NULL)
  71. {
  72. for(int i=0;i<m_nHeight;i++)
  73. if(m_pBinaryArray[i]!=NULL) delete m_pBinaryArray[i];
  74. delete m_pBinaryArray;
  75. }
  76. }
  78. //////////////////////////////////////////////////////////////////////////
  79. //计算相似度
  80. //////////////////////////////////////////////////////////////////////////
  81. void CLikelyHood::CalLikeHood()
  82. {
  83. int i,j;
  85. for(i=0; i<m_nHeight; i++)
  86. {
  87. for(j=0; j<m_nWidth; j++)
  88. {
  89. double x1,x2;
  90. TCbCr temp = CalCbCr(m_pSourceData[i][j].rgbRed,m_pSourceData[i][j].rgbGreen,m_pSourceData[i][j].rgbBlue);
  91. x1 = temp.Cb-bmean;
  92. x2 = temp.Cr-rmean;
  93. double t;
  94. t = x1*(x1*brcov[1][1]-x2*brcov[1][0])+x2*(-x1*brcov[0][1]+x2*brcov[0][0]);
  95. t /= (brcov[0][0]*brcov[1][1]-brcov[0][1]*brcov[1][0]);
  96. t /= (-2);
  97. m_pLikeliHoodArray[i][j] = exp(t);
  98. }
  99. }
  101. filter(m_pLikeliHoodArray,m_nWidth,m_nHeight);
  103. double max = 0.0;
  104. for(i=0; i<m_nHeight; i++)
  105. for(j=0; j<m_nWidth; j++)
  106. if(m_pLikeliHoodArray[i][j] > max) 
  107. max = m_pLikeliHoodArray[i][j];
  109. for(i=0; i<m_nHeight; i++)
  110. {
  111. for(j=0; j<m_nWidth; j++)
  112. {
  113. m_pLikeliHoodArray[i][j] /= max;
  114. }
  115. }
  117. m_bLikeliHoodReady = true;
  118. }
  120. ///////////////////////////////////////////////////////////////////////////////
  121. //计算Cb，Cr
  122. ///////////////////////////////////////////////////////////////////////////////
  123. TCbCr CLikelyHood::CalCbCr(int R, int G, int B)
  124. {
  125. TCbCr res;
  126. res.Cb =( 128 - 37.797 * R/255 - 74.203 * G/255 +   112 * B/255);
  127. res.Cr =( 128 + 112    * R/255 - 93.786 * G/255 -18.214 * B/255);
  128. return res;
  129. }
  131. ///////////////////////////////////////////////////////////////////////////////
  132. //滤波
  133. ///////////////////////////////////////////////////////////////////////////////
  134. void CLikelyHood::filter(double** source,int m_nWidth,int m_nHeight)
  135. {
  136. int i,j;
  137. double **temp;
  138. //申请一个临时二维数组
  139. temp = new  double*[m_nHeight+2];
  140. for(i=0;i <=m_nHeight+1; i++)
  141. temp[i] = new double[m_nWidth+2];
  143. //边界均设为0
  144. for(i=0; i<=m_nHeight+1; i++)
  145. {
  146. temp[i][0] = 0;
  147. temp[i][m_nWidth+1] = 0;
  148. }
  149. for(j=0; j<=m_nWidth+1; j++)
  150. {
  151. temp[0][j] = 0;
  152. temp[m_nHeight+1][j] = 0;
  153. }
  155. //将原数组的值赋予临时数组
  156. for(i=0; i<m_nHeight; i++)
  157. for(j=0; j<m_nWidth; j++)
  158. temp[i+1][j+1] = source[i][j];
  160. //均值滤波
  161. for(i=0; i<m_nHeight; i++)
  162. {
  163. for(j=0; j<m_nWidth; j++)
  164. {
  165. source[i][j] = 0;
  166. for(int k=0;k<=2;k++)
  167. for(int l=0;l<=2;l++)
  168. source[i][j] += temp[i+k][j+l];
  170. source[i][j] /= 9;
  171. }
  172. }
  174. if(temp!=NULL)
  175. {
  176. for(int i=0;i<=m_nHeight+1;i++)
  177. if(temp[i]!=NULL) delete temp[i];
  178. delete temp;
  179. }
  180. }
  182. //////////////////////////////////////////////////////////////////////////
  183. //二值化图像
  184. //////////////////////////////////////////////////////////////////////////
  185. bool CLikelyHood::CalBinary()
  186. {
  187. if(!m_bLikeliHoodReady) 
  188. return false;
  189. int i,j;
  190. BYTE **temp;
  191. temp = new  BYTE*[m_nHeight];
  192. for(i=0;i <m_nHeight; i++)
  193. {
  194. temp[i] = new BYTE[m_nWidth];
  195. for(j=0; j<m_nWidth; j++) 
  196. temp[i][j] = 0;
  197. }
  199. double min = 10000000000000000.0;
  200. int index = -1;
  201. for(int k=5;k>=0;k--)
  202. {
  203. double sum = 0;
  204. for(i=0; i<m_nHeight; i++)
  205. for(j=0; j<m_nWidth; j++)
  206. {
  207. if(m_pLikeliHoodArray[i][j]>k*0.1+0.05)
  208. m_pBinaryArray[i][j] = 1;
  209. else
  210. m_pBinaryArray[i][j] = 0;
  211. sum += (m_pBinaryArray[i][j]-temp[i][j]);
  212. }
  214. if(sum < min)
  215. {
  216. min = sum;
  217. index = 6-k;
  218. }
  220.     for(i=0; i<m_nHeight; i++)
  221.     for(j=0; j<m_nWidth; j++)
  222. temp[i][j] = m_pBinaryArray[i][j];
  223. }
  225. double optimalThreshold = (7-index)*0.1;
  226. for(i=0; i<m_nHeight; i++)
  227. for(j=0; j<m_nWidth; j++)
  228. {
  229. if(m_pLikeliHoodArray[i][j]>optimalThreshold)
  230. m_pBinaryArray[i][j] = 1;
  231. else
  232. m_pBinaryArray[i][j] = 0;
  233. }
  235. if(temp!=NULL)
  236. {
  237. for(int i=0;i<=m_nHeight-1;i++)
  238. if(temp[i]!=NULL) delete temp[i];
  239. delete temp;
  240. }
  242. m_bBinaryReady = true;
  244. return true;
  245. }
  247. /////////////////////////////////////////////////////////////////////////
  248. //功能：训练参数
  249. //参数：DirectPath－Bmp文件路径
  250. /////////////////////////////////////////////////////////////////////////
  251. int CLikelyHood::CalParameter(CString DirectPath)
  252. {
  253. WIN32_FIND_DATA FindFileData;
  254. HANDLE hFind;
  255. BOOL  FINDOVER=TRUE;
  256. hFind = FindFirstFile(DirectPath+"\*.bmp", &FindFileData);
  258. if (hFind == INVALID_HANDLE_VALUE)
  259. {
  260. return 0;
  261. }
  263. int filenum = 0;
  264. while(FINDOVER)
  265. {
  266. CString m_sOpenFileName=DirectPath+FindFileData.cFileName;
  267. filenum ++;
  268. FINDOVER=FindNextFile(hFind,&FindFileData);
  269. }
  270. FindClose(hFind);
  272. double **CrList,**CbList;
  273. CrList = new double*[filenum];
  274. CbList = new double*[filenum];
  276. int* mapLength = new int[filenum];
  278. FINDOVER=TRUE;
  279. BOOL FileOK=true;
  280. int index = 0;
  281. hFind = FindFirstFile(DirectPath+"\*.bmp", &FindFileData);
  282. while(FINDOVER && FileOK)
  283. {
  284. CString m_sOpenFileName=DirectPath+"\"+FindFileData.cFileName;
  285. CDib * dib;
  286. dib = new CDib();
  287. if(!dib->Open(m_sOpenFileName))
  288. {
  289. AfxMessageBox(m_sOpenFileName+": Invalid File Format! It must be BMP File");
  290. FileOK = false;
  291. }
  292. if(FileOK)
  293. {
  294. int m_nBitMapWidth = dib->GetWidth();
  295. int m_nBitMapHeight= dib->GetHeight();
  296. CrList[index] = new double[m_nBitMapWidth*m_nBitMapHeight];
  297. CbList[index] = new double[m_nBitMapWidth*m_nBitMapHeight];
  298. mapLength[index] = m_nBitMapWidth*m_nBitMapHeight;
  300. BYTE *colorTable;
  301. colorTable = (BYTE *)dib->m_pDibBits;
  302. int byteBitCount  = dib->GetBiBitCount()/8;
  303. int count = 0;
  304. double **tempCr,**tempCb;
  305. tempCr = new  double*[m_nBitMapHeight];
  306. tempCb = new  double*[m_nBitMapHeight];
  307. for(int i=0;i <m_nBitMapHeight; i++)
  308. {
  309. tempCr[i] = new double[m_nBitMapWidth];
  310. tempCb[i] = new double[m_nBitMapWidth];
  311. }
  313. for(i=m_nBitMapHeight-1; i>=0; i--)
  314. {
  315. for(int j=0; j<m_nBitMapWidth; j++)
  316. {
  317. TCbCr temp = CalCbCr(colorTable[count+2],colorTable[count+1],colorTable[count]);
  318. tempCr[i][j] = temp.Cr;
  319. tempCb[i][j] = temp.Cb;
  320. //int q = m_nBitMapWidth*(m_nBitMapHeight-1-i)+j;
  321. //CrList[index][q]= temp.Cr;
  322. //CbList[index][q]= temp.Cb;
  323. count += byteBitCount;
  324. }
  325. count += (4-(m_nBitMapWidth*byteBitCount)%4)%4;
  326. }
  327. filter(tempCr,m_nBitMapWidth,m_nBitMapHeight);
  328. filter(tempCb,m_nBitMapWidth,m_nBitMapHeight);
  329. for(i=0 ; i<m_nBitMapHeight; i++)
  330. {
  331. for(int j=0; j<m_nBitMapWidth; j++)
  332. {
  333. int q = m_nBitMapWidth*i+j;
  334. CrList[index][q]= tempCr[i][j];
  335. CbList[index][q]= tempCb[i][j];
  336. }
  337. }
  338. for(i=0;i<m_nBitMapHeight;i++)
  339. {
  340. delete tempCr[i];
  341. delete tempCb[i];
  342. }
  343. delete tempCr;
  344. delete tempCb;
  346. index++;
  347. }
  348. delete dib;
  349. FINDOVER=FindNextFile(hFind,&FindFileData);
  350. }
  351. FindClose(hFind);
  353. double avgCr = 0;
  354. double avgCb = 0;
  355. double cov00,cov01,cov10,cov11;
  356. cov00 = cov01 = cov10 = cov11 = 0.0;
  357. int totallen = 0;
  359. if(FileOK)
  360. {
  361. for(int i=0;i<filenum;i++)
  362. {
  363. totallen+=mapLength[i];
  364. for(int j=0;j<mapLength[i];j++)
  365. {
  366. avgCr += CrList[i][j];
  367. avgCb += CbList[i][j];
  368. }
  369. }
  370. avgCr /= totallen;
  371. avgCb /= totallen;
  373. for(i=0;i<filenum;i++)
  374. {
  375. for(int j=0;j<mapLength[i];j++)
  376. {
  377. cov11 += (CrList[i][j]-avgCr)*(CrList[i][j]-avgCr);
  378. cov00 += (CbList[i][j]-avgCb)*(CbList[i][j]-avgCb);
  379. cov01 += (CrList[i][j]-avgCr)*(CbList[i][j]-avgCb);
  380. }
  381. }
  382. cov00 /= totallen;
  383. cov01 /= totallen;
  384. cov10 = cov01;
  385. cov11 /= totallen;
  386. }
  388. for(int i=0;i<filenum;i++)
  389. {
  390. if(CrList[i]!=NULL) delete CrList[i];
  391. if(CbList[i]!=NULL) delete CbList[i];
  392. }
  393. delete mapLength;
  394. if(!FileOK) return 1;
  396. if((cov00*cov11-cov01*cov01) == 0) return 2;
  398. bmean =  avgCb;
  399. rmean =  avgCr;
  400. brcov[0][0] =  cov00;
  401. brcov[0][1] =  cov01;
  402. brcov[1][0] =  cov10;
  403. brcov[1][1] =  cov11;
  404. return 3;
  405. }