def PlotStimuli(pos):
composition = stimuli.BlankScreen()
picture.plot(composition)
bar.plot(composition)
barEndLeft.plot(composition)
barEndRight.plot(composition)
slider = stimuli.Rectangle((3, 30), position=pos, colour=(194, 24, 7))
slider.plot(composition)
composition.present()
def make_surface(trial):
sf = stimuli.BlankScreen()
boundary = self.exp.config.gettuple('APPEARANCE', 'colour_window_boundary')
if boundary:
stimuli.Rectangle(self.exp.screen.window_size,
line_width=self.line_width,
colour=boundary).plot(sf)
[s.plot(sf) for s in trial.stimuli]
return sf
def stimulus(self, infotext=""):
"""Return the stimulus including infotext (obligatory)"""
canvas = stimuli.BlankScreen()
for elem in self.elements:
elem.plot(canvas)
if len(infotext) > 0:
RecordingScreen._text_line(text=infotext, position=[0, 0],
text_size=36).plot(canvas)
return canvas
def hold_check(exp,
holding_time,
background_stimulus=None,
n_sensors=2): # FIXME not checked for sensor=1
if background_stimulus is None:
background_stimulus = stimuli.BlankScreen()
background_stimulus.present()
background_stimulus.present()
udp.send("hold:test")
fine = stimuli.Circle(radius=20,
colour=misc.constants.C_GREY,
line_width=0)
too_low = stimuli.Circle(radius=20,
colour=misc.constants.C_GREEN,
line_width=0)
too_strong = stimuli.Circle(radius=20,
colour=misc.constants.C_RED,
line_width=0)
bkg = [
stimuli.Circle(position=(-200, 0),
radius=24,
colour=misc.constants.C_BLACK,
line_width=0),
stimuli.Circle(position=(200, 0),
radius=24,
colour=misc.constants.C_BLACK,
line_width=0)
]
key = None
stopwatch.reset_stopwatch()
while key is None and stopwatch.stopwatch_time < holding_time:
key = exp.keyboard.check()
udp.clear_receive_buffer()
lv = [
rc.get_data(rc.Command.GET_THRESHOLD_LEVEL),
rc.get_data(rc.Command.GET_THRESHOLD_LEVEL2)
]
for i in range(n_sensors):
bkg[i].clear_surface()
if lv[i] == WEAK:
too_low.plot(bkg[i])
stopwatch.reset_stopwatch()
elif lv[i] == STRONG:
too_strong.plot(bkg[i])
stopwatch.reset_stopwatch()
elif lv[i] == FINE:
fine.plot(bkg[i])
bkg[i].present(clear=False, update=False)
bkg[i].present(clear=False, update=False)
exp.screen.update()
background_stimulus.present()
def _clickable_numeric_input(title, start_at):
# copied from the 0.7.0 release of expyriment
# https://github.com/expyriment/expyriment/blob/81acb8be1a2abcecdbbfe501e9c4f662c9ba6620/expyriment/control/_experiment_control.py#L96
background_stimulus = stimuli.BlankScreen(colour=(0, 0, 0))
fields = [
stimuli.Circle(diameter=200, colour=(70, 70, 70), position=(0, 70)),
stimuli.Circle(diameter=200, colour=(70, 70, 70), position=(0, -70)),
stimuli.Rectangle(size=(50, 50),
colour=(70, 70, 70),
position=(120, 0))
]
fields[0].scale((0.25, 0.25))
fields[1].scale((0.25, 0.25))
# stimuli.TextLine(text="-", text_size=36, position=(0, -70),
# text_font="FreeMono",
# text_colour=(0, 0, 0)),
plusminus = [
stimuli.TextLine(title,
text_size=24,
text_colour=misc.constants.C_EXPYRIMENT_PURPLE,
position=(-182, 0)),
stimuli.FixCross(size=(15, 15),
position=(0, 70),
colour=(0, 0, 0),
line_width=2),
stimuli.FixCross(size=(15, 2),
position=(0, -70),
colour=(0, 0, 0),
line_width=2),
stimuli.TextLine(text="Go",
text_size=18,
position=(120, 0),
text_colour=(0, 0, 0))
]
number = int(start_at)
while True:
text = stimuli.TextLine(text="{0}".format(number),
text_size=28,
text_colour=misc.constants.C_EXPYRIMENT_ORANGE)
btn = io.TouchScreenButtonBox(button_fields=fields,
stimuli=plusminus + [text],
background_stimulus=background_stimulus)
btn.show()
key, rt = btn.wait()
if key == fields[0]:
number += 1
elif key == fields[1]:
number -= 1
if number <= 0:
number = 0
elif key == fields[2]:
break
return (number)
def __init__(self, device_ID=0, error_screen=True):
"""Create a Cedrus Device Input.
Notes
-----
If no Cedrus device is connected, an error text screen will be
presented informing that the device could not be found and suggesting
to check the connection and to switch on the device. After keypress the
class tries to reconnect with the device. Use <q> to quit this
procedure.
Parameters
----------
device_id : int, optional
device ID (default=0). Only required if more than one
Cedrus Devices are connected.
error_screen : bool, optional
set False to switch off the 'device not found' error screen.
An exception will be raise instead (default=True)
"""
Input.__init__(self)
if not isinstance(_pyxid, ModuleType):
message = """CedrusDevice can not be initialized, because the Python package
'pyxid' is not installed. See Expyriment online documentation."""
raise ImportError(message)
while True:
devices = _pyxid.get_xid_devices()
if len(devices) < 1:
message = "Could not find a Cedrus Device. Please check the connection and \n"\
+ " ensure that the device is switch on."
else:
if not devices[device_ID].is_response_device():
message = "Cedrus Device #{0} is not a response device.".format(
device_ID)
else:
self._xid = devices[device_ID]
break
if error_screen and _internals.active_exp.is_initialized:
stimuli.TextScreen(
"Error", message +
" Press a key to reconnect to the device.").present()
_internals.active_exp.keyboard.wait()
stimuli.BlankScreen().present()
_internals.active_exp.clock.wait(300)
else:
raise IOError(message)
self._xid.reset_base_timer()
self._xid.reset_rt_timer()
self._device_ID = device_ID
self._buffer = misc.Buffer(name="Cedrus Device {0}".format(device_ID))
def __init__(self, task, lsl_stream, fixationTime, instructions_path,
exp=None, is_practice=False):
self.task = task;
self.show_cross_for_seconds = fixationTime;
self.is_practice = is_practice
self.canvas = stimuli.BlankScreen()
self.exp = exp
self.instructions_path = instructions_path
self.file = file
self.lsl_stream = lsl_stream
self.task = task
def ask_for_order(self):
canvas = stimuli.BlankScreen()
order1_ = stimuli.Rectangle(size=(100, 80), position=(-200, 0))
Order1 = stimuli.TextLine(text="Order1", position=order1_.position,
text_colour=misc.constants.C_WHITE)
order2_ = stimuli.Rectangle(size=(100, 80), position=(-70, 0))
Order2 = stimuli.TextLine(text="Order2", position=order2_.position,
text_colour=misc.constants.C_WHITE)
order3_ = stimuli.Rectangle(size=(100, 80), position=(60, 0))
Order3 = stimuli.TextLine(text="Order3", position=order3_.position,
text_colour=misc.constants.C_WHITE)
order4_ = stimuli.Rectangle(size=(100, 80), position=(200, 0))
Order4 = stimuli.TextLine(text="Order4", position=order4_.position,
text_colour=misc.constants.C_WHITE)
order1_.plot(canvas)
Order1.plot(canvas)
order2_.plot(canvas)
Order2.plot(canvas)
order3_.plot(canvas)
Order3.plot(canvas)
order4_.plot(canvas)
Order4.plot(canvas)
self.experiment.exp.mouse.show_cursor()
canvas.present()
while True:
id, pos, _rt = self.experiment.exp.mouse.wait_press()
if order1_.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
self.current_block_order_number = '1'
return
elif order2_.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
self.current_block_order_number = '2'
return
elif order3_.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
self.current_block_order_number = '3'
return
elif order4_.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
self.current_block_order_number = '4'
return
def paint_all_lines(self):
self.canvas = stimuli.BlankScreen()
index = 0
for line_text in self.text_array:
y_position = self.line_positions_y[index]
self.write_text(line_text, self.edges_text[index], y_position,
self.canvas)
self.paint_line(y_position, self.canvas,
self.new_marks_positions[index])
index += 1
self.canvas.present()
self.old_marks_positions = copy.deepcopy(self.new_marks_positions)
def blocks(nb_el_block, nb_probes, exp, block_name):
"""Run a block of trials with the inputed parameters
Saves in the expyriment data file : subject_id, stimulus (digit), button pressed (always space), RT , error, block name
Saves in the manually created data file : block name, trial number, reponse and rt to both Probes
Is used once for the practice block and another number of time (chosen in the parameters) for the real blocks
"""
#random size out of 5
font_sizes_list = [48, 72, 94, 100, 120]
#list far easier this way
#numbers = list(range(0,10))
repetitions = round(nb_el_block / 10)
block = []
for i in range(repetitions):
for j in range(0, 10):
block.append(j)
probe_trials = probe_random(nb_el_block, nb_probes)
trial_number = 0
for digit in block:
trial_number += 1
f_size = randint(0, 4)
target = stimuli.TextLine(text=str(digit),
text_size=font_sizes_list[f_size])
mask = stimuli.TextLine(text='X\u0336',
text_size=font_sizes_list[f_size])
target.present()
exp.clock.wait(250)
mask.present()
button, rt = exp.keyboard.wait(misc.constants.K_SPACE, 900)
#to make sure the ITI stays at 1150ms
if rt != None:
time_left = 900 - rt
exp.clock.wait(time_left - stimuli.BlankScreen().present())
error = (button == misc.constants.K_SPACE
and digit == 3) or (button == [] and digit != 3)
exp.data.add([digit, button, rt, int(error), block_name])
#probe trials
if trial_number in probe_trials:
button_r, rt_r, button_c, rt_c = probes()
globals()[''.join(data_probe_name)] = open(''.join(data_file_name),
"a")
globals()[''.join(data_probe_name)].write(str(block_name)+','+str(trial_number)\
+','+str(button_r)+','+str(rt_r)+','+str(button_c)+','+str(rt_c)+ '\n')
globals()[''.join(data_probe_name)].close
def show_feedback_if_needed(self):
currentTrialsNumber = self.test_trials_number;
if self.is_practice:
currentTrialsNumber = self.practice_trials_number;
if self.is_practice == True:
canvas = stimuli.BlankScreen()
text_title = stimuli.TextLine("Success Rate", (0,0), text_size=(50))
success_rate = str(float(self.correct_trials) / currentTrialsNumber * 100)
text_number = stimuli.TextLine(success_rate + "%", position=(0, -100),\
text_size=(50))
text_title.plot(canvas)
text_number.plot(canvas)
canvas.present();
def prepare_grid_stimulus(self):
side = self.num_boxes**(0.5)
block_size = self.canvas_size / side
center = self.canvas_size / 2
grid = stimuli.BlankScreen()
colour_grid = self.exp._colours(
self.exp.config.get('APPEARANCE', 'colour_grid'))
colour_fixation_cross = self.exp._colours(
self.exp.config.get('APPEARANCE', 'colour_fixation_cross'))
antialiasing = 10 if self.exp.config.getboolean(
'APPEARANCE', 'antialiasing') else None
if colour_grid:
for a, b in [(i % side, i // side) for i in range(self.num_boxes)]:
stimuli.Line(
(a * block_size - center, b * block_size - center),
((a + 1) * block_size - center, b * block_size - center),
line_width=self.line_width,
colour=colour_grid,
anti_aliasing=antialiasing).plot(grid)
stimuli.Line(
(a * block_size - center, b * block_size - center),
(a * block_size - center, (b + 1) * block_size - center),
line_width=self.line_width,
colour=(colour_grid),
anti_aliasing=antialiasing).plot(grid)
stimuli.Line(
(0 - center, side * block_size - center),
(side * block_size - center, side * block_size - center),
line_width=self.line_width,
colour=colour_grid,
anti_aliasing=antialiasing).plot(grid)
stimuli.Line(
(side * block_size - center, 0 - center),
(side * block_size - center, side * block_size - center),
line_width=self.line_width,
colour=colour_grid,
anti_aliasing=antialiasing).plot(grid)
if colour_fixation_cross:
stimuli.FixCross(colour=colour_fixation_cross).plot(grid)
grid.preload()
return (grid)
def ask_for_task():
canvas = stimuli.BlankScreen()
develop_mode = use_develop_mode
design.defaults.experiment_background_colour = misc.constants.C_GREY
design.defaults.experiment_foreground_colour = misc.constants.C_BLACK
N_back = stimuli.Rectangle(size=(100, 80), position=(200, 0))
text_N_back = stimuli.TextLine(text="N back",
position=N_back.position,
text_colour=misc.constants.C_WHITE)
Stroop = stimuli.Rectangle(size=(100, 80), position=(-200, 0))
text_Stroop = stimuli.TextLine(text="Stroop",
position=Stroop.position,
text_colour=misc.constants.C_WHITE)
exit = stimuli.Rectangle(size=(100, 80), position=(0, -200))
text_exit = stimuli.TextLine(text="Exit",
position=exit.position,
text_colour=misc.constants.C_WHITE)
N_back.plot(canvas)
text_N_back.plot(canvas)
Stroop.plot(canvas)
text_Stroop.plot(canvas)
exit.plot(canvas)
text_exit.plot(canvas)
exp.mouse.show_cursor()
canvas.present()
while True:
id, pos, _rt = exp.mouse.wait_press()
if N_back.overlapping_with_position(pos):
exp.mouse.hide_cursor()
return 'n_back', exp
elif Stroop.overlapping_with_position(pos):
exp.mouse.hide_cursor()
return 'stroop', exp
elif exit.overlapping_with_position(pos):
exp.mouse.hide_cursor()
return 'exit', exp
def show_feedback_if_needed(self):
if self.is_practice == True:
canvas = stimuli.BlankScreen()
text_title = stimuli.TextLine("Success Rate", (0, 0),
text_size=(50))
success_rate = int(float(self.hit_trials) / self.targets_amount * 100) - \
int(float(self.FA_trials) / (self.trials_number - self.targets_amount) * 100)
if success_rate < 0:
success_rate = "0"
if success_rate > 100:
success_rate = "100"
else:
success_rate = str(success_rate)
text_number = stimuli.TextLine(success_rate + "%", position=(0, -100),\
text_size=(50))
text_title.plot(canvas)
text_number.plot(canvas)
canvas.present()
def write_anticipation_text(self):
self.canvas = stimuli.BlankScreen()
self.plot_instructions()
self.canvas.present()
if self.is_practice:
key, rt = self.exp.keyboard.wait([self.continue_key,\
self.exit_key], self.show_instructions_for_seconds * 1000)
if key is self.continue_key:
return True
elif key is self.exit_key:
return False
else:
key, rt = self.exp.keyboard.wait([self.exit_key], self.show_instructions_for_seconds * 1000)
if key is self.exit_key:
return False
return True
def ask_for_condition(self):
canvas = stimuli.BlankScreen()
Practice = stimuli.Rectangle(size=(100, 80), position=(200, 0))
text_Practice = stimuli.TextLine(text="Practice",
position=Practice.position,
text_colour=misc.constants.C_WHITE)
Basic = stimuli.Rectangle(size=(100, 80), position=(-200, 0))
text_Basic = stimuli.TextLine(text="Test",
position=Basic.position,
text_colour=misc.constants.C_WHITE)
exit = stimuli.Rectangle(size=(100, 80), position=(0, -200))
text_exit = stimuli.TextLine(text="Exit",
position=exit.position,
text_colour=misc.constants.C_WHITE)
Practice.plot(canvas)
text_Practice.plot(canvas)
Basic.plot(canvas)
text_Basic.plot(canvas)
exit.plot(canvas)
text_exit.plot(canvas)
self.experiment.exp.mouse.show_cursor()
canvas.present()
while True:
id, pos, _rt = self.experiment.exp.mouse.wait_press()
if Practice.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return 'practice'
elif Basic.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return 'test'
elif exit.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return 'exit'
def ask_for_level(self):
canvas = stimuli.BlankScreen()
level1 = stimuli.Rectangle(size=(100, 80), position=(200, 0))
text_level1 = stimuli.TextLine(text="1 back",
position=level1.position,
text_colour=misc.constants.C_WHITE)
level2 = stimuli.Rectangle(size=(100, 80), position=(0, 0))
text_level2 = stimuli.TextLine(text="2 back",
position=level2.position,
text_colour=misc.constants.C_WHITE)
level3 = stimuli.Rectangle(size=(100, 80), position=(-200, 0))
text_level3 = stimuli.TextLine(text="3 back",
position=level3.position,
text_colour=misc.constants.C_WHITE)
level1.plot(canvas)
text_level1.plot(canvas)
level2.plot(canvas)
text_level2.plot(canvas)
level3.plot(canvas)
text_level3.plot(canvas)
self.experiment.exp.mouse.show_cursor()
canvas.present()
while True:
id, pos, _rt = self.experiment.exp.mouse.wait_press()
if level1.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "1"
elif level2.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "2"
elif level3.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "3"
def ask_for_practice_type(self):
canvas = stimuli.BlankScreen()
auditory = stimuli.Rectangle(size=(100, 80), position=(200, 0))
text_auditory = stimuli.TextLine(text="auditory",
position=auditory.position,
text_colour=misc.constants.C_WHITE)
spatial = stimuli.Rectangle(size=(100, 80), position=(-200, 0))
text_spatial = stimuli.TextLine(text="spatial",
position=spatial.position,
text_colour=misc.constants.C_WHITE)
both = stimuli.Rectangle(size=(100, 80), position=(0, 0))
text_both = stimuli.TextLine(text="both",
position=both.position,
text_colour=misc.constants.C_WHITE)
auditory.plot(canvas)
text_auditory.plot(canvas)
spatial.plot(canvas)
text_spatial.plot(canvas)
both.plot(canvas)
text_both.plot(canvas)
self.experiment.exp.mouse.show_cursor()
canvas.present()
while True:
id, pos, _rt = self.experiment.exp.mouse.wait_press()
if auditory.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "a"
elif spatial.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "v"
elif both.overlapping_with_position(pos):
self.experiment.exp.mouse.hide_cursor()
return "both"
def execute_trial(motion_coherence,
direction,
number_dots,
time_duration=MAX_RESPONSE_DELAY):
dot_list = generate_n_dots(N_DOTS)
stimuli.BlankScreen().present()
arena = stimuli.Circle(radius=RADIUS_OF_ARENA + 2 * RADIUS_OF_DOTS,
colour=COLOR_OF_ARENA)
cue = stimuli.FixCross(size=(SIZE_FIXATION_CROSS, SIZE_FIXATION_CROSS),
line_width=LINE_WIDTH_FIXATION_CROSS)
cue.present()
exp.clock.wait(1000)
key = exp.keyboard.check()
exp.clock.reset_stopwatch()
while (exp.clock.stopwatch_time < time_duration) and (key is None):
update_stimulus(dot_list, arena)
key, time = check_keyboard_response_and_time()
exp.clock.wait(1)
return (key, time)
##c.wait(2000)
##
##print "--> ", c.time, "quit"
##udp.send("quit")
##feedback = udp.poll()
##while feedback is None:
## feedback = udp.poll()
##print "<-- ", c.time, feedback
while True:
key = exp.keyboard.check()
if key == ord("q"):
break
elif key == misc.constants.K_SPACE:
text = io.TextInput().get()
stimuli.BlankScreen().present()
print "--> ", c.time, text
udp_connection.send(text)
elif key == ord("t"):
times = []
for cnt in range(20):
stimuli.TextLine("ping test " + str(cnt)).present()
c.reset_stopwatch()
ok, time = udp_connection.ping()
print c.stopwatch_time
times.append(time)
c.wait(100)
stimuli.BlankScreen().present()
print times
feedback = udp_connection.poll()
WORD_DURATION = 400
PICTURE_DURATION = 1000
TEXT_DURATION = 3000
#TOTAL_EXPE_DURATION = 20000 # 10 sec
exp = expyriment.design.Experiment(name="HiRes Experiment")
#expyriment.control.defaults.open_gl=1
expyriment.control.defaults.window_size = (1280, 1028)
expyriment.control.set_develop_mode(True)
#%
expyriment.control.initialize(exp)
kb = expyriment.io.Keyboard()
bs = stimuli.BlankScreen()
wm = stimuli.TextLine('Waiting for scanner sync (or press \'t\')')
fs = stimuli.FixCross()
events = PriorityQueue() # all stimuli will be queued here
# load stimuli
mapsounds = dict()
mapspeech = dict()
maptext = dict()
mappictures = dict()
mapvideos = dict()
for listfile in sys.argv[1:]:
stimlist = csv.reader(io.open(listfile, 'r', encoding='utf-8'))
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
A very short example experiment in 16 lines of pure code.
Participants have to indicate the parity of digits by pressing
the left arrow key for odd and the right arrow key for even numbers.
"""
from expyriment import control, stimuli, design, misc
digit_list = [1, 2, 3, 4, 6, 7, 8, 9] * 12
design.randomize.shuffle_list(digit_list)
exp = control.initialize()
exp.data_variable_names = ["digit", "btn", "rt", "error"]
control.start(exp)
for digit in digit_list:
target = stimuli.TextLine(text=str(digit), text_size=80)
exp.clock.wait(500 - stimuli.FixCross().present() - target.preload())
target.present()
button, rt = exp.keyboard.wait(
[misc.constants.K_LEFT, misc.constants.K_RIGHT])
error = (button == misc.constants.K_LEFT) == digit % 2
if error: stimuli.Tone(duration=200, frequency=2000).play()
exp.data.add([digit, button, rt, int(error)])
exp.clock.wait(1000 - stimuli.BlankScreen().present() - target.unload())
control.end(goodbye_text="Thank you very much...", goodbye_delay=2000)
for shape in ['diamond', 'square']:
for number in [2, 3]:
trial = design.Trial()
trial.set_factor('block', 'mixed')
trial.set_factor('task', task)
trial.set_factor('shape', shape)
trial.set_factor('number_of_circles', number)
pngname = os.path.join(
STIM_DIR, '{}_{}_{}_circles.png'.format(task, shape, number))
trial.add_stimulus(stimuli.Picture(pngname))
mixed_block.add_trial(trial)
mixed_block.shuffle_trials()
BLOCKS = [pure_shape_block, pure_filling_block, mixed_block]
blankscreen = stimuli.BlankScreen()
sex_question = stimuli.TextScreen(
"One last question...",
heading_size=40,
text="What is your biological sex? Press M for male and F for female.")
training_instructions = stimuli.TextScreen("Instructions:",
heading_size=40,
text=TRAINING_INSTRUCTIONS)
reminder_if_incorrect_response = stimuli.TextScreen(
"Your response was incorrect. Instructions reminder:",
heading_size=40,
text=REMINDER_INSTRUCTIONS)
experiment_instructions = stimuli.TextScreen(
"So, you're all set for the experiment! Instructions:",
heading_size=40,
text=EXPERIMENT_INSTRUCTIONS)
exp = design.Experiment(name="Recall")
control.initialize(exp)
StimList = pd.read_hdf(filename,
key='StimLists/StimListRec_Set%d' % run,
mode='r')
# creating most elements on screen
fix = stimuli.Circle(3,
colour=None,
line_width=None,
position=None,
anti_aliasing=None)
pos = [(-300, 0), (300, 0), (0, 0)]
rect_b = stimuli.Rectangle((80, 80), colour=(255, 255, 255), position=pos[2])
blank = stimuli.BlankScreen()
c1 = stimuli.BlankScreen()
blank.plot(c1)
c1.preload()
c2 = stimuli.BlankScreen()
fix.plot(c2)
c2.preload()
c3 = stimuli.BlankScreen()
fix.plot(c3)
rect_b.plot(c3)
c3.preload()
txt_input = io.TextInput("")
# DESIGN
def _font_viewer(exp):
all_fonts = expyriment.misc.list_fonts().keys()
def info_screen():
stimuli.TextScreen(heading="Expyriment Font Viewer",
text="""
arrow keys left/right -- Switch font type
arrow keys up/down -- Switch font size
i -- Switch italic
b -- Switch bold
c -- Change text
h -- Help
return -- Quit
[Touch screen]
click left/right side -- Switch font type
click up/down side -- Switch font size
click center -- Quit
""",
text_font="freemono",
text_bold=True,
text_justification=0).present()
exp.keyboard.wait()
default_text = u"""The quick brown fox jumps over the lazy dog.
ABCDEFGHIJKLMNOPQRSTUVWXYZ ÄÖÜ
abcdefghijklmnopqrstuvwxyz äöü
1234567890.:,;ßéèê(*!?')"""
text = default_text
size = 14
font_id = 0
italic = False
bold = False
quest = io.TextInput(
message="Please enter text: (Keep empty for default text)", length=35)
mouse = io.Mouse(show_cursor=True)
bs = (exp.screen.size[0] / 3.5, exp.screen.size[1] / 3.5)
# rects center, left, right, top, button]
cl = (20, 20, 20)
rects = [
stimuli.Rectangle(size=bs, position=[0, 0], colour=cl),
stimuli.Rectangle(size=bs,
position=[(bs[0] - exp.screen.size[0]) / 2.2, 0],
colour=cl),
stimuli.Rectangle(size=bs,
position=[(exp.screen.size[0] - bs[0]) / 2.2, 0],
colour=cl),
stimuli.Rectangle(size=bs,
position=[0, (bs[1] - exp.screen.size[1]) / 2.2],
colour=cl),
stimuli.Rectangle(size=bs,
position=[0, (exp.screen.size[1] - bs[1]) / 2.2],
colour=cl)
]
rect_key_mapping = [
constants.K_RETURN, constants.K_LEFT, constants.K_RIGHT,
constants.K_UP, constants.K_DOWN
]
info_screen()
while True:
font_str = all_fonts[font_id]
font_description = "font '{0}', size {1}".format(font_str, size)
if italic:
font_description += ", italic"
if bold:
font_description += ", bold"
canvas = stimuli.BlankScreen()
for r in rects:
r.plot(canvas)
try:
stimuli.TextScreen(heading=font_description,
text=text,
text_font=font_str,
text_size=size,
text_justification=0,
text_italic=italic,
text_bold=bold,
text_colour=(255, 255, 255)).plot(canvas)
except:
stimuli.TextLine(
text="Sorry, I can't display the text with " +
"{0}".format(font_description),
text_colour=constants.C_EXPYRIMENT_ORANGE).plot(canvas)
canvas.present()
mouse.clear()
exp.keyboard.clear()
while True:
key = exp.keyboard.check()
if mouse.get_last_button_down_event() is not None:
for cnt, r in enumerate(rects):
if r.overlapping_with_position(mouse.position):
key = rect_key_mapping[cnt]
break
if key is not None:
break
if (key == constants.K_RETURN):
break
elif key == constants.K_UP:
size += 2
elif key == constants.K_DOWN:
size -= 2
elif key == constants.K_LEFT:
font_id -= 1
if font_id < 0:
font_id = len(all_fonts) - 1
elif key == constants.K_RIGHT:
font_id += 1
if font_id >= len(all_fonts):
font_id = 0
elif key == constants.K_i:
italic = not (italic)
elif key == constants.K_b:
bold = not (bold)
elif key == constants.K_c:
text = quest.get()
if len(text) <= 0:
text = default_text
else:
info_screen()
mouse.hide_cursor()
def run_experiment(self):
# define headers for expyriment log file output table (we currently don't use it,
# but if we want - we can improve it and use it if we want
self.exp.data_variable_names = ["time", "location", "direction", "trialType", "response", "rt"\
,"is success", "is practice", "blockType", "order"]
currentTrailsNumber = self.test_trials_number;
if self.is_practice:
currentTrailsNumber = self.practice_trials_number;
for trial_index in range(0, currentTrailsNumber):
canvas = stimuli.BlankScreen()
time_delay = 0
# plot cross on canvas
cross = stimuli.FixCross((50, 50), (0, 0), 5)
time_delay += cross.plot(canvas)
# plot arrow on canvas
picture_arrow = stimuli.Picture(self.direction_file_converter[self.directions[trial_index]] \
, position=self.locations_converter[self.locations[trial_index]])
time_delay += picture_arrow.preload()
time_delay += picture_arrow.plot(canvas)
# show canvas
time_delay += canvas.present();
# send trigger to LSL with arrow details
utils.push_sample_current_time(self.outlet, ["stimulus_task_stroop_type_arrow_location_" + ("u" if "up" in self.directions[trial_index] else "d") \
+ "_direction_" + ("u" if "up" in self.locations[trial_index] else "d")])
# wait for subject's response. Wait only for "duration" time
key, rt = self.game_controller.wait_press(self.possible_joystick_buttons, self.duration,\
process_control_events=False)
# we get here is subjects responded or of duration of stimulus ended
if key != None: # subject responded and stimulus duration hasn't ended
utils.push_sample_current_time(self.outlet, ["keyPressed_task_stroop_key_" + str(key)])
self.exp.clock.wait(self.duration - rt) # wait the rest of the stimulus duration before going on
# we get here when stimulus duration has ended (and subject responded)
time_delay += self.paint_cross();
self.exp.clock.wait(
self.isi - time_delay) # wait for the ISI before going on
else:
# we get here if subject hasn't responded but stimulus duration ended - so we clean the screen
time_delay += self.paint_cross();
key = None;
# we wait for subject to respond (but only for the ISI duration)
key, rt = self.game_controller.wait_press(self.possible_joystick_buttons, self.isi - time_delay,
process_control_events=False)
if key != None: # we get here if subject has responded - so we need to wait for the rest of
# the ISI
self.exp.clock.wait(
self.isi - rt - time_delay) # wait the rest of the ISI before going on
utils.push_sample_current_time(self.outlet, ["keyPressed_task_stroop_key_" + str(key)])
self.save_trial_data(key, rt, trial_index)
self.show_feedback_if_needed()
expyriment.design.defaults.experiment_background_colour = BACKGROUND_COLOR
exp = expyriment.design.Experiment(name="Localizer",
background_colour=BACKGROUND_COLOR,
foreground_colour=TEXT_COLOR,
text_size=TEXT_SIZE,
text_font=TEXT_FONT)
#expyriment.control.defaults.open_gl=1
expyriment.misc.add_fonts('fonts')
expyriment.control.initialize(exp)
#expyriment.control.defaults.quit_key = expyriment.misc.constants.K_q
#expyriment.control.defaults.fast_quit = True
#exp.background_colour = BACKGROUND_COLOR
exp._screen_colour = BACKGROUND_COLOR
kb = expyriment.io.Keyboard()
bs = stimuli.BlankScreen(colour=BACKGROUND_COLOR)
fs = stimuli.FixCross(size=(25, 25), line_width=3, colour=TEXT_COLOR)
##############################
# START PROTOCOL
#time to display the message of Preparing expyriment, otherwise it can be very short
#and we don't see what it is exactly
exp.clock.wait(800)
#CALIBRATION
if not (calibration is None):
calibrage = "Nous allons faire un calibrage"
calibration = stimuli.TextLine(calibrage,
text_font=TEXT_FONT,
text_size=TEXT_SIZE,
control.initialize(exp)
control.start(exp, auto_create_subject_id=True, skip_ready_screen=True)
nPict = 0
for nCard in presentationOrder:
m._matrix.item(nCard).setPicture(picturesExamplesFolder +
picturesExamples[nPict])
nPict += 1
mouse = io.Mouse() # Create Mouse instance
mouse.set_logging(True) # Log mouse
mouse.hide_cursor(True, True) # Hide cursor
setCursor(arrow)
bs = stimuli.BlankScreen(bgColor) # Create blank screen
m.plotDefault(bs, True) # Draw default grid
exp.clock.wait(shortRest)
exp.add_experiment_info(['Block {} - Presentation'.format(0)
]) # Add listPictures
exp.add_experiment_info(presentationOrder) # Add listPictures
instructions = stimuli.TextLine(
' PRESENTATION ',
position=(0, -windowSize[1] / float(2) +
(2 * m.gap + cardSize[1]) / float(2)),
text_font=None,
text_size=textSize,
text_bold=None,
Start Training
'''
control.start(subject_id=45)
# Add variable header to data_file; can't be done before control.start
exp._data.add_variable_names(
["Trial", "clef", "key", "Expected", "Type_response", "RT"])
# iRun indexes the Notes array; when all notes are shown and nTrails remain, this index is set to 0 and runs again
iRun = 0
'''
Trial function
'''
for iTrial in range(0, setup.nTrials):
stimuli.BlankScreen().present(clear=True, update=False)
piano.Canvas.present(clear=False, update=False)
# Present empty music sheet
musicsheet[Notes[iRun].clef].Field.present(clear=False, update=True)
# if Note needs extra help lines they need to be added first
musicsheet[Notes[iRun].clef].add_helplines(Notes[iRun])
# if Note has prefix, add it to screen
musicsheet[Notes[iRun].clef].add_prefix(Notes[iRun])
# Present note, prefix and lines
Notes[iRun].stimuli.present(clear=False, update=True)
from expyriment import stimuli, control, design, io, misc
from config import windowMode, windowSize, restBGColor, restCrossColor, restCrossSize, restCrossThickness
control.defaults.window_mode = windowMode
control.defaults.window_size = windowSize
exp = design.Experiment('Rest') # Save experiment name
control.initialize(exp)
control.start(exp, auto_create_subject_id=True, skip_ready_screen=True)
bs = stimuli.BlankScreen(restBGColor) # Create blank screen
cross = stimuli.FixCross(size=restCrossSize,
colour=restCrossColor,
line_width=restCrossThickness) # Create cross
cross.plot(bs)
kb = io.Keyboard()
bs.present()
kb.wait(keys=misc.constants.K_q)
