def create_stimuli(self, tdSimilarity, ddSimilarity):
# Setup target properties
if P.condition == 'line':
self.target_angle = random.randint(0, 179)
self.target_height = deg_to_px(0.1)
self.target_fill = WHITE
self.target_item = kld.Rectangle(width=self.item_size,
height=self.target_height,
fill=WHITE,
rotation=self.target_angle)
if tdSimilarity == HIGH:
self.ref_angle = self.target_angle
else:
self.ref_angle = self.target_angle + 90
self.mask = kld.Asterisk(size=self.item_size,
thickness=self.target_height,
fill=WHITE,
spokes=12)
else:
self.target_height = self.item_size
self.palette = kld.ColorWheel(diameter=self.item_size)
self.target_angle = random.randint(0, 359)
self.target_colour = self.palette.color_from_angle(
self.target_angle)
self.target_item = kld.Rectangle(width=self.item_size,
height=self.target_height,
fill=self.target_colour)
if tdSimilarity == HIGH:
self.ref_angle = self.target_angle
else:
self.ref_angle = self.target_angle + 180
self.mask = kld.Rectangle(width=self.item_size, fill=WHITE)
# Setup distractor(s) properties
if ddSimilarity == HIGH:
padding = [random.choice([-20, 20])]
else:
padding = [-40, -20, 20, 40]
self.distractors = []
if P.condition == 'line':
for p in padding:
rotation = self.ref_angle + p
self.distractors.append(
kld.Rectangle(width=self.item_size,
height=self.target_height,
fill=WHITE,
rotation=rotation))
else:
for p in padding:
colour = self.palette.color_from_angle(self.ref_angle + p)
self.distractors.append(
kld.Rectangle(width=self.item_size,
height=self.target_height,
fill=colour))
def setup(self):
# Stimulus Sizes
target_size = deg_to_px(3.0)
diamond_size = sqrt(target_size**2/2.0)
probe_diameter = deg_to_px(1.0)
wheel_diameter = deg_to_px(16.0)
# Stimulus Drawbjects
self.line_a = kld.Rectangle(width=P.screen_x/2, height=2, fill=WHITE)
self.line_b = kld.Rectangle(width=P.screen_x/2, height=2, fill=BLACK)
self.diamond_a = kld.Rectangle(diamond_size, fill=WHITE, rotation=45)
self.diamond_b = kld.Rectangle(diamond_size, fill=BLACK, rotation=45)
self.probe = kld.Ellipse(probe_diameter, fill=None)
self.wheel = kld.ColorWheel(wheel_diameter)
self.line_a.render()
self.line_b.render()
self.diamond_a.render()
self.diamond_b.render()
# Layout
self.left_x = P.screen_x/4
self.right_x = 3*P.screen_x/4
self.probe_positions = {
"left": (self.left_x, P.screen_c[1]),
"right": (self.right_x, P.screen_c[1])
}
self.start_baseline = P.screen_y/4
self.end_offset = deg_to_px(5.0)
self.left_start = [self.left_x, P.screen_y/4]
self.right_start = [self.right_x, 3*P.screen_y/4]
self.left_end = [self.left_x, P.screen_c[1]+self.end_offset]
self.right_end = [self.right_x, P.screen_c[1]-self.end_offset]
# Timing
self.motion_duration = 1.5 # seconds
# Experiment Messages
if not P.condition:
P.condition = P.default_condition
toj_string = "Which shape {0} {1}?\n(White = 8 Black = 2)"
stationary_string = toj_string.format("appeared", P.condition)
motion_string = toj_string.format("touched the line", P.condition)
self.toj_prompts = {
'stationary': message(stationary_string, align="center", blit_txt=False),
'motion': message(motion_string, align="center", blit_txt=False)
}
# Initialize ResponseCollector keymaps
if P.use_numpad:
keysyms = [sdl2.SDLK_KP_8, sdl2.SDLK_KP_2]
else:
keysyms = [sdl2.SDLK_8, sdl2.SDLK_2]
self.toj_keymap = KeyMap(
"toj_responses", # Name
['8', '2'], # UI labels
['white', 'black'], # Data labels
keysyms # SDL2 Keysyms
)
# Initialize second ResponseCollector object for colour wheel responses
self.wheel_rc = ResponseCollector()
# Generate practice blocks
default_soas = self.trial_factory.exp_factors['t1_t2_soa']
toj_soas = [soa for soa in default_soas if soa!=0.0]
toj_only = {"t1_t2_soa": toj_soas}
probe_only = {"t1_t2_soa": [0.0]}
if P.run_practice_blocks:
num = P.trials_per_practice_block
self.insert_practice_block(1, trial_counts=num, factor_mask=toj_only)
self.insert_practice_block((2,4), trial_counts=num, factor_mask=probe_only)
self.trial_factory.dump()
def setup(self):
# ---------------------------------- #
# Setup Stimuli #
# ---------------------------------- #
# Set stimulus sizes
line_length = deg_to_px(2)
line_thickness = deg_to_px(0.5)
thick_rect_border = deg_to_px(0.7)
thin_rect_border = deg_to_px(0.3)
fix_size = deg_to_px(0.6)
fix_thickness = deg_to_px(0.1)
square_size = deg_to_px(3)
large_text_size = deg_to_px(0.65)
# Stimulus layout
box_offset = deg_to_px(8.0)
self.left_box_loc = (P.screen_c[0] - box_offset, P.screen_c[1])
self.right_box_loc = (P.screen_c[0] + box_offset, P.screen_c[1])
# Generate target colouring
# Select target colours from randomly rotated colourwheel
# ensuring those selected are unique and equidistant
self.color_selecter = kld.ColorWheel(diameter=1,
rotation=random.randrange(0, 360))
self.target_colours = []
for i in (0, 120, 240):
self.target_colours.append(self.color_selecter.color_from_angle(i))
# Assign colours to payout valences
random.shuffle(self.target_colours)
self.high_value_colour = self.target_colours[0]
self.low_value_colour = self.target_colours[1]
self.neutral_value_colour = self.target_colours[2]
# Initialize drawbjects
self.thick_rect = kld.Rectangle(
square_size, stroke=[thick_rect_border, WHITE, STROKE_CENTER])
self.thin_rect = kld.Rectangle(
square_size, stroke=[thin_rect_border, WHITE, STROKE_CENTER])
self.high_val_rect = kld.Rectangle(
square_size,
stroke=[thin_rect_border, self.high_value_colour, STROKE_CENTER])
self.low_val_rect = kld.Rectangle(
square_size,
stroke=[thin_rect_border, self.low_value_colour, STROKE_CENTER])
self.fixation = kld.Asterisk(fix_size, fix_thickness, fill=WHITE)
self.fix_cueback = kld.Asterisk(fix_size * 2,
fix_thickness * 2,
fill=WHITE)
self.go = kld.FixationCross(fix_size, fix_thickness, fill=BLACK)
self.nogo = kld.FixationCross(fix_size,
fix_thickness,
fill=BLACK,
rotation=45)
self.flat_line = kld.Rectangle(line_length, line_thickness, fill=BLACK)
self.tilt_line = kld.Rectangle(line_length,
line_thickness,
fill=BLACK,
rotation=45)
self.probe = kld.Ellipse(int(0.75 * square_size))
# ---------------------------------- #
# Setup other experiment factors #
# ---------------------------------- #
# COTOA = Cue-Offset|Target-Onset Asynchrony
self.cotoa = 800 # ms
self.feedback_exposure_period = 1.25 # sec
# Training block payout variables
self.high_payout_baseline = 12
self.low_payout_baseline = 8
self.total_score = None
self.penalty = -5
# ---------------------------------- #
# Setup Response Collectors #
# ---------------------------------- #
# Initialize response collectors
self.probe_rc = ResponseCollector(uses=RC_KEYPRESS)
self.training_rc = ResponseCollector(uses=RC_KEYPRESS)
# Initialize ResponseCollector keymaps
self.training_keymap = KeyMap(
'training_response', # Name
['z', '/'], # UI labels
["left", "right"], # Data labels
[sdl2.SDLK_z, sdl2.SDLK_SLASH] # SDL2 Keysyms
)
self.probe_keymap = KeyMap('probe_response', ['spacebar'], ["pressed"],
[sdl2.SDLK_SPACE])
# --------------------------------- #
# Setup Experiment Messages #
# --------------------------------- #
# Make default font size larger
self.txtm.add_style('myText', large_text_size, WHITE)
err_txt = "{0}\n\nPress any key to continue."
lost_fixation_txt = err_txt.format(
"Eyes moved! Please keep your eyes on the asterisk.")
probe_timeout_txt = err_txt.format(
"No response detected! Please respond as fast and as accurately as possible."
)
training_timeout_txt = err_txt.format("Line response timed out!")
response_on_nogo_txt = err_txt.format(
"\'nogo\' signal (x) presented\nPlease only respond when you see "
"the \'go\' signal (+).")
self.err_msgs = {
'fixation':
message(lost_fixation_txt,
'myText',
align='center',
blit_txt=False),
'probe_timeout':
message(probe_timeout_txt,
'myText',
align='center',
blit_txt=False),
'training_timeout':
message(training_timeout_txt,
'myText',
align='center',
blit_txt=False),
'response_on_nogo':
message(response_on_nogo_txt,
'myText',
align='center',
blit_txt=False)
}
self.rest_break_txt = err_txt.format(
"Whew! that was tricky eh? Go ahead and take a break before continuing."
)
self.end_of_block_txt = "You're done the first task! Please buzz the researcher to let them know!"
# -------------------------------- #
# Setup Eyelink boundaries #
# -------------------------------- #
fix_bounds = [P.screen_c, square_size / 2]
self.el.add_boundary('fixation', fix_bounds, CIRCLE_BOUNDARY)
# --------------------------------- #
# Insert training block (line task) #
# --------------------------------- #
if P.run_practice_blocks:
self.insert_practice_block(1, trial_counts=P.trials_training_block)