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 __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 CDPApplyCalibration(self):
ListeCal = self.tracker.applyCalibration(self.baseFilename)
self.disp = libscreen.Display(screennr=int(
self.Config.getConfiguration('DISPLAY', 'screen_number')))
return (ListeCal)
def __init__(self):
self.disp = libscreen.Display()
self.win = pygaze.expdisplay
self.mouse = libinput.Mouse(visible=True)
instructions_file = 'resources/%s_instructions.txt'
self.experiment_start_screen = self.intialize_message_screen(
instructions_file % ('experiment_start'), wrapWidth=1600)
self.experiment_end_screen = self.initialize_experiment_end_screen(
instructions_file % ('experiment_end'))
self.block_start_screen, self.block_threshold_stim, self.block_number_stim = \
self.initialize_block_start_screen(instructions_file % ('block_start'))
self.block_end_screen = self.intialize_message_screen(
instructions_file % ('block_end'))
self.trial_start_screen, self.start_button_rect = self.initialize_trial_start_screen(
)
self.response_screen = self.initialize_response_screen()
self.trial_end_screen = self.initialize_trial_end_screen()
self.rating_screen = self.initialize_rating_screen()
# TODO: change this to PsychoPy's sound.Sound
self.shocker_tone = libsound.Sound(
soundfile='resources/trigger_tone.wav')
def create_screen(self,
size=(2560, 1440),
full_screen=False,
background_color=(0.0, 0.0, 0.0),
gamma_scale=(2.475, 2.25, 2.15),
physical_screen_size=(62, 32),
physical_screen_distance=71.0,
max_lums=(24.52, 78.8, 10.19),
wait_blanking=True,
screen_nr=0,
monitor=None):
"""
create_screen take a screen to display the stimuli on.
the standard screen is assumed to be the Sony FW600, which is set up to start up in the
1280x960@96Hz resolution.
"""
# the actual screen-getting
self.display = libscreen.Display(disptype='psychopy',
dispsize=size,
fgc=(255, 0, 0),
bgc=list(
(255 * bgl
for bgl in background_color)),
screennr=screen_nr,
mousevisible=False,
fullscr=full_screen,
monitor=monitor)
# self.pygaze_scr = libscreen.Screen(disptype='psychopy')
# print dir(self.display)
# print self.display
# print dir(self.pygaze_scr)
# print dir(self.pygaze_scr.screen[0])
self.screen = pygaze.expdisplay
self.screen.setMouseVisible(False)
self.screen.setColor(background_color)
# self.screen = visual.Window( size = size, fullscr = full_screen, allowGUI = False, units = 'pix', allowStencil = True, rgb = background_color, waitBlanking = wait_blanking, winType = 'pyglet' )
self.screen.background_color = background_color
# worked = pygame.display.set_gamma(gamma_scale[0],gamma_scale[1],gamma_scale[2])
self.screen_pix_size = size
self.max_lums = max_lums
self.physical_screen_size = physical_screen_size
self.physical_screen_distance = physical_screen_distance
self.screen_height_degrees = 2.0 * 180.0 / pi * atan(
(physical_screen_size[1] / 2.0) / physical_screen_distance)
self.pixels_per_degree = (size[1]) / self.screen_height_degrees
self.centimeters_per_degree = physical_screen_size[
1] / self.screen_height_degrees
self.pixels_per_centimeter = self.pixels_per_degree / self.centimeters_per_degree
# print 'screen: ' + str(self.screen_height_degrees) + ' degrees tall and pixels per degree: ' + str(self.pixels_per_degree)
# self.screen.mousevis = False
self.screen.flip()
def create_screen(self, size = (1280, 960), full_screen = False, background_color = (0.0,0.0,0.0),
gamma_scale = (2.475,2.25,2.15), physical_screen_size = (48, 32), physical_screen_distance = 71.0, max_lums = (24.52, 78.8, 10.19), wait_blanking = True, screen_nr = 0 ):
"""
create_screen take a screen to display the stimuli on.
the standard screen is assumed to be the Sony FW600, which is set up to start up in the
1280x960@96Hz resolution.
"""
# the actual screen-getting
self.display = libscreen.Display(disptype='psychopy', full_screen = False, dispsize=size, fgc=(255,0,0), bgc=list((255*bgl for bgl in background_color)), screennr=screen_nr,mousevisible=False)
# self.pygaze_scr = libscreen.Screen(disptype='psychopy')
# print dir(self.display)
# print self.display
# print dir(self.pygaze_scr)
# print dir(self.pygaze_scr.screen[0])
self.screen = pygaze.expdisplay
self.screen.setMouseVisible(False)
self.screen.setColor(background_color)
# self.screen = visual.Window( size = size, fullscr = full_screen, allowGUI = False, units = 'pix', allowStencil = True, rgb = background_color, waitBlanking = wait_blanking, winType = 'pyglet' )
self.screen.background_color = background_color
# worked = pygame.display.set_gamma(gamma_scale[0],gamma_scale[1],gamma_scale[2])
self.screen_pix_size = size
self.max_lums = max_lums
self.physical_screen_size = physical_screen_size
self.physical_screen_distance = physical_screen_distance
self.screen_height_degrees = 2.0 * 180.0/pi * atan((physical_screen_size[1]/2.0)/physical_screen_distance)
self.screen_width_degrees = 2.0 * 180.0/pi * atan((physical_screen_size[0]/2.0)/physical_screen_distance)
self.pixels_per_degree = (size[0]) / self.screen_width_degrees
self.centimeters_per_degree = physical_screen_size[1] / self.screen_height_degrees
self.pixels_per_centimeter = self.pixels_per_degree / self.centimeters_per_degree
# print 'screen: ' + str(self.screen_height_degrees) + ' degrees tall and pixels per degree: ' + str(self.pixels_per_degree)
# supplanting the color+texture+mask shader
try:
import psychopy.visual.shaders as shaders
except:
import psychopy._shadersPyglet as shaders
colorToBlackFragmentShader = '''
uniform sampler2D texture, mask;
void main() {
vec4 textureFrag = texture2D(texture,gl_TexCoord[0].st);
vec4 maskFrag = texture2D(mask,gl_TexCoord[1].st);
gl_FragColor.a = gl_Color.a*maskFrag.a*textureFrag.a;
gl_FragColor.rgb = gl_Color.rgb * ((textureFrag.rgb +1.0)/2.0);
}
'''
if self.screen.winType=='pyglet' and self.screen._haveShaders:
self.screen._progSignedTexMask = shaders.compileProgram(shaders.vertSimple,
colorToBlackFragmentShader)
#end
# self.screen.mousevis = False
self.screen.flip()
def create_screen(self, engine='psychopy', **kwargs):
#Set arguments from config file or kwargs
for argument in [
'size', 'full_screen', 'background_color', 'gamma_scale',
'physical_screen_size', 'physical_screen_distance', 'max_lums',
'wait_blanking', 'screen_nr', 'mouse_visible', 'monitor_name'
]:
value = kwargs.pop(argument, config.get('screen', argument))
setattr(self, argument, value)
if engine == 'pygaze':
from pygaze import libscreen
setattr(pygaze.settings, 'FULLSCREEN', self.full_screen)
self.display = libscreen.Display(
disptype='psychopy',
dispsize=self.size,
fgc=(255, 0, 0),
bgc=list((255 * bgl for bgl in self.background_color)),
screennr=int(self.screen_nr),
mousevisible=self.mouse_visible,
fullscr=self.full_screen,
allowStencil=True)
self.screen = pygaze.expdisplay
self.screen.waitBlanking = self.wait_blanking
elif engine == 'psychopy':
self.screen = visual.Window(size=self.size,
fullscr=self.full_screen,
screen=int(self.screen_nr),
allowGUI=True,
units='pix',
allowStencil=True,
rgb=self.background_color,
waitBlanking=self.wait_blanking,
useFBO=True,
winType='pyglet',
monitor=self.monitor_name)
self.screen.setMouseVisible(self.mouse_visible)
event.Mouse(visible=self.mouse_visible, win=self.screen)
self.screen.setColor(self.background_color)
self.screen.background_color = self.background_color
self.screen_pix_size = self.size
self.screen_height_degrees = 2.0 * 180.0 / np.pi * np.arctan(
(self.physical_screen_size[1] / 2.0) /
self.physical_screen_distance)
self.pixels_per_degree = (self.size[1]) / self.screen_height_degrees
self.centimeters_per_degree = self.physical_screen_size[
1] / self.screen_height_degrees
self.pixels_per_centimeter = self.pixels_per_degree / self.centimeters_per_degree
self.screen.flip()
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 __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
# # # # #
# importing the relevant libraries
import random
import constants
from pygaze import libscreen
from pygaze import libtime
from pygaze import liblog
from pygaze import libinput
from pygaze import eyetracker
# # # # #
# experiment setup
# 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=
import random
from pygaze import libscreen
from pygaze import libtime
from pygaze import libinput
from pygaze import liblog
from pygaze import defaults
defaults.osexperiment = exp
w = 1024
h = 768
# # # # #
# 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')
def __init__(self):
self.expName = 'Bird'
self.path = os.getcwd()
self.subjInfo = {
'1': { 'name' : 'subjCode',
'prompt' : 'EXP_XXX',
'options': 'any',
'default':self.expName+'_101'},
'2' : { 'name' : 'gender',
'prompt' : 'Subject Gender m/f: ',
'options' : ("m","f"),
'default':'',
'type' : str},
'3' : { 'name' : 'age',
'prompt' : 'Subject Age: ',
'options' : 'any',
'default':'',
'type' : str},
'4' : {'name' : 'seed',
'prompt' : 'Seed: ',
'options' : 'any',
'default' : 101,
'type' : 101},
'5' : {'name' : 'expInitials',
'prompt' : 'Experiment Initials: ',
'options' : 'any',
'default' : '',
'type' : str},
'6' : { 'name' : 'activeMode',
'prompt' : 'input / gaze',
'options' : ("input","gaze"),
'default':"gaze",
'type' : str},
'7' : { 'name' : 'inputDevice',
'prompt' : 'keyboard / mouse',
'options' : ("keyboard","mouse"),
'default':'keyboard'},
'8' : { 'name' : 'eyetracker',
'prompt' : '(yes / no)',
'options' : ("yes","no"),
'default' : "yes",
'type' : str},
'9' : { 'name' : 'pygazeVersion',
'prompt' : '(04 / 06)',
'options' : ("04","06"),
'default' : "06",
'type' : str},
}
optionsReceived = False
fileOpened = False
while not fileOpened:
[optionsReceived, self.subjVariables] = enterSubjInfo(self.expName, self.subjInfo)
constants.LOGFILENAME=constants.LOGFILEPATH+self.subjVariables['subjCode']
constants.LOGFILE=constants.LOGFILENAME[:]
if self.subjVariables['pygazeVersion'] == "06":
from pygaze import display
from pygaze import settings
settings.LOGFILE = constants.LOGFILENAME[:]
print settings.LOGFILE
if not optionsReceived:
popupError(self.subjVariables)
elif not os.path.isfile('data/'+'data_'+self.subjVariables['subjCode']+'.txt'):
#if using an eyetracker
if self.subjVariables['eyetracker']=="yes":
#import eyetracking package from pygaze
from pygaze import eyetracker
if not os.path.isfile(constants.LOGFILENAME+'_TOBII_output.tsv'):
fileOpened = True
self.outputFile = open('data/'+'data_'+self.subjVariables['subjCode']+'.txt','w')
else:
fileOpened = False
popupError('That subject code for the eyetracking data already exists! The prompt will now close!')
core.quit()
else:
fileOpened = True
self.outputFile = open('data/'+'data_'+self.subjVariables['subjCode']+'.txt','w')
else:
fileOpened = False
popupError('That subject code already exists!')
# create display object
self.disp = libscreen.Display(disptype='psychopy')
#create psychopy window based on Display() object
if self.subjVariables['pygazeVersion'] == "06":
self.win = pygaze.expdisplay
else:
self.win = self.disp.expdisplay
if self.subjVariables['eyetracker']=="yes":
# create eyetracker object
self.tracker = eyetracker.EyeTracker(self.disp)
if self.subjVariables['inputDevice'] == 'keyboard':
print "Using keyboard..."
self.inputDevice = "keyboard"
self.validResponses = {'1':'space','2': 'enter'}
## create keyboard object
self.input = libinput.Keyboard(keylist=['space', 'enter', 'left', 'right'], timeout=None)
elif self.subjVariables['inputDevice'] == 'mouse':
print "Using mouse..."
self.inputDevice = "mouse"
self.input = libinput.Mouse(mousebuttonlist=[1], timeout=None)
if self.subjVariables['activeMode']=="input":
self.input.set_visible(visible=True)
self.imagePath=self.path+'/stimuli/images/'
self.soundPath=self.path+'/stimuli/sounds/'
self.moviePath=self.path+'/stimuli/movies/'
self.imageExt='.png'
from menu_helper import parseMenu from pygaze import libscreen from pygaze import libtime from pygaze import liblog from pygaze import libinput from pygaze import eyetracker from pynput import mouse #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
def CDPLeaveCalibration(self):
self.tracker.annuler_calibration()
self.disp = libscreen.Display(screennr=int(
self.Config.getConfiguration('DISPLAY', 'screen_number')))
