psycho-constellation.C

Go to the documentation of this file.

/*!@file GameBoard/psycho-constellation.C Psychophysics main application for constellation concept learning 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-06-16 16:14:27Z nnoori $
//written by Nader Noori

//
#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 "AppPsycho/psycho-skin-mapgenerator.h"
#include <sstream>
#include "basic-graphics.H"

using namespace std;

ModelManager manager("Psycho Parallel Search");
nub::soft_ref<PsychoDisplay> d(new PsychoDisplay(manager));
bool programQuit = false ;
map<string,Uint32> colorMap ;
int targetExposure ;
int emptyTime ;
int vx , vy ;
//////////////////////////////////////////
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 getStaticResponse(){

//         int c = -1;
//         int conf = -1 ;
//         int quit = -1 ;
//         do{
//                 //
//                 c = -1 ;
//                 while( c!=49 && c!=50 ){
//                         c = d->waitForKey();
//                         d->pushEvent("subject decided to report");
//                         d->clearScreen() ;
//                         if(c!=49 && c!=50  ){
//                                 d-> displayText("Press 1 for 'yes', 2 for 'no'");
//                         }
//                 }
//                 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 ;
//         }
        return 0 ;

}


         //////////////////////////////////////////
// Here we collect subjects response
uint getDynamicResponse(int c = -1){

//         //d->clearScreen();
//         int conf = -1 ;
//         int quit = -1 ;
//         do{
//
//                 while( c!=49 && c!=50 ){
//                         d-> displayText("Press 1 for 'yes', 2 for 'no'");
//                         c = d->waitForKey();
//                         d->pushEvent("subject decided to report");
//                 }
//                 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() ;
//                         }
//                 }
//                 c = -1 ;
//         }while(conf!=32) ;
//
//         if( c == 49 ){
//                 d->pushEvent("positive identification confirmed");
//                 return 1 ;
//         } else {
//                 d->pushEvent("negative identification confirmed");
//                 return 0 ;
//         }
        return 0 ;
}

////////////////////////////////////

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


/////////////////////////////////////////////
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,2).compare("vx")==0 ){
//                         string::size_type position = line.find("=") ;
//                         char rf[10] ;
//                         strcpy(rf,line.substr(position+1).c_str());
//                         vx = atoi(rf);
//                 }
//                 if( line.substr(0,2).compare("vy")==0 ){
//                         string::size_type position = line.find("=") ;
//                         char rf[10] ;
//                         strcpy(rf,line.substr(position+1).c_str());
//                         vy = atoi(rf);
//                 }
//
//                 if( line.substr(0,4).compare("color:")==0 ){
//                         string::size_type colPos = line.find(":") ;
//                         string::size_type eqPos = line.find("=") ;
//                         string colorName = line.substr(colPos+1,eqPos-colPos-1) ;
//                         string colorStr = line.substr(eqPos+1);
//                         string::size_type uPos = colorStr.find("_");
//                         string redString = colorStr.substr(0,) ;
//                         skinFileMap[skinName] = path ;
//                 }
//
//         }
//         return 0 ;
        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();
}
/////////////////////////////////////////
uint showDynamicSlide(Matrix& theMap , map<string,SDL_Surface*>& cmap ){
//         int cs = theMap.getNumOfColumns();
//         int rs = theMap.getNumOfRows() ;
//         map<string , int> clipNumMap;
//         int imageWidth = -1 ;
//         int imageHeigth = -1 ;
//         int pw = 0 ;
//         int maxForPhase = 0;
//         //int sT = 100 ;
//         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);
//         string cname("") ;
//         int key = -1 ;
//         int counter = 0 ;
//         while( key < 0 ){
//                 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->pushEvent("displaying frame "+ stringify(counter));
//                 d->displaySDLSurfacePatch(nbg , &offset,NULL , -2,true, true);
//                 counter++;
//                 key = d->checkForKey();
//                 if( key!=-1 ) {
//                         d->pushEvent("subject decided to report");
//                         d->clearScreen();
//                         break ;
//                 }
//         }
//
//         delete phaseMatrix;
//         delete theClip;
//         SDL_FreeSurface(nbg);
//         return key ;
        return 0 ;
}

/////////////////////////////////////////
void showStaticSlide(Matrix& theMap , map<string,SDL_Surface*>& cmap ){
//         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->pushEvent("displaying the test image");
//         d->displaySDLSurfacePatch(nbg , &offset,NULL , -2,false, true);
//         SDL_FreeSurface(nbg);
//         delete theClip;
}
/////////////////////////////////////////////
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 ;
//         bool staticFlag = true ;
//         bool pureFlag = true ;
//         char ch[1000];
//         bool trainingFlag = false ;
//         bool pureFlag = true ;
//         string trainingMessage("") ;
//         vector<string>* messages = new vector<string>() ;
//         vector<string>* exclusionList = new vector<string>();
//         float minAccuracy = 0 ;
//         float minSensitivity = 0 ;
//         int minPositiveCase = 75;
//
//         /*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("mixed")==0) {
//                         pureFlag = false ;
//                         d ->pushEvent("mixed stimuli");
//                 }
//
//                 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("minimum_positive")==0){
//                         string::size_type position = line.find("=");
//                         char rf[10] ;
//                         strcpy(rf,line.substr(position+1).c_str());
//                         minPositiveCase = atoi(rf);
//                 }
//
//                 if( line.substr(0,12).compare("min_accuracy")==0 ){
//                         string::size_type position = line.find("=");
//                         char rf[10] ;
//                         strcpy(rf,line.substr(position + 1 ).c_str());
//                         minAccuracy = atof(rf);
//                 }
//                 if( line.substr(0,15).compare("min_sensitivity")==0 ){
//                         string::size_type position = line.find("=");
//                         char rf[10] ;
//                         strcpy(rf,line.substr(position + 1 ).c_str());
//                         minSensitivity = 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() ;
//
//         /*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
// */
//         int positiveCases = 0 ;
//         vector<int>* experiment = new vector<int>();
//         vector<int>* report = new vector<int>();
//         float sensitivity = 0.0f;
//         float accuracy = 0.0f ;
//         do{
//
//
//                 /*here we start different trials and we will have as many as block_size trials*/
//                 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 ){
//
//                         if(pureFlag){
//                                 mapsVector =  getPureMapsWithExactPatternAndExactChannel(rows,columns,NUMBER_OF_CLASSES , patternChannel+1,*patternMatrix,1,1);
//                         }else{
//                                 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-> push_back(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 -> push_back(0) ;
//                         positiveFalg = false ;
//                 }
//                 if( positiveFalg ) positiveCases++ ;
//                 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*/
//
//                 if( staticFlag ){
//                         showStaticSlide(*map,*classesMap );
//                         report->push_back(getStaticResponse());
//                 } else {
//                         int resp = showDynamicSlide(*map,*classesMap);
//                         report->push_back(getDynamicResponse(resp));
//                 }
//
//
//         /*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 ;
//                 vector<int>::size_type trialSize = experiment->size() ;
//                 for( uint i = 0 ; i < trialSize ; 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) ;
//
//
//                 d->pushEvent("positiveCases:%s"+stringify(positiveCases)+"  minPositiveCase:"+stringify(minPositiveCase));
//                 d->pushEvent("accuracy:%s"+stringify(accuracy)+"   minAccuracy:"+stringify(minAccuracy)) ;
//                 d->pushEvent("sensitivity:%s"+stringify(sensitivity)+"    minSensitivity"+stringify(minSensitivity));
//
//         }while( sensitivity < minSensitivity || accuracy < minAccuracy || positiveCases < minPositiveCase );
//
//         string reportString("") ;
//         string experimentString("");
//         for(uint i = 0 ; i < experiment->size() ; i++){
//                 experimentString += stringify((*experiment)[i]) ;
//                 reportString += stringify((*report)[i]) ;
//         }
//         d->pushEvent("experiment string :" + experimentString);
//         d->pushEvent("report string:" + reportString) ;
//
//         /*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);
//         }
//         delete classesMap;
//         delete rawPattenMatrix;
//         delete vars;
//         delete messages;
//         delete exclusionList;
//         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;
        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) ;
}

#endif // INVT_HAVE_LIBSDL_IMAGE