def __init__(self): self.disp = libscreen.Display(monitor=MONITOR) self.mouse = libinput.Mouse(visible=True) self.keyboard = libinput.Keyboard( keylist=['space', 'left', 'right', 'lctrl', 'rctrl'], timeout=None) self.blank_screen = libscreen.Screen() self.intro_screen = libscreen.Screen() self.intro_screen.draw_text( text='During each trial, a cloud of moving dots is going to \ appear on the screen. Watch it carefully to detect \ whether the dots in general are moving to the left or \ to the right (click left mouse button to start)', fontsize=18) self.fixation_screen = libscreen.Screen() self.fixation_screen.draw_fixation(fixtype='cross', pw=3) self.initialize_ready_screen() self.initialize_stimulus_screen() self.initialize_feedback_screen() self.warning_sound = sound.Sound(1000, secs=0.1)
def ValidationFixation(self, screen, t): ''' Paramètres : screen : écran virtuel d'affichage t : temps de fixation en millisecondes Description : Permet d'afficher un point sur l'écran qui devient vert lorsque l'on regarde ce point et attendre de le fixer pendant "t" millisecondes. ''' tfix = 0 while tfix < t: # Tant que l'on regarde pas le cercle pendant 1 seconde newTime = libtime.get_time() gazepos = self.tracker.sample() # si l'individu ne regarde pas le point central if (gazepos[0] < self.norm_2_px( (0.44, 0.44))[0] or gazepos[0] > self.norm_2_px( (0.56, 0.56))[0]) and (gazepos[1] < self.norm_2_px( (0.44, 0.44))[1] or gazepos[1] > self.norm_2_px( (0.56, 0.56))[1]): screen = libscreen.Screen() #le cercle reste blanc screen.draw_circle(colour='white', pos=self.norm_2_px((0.5, 0.5)), r=40, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() tfix = 0 else: # si l'individu regarde le point central screen = libscreen.Screen() #Le cercle devient vert screen.draw_circle(colour='green', pos=self.norm_2_px((0.5, 0.5)), r=40, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() tfix += (libtime.get_time() - newTime) if self.kb.get_key(keylist=['space'], flush=False)[0]: screen.clear() self.disp.fill(screen=screen) self.disp.show() return () screen.clear()
def initialize_trial_end_screen(self): trial_end_screen = libscreen.Screen() self.points_earned_stim = visual.TextStim(pygaze.expdisplay, color='#F5F500', pos=(0, DISPSIZE[1] / 2 - 200), height=40) #fontsize=height trial_end_screen.screen.append(self.points_earned_stim) self.accumulated_points_stim = visual.TextStim( pygaze.expdisplay, color='#F5F500', #pos=(0,DISPSIZE[1]/2-400), height=30) trial_end_screen.screen.append(self.accumulated_points_stim) trial_end_instructions = visual.TextStim(pygaze.expdisplay, pos=(0, -DISPSIZE[1] / 2 + 100), color='#80FF40', text='CLICK TO CONTINUE', height=28) trial_end_screen.screen.append(trial_end_instructions) return trial_end_screen
def initialize_gamble_screen(self, loc='left'): response_button_pos = (self.response_button_pos_right if loc == 'right' else self.response_button_pos_left) img = self.right_response_image if loc == 'right' else self.left_response_image self.gamble_screen = libscreen.Screen() self.gamble_screen.screen.append(img) self.gamble_rects = [] for i, gamble in enumerate(self.gambles): pos=(response_button_pos[0], response_button_pos[1]-self.response_button_size[1]/2 - \ (i+0.5)*self.gamble_button_size[1]) rect = visual.Rect(win=pygaze.expdisplay, pos=pos, width=self.gamble_button_size[0], height=self.gamble_button_size[1], lineColor=(5, 5, 5), lineColorSpace='rgb255', fillColor=(255, 250, 250), fillColorSpace='rgb255') text = visual.TextStim(win=pygaze.expdisplay, pos=pos, text=gamble, height=36, color=(5, 5, 5), colorSpace='rgb255') self.gamble_screen.screen.append(rect) self.gamble_screen.screen.append(text) self.gamble_rects.append(rect)
def presentAGTrial(self,curTrial, getInput,AGTime): libtime.pause(self.ISI) self.experiment.disp.show() if curTrial['AGType']=="image": #create picture curPic=self.pictureMatrix[curTrial['image']][0] curPic.pos=(0,0) #build screen agScreen=libscreen.Screen(disptype='psychopy') buildScreenPsychoPy(agScreen, [curPic]) #wait 1 s libtime.pause(self.agWait1) #present screen setAndPresentScreen(self.experiment.disp, agScreen) #play audio playAndWait(self.soundMatrix[curTrial['audio']],waitFor=0) #display for rest of ag Time libtime.pause(AGTime) elif curTrial['AGType']=="movie": #load movie stim print(self.experiment.moviePath) print(curTrial['AGVideo']) mov = visual.MovieStim3(self.experiment.win, self.experiment.moviePath+curTrial['AGVideo']) while mov.status != visual.FINISHED: mov.draw() self.experiment.win.flip() #if getInput=True, wait for keyboard press before advancing if getInput: self.experiment.input.get_key()
def CDPInitialisation(self): self.findtracker = tr.find_all_eyetrackers() if self.findtracker == (): print("Veuillez réassayer, aucun EyeTracker détecté") return () self.filename = 0 self.baseFilename = 0 self.blackdisp = libscreen.Display(screennr=int( self.Config.getConfiguration('DISPLAY', 'screen_number'))) self.disp = libscreen.Display(screennr=int( self.Config.getConfiguration('DISPLAY', 'screen_number'))) self.blankscreen = libscreen.Screen() self.tracker = CDPProTracker( self.disp) # création de l'objet eyeTracker self.kb = Keyboard(keylist=['space', 'escape', 'q'], timeout=1) self.Visu = CDPBaseVisualisation(self) self.RecSound = libsound.Sound( soundfile=self.Config.getSoundDirname('2.wav')) self.ErrSound = libsound.Sound( soundfile=self.Config.getSoundDirname('punition.wav')) self.nameInd = 0 self.mydisp = [self.disp] print("Eyetracker connecté avec succès")
def intialize_message_screen(self, message_file, **kwargs): message_screen = libscreen.Screen() with open(message_file) as f: instructions = f.read() instructions_stim = visual.TextStim(self.win, text=instructions, units='pix', height=self.standard_text_heigth, **kwargs) message_screen.screen.append(instructions_stim) return message_screen
def show_block_end_screen(self, is_practice, accumulated_points): self.mouse.set_visible(True) self.block_end_screen = libscreen.Screen() block_end_text = \ '''You have completed this experimental block. \nYour score is %i points. \nClick left mouse button to proceed.''' % (accumulated_points) self.block_end_screen.draw_text(text=block_end_text, fontsize=18) self.disp.fill(self.block_end_screen) self.disp.show() self.mouse.get_clicked() libtime.pause(200)
def fonction_essai(self): ScreenVisage = libscreen.Screen() self.tracker.start_recording() ListeNomImg = [ '/home/eyetracker/Bureau/Program/Images/pizza.jpg', '/home/eyetracker/Bureau/Program/Images/ExpVisages/Image_Homme_2.bmp' ] cpt = 0 for Img in ListeNomImg: table = Workbook() gazePosSheet = table.active gazePosSheet.title = 'gazePos' gazePosSheet.append([ "Time", "XOeilDroit", "YOeilDroit", "XOeilGauche", "YOeilGauche", "xRetenu", "Yretenu", "Etat" ]) self.ValidationFixation(ScreenVisage, 1000) LisTOeilDroit = [] LisTOeilGauche = [] ListeOeilRetenu = [] temps = [] ScreenVisage.draw_image(image=Img) self.disp.fill(screen=ScreenVisage) self.disp.show() tdeb = libtime.get_time() oldTimeStamp = 0 while libtime.get_time() - tdeb < 10000: time.sleep(0.010) t = libtime.get_time() NewTimeStamp, Newgazepos = self.tracker.binocular_sample() if NewTimeStamp != oldTimeStamp: etat = self.etat_yeux(Newgazepos[0], Newgazepos[1]) gazePosSheet.append([ t, Newgazepos[0][0], Newgazepos[0][1], Newgazepos[1][0], Newgazepos[1][1], Newgazepos[2][0], Newgazepos[2][1], etat ]) oldTimeStamp = NewTimeStamp ScreenVisage.clear() self.disp.fill(screen=ScreenVisage) self.disp.show() table.save('/home/eyetracker/Bureau/' + self.nameInd + '_' + str(cpt) + '_Donnees.xls') cpt = 1 self.tracker.stop_recording()
def show_block_intro_screen(self, block_size, is_practice): self.mouse.set_visible(True) self.block_intro_screen = libscreen.Screen() block_type = 'practice' if is_practice else 'recorded' self.block_intro_screen.draw_text( text='You are about to start the block of %d %s trials.\ To start click left mouse button.' % (block_size, block_type), fontsize=18) self.disp.fill(self.block_intro_screen) self.disp.show() self.mouse.get_clicked() libtime.pause(200)
def initialize_feedback_screen(self): self.feedback_screen = libscreen.Screen() self.feedback_text = visual.TextStim(win=pygaze.expdisplay, colorSpace='rgb255', height=36) self.feedback_points_earned = visual.TextStim(win=pygaze.expdisplay, pos=(0, -100), colorSpace='rgb255', height=36) self.feedback_accumulated_points = visual.TextStim( win=pygaze.expdisplay, pos=(0, -175), height=36) self.feedback_screen.screen.append(self.feedback_text) self.feedback_screen.screen.append(self.feedback_points_earned) self.feedback_screen.screen.append(self.feedback_accumulated_points)
def show_end_experiment_screen(self, scores): self.mouse.set_visible(True) self.experiment_end_screen = libscreen.Screen() experiment_end_text = \ '''Congratulations! You have completed the experiment. Your scores for each block are displayed below. \nClick left mouse button to proceed \n\n''' for i, score in enumerate(scores): experiment_end_text += 'Block %i: %i points \n' % (i + 1, score) self.experiment_end_screen.draw_text(text=experiment_end_text, fontsize=18) self.disp.fill(self.experiment_end_screen) self.disp.show() self.mouse.get_clicked()
def __init__(self): try: self.eyetracker = tr.find_all_eyetrackers()[0] except IndexError: messagebox.showinfo( "Error", "Tobii Eye Tracker not found. Please restart the Tobii Service\nfound in the \"Services\" application" ) import sys sys.exit(1) self.gaze_data = [] self.disp = libscreen.Display() self.screen = libscreen.Screen() self.kb = libinput.Keyboard(keylist=['space', 'escape', 'q'], timeout=1) self.screendist = constants.SCREENDIST # calibration and validation points lb = 0.1 # left bound xc = 0.5 # horizontal center rb = 0.9 # right bound ub = 0.1 # upper bound yc = 0.5 # vertical center bb = 0.9 # bottom bound self.points_to_calibrate = [ self._norm_2_px(p) for p in [(lb, ub), (rb, ub), (xc, yc), (lb, bb), (rb, bb)] ] # maximal distance from fixation start (if gaze wanders beyond this, fixation has stopped) self.fixtresh = 1.5 # degrees # amount of time gaze has to linger within self.fixtresh to be marked as a fixation self.fixtimetresh = 100 # milliseconds # saccade velocity threshold self.spdtresh = 35 # degrees per second # saccade acceleration threshold self.accthresh = 9500 # degrees per second**2 # blink detection threshold used in PyGaze method self.blinkthresh = 50 # milliseconds self.screensize = constants.SCREENSIZE # display size in cm self.pixpercm = ( self.disp.dispsize[0] / float(self.screensize[0]) + self.disp.dispsize[1] / float(self.screensize[1])) / 2.0
def addCalibrationPoint(self, indice): dispAffich = libscreen.Display(screennr=1) point = self.points_to_calibrate[indice] Newscreen = libscreen.Screen() for i in range(0, 200, 3): Newscreen.clear() Newscreen.draw_circle(colour='red', pos=point, r=int(1920 / (50 + i)), pw=5, fill=True) dispAffich.fill(Newscreen) dispAffich.show() dispAffich.close()
def initialize_ready_screen(self): self.ready_screen = libscreen.Screen() self.ready_screen.draw_text( text='Click the Start button to start the trial', fontsize=18) self.ready_button = visual.Rect(win=pygaze.expdisplay, pos=self.ready_button_pos, width=self.ready_button_size[0], height=self.ready_button_size[1], lineColor=(200, 200, 200), lineWidth=3, lineColorSpace='rgb255', fillColor=None) self.ready_button_text = visual.TextStim(win=pygaze.expdisplay, text='Start', pos=self.ready_button_pos, height=18) self.ready_screen.screen.append(self.ready_button) self.ready_screen.screen.append(self.ready_button_text)
def initialize_response_screen(self): response_screen = libscreen.Screen() self.deadzone_rect = visual.Rect(win=self.win, pos=self.deadzone_pos, width=self.deadzone_size[0], height=self.deadzone_size[1], lineColor=None, fillColor=None) #We're using psychopy object ImageStim self.left_resp_img = visual.ImageStim(self.win, pos=self.leftButton_pos) self.right_resp_img = visual.ImageStim(self.win, pos=self.rightButton_pos) self.left_resp_rect = visual.Rect(win=self.win, pos=self.leftButton_pos, width=self.respButton_size[0], height=self.respButton_size[1], lineColor=None, fillColor=None) self.right_resp_rect = visual.Rect(win=self.win, pos=self.rightButton_pos, width=self.respButton_size[0], height=self.respButton_size[1], lineColor=None, fillColor=None) self.target = visual.TextStim(self.win, pos=self.target_pos, height=self.target_height, units='pix', opacity=0.0) # Here we specify the screeen onto which the stimuli are to be displayed response_screen.screen.append(self.deadzone_rect) response_screen.screen.append(self.left_resp_img) response_screen.screen.append(self.right_resp_img) response_screen.screen.append(self.left_resp_rect) response_screen.screen.append(self.right_resp_rect) response_screen.screen.append(self.target) return response_screen
def initialize_trial_start_screen(self): trial_start_screen = libscreen.Screen() start_button_rect = visual.Rect(win=self.win, pos=self.start_button_pos, width=self.start_button_size[0], height=self.start_button_size[1], lineColor=(200, 200, 200), lineColorSpace='rgb255', fillColor=None, lineWidth=3) start_button_text = visual.TextStim(self.win, text='Start', pos=self.start_button_pos) trial_start_screen.screen.append(start_button_rect) trial_start_screen.screen.append(start_button_text) return trial_start_screen, start_button_rect
def startscreen(): mainscreen = libscreen.Screen(bgc=(15, 129, 5, 0), fgc=(50, 90, 0, 55)) image = "Backgrounds/backend.jpg" mainscreen.draw_image(image) w, h = calcresolution() mainscreen.draw_rect(colour=(255, 255, 255), x=w / 2 - 0.5 * w / 2, y=h / 2 - 0.4 * h / 2, w=0.5 * w, h=0.4 * h, pw=1, fill=True) mainscreen.draw_text(text='Badanie reakcji na widok\n twarzy po operacji', colour=(0, 0, 0), pos=None, center=True, font='mono', fontsize=40, antialias=True) return mainscreen
def initialize_stimulus_screen(self): self.stimuli_screen = libscreen.Screen() self.rdk = RDK_MN(pygaze.expdisplay) self.stimuli_screen.screen.append(self.rdk.dot_stim) self.left_response_image = visual.ImageStim( win=pygaze.expdisplay, image='resources/images/arrow_left_sq.png', pos=self.response_button_pos_left) self.left_response_rect = visual.Rect( win=pygaze.expdisplay, pos=self.response_button_pos_left, width=self.response_button_size[0], height=self.response_button_size[1], lineColor=(5, 5, 5), lineColorSpace='rgb255', fillColor=None) self.right_response_image = visual.ImageStim( win=pygaze.expdisplay, image='resources/images/arrow_right_sq.png', pos=self.response_button_pos_right) self.right_response_rect = visual.Rect( win=pygaze.expdisplay, pos=self.response_button_pos_right, width=self.response_button_size[0], height=self.response_button_size[1], lineColor=(5, 5, 5), lineColorSpace='rgb255', fillColor=None) self.stimuli_screen.screen.append(self.left_response_image) self.stimuli_screen.screen.append(self.left_response_rect) self.stimuli_screen.screen.append(self.right_response_image) self.stimuli_screen.screen.append(self.right_response_rect)
def CDPFixationPoint(self, tfixation, Name, tol, x, y): self.Visu.blackscreen() datej = datetime.datetime.now().strftime("%d-%m-%Y") date = datetime.datetime.now().strftime("%d-%m-%Y_%H:%M:%S") table = load_workbook( self.Config.getDataDirname('FixationPoint') + '/' + Name + '.xlsx') mysheet = table.active ListeResultat = [] txp = 0 tdeb = 0 tfix = 0 cptperte = 0 self.tracker.start_recording() #table = Workbook() #gazePosSheet = table.active #gazePosSheet.title = 'gazePos' Result = 1 #gazePosSheet.append(["Time", "XOeilDroit", "YOeilDroit","XOeilGauche","YOeilGauche","xRetenu","Yretenu","Etat"]) pospxl = self.norm_2_px((x, y)) self.Visu.draw_AOI_fix(pospxl[0], pospxl[1], tol) self.Visu.VisuShow() screen = libscreen.Screen() cptdefauteyetracker = 0 #le cercle reste blanc screen.draw_circle(colour='white', pos=pospxl, r=30, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() oldTimeStamp = 0 tdebxp = libtime.get_time() txp, Newgazepos = self.tracker.binocular_sample() while tdeb < 3000 and not ((Newgazepos[2][0] > (pospxl[0] - tol) and Newgazepos[2][0] < (pospxl[0] + tol)) and (Newgazepos[2][1] > (pospxl[1] - tol) and Newgazepos[2][1] < (pospxl[1] + tol))): print(tdeb) time.sleep(0.005) NewTimeStamp, Newgazepos = self.tracker.binocular_sample() self.Visu.Show_gaze(Newgazepos[2][0], Newgazepos[2][1]) newTime = libtime.get_time() if NewTimeStamp != oldTimeStamp: t = int(NewTimeStamp - txp) / 1000 etat = self.etat_yeux(Newgazepos[0], Newgazepos[1]) #gazePosSheet.append([t, Newgazepos[0][0],Newgazepos[0][1],Newgazepos[1][0],Newgazepos[1][1],Newgazepos[2][0],Newgazepos[2][1],etat]) oldTimeStamp = NewTimeStamp tdeb = (libtime.get_time() - tdebxp) screen = libscreen.Screen() if tdeb < 3000: while tfix < tfixation and cptperte < 300: newTime = libtime.get_time() time.sleep(0.005) NewTimeStamp, Newgazepos = self.tracker.binocular_sample() self.Visu.Show_gaze(Newgazepos[2][0], Newgazepos[2][1]) self.Visu.VisuShow() #si l'individu ne regarde pas le point central if (Newgazepos[2][0] > (pospxl[0] - tol) and Newgazepos[2][0] < (pospxl[0] + tol)) and (Newgazepos[2][1] > (pospxl[1] - tol) and Newgazepos[2][1] < (pospxl[1] + tol)): screen = libscreen.Screen() #Le cercle devient vert #screen.draw_circle(colour=(int(128-(tfix*128/tfixation)),128,0), pos= pospxl, r=30, pw=2, fill=True) #screen.draw_circle(colour='green', pos= pospxl, r=30, pw=2, fill=True) screen.draw_circle(colour='white', pos=pospxl, r=30, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() tfix += (libtime.get_time() - newTime) cptperte = 0 cptdefauteyetracker = 0 else: # si l'individu regarde le point central if Newgazepos[2] == (-1, -1): cptdefauteyetracker += (libtime.get_time() - newTime) cptperte += (libtime.get_time() - newTime) if NewTimeStamp != oldTimeStamp: t = int(NewTimeStamp - txp) / 1000 etat = self.etat_yeux(Newgazepos[0], Newgazepos[1]) #gazePosSheet.append([t, Newgazepos[0][0],Newgazepos[0][1],Newgazepos[1][0],Newgazepos[1][1],Newgazepos[2][0],Newgazepos[2][1],etat]) oldTimeStamp = NewTimeStamp if tfix > tfixation: self.RecSound.play() Result = 0 self.tracker.stop_recording() if tdeb > 3000: Resulat = 1 self.ErrSound.play() screen = libscreen.Screen(bgc='white') self.disp.fill(screen=screen) self.disp.show() time.sleep(3) elif tfix < tfixation: if cptdefauteyetracker > 200: Result = 2 else: Result = 3 self.ErrSound.play() screen = libscreen.Screen(bgc='white') self.disp.fill(screen=screen) self.disp.show() time.sleep(3) mysheet.append([datej, x, y, tol, tfixation, Result]) #table.save(self.Config.getDataDirname('FixationPoint') + '/' + Name +'_' + date + '_' + Result + '_' + str(tfixation) + 'ms' + '.xls') table.save( self.Config.getDataDirname('FixationPoint') + '/' + Name + '.xlsx') print('fin') screen = libscreen.Screen() self.disp.fill(screen=screen) self.disp.show()
def CDPcontroleNictation(self): ''' Description : Après avoir fixé un point central pendant 500 ms, une image de mer (paysage calm et apsiant) apparait pednant 30 sec puis un autre point a fixer et une image de "Ou est Charlie" apparait et l'individu doit trouver Charlier (COncentration). Cette foction renvoie un tableau excel avec les données de l'eye tracker permettant d'effectuer un contrôle psitiif sur les nictations de l'individu ''' date = datetime.datetime.now().strftime("%d-%m-%Y_%H:%M:%S") self.tracker.start_recording() name = 'Charlie' ScreenNict = libscreen.Screen() Img = self.Config.getImageDirname('ControlNictation') + '/Charlie.jpg' table = Workbook() gazePosSheet = table.active gazePosSheet.title = 'gazePos' informationsheet = table.create_sheet("Information") gazePosSheet.append([ "Time", "XOeilDroit", "YOeilDroit", "XOeilGauche", "YOeilGauche", "xRetenu", "Yretenu", "Etat" ]) informationsheet.append(["NomImg", "xImage", "yImage"]) print("Début de l'expérience") self.ValidationFixation(ScreenNict, 500) ScreenNict.draw_image(image=Img) self.disp.fill(screen=ScreenNict) self.disp.show() tdeb = libtime.get_time() oldTimeStamp = 0 txp, gase = self.tracker.binocular_sample() while libtime.get_time() - tdeb < 30000: time.sleep(0.01) NewTimeStamp, Newgazepos = self.tracker.binocular_sample() if NewTimeStamp != oldTimeStamp: t = int(NewTimeStamp - txp) / 1000 etat = self.etat_yeux(Newgazepos[0], Newgazepos[1]) gazePosSheet.append([ t, Newgazepos[0][0], Newgazepos[0][1], Newgazepos[1][0], Newgazepos[1][1], Newgazepos[2][0], Newgazepos[2][1], etat ]) oldTimeStamp = NewTimeStamp if self.kb.get_key(keylist=['space'], flush=False)[0]: ScreenNict.clear() self.disp.fill(screen=ScreenNict) self.disp.show() self.tracker.stop_recording() print("Fin de l'expérience") return () ScreenNict.clear() self.disp.fill(screen=ScreenNict) self.disp.show() informationsheet.append([name + '.jpg', 960, 540]) table.save( '/home/eyetracker/Bureau/Data/Experiences/ControlNictation/' + self.nameInd + '_' + name + '_' + date + '.xls') print("Fin de l'expérience") self.tracker.stop_recording()
#pytesseract.pytesseract.tesseract_cmd ='C:\\Program Files (x86)\\Tesseract-OCR\\tessdata' menuMap = parseMenu() # create display object disp = libscreen.Display(disptype='psychopy', dispsize=(1200,800)) # create eyetracker object tracker = eyetracker.EyeTracker(disp) # create logfile object log = liblog.Logfile() # create screens mainScreen = libscreen.Screen(dispsize=(1200,800)) #mainScreen.draw_text(text="When you see a cross, look at it and press space. Then make an eye movement to the black circle when it appears.\n\n(press space to start)", fontsize=24) mainScreen.draw_image(image="./documents/vorder/vorder_test_1/test_menu_images/test_menu_2.jpeg") #stores the amount of blinks that fall within a microsecond apart blinkCount = 0 # calibrate eye tracker tracker.calibrate() print(tracker.connected()) #print("gazePosition_X: %s and gazePosition_Y: %s" %(tracker.sample()[0], tracker.sample()[1])) # Should return the closest item on the menu to where the customers current gave it def findClosestItem(x, y):
def CDPExplorationVisage(self, name, xfix, yfix): xfix = float(xfix) yfix = float(yfix) datedeb = datetime.datetime.now().strftime("%d-%m-%Y_%H:%M:%S") os.mkdir( self.Config.getDataDirname('Exploration Visages') + '/' + name + '_' + datedeb) #SetImageFile = self.SelectionSetIndividu(name) SetImageFile = [ self.Config.getImageDirname( 'Exploration Visages/anu/Anubis_02_200110DSC06806.resized.jpg' ), self.Config.getImageDirname( 'Exploration Visages/anu/Anubis_Ref_200123DSC07844.resized.jpg' ), self.Config.getImageDirname( 'Exploration Visages/bar/Barnabe_Ref_200123DSC07867.resized.jpg' ), self.Config.getImageDirname( 'Exploration Visages/bar/Barnabe_04_200123DSC07859.resized.jpg' ), self.Config.getImageDirname( 'Exploration Visages/ces/Cesar_03_200129DSC08442.resized.jpg'), self.Config.getImageDirname( 'Exploration Visages/ces/Cesar_Ref_200123DSC07860.resized.jpg') ] random.shuffle(SetImageFile) self.tracker.start_recording() print("L'expérience a débuté") for img in SetImageFile: poscercle = self.norm_2_px((xfix, yfix)) date = datetime.datetime.now().strftime("%d-%m-%Y_%H:%M:%S") imgname = os.path.basename(img) imgname = os.path.splitext(imgname)[0] table = Workbook() gazePosSheet = table.active gazePosSheet.title = 'gazePos' informationsheet = table.create_sheet("Information") informationsheet.append( ["NomImg", "xImage", "yImage", "xdep", "ydep"]) gazePosSheet.append([ "Time", "XOeilDroit", "YOeilDroit", "XOeilGauche", "YOeilGauche", "xRetenu", "Yretenu", "Etat" ]) informationsheet.append( [img, 960, 702, poscercle[0], poscercle[1]]) screen = libscreen.Screen() #le cercle reste blanc screen.draw_circle(colour='white', pos=poscercle, r=30, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() tfix = 0 cptperte = 0 while tfix < 250: if self.kb.get_key(keylist=['space'], flush=False)[0]: screen.clear() self.disp.fill(screen=screen) self.disp.show() self.tracker.stop_recording() return () newTime = libtime.get_time() time.sleep(0.005) NewTimeStamp, Newgazepos = self.tracker.binocular_sample() # si l'individu ne regarde pas le point central if (Newgazepos[2][0] < poscercle[0] - 100 or Newgazepos[2][0] > poscercle[0] + 100) or ( Newgazepos[2][1] < poscercle[1] - 100 or Newgazepos[2][1] > poscercle[1] + 100): cptperte += (libtime.get_time() - newTime) if cptperte > 300: tfix = 0 screen.draw_circle(colour='white', pos=poscercle, r=30, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() else: # si l'individu regarde le point screen = libscreen.Screen() #Le cercle devient vert screen.draw_circle(colour=(int(128 - (tfix * 128 / 250)), 128, 0), pos=poscercle, r=30, pw=2, fill=True) self.disp.fill(screen=screen) self.disp.show() tfix += (libtime.get_time() - newTime) cptperte = 0 screen.clear() screen.draw_image(image=img, pos=(960, 702)) self.disp.fill(screen=screen) self.disp.show() tdeb = libtime.get_time() oldTimeStamp = 0 txp, gase = self.tracker.binocular_sample() while libtime.get_time() - tdeb < 4000: time.sleep(0.01) NewTimeStamp, Newgazepos = self.tracker.binocular_sample() if NewTimeStamp != oldTimeStamp: t = int(NewTimeStamp - txp) / 1000 etat = self.etat_yeux(Newgazepos[0], Newgazepos[1]) gazePosSheet.append([ t, Newgazepos[0][0], Newgazepos[0][1], Newgazepos[1][0], Newgazepos[1][1], Newgazepos[2][0], Newgazepos[2][1], etat ]) oldTimeStamp = NewTimeStamp screen.clear() self.disp.fill(screen=screen) self.disp.show() self.RecSound.play() table.save( self.Config.getDataDirname('Exploration Visages') + '/' + name + '_' + datedeb + '/' + name + '_' + imgname + '_' + date + '.xls') time.sleep(2) print("L'expérience est terminée") self.tracker.stop_recording()
def initializeExperiment(self): print "Loading files..." loadScreen = libscreen.Screen() loadScreen.draw_text(text="Loading Files...",colour="lightgray", fontsize=48) self.experiment.disp.fill(loadScreen) self.experiment.disp.show() self.imageScreen=libscreen.Screen(disptype="psychopy") imageName=self.experiment.imagePath+"bunnies.png" image=visual.ImageStim(self.experiment.win, imageName,mask=None,interpolate=True) image.setPos((0,0)) buildScreenPsychoPy(self.imageScreen,[image]) setAndPresentScreen(self.experiment.disp,self.imageScreen) self.imageScreen2=libscreen.Screen(disptype="psychopy") imageName2=self.experiment.imagePath+"puppies.png" image2=visual.ImageStim(self.experiment.win, imageName2,mask=None,interpolate=True) image2.setPos((0,0)) buildScreenPsychoPy(self.imageScreen2,[image2]) trialsPath = 'trialLists/Bird_trialList_%s_%s.csv' % (self.experiment.subjVariables['subjCode'],self.experiment.subjVariables['seed']) if not os.path.isfile(trialsPath): print 'Trials file not found. Creating...' Birdsong_generateTrials.main(self.experiment.subjVariables['subjCode'],self.experiment.subjVariables['seed']) (self.trialListMatrix, self.trialFieldNames) = importTrials(trialsPath, method="sequential") #number of trials self.numTrials = 12 #load sound files self.pictureMatrix = loadFiles('stimuli/images', ['png',], 'image', self.experiment.win) self.soundMatrix = loadFiles('stimuli/sounds',['wav'], 'sound') #load AG movie self.mov = visual.MovieStim3(self.experiment.win, self.experiment.moviePath+"pinwheel.mov",loop=True,noAudio=True,size=(600,445)) self.locations=['center'] self.pos={'center': (0,0)} self.posDims=(600,600) self.posImageDims=(400.0,400.0) #set duration of pauses between trial events #this may need to be changed self.ISI=500 self.screenPause=500 self.BoxStep = 20 self.BoxStepCount = 600 self.picStepSize = 1 self.AGTimeOut = 20000 self.AGFixCount = 30 self.lookAwayPos = (-1920,-1200) #gaze contingent params self.aoiCenter=libgazecon.AOI('rectangle',pos=(640,280),size=[640,640]) self.aoiCenterMovie=libgazecon.AOI('rectangle',pos=(560,300),size=[800,600]) self.aoiScreen=libgazecon.AOI('rectangle',pos=(0,0),size=[1920,1200]) #all geometric objects to be drawn self.AGCircle=visual.Circle(self.experiment.win, radius=100, fillColor="green",lineColor="green") self.rect = newRect(self.experiment.win,self.posDims,self.pos['center'],"white") self.grayRect = newRect(self.experiment.win,(600,300),(0,450),"lightgray") print "Files Loaded!"
from psychopy import visual from psychopy import core import matplotlib.pyplot as plt import os import constants import Waveforms_v2 as wf import numpy as np disp = libscreen.Display() kb_space = libinput.Keyboard(keylist=['space'], timeout=None) kb_response = libinput.Keyboard(keylist=['s', 'v', 'q'], timeout=None) scr = libscreen.Screen() scr.draw_text( 'Starting the ITD demo!\n\nPress S for sound first\n\nPress V for visual first\n\n--Space bar to start--', fontsize=24) disp.fill(scr) disp.show() kb_space.get_key() ITD_array = np.linspace(-1, 1, num=80) ITD_size = 400 np.random.shuffle(ITD_array) response_array = [] sound = wf.waveform(wavetype='wn', duration=0.1) box = visual.Circle(pygaze.expdisplay, radius=200)
def presentTrial(self,curTrial,curTrialIndex): #self.checkExit() #self.experiment.disp.show() #random jitter prior to trial start libtime.pause(self.ISI+random.choice([0,100,200])) #######start eye tracking########## if self.experiment.subjVariables['eyetracker']=="yes": self.experiment.tracker.start_recording() #log data on trial self.experiment.tracker.log("Experiment %s subjCode %s seed %s TrialNumber %s TrialType %s audio %s image %s" % (self.experiment.expName, self.experiment.subjVariables['subjCode'],str(self.experiment.subjVariables['seed']),str(curTrialIndex),curTrial['audioType'], curTrial['audio'],curTrial['image'])) #start trial timer trialTimerStart=libtime.get_time() #create ag screen #agScreen=libscreen.Screen(disptype='psychopy') agScreenTime=libtime.get_time() if self.experiment.subjVariables['eyetracker']=="yes": #log event self.experiment.tracker.log("agStart") agCount = 0 keyBreak = False movPlaying = True self.mov.play() while self.mov.status != visual.FINISHED and libtime.get_time() - agScreenTime < self.AGTimeOut: self.mov.draw() self.experiment.win.flip() libtime.pause(10) if self.experiment.subjVariables['activeMode']=="input" and self.experiment.subjVariables['inputDevice']=="keyboard": for key in event.getKeys(): if key == 'space': if self.mov.status == visual.PLAYING: self.mov.pause() self.experiment.win.flip() movPlaying = False keyBreak = True if keyBreak: break else: if self.experiment.subjVariables['activeMode']=="gaze": inputpos = self.experiment.tracker.sample() elif self.experiment.subjVariables['activeMode']=="input" and self.experiment.subjVariables['inputDevice']=="mouse": inputpos = self.experiment.input.get_pos() if self.aoiCenterMovie.contains(inputpos): agCount += 1 if agCount > self.AGFixCount: #if self.mov.status == visual.PLAYING: break if movPlaying: if self.mov.status == visual.PLAYING: self.mov.pause() self.experiment.win.flip() #print libtime.get_time() - agScreenTime if self.experiment.subjVariables['eyetracker']=="yes": #log event self.experiment.tracker.log("agEnd") #create starting screen startScreen=libscreen.Screen(disptype='psychopy') curPic=self.pictureMatrix[str(curTrial['image'])][0] curPicCoord=self.pos['center'] curPic.setPos(curPicCoord) curPic.size = (300,300) curBox = self.pictureMatrix[str(curTrial['box'])][0] curBox.size = self.posDims curBox.pos = self.pos['center'] buildScreenPsychoPy(startScreen,[self.rect,curPic,curBox,self.grayRect]) #present starting screen setAndPresentScreen(self.experiment.disp, startScreen) startScreenTime=libtime.get_time() if self.experiment.subjVariables['eyetracker']=="yes": #log event self.experiment.tracker.log("startScreen") libtime.pause(self.screenPause) #slide screen up for i in range(0,self.BoxStepCount+1,self.BoxStep): #set up box curBox.pos=(self.pos['center'][0],i) #add new screen curScreen=libscreen.Screen(disptype='psychopy') #add stimuli to the screen buildScreenPsychoPy(curScreen,[self.rect,curPic,curBox,self.grayRect]) setAndPresentScreen(self.experiment.disp,curScreen) if i==self.BoxStepCount: screenUpTime=libtime.get_time() if self.experiment.subjVariables['eyetracker']=="yes": #log screen slide event self.experiment.tracker.log("screenUp") #play audio self.soundMatrix[curTrial['audio']].play() audioStartTime=libtime.get_time() if self.experiment.subjVariables['eyetracker']=="yes": #log audio event self.experiment.tracker.log("audioStart") ######Contingent Procedure###### lookProcedureTimes = self.watchProcedure(curTrial,audioStartTime,curTrial['audioDur'],1000,self.aoiScreen,looming=True,curPic=curPic,stim1=self.rect,stim2=curBox,stim3=self.grayRect) #print lookProcedureTimes self.soundMatrix[curTrial['audio']].stop() self.experiment.disp.show() audioEndTime=libtime.get_time()-audioStartTime if self.experiment.subjVariables['eyetracker']=="yes": #log audio end event self.experiment.tracker.log("audioEnd") ######Stop Eyetracking###### #trialEndTime trialTimerEnd=libtime.get_time() #trial time trialTime=trialTimerEnd-trialTimerStart if self.experiment.subjVariables['eyetracker']=="yes": #stop eye tracking self.experiment.tracker.stop_recording() #######Save data######### fieldVars=[] for curField in self.trialFieldNames: fieldVars.append(curTrial[curField]) [header, curLine] = createRespNew(self.experiment.subjInfo, self.experiment.subjVariables, self.trialFieldNames, fieldVars, a_curTrialIndex=curTrialIndex, b_expTimer=trialTimerEnd, c_trialStart=trialTimerStart, d_trialTime=trialTime, e_totalTime = lookProcedureTimes[0], f_lookAways = lookProcedureTimes[1], g_totalLookingTime = lookProcedureTimes[2], h_totalLookingTimeNS = lookProcedureTimes[3], i_agScreenTime = agScreenTime, j_startScreenTime = startScreenTime, k_audioStartTime=audioStartTime, l_audioEndTime = audioEndTime ) writeToFile(self.experiment.outputFile,curLine)
pos = [0, 0]) target = visual.Circle(pygaze.expdisplay, size = 20, fillColor=[-1,-1,-1], lineColor=[0,0,0], pos = [100, 200]) distractor = visual.Circle(pygaze.expdisplay, size = 20, fillColor=[1, 1, 1], lineColor=[1, 1, 1], pos = [200, 100]) dist = 0 fixscreen = libscreen.Screen() fixscreen.screen.append(fix) targetscreen = libscreen.Screen() targetscreen.screen.append(target) targetscreen.screen.append(fix) distractorscreen = libscreen.Screen() distractorscreen.screen.append(target) distractorscreen.screen.append(distractor) distractorscreen.screen.append(fix) resultscreen = libscreen.Screen() tracker.calibrate()
# # # # # # setup the experiment # create display object disp = libscreen.Display(disptype='opensesame') # create keyboard object kb = libinput.Keyboard(disptype='opensesame', keylist=['left','right','escape'], timeout=2000) # create logfile object log = liblog.Logfile() log.write(["trialnr", "trialtype", "response", "RT", "correct"]) # create screens fixscreen = libscreen.Screen(disptype='opensesame') fixscreen.draw_fixation(fixtype='cross',pw=2) targetscreens = {} targetscreens['left'] = libscreen.Screen(disptype='opensesame') targetscreens['left'].draw_circle(pos=(w*0.25,h/2), fill=True) targetscreens['right'] = libscreen.Screen(disptype='opensesame') targetscreens['right'].draw_circle(pos=(w*0.75,h/2), fill=True) feedbackscreens = {} feedbackscreens[1] = libscreen.Screen(disptype='opensesame') feedbackscreens[1].draw_text(text='correct', colour=(0,255,0)) feedbackscreens[0] = libscreen.Screen(disptype='opensesame') feedbackscreens[0].draw_text(text='incorrect', colour=(255,0,0)) # # # # # # run the experiment
# create display object disp = libscreen.Display() # create eyetracker object tracker = eyetracker.EyeTracker(disp) # create keyboard object keyboard = libinput.Keyboard(keylist=['space'], timeout=None) # create logfile object log = liblog.Logfile() log.write(["trialnr", "trialtype", "endpos", "latency", "correct"]) # create screens inscreen = libscreen.Screen() inscreen.draw_text( text= "When you see a cross, look at it and press space. Then make an eye movement to the black circle when it appears.\n\n(press space to start)", fontsize=24) fixscreen = libscreen.Screen() fixscreen.draw_fixation(fixtype='cross', pw=3) targetscreens = {} targetscreens['left'] = libscreen.Screen() targetscreens['left'].draw_circle(pos=(int(constants.DISPSIZE[0] * 0.25), constants.DISPSIZE[1] / 2), fill=True) targetscreens['right'] = libscreen.Screen() targetscreens['right'].draw_circle(pos=(int(constants.DISPSIZE[0] * 0.75), constants.DISPSIZE[1] / 2), fill=True)
def watchProcedure(self,curTrial,startTime,maxTime,maxLookAwayTime, aoi,looming=False,curPic=None,stim1=None,stim2=None,stim3=None): totalLookingTime = 0 nonLookingTimes = [] transitionNonLookingTimes = [] lookAways = 0 curNonLookingTime = 0 looking = True nonLook = False curLookAwayTime = 0 responded = True counter=0.0 direction=1 startValues=(300,300) loomCounter = 0 transition=False #list to store last 150 ms of looking last150ms=[] #store current location to initiate checking of when looks go off screen if self.experiment.subjVariables['activeMode']=="gaze": lastInputpos = self.experiment.tracker.sample() if lastInputpos == self.lookAwayPos: transitionNonLookingTimeOnset = libtime.get_time() elif self.experiment.subjVariables['activeMode']=="input" and self.experiment.subjVariables['inputDevice']=="mouse": lastInputpos = self.experiment.input.get_pos() if lastInputpos == self.lookAwayPos: transitionNonLookingTimeOnset = libtime.get_time() while libtime.get_time() - startTime < maxTime and curLookAwayTime < maxLookAwayTime: if self.experiment.subjVariables['activeMode']=="input" and self.experiment.subjVariables['inputDevice']=="keyboard": for key in event.getKeys(): if key == 'space' and looking ==True: responded = False event.clearEvents() transitionNonLookingTimeOnset = libtime.get_time() elif key == 'space' and looking ==False: responded = True event.clearEvents() else: libtime.pause(10) #get gaze/ mouse position if self.experiment.subjVariables['activeMode']=="gaze": curInputpos = self.experiment.tracker.sample() elif self.experiment.subjVariables['activeMode']=="input": curInputpos = self.experiment.input.get_pos() #mark transition time if curInputpos == self.lookAwayPos and lastInputpos != self.lookAwayPos: transition=True transitionNonLookingTimeOnset = libtime.get_time() else: transition = False ####smoothing eyetracking/mousetracking sample### ##add cur gaze position to the list last150ms.append(curInputpos) # ##if the length of the list exceeds 150 ms/25==6, then delete the earliest item in the lis ## 25 ms because an average run through the while loop takes between 20-30 ms if len(last150ms)>6: del last150ms[0] ##Now, remove the (no looking data) tuples last150msClean=[e for e in last150ms if e != self.lookAwayPos] ##Now calculate the mean if len(last150msClean)>0: #calculate mean #looks a bit tricky, but that's just because I think the gaze positions are stored as tuples, which is a bit of an odd data structure. inputpos=tuple(map(lambda y: sum(y) / float(len(y)), zip(*last150msClean))) else: inputpos=self.lookAwayPos ####smoothing procedure end### responded = aoi.contains(inputpos) #update last gaze position lastInputpos = curInputpos if not responded and looking: nonLookingTimeOnset = libtime.get_time() looking = False lookAways +=1 nonLook = True if responded: if not looking: looking = True nonLookOnset = False curNonLookingTime=libtime.get_time()-nonLookingTimeOnset curTransitionNonLookingTime=libtime.get_time()- transitionNonLookingTimeOnset nonLookingTimes.append(curNonLookingTime) transitionNonLookingTimes.append(curTransitionNonLookingTime) if looking: curLookAwayTime = 0 else: curLookAwayTime = libtime.get_time() - nonLookingTimeOnset if curLookAwayTime > maxLookAwayTime: nonLookingTimes.append(curLookAwayTime) curTransitionNonLookingTime=libtime.get_time()- transitionNonLookingTimeOnset transitionNonLookingTimes.append(curTransitionNonLookingTime) if looming: #update screen newScreen=libscreen.Screen(disptype='psychopy') counter +=1 if counter > 100: direction=(-1)*direction counter = 0.0 startValues=(xSize,ySize) xSize = self.easeInOut(startValues[0],200.0,counter,100,direction) ySize = self.easeInOut(startValues[1],200.0,counter,100,direction) curPic.size = (xSize,ySize) buildScreenPsychoPy(newScreen,[stim1,curPic,stim2,stim3]) setAndPresentScreen(self.experiment.disp, newScreen) totalTime=libtime.get_time()-startTime totalLookingTime = totalTime - sum(nonLookingTimes) totalLookingTimeNonSmoothed = totalTime - sum(transitionNonLookingTimes) return [totalTime, lookAways, totalLookingTime,totalLookingTimeNonSmoothed]