OmniAlgoSimpleDetection.hh

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005-2006 <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 __OMNIALGO_SIMPLE_DETECTION_H__
#define __OMNIALGO_SIMPLE_DETECTION_H__

#include "../OmniConfig.hh"
#include "../OmniConversion.hh"
#include "../OmniMotionDetecting.hh"
#include "../OmniTracking.hh"
#include "../OmniTrackingTable.hh"
#include "../OmniFaceDetecting.hh"
#include "../HaarFaceDetecting.hh"
#include "../OmniGCardConverter.hh"
#include "../OmniCallback.hh"

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


template <class ConverterT, class AngleT, class ImageT, class PointT>
class OmniAlgoSimpleDetection {
public:
        OmniAlgoSimpleDetection( OmniConversion<ConverterT, AngleT, ImageT, PointT> *conversion_klass,
                                                        IplImage *first_frame, const char** cascade_file_array, int cascade_length,
                                                        int freeze_frame_bound, double track_window_hitrate );
        virtual ~OmniAlgoSimpleDetection();

        void loop_next_frame( IplImage* frame );
        
        void loop_stop();

        static void on_window_trackable_wannabe( IplImage* omni_frame, 
                                                                                         int theta_start, 
                                                                                         int theta_end, 
                                                                                         int win_length,
                                                                                         void* callback_data );

        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
                                                                  );
        
        void register_all_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
                                                                          );


private:                // functions
        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

#ifdef SHOW_DETECTED_FACES
        int _face_detected_num;
#endif  

        void* _callback_data_image_cb;  
        HaarFaceDetecting* _face_det;
        OmniTracking<ConverterT, AngleT, ImageT, PointT> * _tracking;
        OmniConversion<ConverterT, AngleT, ImageT, PointT> *_conv_table;
        OmniMotionDetecting<ConverterT, AngleT> *_motion_det;

        bool _is_running;
};






template <class ConverterT, class AngleT, class ImageT, class PointT>
OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::OmniAlgoSimpleDetection( 
                                                                                                OmniConversion<ConverterT, AngleT, ImageT, PointT> *conversion_klass,
                                                                                                IplImage *first_frame, 
                                                                                                const char** cascade_file_array, int cascade_length,
                                                                                                int freeze_frame_bound, double track_window_hitrate ) :
                                                                                _conv_table( conversion_klass )
{
        _is_running = false;
        _tracking = new OmniTracking<ConverterT, AngleT, ImageT, PointT>( first_frame, 
                                                                                                                                         _conv_table, 
                                                                                                                                         100, 
                                                                                                                                         freeze_frame_bound, 
                                                                                                                                         track_window_hitrate );

        _face_det = new HaarFaceDetecting( cascade_file_array, cascade_length );

        _motion_det = new OmniMotionDetecting<ConverterT, AngleT>( OmniAlgoSimpleDetection::on_window_trackable_wannabe,
                                                                                  this, _conv_table );

#ifdef SHOW_DETECTED_FACES
        _face_detected_num = 0;
#endif

        _callback_data_image_cb = NULL;
        // ok ok, we should also have created OmniTracking and OmniMotionDetecting instances
        // outside and then have passed them as parameters, so there wouldn't be the need
        // of use these callbacks, but anyway here they are. 
        // set the default callbacks. They can be changed with register_callbacks () call.
        register_image_callbacks( omnistuff_create_image_context, omnistuff_image_do_action, 
                                                          omnistuff_destroy_image_context, NULL );

        _is_running = true;
}


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

template <class ConverterT, class AngleT, class ImageT, class PointT>
OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::~OmniAlgoSimpleDetection() 
{
        delete _conv_table;
        delete _tracking;
        delete _face_det;
        delete _motion_det;
}


//-------------------------------------------------------------------------
// static. It will be a callback function.

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::on_window_trackable_wannabe( 
                                                                                                                        IplImage* omni_frame, 
                                                                                                                        int theta_start,  int theta_end, 
                                                                                                                        int win_length, void* callback_data ) 
{

        OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT> *ctrl;
        ctrl = (OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT> *)callback_data;

        // first of all test if the angle we want to test for new faces isn't
        // yet tracked
        if ( ctrl->_tracking->test_tracking_window_availability( theta_start, 
                                                                                                                        theta_end, 
                                                                                                                        win_length ) == true ) {
                IplImage *pano_frame;
                CvPoint face_center;
                OmniAngle<int> angle;

                angle.angle_start = theta_start;
                angle.angle_end = theta_end;
                angle.range = win_length;

                // trasform the omni part of the angle 
                pano_frame = ctrl->_conv_table->omni2pano( omni_frame, angle );

                // haar test: detect new faces
                if ( ctrl->_face_det->face_detected( pano_frame, &face_center ) == true ) {
#ifdef SHOW_DETECTED_FACES
                        char title[30];
                        sprintf(title, "face_detected! - %d", ctrl->_face_detected_num++ );
                        ctrl->create_image_context( title );
#endif
                        CvPoint omni_point;

                        // get the face center point back to the omni-image system
                        ctrl->_conv_table->pano2omni_xy( &face_center,
                                                                                  (AngleT)theta_start,
                                                                                  &omni_point );

                        // yes, now we can finally add the face center [always if it's not a
                        // false positive] to the tracker, that will follow it as long as it can.
                        ctrl->_tracking->add_point_to_track( omni_point );

#ifdef SHOW_DETECTED_FACES
                        // FIXME 0
                        ctrl->image_show( pano_frame, 0, title, ctrl->_callback_data_image_cb );
#endif
                }
                cvReleaseImage( &pano_frame );
        }
}


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

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::loop_next_frame( IplImage *frame ) 
{
        if ( !_is_running ) {
                return;
        }

#ifdef SHOW_MAIN_VIDEO
        create_image_context( "video_window", _callback_data_image_cb );
#endif

        // go on with the motion process of the frame
        _motion_det->process_next_frame( frame );

        // now we can track the points we have detected as faces
        _tracking->process_next_frame( frame );

#ifdef SHOW_MAIN_VIDEO
        // FIXME 0
        image_show( frame, 0, "video_window", _callback_data_image_cb );
#endif
}


//-------------------------------------------------------------------------
// Must be called in a mutex context. Otherwise there should be strange effects

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::loop_stop() 
{
        _is_running = false;

#ifdef SHOW_MAIN_VIDEO  
        destroy_image_context( "video_window", _callback_data_image_cb );
#endif

#ifdef SHOW_DETECTED_FACES
        // destroy all the tracked faces window
        for ( int i = 0; i < _face_detected_num; i++ ) {
                char title[30];
                sprintf(title, "face_detected! - %d", i );
                destroy_image_context( title );
        }
#endif


}

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

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::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_image_cb = callback_data_on_image_cb;
}

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

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniAlgoSimpleDetection<ConverterT, AngleT, ImageT, PointT>::register_all_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
                                                                                )
{
        // instances.
        _tracking->register_image_callbacks( create_image_context, image_show, 
                                                         destroy_image_context, callback_data_on_image_cb );
        
        _motion_det->register_image_callbacks( create_image_context, image_show, 
                                                         destroy_image_context, callback_data_on_image_cb );
}

#endif  /* __OMNIALGO_SIMPLE_DETECTION_H__ */

---