def define_stimuli(self):
"""
Creates standard and deviant stimuli.
"""
# The stimului. This can be anything compatible with VisionEgg
dev = FilledCircle(
color=(0, 1.0, 0),
position=[self.geometry[2] / 2, self.geometry[3] / 2],
radius=100)
std1 = Target2D(color=(0, 0, 1.0),
position=[self.geometry[2] / 2, self.geometry[3] / 2],
size=(200, 200))
std2 = Target2D(color=(1.0, 0, 0),
position=[self.geometry[2] / 2, self.geometry[3] / 2],
size=(200, 200))
#dev = Text(text='Deviant', font_size=72, position=(300, 200), anchor='center')
#std1 = Text(text='Standard I', font_size=72, position=(300, 200), anchor='center')
#std2 = Text(text='Standard II', font_size=72, position=(300, 200), anchor='center')
return [std1, std2], [dev]
def __init_screen(self):
## create screen:
if not self.fullscreen:
os.environ['SDL_VIDEO_WINDOW_POS'] = '%d, %d' % (self.geometry[0],
self.geometry[1])
self._screen = Screen(size=(self.geometry[2], self.geometry[3]),
fullscreen=self.fullscreen,
bgcolor=self.bg_color,
sync_swap=True)
## create letter box on top:
self._ve_letterbox = Target2D(position=(self._centerPos[0],
self.geometry[3] * (1 - 0.01) -
self.letterbox_size[1] / 2.),
size=(self.letterbox_size[0],
self.letterbox_size[1]),
color=self.phrase_color)
self._ve_innerbox = Target2D(position=(self._centerPos[0],
self.geometry[3] * (1 - 0.01) -
self.letterbox_size[1] / 2.),
size=(self.letterbox_size[0] - 6,
self.letterbox_size[1] - 6),
color=self.bg_color)
self._current_letter_position = (self._centerPos[0],
self.geometry[3] * (1 - 0.015) -
self.letterbox_size[1] / 2.)
self._ve_current_letter = Text(
position=self._current_letter_position,
text=(len(self._desired_letters[:1]) == 0 and " "
or self._desired_letters[:1]),
font_size=self.font_size_current_letter,
color=self.current_letter_color,
anchor='center')
self._ve_desired_letters = Text(
position=(self._centerPos[0] + 5 + self.letterbox_size[0] / 2.,
self._current_letter_position[1]),
text=(len(self._desired_letters[1:]) == 0 and " "
or self._desired_letters[1:]),
font_size=self.font_size_phrase,
color=self.phrase_color,
anchor='left')
self._ve_spelled_phrase = Text(
position=(self._centerPos[0] - 5 - self.letterbox_size[0] / 2.,
self._current_letter_position[1]),
text=(len(self._spelled_phrase) == 0 and " "
or self._spelled_phrase),
font_size=self.font_size_phrase,
color=self.phrase_color,
anchor='right')
# if we're in free spelling mode, we hide all text fields but
# the _ve_spelled_phrase. we also need a multiline
# _ve_spelled_phrase instead of the single lined one
if self.offline == self.copy_spelling == False:
self._spelled_phrase = " "
self._ve_spelled_phrase = WrappedText(
position=(0, self._current_letter_position[1]),
text=(len(self._spelled_phrase) == 0 and " "
or self._spelled_phrase),
font_size=self.font_size_phrase,
color=self.phrase_color,
size=(float(self.geometry[2]), float(self.geometry[3])))
for i in self._ve_letterbox, self._ve_innerbox, self._ve_current_letter, self._ve_desired_letters:
i.set(on=False)
## add word box to elementlist:
self._ve_elements.extend([
self._ve_letterbox, self._ve_innerbox, self._ve_current_letter,
self._ve_desired_letters, self._ve_spelled_phrase
])
## create countdown:
self._ve_countdown = Text(position=self._centerPos,
text=" ",
font_size=self.font_size_countdown,
color=self.countdown_color,
anchor='center',
on=False)
## create countdown shapes
self._ve_countdown_shape = self.countdown_shapes[
self.countdown_shape_select](radius=90,
position=self._centerPos,
color=self.countdown_shape_color,
on=False)
## create oscillator circle:
self._ve_oscillator = FilledCircle(position=(self.osc_size / 2 + 10,
self.osc_size / 2 + 10),
radius=self.osc_size / 2,
color=self.osc_color,
on=False)
## create shapes and letters:
self.init_screen_elements()
## add remaining elements to element list:
self._ve_elements.extend([
self._ve_countdown_shape, self._ve_countdown, self._ve_oscillator
])
## add elements to viewport:
self._viewport = Viewport(screen=self._screen,
stimuli=self._ve_elements)
self._presentation = Presentation(viewports=[self._viewport],
handle_event_callbacks=[
(pygame.KEYDOWN,
self.keyboard_input),
(pygame.QUIT, self.__stop)
])
def init_screen_elements(self):
'''
Initializing screen elements
'''
self._letter_positions = []
## create and place the circles and letters:
circle_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.speller_radius,
start=NP.pi/6.*5)
circle_layout.positions.reverse()
self._letter_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.circle_radius*0.65,
start=NP.pi/6.*5)
self._letter_layout.positions.reverse()
self._shape_positions = [(x+self.geometry[2]/2, y+self._spellerHeight/2) for (x,y) in circle_layout.positions]
# add the standard elements:
for i in xrange(self._nr_elements):
self._ve_edges.append(FilledCircle(radius=self._edge_radius,
position=self._shape_positions[i],
color=self.edge_color))
self._ve_shapes.append(FilledCircle(radius=self._circle_radius,
position=self._shape_positions[i],
color=self.shape_color))
# add the letters of level 1:
for j in xrange(len(self.letter_set[i])): # warning: self.letter_set must be at least of length self._nr_elements!!!
self._letter_positions.append((self._letter_layout.positions[j][0]+self._shape_positions[i][0],
self._letter_layout.positions[j][1]+self._shape_positions[i][1]))
self._ve_letters.append(Text(position=self._letter_positions[-1],
text=self.letter_set[i][j],
font_size=self.font_size_level1,
color=self.letter_color,
anchor='center'))
# add the stimuli letters of level 1:
letter_layout2 = CircularLayout(nr_elements=self._nr_elements,
radius=self.circle_radius*0.65*self.flash_size_factor,
start=NP.pi/6.*5)
letter_layout2.positions.reverse()
for i in xrange(self._nr_elements):
for j in xrange(len(self.letter_set[i])): # warning: self.letter_set must be at least of length self._nr_elements!!!
self._letter_positions.append((letter_layout2.positions[j][0]+self._shape_positions[i][0],
letter_layout2.positions[j][1]+self._shape_positions[i][1]))
self._ve_letters.append(Text(position=self._letter_positions[-1],
text=self.letter_set[i][j],
font_size=int(NP.floor(self.font_size_level1*self.flash_size_factor)),
color=self.letter_stimulus_color,
anchor='center',
on=False))
# add letters of level 2:
for i in xrange(self._nr_elements):
self._ve_letters.append(Text(position=self._shape_positions[i],
text=" ",
font_size=self.font_size_level2,
color=self.letter_color,
anchor='center',
on=False))
# add stimuli letters of level 2:
for i in xrange(self._nr_elements):
self._ve_letters.append(Text(position=self._shape_positions[i],
text=" ",
font_size=int(NP.floor(self.font_size_level2*self.flash_size_factor)),
color=self.letter_stimulus_color,
anchor='center',
on=False))
## add fixation point:
self._ve_fixationpoint = FilledCircle(radius=self.fixationpoint_size,
position=self._centerPos,
color=self.fixationpoint_color)
## create feedback box:
self._ve_feedback_box = Target2D(position=self._centerPos,
size=(self.feedbackbox_size, self.feedbackbox_size),
color=self.feedback_color,
on=False)
## add feedback letters:
self._ve_feedback_letters = []
for i in xrange(self._nr_elements-1):
self._ve_feedback_letters.append(Text(position=(self._letter_layout.positions[i][0]+self._centerPos[0],
self._letter_layout.positions[i][1]+self._centerPos[1]),
color=self.letter_color,
font_size=self.font_size_level1,
text=" ",
on=False,
anchor="center"))
self._ve_feedback_letters.append(Text(position=self._centerPos,
color=self.letter_color,
font_size=self.font_size_level2,
text=" ",
anchor='center',
on=False))
## put all in elements container:
self._ve_elements.extend(self._ve_edges)
self._ve_elements.extend(self._ve_shapes)
self._ve_elements.extend(self._ve_letters)
self._ve_elements.extend([self._ve_feedback_box])
self._ve_elements.extend(self._ve_feedback_letters)
self._ve_elements.append(self._ve_fixationpoint)
def init_screen_elements(self):
'''
Initializing screen elements
'''
## create shapes:
if self.do_animation:
for i in xrange(self._nr_elements):
self._ve_shapes.append(
self.registered_shapes[self.shapes[i][0]](
position=self._centerPos,
color=self.shape_color[i],
on=False,
**self.shapes[i][1]))
## add letters of level 1:
circle_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.speller_radius,
start=NP.pi / 6. * 5)
circle_layout.positions.reverse()
self._letter_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.letter_radius,
start=NP.pi / 6. * 5)
self._letter_layout.positions.reverse()
for i in xrange(self._nr_elements):
# store countdown position:
self._countdown_shape_positions.append(
(self._centerPos[0] + circle_layout.positions[i][0],
self._centerPos[1] + circle_layout.positions[i][1]))
# put shape in container:
self._ve_elements.append(self._ve_shapes[i])
for j in xrange(
len(self.letter_set[i])
): # warning: self.letter_set must be at least of length self._nr_elements!!!
# store position:
self._letter_positions.append(
(self._letter_layout.positions[j][0] +
self._centerPos[0],
self._letter_layout.positions[j][1] +
self._centerPos[1]))
# store countdown position:
self._countdown_letter_positions.append(
(self._letter_layout.positions[j][0] +
self._countdown_shape_positions[-1][0],
self._letter_layout.positions[j][1] +
self._countdown_shape_positions[-1][1]))
# add letter:
self._ve_letters.append(
Text(position=self._letter_positions[-1],
text=self.letter_set[i][j],
font_size=self.font_size_level1,
color=self.letter_color,
anchor='center',
on=False))
# add letters of level 2:
for i in xrange(self._nr_elements):
self._letter_positions.append(self._centerPos)
self._countdown_letter_positions.append(
self._countdown_shape_positions[i])
self._ve_letters.append(
Text(position=self._centerPos,
text=" ",
font_size=self.font_size_level2,
color=(self.level_2_letter_colors
and self.stimuli_colors[i]
or self.letter_color),
anchor='center',
on=False))
# put letters in container:
self._ve_elements.extend(self._ve_letters)
## create feedback box:
self._ve_feedback_box = Target2D(position=self._centerPos,
size=(self.feedbackbox_size,
self.feedbackbox_size),
color=self.feedback_color,
on=False)
## add feedback letters:
self._ve_feedback_letters = []
for i in xrange(self._nr_elements):
self._ve_feedback_letters.append(
Text(position=(self._letter_layout.positions[i][0] +
self._centerPos[0],
self._letter_layout.positions[i][1] +
self._centerPos[1]),
color=self.letter_color,
font_size=self.font_size_level1,
text=" ",
on=False,
anchor="center"))
self._ve_feedback_letters.append(
Text(position=self._centerPos,
color=self.letter_color,
font_size=self.font_size_level2,
text=" ",
anchor='center',
on=False))
## add feedback note (whether or not there was an ErrP detected):
self._ve_feedback_ErrP = Text(
position=self._centerPos,
color=self.feedback_ErrP_color,
text="X",
font_size=self.font_size_feedback_ErrP,
anchor='center',
on=False)
## add fixation point:
self._ve_fixationpoint = FilledCircle(
radius=self.fixationpoint_size,
position=self._centerPos,
color=self.fixationpoint_color,
on=False)
##################### IF NOT DO ANIMATION #########################
else:
## add letters of level 1:
circle_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.speller_radius,
start=NP.pi / 6. * 5)
self._letter_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.letter_radius,
start=NP.pi / 6. * 5)
circle_layout.positions.reverse()
self._letter_layout.positions.reverse()
for i in xrange(self._nr_elements):
self._ve_shapes.append(
self.registered_shapes[self.shapes[i][0]](
position=(self._centerPos[0] +
circle_layout.positions[i][0],
self._centerPos[1] +
circle_layout.positions[i][1]),
color=self.shape_color[i],
on=False,
**self.shapes[i][1]))
for i in xrange(self._nr_elements):
# store countdown position:
self._countdown_shape_positions.append(
(self._centerPos[0] + circle_layout.positions[i][0],
self._centerPos[1] + circle_layout.positions[i][1]))
# put shape in container:
self._ve_elements.append(self._ve_shapes[i])
for j in xrange(
len(self.letter_set[i])
): # warning: self.letter_set must be at least of length self._nr_elements!!!
# store position:
self._letter_positions.append(
(self._letter_layout.positions[j][0] +
self._centerPos[0],
self._letter_layout.positions[j][1] +
self._centerPos[1]))
# store countdown position:
self._countdown_letter_positions.append(
(self._letter_layout.positions[j][0] +
self._countdown_shape_positions[-1][0],
self._letter_layout.positions[j][1] +
self._countdown_shape_positions[-1][1]))
# add letter:
self._ve_letters.append(
Text(position=(self._letter_layout.positions[j][0] +
self._centerPos[0] +
circle_layout.positions[i][0],
self._letter_layout.positions[j][1] +
self._centerPos[1] +
circle_layout.positions[i][1]),
text=self.letter_set[i][j],
font_size=self.font_size_level1,
color=self.letter_color,
anchor='center',
on=False))
# add letters of level 2:
for i in xrange(self._nr_elements):
self._letter_positions.append(
(self._letter_layout.positions[i][0] + self._centerPos[0],
self._letter_layout.positions[i][1] + self._centerPos[1]))
self._countdown_letter_positions.append(
(self._letter_layout.positions[i][0] +
self._countdown_shape_positions[-1][0],
self._letter_layout.positions[i][1] +
self._countdown_shape_positions[-1][1]))
self._ve_letters.append(
Text(position=(self._letter_layout.positions[i][0] +
self._centerPos[0] +
circle_layout.positions[i][0],
self._letter_layout.positions[i][1] +
self._centerPos[1] +
circle_layout.positions[i][1]),
text=" ",
font_size=self.font_size_level2,
color=(self.level_2_letter_colors
and self.stimuli_colors[i]
or self.letter_color),
anchor='center',
on=False))
# put letters in container:
self._ve_elements.extend(self._ve_letters)
## create feedback box:
self._ve_feedback_box = Target2D(position=self._centerPos,
size=(self.feedbackbox_size,
self.feedbackbox_size),
color=self.feedback_color,
on=False)
## add feedback letters:
self._ve_feedback_letters = []
for i in xrange(self._nr_elements):
self._ve_feedback_letters.append(
Text(position=(self._letter_layout.positions[i][0] +
self._centerPos[0],
self._letter_layout.positions[i][1] +
self._centerPos[1]),
color=self.letter_color,
font_size=self.font_size_level1,
text=" ",
on=False,
anchor="center"))
self._ve_feedback_letters.append(
Text(position=self._centerPos,
color=self.letter_color,
font_size=self.font_size_level2,
text=" ",
anchor='center',
on=False))
## add feedback note (whether or not there was an ErrP detected):
self._ve_feedback_ErrP = Text(
position=self._centerPos,
color=self.feedback_ErrP_color,
text="X",
font_size=self.font_size_feedback_ErrP,
anchor='center',
on=False)
## add fixation point:
self._ve_fixationpoint = FilledCircle(
radius=self.fixationpoint_size,
position=self._centerPos,
color=self.fixationpoint_color,
on=False)
# put letters in container:
self._ve_elements.append(self._ve_feedback_box)
self._ve_elements.extend(self._ve_feedback_letters)
self._ve_elements.append(self._ve_feedback_ErrP)
self._ve_elements.append(self._ve_fixationpoint)
def init_screen_elements(self):
'''
Initialize screen elements
'''
self._letter_positions = []
## create triangles:
self._letter_layout = CircularLayout(nr_elements=self._nr_elements,
radius=self.letter_radius,
start=NP.pi / 6. * 5)
self._letter_layout.positions.reverse()
a = self.speller_radius / 2.
b = a * NP.sqrt(3) / 3.
self._shape_positions = [
(self._centerPos[0], self._centerPos[1] + 2 * b),
(self._centerPos[0] + a, self._centerPos[1] + b),
(self._centerPos[0] + a, self._centerPos[1] - b),
(self._centerPos[0], self._centerPos[1] - 2 * b),
(self._centerPos[0] - a, self._centerPos[1] - b),
(self._centerPos[0] - a, self._centerPos[1] + b)
]
orientaion = [180., 0., 180., 0., 180., 0.]
for i in xrange(self._nr_elements):
self._ve_edges.append(
FilledTriangle(size=self.speller_radius,
position=self._shape_positions[i],
orientation=orientaion[i],
color=self.edge_color))
self._ve_shapes.append(
FilledTriangle(size=self.speller_radius - self.edge_size,
position=self._shape_positions[i],
orientation=orientaion[i],
color=self.shape_color))
## add the letters of level 1:
for j in xrange(
len(self.letter_set[i])
): # warning: self.letter_set must be at least of length self._nr_elements!!!
self._letter_positions.append(
(self._letter_layout.positions[j][0] +
self._shape_positions[i][0],
self._letter_layout.positions[j][1] +
self._shape_positions[i][1]))
self._ve_letters.append(
Text(position=self._letter_positions[-1],
text=self.letter_set[i][j],
font_size=self.font_size_level1,
color=self.letter_color,
anchor='center'))
## add letters of level 2:
for i in xrange(self._nr_elements):
self._ve_letters.append(
Text(position=self._shape_positions[i],
text=" ",
font_size=self.font_size_level2,
color=self.letter_color,
anchor='center',
on=False))
## add fixation point:
self._ve_fixationpoint = FilledCircle(radius=self.fixationpoint_size,
position=self._centerPos,
color=self.fixationpoint_color)
## create feedback box:
self._ve_feedback_box = Target2D(position=self._centerPos,
size=(self.feedbackbox_size,
self.feedbackbox_size),
color=self.feedback_color,
on=False)
## add feedback letters:
self._ve_feedback_letters = []
for i in xrange(self._nr_elements - 1):
self._ve_feedback_letters.append(
Text(position=(self._letter_layout.positions[i][0] +
self._centerPos[0],
self._letter_layout.positions[i][1] +
self._centerPos[1]),
color=self.letter_color,
font_size=self.font_size_level1,
text=" ",
on=False,
anchor="center"))
self._ve_feedback_letters.append(
Text(position=self._centerPos,
color=self.letter_color,
font_size=self.font_size_level2,
text=" ",
anchor='center',
on=False))
## put all in elements container:
self._ve_elements.extend(self._ve_edges)
self._ve_elements.extend(self._ve_shapes)
self._ve_elements.extend(self._ve_letters)
self._ve_elements.append(self._ve_feedback_box)
self._ve_elements.extend(self._ve_feedback_letters)
self._ve_elements.append(self._ve_fixationpoint)
