CvVRFilter.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*/

//#include "precomp.h"
#include "CvVRFilter.hh"


CvVrFilter::CvVrFilter (int min, int max)
{
        
        this->min_point = min;
        this->max_point = max;

        this->started = false ;

}

CvVrFilter::~CvVrFilter ()
{       
        cvReleaseImage( &this->median );
        cvReleaseImage( &this->rgb_norm );
        cvReleaseImage( &this->skin_mask );

        
}

IplImage *
CvVrFilter::cvVrFilter(IplImage * image , CvMemStorage *storage, CvSeq *seq)
{       
        if (started)
        {       
                cvReleaseImage( &this->median );
                cvReleaseImage( &this->rgb_norm );
                cvReleaseImage( &this->skin_mask );

        }
        else
        {       
                this->size = cvGetSize(image);
        }

        this->started = true ;
        this->source = image;

        
        icvSkinMask ();
        icvContours(storage, seq);

        return cvGetContoursMap(seq);
        
}

IplImage * 
CvVrFilter::cvGetSkinMask()
{       
        IplImage *_skin_mask ;
        _skin_mask = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        cvSmooth (this->median, _skin_mask, CV_MEDIAN, 9, 9, 0);

        return _skin_mask;
}

IplImage * 
CvVrFilter::cvGetSkinMap(CvSeq *seq)
{       
        IplImage *skin_map;
        cvGetContoursMask(seq);

        skin_map = icvCreateMap(this->source, this->skin_mask);

        return skin_map;
}

IplImage * 
CvVrFilter::cvGetContoursMask( CvSeq *seq, bool color_mask )
{       
        IplImage *contours_mask;

        if (color_mask)
                contours_mask = cvCreateImage(this->size, IPL_DEPTH_8U, 3  );
        else
                contours_mask = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        CvScalar color ;
        
        for (int i = 0; i < seq->total ; i++)
        {       
                Cvface *face;
                face = (Cvface *)cvGetSeqElem( seq, i );

                if (color_mask)
                        color = CV_RGB( rand()&255, rand()&255, rand()&255 );
                else    
                        color = CV_RGB( 255, 255, 255 );

                // replace CV_FILLED with 1 to see only the outlines 
                cvDrawContours( contours_mask, &face->skin_face.skin_contour , color, color, -1, CV_FILLED, 8 );
        }

#ifdef SKIN_SHOW
        cvNamedWindow( "mask_contours", 1 );
        cvShowImage( "mask_contours", contours_mask);
        cvWaitKey(0);
#endif

        return contours_mask;
}

IplImage * 
CvVrFilter::cvGetContoursMap(CvSeq *seq)
{       
        IplImage *contours_map, *contours_mask;
        contours_mask = cvGetContoursMask(seq);

        contours_map = icvCreateMap(this->source, contours_mask);

#ifdef SKIN_SHOW
        cvNamedWindow( "skin_contours", 1 );
        cvShowImage( "skin_contours", contours_map);
        cvWaitKey(0);
#endif
        
        cvReleaseImage( &contours_mask );

        return contours_map;

}


void 
CvVrFilter::icvContours(CvMemStorage *storage , CvSeq * seq)
{       
        CvSeq *contour = 0;

        int cont = cvFindContours( this->skin_mask , storage, &(contour) ,  
                                                                                sizeof(CvContour), CV_RETR_EXTERNAL  );
        
        for(CvSeq* temp_contour = contour; temp_contour != 0; temp_contour = temp_contour->h_next )
        {       
        

                if ( (temp_contour->total  < this->min_point) || (temp_contour->total  > this->max_point))
                {
                        //cvClearSeq(temp_contour );
                        continue;

                }
                else
                {       
                        CvBox2D box = cvMinAreaRect2( temp_contour );
                        
                        //CHANGE THIS PARAMETER SPECIFIC FOR YOUR APPLICATION POURPOSE
                        if( box.size.height/box.size.width > H_ON_W_VALUE ||
                                box.size.width/box.size.height > W_ON_H_VALUE )
                                continue;
                        
                        Cvface face;
                        memset(&face, 0, sizeof(Cvface));

                        face.skin_face.skin_rect = cvBoundingRect(temp_contour, 0 );
                        face.skin_face.skin_box = cvMinAreaRect2( temp_contour );

                        face.skin_face.skin_contour = *temp_contour;
                        
                        face.track = false ;

                        //memset(&face.mouth_box, 0, sizeof(CvBox2D));
                        //memset(&face.eyes_box[0], 0, sizeof(CvBox2D));
                        //memset(&face.eyes_box[1], 0, sizeof(CvBox2D));

                        cvSeqPush( seq ,  &face );

                }
        }

}

IplImage * 
CvVrFilter::icvCreateMap(const IplImage * src, const IplImage * mask)
{
        if ((src->width != mask->width) || (src->height != mask->height))
                 cvError( 0, "icvCreateMap","src and mask image must have the same size",
                                "cvvrfilter.cpp", 178);

        if (mask->nChannels != 1)
                cvError( 0, "icvCreateMap","mask image must be a 1 channel image",
                                "cvvrfilter.cpp", 178);

        IplImage *temp;
        
        // create the resulting image
        temp = cvCreateImage(cvSize(src->width,src->height),src->depth, src->nChannels );
        
        uchar * temp_ptr , *src_ptr;
        temp_ptr = &(CV_IMAGE_ELEM( temp, unsigned char, 0, 0));
        src_ptr = &(CV_IMAGE_ELEM(src, unsigned char, 0, 0));

        int pos = 0 ;
        int step = src->widthStep ;

        int original_r, original_g, original_b ;
        for ( int j = 0; j < src->height ; j++ ) {
                for ( int i=0; i < src->width ; i++ ) {
                        
                        pos = 3*i + j*step ;

                        if ( 0xFF == CV_IMAGE_ELEM(mask, unsigned char, j, i )  )
                        {
                                
                                original_b = src_ptr[pos + 0];
                                original_g = src_ptr[pos + 1];
                                original_r = src_ptr[pos + 2];

                                                                
                                temp_ptr[pos + 0] = original_b;
                                temp_ptr[pos + 1] = original_g;
                                temp_ptr[pos + 2] = original_r;

                        }
                        else
                        {
                                
                                temp_ptr[pos + 0] = 0xFF;
                                temp_ptr[pos + 1] = 0xFF;
                                temp_ptr[pos + 2] = 0xFF;
                        }
                }
        }
        
        return temp;
}

IplImage * 
CvVrFilter::icvRGBnorm(IplImage * image)
{       
        IplImage *rgbnorm ;
        
        // create the resulting image
        rgbnorm = cvCreateImage(this->size, IPL_DEPTH_32F, 3  );


        //build rgb normalized space
        
        //pointer to the images data
        uchar * src_ptr ; float * dest_ptr;
        src_ptr = &(CV_IMAGE_ELEM( image, unsigned char, 0, 0));
        dest_ptr = &(CV_IMAGE_ELEM( rgbnorm, float, 0, 0));
        int pos = 0;
        int step = image->widthStep ;
        
        int original_r, original_g, original_b, sum;
        for ( int j = 0; j < this->size.height ; j++ ) 
        {
                for ( int i=0; i < this->size.width ; i++ ) 
                {

                        pos = 3*i + j*step ;

                        original_b = src_ptr[pos + 0];
                        original_g = src_ptr[pos + 1];
                        original_r = src_ptr[pos + 2];

                        sum = original_r + original_b + original_g + 1;
                        
                        dest_ptr[pos + 0] = (float)(original_r + 1)/sum;
                        dest_ptr[pos + 1] = (float)(original_g + 1)/sum;
                        dest_ptr[pos + 2] = (float)(original_b + 1)/sum;
                        
                }
        }

        return rgbnorm ;

}

double * 
CvVrFilter::icvPline (double x1, double x2, double y1, double y2 )
{
        double *pline;
        pline = new double[2];

        pline[0] = (y2 - y1)/(x2 - x1);
        pline[1] = y2 -(x2*pline[0]);

        return pline;

}

void 
CvVrFilter::icvSkinMask ()
{       

        this->median = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );
        this->skin_mask = cvCreateImage(this->size, IPL_DEPTH_8U, 1  );

        cvZero( median );
        cvZero( skin_mask );

        //create rgb normalized color space
        this->rgb_norm = icvRGBnorm(this->source);

    //create statistic of image channels r/b
        CvScalar rgb_mean , rgb_sdv ;
        rgb_mean = rgb_sdv = cvScalarAll(0);

        cvAvgSdv( rgb_norm, &rgb_mean, &rgb_sdv, NULL );
        
        double *bg_pline ;
        bg_pline = icvPline (rgb_mean.val[2], (rgb_mean.val[2] - rgb_sdv.val[2]), rgb_mean.val[1], (rgb_mean.val[1] - rgb_sdv.val[1]));
        
        double norm_b, norm_g;
        int original_r, original_g, original_b;
        
        //pointer to the images data
        uchar * src_ptr ; float * dest_ptr;
        src_ptr = &(CV_IMAGE_ELEM( this->source, unsigned char, 0, 0));
        dest_ptr = &(CV_IMAGE_ELEM( this->rgb_norm, float, 0, 0));
        int pos = 0;
        int step = this->source->widthStep ;

        for ( int j = 0; j <  this->size.height ; j++ ) 
        {
                for ( int i = 0; i < this->size.width ; i++ ) 
                {       
                        pos = 3*i + j*step ;
                                                
                        original_b = src_ptr[pos + 0];
                        original_g = src_ptr[pos + 1];
                        original_r = src_ptr[pos + 2];
                        
                        norm_b = dest_ptr[pos + 2];
                        norm_g = dest_ptr[pos + 1];

                        if ( 
                                (//Filt3
                                  (original_g < 165) && (original_g < original_r - 25) &&
                                  (original_g < 0.8*original_r) && (original_g > 0.6*original_r) && 
                                  (original_b < (original_g + original_r)/2)
                )&&
                                
                                (//F3 OR F2
                                 (//F3
                                  ((norm_g > rgb_mean.val[1] - rgb_sdv.val[1]) && (norm_g < rgb_mean.val[1] + rgb_sdv.val[1]) && (norm_b < rgb_mean.val[2]))
                                )||
                                 (//F2
                                  (norm_g > bg_pline[0]*norm_b + bg_pline[1] - rgb_sdv.val[1]) &&
                                  (norm_g < bg_pline[0]*norm_b + bg_pline[1] + rgb_sdv.val[1]) &&
                                  (norm_g < rgb_mean.val[1] + rgb_sdv.val[1])
                                 )
                                )&&
                                
                                (//F1
                                  ( (((norm_b - rgb_mean.val[2])/0.2)*((norm_b - rgb_mean.val[2])/0.2) + ((norm_g - rgb_mean.val[2])/0.2)*((norm_g - rgb_mean.val[2])/0.2)) < 1 ) 
                                )&&
                                
                                //thresold
                                (original_r > 30) && (original_g > 25) && (original_b > 20)
                                
                                )
                        {
                        
                        //black and white mask
                        CV_IMAGE_ELEM (this->median, unsigned char, j, i )   = 0xff; 
            
            
                        }
                }
        }

#ifdef SKIN_SHOW
        cvNamedWindow( "debug", 1 );
        cvShowImage( "debug", this->median);
        cvWaitKey(0);
#endif


        cvSmooth (this->median, this->skin_mask, CV_MEDIAN, 9, 9, 0);
        
#ifdef SKIN_SHOW
        cvNamedWindow( "skin_mask", 1 );
        cvShowImage( "skin_mask", this->skin_mask);
        cvWaitKey(0);
#endif
        
}

---