main_frame.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005 <maxcvs@email.it>
 *  Copyright (C) Fabio Zecchini 2005 <zio.zec@gmail.com>
 *
 *  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.
 */

#if defined(__GNUG__) && !defined(__APPLE__)
#pragma implementation "main_frame.h"
#endif

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif

#include "options_dialog.h"
#include "about_dialog.h"
#include "version_dialog.h"

#include <wx/dcbuffer.h>
#include "main_frame.h"

// OpenCv
#include <cv.h>
#include <highgui.h>
#include <cvaux.h>

#include <stdio.h>
#include <ctype.h>
#include <time.h>       


static bool video_received_window = false;


IMPLEMENT_CLASS( MainFrame, wxFrame )


BEGIN_EVENT_TABLE( MainFrame, wxFrame )

    EVT_CLOSE( MainFrame::OnCloseWindow )

    EVT_MENU( ID_MENUITEM_FILE_EXIT, MainFrame::OnMenuitemFileExitClick )

    EVT_MENU( ID_MENUITEM_ACTIONS_STOP_SERVER, MainFrame::OnMenuitemActionsStopServerClick )

    EVT_MENU( ID_MENUITEM_ACTIONS_STOP_RECEIVING, MainFrame::OnMenuitemActionsStopReceivingClick )

    EVT_MENU( ID_MENU_PREFERENCES, MainFrame::OnMenuPreferencesClick )

    EVT_MENU( ID_MENU_HELP_AUTHORS, MainFrame::OnMenuHelpAuthorsClick )

    EVT_MENU( ID_MENU_HELP_VERSION, MainFrame::OnMenuHelpVersionClick )


        // added to use with threads events
        EVT_MENU( WORKER_EVENT, MainFrame::OnWorkerEvent )

        // images received are parsed in the main gui thread
        EVT_MENU( IMAGE_RECEIVED_EVENT, MainFrame::OnImageReceivedFromNet )

        // audio received are parsed in the main gui thread. This for separate
        // the libraries from the gui.
        EVT_MENU( AUDIO_RECEIVED_EVENT, MainFrame::OnAudioFrameReceivedFromNet )

END_EVENT_TABLE()

MainFrame::MainFrame( )
{

}

MainFrame::MainFrame( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
        // initialize StreamerCtrlThread thread And the Receiver one. 
        m_streamer_thread = new StreamerCtrlThread( this );
        m_receiver_thread = new ReceiverCtrlThread( this );

        ctrl_lookup = NULL;
        ctrl_gcard = NULL;
        ctrl_vr_lookup = NULL;
        ctrl_vr_gcard = NULL;
        ctrl_initialized = false;
        face_detect = false;


        num_streams = -1;
        _displayed_frames = new vector<DisplayImageFrame *>;
        _gc_images = new vector<list<IplImage* > *>;
        _paint_mutex = new wxMutex();
                
    Create( parent, id, caption, pos, size, style );

        SetAutoLayout( true );
}


//--------------------------------------------------------------------------
// provide a clean deletion of objects.

MainFrame::~MainFrame( ){

        if ( m_receiver_thread ) {
                if ( m_receiver_thread->isReceiving() ) {
                        printf("stop receiving\n");
                        m_receiver_thread->StopReceiving();
                        m_receiver_thread = NULL;
                }
                else
                        delete m_receiver_thread;

        }

        if ( m_streamer_thread ) {
                if ( m_streamer_thread->isStreaming() ) {
                        printf("stop streaming\n");
                        m_streamer_thread->stopStreaming();
                        m_streamer_thread = NULL;
                }
                else
                        delete m_streamer_thread;
        }

        reset_displayed_image_vector ();
        delete _displayed_frames;
}

bool MainFrame::Create( wxWindow* parent, wxWindowID id, const wxString& caption, const wxPoint& pos, const wxSize& size, long style )
{
    m_status_bar = NULL;

    wxFrame::Create( parent, id, caption, pos, size, style );

    CreateControls();
    Centre();
    return TRUE;
}

void MainFrame::CreateControls()
{    
    MainFrame* itemFrame1 = this;

    wxMenuBar* menuBar = new wxMenuBar;
    wxMenu* itemMenu3 = new wxMenu;
    itemMenu3->Append(ID_MENUITEM_FILE_EXIT, _("Exit"), _T(""), wxITEM_NORMAL);
    menuBar->Append(itemMenu3, _("File"));
    wxMenu* itemMenu5 = new wxMenu;
    itemMenu5->Append(ID_MENUITEM_ACTIONS_STOP_SERVER, _("Stop Server"), _T(""), wxITEM_NORMAL);
    itemMenu5->Append(ID_MENUITEM_ACTIONS_STOP_RECEIVING, _("Stop Receiving"), _T(""), wxITEM_NORMAL);
    menuBar->Append(itemMenu5, _("Actions"));
    wxMenu* itemMenu8 = new wxMenu;
    itemMenu8->Append(ID_MENU_PREFERENCES, _("Preferences..."), _T(""), wxITEM_NORMAL);
    menuBar->Append(itemMenu8, _("Tools"));
    wxMenu* itemMenu10 = new wxMenu;
    itemMenu10->Append(ID_MENU_HELP_AUTHORS, _("Authors..."), _T(""), wxITEM_NORMAL);
    itemMenu10->Append(ID_MENU_HELP_VERSION, _("Version..."), _T(""), wxITEM_NORMAL);
    menuBar->Append(itemMenu10, _("Help"));
    itemFrame1->SetMenuBar(menuBar);

    m_status_bar = new wxStatusBar( itemFrame1, ID_STATUSBAR, wxST_SIZEGRIP|wxNO_BORDER );
    m_status_bar->SetFieldsCount(2);
    itemFrame1->SetStatusBar(m_status_bar);


        
}

void MainFrame::OnMenuPreferencesClick( wxCommandEvent& event )
{

        if ( m_streamer_thread == NULL ) {
                m_streamer_thread = new StreamerCtrlThread( this );
        }

        if ( m_receiver_thread == NULL ) {
                m_receiver_thread = new ReceiverCtrlThread( this );
        }

    
        DialogOptions* window = new DialogOptions(this, m_streamer_thread, m_receiver_thread, this,
                ID_OPTIONS, _("Preferences..."));
    window->Show(true);

}


bool MainFrame::ShowToolTips()
{
    return TRUE;
}

wxBitmap MainFrame::GetBitmapResource( const wxString& name )
{
    // Bitmap retrieval
    return wxNullBitmap;
}

wxIcon MainFrame::GetIconResource( const wxString& name )
{
    // Icon retrieval
    return wxNullIcon;
}
void MainFrame::OnCloseWindow( wxCloseEvent& event )
{
        // provide a clean deletion of objects.
        if ( m_receiver_thread && m_receiver_thread->isReceiving() ) {
                wxMessageDialog dlg1( this, 
                        wxT("Please stop by hand the receiver, then close.") , wxT( "Warning" ), wxOK );
                dlg1.ShowModal();
                return;
        }

        if ( m_streamer_thread && m_streamer_thread->isStreaming() ) {
                wxMessageDialog dlg1( this, 
                        wxT("Please stop by hand the server streaming, then close."), wxT( "Warning" ), wxOK );
                dlg1.ShowModal();
                return;
        }

        destroy_garbage_collector_for_images ();

    wxWindow* window = this;
    window->Destroy();

        event.Skip();
}


void MainFrame::OnMenuitemFileExitClick( wxCommandEvent& event )
{
    // Before editing this code, remove the block markers.
    Destroy();
}


void MainFrame::OnMenuitemActionsStopServerClick( wxCommandEvent& event )
{
        if ( m_streamer_thread != NULL ) {
                if (  m_streamer_thread->isStreaming() ) {
                        m_streamer_thread->stopStreaming();

                        PrintStatusBarMessage( wxT( "Streaming stopped" ), 0 );

                        // no need to delete the object! Being a thread it will auto-destroy after
                        // its exiting
                        // recreate a new ojbect
                        m_streamer_thread = new StreamerCtrlThread( this );
                }
                else {
                        wxMessageDialog dlg1( this, wxT( "Server is not running" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();

                        delete m_streamer_thread;
                        m_streamer_thread = new StreamerCtrlThread( this );
                }
        }
        else {  
                wxMessageDialog dlg1( this, wxT( "Server is not running" ), wxT( "Info" ), wxOK );
                dlg1.ShowModal();
        }
}


void MainFrame::OnMenuitemActionsStopReceivingClick( wxCommandEvent& event )
{
        if ( m_receiver_thread != NULL ) {
                if ( m_receiver_thread->isReceiving() ) {
                        m_receiver_thread->StopReceiving();

                        PrintStatusBarMessage( wxT( "Receiving stopped" ), 1 );
                }
                else {
                        wxMessageDialog dlg1( this, wxT( "Receiver is not running" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();

                        delete m_receiver_thread;
                        m_receiver_thread = new ReceiverCtrlThread( this );
                }
        }
        else {  
                wxMessageDialog dlg1( this, wxT( "Receiver is not running" ), wxT( "Info" ), wxOK );
                dlg1.ShowModal();
        }
}


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

void MainFrame::PrintStatusBarMessage( const wxChar* message, int field /* = 0 */) 
{       
        m_status_bar->SetStatusText( message, field );
}

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

void MainFrame::OnStreamerCtrlThreadEnd() 
{
        PrintStatusBarMessage( wxT( "Streaming stopped" ), 0 );

        // important!: set to null our class, so that we can recreate it when necessary
        m_streamer_thread = NULL;
}


void MainFrame::reset_displayed_image_vector () 
{       
        // we'll free every DisplayImageFrame here.
        int vec_size = (int)_displayed_frames->size();
        for ( int i = 0; i < vec_size; i++ ) {
                _displayed_frames->at( i )->Close ();
        }

        // clear them all 
        _displayed_frames->clear();
}

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

void MainFrame::OnReceiverCtrlThreadEnd() 
{
        // provide a stop for the face_detecting/tracking class if it's available
        if ( face_detect ) {
                if ( gcard_use == true ) {
                        if ( ctrl_gcard ) {
                                ctrl_gcard->loop_stop();

                                delete ctrl_gcard;
                                ctrl_gcard = NULL;
                        }

                        if ( ctrl_vr_gcard ) {
                                ctrl_vr_gcard->loop_stop();

                                delete ctrl_vr_gcard;
                                ctrl_vr_gcard = NULL;
                        }
                }
                else {
                        if ( ctrl_lookup ) {
                                ctrl_lookup->loop_stop();

                                delete ctrl_lookup;
                                ctrl_lookup = NULL;
                        }
                        if ( ctrl_vr_lookup ) {
                                ctrl_vr_lookup->loop_stop();

                                delete ctrl_vr_lookup;
                                ctrl_vr_lookup = NULL;
                        }

                }

                ctrl_initialized = false;
                face_detect = false;
        }

        // important!: set to null our class, so that we can recreate it when necessary
        m_receiver_thread = NULL;

        reset_displayed_image_vector();

        clear_garbage_collector_for_images();

        video_received_window = false;
}


void MainFrame::OnAudioFrameReceivedFromNet( wxCommandEvent& event ) 
{       
}

void MainFrame::destroy_garbage_collector_for_images() 
{

        // call this to be sure there'll not be any mem leak.
        clear_garbage_collector_for_images ();

        
        // we're going to destroy the the lists and the vector

        int tmp_size = (int)_gc_images->size();
        for (int i=0; i < tmp_size; i++) {
                list<IplImage*>* tmp_list;
                                
                tmp_list = _gc_images->at(i);
                tmp_list->clear();
                delete tmp_list;
        }

        delete _gc_images;
        _gc_images = NULL;
}


void MainFrame::clear_garbage_collector_for_images() 
{
        // we're going to destroy the images but NOT the lists.
        // see destroy_garbage_collector_for_images for that.
        int tmp_size = (int)_gc_images->size();
        for (int i=0; i < tmp_size; i++) {
                list<IplImage*>* tmp_list;
                                
                tmp_list = _gc_images->at(i);

                while (tmp_list->size() > 0) {
                        cvReleaseImage( &tmp_list->front());
                        tmp_list->pop_front();
                }
        }
}

void MainFrame::manage_garbage_collector_for_images( IplImage *image, int stream_id ) 
{
        // build the vector node, a list, if it doesn't exist.
        if ( (int)_gc_images->size() < (stream_id +1) ) {
                list<IplImage*>* tmp_node; 

                for ( int i = (int)_gc_images->size(); i < (stream_id +1); i++) {
                        tmp_node = new list<IplImage*>;

                        // save it in the vector
                        _gc_images->push_back( tmp_node );
                }
        }
        
        list<IplImage*> *list_at_id;
        list_at_id = _gc_images->at( stream_id );

        // add the image to the list at vector[stream_id]
        list_at_id->push_back( image );

        // check the size of that list. If it's > 3 we will release that image.
        if ( list_at_id->size() > 3 ) {
                // remove from the list the first element, then release 
                IplImage *tmp_image;
                tmp_image = list_at_id->front();
                
                list_at_id->pop_front();

                cvReleaseImage( &tmp_image );
        }
}


void MainFrame::on_display_image_cb ( IplImage* image_received, int stream_id, 
                                                           char* window_id, void* callback_data ) 
{
        MainFrame * klass;

        if ( callback_data == NULL )
                return;

        klass = (MainFrame*)callback_data;

        if ( (int)klass->_displayed_frames->size() < (stream_id +1) ) {
                DisplayImageFrame *df;
                for ( int i = (int)klass->_displayed_frames->size(); i < (stream_id +1); i++) {
                        df = new DisplayImageFrame( klass, i, wxSize(image_received->width, 
                                image_received->height) );
                   
                        // save it in the vector
                        klass->_displayed_frames->push_back( df );
                }
        }
        klass->_displayed_frames->at(stream_id)->DisplayIplImage( image_received );
        klass->manage_garbage_collector_for_images( image_received, stream_id );
        
}

void MainFrame::on_destroy_image_cb ( char* window_id, void* callback_data )
{
}

void MainFrame::on_create_image_cb ( char* window_id, void* callback_data )
{
}

//--------------------------------------------------------------------------
// it will receive events from other threads. Doing so we can assure that a 
// clean paint from the *main_gui_thread* is performed.

void MainFrame::OnImageReceivedFromNet( wxCommandEvent& event ) 
{
        image_received_data_t *img_data_struct;
        IplImage *image_received;
        int stream_id;

#ifdef __LINUX__
        wxMutexLocker( *this->_paint_mutex );
#endif
        img_data_struct = (image_received_data_t *)event.GetClientData();

        if ( img_data_struct == NULL )
                return;
        
        
        image_received = img_data_struct->image;
        stream_id = img_data_struct->stream_id;

        //
        // MULTI STREAM
        //
        if ( this->num_streams > 0 ) {
                // NOTE: the streams must have all the same format width x height
                if ( (int)_displayed_frames->size() < (stream_id +1) ) {
                        DisplayImageFrame *df;
                        for ( int i = (int)_displayed_frames->size(); i < (stream_id +1); i++) {
                                df = new DisplayImageFrame( this, i, wxSize(image_received->width, 
                                        image_received->height) );
                    
                                // save it in the vector
                                _displayed_frames->push_back( df );
                        }
                }
                _displayed_frames->at(stream_id)->DisplayIplImage( image_received );
                manage_garbage_collector_for_images( image_received, stream_id );
                delete img_data_struct;
        }
        else {
                //
                //      SINGLE STREAM
                //

                // clean and simple webcam stream
                if ( !face_detect ) {
                        if ( video_received_window == false ) {
                                DEBUG_PRINT ( "creating Video received window\n" );
                                DisplayImageFrame *df;
                                if ( _displayed_frames->size() == 0 ) {
                                        // create a new frame where to display stream
                                        df = new DisplayImageFrame( this, stream_id, wxSize(image_received->width, 
                                                image_received->height) );
                   
                                        df->Show();
                                        // save it in the vector
                                        _displayed_frames->push_back( df );
                                }
                                else {
                                        // FIXME should we check for a right size of DiplayImageFrame here?
                                        _displayed_frames->at(0)->Show();
                                }

                                video_received_window  = true;
                        }
                        _displayed_frames->at(0)->DisplayIplImage( image_received );

                        manage_garbage_collector_for_images( image_received, stream_id );
                        delete img_data_struct;
                }
                else  {                 // omnidirectional stuff

                        // NOTE: the streams must have all the same format width x height
                        if ( (int)_displayed_frames->size() < (stream_id +1) ) {
                                DisplayImageFrame *df;
                                for ( int i = (int)_displayed_frames->size(); i < (stream_id +1); i++) {
                                        df = new DisplayImageFrame( this, i, wxSize(image_received->width, 
                                                image_received->height) );
                    
                                        // save it in the vector
                                        _displayed_frames->push_back( df );
                                }
                        }
                        _displayed_frames->at(stream_id)->DisplayIplImage( image_received );
                        manage_garbage_collector_for_images( image_received, stream_id );
                        delete img_data_struct;
                }
        }
#ifdef __LINUX__
        // Faith mysteries.........
        Update();       
#endif
        return;
}


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

void MainFrame::SetFacetrackOptions( wxArrayString* cascade_array, int cascade_count, int radius_min, 
                                                                        int radius_max, int center_x, int center_y, int freeze_frame_bound, 
                                                                        double track_window_hitrate, bool gcard_use, bool flipped_mode, 
                                                                        int num_streams /* = -1 */,     bool algo_simple /* = true */) 
{
        // calling this function automatically sets true the face detecting
        face_detect = true;
        
        this->cascade_array = cascade_array;
        this->cascade_size = cascade_count;
        this->radius_min = radius_min;
        this->radius_max = radius_max;
        this->center_x = center_x;
        this->center_y = center_y;
        this->freeze_frame_bound = freeze_frame_bound;
        this->track_window_hitrate = track_window_hitrate;
        this->gcard_use = gcard_use;
        this->flipped_mode = flipped_mode;
        this->num_streams = num_streams;
        this->algo_simple = algo_simple;
}



void MainFrame::OnMenuHelpAuthorsClick( wxCommandEvent& event )
{
    // Before editing this code, remove the block markers.
    AboutDialog* window = new AboutDialog(NULL, ID_AUTHORS_DIALOG, _("Authors"));
    window->Show(true);
}
 

void MainFrame::OnMenuHelpVersionClick( wxCommandEvent& event )
{
    // Before editing this code, remove the block markers.
    VersionDialog* window = new VersionDialog(NULL, ID_VERSION_DIALOG, _("Dialog"));
    window->Show(true);
}


void MainFrame::OnWorkerEvent( wxCommandEvent& event ) 
{

        wxString str = event.GetString();

        wxMessageDialog dlg( this, str, wxT( "Info" ), wxOK );
                
        dlg.ShowModal();
}


int MainFrame::GetMaxRadius()
{
        return radius_max;
}

int MainFrame::GetMinRadius()
{
        return radius_min;
}

int MainFrame::GetCenterX()
{
        return center_x;
}

int MainFrame::GetCenterY()
{
        return center_y;
}

wxArrayString* MainFrame::GetCascadeArray ()
{
        return cascade_array;
}

int MainFrame::GetFreezeFrameBound()
{
        return freeze_frame_bound;
}

double MainFrame::GetTrackWindowHitrate()
{
        return track_window_hitrate;
}

int MainFrame::GetCascadeSize ()
{
        return cascade_size;
}

bool MainFrame::GetAlgoSimpleStatus()
{
        return algo_simple;
}

bool MainFrame::is_face_detect_options_set ()
{
        return face_detect;
}

bool MainFrame::GetGCardUseStatus()
{
        return gcard_use;
}

bool MainFrame::GetFlippedModeStatus()
{
        return flipped_mode;
}

---