CvFaceTrack.hh

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

#ifndef __CVFACETRACKING_H__
#define __CVFACETRACKING_H__


// opencv
#include <cv.h>
#include <highgui.h>

#include <stdio.h>
#include "OmniConfig.hh"

template <class ConverterT, class AngleT>
class CvFaceTrack
{       
        IplImage *image;
        IplImage *grey ;
        IplImage *prev_grey ;
        IplImage *pyramid ;
        IplImage *prev_pyramid ;
        IplImage *swap_temp;
        CvSize size;
        
        int win_size ;
        int MAX_TRACKED_COUNT;

        CvPoint2D32f* tracked_points[2] ;
        CvPoint2D32f *swap_points;
        
        Cvface* face2track; 
        int face_count;

        char* tracked_status ;
        int tracked_count ;

        int track_flags ;

        bool started ;
        
        bool add_pt ;
        
        OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *conv_table;

        // define here the default callbacks
        on_create_image_context_cb* create_image_context;
        on_image_do_action_cb* image_show;
        on_destroy_image_context_cb* destroy_image_context;
        void* _callback_data_image_cb;
        
public:
        

        CvFaceTrack( OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *conv_table );

        virtual ~CvFaceTrack();
        

        int cvAddPoint2Track( CvSeq * faces);


        void cvTrackNextFrame(IplImage *frame);

        void register_image_callbacks( on_create_image_context_cb* create_image_context,
                                                                   on_image_do_action_cb* image_show,                                                              
                                                                   on_destroy_image_context_cb* destroy_image_context,
                                                                   void* callback_data_image_cb
                                                                   );   
        
private:
        

        void icvInitBuffer(IplImage *first_frame);
        
};




template <class ConverterT, class AngleT>
CvFaceTrack<ConverterT, AngleT>::CvFaceTrack( OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *c_table ) : 
                        conv_table ( c_table )
{
        this->win_size = 10;
        this->MAX_TRACKED_COUNT = 20;

        this->tracked_points[0] = 0;
        this->tracked_points[1] = 0;

        this->tracked_status = 0;
        this->tracked_count = 0;

        this->track_flags = 0;
        this->started = false ;

        this->add_pt = false;

        this->face2track = (Cvface*)
                        cvAlloc( MAX_TRACKED_COUNT * sizeof(Cvface));
        
        this->face_count = 0 ;
        
        
        // set the default callbacks. They can be changed with register_callbacks () call.
        // callback data to NULL to avoid strange behaviour on pointers.
        register_image_callbacks( omnistuff_create_image_context, omnistuff_image_do_action, 
                                                         omnistuff_destroy_image_context, NULL );
        
}

template <class ConverterT, class AngleT>
CvFaceTrack<ConverterT, AngleT>::~CvFaceTrack()
{

}

template <class ConverterT, class AngleT>
void 
CvFaceTrack<ConverterT, AngleT>::cvTrackNextFrame(IplImage *frame)
{
        if(!started)
        {
                icvInitBuffer(frame);
                started = true ;
        }

        int i, k;

    cvCopy( frame, image, 0 );
    cvCvtColor( image, grey, CV_BGR2GRAY );

        if( tracked_count > 0 )
        {
                cvCalcOpticalFlowPyrLK( prev_grey, grey, prev_pyramid, pyramid,
                tracked_points[0], tracked_points[1], tracked_count, cvSize(win_size,win_size), 3, tracked_status, 0,
                cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03), track_flags );
                
                track_flags |= CV_LKFLOW_PYR_A_READY;
        
                for( i = k = 0; i < tracked_count; i++ )
                {
                        if( !tracked_status[i] )
                                continue;
                
                        tracked_points[1][k++] = tracked_points[1][i];
            
                        face2track[i].skin_face.skin_box.center = tracked_points[1][i];

                        //show windows faces

                        CvPoint angle_point = cvPointFrom32f( tracked_points[1][i] );
                        OmniAngle<int> angle_int;

                        float rad_angle = 
                                atan2f( angle_point.y - ((float)conv_table->get_omni_center_y()),
                                                angle_point.x - ((float)conv_table->get_omni_center_x()));
                        
                        OmniAngle<double> angle_double (rad_angle - FACE_TRACK_ANGLE_WINDOW, 
                                                                                 rad_angle + FACE_TRACK_ANGLE_WINDOW,
                                                                                 2 * FACE_TRACK_ANGLE_WINDOW);
                        
                        
                        // get the angle interval we want to track [= a window]
                        conv_table->angle_type_conversion( angle_double, angle_int );                   

                        char title[30];
                        sprintf(title, "Tracking face id #%d", k );
            create_image_context( title, _callback_data_image_cb );
                        IplImage *face;

                        face = conv_table->omni2pano( frame, angle_int );

                        // So !*DO NOT FREE*! the image when you call this function.
                        image_show( face, k, title, _callback_data_image_cb );

                        face2track[i].skin_face.skin_box.center = tracked_points[1][i];
                }
        tracked_count = k;
        }
        
        if( add_pt && tracked_count < MAX_TRACKED_COUNT )
    {   
                tracked_count = 0;
                
                for(int i = 0; i < face_count; i++)
                {
                        tracked_points[1][tracked_count++] = face2track[i].skin_face.skin_box.center;

                        cvFindCornerSubPix( grey, tracked_points[1] + tracked_count - 1, 1,
                                                                cvSize(win_size,win_size), cvSize(-1,-1),
                                                                cvTermCriteria(CV_TERMCRIT_ITER|CV_TERMCRIT_EPS,20,0.03));
                }
                
                add_pt = false;
        }

    CV_SWAP( prev_grey, grey, swap_temp );
    CV_SWAP( prev_pyramid, pyramid, swap_temp );
    CV_SWAP( tracked_points[0], tracked_points[1], swap_points );
}

template <class ConverterT, class AngleT>
int
CvFaceTrack<ConverterT, AngleT>::cvAddPoint2Track(CvSeq * faces)
{       

        //printf("face_tracking.cpp faces->total : %d \n", faces->total);       
        face_count = 0;

        for (int i = 0; i < faces->total ; i++)
        {       
                Cvface *face;
                face = (Cvface *)cvGetSeqElem( faces, i );
                
                if (!face->track)
                        continue;
                
                //printf("center : x=%f y=%f \n", face->skin_face.skin_box.center.x , face->skin_face.skin_box.center.y);
                face2track[face_count++] = *face ;

        }
        
        if (face_count > 0)
        {
                add_pt = true ;
        }

        return face_count;
}

template <class ConverterT, class AngleT>
void
CvFaceTrack<ConverterT, AngleT>::icvInitBuffer(IplImage *first_frame)
{       
        this->size = cvGetSize(first_frame);

        // allocate all the buffers
    this->image = cvCreateImage( this->size, 8, 3 );
        this->image->origin = first_frame->origin;

        // grey image
    this->grey = cvCreateImage( this->size, 8, 1 );
    this->prev_grey = cvCreateImage( this->size, 8, 1 );

        // pyramid image
    this->pyramid = cvCreateImage( this->size, 8, 1 );
    this->prev_pyramid = cvCreateImage( this->size, 8, 1 );

        // alloc the space for the max number of tracked points
    this->tracked_points[0] = (CvPoint2D32f*)
                        cvAlloc( MAX_TRACKED_COUNT * sizeof(tracked_points[0][0]));
    this->tracked_points[1] = (CvPoint2D32f*)
                        cvAlloc( MAX_TRACKED_COUNT * sizeof(tracked_points[0][0]));

    this->tracked_status = (char*)cvAlloc( MAX_TRACKED_COUNT );


}

template <class ConverterT, class AngleT>
void 
CvFaceTrack<ConverterT, AngleT>::register_image_callbacks( 
                                                                   on_create_image_context_cb* create_image_context,
                                                                   on_image_do_action_cb* image_show,
                                                                   on_destroy_image_context_cb* destroy_image_context,
                                                                   void* callback_data
                                                                  )
{
        this->create_image_context = create_image_context;
        this->image_show = image_show;
        this->destroy_image_context = destroy_image_context;
        this->_callback_data_image_cb = callback_data;
}



#endif /*_CVFACETRACKING_H_*/

---