OmniTrackingTable.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 __OMNITRACKING_TABLE_H__
#define __OMNITRACKING_TABLE_H__

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

// stl
#include <list>

using namespace std;


template <class ConverterT, class AngleT, class ImageT, class PointT>
class OmniTrackingTable {

public:
        OmniTrackingTable( OmniConversion<ConverterT, AngleT, ImageT, PointT> *conv_table,
                int freeze_frame_bound, double track_window_hitrate );

        virtual ~OmniTrackingTable();

        bool test_tracking_window_availability( int theta_start, int theta_end, 
                                int window_length );

protected:              // functions
        void add_tracking_window( int window_id, int theta_start, int theta_end );
        
        void add_wannabe_trackable_marks( int theta_start, int theta_end );
        
        bool update_tracking_window_bounds( int window_id, int new_theta_start, 
                                int new_theta_end );
        
        void remove_tracking_window( int window_id );

        void update_begin();

        void update_end();

        OmniConversion<ConverterT, AngleT, ImageT, PointT> *m_conv_table;

private:                // functions
        bool init_tracking_table( int degrees );


private:                // data
        char *_degree_table;            // array of chars
        
        int _degree_table_length;

        int _active_tracks;

        const double _track_window_hitrate;
        const int _freeze_frame_bound;
        
        bool _update_is_possibile;

        list<TrackingWindow*> _track_list;
};




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

template <class ConverterT, class AngleT, class ImageT, class PointT>
OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::OmniTrackingTable( 
                                                                         OmniConversion<ConverterT, AngleT, ImageT, PointT> *conv_table, 
                                                                         int freeze_frame_bound, 
                                                                         double track_window_hitrate ) : 
                                                                         _freeze_frame_bound( freeze_frame_bound ),
                                                                         _track_window_hitrate( track_window_hitrate ),
                                                                         m_conv_table( conv_table )
{
        _update_is_possibile = false;
        init_tracking_table( (int)ceil( 2 * CV_PI * m_conv_table->get_max_radius() ) );
}



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

template <class ConverterT, class AngleT, class ImageT, class PointT>
OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::~OmniTrackingTable() {

        free( _degree_table );

        if ( ! _track_list.empty () ) {
                TrackingWindow* tmp_track;

                while ( (tmp_track = _track_list.front ())) {
                        _track_list.pop_front ();
                        if ( tmp_track ) {
                                delete tmp_track;
                        }
                }
        }
}


//-------------------------------------------------------------------------
// WARNING: with this call the entire degree_table will be cleaned from its
// marks. 

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::update_begin() {
        _update_is_possibile = true;

        memset( _degree_table, 0, _degree_table_length * sizeof(char));
}


//-------------------------------------------------------------------------
//  perform a total rewrite of the degree table: every linked list element 
// [a window] will write its own info to the table.

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::update_end() {
        _update_is_possibile = false;


        list<TrackingWindow*>::iterator iter;

        // perform a scan till to find the right id element.
        for ( iter = _track_list.begin(); iter != _track_list.end(); iter++ ) {
                (*iter)->write_window_to_table( _degree_table );
        }
}


//-------------------------------------------------------------------------
// this will remove the object from the list, delete it and then upgrade the 
// window_id of the remainings objects in the list. They will be decreased
// by one. This to mantain a crescent array

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::remove_tracking_window( int window_id ) 
{

        list<TrackingWindow*>::iterator iter;

        TrackingWindow *win_to_remove = NULL;
        // flag
        bool win_deleted = false;

        // perform a scan till to find the right id element.
        for ( iter = _track_list.begin(); iter != _track_list.end(); iter++ ) {
                // we wanna modify the object, not having its copy
                TrackingWindow *win = (TrackingWindow*)(*iter);

                // then update its status
                if ( win->get_id() == window_id ) {
                        
                        win_to_remove = win;
                        win_deleted = true;
                }

                // go on decrementing the others window_id
                if ( win_deleted ) {
                        win->change_id( win->get_id() - 1 );
                }
        }

        if ( win_to_remove != NULL ) {
                _track_list.remove( win_to_remove );
                delete win_to_remove;
        }

        _active_tracks--;
}


//-------------------------------------------------------------------------
// construct a TrackingWindow object and adds it to the linked list
// It also performs a write to the table of the VALUE_TRACKED status.

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::add_tracking_window( 
                        int window_id, int theta_start, int theta_end ) {
        
        TrackingWindow *t_win = new TrackingWindow( window_id, theta_start, theta_end, 
                _degree_table_length, _freeze_frame_bound );
        _track_list.push_back( t_win );

        // write the status to the window
    t_win->write_window_to_table( _degree_table );

        _active_tracks++;
}


//-------------------------------------------------------------------------
// I'll try to explain at best what this function does: it just writes to the degree
// table a mark 'W' for a wannabe trackable window. It does not construct
// a TrackingWindow object and does not add it to the list track_list.
// This mark 'W' is written here only to permit a multiple tracking-window adding,
// in case the motion detection detects more than one movement.
// This happens because only with a complete loop of process_next_frame in OmniTracking
// a window can be completely and cleanly added: so to avoid the loosing of 
// many ( >1 ) motion windows at a time we must find a way to "update" the degree_table
// so that the test_tracking_window_availability can return a "no, this space is already
// tracked".
// On next update_begin() and changes made here will be lost

template <class ConverterT, class AngleT, class ImageT, class PointT>
void OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::add_wannabe_trackable_marks( 
                        int theta_start, int theta_end ) 
{
        int window_length_tmp;

        if ( theta_start < theta_end )  // 0 .. | | | |S| | | | | | |E| | | .. theta_max
                window_length_tmp = theta_end - theta_start;
        else                                                    // 0 .. | | | |E| | | | | | |S| | | .. theta_max
                window_length_tmp = theta_end + _degree_table_length - theta_start;

        for ( int i = 0 ; i < window_length_tmp; i++ ) {
                _degree_table[(theta_start + i) % _degree_table_length] = VALUE_WANNABE_TRACKABLE;
        }
}


//-------------------------------------------------------------------------
// test if the tracking window [i.e. the degree interval in which the 
// motion is caught] is a face-detectable window [i.e. is not yet
// tracked by LK algorithm].
// 0 <= start_angle < end_angle <= 2pi in a circular fashion.
//
//   [ T T T T T T 0 0 0 0 0 0 0 0 0 0 W W W W 0 0 0 0 0 0 0 0 0 0 0]
//      [M M M M M M M]   <-- testing motion window [*1]
//   <-M M M]                                    [2*]          [ M M->
//                                      [3*]      [M M M M M]
//
//  [*1]: new tracking window is not avaiable coz > 50% hits are yet tracked [T]
//  [*2]: even here we have a failed new window
//  [*3]: good new tracking window. Of course this must match the face-detect before
//        become a real *new* tracking win.

template <class ConverterT, class AngleT, class ImageT, class PointT>
bool OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::test_tracking_window_availability( int theta_start, int theta_end, 
                                                                                                                  int window_length ) 
{
        // main for loop: let's check in a circular fascion for an hitrate  > MOTION_HITRATE 
        // of avaiable tracking portions
        int hitrate = 0;
        
        for ( int step_count = 0; step_count < window_length; step_count++ ) {
                int curr_value = _degree_table[(theta_start + step_count) % _degree_table_length];
                if (  curr_value != VALUE_TRACKED && curr_value != VALUE_WANNABE_TRACKABLE )
                        hitrate++;
        }

        // check the rate obtained
        if ( hitrate > (window_length * TRACK_WINDOW_HITRATE) ) {
                return true;
        }
        
        return false;
}


//-------------------------------------------------------------------------
// be careful to call this function only between a update_begin() and a
// update_end(). Will return false if this condition is not accomplished
// or if a TrackingWindow remains in the same position too 
// long [i.e. false positive tracking?!]

template <class ConverterT, class AngleT, class ImageT, class PointT>
bool OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::update_tracking_window_bounds( 
                        int window_id, int new_theta_start, int new_theta_end ) 
{
        if ( !_update_is_possibile )
                return false;

        list<TrackingWindow*>::iterator iter;

        // perform a scan till to find the right id element.
        for ( iter = _track_list.begin(); iter != _track_list.end(); iter++ ) {
                // we wanna modify the object, not having its copy
                TrackingWindow *win = (TrackingWindow*)(*iter);

                // then update its status
                if ( win->get_id() == window_id ) {
                        // we're done
                        return win->update_window_bounds( new_theta_start, new_theta_end );
                }
        }

        return false;
}

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

template <class ConverterT, class AngleT, class ImageT, class PointT>
bool OmniTrackingTable<ConverterT, AngleT, ImageT, PointT>::init_tracking_table( int degrees ) 
{
        if (degrees <= 0)
                return false;

        // create the table which represents all the 360 degree
        _degree_table = (char*)calloc( degrees, sizeof(char) );

        _degree_table_length = degrees;
        _active_tracks = 0;

        return true;
}


#endif /* __OMNITRACKING_TABLE_H__ */

---