def __init__(self, text):
self.text = text
self.color = [random.random() for i in (1,2,3)]
self.type = 'text'
Text.__init__(self, text = text, font_size = 50,
color = self.color, **std_params)
def __init__(self, stim_string):
self.stim_string = stim_string
Text.__init__(self,
text=stim_string,
font_size=50,
color=[200, 200, 200],
**std_params)
def __init__(self, config, question):
self.displayPhrase = False
colorBlack = (0.0, 0.0, 0.0)
answLeft, answRight = question['answers']
answ_correct = question['correct']
question = question['question']
self.textAnswLeft = answLeft
self.textAnswRight = answRight
self.textAnswCorrect = answ_correct
border = config.textDisplayBorder
size = (globalScreen.size[0] - border, globalScreen.size[1] - border)
positionQuestion = [globalScreen.size[0] / 2, globalScreen.size[1] / 2]
positionAnswLeft = [border, border]
positionAnswRight = [globalScreen.size[0] - border, border]
self._question = Text(text=question,
color=colorBlack,
size=size,
on=1,
font_size=config.textQuestionSize,
font_name=config.font)
positionQuestion[
0] = positionQuestion[0] - self._question.parameters.size[0] / 2
self._question.parameters.position = positionQuestion
self._answLeft = Text(text=answLeft,
color=colorBlack,
size=size,
on=1,
font_size=config.textAnswerSize,
font_name=config.font)
self._answLeft.parameters.position = positionAnswLeft
self._answRight = Text(text=answRight,
color=colorBlack,
size=size,
on=1,
font_size=config.textAnswerSize,
font_name=config.font)
positionAnswRight[
0] = positionAnswRight[0] - self._answRight.parameters.size[0]
self._answRight.parameters.position = positionAnswRight
self._viewport = Viewport(
screen=globalScreen,
size=size,
stimuli=[self._question, self._answLeft, self._answRight])
ResponseHandler.__init__(self, config)
EventRecorder.__init__(self)
def update(t):
dt = t / self.animation_time
self._viewport.parameters.stimuli = self._viewport.parameters.stimuli[:-(
self._nr_elements)]
feedback_letters = []
for i in xrange(self._nr_elements):
pos = (animate_sigmoid(
NP.add(self._letter_layout.positions[i],
self._centerPos),
self._countdown_shape_positions[i], dt))
font_size = int(
round(
animate(self.font_size_level1,
self.font_size_level2, dt)))
color = (self.level_2_letter_colors and list(
animate(self.letter_color, self.stimuli_colors[i],
dt)) or self.letter_color)
text = (
i == self._nr_elements - 1 and self.backdoor_symbol
or self.letter_set[self._classified_element][i])
feedback_letters.append(
Text(position=pos,
color=color,
font_size=font_size,
text=text,
anchor="center"))
self._viewport.parameters.stimuli.extend(
feedback_letters)
if self.feedback_show_shape_at_center:
pos = animate_sigmoid(
self._centerPos, self._countdown_shape_positions[
self._classified_element], dt)
self._ve_shapes[self._classified_element].set(
position=pos)
def run():
screen = Screen()
screen.parameters.bgcolor = (0.0, 0.0, 0.0) # black (RGB)
dots = DotArea2D(position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
size=(300.0, 300.0),
signal_fraction=0.1,
signal_direction_deg=180.0,
velocity_pixels_per_sec=10.0,
dot_lifespan_sec=5.0,
dot_size=3.0,
num_dots=100)
text = Text(text="Vision Egg dot_simple_loop demo.",
position=(screen.size[0] / 2, 2),
anchor='bottom',
color=(1.0, 1.0, 1.0))
viewport = Viewport(screen=screen, stimuli=[dots, text])
# The main loop below is an alternative to using the
# VisionEgg.FlowControl.Presentation class.
quit_now = 0
while not quit_now:
for event in pygame.event.get():
if event.type in (QUIT, KEYDOWN, MOUSEBUTTONDOWN):
quit_now = 1
screen.clear()
viewport.draw()
swap_buffers()
screen.close()
def __init__(self, nrow, ncol, screen, anchor='center'):
"""Accept number of columns and rows, and how to anchor stimuli
"""
self.nrow = nrow
self.ncol = ncol
self.screen = screen
self.anchor = anchor
self.npanels = nrow * ncol
self.panel = []
for i in xrange(nrow):
self.panel.append([])
for j in xrange(ncol):
p = Panel(size=(screen.size[0] / ncol, screen.size[1] / nrow),
position=((j) * screen.size[0] / ncol,
(i) * screen.size[1] / nrow),
coords=(i, j),
label="(%d, %d)" % (i, j))
p.stimulus = Text(text=p.label,
position=p.center,
anchor=anchor)
self.panel[i].append(p)
self.all_panels = list(chain.from_iterable(self.panel))
def make_stimuli(self):
position = self.viewport.deg2pix(self.parameters.xorigDeg) + self.viewport.xorig ,\
self.viewport.deg2pix(self.parameters.yorigDeg) + self.viewport.yorig
self.text = Text(text=self.parameters.text,
position=position,
color=self.parameters.color,
font_size=self.parameters.fontsize,
anchor='center')
self.stimuli = [self.text]
def generate_continue(self):
self._continue = Text(text=self.config.string_continue,
color=(0.0, 0.0, 0.0),
position=(globalScreen.size[0] / 2,
self.config.textContinueDistance),
font_size=self.config.textContinueSize,
anchor='center',
on=1,
font_name=self.config.font)
def update(t):
# Add one screen refresh (otherwise animation lags by 1 frame)
dt = t/self.animation_time
self._viewport.parameters.stimuli = self._viewport.parameters.stimuli[:-1]
pos = animate_sigmoid(self._centerPos, self._current_letter_position, dt)
color = animate_sigmoid(self.letter_color, self.current_letter_color, dt)
font_size = int(round(animate(self.font_size_level2, self.font_size_current_letter, dt)))
self._viewport.parameters.stimuli.append(Text(position=pos,
color=color,
font_size=font_size,
text=text,
anchor='center'))
def update(t):
dt = t/self.animation_time
self._viewport.parameters.stimuli = self._viewport.parameters.stimuli[:-(self._nr_elements-1)]
feedback_letters = []
for i in xrange(self._nr_elements-1):
pos = animate_sigmoid(NP.add(self._letter_layout.positions[i], self._centerPos), self._shape_positions[i], dt)
font_size = int(round(animate(self.font_size_level1, self.font_size_level2, dt)))
feedback_letters.append(Text(position=pos,
color=self.letter_color,
font_size=font_size,
text=self.letter_set[self._classified_element][i],
anchor="center"))
self._viewport.parameters.stimuli.extend(feedback_letters)
def update(t):
dt = t / self.animation_time
self._viewport.parameters.stimuli = self._viewport.parameters.stimuli[:
-1]
pos = animate_sigmoid(self._centerPos,
self._current_letter_position, dt)
color = (self.level_2_letter_colors and list(
animate_sigmoid(
self.stimuli_colors[self._classified_letter],
self.current_letter_color, dt)) or list(
animate_sigmoid(self.letter_color,
self.current_letter_color,
dt)))
font_size = int(
round(
animate(self.font_size_level2,
self.font_size_current_letter, dt)))
self._viewport.parameters.stimuli.append(
Text(position=pos,
color=color,
font_size=font_size,
text=text,
anchor='center'))
def test_dav_obscure_bug():
# Test a bug reported by Dav Clark. Ported from
# http://www.freelists.org/archives/visionegg/08-2008/msg00000.html
s = VisionEgg.Core.Screen()
t = Text()
t.set(text='test')
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)
])
#!/usr/bin/env python
"""Display text strings."""
import VisionEgg
VisionEgg.start_default_logging(); VisionEgg.watch_exceptions()
from VisionEgg.Core import get_default_screen, Viewport
from VisionEgg.FlowControl import Presentation
from VisionEgg.Text import Text
screen = get_default_screen()
screen.parameters.bgcolor = (0.0,0.0,1.0) # background blue (RGB)
text = Text(text="Hello world!",
color=(1.0,1.0,1.0), # alpha is ignored (set with max_alpha_param)
position=(screen.size[0]/2,screen.size[1]/2),
font_size=50,
anchor='center')
viewport = Viewport(screen=screen,
size=screen.size,
stimuli=[text])
p = Presentation(go_duration=(5.0,'seconds'),viewports=[viewport])
p.go()
def __init__(self,face):
self.face = face
Text.__init__(self, text=face, font_size=50,
color=[random.random() for i in (1,2,3)],
**std_params)
import numpy
screen = get_default_screen()
screen.parameters.bgcolor = (0.0, 0.0, 0.0) # black (RGB)
stimulus = SinGrating3D(
spatial_freq=20.0,
temporal_freq_hz=1.0,
upperleft=(-5, .25, -1),
lowerleft=(-5, -.25, -1),
lowerright=(5, -.25, -1),
upperright=(5, .25, -1),
)
text = Text(text="Vision Egg project_linear_grating_on_cylinder demo.",
position=(screen.size[0] / 2, 2),
anchor='bottom',
color=(1.0, 1.0, 1.0))
# use default 2D pixel-coordinate projection for text
overlay_viewport = Viewport(screen=screen, stimuli=[text])
num_viewports = 20
arc_degrees = 150 # angle of display
D2R = pi / 180.0
arc = arc_degrees * D2R
arc_center = arc / 2
viewport_arc = arc / num_viewports
eye = (0, 0, 0)
camera_up = (0, 1, 0)
viewports = []
def add(self, text, size):
new = Text(font_size=size, text=text, anchor='bottom')
self.append(new)
self._rearrange()
def __init__(self, expparadigm, config, phrases, args):
# TODO: add a 'question' argument
debug("__init__")
Trial.__init__(self,
config,
args['experiment'],
args['item'],
args['condition'],
args['mode'],
phrases,
len(phrases) + 1,
question=None)
if expparadigm == "MR-SAT":
self.paradigm = "MR"
elif expparadigm == "SAT":
self.paradigm = "SR"
else:
raise ("Invalid experiment paradigm.")
mode = args['mode']
if not args.has_key('speededAcceptability'):
args['speededAcceptability'] = False
#if not args.has_key('lastFeedbackOffset'):
# args['lastFeedbackOffset'] = 0
self.args = args
self.displayPhrase = None
self.lastPhraseRead = None
self.lastResponseCorrect = None
# create phrase chunks
masked_phrases = []
text_phrases = []
space = Text(text=" ",
color=(0.0, 0.0, 0.0),
position=(0, 0),
font_size=self.config.sprStimulusSize,
anchor='left',
on=0,
font_name=self.config.font)
space_size = space.parameters.size[0]
# set initial word coordinates
phrase_positions = []
if mode == CPresentationMode.MovingWindow:
x_pos = self.config.xPositionStart
y_pos = globalScreen.size[1] / 2
anchor = "left"
elif mode == CPresentationMode.Centered:
x_pos = globalScreen.size[0] / 2
y_pos = globalScreen.size[1] / 2
anchor = "center"
# create phrases
self.sentence = ""
for i in range(0, len(phrases)):
if phrases[i] == "$":
self.phraseSignalReference = i
continue
self.sentence = self.sentence + " " + phrases[i]
text = Text(text=phrases[i],
color=(0.0, 0.0, 0.0),
position=(x_pos, y_pos),
font_size=self.config.sprStimulusSize,
anchor=anchor,
on=0,
font_name=self.config.font)
if mode == CPresentationMode.MovingWindow:
phrase_positions.append((x_pos, y_pos))
x_pos = x_pos + text.parameters.size[0] + space_size
text_phrases.append(text)
# TODO: Fix y coordinates too. Necessary once the stimulus
# becomes longer than one line.
assert (hasattr(self, "phraseSignalReference"))
self.sentence.strip()
# create masks if the mode is moving window
if mode == CPresentationMode.MovingWindow:
for i in range(0, len(phrases)):
text_size = text_phrases[i].parameters.size
mask_size = (text_size[0], config.sprMaskHeight)
mask_position = [
phrase_positions[i][0], phrase_positions[i][1]
]
mask_position[1] = mask_position[1] - (text_size[1] / 2 -
mask_size[1] / 2)
phrase_mask = Target2D(color=(0.0, 0.0, 0.0),
position=mask_position,
anchor='left',
on=1,
size=mask_size)
masked_phrases.append(phrase_mask)
self.screen = TrialScreenSAT(config, text_phrases, masked_phrases,
mode, self.args['signalsCnt'],
self.args['feedbackIndicators'],
self.args['mappingIndicators'])
if not self.args['speededAcceptability']:
self.responses = [False] * self.args['signalsCnt']
else:
self.responses = [False]
self._directionBeforeSignal = None
self._directionAfterSignal = None
import VisionEgg
VisionEgg.start_default_logging()
VisionEgg.watch_exceptions()
from VisionEgg.Core import get_default_screen, Viewport, gl
from VisionEgg.FlowControl import Presentation
from VisionEgg.Text import Text
from VisionEgg.Textures import Texture, TextureStimulus
screen = get_default_screen()
screen.parameters.bgcolor = (0.0, 0.0, 1.0) # background blue (RGB)
orig_text = Text(
text="Hello world!",
color=(1.0, 1.0, 1.0),
font_size=50,
)
arr = orig_text.parameters.texture.get_texels_as_array() # get numpy array
arr = arr[::-1] # flip upside down
flipped_text = TextureStimulus(
texture=Texture(arr),
position=(screen.size[0] / 2, screen.size[1] / 2),
anchor='center',
internal_format=gl.GL_RGBA,
mipmaps_enabled=False,
)
viewport = Viewport(screen=screen, size=screen.size, stimuli=[flipped_text])
p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport])
def __init__(self,
config,
experiment,
item,
condition,
mode,
phrases,
question=None):
debug("__init__")
Trial.__init__(self, config, experiment, item, condition, mode,
phrases,
len(phrases) + 1, question)
self.displayPhrase = None
self.lastPhraseRead = None
# create phrase chunks
masked_phrases = []
text_phrases = []
i = 0
signalReference = -1
space = Text(text=" ",
color=(0.0, 0.0, 0.0),
position=(0, 0),
font_size=self.config.sprStimulusSize,
anchor='left',
on=0,
font_name=self.config.font)
space_size = space.parameters.size[0]
# set initial word coordinates
phrase_positions = []
if mode == CPresentationMode.MovingWindow:
x_pos = self.config.xPositionStart
y_pos = globalScreen.size[1] / 2
anchor = "left"
elif mode == CPresentationMode.Centered:
x_pos = globalScreen.size[0] / 2
y_pos = globalScreen.size[1] / 2
anchor = "center"
# create phrases
for i in range(0, len(phrases)):
if phrases[i] == "$":
raise "There should not be a '$' in an SPR stimulus."
text = Text(text=phrases[i],
color=(0.0, 0.0, 0.0),
position=(x_pos, y_pos),
font_size=self.config.sprStimulusSize,
anchor=anchor,
on=0,
font_name=self.config.font)
if mode == CPresentationMode.MovingWindow:
phrase_positions.append((x_pos, y_pos))
x_pos = x_pos + text.parameters.size[0] + space_size
text_phrases.append(text)
# TODO: Fix y coordinates too. Necessary once the stimulus becomes longer than one line.
# create masks if the mode is moving window
if mode == CPresentationMode.MovingWindow:
for i in range(0, len(phrases)):
text_size = text_phrases[i].parameters.size
mask_size = (text_size[0], config.sprMaskHeight)
mask_position = [
phrase_positions[i][0], phrase_positions[i][1]
]
mask_position[1] = mask_position[1] - (text_size[1] / 2 -
mask_size[1] / 2)
phrase_mask = Target2D(color=(0.0, 0.0, 0.0),
position=mask_position,
anchor='left',
on=1,
size=mask_size)
masked_phrases.append(phrase_mask)
self.screen = TrialScreen(config, text_phrases, masked_phrases, mode)
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)
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)
import pygame
import numpy as np
if not hasattr(pygame.display, "set_gamma_ramp"):
raise RuntimeError(
"Need pygame 1.5 or greater for set_gamma_ramp function.")
# Initialize OpenGL graphics screen.
screen = get_default_screen()
center_x = screen.size[0] / 2.0
# Create the instance SinGrating with appropriate parameters
stimulus = SinGrating2D()
text2 = Text(text="set_gamma_ramp(r,g,b):",
position=(center_x, 0),
anchor="bottom")
text1 = Text(text="Press - to decrease luminance range, + to increase.",
position=(center_x, text2.parameters.size[1] + 5),
anchor="bottom")
# Use viewport with pixel coordinate system for projection
viewport = Viewport(screen=screen, stimuli=[stimulus, text1, text2])
def quit(event):
global p # get presentation instance
p.parameters.quit = 1
# set initial value
from VisionEgg.Dots import DotArea2D
screen = get_default_screen()
screen.parameters.bgcolor = (0.0, 0.0, 0.0) # black (RGB)
dots = DotArea2D(position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
size=(300.0, 300.0),
signal_fraction=0.1,
signal_direction_deg=180.0,
velocity_pixels_per_sec=10.0,
dot_lifespan_sec=5.0,
dot_size=3.0,
num_dots=100)
text = Text(text="Vision Egg dot_simple_loop demo.",
position=(screen.size[0] / 2, 2),
anchor='bottom',
color=(1.0, 1.0, 1.0))
viewport = Viewport(screen=screen, stimuli=[dots, text])
# The main loop below is an alternative to using the
# VisionEgg.FlowControl.Presentation class.
frame_timer = FrameTimer()
quit_now = 0
while not quit_now:
for event in pygame.event.get():
if event.type in (QUIT, KEYDOWN, MOUSEBUTTONDOWN):
quit_now = 1
screen.clear()
viewport.draw()
from math import sin, pi
import math
from pygame.locals import QUIT, KEYDOWN, MOUSEBUTTONDOWN
import numpy
#####################################
# Initialize OpenGL window/screen #
#####################################
screen = get_default_screen()
screen.parameters.bgcolor = (0.0, 0.0, 0.0, 0.0) # make black (RGBA)
# display loading screen ASAP
screen.clear()
loading_text = Text(
text="Vision Egg multi stimulus demo - Loading...",
position=(screen.size[0] / 2, screen.size[1] / 2),
anchor='center',
color=(1.0, 1.0, 1.0),
)
viewport_2d = Viewport(
screen=screen,
stimuli=[loading_text],
)
viewport_2d.draw()
swap_buffers()
x1 = screen.size[0] / 4
x2 = 2 * screen.size[0] / 4
x3 = 3 * screen.size[0] / 4
y1 = screen.size[1] / 3
y2 = 2 * screen.size[1] / 3
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)
SUBJECT = raw_input('Participant: ')
time_point = int(raw_input('Time (1/2/3/4): '))
# initialize vision egg
vision_egg = SimpleVisionEgg()
screen = vision_egg.screen
screen.parameters.bgcolor = (0, 0, 0)
xlim, ylim = vision_egg.screen.size # size of the screen in pixels
# a few useful stim objects
std_params = {
'anchor': 'center', # for text display objects
'position': (xlim / 2, ylim / 2),
'on': False
}
fixation = Text(text="+", font_size=55, **std_params)
mask = Text(text="XXXXXXXXXXX", font_size=55, **std_params)
blank = Text(text="", **std_params)
rest_screen = Text(text="Press SPACE to continue.", **std_params)
###########################
# A couple useful classes #
###########################
class TextStim(Text):
"""Stimulus text object"""
def __init__(self, stim_string):
self.stim_string = stim_string
Text.__init__(self,
text=stim_string,
