HaarFaceDetecting.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005 <maxcvs@email.it>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */


#include "HaarFaceDetecting.hh"


//-------------------------------------------------------------------------
// min_size_x and y are the min sized objects to search for.

HaarFaceDetecting::HaarFaceDetecting( const char** cascade_file_array, 
                                                                         int array_length,
                                                                         int min_size_x /* =40 */,
                                                                         int min_size_y /* =40 */) {

        if ( array_length <= 0 ) {
                ready_to_detect = false;                                                                                                 
                return;
        }

        this->_min_size_x = min_size_x;
        this->_min_size_y = min_size_y;
        
        // will determine the length only of the usable files
        int arr_real_length = 0;

        _cascade_array = (CvHaarClassifierCascade**)calloc( array_length, sizeof(CvHaarClassifierCascade*));

    // load haar cascade classifiers
        for ( int i = 0; i < array_length; i++ ) {
                _cascade_array[arr_real_length] = (CvHaarClassifierCascade*)cvLoad( cascade_file_array[i] );

                // is it correctly loaded?
                if ( _cascade_array[arr_real_length] )
                        arr_real_length++;
        }

        this->_cascade_array_length = arr_real_length;
        _storage = 0;
        if ( arr_real_length > 0 )
                ready_to_detect = true;
        else
                ready_to_detect = false;
}


//-------------------------------------------------------------------------
//

HaarFaceDetecting::~HaarFaceDetecting() {

        if ( _cascade_array_length > 0 )
                free( _cascade_array );

        if ( _storage )
                cvClearMemStorage( _storage );
}


//-------------------------------------------------------------------------
// must be implemented

bool HaarFaceDetecting::is_ready_to_detect() {
        return ready_to_detect;
}


//-------------------------------------------------------------------------
// must be implemented
// Will return a face center point that is suitable for a LK face tracking
// if HAAR_DEBUG id defined than a red rectangle is painted around the tracked face

bool HaarFaceDetecting::face_detected( IplImage *image, CvPoint *face_center ) {

    int scale = 1;
    CvPoint pt1, pt2;
        CvSeq* faces = NULL;
        bool detected_something = false;

        if ( !is_ready_to_detect() )
                return false;

        if( !_storage )
        _storage = cvCreateMemStorage( 0 );
        else
                cvClearMemStorage( _storage );

        for ( int i = 0; i < _cascade_array_length; i++ ) {
                faces = cvHaarDetectObjects( image, _cascade_array[i], _storage,
                                                 1.1, 2, 0/*CV_HAAR_DO_CANNY_PRUNING*/,
                                                 cvSize(_min_size_x, _min_size_y) );
                if ( faces->total ) {
                        detected_something = true;
                        break;
                }
        }

        for( int i = 0; i < (faces ? faces->total : 0); i++ ) {
                CvRect* r = (CvRect*)cvGetSeqElem( faces, i );
        pt1.x = r->x*scale;
        pt2.x = (r->x+r->width)*scale;
        pt1.y = r->y*scale;
        pt2.y = (r->y+r->height)*scale;

                face_center->x = (pt1.x + pt2.x) / 2;
                face_center->y = (pt1.y + pt2.y) / 2;

#ifdef HAAR_DEBUG
                cvRectangle( image, pt1, pt2, CV_RGB(255,0,0), 3, 8, 0 );
#endif
    }

        if ( faces != NULL )
                cvClearSeq( faces );

        return detected_something;
}

---