def present(self, feedback):
self.generate_continue()
size = (globalScreen.size[0] - self.config.textDisplayBorder,
globalScreen.size[1] - self.config.textDisplayBorder)
debug("presenting screen")
feedback.registerHandler(self)
debug("instruction <%s>" % self.instruction)
text = WrappedText(
text=self.instruction,
color=(0.0, 0.0,
0.0), # alpha is ignored (set with max_alpha_param)
position=(self.config.textDisplayBorder,
globalScreen.size[1] - self.config.textDisplayBorder),
size=size,
font_size=self.config.textInstructionsSize,
on=1,
font_name=self.config.font)
viewport = Viewport(screen=globalScreen,
size=size,
stimuli=[self._continue, text])
self.updateDisplay(viewport)
self.waitForResponse()
feedback.detachHandler()
viewport = Viewport(screen=globalScreen,
size=globalScreen.size,
stimuli=[])
self.updateDisplay(viewport)
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, 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 add_stimuli(self, *stimuli):
""" Add additional custom stimulus objects to the list of
stimuli. TextList instances need their own Viewport, as they
consist of multiple stimulus objects that are deleted everytime
they change, and so the Viewport needs to have a reference to
the containing TextList, otherwise they get lost.
"""
text_lists = filter(lambda s: isinstance(s, TextList), stimuli)
if text_lists:
for text in text_lists:
self.add_viewport(Viewport(screen=self.screen, stimuli=text))
stimuli = filter(lambda s: not isinstance(s, TextList), stimuli)
stimuli = self._standard_viewport.parameters.stimuli + list(stimuli)
if stimuli:
self.set_stimuli(*stimuli)
def __init__(self, config):
Display.__init__(self, config)
globalScreen.parameters.bgcolor = (.8, .8, .8
) # background white (RGB)
# prepare continue instruction
stimuli = []
self.baseViewport = Viewport(screen=globalScreen,
size=globalScreen.size,
stimuli=stimuli)
self._textWords = ""
self.notifier = None
self.lastWordPresentend = None
self.updateLock = Lock()
# 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
global gamma_scale
gamma_scale = 1.0
def keydown(event):
global gamma_scale
if event.key == pygame.locals.K_ESCAPE:
gl.glLoadIdentity() # Clear the modelview matrix
gl.glTranslate(viewport_with, 0, 0)
gl.glRotate(180, 0, 1, 0)
matrix = gl.glGetFloatv(gl.GL_MODELVIEW_MATRIX)
gl.glPopMatrix()
if matrix is None:
# OpenGL wasn't started
raise RuntimeError(
"OpenGL matrix operations can only take place once OpenGL context started."
)
matrix = np.asarray(matrix) # make sure it's numpy array
VisionEgg.Core.ModelView.__init__(self, **{'matrix': matrix})
# Normal stuff (from grating demo):
screen = VisionEgg.Core.get_default_screen()
grating = SinGrating2D(
position=(screen.size[0] / 2.0, screen.size[1] / 2.0),
anchor='center',
size=(400.0, 300.0),
spatial_freq=10.0 / screen.size[0], # units of cycles/pixel
temporal_freq_hz=5.0,
orientation=45.0)
viewport = Viewport(screen=screen, stimuli=[grating])
viewport.parameters.camera_matrix = HorizontalMirrorView(offset=screen.size[0])
p = Presentation(go_duration=(5.0, 'seconds'), viewports=[viewport])
# Go!
p.go()
def __init_viewports(self):
""" Provide a standard viewport. """
self._standard_viewport = Viewport(screen=self.screen)
self.add_viewport(self._standard_viewport)
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)
])
else:
ns1 = Text(text=str(my_n1),
angle=0,
anchor='center',
position=[x * 3, y],
color=[255, 255, 255],
font_size=fontsize)
ns2 = Text(text=str(my_n2),
angle=a,
anchor='center',
position=[x * 4, y],
color=[255, 255, 255],
font_size=fontsize)
expPort = Viewport(screen=screen, stimuli=[ns1, ns2])
print "----------------------"
print "PROBLEM: %s" % problemString
print "Rotated: %s" % s
print "Larger: %s" % b
print "----------------------"
else:
random.shuffle(numbers)
ns1 = str(numbers[0])
ns2 = str(numbers[1])
if len(ns1) == 1:
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()
swap_buffers()
frame_timer.tick()
frame_timer.log_histogram()
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 = []
# The center of the screen is looking, in 3D world coordinates, at -z,
# with +y up and +x right. In cylindrical coordinates, the -z axis
# corresponds with theta = 0 and the +y axis corresponds with +h, and
box2 = TextureStimulus(color=[1, 1, 1],
anchor='center',
position=[x * 3, y],
size=[boxsize, boxsize])
ns1 = Text(text=str(n1),
anchor='center',
position=[x, y],
color=[0, 0, 0],
font_size=fontsize)
ns2 = Text(text=str(n2),
anchor='center',
position=[x * 3, y],
color=[0, 0, 0],
font_size=fontsize)
expPort = Viewport(screen=screen, stimuli=[box1, box2, ns1, ns2])
subject.inputData(trial, "n1", n1)
subject.inputData(trial, "n2", n2)
subject.inputData(trial, "problem", problem)
#format problem
print "----------------------"
print "PROBLEM: %s" % problem
print "SOLUTION: %s " % solution
print "----------------------"
ns = [n1, n2]
#default values for misfiring voice key
misfire = 0
screen = get_default_screen()
screen.parameters.bgcolor = (0.0,0.0,0.0,0.0) # make black (RGBA)
######################################
# Create random dot stimulus #
######################################
stimulus = DotArea2D( position = ( screen.size[0]/2.0, screen.size[1]/2.0 ),
anchor = 'center',
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)
###############################################################
# Create viewport - intermediary between stimuli and screen #
###############################################################
viewport = Viewport( screen=screen, stimuli=[stimulus] )
########################################
# Create presentation object and go! #
########################################
p = Presentation(go_duration=(10.0,'seconds'),viewports=[viewport])
p.go()
# Create the instance of TextureStimulus3D
duration = 5.0
speed = 1.0
z = duration * speed
stimulus = TextureStimulus3D(
texture=texture,
shrink_texture_ok=True,
internal_format=gl.GL_RGBA,
)
def every_frame_func(t=None):
z = t * speed - duration
stimulus.parameters.upperleft = (-5, 1, z)
stimulus.parameters.lowerleft = (-5, -1, z)
stimulus.parameters.lowerright = (5, -1, z)
stimulus.parameters.upperright = (5, 1, z)
every_frame_func(0.0) # set initial stimulus postion
projection = SimplePerspectiveProjection(fov_x=135.0)
viewport = Viewport(screen=screen, projection=projection, stimuli=[stimulus])
p = Presentation(go_duration=(duration, 'seconds'), viewports=[viewport])
p.add_controller(None, None,
FunctionController(during_go_func=every_frame_func))
p.go()
#!/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()
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])
p.go()
