--- /dev/null
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+// By downloading, copying, installing or using the software you agree to this license.
+// If you do not agree to this license, do not download, install,
+// copy or use the software.
+//
+//
+// Intel License Agreement
+// For Open Source Computer Vision Library
+//
+// Copyright (C) 2000, Intel Corporation, all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+// * Redistribution's of source code must retain the above copyright notice,
+// this list of conditions and the following disclaimer.
+//
+// * Redistribution's in binary form must reproduce the above copyright notice,
+// this list of conditions and the following disclaimer in the documentation
+// and/or other materials provided with the distribution.
+//
+// * The name of Intel Corporation may not be used to endorse or promote products
+// derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+///////////////////////////////////////////////
+//// Created by Khudyakov V.A. bober@gorodok.net
+//////////////////////////////////////////////
+// FaceDetection.cpp: implementation of the FaceDetection class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#include "_cvaux.h"
+#include "_cvfacedetection.h"
+
+
+int CV_CDECL CompareContourRect(const void* el1, const void* el2, void* userdata);
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+FaceDetection::FaceDetection()
+{
+
+ m_imgGray = NULL;
+ m_imgThresh = NULL;
+ m_mstgContours = NULL;
+ memset(m_seqContours, 0, sizeof(CvSeq*) * MAX_LAYERS);
+ m_mstgRects = NULL;
+ m_seqRects = NULL;
+ m_iNumLayers = 16;
+ assert(m_iNumLayers <= MAX_LAYERS);
+ m_pFaceList = new List();
+
+
+
+ m_bBoosting = false;
+
+}// FaceDetection()
+
+FaceDetection::~FaceDetection()
+{
+ if (m_imgGray)
+ cvReleaseImage(&m_imgGray);
+
+ if (m_imgThresh)
+ cvReleaseImage(&m_imgThresh);
+
+ if (m_mstgContours)
+ cvReleaseMemStorage(&m_mstgContours);
+
+ if (m_mstgRects)
+ cvReleaseMemStorage(&m_mstgRects);
+
+
+}// ~FaceDetection()
+
+void FaceDetection::FindContours(IplImage* imgGray)
+{
+ ReallocImage(&m_imgThresh, cvGetSize(imgGray), 1);
+ if (NULL == m_imgThresh)
+ return;
+ //
+ int iNumLayers = m_iNumLayers;
+ int iMinLevel = 0, iMaxLevel = 255, iStep = 255 / iNumLayers;
+ ThresholdingParam(imgGray, iNumLayers, iMinLevel, iMaxLevel, iStep);
+ // init
+ cvReleaseMemStorage(&m_mstgContours);
+ m_mstgContours = cvCreateMemStorage();
+ if (NULL == m_mstgContours)
+ return;
+ memset(m_seqContours, 0, sizeof(CvSeq*) * MAX_LAYERS);
+
+ cvReleaseMemStorage(&m_mstgRects);
+ m_mstgRects = cvCreateMemStorage();
+ if (NULL == m_mstgRects)
+ return;
+ m_seqRects = cvCreateSeq(0, sizeof(CvSeq), sizeof(CvContourRect), m_mstgRects);
+ if (NULL == m_seqRects)
+ return;
+ // find contours
+ for (int l = iMinLevel, i = 0; l < iMaxLevel; l += iStep, i++)
+ {
+ cvThreshold(imgGray, m_imgThresh, (double)l, (double)255, CV_THRESH_BINARY);
+ if (cvFindContours(m_imgThresh, m_mstgContours, &m_seqContours[i], sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE))
+ AddContours2Rect(m_seqContours[i], l, i);
+ }
+ // sort rects
+ cvSeqSort(m_seqRects, CompareContourRect, NULL);
+}// void FaceDetection::FindContours(IplImage* imgGray)
+
+#define GIST_STEP 10
+#define GIST_NUM (256 / GIST_STEP)
+#define GIST_MIN 32
+
+void FaceDetection::ThresholdingParam(IplImage *imgGray, int iNumLayers, int &iMinLevel, int &iMaxLevel, int &iStep)
+{
+ assert(imgGray != NULL);
+ assert(imgGray->nChannels == 1);
+ int i, j;
+ // create gistogramm
+ uchar* buffImg = (uchar*)imgGray->imageData;
+ int gistImg[GIST_NUM + 1] = {0};
+
+ for (j = 0; j < imgGray->height; j ++)
+ {
+ for (i = 0; i < imgGray->width; i ++)
+ {
+ int ind = buffImg[i] / GIST_STEP;
+ gistImg[ind] ++;
+ }
+ buffImg += imgGray->widthStep;
+ }
+ // params
+
+ for (i = 0; i <= GIST_NUM; i ++)
+ {
+ if (gistImg[i] >= GIST_MIN)
+ break;
+ }
+
+ iMinLevel = i * GIST_STEP;
+
+ for (i = GIST_NUM; i >= 0; i --)
+ {
+ if (gistImg[i] >= GIST_MIN)
+ break;
+ }
+
+ iMaxLevel = i * GIST_STEP;
+
+ int dLevels = iMaxLevel - iMinLevel;
+ if (dLevels <= 0)
+ {
+ iMinLevel = 0;
+ iMaxLevel = 255;
+ }
+ else if (dLevels <= iNumLayers)
+ {
+ iMinLevel = iMaxLevel - iNumLayers;
+ if (iMinLevel < 0)
+ {
+ iMinLevel = 0;
+ iMaxLevel = iNumLayers;
+ }
+ }
+ iStep = (iMaxLevel - iMinLevel) / iNumLayers;
+
+}// void FaceDetection::ThresholdingParam(IplImage *imgGray, int iNumLayers, int &iMinLevel, int &iMaxLevel, int &iStep)
+
+#ifndef MAX_ERROR
+#define MAX_ERROR 0xFFFFFFFF
+#endif //MAX_ERROR
+
+
+void FaceDetection::CreateResults(CvSeq * lpSeq)
+{
+
+ Face * tmp;
+
+ double Max = 0;
+ double CurStat = 0;
+
+ FaceData tmpData;
+ if (m_bBoosting)
+ {
+ tmp = m_pFaceList->GetData();
+ tmp->CreateFace(&tmpData);
+
+ CvFace tmpFace;
+ tmpFace.MouthRect = tmpData.MouthRect;
+ tmpFace.LeftEyeRect = tmpData.LeftEyeRect;
+ tmpFace.RightEyeRect = tmpData.RightEyeRect;
+
+ cvSeqPush(lpSeq,&tmpFace);
+
+ }else
+ {
+ while ( (tmp = m_pFaceList->GetData()) != 0 )
+ {
+ CurStat = tmp->GetWeight();
+ if (CurStat > Max)
+ Max = CurStat;
+ }
+
+ while ( (tmp = m_pFaceList->GetData()) != 0 )
+ {
+ tmp->CreateFace(&tmpData);
+ CurStat = tmp->GetWeight();
+
+ if (CurStat == Max)
+ {
+ CvFace tmpFace;
+ tmpFace.MouthRect = tmpData.MouthRect;
+ tmpFace.LeftEyeRect = tmpData.LeftEyeRect;
+ tmpFace.RightEyeRect = tmpData.RightEyeRect;
+ cvSeqPush(lpSeq,&tmpFace);
+
+
+ }
+ }
+ }
+}// void FaceDetection::DrawResult(IplImage* img)
+
+void FaceDetection::ResetImage()
+{
+ delete m_pFaceList;
+ m_pFaceList = new List();
+
+}//FaceDetection::ResetImage
+
+void FaceDetection::AddContours2Rect(CvSeq *seq, int color, int iLayer)
+{
+ assert(m_mstgRects != NULL);
+ assert(m_seqRects != NULL);
+
+ CvContourRect cr;
+ for (CvSeq* external = seq; external; external = external->h_next)
+ {
+ cr.r = cvContourBoundingRect(external, 1 );
+ cr.pCenter.x = cr.r.x + cr.r.width / 2;
+ cr.pCenter.y = cr.r.y + cr.r.height / 2;
+ cr.iNumber = iLayer;
+ cr.iType = 6;
+ cr.iFlags = 0;
+ cr.seqContour = external;
+ cr.iContourLength = external->total;
+ cr.iColor = color;
+ cvSeqPush(m_seqRects, &cr);
+ for (CvSeq* internal = external->v_next; internal; internal = internal->h_next)
+ {
+ cr.r = cvContourBoundingRect(internal, 0);
+ cr.pCenter.x = cr.r.x + cr.r.width / 2;
+ cr.pCenter.y = cr.r.y + cr.r.height / 2;
+ cr.iNumber = iLayer;
+ cr.iType = 12;
+ cr.iFlags = 0;
+ cr.seqContour = internal;
+ cr.iContourLength = internal->total;
+ cr.iColor = color;
+ cvSeqPush(m_seqRects, &cr);
+ }
+ }
+}// void FaceDetection::AddContours2Rect(CvSeq *seq, int color, int iLayer)
+
+int CV_CDECL CompareContourRect(const void* el1, const void* el2, void* /*userdata*/)
+{
+ return (((CvContourRect*)el1)->pCenter.y - ((CvContourRect*)el2)->pCenter.y);
+}// int CV_CDECL CompareContourRect(const void* el1, const void* el2, void* userdata)
+
+void FaceDetection::FindFace(IplImage *img)
+{
+ // find all contours
+ FindContours(img);
+ //
+ ResetImage();
+
+ if (m_bBoosting)
+ PostBoostingFindCandidats(img);
+ else
+ FindCandidats();
+
+}// void FaceDetection::FindFace(IplImage *img)
+
+
+void FaceDetection::FindCandidats()
+{
+ bool bFound1 = false;
+ MouthFaceTemplate * lpFaceTemplate1;
+ RFace * lpFace1;
+ bool bInvalidRect1 = false;
+ CvRect * lpRect1 = NULL;
+
+ for (int i = 0; i < m_seqRects->total; i++)
+ {
+ CvContourRect* pRect = (CvContourRect*)cvGetSeqElem(m_seqRects, i);
+ CvRect rect = pRect->r;
+ if (rect.width >= 2*rect.height)
+ {
+
+ lpFaceTemplate1 = new MouthFaceTemplate(3,rect,3*(double)rect.width/(double)4,
+ 3*(double)rect.width/(double)4,
+ (double)rect.width/(double)2,
+ (double)rect.width/(double)2);
+
+
+ lpFace1 = new RFace(lpFaceTemplate1);
+
+ for (int j = 0; j < m_seqRects->total; j++)
+ {
+ CvContourRect* pRect = (CvContourRect*)cvGetSeqElem(m_seqRects, j);
+
+ if ( !bInvalidRect1 )
+ {
+ lpRect1 = NULL;
+ lpRect1 = new CvRect();
+ *lpRect1 = pRect->r;
+ }else
+ {
+ delete lpRect1;
+ lpRect1 = new CvRect();
+ *lpRect1 = pRect->r;
+ }
+
+
+ if ( lpFace1->isFeature(lpRect1) )
+ {
+ bFound1 = true;
+ bInvalidRect1 = false;
+ }else
+ bInvalidRect1 = true;
+
+
+ }
+
+
+ if (bFound1)
+ {
+ m_pFaceList->AddElem(lpFace1);
+ bFound1 = false;
+ lpFace1 = NULL;
+ }else
+ {
+ delete lpFace1;
+ lpFace1 = NULL;
+ }
+
+
+ delete lpFaceTemplate1;
+ }
+
+ }
+
+}
+
+
+void FaceDetection::PostBoostingFindCandidats(IplImage * FaceImage)
+{
+ BoostingFaceTemplate * lpFaceTemplate1;
+ RFace * lpFace1;
+ bool bInvalidRect1 = false;
+ CvRect * lpRect1 = NULL;
+
+ if ( ( !FaceImage->roi ) )
+ lpFaceTemplate1 = new BoostingFaceTemplate(3,cvRect(0,0,FaceImage->width,FaceImage->height));
+ else
+ lpFaceTemplate1 = new BoostingFaceTemplate(3,cvRect(FaceImage->roi->xOffset,FaceImage->roi->yOffset,
+ FaceImage->roi->width,FaceImage->roi->height));
+
+ lpFace1 = new RFace(lpFaceTemplate1);
+
+ for (int i = 0; i < m_seqRects->total; i++)
+ {
+ CvContourRect* pRect = (CvContourRect*)cvGetSeqElem(m_seqRects, i);
+
+ if ( !bInvalidRect1 )
+ {
+ lpRect1 = NULL;
+ lpRect1 = new CvRect();
+ *lpRect1 = pRect->r;
+ }else
+ {
+ delete lpRect1;
+ lpRect1 = new CvRect();
+ *lpRect1 = pRect->r;
+ }
+
+
+ if ( lpFace1->isFeature(lpRect1) )
+ {
+ //bFound1 = true;
+ bInvalidRect1 = false;
+ }else
+ bInvalidRect1 = true;
+
+
+ }
+
+ m_pFaceList->AddElem(lpFace1);
+
+ delete lpFaceTemplate1;
+
+}//void FaceDetection::PostBoostingFindCandidats(IplImage * FaceImage)
+
+/////////////////////////
+//class Face
+
+
+
+//////
+//List Class
+/////
+ListElem::ListElem()
+{
+ m_pNext = this;
+ m_pPrev = this;
+ m_pFace = NULL;
+}///ListElem::ListElem()
+
+ListElem::ListElem(Face * pFace,ListElem * pHead)
+{
+ m_pNext = pHead;
+ m_pPrev = pHead->m_pPrev;
+ pHead->m_pPrev->m_pNext = this;
+ pHead->m_pPrev = this;
+
+ m_pFace = pFace;
+}//ListElem::ListElem(Face * pFace)
+
+
+
+ListElem::~ListElem()
+{
+ delete m_pFace;
+ m_pNext->m_pPrev = m_pPrev;
+ m_pPrev->m_pNext = m_pNext;
+
+}//ListElem::~ListElem()
+
+List::List()
+{
+ m_pHead = new ListElem();
+ m_FacesCount = 0;
+ m_pCurElem = m_pHead;
+}//List::List()
+
+List::~List()
+{
+ void * tmp;
+ while((tmp = m_pHead->m_pNext->m_pFace) != 0)
+ delete m_pHead->m_pNext;
+
+ delete m_pHead;
+
+}//List::~List()
+
+
+int List::AddElem(Face * pFace)
+{
+ new ListElem(pFace,m_pHead);
+ return m_FacesCount++;
+}//List::AddElem(Face * pFace)
+
+Face * List::GetData()
+{
+ m_pCurElem = m_pCurElem->m_pNext;
+ return m_pCurElem->m_pFace;
+}//Face * List::GetData()
+
+
projects / opencv / blobdiff