cvaux/src/_cvfacedetection.h - platform/external/opencv - Git at Google

 /*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.h: interface for the FaceDetection class.
 //
 //////////////////////////////////////////////////////////////////////

 #ifndef _CVFACEDETECTION_H_
 #define _CVFACEDETECTION_H_

 #define MAX_LAYERS 64

 class FaceFeature
 {
 public:
     FaceFeature(double dWeight,void * lpContour,bool bIsFeature);
     FaceFeature();
     virtual ~FaceFeature();
     inline bool isFaceFeature();
     inline void * GetContour();
     inline double GetWeight();
     inline void SetContour(void * lpContour);
     inline void SetWeight(double dWeight);
     inline void SetFeature(bool bIsFeature);
 private:
     double m_dWeight;
     void * m_lpContour;
     bool m_bIsFaceFeature;
 };//class FaceFeature

 inline void FaceFeature::SetFeature(bool bIsFeature)
 {
     m_bIsFaceFeature = bIsFeature;
 }

 inline bool FaceFeature::isFaceFeature()
 {
     return m_bIsFaceFeature;
 }//inline bool FaceFeature::isFaceFeature()

 inline void * FaceFeature::GetContour()
 {
     return m_lpContour;
 }//inline void * FaceFeature::GetContour()

 inline double FaceFeature::GetWeight()
 {
     return m_dWeight;
 }//inline long FaceFeature::GetWeight()

 inline void FaceFeature::SetContour(void * lpContour)
 {
     m_lpContour = lpContour;
 }//inline void FaceFeature::SetContour(void * lpContour)

 inline void FaceFeature::SetWeight(double  dWeight)
 {
     m_dWeight = dWeight;
 }//inline void FaceFeature::SetWeight(double * dWeight)


 class FaceTemplate
 {
 public:
     FaceTemplate(long lFeatureCount) {m_lFeaturesCount = lFeatureCount;  m_lpFeaturesList = new FaceFeature[lFeatureCount];};
     virtual ~FaceTemplate();

     inline long GetCount();
     inline FaceFeature * GetFeatures();

 protected:
     FaceFeature * m_lpFeaturesList;
 private:
     long m_lFeaturesCount;
 };//class FaceTemplate


 inline long FaceTemplate::GetCount()
 {
     return m_lFeaturesCount;
 }//inline long FaceTemplate::GetCount()


 inline FaceFeature * FaceTemplate::GetFeatures()
 {
     return m_lpFeaturesList;
 }//inline FaceFeature * FaceTemplate::GetFeatures()

 ////////////
 //class RFaceTemplate
 ///////////

 class MouthFaceTemplate:public FaceTemplate
 {
 public:
     inline MouthFaceTemplate(long lNumber,CvRect rect,double dEyeWidth,double dEyeHeight,double dDistanceBetweenEye,double dDistanceEyeAboveMouth);
     ~MouthFaceTemplate();
 };//class MouthFaceTemplate:public FaceTemplate


 inline MouthFaceTemplate::MouthFaceTemplate(long lNumber,CvRect rect,double dEyeWidth,double dEyeHeight,
                              double dDistanceBetweenEye,double dDistanceEyeAboveMouth):FaceTemplate(lNumber)
 {

     CvRect MouthRect = rect;


     CvRect LeftEyeRect = cvRect(cvRound(rect.x - (dEyeWidth + dDistanceBetweenEye/(double)2 - (double)rect.width/(double)2)),
                                 cvRound(rect.y - dDistanceEyeAboveMouth - dEyeHeight),
                                 cvRound(dEyeWidth),
                                 cvRound(dEyeHeight) );

     CvRect RightEyeRect = cvRect(cvRound(rect.x + (double)rect.width/(double)2 + dDistanceBetweenEye/(double)2),
                                  cvRound(rect.y - dDistanceEyeAboveMouth - dEyeHeight),
                                  cvRound(dEyeWidth),
                                  cvRound(dEyeHeight) );

 //  CvRect NoseRect = cvRect(cvRound(rect.x + (double)rect.width/(double)4),
 //                           cvRound(rect.y - (double)rect.width/(double)2 - (double)rect.height/(double)4),
 //                           cvRound((double)rect.width/(double)2),
 //                           cvRound((double)rect.width/(double)2) );
 /*
     CvRect CheenRect = cvRect(rect.x,rect.y + 3*rect.height/2,rect.width,rect.height);

 */

     CvRect * lpMouthRect = new CvRect();
     *lpMouthRect = MouthRect;
     m_lpFeaturesList[0].SetContour(lpMouthRect);
     m_lpFeaturesList[0].SetWeight(1);
     m_lpFeaturesList[0].SetFeature(false);


     CvRect * lpLeftEyeRect = new CvRect();
     *lpLeftEyeRect = LeftEyeRect;
     m_lpFeaturesList[1].SetContour(lpLeftEyeRect);
     m_lpFeaturesList[1].SetWeight(1);
     m_lpFeaturesList[1].SetFeature(true);

     CvRect * lpRightEyeRect = new CvRect();
     *lpRightEyeRect = RightEyeRect;
     m_lpFeaturesList[2].SetContour(lpRightEyeRect);
     m_lpFeaturesList[2].SetWeight(1);
     m_lpFeaturesList[2].SetFeature(true);


 //  CvRect * lpNoseRect = new CvRect();
 //  *lpNoseRect = NoseRect;
 //  m_lpFeaturesList[3].SetContour(lpNoseRect);
 //  m_lpFeaturesList[3].SetWeight(0);
 //  m_lpFeaturesList[3].SetFeature(true);

 /*  CvRect * lpCheenRect = new CvRect();
     *lpCheenRect = CheenRect;
     m_lpFeaturesList[4].SetContour(lpCheenRect);
     m_lpFeaturesList[4].SetWeight(1);
     m_lpFeaturesList[4].SetFeature(false);

 */

 }//constructor MouthFaceTemplate(long lNumFeatures,CvRect rect,double dEyeWidth,double dEyeHeight,double dDistanceBetweenEye,double dDistanceEyeAboveMouth);


 typedef struct CvContourRect
 {
     int     iNumber;
     int     iType;
     int     iFlags;
     CvSeq   *seqContour;
     int     iContourLength;
     CvRect  r;
     CvPoint pCenter;
     int     iColor;
 } CvContourRect;

 class Face
 {
 public:
     Face(FaceTemplate * lpFaceTemplate);
     virtual ~Face();

     inline bool isFeature(void * lpElem);

     virtual void Show(IplImage * /*Image*/){};
     virtual void ShowIdeal(IplImage* /*Image*/){};

     virtual void CreateFace(void * lpData) = 0;
     virtual bool CheckElem(void * lpCandidat,void * lpIdeal) = 0;
     virtual double GetWeight() = 0;
 protected:
     FaceFeature * m_lpIdealFace;//ideal face definition
     long m_lFaceFeaturesNumber; //total number of diferent face features
     long * m_lplFaceFeaturesCount;//number of each features fouded for this face
     FaceFeature ** m_lppFoundedFaceFeatures;//founded features of curen face
     double m_dWeight;
 };

 inline bool Face::isFeature(void * lpElem)
 {
     for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
     {
         void * lpIdeal = m_lpIdealFace[i].GetContour();

         if ( CheckElem( lpElem,lpIdeal) )
         {
             if (m_lplFaceFeaturesCount[i] < 3*MAX_LAYERS)
             {
                 double dWeight = m_lpIdealFace[i].GetWeight();
                 bool bIsFeature = m_lpIdealFace[i].isFaceFeature();


                 if (bIsFeature)
                 {
                     m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetWeight(dWeight);
                     m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetContour(lpElem);
                     m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetFeature(bIsFeature);
                     m_lplFaceFeaturesCount[i] ++;
                 }

                 m_dWeight += dWeight;

                 if (bIsFeature)
                     return true;
             }
         }

     }

     return false;
 }//inline bool RFace::isFeature(void * lpElem);


 struct FaceData
 {
     CvRect LeftEyeRect;
     CvRect RightEyeRect;
     CvRect MouthRect;
     double Error;
 };//struct FaceData

 class RFace:public Face
 {
 public:
     RFace(FaceTemplate * lpFaceTemplate);
     virtual ~RFace();
     virtual bool CheckElem(void * lpCandidat,void * lpIdeal);
     virtual void  CreateFace(void * lpData);
     virtual void Show(IplImage* Image);
     virtual void ShowIdeal(IplImage* Image);
     virtual double GetWeight();
 private:
     bool isPointInRect(CvPoint p,CvRect rect);
     bool m_bIsGenerated;
     void ResizeRect(CvRect Rect,CvRect * lpRect,long lDir,long lD);
     void CalculateError(FaceData * lpFaceData);
 };


 class ListElem
 {
 public:
     ListElem();
     ListElem(Face * pFace,ListElem * pHead);
     virtual ~ListElem();
     ListElem * m_pNext;
     ListElem * m_pPrev;
     Face * m_pFace;
 };//class ListElem

 class List
 {
 public:
     List();
     int AddElem(Face * pFace);
     virtual ~List();
     Face* GetData();
         long m_FacesCount;
 private:
     ListElem * m_pHead;
     ListElem * m_pCurElem;
 };//class List


 class FaceDetection
 {
 public:
     void FindFace(IplImage* img);
     void CreateResults(CvSeq * lpSeq);
     FaceDetection();
     virtual ~FaceDetection();
     void SetBoosting(bool bBoosting) {m_bBoosting = bBoosting;}
     bool isPostBoosting() {return m_bBoosting;}
 protected:

     IplImage* m_imgGray;
     IplImage* m_imgThresh;
     int m_iNumLayers;
     CvMemStorage* m_mstgContours;
     CvSeq* m_seqContours[MAX_LAYERS];
     CvMemStorage* m_mstgRects;
     CvSeq* m_seqRects;

     bool m_bBoosting;
     List * m_pFaceList;

 protected:
     void ResetImage();
     void FindContours(IplImage* imgGray);
     void AddContours2Rect(CvSeq*  seq, int color, int iLayer);
     void ThresholdingParam(IplImage* imgGray, int iNumLayers, int& iMinLevel, int& iMaxLevel, int& iStep);
     void FindCandidats();
     void PostBoostingFindCandidats(IplImage * FaceImage);
 };

 inline void ReallocImage(IplImage** ppImage, CvSize sz, long lChNum)
 {
     IplImage* pImage;
     if( ppImage == NULL )
         return;
     pImage = *ppImage;
     if( pImage != NULL )
     {
         if (pImage->width != sz.width || pImage->height != sz.height || pImage->nChannels != lChNum)
             cvReleaseImage( &pImage );
     }
     if( pImage == NULL )
         pImage = cvCreateImage( sz, IPL_DEPTH_8U, lChNum);
     *ppImage = pImage;
 }

 ////////////
 //class RFaceTemplate
 ///////////

 class BoostingFaceTemplate:public FaceTemplate
 {
 public:
     inline BoostingFaceTemplate(long lNumber,CvRect rect);
     ~BoostingFaceTemplate() {};
 };//class RFaceTemplate:public FaceTemplate


 inline BoostingFaceTemplate::BoostingFaceTemplate(long lNumber,CvRect rect):FaceTemplate(lNumber)
 {
     long EyeWidth = rect.width/5;
     long EyeHeight = EyeWidth;

     CvRect LeftEyeRect = cvRect(rect.x + EyeWidth,rect.y + rect.height/2 - EyeHeight,EyeWidth,EyeHeight);
     CvRect RightEyeRect = cvRect(rect.x + 3*EyeWidth,rect.y + rect.height/2 - EyeHeight,EyeWidth,EyeHeight);
     CvRect MouthRect = cvRect(rect.x + 3*EyeWidth/2,rect.y + 3*rect.height/4 - EyeHeight/2,2*EyeWidth,EyeHeight);

     CvRect * lpMouthRect = new CvRect();
     *lpMouthRect = MouthRect;
     m_lpFeaturesList[0].SetContour(lpMouthRect);
     m_lpFeaturesList[0].SetWeight(1);
     m_lpFeaturesList[0].SetFeature(true);

     CvRect * lpLeftEyeRect = new CvRect();
     *lpLeftEyeRect = LeftEyeRect;
     m_lpFeaturesList[1].SetContour(lpLeftEyeRect);
     m_lpFeaturesList[1].SetWeight(1);
     m_lpFeaturesList[1].SetFeature(true);

     CvRect * lpRightEyeRect = new CvRect();
     *lpRightEyeRect = RightEyeRect;
     m_lpFeaturesList[2].SetContour(lpRightEyeRect);
     m_lpFeaturesList[2].SetWeight(1);
     m_lpFeaturesList[2].SetFeature(true);

 }//inline BoostingFaceTemplate::BoostingFaceTemplate(long lNumber,CvRect rect):FaceTemplate(lNumber)

 #endif // !defined(AFX_FACEDETECTION_H__55865033_D8E5_4DD5_8925_34C2285BB1BE__INCLUDED_)
	/*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.h: interface for the FaceDetection class.
	//
	//////////////////////////////////////////////////////////////////////

	#ifndef _CVFACEDETECTION_H_
	#define _CVFACEDETECTION_H_

	#define MAX_LAYERS 64

	class FaceFeature
	{
	public:
	FaceFeature(double dWeight,void * lpContour,bool bIsFeature);
	FaceFeature();
	virtual ~FaceFeature();
	inline bool isFaceFeature();
	inline void * GetContour();
	inline double GetWeight();
	inline void SetContour(void * lpContour);
	inline void SetWeight(double dWeight);
	inline void SetFeature(bool bIsFeature);
	private:
	double m_dWeight;
	void * m_lpContour;
	bool m_bIsFaceFeature;
	};//class FaceFeature

	inline void FaceFeature::SetFeature(bool bIsFeature)
	{
	m_bIsFaceFeature = bIsFeature;
	}

	inline bool FaceFeature::isFaceFeature()
	{
	return m_bIsFaceFeature;
	}//inline bool FaceFeature::isFaceFeature()

	inline void * FaceFeature::GetContour()
	{
	return m_lpContour;
	}//inline void * FaceFeature::GetContour()

	inline double FaceFeature::GetWeight()
	{
	return m_dWeight;
	}//inline long FaceFeature::GetWeight()

	inline void FaceFeature::SetContour(void * lpContour)
	{
	m_lpContour = lpContour;
	}//inline void FaceFeature::SetContour(void * lpContour)

	inline void FaceFeature::SetWeight(double dWeight)
	{
	m_dWeight = dWeight;
	}//inline void FaceFeature::SetWeight(double * dWeight)



	class FaceTemplate
	{
	public:
	FaceTemplate(long lFeatureCount) {m_lFeaturesCount = lFeatureCount; m_lpFeaturesList = new FaceFeature[lFeatureCount];};
	virtual ~FaceTemplate();

	inline long GetCount();
	inline FaceFeature * GetFeatures();

	protected:
	FaceFeature * m_lpFeaturesList;
	private:
	long m_lFeaturesCount;
	};//class FaceTemplate


	inline long FaceTemplate::GetCount()
	{
	return m_lFeaturesCount;
	}//inline long FaceTemplate::GetCount()


	inline FaceFeature * FaceTemplate::GetFeatures()
	{
	return m_lpFeaturesList;
	}//inline FaceFeature * FaceTemplate::GetFeatures()

	////////////
	//class RFaceTemplate
	///////////

	class MouthFaceTemplate:public FaceTemplate
	{
	public:
	inline MouthFaceTemplate(long lNumber,CvRect rect,double dEyeWidth,double dEyeHeight,double dDistanceBetweenEye,double dDistanceEyeAboveMouth);
	~MouthFaceTemplate();
	};//class MouthFaceTemplate:public FaceTemplate


	inline MouthFaceTemplate::MouthFaceTemplate(long lNumber,CvRect rect,double dEyeWidth,double dEyeHeight,
	double dDistanceBetweenEye,double dDistanceEyeAboveMouth):FaceTemplate(lNumber)
	{

	CvRect MouthRect = rect;


	CvRect LeftEyeRect = cvRect(cvRound(rect.x - (dEyeWidth + dDistanceBetweenEye/(double)2 - (double)rect.width/(double)2)),
	cvRound(rect.y - dDistanceEyeAboveMouth - dEyeHeight),
	cvRound(dEyeWidth),
	cvRound(dEyeHeight) );

	CvRect RightEyeRect = cvRect(cvRound(rect.x + (double)rect.width/(double)2 + dDistanceBetweenEye/(double)2),
	cvRound(rect.y - dDistanceEyeAboveMouth - dEyeHeight),
	cvRound(dEyeWidth),
	cvRound(dEyeHeight) );

	// CvRect NoseRect = cvRect(cvRound(rect.x + (double)rect.width/(double)4),
	// cvRound(rect.y - (double)rect.width/(double)2 - (double)rect.height/(double)4),
	// cvRound((double)rect.width/(double)2),
	// cvRound((double)rect.width/(double)2) );
	/*
	CvRect CheenRect = cvRect(rect.x,rect.y + 3*rect.height/2,rect.width,rect.height);

	*/

	CvRect * lpMouthRect = new CvRect();
	*lpMouthRect = MouthRect;
	m_lpFeaturesList[0].SetContour(lpMouthRect);
	m_lpFeaturesList[0].SetWeight(1);
	m_lpFeaturesList[0].SetFeature(false);


	CvRect * lpLeftEyeRect = new CvRect();
	*lpLeftEyeRect = LeftEyeRect;
	m_lpFeaturesList[1].SetContour(lpLeftEyeRect);
	m_lpFeaturesList[1].SetWeight(1);
	m_lpFeaturesList[1].SetFeature(true);

	CvRect * lpRightEyeRect = new CvRect();
	*lpRightEyeRect = RightEyeRect;
	m_lpFeaturesList[2].SetContour(lpRightEyeRect);
	m_lpFeaturesList[2].SetWeight(1);
	m_lpFeaturesList[2].SetFeature(true);


	// CvRect * lpNoseRect = new CvRect();
	// *lpNoseRect = NoseRect;
	// m_lpFeaturesList[3].SetContour(lpNoseRect);
	// m_lpFeaturesList[3].SetWeight(0);
	// m_lpFeaturesList[3].SetFeature(true);

	/* CvRect * lpCheenRect = new CvRect();
	*lpCheenRect = CheenRect;
	m_lpFeaturesList[4].SetContour(lpCheenRect);
	m_lpFeaturesList[4].SetWeight(1);
	m_lpFeaturesList[4].SetFeature(false);

	*/

	}//constructor MouthFaceTemplate(long lNumFeatures,CvRect rect,double dEyeWidth,double dEyeHeight,double dDistanceBetweenEye,double dDistanceEyeAboveMouth);


	typedef struct CvContourRect
	{
	int iNumber;
	int iType;
	int iFlags;
	CvSeq *seqContour;
	int iContourLength;
	CvRect r;
	CvPoint pCenter;
	int iColor;
	} CvContourRect;

	class Face
	{
	public:
	Face(FaceTemplate * lpFaceTemplate);
	virtual ~Face();

	inline bool isFeature(void * lpElem);

	virtual void Show(IplImage * /Image/){};
	virtual void ShowIdeal(IplImage* /Image/){};

	virtual void CreateFace(void * lpData) = 0;
	virtual bool CheckElem(void * lpCandidat,void * lpIdeal) = 0;
	virtual double GetWeight() = 0;
	protected:
	FaceFeature * m_lpIdealFace;//ideal face definition
	long m_lFaceFeaturesNumber; //total number of diferent face features
	long * m_lplFaceFeaturesCount;//number of each features fouded for this face
	FaceFeature ** m_lppFoundedFaceFeatures;//founded features of curen face
	double m_dWeight;
	};

	inline bool Face::isFeature(void * lpElem)
	{
	for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
	{
	void * lpIdeal = m_lpIdealFace[i].GetContour();

	if ( CheckElem( lpElem,lpIdeal) )
	{
	if (m_lplFaceFeaturesCount[i] < 3*MAX_LAYERS)
	{
	double dWeight = m_lpIdealFace[i].GetWeight();
	bool bIsFeature = m_lpIdealFace[i].isFaceFeature();


	if (bIsFeature)
	{
	m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetWeight(dWeight);
	m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetContour(lpElem);
	m_lppFoundedFaceFeatures[i][m_lplFaceFeaturesCount[i]].SetFeature(bIsFeature);
	m_lplFaceFeaturesCount[i] ++;
	}

	m_dWeight += dWeight;

	if (bIsFeature)
	return true;
	}
	}

	}

	return false;
	}//inline bool RFace::isFeature(void * lpElem);


	struct FaceData
	{
	CvRect LeftEyeRect;
	CvRect RightEyeRect;
	CvRect MouthRect;
	double Error;
	};//struct FaceData

	class RFace:public Face
	{
	public:
	RFace(FaceTemplate * lpFaceTemplate);
	virtual ~RFace();
	virtual bool CheckElem(void * lpCandidat,void * lpIdeal);
	virtual void CreateFace(void * lpData);
	virtual void Show(IplImage* Image);
	virtual void ShowIdeal(IplImage* Image);
	virtual double GetWeight();
	private:
	bool isPointInRect(CvPoint p,CvRect rect);
	bool m_bIsGenerated;
	void ResizeRect(CvRect Rect,CvRect * lpRect,long lDir,long lD);
	void CalculateError(FaceData * lpFaceData);
	};


	class ListElem
	{
	public:
	ListElem();
	ListElem(Face * pFace,ListElem * pHead);
	virtual ~ListElem();
	ListElem * m_pNext;
	ListElem * m_pPrev;
	Face * m_pFace;
	};//class ListElem

	class List
	{
	public:
	List();
	int AddElem(Face * pFace);
	virtual ~List();
	Face* GetData();
	long m_FacesCount;
	private:
	ListElem * m_pHead;
	ListElem * m_pCurElem;
	};//class List


	class FaceDetection
	{
	public:
	void FindFace(IplImage* img);
	void CreateResults(CvSeq * lpSeq);
	FaceDetection();
	virtual ~FaceDetection();
	void SetBoosting(bool bBoosting) {m_bBoosting = bBoosting;}
	bool isPostBoosting() {return m_bBoosting;}
	protected:

	IplImage* m_imgGray;
	IplImage* m_imgThresh;
	int m_iNumLayers;
	CvMemStorage* m_mstgContours;
	CvSeq* m_seqContours[MAX_LAYERS];
	CvMemStorage* m_mstgRects;
	CvSeq* m_seqRects;

	bool m_bBoosting;
	List * m_pFaceList;

	protected:
	void ResetImage();
	void FindContours(IplImage* imgGray);
	void AddContours2Rect(CvSeq* seq, int color, int iLayer);
	void ThresholdingParam(IplImage* imgGray, int iNumLayers, int& iMinLevel, int& iMaxLevel, int& iStep);
	void FindCandidats();
	void PostBoostingFindCandidats(IplImage * FaceImage);
	};

	inline void ReallocImage(IplImage** ppImage, CvSize sz, long lChNum)
	{
	IplImage* pImage;
	if( ppImage == NULL )
	return;
	pImage = *ppImage;
	if( pImage != NULL )
	{
	if (pImage->width != sz.width \|\| pImage->height != sz.height \|\| pImage->nChannels != lChNum)
	cvReleaseImage( &pImage );
	}
	if( pImage == NULL )
	pImage = cvCreateImage( sz, IPL_DEPTH_8U, lChNum);
	*ppImage = pImage;
	}

	////////////
	//class RFaceTemplate
	///////////

	class BoostingFaceTemplate:public FaceTemplate
	{
	public:
	inline BoostingFaceTemplate(long lNumber,CvRect rect);
	~BoostingFaceTemplate() {};
	};//class RFaceTemplate:public FaceTemplate


	inline BoostingFaceTemplate::BoostingFaceTemplate(long lNumber,CvRect rect):FaceTemplate(lNumber)
	{
	long EyeWidth = rect.width/5;
	long EyeHeight = EyeWidth;

	CvRect LeftEyeRect = cvRect(rect.x + EyeWidth,rect.y + rect.height/2 - EyeHeight,EyeWidth,EyeHeight);
	CvRect RightEyeRect = cvRect(rect.x + 3*EyeWidth,rect.y + rect.height/2 - EyeHeight,EyeWidth,EyeHeight);
	CvRect MouthRect = cvRect(rect.x + 3EyeWidth/2,rect.y + 3rect.height/4 - EyeHeight/2,2*EyeWidth,EyeHeight);

	CvRect * lpMouthRect = new CvRect();
	*lpMouthRect = MouthRect;
	m_lpFeaturesList[0].SetContour(lpMouthRect);
	m_lpFeaturesList[0].SetWeight(1);
	m_lpFeaturesList[0].SetFeature(true);

	CvRect * lpLeftEyeRect = new CvRect();
	*lpLeftEyeRect = LeftEyeRect;
	m_lpFeaturesList[1].SetContour(lpLeftEyeRect);
	m_lpFeaturesList[1].SetWeight(1);
	m_lpFeaturesList[1].SetFeature(true);

	CvRect * lpRightEyeRect = new CvRect();
	*lpRightEyeRect = RightEyeRect;
	m_lpFeaturesList[2].SetContour(lpRightEyeRect);
	m_lpFeaturesList[2].SetWeight(1);
	m_lpFeaturesList[2].SetFeature(true);

	}//inline BoostingFaceTemplate::BoostingFaceTemplate(long lNumber,CvRect rect):FaceTemplate(lNumber)

	#endif // !defined(AFX_FACEDETECTION_H__55865033_D8E5_4DD5_8925_34C2285BB1BE__INCLUDED_)