CvFaceDetect.cpp

Go to the documentation of this file.

/*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
//                                   
//                    Contributors License Agreement
//
// Copyright (C) 2006, Zecchini Fabio, all rights reserved.
//
// Copyright (C) 2006, Cora' Massimo, all rights reserved. Code adapting and integration into Omnimeeting.
//
// 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*/

//
// Mouth and eye detection based on the paper:
//                                                            
// P. Campadelli, F. Cusmai, and R. Lanzarotti, A color-based method for face detection
// http://homes.dsi.unimi.it/%7Ecampadel/Articoli/IST2003.pdf
//

#include "CvFaceDetect.hh"

CvFaceDetect::CvFaceDetect(int min, int max)
{       
        this->started = false;
        this->vrfilter = new CvVrFilter(min, max);
        //this->storage = 0;

        this->storage = cvCreateMemStorage(0);

}

CvFaceDetect::~CvFaceDetect()
{       
        cvReleaseImage( &this->skin_locus_map );
#ifdef DETECT
        cvReleaseImage( &this->ycc );
        cvReleaseImage( &this->y );
        cvReleaseImage( &this->mouth_map );
        cvReleaseImage( &this->mouth_map_bin );
        cvReleaseImage( &this->eyes_map );
        cvReleaseImage( &this->eyes_map_bin );
#endif

        cvReleaseMemStorage( &this->storage );
}

void
CvFaceDetect::cvFaceDetect(IplImage * image, int DRAW_TYPE)
{       
        if(started)
        {

                cvReleaseImage( &this->skin_locus_map );

#ifdef DETECT
                cvReleaseImage( &this->ycc );
                cvReleaseImage( &this->y );
                cvReleaseImage( &this->mouth_map );
                cvReleaseImage( &this->mouth_map_bin );
                cvReleaseImage( &this->eyes_map );
                cvReleaseImage( &this->eyes_map_bin );
#endif
                cvClearMemStorage(this->storage);
                //cvRelease( (void **)&this->faces );
                //cvReleaseMemStorage( &this->storage );

        }
        
        //this->storage = cvCreateMemStorage(0);

        this->started = true;
        this->size = cvGetSize(image);
        this->source = image ;

        this->faces = cvCreateSeq( 0,                           // sequence of generic elements 
                                                          sizeof(CvSeq),        // header size - no extra fields 
                                                          sizeof(Cvface),       // element size 
                                                          storage                       // the container storage 
                                                          );
        
    this->skin_locus_map = this->vrfilter->cvVrFilter(image, this->storage, this->faces);


#ifdef DETECT

        //YCrCb skin locus converted image
        ycc = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 3  );
        cvCvtColor( this->skin_locus_map , ycc, CV_BGR2YCrCb );
        
        
        /*
        icvMouthMap(ycc);
        icvMouthMask();
        icvMouthDetect();
        

        icvEyesMap(ycc);
        icvEyesMask();
        icvEyesDetect();
        /*/

        icvMouthEyesMap(ycc);
        icvMouthEyesMask();
        icvMouthEyesDetect();
        


        if (DRAW_TYPE > 0)
        {       
                //printf("face_detect.cpp faces->total : %d \n", this->faces->total);   
                
                for (int i = 0; i < this->faces->total ; i++)
                {       
                        
                        Cvface *face;

                        face = (Cvface *)cvGetSeqElem( this->faces, i );

                        if (DRAW_TYPE == DRAW_BOX_ONLY || DRAW_TYPE == DRAW_ALL)
                        {
                                //draw a box
                                int n = 4;
                                CvPoint2D32f _box_point[4];
                                CvPoint box_point[4], *bpp = box_point;

                                cvBoxPoints( face->skin_face.skin_box , _box_point );
                
                                for (int i=0; i<n ; i++)
                                {
                                        box_point[i] = cvPoint(cvRound(_box_point[i].x),cvRound(_box_point[i].y));
                                }
                                
                                if(face->track)
                                        cvPolyLine( image, &bpp , &n, 1, 1, CV_RGB(255,0,255), 2, CV_AA , 0 );
                                /*else
                                        cvPolyLine( image, &bpp , &n, 1, 1, CV_RGB(255,0,0), 2, CV_AA , 0 );*/
                                
                        }

                        if (DRAW_TYPE == DRAW_EYES || DRAW_TYPE == DRAW_ALL)
                        {       
                                for (int i= 0 ; i < 2; i++)
                                {       
                                        if ( &face->eyes_box[i] != 0)
                                        {
                                                
                                                //printf("occhio x%d :%d ",i ,(int) face->eyes_box[i].center.x  );

                                                cvEllipse(      image, 
                                                                        cvPoint((int) face->eyes_box[i].center.x , 
                                                                                        (int) face->eyes_box[i].center.y) , 
                                                                        cvSize( (int) face->eyes_box[i].size.width , 
                                                                                        (int) face->eyes_box[i].size.height), 
                                                                        (double)(360 * face->eyes_box[i].angle)/ (2 * CV_PI) - 90, 
                                                                        0, 360, 
                                                                        cvScalar( 0, 255, 0 ),
                                                                        1, CV_AA );
                                        }
                                }
                        }

                        if (DRAW_TYPE == DRAW_MOUTH || DRAW_TYPE == DRAW_ALL)
                        {       
                                if ( &face->mouth_box != 0)
                                {
                                        //printf("bocca angolo : %d \n", (int)((360 * face->mouth_box.angle)/ (2 * CV_PI) - 90));

                                        cvEllipse(      image, 
                                                                cvPoint((int) face->mouth_box.center.x , 
                                                                                (int) face->mouth_box.center.y) , 
                                                                cvSize( (int) face->mouth_box.size.width , 
                                                                                (int) face->mouth_box.size.height), 
                                                                (double)(360 * face->mouth_box.angle)/ (2 * CV_PI) - 90, 
                                                                0, 360, 
                                                                cvScalar( 0, 255, 255 ),
                                                                1, CV_AA );

                                        
                                }
        
                        }

                        if (DRAW_TYPE == DRAW_ALL)
                        {       
                                float angle = 0;

                                if (&face->eyes_box[0] != 0 && &face->eyes_box[1] != 0)
                                {
                                        cvLine( image, 
                                                        cvPoint((int) face->eyes_box[0].center.x , 
                                                                        (int) face->eyes_box[0].center.y),  
                                                        cvPoint((int) face->eyes_box[1].center.x , 
                                                                        (int) face->eyes_box[1].center.y),  
                                                        cvScalar( 231, 169, 0 ),
                                                        2, CV_AA, 0 );
                                        
                                        angle = (float)(atan2((face->eyes_box[1].center.y - face->eyes_box[0].center.y),
                                                                  (face->eyes_box[1].center.x - face->eyes_box[0].center.x)) 
                                                        + CV_PI/2);
                                        
                                        //printf("angle : %f \n", angle);

                                }
                                
                                if (&face->mouth_box != 0 )
                                {       
                                        int mult = (int)(MAX(face->skin_face.skin_box.size.width,
                                                                                 face->skin_face.skin_box.size.height ) /2);
                                        
                                        cvLine( image, 
                                                        cvPoint((int) ((face->mouth_box.center.x) - mult *
                                                                                cos(angle)), 
                                                                                (int) ((face->mouth_box.center.y) - mult *
                                                                                sin(angle))),  
                                                        cvPoint((int) ((face->mouth_box.center.x) + mult *
                                                                                cos(angle)), 
                                                                                (int) ((face->mouth_box.center.y) + mult *
                                                                                sin(angle))),  
                                                        cvScalar( 186, 114, 8 ),
                                                        2, CV_AA, 0 );
                                }

                        }

                }
        }
#endif

}

void
CvFaceDetect::icvMouthMap(IplImage * image)
{
        this->mouth_map = cvCreateImage(this->size, IPL_DEPTH_32F, 1  );

        int _cr, _cb ;
        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cr = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +1);
                        _cb = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +2);
                        
                        CV_IMAGE_ELEM( this->mouth_map, float, j, i )  = 
                                                                        (float) ( _cr * (255 - (_cr - _cb) ) * _cr ) ;
                                                                                
                }
        }
}

void  
CvFaceDetect::icvMouthMask()
{       
        this->mouth_map_bin = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        IplImage * _mouth_map_bin;
        _mouth_map_bin = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        // find the max value
        double map_min = 0 , map_max = 0 , map_range;
        cvMinMaxLoc( this->mouth_map, &map_min , &map_max );
        map_range = map_max - ( map_max * 0.06 );

        cvThreshold( this->mouth_map, _mouth_map_bin, map_range, 255, CV_THRESH_BINARY );
        
        /*
        cvNamedWindow("mouth_bin", 1);
        cvShowImage("mouth_bin", _mouth_map_bin);
        
        cvWaitKey(0);
        */
        
        IplConvKernel* kernelOp = cvCreateStructuringElementEx( 4, 3, 1, 1, CV_SHAPE_CROSS, NULL );
        cvDilate( _mouth_map_bin , this->mouth_map_bin, kernelOp,  1 );

        /*
        cvNamedWindow("mouth", 1);
        cvShowImage("mouth", this->mouth_map_bin);

        cvWaitKey(0);
        */
        
#ifdef MOUTH
        cvNamedWindow("mouth", 1);
        cvShowImage("mouth", this->mouth_map_bin);
#endif
        
        cvReleaseImage( &_mouth_map_bin );
}

void  
CvFaceDetect::icvMouthDetect()
{
        
        int mouth = 0 ;
        int x , y, width, height, count;
        double angle ;
        
        Cvface *face;

        for (int i = 0; i < faces->total; i++)
        {       
                //printf("width: %d , height: %d\n", this->skin_rect[i].width, this->skin_rect[i].height);
                
                /*
                // draw a rectangle
                CvPoint left_bottom = { this->skin_rect[i].x, this->skin_rect[i].y };
                CvPoint right_top   = { this->skin_rect[i].x + this->skin_rect[i].width, 
                                                            this->skin_rect[i].y + this->skin_rect[i].height };
                
                cvRectangle( this->src, left_bottom, right_top, CV_RGB(255,0,0), 2, 4, 0 );
                //*/
                
                /*
                //draw a box
                int n = 4;
                CvPoint2D32f _box_point[4];
                CvPoint box_point[4], *bpp = box_point;

                cvBoxPoints( this->skin_box[i], _box_point );
                
                for (int i=0; i<n ; i++)
                {
                        box_point[i] = cvPoint(cvRound(_box_point[i].x),cvRound(_box_point[i].y));
                }

                cvPolyLine( this->src, &bpp , &n, 1, 1, CV_RGB(255,0,0), 2, 8, 0 );
                */
                /*
                cvNamedWindow("mouth_", 1);
                cvShowImage("mouth_", this->src);
                cvWaitKey(0);
                */
                //cvSetImageROI(this->mouth_map_bin, this->skin_rect[i]);

                face = (Cvface *)cvGetSeqElem( this->faces, i);

                cvSetImageROI(this->mouth_map_bin, face->skin_face.skin_rect );

                x = y = height = width = count = 0;
                angle = 0;
                                        
                mouth = cvFindContours( this->mouth_map_bin , this->storage, &(this->contour) ,  
                                                sizeof(CvContour), CV_RETR_EXTERNAL ,
                                                CV_CHAIN_APPROX_SIMPLE ,
                                                cvPoint( face->skin_face.skin_rect.x,face->skin_face.skin_rect.y )  );
                
                //if no mouth is detect jump..
                if (mouth == 0) 
                {
                        continue;
                }
                //printf("mouth : %d \n" , mouth);

                for(CvSeq* temp_contour = this->contour; temp_contour != 0; temp_contour = temp_contour->h_next )
                {                       
                        CvBox2D  box = cvMinAreaRect2( temp_contour );
                        
                        //CHANGE THIS PARAMETER SPECIFIC FOR YOUR APPLICATION POURPOSE
                        /*
                        if (box.size.width  > (face->skin_face->skin_rect.width)/2.5   ||       //TOO BIG
                                box.size.height > (face->skin_face->skin_rect.height)/4    ||
                                box.size.width  < (face->skin_face->skin_rect.width)/14    ||   //TOO SMALL
                                box.size.height < (face->skin_face->skin_rect.height)/14  
                                )
                        continue;
                        */

                        /*
                        cvEllipse( image, cvPoint ((int) box.center.x , (int) box.center.y) , 
                                        cvSize( (int)box.size.width , (int)box.size.height), 
                                        (double)(360 * box.angle)/ (2 * CV_PI) - 90, 
                                        0, 360, cvScalar( 0, 255, 255 ),
                                        2, 4 );
                        */
                        count ++;
                        x     += (int)box.center.x ;
                        y     += (int)box.center.y ;
                        width = MAX ((int)box.size.width, width) ;
                        height= MAX((int)box.size.height, height );
                        angle += box.angle ;

                        //printf ("angle : %f\n" , box.angle);
                }
                
                if (count > 0)
                {       
                        /*
                        cvEllipse( this->src, cvPoint ((int) x/count , (int) y/count) , 
                                        cvSize( width , height ), 
                                        (double)(360 * (angle /count))/ (2 * CV_PI) - 90, 
                                        0, 360, cvScalar( 0, 255, 255 ),
                                        2, 4 );
                        */
                        //face->mouth_box ;

                        face->mouth_box.center = cvPoint2D32f( x/count , y/count); 
                        face->mouth_box.size   = cvSize2D32f( width , height );
                        face->mouth_box.angle  = (float) angle /count ;

                        //printf ("angle : %d\n" , (int)((360 * face->mouth_box.angle)/ (2 * CV_PI) - 90));

                }
                
                /*
                cvNamedWindow("mouth_", 1);
                cvShowImage("mouth_", this->src);
                cvWaitKey(0);
                */
        }


        //cvClearMemStorage( storage );

}

void 
CvFaceDetect::icvEyesMap(IplImage * image)
{
        this->eyes_map  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        this->y         = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        cvSplit (ycc, y, 0, 0, 0);

        IplImage *cb2, *cr_2, *cbcr ;
        cb2   = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );
        cr_2  = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );
        cbcr  = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );

        // build the two channels  cr^2 , cr-^2 and cb/cr (they'll be normalized later)
        int _cr, _cb ;
        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cr = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +1);
                        _cb = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +2);
                        
                        CV_IMAGE_ELEM( cb2, float, j, i )   = (float)(_cb * _cb) ;
                        CV_IMAGE_ELEM( cr_2, float, j, i )  = (float)(255 - _cr) * (255 - _cr) ;
                        CV_IMAGE_ELEM( cbcr, float, j, i )  = (float)(_cb / _cr) ;

                }
        }

        // calculate max and min value of the two channels cr^2 and crcb for the normalization
        double cb2_min = 0 , cb2_max = 0 , cr_2_min = 0, cr_2_max = 0 , cbcr_min = 0 , cbcr_max = 0;

        cvMinMaxLoc( cb2, &cb2_min , &cb2_max );
        cvMinMaxLoc( cr_2, &cr_2_min , &cr_2_max );
        cvMinMaxLoc( cbcr, &cbcr_min , &cbcr_max );

        // create channels
        IplImage *cb2_norm, *cr_2_norm, *cbcr_norm ;
        cb2_norm   = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );
        cr_2_norm  = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );
        cbcr_norm  = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );

        // normalize channels just built on [0, 255]
        float _cbcr , _cb2, _cr_2 ;
        double cr_2_range  = cr_2_max - cr_2_min;
        double cbcr_range = cbcr_max - cbcr_min;
        double cb2_range = cb2_max - cb2_min;

        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cb2 =  CV_IMAGE_ELEM( cb2 , float, j, i )  ;
                        _cr_2 = CV_IMAGE_ELEM( cr_2, float, j, i )      ;
                        _cbcr = CV_IMAGE_ELEM( cbcr, float, j, i )      ;
                        
                        // to normalize on [0, 255] I'll use the formula
                        // [(x - min)/(max - min)] * scale
                        CV_IMAGE_ELEM( cb2_norm  , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cb2 - cb2_min) / cb2_range) * 255);
                        CV_IMAGE_ELEM( cr_2_norm  , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cr_2 - cr_2_min) / cr_2_range) * 255);
                        CV_IMAGE_ELEM( cbcr_norm , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cbcr - cbcr_min) / cbcr_range) * 255);
                                        
                }
        }

        // build the eyes map
        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cb2 =  CV_IMAGE_ELEM( cb2_norm , unsigned char, j, i )  ;
                        _cr_2 = CV_IMAGE_ELEM( cr_2_norm, unsigned char, j, i ) ;
                        _cbcr = CV_IMAGE_ELEM( cbcr_norm, unsigned char, j, i ) ;
                        
                        CV_IMAGE_ELEM( this->eyes_map  , unsigned char, j, i )  = 
                                                (unsigned char) ( (_cb2 + _cr_2 + _cbcr  ) / 3 ) ;
                                        
                }
        }

        cvReleaseImage( &cb2 );
        cvReleaseImage( &cr_2 );
        cvReleaseImage( &cbcr );
        cvReleaseImage( &cb2_norm );
        cvReleaseImage( &cr_2_norm );
        cvReleaseImage( &cbcr_norm );
}

void 
CvFaceDetect::icvEyesMask(){
        
        IplImage *_eyes_map_bin,  *eyes_map_y , *eyes;

        eyes_map_bin  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        
        _eyes_map_bin  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        eyes_map_y  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        eyes  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        // calculate max value
        double map_min = 0 , map_max = 0 , map_range;
        cvMinMaxLoc( this->eyes_map, &map_min , &map_max );
        map_range = map_max - ( map_max * 0.60 );
        

        // binarize the map with 20% of highest values
        cvThreshold( this->eyes_map, _eyes_map_bin, map_range, 255, CV_THRESH_BINARY );
        
        // take the channel y and take the darkest values of skin locus
        cvThreshold( this->y , eyes_map_y, 80, 255, CV_THRESH_BINARY_INV);
        
        cvAnd( _eyes_map_bin, eyes_map_y, eyes );
        // cvAnd( eyes_map, eyes_map_y, eyes );

        // open the eye region
        //IplConvKernel* kernelOp = cvCreateStructuringElementEx( 4, 4, 1, 1, CV_SHAPE_CROSS, NULL );
        cvDilate( eyes , eyes_map_bin, NULL/*kernelOp*/ ,  1 );

#ifdef EYES
        cvNamedWindow( "eyes", 1 );
        cvShowImage( "eyes", eyes_map_bin);
#endif

        /*
        cvNamedWindow( "eyes_map", 1 );
        cvShowImage( "eyes_map", eyes_map);
        
        cvNamedWindow( "eyes_map_bin", 1 );
        cvShowImage( "eyes_map_bin", eyes_map_bin);

        cvNamedWindow( "eyes_Y", 1 );
        cvShowImage( "eyes_Y", eyes_map_y);
        
        cvNamedWindow( "eyes", 1 );
        cvShowImage( "eyes", eyes);
        */

        cvReleaseImage( &_eyes_map_bin );
        cvReleaseImage( &eyes_map_y );
        cvReleaseImage( &eyes );
}

void 
CvFaceDetect::icvEyesDetect()
{

        int eyes = 0 ;
/*
        int x , y, width, height, count;
        double angle ;
*/
        Cvface *face;
        
        //printf ("face skin presenti : %d", this->faces->total);
        //printf ("face skin presenti : %d", this->contours);

        //for (int i = 0; i < this->contours; i++)
        for (int i = 0; i < this->faces->total ; i++)
        {       
                //printf("width: %d , height: %d\n", this->skin_rect[i].width, this->skin_rect[i].height);
                
                /*
                // draw a rectangle
                CvPoint left_bottom = { this->skin_rect[i].x, this->skin_rect[i].y };
                CvPoint right_top   = { this->skin_rect[i].x + this->skin_rect[i].width, 
                                                            this->skin_rect[i].y + this->skin_rect[i].height };
                
                cvRectangle( this->src, left_bottom, right_top, CV_RGB(255,0,0), 2, 4, 0 );
                //*/
                
                /*
                //draw a box
                int n = 4;
                CvPoint2D32f _box_point[4];
                CvPoint box_point[4], *bpp = box_point;

                cvBoxPoints( this->skin_box[i], _box_point );
                
                for (int i=0; i<n ; i++)
                {
                        box_point[i] = cvPoint(cvRound(_box_point[i].x),cvRound(_box_point[i].y));
                }

                cvPolyLine( this->src, &bpp , &n, 1, 1, CV_RGB(255,0,0), 2, 8, 0 );
                */
                
                /*
                cvNamedWindow("eyes_", 1);
                cvShowImage("eyes_", this->src);
                cvWaitKey(0);
                */
                
                face = (Cvface *)cvGetSeqElem( this->faces, i);

                cvSetImageROI(this->eyes_map_bin, face->skin_face.skin_rect );
                //cvSetImageROI(this->eyes_map_bin, this->skin_rect[i]);
                
                                        
                eyes = cvFindContours( this->eyes_map_bin , this->storage, &(this->contour) ,  
                                                sizeof(CvContour), CV_RETR_EXTERNAL ,
                                                CV_CHAIN_APPROX_SIMPLE ,
                                                cvPoint( face->skin_face.skin_rect.x, face->skin_face.skin_rect.y )   );
                
                //if no eye is detect jump..
                if (eyes == 0) continue;
                
                int _ey = 0;

                for(CvSeq* temp_contour = this->contour; temp_contour != 0; temp_contour = temp_contour->h_next )
                {                       
                        CvBox2D  box = cvMinAreaRect2( temp_contour );
                        
                        //printf("box_width : %f \t skin_rect : %d\n",box.size.width , this->skin_rect[i].width);
                        //printf("box_height : %f \t skin_rect: %d\n\n", box.size.height ,this->skin_rect[i].height);
                        
                        //CHANGE THIS PARAMETER SPECIFIC FOR YOUR APPLICATION POURPOSE
                        if (box.size.width  < (face->skin_face.skin_rect.width)/16   || //TOO SMALL
                                box.size.height < (face->skin_face.skin_rect.height)/16 /* ||
                                
                                box.size.width  > (face->skin_face->skin_rect.width)/5.5    ||  //TOO BIG
                                box.size.height > (face->skin_face->skin_rect.height)/4 */
                                )
                        continue;
                        
                        //printf("pos : %d\t x: %f \n", _ey%2 , box.center.x);
                        //face->eyes_box[_ey%2] = new CvBox2D ;

                        face->eyes_box[_ey%2] = box ;
                        
                        _ey++;

                        /*
                        cvEllipse( this->src, cvPoint ((int) box.center.x , (int) box.center.y) , 
                                        cvSize( (int)box.size.width , (int)box.size.height), 
                                        (double)(360 * box.angle)/ (2 * CV_PI) - 90, 
                                        0, 360, cvScalar( 0, 255, 0 ),
                                        2, 4 );
                        */

                        /*
                        count ++;
                        x     += (int)box.center.x ;
                        y     += (int)box.center.y ;
                        width = max ((int)box.size.width, width) ;
                        height= max((int)box.size.height, height );
                        angle += box.angle ;
                        */
                        //printf ("angle : %f\n" , box.angle);
                }
                /*
                if (count > 0)
                {
                        cvEllipse( this->src, cvPoint ((int) x/count , (int) y/count) , 
                                        cvSize( width , height ), 
                                        (double)(360 * (angle /count))/ (2 * CV_PI) - 90, 
                                        0, 360, cvScalar( 0, 255, 255 ),
                                        2, 4 );

                }
                */
                
                /*
                cvNamedWindow("eyes_", 1);
                cvShowImage("eyes_", this->src);
                cvWaitKey(0);
                */
        }
        
        //cvClearMemStorage( storage );
}

void 
CvFaceDetect::icvMouthEyesMap(IplImage * image)
{
        this->eyes_map  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        this->y         = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        this->mouth_map = cvCreateImage(this->size, IPL_DEPTH_32F, 1  );
        
        cvSplit (ycc, y, 0, 0, 0);

        IplImage *cb2, *cr_2, *cbcr ;
        cb2   = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );
        cr_2  = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );
        cbcr  = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1  );

        // build channel cr^2 , cr-^2 and cb/cr (then normalize them)
        int _cr, _cb ;
        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cr = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +1);
                        _cb = CV_IMAGE_ELEM(ycc, unsigned char, j, 3*i +2);
                        
                        CV_IMAGE_ELEM( cb2, float, j, i )   = (float)(_cb * _cb) ;
                        CV_IMAGE_ELEM( cr_2, float, j, i )  = (float)(255 - _cr) * (255 - _cr) ;
                        CV_IMAGE_ELEM( cbcr, float, j, i )  = (float)(_cb / _cr) ;
                        
                        // build mouth_map
                        CV_IMAGE_ELEM( this->mouth_map, float, j, i )  = 
                                                                        (float) ( _cr * (255 - (_cr - _cb) ) * _cr ) ;

                }
        }

        // calculate max and min value on two the channels cr^2 and crcb for the normalization
        double cb2_min = 0 , cb2_max = 0 , cr_2_min = 0, cr_2_max = 0 , cbcr_min = 0 , cbcr_max = 0;

        cvMinMaxLoc( cb2, &cb2_min , &cb2_max );
        cvMinMaxLoc( cr_2, &cr_2_min , &cr_2_max );
        cvMinMaxLoc( cbcr, &cbcr_min , &cbcr_max );

        // build normalized channels
        IplImage *cb2_norm, *cr_2_norm, *cbcr_norm ;
        cb2_norm   = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );
        cr_2_norm  = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );
        cbcr_norm  = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, 1  );

        // normalize channels on [0, 255]
        float _cbcr , _cb2, _cr_2 ;
        double cr_2_range  = cr_2_max - cr_2_min;
        double cbcr_range = cbcr_max - cbcr_min;
        double cb2_range = cb2_max - cb2_min;

        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cb2 =  CV_IMAGE_ELEM( cb2 , float, j, i )  ;
                        _cr_2 = CV_IMAGE_ELEM( cr_2, float, j, i )      ;
                        _cbcr = CV_IMAGE_ELEM( cbcr, float, j, i )      ;
                        
                        // x normalizzare su [0, 255] uso la formula
                        // [(x - min)/(max - min)] * scala
                        CV_IMAGE_ELEM( cb2_norm  , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cb2 - cb2_min) / cb2_range) * 255);
                        CV_IMAGE_ELEM( cr_2_norm  , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cr_2 - cr_2_min) / cr_2_range) * 255);
                        CV_IMAGE_ELEM( cbcr_norm , unsigned char, j, i )  = 
                                                                (unsigned char)(( (_cbcr - cbcr_min) / cbcr_range) * 255);
                                        
                }
        }

        // build the eyes map
        for ( int j = 0; j < this->size.height; j++ ) {
                for ( int i=0; i < this->size.width; i++ ) {

                        _cb2 =  CV_IMAGE_ELEM( cb2_norm , unsigned char, j, i )  ;
                        _cr_2 = CV_IMAGE_ELEM( cr_2_norm, unsigned char, j, i ) ;
                        _cbcr = CV_IMAGE_ELEM( cbcr_norm, unsigned char, j, i ) ;
                        
                        CV_IMAGE_ELEM( this->eyes_map  , unsigned char, j, i )  = 
                                                (unsigned char) ( (_cb2 + _cr_2 + _cbcr  ) / 3 ) ;
                                        
                }
        }

        cvReleaseImage( &cb2 );
        cvReleaseImage( &cr_2 );
        cvReleaseImage( &cbcr );
        cvReleaseImage( &cb2_norm );
        cvReleaseImage( &cr_2_norm );
        cvReleaseImage( &cbcr_norm );
}

void 
CvFaceDetect::icvMouthEyesMask()
{
        this->mouth_map_bin = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        this->eyes_map_bin  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        IplImage * _mouth_map_bin;
        _mouth_map_bin = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        IplImage *_eyes_map_bin,  *eyes_map_y , *eyes;
        _eyes_map_bin  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        eyes_map_y  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        eyes  = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        // max value MOUTH
        double map_min = 0 , map_max = 0 , map_range;
        cvMinMaxLoc( this->mouth_map, &map_min , &map_max );
        map_range = map_max - ( map_max * 0.04 );

        cvThreshold( this->mouth_map, _mouth_map_bin, map_range, 255, CV_THRESH_BINARY );
        
        IplConvKernel* kernelOp = cvCreateStructuringElementEx( 4, 3, 1, 1, CV_SHAPE_CROSS, NULL );
        cvDilate( _mouth_map_bin , this->mouth_map_bin, kernelOp,  1 );

        
#ifdef MOUTH
        cvNamedWindow("mouth map bin", 1);
        cvShowImage("mouth", this->mouth_map_bin);
        cvWaitKey(0);
#endif

        // max value EYES
        cvMinMaxLoc( this->eyes_map, &map_min , &map_max );
        map_range = map_max - ( map_max * 0.60 );

        // binarize map with 20% of highest values.
        cvThreshold( this->eyes_map, _eyes_map_bin, map_range, 255, CV_THRESH_BINARY );
        
        // take channel y and take darkest values of skin locus
        cvThreshold( this->y , eyes_map_y, 80, 255, CV_THRESH_BINARY_INV);
        
        cvAnd( _eyes_map_bin, eyes_map_y, eyes );
        //cvAnd( eyes_map, eyes_map_y, eyes );

        // open eye region
        //IplConvKernel* kernelOp = cvCreateStructuringElementEx( 4, 4, 1, 1, CV_SHAPE_CROSS, NULL );
        cvDilate( eyes , eyes_map_bin, NULL/*kernelOp*/ ,  1 );

#ifdef EYES
        cvNamedWindow( "eyes", 1 );
        cvShowImage( "eyes", eyes_map_bin);
#endif

        /*
//      cvNamedWindow( "eyes_map", 1 );
//      cvShowImage( "eyes_map", eyes_map);
        
        cvNamedWindow( "eyes_map_bin", 1 );
        cvShowImage( "eyes_map_bin", eyes_map_bin);

        cvNamedWindow( "eyes_Y", 1 );
        cvShowImage( "eyes_Y", eyes_map_y);
        
        cvNamedWindow( "eyes", 1 );
        cvShowImage( "eyes", eyes);
        //*/

        cvReleaseImage( &_eyes_map_bin );
        cvReleaseImage( &eyes_map_y );
        cvReleaseImage( &eyes );

        cvReleaseImage( &_mouth_map_bin );
}

void 
CvFaceDetect::icvMouthEyesDetect()
{
        int mouth = 0 ;
        int eyes = 0 ;

        int x , y, width, height, count;
        double angle ;
        
        Cvface *face ;

        for (int i = 0; i < this->faces->total; i++)
        {       

                face = (Cvface *)cvGetSeqElem( this->faces, i);

                cvSetImageROI(this->mouth_map_bin, face->skin_face.skin_rect );
                cvSetImageROI(this->eyes_map_bin, face->skin_face.skin_rect );

                x = y = height = width = count = 0;
                angle = 0;
                                        
                mouth = cvFindContours( this->mouth_map_bin , this->storage, &(this->contour) ,  
                                                sizeof(CvContour), CV_RETR_EXTERNAL ,
                                                CV_CHAIN_APPROX_SIMPLE ,
                                                cvPoint( face->skin_face.skin_rect.x,face->skin_face.skin_rect.y )  );
                
                //if no mouth is detect jump..
                if (mouth == 0) 
                {
                        continue;
                }
                //printf("mouth : %d \n" , mouth);

                for(CvSeq* temp_contour = this->contour; temp_contour != 0; temp_contour = temp_contour->h_next )
                {                       
                        CvBox2D  box = cvMinAreaRect2( temp_contour );
                        
                        //CHANGE THIS PARAMETER SPECIFIC FOR YOUR APPLICATION POURPOSE
                        if (box.size.width  > (face->skin_face.skin_rect.width)/2.5   ||        //TOO BIG
                                box.size.height > (face->skin_face.skin_rect.height)/4    ||
                                box.size.width  < (face->skin_face.skin_rect.width)/14    ||    //TOO SMALL
                                box.size.height < (face->skin_face.skin_rect.height)/14  
                                )
                        continue;
                        

                        count ++;
                        x     += (int)box.center.x ;
                        y     += (int)box.center.y ;
                        width = MAX ((int)box.size.width, width) ;
                        height= MAX((int)box.size.height, height );
                        angle += box.angle ;

                        //printf ("angle : %f\n" , box.angle);
                }
                
                if (count > 0)
                {       
                        //face->mouth_box = new CvBox2D;

                        face->mouth_box.center = cvPoint2D32f( x/count , y/count); 
                        face->mouth_box.size   = cvSize2D32f( width , height );
                        face->mouth_box.angle  = (float) angle /count ;

                        //printf ("angle : %d\n" , (int)((360 * face->mouth_box.angle)/ (2 * CV_PI) - 90));

                }
                
                /*
                cvNamedWindow("mouth_", 1);
                cvShowImage("mouth_", this->src);
                cvWaitKey(0);
                /*/
                
                eyes = cvFindContours( this->eyes_map_bin , this->storage, &(this->contour) ,  
                                                sizeof(CvContour), CV_RETR_EXTERNAL ,
                                                CV_CHAIN_APPROX_SIMPLE ,
                                                cvPoint( face->skin_face.skin_rect.x, face->skin_face.skin_rect.y )   );


                // if no eye is detect jump..
                if (eyes == 0) continue;
                
                int _ey = 0;
                
                
                for(CvSeq* temp_contour = this->contour; temp_contour != 0; temp_contour = temp_contour->h_next )
                {                       
                        CvBox2D  box = cvMinAreaRect2( temp_contour );
                        
                        // CHANGE THIS PARAMETER SPECIFIC FOR YOUR APPLICATION POURPOSE
                        if (box.size.width  < (face->skin_face.skin_rect.width)/16   || //TOO SMALL
                                box.size.height < (face->skin_face.skin_rect.height)/16  ||
                                
                                box.size.width  > (face->skin_face.skin_rect.width)/5.5    ||   //TOO BIG
                                box.size.height > (face->skin_face.skin_rect.height)/4 
                                )
                        continue;
                        
                        //face->eyes_box[_ey%2] = new CvBox2D ;

                        face->eyes_box[_ey%2] = box ;
                        
                        _ey++;

                }

                if ( &face->eyes_box[0]!=0 &&
                         &face->eyes_box[1]!=0 &&
                         &face->mouth_box !=0                   
                        //add other check like perpendicularity between eyes & mouth
                        )
                {
                        face->track = true;
                        //printf("face %d enale to be tracked!\n\n", i);
                }
                /*
                cvNamedWindow("eyes_", 1);
                cvShowImage("eyes_", this->src);
                cvWaitKey(0);
                */

        }
}

---