OmniMotionDetecting.hh

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


#ifndef __OMNIMOTION_DETECTING__
#define __OMNIMOTION_DETECTING__

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

#include <time.h>

#include "OmniConfig.hh"
#include "OmniConversion.hh"



const double MHI_DURATION = 1;

const double MAX_TIME_DELTA = 1;

const double MIN_TIME_DELTA = 0.05;

typedef void (on_window_trackable_wannabe_cb)(  IplImage* omni_frame, 
                                                                                                int theta_start, 
                                                                                                int theta_end, 
                                                                                                int win_length, 
                                                                                                void* callback_data );

template <class ConverterT, class AngleT>
class OmniMotionDetecting {
public:
        OmniMotionDetecting( on_window_trackable_wannabe_cb *f_cb,
                                                 void* callback_data,
                                                 OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *conv_table,
                                                 int ring_buf_length = 4 );
        virtual ~OmniMotionDetecting();

        void process_next_frame( IplImage *next_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_on_image_cb );
        

private:        // functions
        void fast_update_mhi( IplImage* img, int diff_threshold = 10 );

        on_window_trackable_wannabe_cb* f_on_window_trackable_wannabe_cb;
        
        on_create_image_context_cb* create_image_context;
        
        on_image_do_action_cb* image_show;
        
        on_destroy_image_context_cb* destroy_image_context;
        
private:        // data

        void* _callback_data_on_window_trackable_wannabe_cb;
        void* _callback_data_on_image_cb;
        
        OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *_conv_table;

        IplImage **_ring_buf;

        int _ring_buf_length;
        int _ring_last_indx;


        IplImage *_mhi;
        
        IplImage *_orient;
        
        IplImage *_mask;
        
        IplImage *_segmask;     
        
        CvMemStorage *_storage; 
};





template <class ConverterT, class AngleT>
OmniMotionDetecting<ConverterT, AngleT>::OmniMotionDetecting( on_window_trackable_wannabe_cb *f_cb,
                                                                                 void* callback_data,
                                                                                 OmniConversion<ConverterT, AngleT, IplImage, CvPoint> *conv_table,
                                                                                 int ring_buf_length /* = 4 */ ) : _conv_table( conv_table ),
                                                                                        f_on_window_trackable_wannabe_cb( f_cb ),
                                                                                        _callback_data_on_window_trackable_wannabe_cb ( callback_data ),
                                                                                        _ring_buf_length( ring_buf_length ),
                                                                                        _ring_last_indx( 0 ),
                                                                                        _mhi( 0 ),              
                                                                                        _orient( 0 ),
                                                                                        _mask( 0 ),
                                                                                        _segmask( 0 ),
                                                                                        _storage( 0 )
{
        // create the ring buffer
        _ring_buf = (IplImage**)malloc( _ring_buf_length * sizeof(_ring_buf[0]) );
    memset( _ring_buf, 0, _ring_buf_length * sizeof(_ring_buf[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>
OmniMotionDetecting<ConverterT, AngleT>::~OmniMotionDetecting() 
{
        free( _ring_buf );
}

//-------------------------------------------------------------------------
//
template <class ConverterT, class AngleT>
void OmniMotionDetecting<ConverterT, AngleT>::process_next_frame( IplImage *next_frame ) 
{
        fast_update_mhi( next_frame );
}

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

template <class ConverterT, class AngleT>
void OmniMotionDetecting<ConverterT, AngleT>::fast_update_mhi( IplImage* img, int diff_threshold /* = 10 */) 
{
        // get current time in seconds
    double timestamp = clock()/1000.; 

        // get current frame size
    CvSize size = cvSize(img->width,img->height); 
    int i, idx1 = _ring_last_indx, idx2;
    IplImage* silh;
    CvSeq* seq;
    CvRect comp_rect;

    // allocate images at the beginning or
    // reallocate them if the frame size is changed
    if( (!_mhi || _mhi->width != size.width) || (_mhi->height != size.height) ) {
        
        for( i = 0; i < _ring_buf_length; i++ ) {
            cvReleaseImage( &_ring_buf[i] );
                        _ring_buf[i] = cvCreateImage( size, IPL_DEPTH_8U, 1 );
            cvZero( _ring_buf[i] );
        }
        cvReleaseImage( &_mhi );
        cvReleaseImage( &_orient );
        cvReleaseImage( &_segmask );
        cvReleaseImage( &_mask );
        
        _mhi = cvCreateImage( size, IPL_DEPTH_32F, 1 );

                // clear MHI at the beginning - the motion history -
        cvZero( _mhi ); 
        _orient = cvCreateImage( size, IPL_DEPTH_32F, 1 );
        _segmask = cvCreateImage( size, IPL_DEPTH_32F, 1 );
        _mask = cvCreateImage( size, IPL_DEPTH_8U, 1 );
    }

        // convert frame to grayscale
    cvCvtColor( img, _ring_buf[_ring_last_indx], CV_BGR2GRAY ); 

        // index of (last - (N-1))th frame
    idx2 = (_ring_last_indx + 1) % _ring_buf_length; 
    _ring_last_indx = idx2;

    silh = _ring_buf[idx2];
        // get difference between frames
    cvAbsDiff( _ring_buf[idx1], _ring_buf[idx2], silh ); 

        // and threshold it
    cvThreshold( silh, silh, diff_threshold, 1, CV_THRESH_BINARY ); 

        // update MHI
    cvUpdateMotionHistory( silh, _mhi, timestamp, MHI_DURATION ); 

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

    // segment motion: get sequence of motion components
    // segmask is marked motion components map. It is not used further
    seq = cvSegmentMotion( _mhi, _segmask, _storage, timestamp, MAX_TIME_DELTA );


    // iterate through the motion components,
    // One more iteration (i == -1) corresponds to the null image (no motion)
    for( i = -1; i < seq->total; i++ ) {

        if( i < 0 ) { // case of the whole image
            comp_rect = cvRect( 0, 0, size.width, size.width );
        }
        else { // i-th motion component
            comp_rect = ((CvConnectedComp*)cvGetSeqElem( seq, i ))->rect;

                        // reject very small components. This is important
            if( comp_rect.width + comp_rect.height < 150 ) 
                continue;
        }

                CvPoint left_bottom = { comp_rect.x, comp_rect.y };

                // take the middle motion-rectangle angle. 
                float rad_angle = atan2f( left_bottom.y - ((float)_conv_table->get_omni_center_y()),
                        left_bottom.x - ((float)_conv_table->get_omni_center_x()));

                // let's call our callback function to which we'll deliver frame and angle range
                OmniAngle<int> angle_int;
                OmniAngle<double> angle_double(rad_angle - FACE_TRACK_ANGLE_WINDOW, 
                                                                                 rad_angle + FACE_TRACK_ANGLE_WINDOW,
                                                                                 2 * FACE_TRACK_ANGLE_WINDOW);

                _conv_table->angle_type_conversion( angle_double, angle_int );

                f_on_window_trackable_wannabe_cb( img, angle_int.angle_start, 
                        angle_int.angle_end, angle_int.range, _callback_data_on_window_trackable_wannabe_cb );
    }

        if ( seq != NULL )
                cvClearSeq( seq );
}

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

template <class ConverterT, class AngleT>
void OmniMotionDetecting<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_on_image_cb
                                                                  )
{
        this->create_image_context = create_image_context;
        this->image_show = image_show;
        this->destroy_image_context = destroy_image_context;
        this->_callback_data_on_image_cb = callback_data_on_image_cb;
}


#endif /*__OMNIMOTION_DETECTING__ */

---