psycho-skin-bsindexing.C

/*!@file AppPsycho/psycho-skin-bsindexing.c Psychophysics main application for indexing experiment */

// //////////////////////////////////////////////////////////////////// //
// The iLab Neuromorphic Vision C++ Toolkit - Copyright (C) 2001 by the //
// University of Southern California (USC) and the iLab at USC.         //
// See http://iLab.usc.edu for information about this project.          //
// //////////////////////////////////////////////////////////////////// //
// Major portions of the iLab Neuromorphic Vision Toolkit are protected //
// under the U.S. patent ``Computation of Intrinsic Perceptual Saliency //
// in Visual Environments, and Applications'' by Christof Koch and      //
// Laurent Itti, California Institute of Technology, 2001 (patent       //
// pending; application number 09/912,225 filed July 23, 2001; see      //
// http://pair.uspto.gov/cgi-bin/final/home.pl for current status).     //
// //////////////////////////////////////////////////////////////////// //
// This file is part of the iLab Neuromorphic Vision C++ Toolkit.       //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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.     //
//                                                                      //
// The iLab Neuromorphic Vision C++ Toolkit 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 the iLab Neuromorphic Vision C++ Toolkit; if not, write   //
// to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,   //
// Boston, MA 02111-1307 USA.                                           //
// //////////////////////////////////////////////////////////////////// //
//
// Primary maintainer for this file: Laurent Itti <itti@usc.edu>
//
// 2008-02-20 16:14:27Z nnoori $
//

#ifndef INVT_HAVE_LIBSDL_IMAGE

#include <cstdio>
int main()
{
  fprintf(stderr, "The SDL_image library must be installed to use this program\n");
  return 1;
}

#else



/*
Attention: SDL_image is needed for linking

*/

#include "Component/ModelManager.H"
#include "Image/Image.H"
#include "Psycho/PsychoDisplay.H"
#include "Psycho/EyeTrackerConfigurator.H"
#include "Psycho/EyeTracker.H"
#include "Psycho/PsychoOpts.H"
#include "Component/EventLog.H"
#include "Component/ComponentOpts.H"
#include "Raster/Raster.H"
#include "Util/MathFunctions.H"
#include "Util/Types.H"
#include <iostream>
#include <fstream>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include "psycho-skin-resize.h"
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include <time.h>
#include "psycho-skin-mapgenerator.h"
#include <sstream>


using namespace std;

ModelManager manager("Psycho Skin");
nub::soft_ref<PsychoDisplay> d(new PsychoDisplay(manager));
bool programQuit = false ;
map<string,string> skinFileMap ;
const int NUMBER_OF_CLASSES = 6;
const int IMAGE_WIDTH = 128 ;
const string classes[NUMBER_OF_CLASSES]={"class1","class2","class3","class4","class5","class6"};
int targetExposure ;
int emptyTime ;
//////////////////////////////////////////
int emergencyExit(){
        time_t rawtime;
        time ( &rawtime );
        LINFO("...emergencyExit called @%s .", ctime( &rawtime ));
        d->pushEvent(std::string("experiment ended at ")+ ctime( &rawtime ) );
        manager.stop();
        return -1;
}


//////////////////////////////////////////
// Here we collect subjects response
uint getResponse(){

        int c = -1;
        int conf = -1 ;
        int quit = -1 ;
        do{
                d-> displayText("Press 1 for 'yes', 2 for 'no'");
                c = -1 ;
                while( c!=49 && c!=50 ){
                        c = d->waitForKey();
                }
                if( c == 49){
                        d-> displayText("You chose 'yes' press space-bar to confirm");
                } else {
                        d-> displayText("You chose 'no' press space-bar to confirm");
                }
                conf = d-> waitForKey() ;
                if( conf == 127){
                        quit =  d-> waitForKey() ;
                        if( quit == 127 ){
                                emergencyExit() ;
                        }
                }
        }while(conf!=32) ;

        if( c == 49 ){
                d->pushEvent("positive identification confirmed");
                return 1 ;
        } else {
                d->pushEvent("negative identification confirmed");
                return 0 ;
        }
}

/////////////////////////////////////////////
SDL_Surface *load_image( string filename )
{
        //The image that's loaded
        SDL_Surface* loadedImage = NULL;

        //The optimized image that will be used
        SDL_Surface* optimizedImage = NULL;

        //Load the image
        loadedImage = IMG_Load( filename.c_str() );

        //If the image loaded
        if( loadedImage != NULL )
        {
        //Create an optimized image
        optimizedImage = SDL_DisplayFormat( loadedImage );

        //Free the old image
        SDL_FreeSurface( loadedImage );

        //If the image was optimized just fine
        if( optimizedImage != NULL )
        {
                //Map the color key
                Uint32 colorkey = SDL_MapRGB( optimizedImage->format, 0, 0xFF, 0xFF );

                //Set all pixels of color R 0, G 0xFF, B 0xFF to be transparent
                SDL_SetColorKey( optimizedImage, SDL_SRCCOLORKEY, colorkey );
        }
        }else{
                emergencyExit() ;
        }

        //Return the optimized image
        return optimizedImage;
}
///////////////////////////////////

SDL_Surface *getAFreshSurface(int w ,  int h){

        SDL_Surface *sur = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32,
                                        0x00000000, 0x00000000, 0x00000000, 0x00000000);

        return sur ;

}
////////////////////////////////////

template <class T>
string stringify(T &i)
{
        ostringstream o ;
        o << i ;
        return o.str();
}

///////////////////////////////////
void dumpSurface(SDL_Surface& surface){
        SDL_FreeSurface( &surface );
}
/////////////////////////////////////////////
void apply_surface( int x, int y, SDL_Surface& source, SDL_Surface& destination , SDL_Rect& clip )
{
        //Make a temporary rectangle to hold the offsets
        SDL_Rect offset;

        //Give the offsets to the rectangle
        offset.x = x;
        offset.y = y;

        //Blit the surface
        SDL_BlitSurface( &source, &clip, &destination, &offset );
}
/////////////////////////////////////////////
int readTop(ifstream& inFile){
        char ch[1000] ;
        while( inFile.getline(ch , 1000) ){
                string line  = ch ;
                LINFO("reads : %s" , line.c_str()) ;
                if( line.compare("end_top") == 0 ) break;
                if( line.substr(0,4).compare("skin")==0 ){
                        string::size_type position = line.find("=") ;
                        string skinName = line.substr(0,position) ;
                        string path = line.substr(position+1) ;
                        skinFileMap[skinName] = path ;
                }
                if( line.substr(0,15).compare("target_exposure")==0 ){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        targetExposure = atoi(rf);
                        d->pushEvent(line.c_str());
                }
                if( line.substr(0,10).compare("empty_time")==0 ){
                        string::size_type position = line.find("=") ;
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        emptyTime = atoi(rf);
                }

        }
        return 0 ;
}
/////////////////////////////////////////////
void showStaticTarget(Matrix& pattern , SDL_Surface* classSkin){
        int pw = classSkin->w;
        int ph = classSkin->h ;
        SDL_Rect theClip ;
        theClip.x = 0 ;
        theClip.y = 0 ;
        theClip.w = pw ;
        theClip.h = pw ;
        SDL_Surface* blankSurface = getAFreshSurface(pw*pattern.getNumOfColumns(),pw*pattern.getNumOfRows());
        int nv = ph / pw ;
        for( int r = 0 ; r < pattern.getNumOfRows() ; r++){
                for( int c = 0 ; c < pattern.getNumOfColumns() ; c++){
                        if( pattern.get(r,c)== 1 ){
                                theClip.y = (rand()%nv)*pw ;
                                apply_surface(c*pw,r*pw, *classSkin , *blankSurface ,theClip)        ;
                        }
                }
        }
        d->clearScreen();
        SDL_Rect offset;

                    //Give the offsets to the rectangle
        offset.x = (d->getWidth() - blankSurface->w) /2;
        offset.y = (d-> getHeight() - blankSurface->h) /2;
        d->displaySDLSurfacePatch(blankSurface , &offset,NULL , -2,false, true);
        d->waitFrames(targetExposure);
        SDL_FreeSurface(blankSurface);
        theClip.~SDL_Rect();
}
/////////////////////////////////////////
void showDynamicTarget(Matrix& pattern , SDL_Surface* classSkin){
        int pw = classSkin->w;
        int ph = classSkin->h ;
        SDL_Rect theClip ;
        theClip.x = 0 ;
        theClip.y = 0 ;
        theClip.w = pw ;
        theClip.h = pw ;
        SDL_Surface* blankSurface = getAFreshSurface(pw*pattern.getNumOfColumns(),pw*pattern.getNumOfRows());
        int nv = ph / pw ;
        Matrix* phaseMatrix = getARandomMap(pattern.getNumOfRows(),pattern.getNumOfColumns(),nv) ;
        int counter = 0 ;
        while(counter < targetExposure  ){
                for( int r = 0 ; r < pattern.getNumOfRows() ; r++){
                        for( int c = 0 ; c < pattern.getNumOfColumns() ; c++){
                                if( pattern.get(r,c)== 1 ){
                                        theClip.y = ((counter+phaseMatrix->get(r,c)) %nv)*pw ;
                                        apply_surface(c*pw,r*pw, *classSkin , *blankSurface ,theClip)        ;
                                }
                        }
                }


                SDL_Rect offset;

                    //Give the offsets to the rectangle
                offset.x = (d->getWidth() - blankSurface->w) /2;
                offset.y = (d-> getHeight() - blankSurface->h) /2;
                d->displaySDLSurfacePatch(blankSurface , &offset,NULL , -2,true, true);
                counter++;
        }

        SDL_FreeSurface(blankSurface);
        phaseMatrix->~Matrix();
        theClip.~SDL_Rect();
}
/////////////////////////////////////////
void showDynamicSlide(Matrix& theMap , map<string,SDL_Surface*>& cmap, int sT ){
        int cs = theMap.getNumOfColumns();
        int rs = theMap.getNumOfRows() ;
        map<string , int> clipNumMap;
        int imageWidth = -1 ;
        int imageHeigth = -1 ;
        int pw = 0 ;
        int maxForPhase = 0;

        for( map<string,SDL_Surface*>:: iterator it = cmap.begin() ; it != cmap.end() ; ++it ){
                string clName = it->first ;
                SDL_Surface* surf = it->second;
                int numOfClips = (surf->h) / (surf->w);
                clipNumMap[clName] = numOfClips;
                maxForPhase = max(maxForPhase,numOfClips);
                if(imageWidth == -1){
                        pw = surf->w ;
                        imageWidth = theMap.getNumOfColumns()*pw ;
                        imageHeigth = theMap.getNumOfRows()*pw ;
                }

        }
        Matrix* phaseMatrix = getARandomMap(rs,cs,maxForPhase) ;

        SDL_Rect* theClip = new SDL_Rect();
        theClip->x = 0 ;
        theClip->y = 0 ;
        theClip->w = pw ;
        theClip->h = pw ;
        //
        SDL_Surface* nbg = getAFreshSurface(imageWidth,imageHeigth);
        int counter = 0 ;
        string cname("") ;
        while( counter < sT ){
                for( int r = 0 ; r < rs ; r++){
                        for( int c = 0 ; c < cs ; c++){
                                switch( theMap.get(r,c) ){
                                        case 1 : cname = "class1" ;break ;
                                        case 2 : cname = "class2" ; break ;
                                        case 3 : cname = "class3" ; break ;
                                        case 4 : cname = "class4" ; break ;
                                        case 5 : cname = "class5" ; break ;
                                        case 6 : cname = "class6" ; break ;
                                }
                                SDL_Surface* csurf = cmap[cname] ;
                                int y = ( (counter+phaseMatrix->get(r,c)) % clipNumMap[cname])*pw;
                                theClip->y = y ;
                                apply_surface(c*pw,r*pw, *csurf , *nbg ,*theClip)        ;
                        }
                }
                //d->clearScreen();
                SDL_Rect offset;
                offset.x = (d->getWidth() - nbg->w) /2;
                offset.y = (d-> getHeight() - nbg->h) /2;
                d->displaySDLSurfacePatch(nbg , &offset,NULL , -2,true, true);
                counter++ ;
        }

        phaseMatrix->~Matrix();
        theClip->~SDL_Rect();
        SDL_FreeSurface(nbg);

}

/////////////////////////////////////////
void showStaticSlide(Matrix& theMap , map<string,SDL_Surface*>& cmap, int sT ){
        d->pushEvent("exposure time will be "+stringify(sT));
        int cs = theMap.getNumOfColumns();
        int rs = theMap.getNumOfRows() ;
        map<string , int> clipNumMap;
        int imageWidth = -1 ;
        int imageHeigth = -1 ;
        int pw = 0 ;

        for( map<string,SDL_Surface*>:: iterator it = cmap.begin() ; it != cmap.end() ; ++it ){
                string clName = it->first ;
                SDL_Surface* surf = it->second;
                int numOfClips = (surf->h) / (surf->w);
                clipNumMap[clName] = numOfClips;
                if(imageWidth == -1){
                        pw = surf->w ;
                        imageWidth = theMap.getNumOfColumns()*pw ;
                        imageHeigth = theMap.getNumOfRows()*pw ;

                }

        }
        SDL_Rect* theClip = new SDL_Rect();
        theClip->x = 0 ;
        theClip->y = 0 ;
        theClip->w = pw ;
        theClip->h = pw ;
        //
        SDL_Surface* nbg = getAFreshSurface(imageWidth,imageHeigth);
        for( int r = 0 ; r < rs ; r++){
                for( int c = 0 ; c < cs ; c++){
                        const int ti = theMap.get(r,c);
                        string cname = "class"+stringify(ti);
                        SDL_Surface* csurf = cmap[cname] ;
                        int y = (rand() % clipNumMap[cname])*pw;
                        theClip->y = y ;
                        apply_surface(c*pw,r*pw, *csurf , *nbg ,*theClip)        ;
                }
        }
        d->clearScreen();
        SDL_Rect offset;
        offset.x = (d->getWidth() - nbg->w) /2;
        offset.y = (d-> getHeight() - nbg->h) /2;
        d->clearScreen();
        d->displaySDLSurfacePatch(nbg , &offset,NULL , -2,false, true);
        d->waitFrames(sT);
        SDL_FreeSurface(nbg);
        theClip->~SDL_Rect();
}
/////////////////////////////////////////////
void doStaticTraining( map<string,SDL_Surface*>& cmap,vector<string>& messages){
        d->pushEvent("training starts") ;
        d->displayText("Training Time! Press any key to start");
        d->showCursor(true);
        d->waitForKey() ;
        //////
        for( uint i = 0 ; i< messages.size() ; i++){
                d->displayText(messages[i]);
                d->pushEvent("displayed training message : " + messages[i]);
                d->waitFrames(300);
        }

        /////
        d->pushEvent("training ends");
        //d->pushEvent("Congradulations! You are ready for the real test");
        d->waitFrames(45);
        d->displayText("Press any key to start!") ;
        d->waitForKey();
        //d->showCursor(false);
}

void doDynamicTraining( map<string,SDL_Surface*>& cmap,vector<string>& messages){
        d->pushEvent("training starts") ;
        d->displayText("Training Time! Press any key to start");
        d->showCursor(true);
        d->waitForKey() ;
        //////
        for( uint i = 0 ; i< messages.size() ; i++){
                d->pushEvent(messages[i]);
        }

        /////
        d->pushEvent("training ends");
        //d->pushEvent("Congradulations! You are ready for the real test");
        d->waitFrames(45);
        d->displayText("Press any key to start!") ;
        d->waitForKey();
        d->showCursor(false);
}
/////////////////////////////////////////////
int readBlock(ifstream& inFile){
        string block_name("") ;
        string pattern("") ;
        string skin_name("") ;
        int px = 0 ;
        int py = 0 ;
        int rows = 0 ;
        int columns = 0 ;
        float rf = 1.0f ;
        float prb = 0.5f ;
        int block_size = 20 ;
        int ie = 60 ;
        int skip_by = 100 ;
        bool staticFlag = true ;
        char ch[1000];
        float maxSen = 0.0f;
        float maxAcc = 0.0f;
        bool trainingFlag = false ;
        string trainingMessage("") ;
        vector<string>* messages = new vector<string>() ;
        vector<string>* exclusionList = new vector<string>();

        /*let's read attributes of the block*/
        while( inFile.getline(ch , 1000) ){
                string line = ch ;
                LINFO("reads : %s" , line.c_str()) ;

                if(line.compare("dynamic")==0) {
                        staticFlag = false ;
                }
                if(line.compare("end_block")==0) {
                        d -> pushEvent("ended reading block "+ block_name);
                        break ;
                }
                if( line.substr(0,10).compare("block_name") == 0 ){
                        string::size_type position = line.find("=") ;
                        block_name = line.substr(position+1) ;
                        d -> pushEvent("started reading block "+block_name) ;
                }

                if( line.substr(0,14).compare("target_pattern") == 0 ){
                        string::size_type position = line.find("=") ;
                        pattern = line.substr(position+1) ;
                        d -> pushEvent("target pattern "+pattern) ;
                }

                if( line.substr(0,16).compare("excluded_pattern") == 0 ){
                        string::size_type position = line.find("=") ;
                        string exPattern = line.substr(position+1);
                        exclusionList->push_back(exPattern ) ;
                        d -> pushEvent("excluded pattern "+exPattern) ;
                }

                if( line.substr(0,4).compare("skin") == 0 ){
                        string::size_type position = line.find("=") ;
                        skin_name = line.substr(position+1) ;
                }

                if(line.substr(0,2).compare("rf")==0){
                        string::size_type position = line.find("=");
                        char x[10] ;
                        strcpy(x,line.substr(position+1).c_str());
                        rf = atof(x);
                }
                if(line.substr(0,11).compare("probability")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        prb = atof(rf);
                }
                if(line.substr(0,2).compare("px")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        px = atoi(rf);
                }
                if(line.substr(0,2).compare("py")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        py = atoi(rf);
                }
                if(line.substr(0,2).compare("rs")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        rows = atoi(rf);
                }
                if(line.substr(0,2).compare("cs")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        columns = atoi(rf);
                }
                if(line.substr(0,16).compare("initial_exposure")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        ie = atoi(rf);
                }
                if(line.substr(0,8).compare("skip_exp")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        skip_by = atoi(rf);
                }
                if(line.substr(0,10).compare("block_size")==0){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position+1).c_str());
                        block_size = atoi(rf);
                }
                if( line.substr(0,15).compare("max_sensitivity")==0 ){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position + 1 ).c_str());
                        maxSen = atof(rf);
                }
                if( line.substr(0,12).compare("max_accuracy")==0 ){
                        string::size_type position = line.find("=");
                        char rf[10] ;
                        strcpy(rf,line.substr(position + 1 ).c_str());
                        maxAcc = atof(rf);
                }
                if( line.substr(0,16).compare("training_message")==0 ){
                        string::size_type position = line.find("=");
                        trainingFlag = true ;
                        trainingMessage = line.substr(position +1) ;
                        messages->push_back(trainingMessage);
                }

        }

        /*let's load up the sprites associated with the skin and resize them and store them in a map*/
        map<string,SDL_Surface*>* classesMap = new map<string,SDL_Surface*>();
        for( int i = 0 ; i < 6 ; i++ ){
                string filepath ;
                filepath += skinFileMap[skin_name]+"/"+classes[i]+"/ball.png" ;
                SDL_Surface* tmpSurface = load_image(filepath) ;
                tmpSurface = SDL_Resize(tmpSurface , rf , 6 );
                (*classesMap)[classes[i]] = tmpSurface;
        }

        /*now we find all Euclidean transormations of the patten and store them in a vector
        in every trial one of these pattens will be used (either included or excluded)
        */
        Matrix *rawPattenMatrix = getPattenByString(pattern) ;
        vector<Matrix*>* vars = getAllVariations(*rawPattenMatrix);
        int vs = vars->size() ;

        float maxSensitivity = 0.0f ;
        float maxAccuracy = 0.0f ;
        int exposureTime = ie ;

        /*Let's start training the subject*/
        d->displayText("Press any key to start!") ;
        d->waitForKey() ;
        if( trainingFlag ){
                if( staticFlag ){
                        doStaticTraining(*classesMap,*messages) ;
                } else {
                        doDynamicTraining(*classesMap,*messages) ;
                }

        }

        /*the real test starts here and unless the required sensitivity is reached or prbability of having
        positive cases it will continue
        */
        do{
                float sensitivity = 0.0f ;
                float accuracy = 0.0f ;
                int* experiment = new int[block_size] ;
                int* report = new int[block_size] ;

                /*here we start different trials and we will have as many as block_size trials*/
                for( int i = 0 ; i < block_size ; i++ ){
                        d->clearScreen();
                        d->displayText("Please wait!") ;
                        srand ( time(NULL) );
                        int patternChannel = rand()%NUMBER_OF_CLASSES ;
                        string targetClass = classes[patternChannel];
                        srand ( time(NULL) );
                        /*here we pick one of the transformed pattern to be used*/
                        Matrix *patternMatrix = (*vars)[rand()%vs] ;
                        vector<Matrix*>* mapsVector ;
                        bool positiveFalg = true ;

                        /*here we filp a coin to see if we include the pattern or exclude it*/
                        if( rand()%10000 < prb*10000 ){
                                mapsVector =  getMapsWithExactPattenAndExactChannel(rows,columns,NUMBER_OF_CLASSES , patternChannel+1,*patternMatrix,1,1);
                                /*we keep in mind that we chose to include the target in the board*/
                                experiment[i] = 1 ;
                        }else{
                                mapsVector =  getMapsWithExactPattenAndExactChannel(rows,columns,NUMBER_OF_CLASSES , patternChannel+1,*patternMatrix,0,1);
                                /*we keep in mind that we chose to exclude the target from the board*/
                                experiment[i] = 0 ;
                                positiveFalg = false ;
                        }

                        Matrix *map = (*mapsVector)[0] ;
                        d->pushEvent("class picked : " + targetClass) ;
                        d->pushEvent("pattern picked : "+patternMatrix->toFormattedString()) ;
                        d->pushEvent("map picked :" +map->toFormattedString());

                        /*now that we have picked the target patten and the board map let's start showing the
                        target
                        */
                        d->clearScreen();
                        d->pushEvent("started showing target image");
                        if( staticFlag ){
                                showStaticTarget(*patternMatrix,(*classesMap)[targetClass]) ;
                        } else {
                                showDynamicTarget(*patternMatrix,(*classesMap)[targetClass]) ;
                        }
                        /*we let's delay showing the board after the target*/
                        d->pushEvent("started showing blink");
                        d->displayFixationBlink(-1, -1, emptyTime/2, 2);
                        /*now that the target is shown we can show the board*/
                        d->pushEvent("started showing the test image");
                        if( staticFlag ){
                                showStaticSlide(*map,*classesMap , exposureTime );
                        } else {
                                showDynamicSlide(*map,*classesMap , exposureTime );
                        }
                        d->pushEvent("ended showing the test image");
                        /*let's ask the subject if s/he identified the target*/
                        report[i] = getResponse();
                        d->clearScreen();
                }

                /*now that we are done with trials let's do some book keeping and see what was subject's sensitivity and
                accuracy
                */
                float truePositives = 0.0f ;
                float trueNegatives = 0.0f ;
                float falsePositives = 0.0f ;
                float falseNegatives = 0.0f ;
                float positives = 0.0f ;
                float negatives = 0.0f ;
                string reportString("");
                string experimentString("");
                for( int i = 0 ; i < block_size ; i++ ){
                        reportString += stringify(report[i]) ;
                        experimentString += stringify( experiment[i]) ;
                        if( experiment[i]==1 && report[i]==1 ) {truePositives++ ; positives++ ; }
                        if( experiment[i]==1 && report[i]==0 ) {falseNegatives++ ; positives++ ; }
                        if( experiment[i]==0 && report[i]==1 ) {falsePositives++ ;negatives++ ; }
                        if( experiment[i]==0 && report[i]==0 ) {trueNegatives++ ; negatives++ ;}
                }
                if( positives != 0 ){
                        sensitivity = truePositives / positives ;
                }
                accuracy = (truePositives + trueNegatives) / (positives+negatives) ;
                maxSensitivity = max(sensitivity,maxSensitivity) ;
                maxAccuracy = max(accuracy,maxAccuracy);
                exposureTime += skip_by ;
                d->pushEvent("experiment srting : " + experimentString);
                d->pushEvent("report string : " + reportString);
                d->pushEvent("sensitivity : "+ stringify(sensitivity)) ;
                d->pushEvent("accuracy : " + stringify(accuracy));
        }while( maxSensitivity < maxSen || maxAccuracy < maxAcc  );


        /*and here we do necessary cleanups before finishing up the block*/
        for( map<string,SDL_Surface*>::iterator it=classesMap->begin() ; it!= classesMap->end() ; ++it){
                SDL_FreeSurface(it->second);
        }
        classesMap->~map<string,SDL_Surface*>();
        rawPattenMatrix->~Matrix();
        vars->~vector<Matrix*>() ;
        messages->~vector<string>() ;
        exclusionList->~vector<string>() ;
        d-> displayText("You may take a short break!") ;
        d->waitForKey() ;
        return 0 ;
}
/////////////////////////////////////////////
int readprofile(const char* filename){
        ifstream inFile(filename, ios::in);
        if (! inFile)
   {
           LINFO("profile '%s' not found!" , filename);
      return -1;
   }

   char ch[1000];
   while (inFile.getline(ch , 1000)){
           string line = ch;
           LINFO("reads : %s", line.c_str());
           if( line.substr(0,11).compare("profilename") == 0 ){
                   string::size_type position = line.find("=");
                   d -> pushEvent("profile  "+line.substr(position+1)+" started reading" ) ;
           }
           if(line.compare("start_top")==0 ) readTop(inFile);
           if(line.compare("start_block")==0) readBlock(inFile);
           if(programQuit == true) break ;
        }

        return 0 ;
}
/////////////////////////////////////////////


extern "C" int main( int argc, char* argv[] )

{

        MYLOGVERB = LOG_INFO;  // suppress debug messages

        manager.addSubComponent(d);
        nub::soft_ref<EventLog> el(new EventLog(manager));
        manager.addSubComponent(el);
        d->setEventLog(el);
          // Parse command-line:
        if (manager.parseCommandLine(argc, argv,"<profile.prf> <logfileName.psy>", 2, 2)==false)
        return(1);
         manager.setOptionValString(&OPT_EventLogFileName,manager.getExtraArg(1).c_str() );
        manager.start();
        d->clearScreen() ;
        readprofile(manager.getExtraArg(0).c_str());
        d->displayText("Experiment is done! Thanks for participating! ") ;
        d->waitForKey() ;
        manager.stop();
        return(0) ;
//         time_t rawtime;
//         time ( &rawtime );
//         LINFO("@%s psycho-skin-bsindexing started:...", ctime(&rawtime));
//         manager.start();
//         d->pushEvent(std::string("started the experiment at ")+ ctime( &rawtime ) );
//         SDL_Surface* free = getAFreshSurface(40,80) ;
//         SDL_Rect offset;
//             //Give the offsets to the rectangle
//         d->clearScreen();
//             offset.x = 100;
//             offset.y = 60;
//         d->displaySDLSurfacePatch(free,&offset,NULL , -2,false, true);
//         d->waitFrames(10);
//         ////////////////////////////
//         d->clearScreen();
//         offset.x = 100;
//             offset.y = 160;
//         d->displaySDLSurfacePatch(free , &offset,NULL , -2,false, true);
//         d->waitFrames(10);
//           d->displayText("Experiment complete. Thank you!");
//         //d->waitFrames(1);
//           //d->waitForKey();
//         time ( &rawtime );
//         LINFO("...psycho-skin-bsindexing ended @%s .", ctime( &rawtime ));
//         d->pushEvent(std::string("experiment ended at ")+ ctime( &rawtime ) );
//         manager.stop();
//
//         return 0 ;
}

#endif // INVT_HAVE_LIBSDL_IMAGE