355 lines
11 KiB
C++
355 lines
11 KiB
C++
/*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
|
|
//////////////////////////////////////////////
|
|
|
|
#include "precomp.hpp"
|
|
#include "_facedetection.h"
|
|
|
|
Face::Face(FaceTemplate * lpFaceTemplate)
|
|
{
|
|
//init number of face elements;
|
|
m_lFaceFeaturesNumber = lpFaceTemplate->GetCount();
|
|
|
|
//init array of numbers of foundet face elements of each type
|
|
m_lplFaceFeaturesCount = new long[m_lFaceFeaturesNumber];
|
|
memset(m_lplFaceFeaturesCount,0,m_lFaceFeaturesNumber*sizeof(long));
|
|
|
|
//init array of ideal face features
|
|
m_lpIdealFace = new FaceFeature[m_lFaceFeaturesNumber];
|
|
|
|
//init array of founded features
|
|
m_lppFoundedFaceFeatures = new FaceFeature*[m_lFaceFeaturesNumber];
|
|
|
|
for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
|
|
{
|
|
m_lppFoundedFaceFeatures[i] = (new FaceFeature[3*MAX_LAYERS]);
|
|
}
|
|
|
|
//set start weight 0
|
|
m_dWeight = 0;
|
|
|
|
}//Face::Face(FaceTemplate * lpFaceTemplate)
|
|
|
|
Face::~Face()
|
|
{
|
|
for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
|
|
{
|
|
delete [] (m_lppFoundedFaceFeatures[i]);
|
|
}
|
|
delete [] m_lppFoundedFaceFeatures;
|
|
|
|
|
|
delete [] m_lplFaceFeaturesCount;
|
|
delete [] m_lpIdealFace;
|
|
|
|
}//Face::~Face()
|
|
|
|
|
|
#define UP_SCALE 1
|
|
#define DOWN_SCALE 2
|
|
|
|
|
|
////////////
|
|
//class RFace(rect based face)
|
|
////////////
|
|
RFace::RFace(FaceTemplate * lpFaceTemplate):Face(lpFaceTemplate)
|
|
{
|
|
//init ideal face
|
|
FaceFeature * lpTmp = lpFaceTemplate->GetFeatures();
|
|
|
|
for (int j = 0;j < m_lFaceFeaturesNumber;j ++)
|
|
{
|
|
CvRect * lpTmpRect = NULL;
|
|
lpTmpRect = new CvRect;
|
|
*lpTmpRect = *(CvRect*)lpTmp[j].GetContour();
|
|
|
|
m_lpIdealFace[j].SetContour( lpTmpRect );
|
|
m_lpIdealFace[j].SetWeight( lpTmp[j].GetWeight() );
|
|
m_lpIdealFace[j].SetFeature( lpTmp[j].isFaceFeature() );
|
|
|
|
}
|
|
|
|
m_bIsGenerated = false;
|
|
}//RFace::RFace(FaceTemplate * lpFaceTemplate)
|
|
|
|
RFace::~RFace()
|
|
{
|
|
|
|
}//RFace::~RFace()
|
|
|
|
inline bool RFace::isPointInRect(CvPoint p,CvRect rect)
|
|
{
|
|
if ( (p.x >= rect.x) && (p.y >= rect.y) && (p.x <= rect.x + rect.width) && (p.y <= rect.y + rect.height) )
|
|
return true;
|
|
|
|
return false;
|
|
}//inline bool RFace::isPointInRect(CvPoint,CvRect rect)
|
|
|
|
double RFace::GetWeight()
|
|
{
|
|
return m_dWeight;
|
|
}//double RFace::GetWeight()
|
|
|
|
|
|
bool RFace::CheckElem(void * lpCandidat,void * lpIdeal)
|
|
{
|
|
|
|
CvRect IdealRect = *(CvRect*)lpIdeal;
|
|
CvRect Rect = *(CvRect*)lpCandidat;
|
|
|
|
if (Rect.height > Rect.width)
|
|
return false;
|
|
|
|
long SizeIdeal = IdealRect.width*IdealRect.height;
|
|
long Size = Rect.width*Rect.height;
|
|
|
|
if ( (Size > SizeIdeal) || ( Size < (SizeIdeal/5) ) )
|
|
return false;
|
|
|
|
// CvRect UpRect;
|
|
// CvRect DownRect;
|
|
// ResizeRect(IdealRect,&UpRect,UP_SCALE,7);
|
|
// ResizeRect(IdealRect,&DownRect,DOWN_SCALE,7);
|
|
|
|
long x = Rect.x + cvRound(Rect.width/2);
|
|
long y = Rect.y + cvRound(Rect.height/2);
|
|
|
|
if ( isPointInRect(cvPoint(x,y),IdealRect) )
|
|
return true;
|
|
|
|
// if ( isPointInRect(cvPoint(Rect.x,Rect.y),UpRect) &&
|
|
// isPointInRect(cvPoint(Rect.x + Rect.width,Rect.y + Rect.height),UpRect ) &&
|
|
// isPointInRect(cvPoint(DownRect.x,DownRect.y),Rect) &&
|
|
// isPointInRect(cvPoint(DownRect.x + DownRect.width,DownRect.y + DownRect.height),Rect) )
|
|
// return true;
|
|
|
|
|
|
// if ( isPointInRect(cvPoint(Rect.x,Rect.y),IdealRect) &&
|
|
// isPointInRect(cvPoint(Rect.x + Rect.width,Rect.y + Rect.height),IdealRect ) )
|
|
// return true;
|
|
|
|
return false;
|
|
}//inline bool RFace::CheckElem(CvRect rect)
|
|
|
|
|
|
|
|
void RFace::CalculateError(FaceData * lpFaceData)
|
|
{
|
|
CvRect LeftEyeRect = lpFaceData->LeftEyeRect;
|
|
CvRect RightEyeRect = lpFaceData->RightEyeRect;
|
|
CvRect MouthRect = lpFaceData->MouthRect;
|
|
|
|
long LeftSquare = LeftEyeRect.width*LeftEyeRect.height;
|
|
long RightSquare = RightEyeRect.width*RightEyeRect.height;
|
|
|
|
long dy = LeftEyeRect.y - RightEyeRect.y;
|
|
|
|
long dx1 = LeftEyeRect.x + LeftEyeRect.width/2 - MouthRect.x;
|
|
long dx2 = RightEyeRect.x + RightEyeRect.width/2 - MouthRect.x - MouthRect.width;
|
|
|
|
|
|
lpFaceData->Error = (double)(LeftSquare - RightSquare)*(double)(LeftSquare - RightSquare)/((double)(LeftSquare + RightSquare)*(LeftSquare + RightSquare)) +
|
|
(double)(dy*dy)/((double)(LeftEyeRect.height + RightEyeRect.height)*(LeftEyeRect.height + RightEyeRect.height)) +
|
|
(double)(dx1*dx1)/((double)MouthRect.width*MouthRect.width) +
|
|
(double)(dx2*dx2)/((double)MouthRect.width*MouthRect.width);
|
|
|
|
}//void RFace::CalculateError(FaceData * lpFaceData)
|
|
|
|
#define MAX_ERROR 0xFFFFFFFF
|
|
|
|
void RFace::CreateFace(void * lpData)
|
|
{
|
|
FaceData Data;
|
|
|
|
double Error = MAX_ERROR;
|
|
double CurError = MAX_ERROR;
|
|
|
|
FaceData * lpFaceData = (FaceData*)lpData;
|
|
|
|
int im = 0;//mouth was find
|
|
int jl = 0;//left eye was find
|
|
int kr = 0;//right eye was find
|
|
|
|
long MouthNumber = 0;
|
|
long LeftEyeNumber = 0;
|
|
long RightEyeNumber = 0;
|
|
|
|
for (int i = 0;i < m_lplFaceFeaturesCount[0] + 1;i ++)
|
|
{
|
|
|
|
if ( !m_lplFaceFeaturesCount[0] )
|
|
Data.MouthRect = *(CvRect*)m_lpIdealFace[0].GetContour();
|
|
else
|
|
{
|
|
if ( i != m_lplFaceFeaturesCount[0] )
|
|
Data.MouthRect = *(CvRect*)m_lppFoundedFaceFeatures[0][i].GetContour();
|
|
im = 1;
|
|
}
|
|
|
|
|
|
for (int j = 0;j < m_lplFaceFeaturesCount[1] + 1;j ++)
|
|
{
|
|
|
|
if ( !m_lplFaceFeaturesCount[1] )
|
|
Data.LeftEyeRect = *(CvRect*)m_lpIdealFace[1].GetContour();
|
|
else
|
|
{
|
|
if (j != m_lplFaceFeaturesCount[1] )
|
|
Data.LeftEyeRect = *(CvRect*)m_lppFoundedFaceFeatures[1][j].GetContour();
|
|
jl = 1;
|
|
}
|
|
|
|
|
|
for (int k = 0;k < m_lplFaceFeaturesCount[2] + 1;k ++)
|
|
{
|
|
|
|
if ( !m_lplFaceFeaturesCount[2] )
|
|
Data.RightEyeRect = *(CvRect*)m_lpIdealFace[2].GetContour();
|
|
else
|
|
{
|
|
if (k != m_lplFaceFeaturesCount[2] )
|
|
Data.RightEyeRect = *(CvRect*)m_lppFoundedFaceFeatures[2][k].GetContour();
|
|
kr = 1;
|
|
}
|
|
|
|
CalculateError(&Data);
|
|
|
|
if ( (im + jl + kr) )
|
|
{
|
|
Error = Data.Error/(im + jl + kr);
|
|
}else
|
|
Error = MAX_ERROR;
|
|
|
|
if (CurError > Error)
|
|
{
|
|
CurError = Error;
|
|
MouthNumber = i;
|
|
LeftEyeNumber = j;
|
|
RightEyeNumber = k;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( m_lplFaceFeaturesCount[0] )
|
|
lpFaceData->MouthRect = *(CvRect*)m_lppFoundedFaceFeatures[0][MouthNumber].GetContour();
|
|
else
|
|
lpFaceData->MouthRect = *(CvRect*)m_lpIdealFace[0].GetContour();
|
|
|
|
if ( m_lplFaceFeaturesCount[1] )
|
|
lpFaceData->LeftEyeRect = *(CvRect*)m_lppFoundedFaceFeatures[1][LeftEyeNumber].GetContour();
|
|
else
|
|
lpFaceData->LeftEyeRect = *(CvRect*)m_lpIdealFace[1].GetContour();
|
|
|
|
if ( m_lplFaceFeaturesCount[2] )
|
|
lpFaceData->RightEyeRect = *(CvRect*)m_lppFoundedFaceFeatures[2][RightEyeNumber].GetContour();
|
|
else
|
|
lpFaceData->RightEyeRect = *(CvRect*)m_lpIdealFace[2].GetContour();
|
|
|
|
lpFaceData->Error = CurError;
|
|
|
|
}//void * RFace::CreateFace()
|
|
|
|
void RFace::Show(IplImage * Image)
|
|
{
|
|
for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
|
|
{
|
|
if (m_lplFaceFeaturesCount[i])
|
|
{
|
|
for (int j = 0;j < m_lplFaceFeaturesCount[i];j ++)
|
|
{
|
|
CvRect rect = *(CvRect*)m_lppFoundedFaceFeatures[i][j].GetContour();
|
|
CvPoint p1 = cvPoint(rect.x,rect.y);
|
|
CvPoint p2 = cvPoint(rect.x + rect.width,rect.y + rect.height);
|
|
cvRectangle(Image,p1,p2,CV_RGB(255,0,0),1);
|
|
}
|
|
}
|
|
}
|
|
|
|
}//void RFace::Show(IplImage * Image)
|
|
|
|
void RFace::ShowIdeal(IplImage* Image)
|
|
{
|
|
for (int i = 0;i < m_lFaceFeaturesNumber;i ++)
|
|
{
|
|
CvRect Rect = *(CvRect*)m_lpIdealFace[i].GetContour();
|
|
CvPoint p1 = cvPoint(Rect.x,Rect.y);
|
|
CvPoint p2 = cvPoint(Rect.x + Rect.width,Rect.y + Rect.height);
|
|
cvRectangle(Image,p1,p2,CV_RGB(0,0,255),1);
|
|
}
|
|
}//void RFace::ShowIdeal(IplImage* Image)
|
|
|
|
|
|
inline void RFace::ResizeRect(CvRect Rect,CvRect * lpRect,long lDir,long lD)
|
|
{
|
|
if (lDir == UP_SCALE)
|
|
{
|
|
lpRect->x = Rect.x - lD;
|
|
lpRect->y = Rect.y - lD;
|
|
lpRect->width = Rect.width + 2*lD;
|
|
lpRect->height = Rect.height + 2*lD;
|
|
}
|
|
if (lDir == DOWN_SCALE)
|
|
{
|
|
lpRect->x = Rect.x + lD;
|
|
lpRect->y = Rect.y + lD;
|
|
if (Rect.width - 2*lD >= 0)
|
|
{
|
|
lpRect->width = Rect.width - 2*lD;
|
|
}else
|
|
lpRect->width = 0;
|
|
|
|
if (Rect.height - 2*lD >= 0)
|
|
{
|
|
lpRect->height = Rect.height - 2*lD;
|
|
}else
|
|
lpRect->height = 0;
|
|
}
|
|
|
|
}// inline void RFace::ResizeRect(CvRect * lpRect,long lDir,long lD)
|
|
|