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, text_phrases, masked_phrases, mode, indicators=[]): self.config = config self.text_phrases = text_phrases self.masked_phrases = masked_phrases self.current_index = -1 stimuli = copy.copy(text_phrases) stimuli.extend(masked_phrases) stimuli.append(self.fixationCross) stimuli.extend(indicators) Viewport.__init__(self, screen=globalScreen, stimuli=stimuli) self.mode = mode if mode == CPresentationMode.MovingWindow: self.hide_mask = config.sprHideMask elif mode == CPresentationMode.Centered: self.hide_mask = False else: raise "No other mode is implemented so far." # determine all necessary positions for the fixation cross self.fixationCross.parameters.size = ( config.sprFixationCrossSize, ) * 2 position = self.text_phrases[0].parameters.position size = self.text_phrases[0].parameters.size self.fixationCrossFirstWord = (position[0] + size[0] / 2, position[1] + self.config.sprFixationCrossSize / 4) self.fixationCrossCenter = (globalScreen.size[0] / 2, position[1] + self.config.sprFixationCrossSize / 4)
def __init__(self, config, text_phrases, masked_phrases, mode, indicators=[]): self.config = config self.text_phrases = text_phrases self.masked_phrases = masked_phrases self.current_index = -1 stimuli = copy.copy(text_phrases) stimuli.extend(masked_phrases) stimuli.append(self.fixationCross) stimuli.extend(indicators) Viewport.__init__(self, screen=globalScreen, stimuli=stimuli) self.mode = mode if mode == CPresentationMode.MovingWindow: self.hide_mask = config.sprHideMask elif mode == CPresentationMode.Centered: self.hide_mask = False else: raise "No other mode is implemented so far." # determine all necessary positions for the fixation cross self.fixationCross.parameters.size = (config.sprFixationCrossSize,)*2 position = self.text_phrases[0].parameters.position size = self.text_phrases[0].parameters.size self.fixationCrossFirstWord = (position[0]+size[0]/2, position[1]+self.config.sprFixationCrossSize/4) self.fixationCrossCenter = (globalScreen.size[0]/2, position[1]+self.config.sprFixationCrossSize/4)
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()
def __init_viewports(self): """ Provide a standard viewport. """ self._standard_viewport = Viewport(screen=self.screen) self.add_viewport(self._standard_viewport)
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()
# 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:
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()
class VisionEggView(object): """ This class handles VisionEgg internals and the creation of common/standard stimuli like centered words, a fixation cross or a countdown. Inherit this and pass the type to VisionEggFeedback for customization. """ def __init__(self): self.__init_attributes() def __init_attributes(self): """ Setup internal attributes. """ self._logger = logging.getLogger('VisionEggView') self._logger.addHandler(logging.FileHandler('log')) self._screen_acquired = False self._viewports = [] def set_trigger_function(self, trigger): self._trigger = trigger def set_event_handlers(self, event_handlers): """ Set pygame/VisionEgg event handler function. """ self._event_handlers = event_handlers def set_iterator_semaphore(self, flag): """ Specify the object to be used as semaphore for iterators. See L{Switcherator} for more. """ self._iter = lambda it: Switcherator(flag, it) def update_parameters(self, **kwargs): """ Apply new parameters set from pyff. """ for k, v in kwargs.iteritems(): setattr(self, '_' + k, v) if self._screen_acquired: self.reinit() def acquire(self): """ Allow L{update_parameters} initialize VisionEgg. """ self._screen_acquired = True def reinit(self): """ Initialize VisionEgg objects. """ self.__init_screen() self.__init_presentation() self.__init_viewports() self.init() self.__init_text() def init(self): """ Overload this for additional custom VisionEgg initialization. """ pass def __init_screen(self): """ Create the VisionEgg Screen object using the pyff configuration parameters 'fullscreen' and 'geometry' and the font and background colors according to parameters 'font_color_name' and 'bg_color'. """ params = {'fullscreen': self._fullscreen, 'sync_swap': True} if not self._fullscreen: os.environ['SDL_VIDEO_WINDOW_POS'] = '%d, %d' % (self._geometry[0], self._geometry[1]) params['size'] = self._geometry[2:] self.screen = Screen(**params) self._set_bg_color() self._set_font_color() def __init_presentation(self): """ Provide a standard presentation object. """ self.presentation = Presentation( handle_event_callbacks=self._event_handlers) def __init_viewports(self): """ Provide a standard viewport. """ self._standard_viewport = Viewport(screen=self.screen) self.add_viewport(self._standard_viewport) def __init_text(self): """ Provide a text in the screen center for standard stimuli and fixation cross etc. """ sz = self.screen.size self._center_text = self.add_color_word(position=(sz[0] / 2., sz[1] / 2.), font_size=self._font_size) def add_viewport(self, viewport): """ Add an additional custom viewport object to the list of viewports. """ self._viewports.append(viewport) self.presentation.set(viewports=self._viewports) def clear_stimuli(self): """ Remove all existing stimuli in the standard viewport. """ self.set_stimuli() 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 set_stimuli(self, *stimuli): """ Set the list of stimulus objects. """ self._standard_viewport.set(stimuli=list(stimuli)) def add_text_stimulus(self, text, font_size=None, **kw): if not kw.has_key('anchor'): kw['anchor'] = 'center' font_size = font_size or self._font_size txt = VisionEgg.Text.Text(text=text, font_size=font_size, **kw) self.add_stimuli(txt) return txt def add_color_word(self, text='', font_size=None, **kw): font_size = font_size or self._font_size txt = ColorWord(text=text, symbol_size=font_size, **kw) self.add_stimuli(txt) return txt def add_image_stimulus(self, **kw): if not kw.has_key('anchor'): kw['anchor'] = 'center' img = TextureStimulus(**kw) self.add_stimuli(img) return img def _create_color(self, name): try: if isinstance(name, tuple): return Color(*name).normalize() else: return Color(str(name)).normalize() except ValueError: self._logger.warn('No such pygame.Color: %s' % str(name)) def _set_font_color(self): """ Set the standard font color by pygame name. """ self._font_color = (self._create_color(self._font_color_name) or Color(1, 1, 1, 255).normalize()) def _set_bg_color(self): """ Set the standard background color by pygame name. """ c = (self._create_color(self._bg_color) or Color(0, 0, 0, 255).normalize()) self.screen.set(bgcolor=c) def present_frames(self, num_frames): """ Launch the presentation main loop for a given number of frames. """ self.presentation.set(go_duration=(num_frames, 'frames')) self.presentation.go() def present(self, sec): self.presentation.set(go_duration=(sec, 'seconds')) self.presentation.go() def update(self): """ Repaint the canvas for one frame to update changed stimuli. """ self.present_frames(1) def center_word(self, text, color=None): """ Set the standard word in the screen center. """ self._center_text.set(text=text) self._center_text.set(colors=color or (self._font_color for l in self._center_text)) def clear_center_word(self): """ Remove the center word from the screen. """ self.center_word('') self.update() def present_center_word(self, text, seconds, color=None): self.center_word(text, color) self.present(seconds) self.clear_center_word() def ask(self, question=True): """ Loop indefinitely until answered() is called. If question is True, a question mark is shown in the center. """ if question: self.center_word('?') self.presentation.run_forever() self.presentation.set(quit=False) self.clear_center_word() def answered(self): """ Abort the current presentation (usually the question mark) after subject input. For thread safety, the screen shouldn't be changed here. """ self.presentation.set(quit=True) def show_fixation_cross(self): """ Display the pyff parameter 'fixation_cross_symbol' for the period of time given by pyff parameter 'fixation_cross_time'. """ self.center_word(self._fixation_cross_symbol) self._trigger(marker.FIXATION_START, wait=True) self.present(self._fixation_cross_time) self._trigger(marker.FIXATION_END, wait=True) def countdown(self): """ Display a countdown according to pyff parameters 'countdown_start' and 'countdown_symbol_duration'. """ self._trigger(marker.COUNTDOWN_START, wait=True) for i in self._iter(reversed(xrange(self._countdown_start + 1))): self.center_word(str(i)) self.present(self._countdown_symbol_duration) self._trigger(marker.COUNTDOWN_END, wait=True) self.clear_center_word() def close(self): """ Shut down the screen. """ self._screen_acquired = False self.screen.close() def quit(self): """ Stop the presentation. """ self.presentation.set(quit=True) self.presentation.set(go_duration=(1, 'frames'))
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()
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:
from VisionEgg.Core import get_default_screen, Viewport, swap_buffers, \ FrameTimer from VisionEgg.Text import Text from VisionEgg.WrappedText import WrappedText import pygame from pygame.locals import QUIT,KEYDOWN,MOUSEBUTTONDOWN screen = get_default_screen() screen.parameters.bgcolor = (0.0,0.0,1.0) # background blue (RGB) text = WrappedText( text="""Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas ac magna nibh. Cras ac volutpat purus. Suspendisse potenti. Vestibulum accumsan erat ac massa hendrerit semper. Ut a laoreet magna. Suspendisse risus odio, porttitor nec sodales nec, laoreet sit amet tellus. Maecenas condimentum orci id magna laoreet tincidunt. Sed porta velit a ligula ullamcorper accumsan. Fusce a felis tortor, vel hendrerit mauris.""", position=(0,screen.size[1])) viewport = Viewport(screen=screen, size=screen.size, stimuli=[text]) frame_timer = FrameTimer() quit_now = 0 print "press any key or click the mouse to stop" 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
# 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()
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
def main(live_demo = False, # if True, never leave VR mode ): os.environ['SDL_VIDEO_WINDOW_POS']="0,0" screen=Screen(size=(1024,768), bgcolor=(0,0,0), alpha_bits=8, frameless=True #fullscreen=True, ) if 1: # this loads faster, for debugging only mipmaps_enabled=False else: mipmaps_enabled=True DEBUG='none' # no debugging #DEBUG='flicker' # alternate views on successive frames vr_walls = {} ########## WALL 2 ################# if 1: # order: LL, UL, UR, LR # -y wall # load data file filename = '/home/floris/data/calibrations/projector/flydra_data_20100816_141544' fd = open( filename, mode='r') data = pickle.load(fd) # find best fit plane C = VR_math.ensure_coplanar(data,also_ensure_parallel=True) corners_3d = [ # LL (C[1,0], C[1,1], C[1,2]), # UL (C[0,0], C[0,1], C[0,2]), # UR (C[2,0], C[2,1], C[2,2]), #-0.49650067090988159 # LR (C[3,0], C[3,1], C[3,2]), #-0.52826571464538574 ] corners_2d = [ # LL (513, 1), # UL (513,768), #UR (1024,550), # LR (1024,50), ] name = '-y' approx_view_dir = None vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, approx_view_dir,name) vr_walls[name] = vr_wall_dict ########## WALL 3 ################# if 1: # order: LL, UL, UR, LR # -y wall # load data file filename = '/home/floris/data/calibrations/projector/flydra_data_20100816_141500' fd = open( filename, mode='r') data = pickle.load(fd) # find best fit plane C = VR_math.ensure_coplanar(data,also_ensure_parallel=False) #C = np.random.random(C.shape) corners_3d = [ # LL (C[3,0], C[3,1], C[3,2]), # UL (C[2,0], C[2,1], C[2,2]), # UR (C[0,0], C[0,1], C[0,2]), #-0.49650067090988159 # LR (C[1,0], C[1,1], C[1,2]), #-0.52826571464538574 ] corners_2d = [ # LL (1,50), # UL (1,620), # UR (512,768), # LR (512,1), ] name = '+x' approx_view_dir = None vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, approx_view_dir,name) vr_walls[name] = vr_wall_dict screen_stimuli = [] for wall in vr_walls.itervalues(): screen_stimuli.extend( wall['display_stimuli'] ) display_viewport = Viewport( screen=screen, stimuli=screen_stimuli, ) # OpenGL textures must be power of 2 def next_power_of_2(f): return math.pow(2.0,math.ceil(math.log(f)/math.log(2.0))) fb_width_pow2 = int(next_power_of_2(screen.size[0])) fb_height_pow2 = int(next_power_of_2(screen.size[1])) frame_timer = FrameTimer() # draw static white walls draw_stimuli = True for wallname,wall in vr_walls.iteritems(): screen.set(bgcolor=BGCOLOR) screen.clear() # clear screen wall['cam_viewport'].draw() if 0: framebuffer_texture_object = wall['framebuffer_texture_object'] # copy screen back-buffer to texture framebuffer_texture_object.put_new_framebuffer( size=(fb_width_pow2,fb_height_pow2), internal_format=gl.GL_RGB, buffer='back', ) screen.set(bgcolor=(0.0,0.0,0.0)) #black screen.clear() # clear screen display_viewport.draw() # draw the viewport and hence the stimuli swap_buffers() # swap buffers quit_now = False while not quit_now: # infinite loop to draw stimuli # test for keypress or mouseclick to quit for event in pygame.event.get(): if event.type in (QUIT,MOUSEBUTTONDOWN): #if event.type in (QUIT,KEYDOWN,MOUSEBUTTONDOWN): quit_now = True pass
def main(connect_to_mainbrain=True, save_osg_info=None, # dict with info live_demo = False, # if True, never leave VR mode ): global EXPERIMENT_STATE global EXPERIMENT_STATE_START_TIME global mainbrain if save_osg_info is not None: save_osg = True else: save_osg = False sendsock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) if connect_to_mainbrain: assert not save_osg, 'cannot connect to mainbrain and save to .osg file' # make connection to flydra mainbrain my_host = '' # get fully qualified hostname my_port = 8322 # arbitrary number # create UDP socket object, grab the port sockobj = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) print 'binding',( my_host, my_port) sockobj.bind(( my_host, my_port)) # connect to mainbrain mainbrain_hostname = 'brain1' mainbrain_port = flydra.common_variables.mainbrain_port mainbrain_name = 'main_brain' remote_URI = "PYROLOC://%s:%d/%s" % (mainbrain_hostname, mainbrain_port, mainbrain_name) Pyro.core.initClient(banner=0) mainbrain = Pyro.core.getProxyForURI(remote_URI) mainbrain._setOneway(['log_message']) my_host_fqdn = socket.getfqdn(my_host) mainbrain.register_downstream_kalman_host(my_host_fqdn,my_port) listener = InterpolatingListener(sockobj) #listener = Listener(sockobj) listen_thread = threading.Thread(target=listener.run) listen_thread.setDaemon(True) listen_thread.start() else: if save_osg: listener = ReplayListener(save_osg_info['kalman_h5']) else: listener = InterpolatingListener(None,dummy=True) mainbrain = DummyMainbrain() screen=Screen(size=(1024,768), bgcolor=(0,0,0), alpha_bits=8, #fullscreen=True, ) if 1: # this loads faster, for debugging only mipmaps_enabled=False else: mipmaps_enabled=True DEBUG='none' # no debugging #DEBUG='flicker' # alternate views on successive frames vr_objects = [] on_eye_loc_update_funcs = [] if 0: # floor stimulus # Get a texture filename = 'stones_and_cement.jpg' texture = Texture(filename) # floor is iso-z rectangle x0 = -1 x1 = 1 y0 = -.25 y1 = .25 z0 = -.1 z1 = -.1 vr_object = FlatRect.FlatRect(texture=texture, shrink_texture_ok=1, lowerleft=(x0,y0,z0), upperleft=(x0,y1,z1), upperright=(x1,y1,z1), lowerright=(x1,y0,z0), tex_phase = 0.2, mipmaps_enabled=mipmaps_enabled, depth_test=True, ) vr_objects.append( vr_object ) if FOREST: # +y wall stimulus if 0: # wall iso-y rectangle x0 = -1 x1 = 1 y0 = .25 y1 = .25 z0 = -.1 z1 = .5 # Get a texture filename = 'stones_and_cement.jpg' texture = Texture(filename) vr_object = FlatRect.FlatRect(texture=texture, shrink_texture_ok=1, lowerleft=(x0,y0,z0), upperleft=(x0,y1,z1), upperright=(x1,y1,z1), lowerright=(x1,y0,z0), tex_phase = 0.2, mipmaps_enabled=mipmaps_enabled, depth_test=True, ) vr_objects.append(vr_object) else: # forest of trees in +y direction filename = 'tree.png' tree_texture = Texture(filename) for x0 in np.arange(-1,1,.3): for y0 in np.arange(.1, 1.0, .2): #for y0 in [0.0]: x1 = x0+0.1 y1 = y0 z0 = -0.5 z1 = 1.0 tree = TextureStimulus3D(texture = tree_texture, shrink_texture_ok=True, internal_format=gl.GL_RGBA, lowerleft=(x0,y0,z0), upperleft=(x0,y1,z1), upperright=(x1,y1,z1), lowerright=(x1,y0,z0), mipmaps_enabled=False, depth_test=True, ) vr_objects.append(tree) if FOREST: if 1: # forest of trees in -y direction filename = 'tree.png' tree_texture = Texture(filename) for x0 in np.arange(-1,1,.3): for y0 in np.arange(-.1, -1.0, -.2): #for y0 in [0.0]: x1 = x0+0.1 y1 = y0 z0 = -0.5 z1 = 1.0 tree = TextureStimulus3D(texture = tree_texture, shrink_texture_ok=True, internal_format=gl.GL_RGBA, lowerleft=(x0,y0,z0), upperleft=(x0,y1,z1), upperright=(x1,y1,z1), lowerright=(x1,y0,z0), mipmaps_enabled=False, depth_test=True, ) vr_objects.append(tree) if UNIT_CUBE: arena = Arena() for face_name, face_verts in arena.face_verts.iteritems(): face = TextureStimulus3D(texture = arena.texture, shrink_texture_ok=True, internal_format=gl.GL_RGBA, lowerleft=arena.verts[arena.face_verts[face_name][0]], upperleft=arena.verts[arena.face_verts[face_name][1]], upperright=arena.verts[arena.face_verts[face_name][2]], lowerright=arena.verts[arena.face_verts[face_name][3]], mipmaps_enabled=False, depth_test=True, ) vr_objects.append(face) if DRUM: filename = os.path.join( os.path.split( __file__ )[0], 'panorama-checkerboard.png') texture = Texture(filename) # cylinder drum = SpinningDrum( position=(0.5,0.5,0.5), # center of WT orientation=0.0, texture=texture, drum_center_elevation=90.0, radius = (0.4), height=0.3, internal_format=gl.GL_RGBA, ) vr_objects.append(drum) if DOTS: # due to a bug in Vision Egg, these only show up if drawn last. if 1: # fly tracker negZ stimulus negZ_stim = Rectangle3D(color=(1,1,1,1), ) updater = StimulusLocationUpdater(negZ_stim,offset=(0,0,-1),inc=0.1) on_eye_loc_update_funcs.append( updater.update ) vr_objects.append( negZ_stim ) if 1: # fly tracker plusY stimulus plusY_stim = Rectangle3D(color=(1,1,1,1), ) updater = StimulusLocationUpdater(plusY_stim, offset=(0,1,0), inc1_dir=(1,0,0), inc2_dir=(0,0,1), inc=0.1) on_eye_loc_update_funcs.append( updater.update ) vr_objects.append( plusY_stim ) if 1: # fly tracker negY stimulus negY_stim = Rectangle3D(color=(1,1,1,1), ) updater = StimulusLocationUpdater(negY_stim, offset=(0,-1,0), inc1_dir=(1,0,0), inc2_dir=(0,0,1), inc=0.1) on_eye_loc_update_funcs.append( updater.update ) vr_objects.append( negY_stim ) vr_walls = {} arena = Arena() if 0: # test ## corners_3d = [ ## ( 0.5, 0.15, 0.01), ## (-0.5, 0.15, 0.01), ## (-0.5, -0.15, 0.01), ## ( 0.5, -0.15, 0.01), ## ] testz = 0. ## corners_3d = [(-0.5, -0.15, testz), ## ( 0.5, -0.15, testz), ## ( 0.5, 0.15, testz), ## (-0.5, 0.15, testz)] corners_3d = [(-0.5, 0.15, testz), ( 0.5, 0.15, testz), ( 0.5, -0.15, testz), (-0.5, -0.15, testz)] corners_2d = [ (0,210), (799,210), (799,401), (0,399)] name = 'test' approx_view_dir = (0,0,-1) # down vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, vr_objects, approx_view_dir, name) vr_walls[name] = vr_wall_dict del testz if 0: # test2 testy = 0.15 corners_3d = [(-0.5, testy, 0), ( -0.5, testy, 0.3), ( 0.5, testy, 0.3), (0.5, testy, 0)] del testy corners_2d = [ (0,0), (799,0), (799,200), (0,200)] name = 'test2' approx_view_dir = (0,0,-1) # down vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, vr_objects, approx_view_dir, name) vr_walls[name] = vr_wall_dict if 0: # floor # Measured Mar 24, 2009. Used calibration cal20081120.xml. corners_3d = arena.faces_3d['-z'] corners_2d = [ (1,401), (800,399), (800,209), (1,208), ] name = 'floor' approx_view_dir = None vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, vr_objects, approx_view_dir, name) vr_walls[name] = vr_wall_dict if 1: # order: LL, UL, UR, LR # +y wall corners_3d = arena.faces_3d['+y'] corners_2d = [ # LL (513, 1), # UL (513,768), #UR (1024,550), # LR (1024,50), ] name = '+y' approx_view_dir = None vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, vr_objects, approx_view_dir,name) vr_walls[name] = vr_wall_dict if 1: # order: LL, UL, UR, LR # -y wall corners_3d = arena.faces_3d['+x'] corners_2d = [ # LL (1,50), # UL (1,620), # UR (512,768), # LR (512,1), ] name = '-y' approx_view_dir = None vr_wall_dict = get_wall_dict( SHOW, screen, corners_3d, corners_2d, vr_objects, approx_view_dir,name) vr_walls[name] = vr_wall_dict if SHOW in ['overview','projector (calibrated)']: screen_stimuli = [] for wall in vr_walls.itervalues(): screen_stimuli.extend( wall['display_stimuli'] ) if SHOW=='overview': # draw dot where VR camera is for overview VR_eye_stim = Rectangle3D(color=(.2,.2,.2,1), # gray depth_test=True,#requires VE 1.1.1.1 ) fly_stim_updater=StimulusLocationUpdater(VR_eye_stim) on_eye_loc_update_funcs.append( fly_stim_updater.update ) VR_stimuli = [] for wall in vr_walls.itervalues(): VR_stimuli.extend( wall['cam_viewport'].parameters.stimuli ) display_viewport = Viewport( screen=screen, projection=SimplePerspectiveProjection(fov_x=90.0), stimuli=VR_stimuli+screen_stimuli+[VR_eye_stim, ], ) elif SHOW=='projector (calibrated)': display_viewport = Viewport( screen=screen, stimuli=screen_stimuli, ) else: # parse e.g. SHOW='cam:floor' camname = SHOW[4:] display_viewport = vr_walls[camname]['cam_viewport'] last_log_message_time = -np.inf # OpenGL textures must be power of 2 def next_power_of_2(f): return math.pow(2.0,math.ceil(math.log(f)/math.log(2.0))) fb_width_pow2 = int(next_power_of_2(screen.size[0])) fb_height_pow2 = int(next_power_of_2(screen.size[1])) if save_osg: listener.set_obj_frame(save_osg_info['obj'],save_osg_info['frame']) if 1: # initialize if live_demo: EXPERIMENT_STATE = 0 else: EXPERIMENT_STATE = -1 tmp = listener.get_fly_xyz() if tmp is not None: obj_id,fly_xyz,framenumber = tmp else: fly_xyz = None obj_id = None framenumber = None del tmp if not save_osg: advance_state(fly_xyz,obj_id,framenumber,sendsock) else: warnings.warn('save_osg mode -- forcing experiment state') EXPERIMENT_STATE = 1 frame_timer = FrameTimer() quit_now = False while not quit_now: # infinite loop to draw stimuli if save_osg: quit_now = True # quit on next round # test for keypress or mouseclick to quit for event in pygame.event.get(): if event.type in (QUIT,MOUSEBUTTONDOWN): #if event.type in (QUIT,KEYDOWN,MOUSEBUTTONDOWN): quit_now = True ## now = time.time() ## if now-last_log_message_time > 5.0: # log a message every 5 seconds ## mainbrain.log_message('<wtstim>', ## time.time(), ## 'This is my message.' ) ## last_log_message_time = now near = 0.001 far = 10.0 tmp = listener.get_fly_xyz(prefer_obj_id=obj_id) if tmp is not None: obj_id,fly_xyz,framenumber = tmp else: fly_xyz = None obj_id = None framenumber = None del tmp if not save_osg: if should_i_advance_to_next_state(fly_xyz): if not live_demo: advance_state(fly_xyz,obj_id,framenumber,sendsock) state_string = EXPERIMENT_STATES[EXPERIMENT_STATE] state_string_split = state_string.split() draw_stimuli = True if state_string_split[0]=='waiting': draw_stimuli=False elif state_string=='doing gray only stimulus': draw_stimuli=False if fly_xyz is not None: if state_string.startswith('doing static'): fly_xyz = STATIC_FLY_XYZ for wall in vr_walls.itervalues(): wall['screen_data'].update_VE_viewport( wall['cam_viewport'], fly_xyz, near, far, avoid_clipping=True) for func in on_eye_loc_update_funcs: # only used to draw dots and in overview mode func(fly_xyz) else: # no recent data draw_stimuli = False # render fly-eye views and copy to texture objects if necessary #screen.set(bgcolor=(.4,.4,0)) # ?? for wallname,wall in vr_walls.iteritems(): if wallname=='test': screen.set(bgcolor=(1,0,0)) # red else: screen.set(bgcolor=BGCOLOR) screen.clear() # clear screen if draw_stimuli: if DRUM and state_string.endswith('drum radius 0.1'): drum.set(radius = 0.1) elif DRUM and state_string.endswith('drum radius 0.3'): drum.set(radius = 0.3) # render fly-eye view wall['cam_viewport'].draw() if SHOW in ['overview','projector (calibrated)']: framebuffer_texture_object = wall['framebuffer_texture_object'] # copy screen back-buffer to texture framebuffer_texture_object.put_new_framebuffer( size=(fb_width_pow2,fb_height_pow2), internal_format=gl.GL_RGB, buffer='back', ) if save_osg: # save screen back buffer to image file pil_image = screen.get_framebuffer_as_image( format=gl.GL_RGBA) if not os.path.exists(save_osg_info['dirname']): os.mkdir(save_osg_info['dirname']) wall_fname = wallname+'.png' wall_full_path = os.path.join( save_osg_info['dirname'], wall_fname ) print 'saving %s'%wall_fname pil_image.save(wall_full_path) if DEBUG=='flicker': swap_buffers() # swap buffers #time.sleep(3.0) if save_osg: save_wall_models( vr_walls, save_osg_info) if SHOW=='overview': now = time.time() overview_movement_tf = 0.1 theta = (2*pi*now * overview_movement_tf) overview_eye_loc = (-.5 + 0.1*np.cos( theta ), # x -1.5 + 0.1*np.sin( theta ), # y 2.0) # z camera_matrix = ModelView() camera_matrix.look_at( overview_eye_loc, # eye eye_loc_default, # look at fly center #screen_data.t_3d[:3,0], # look at upper left corner (0,0,1), # up ) display_viewport.set(camera_matrix=camera_matrix) # clear screen again if SHOW=='overview': screen.set(bgcolor=(0.0,0.0,0.8)) # blue else: screen.set(bgcolor=(0.0,0.0,0.0)) #black screen.clear() # clear screen display_viewport.draw() # draw the viewport and hence the stimuli swap_buffers() # swap buffers frame_timer.tick() # notify the frame time logger that we just drew a frame frame_timer.log_histogram() # print frame interval histogram
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()
class VisionEggView(object): """ This class handles VisionEgg internals and the creation of common/standard stimuli like centered words, a fixation cross or a countdown. Inherit this and pass the type to VisionEggFeedback for customization. """ def __init__(self): self.__init_attributes() def __init_attributes(self): """ Setup internal attributes. """ self._logger = logging.getLogger('VisionEggView') self._logger.addHandler(logging.FileHandler('log')) self._screen_acquired = False self._viewports = [] def set_trigger_function(self, trigger): self._trigger = trigger def set_event_handlers(self, event_handlers): """ Set pygame/VisionEgg event handler function. """ self._event_handlers = event_handlers def set_iterator_semaphore(self, flag): """ Specify the object to be used as semaphore for iterators. See L{Switcherator} for more. """ self._iter = lambda it: Switcherator(flag, it) def update_parameters(self, **kwargs): """ Apply new parameters set from pyff. """ for k, v in kwargs.iteritems(): setattr(self, '_' + k, v) if self._screen_acquired: self.reinit() def acquire(self): """ Allow L{update_parameters} initialize VisionEgg. """ self._screen_acquired = True def reinit(self): """ Initialize VisionEgg objects. """ self.__init_screen() self.__init_presentation() self.__init_viewports() self.init() self.__init_text() def init(self): """ Overload this for additional custom VisionEgg initialization. """ pass def __init_screen(self): """ Create the VisionEgg Screen object using the pyff configuration parameters 'fullscreen' and 'geometry' and the font and background colors according to parameters 'font_color_name' and 'bg_color'. """ params = { 'fullscreen': self._fullscreen, 'sync_swap': True } if not self._fullscreen: os.environ['SDL_VIDEO_WINDOW_POS'] = '%d, %d' % (self._geometry[0], self._geometry[1]) params['size'] = self._geometry[2:] self.screen = Screen(**params) self._set_bg_color() self._set_font_color() def __init_presentation(self): """ Provide a standard presentation object. """ self.presentation = Presentation(handle_event_callbacks= self._event_handlers) def __init_viewports(self): """ Provide a standard viewport. """ self._standard_viewport = Viewport(screen=self.screen) self.add_viewport(self._standard_viewport) def __init_text(self): """ Provide a text in the screen center for standard stimuli and fixation cross etc. """ sz = self.screen.size self._center_text = self.add_color_word(position=(sz[0] / 2., sz[1] / 2.), font_size=self._font_size) def add_viewport(self, viewport): """ Add an additional custom viewport object to the list of viewports. """ self._viewports.append(viewport) self.presentation.set(viewports=self._viewports) def clear_stimuli(self): """ Remove all existing stimuli in the standard viewport. """ self.set_stimuli() 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 set_stimuli(self, *stimuli): """ Set the list of stimulus objects. """ self._standard_viewport.set(stimuli=list(stimuli)) def add_text_stimulus(self, text, font_size=None, **kw): if not kw.has_key('anchor'): kw['anchor'] = 'center' font_size = font_size or self._font_size txt = VisionEgg.Text.Text(text=text, font_size=font_size, **kw) self.add_stimuli(txt) return txt def add_color_word(self, text='', font_size=None, **kw): font_size = font_size or self._font_size txt = ColorWord(text=text, symbol_size=font_size, **kw) self.add_stimuli(txt) return txt def add_image_stimulus(self, **kw): if not kw.has_key('anchor'): kw['anchor'] = 'center' img = TextureStimulus(**kw) self.add_stimuli(img) return img def _create_color(self, name): try: if isinstance(name, tuple): return Color(*name).normalize() else: return Color(str(name)).normalize() except ValueError: self._logger.warn('No such pygame.Color: %s' % str(name)) def _set_font_color(self): """ Set the standard font color by pygame name. """ self._font_color = (self._create_color(self._font_color_name) or Color(1, 1, 1, 255).normalize()) def _set_bg_color(self): """ Set the standard background color by pygame name. """ c = (self._create_color(self._bg_color) or Color(0, 0, 0, 255).normalize()) self.screen.set(bgcolor=c) def present_frames(self, num_frames): """ Launch the presentation main loop for a given number of frames. """ self.presentation.set(go_duration=(num_frames, 'frames')) self.presentation.go() def present(self, sec): self.presentation.set(go_duration=(sec, 'seconds')) self.presentation.go() def update(self): """ Repaint the canvas for one frame to update changed stimuli. """ self.present_frames(1) def center_word(self, text, color=None): """ Set the standard word in the screen center. """ self._center_text.set(text=text) self._center_text.set(colors=color or (self._font_color for l in self._center_text)) def clear_center_word(self): """ Remove the center word from the screen. """ self.center_word('') self.update() def present_center_word(self, text, seconds, color=None): self.center_word(text, color) self.present(seconds) self.clear_center_word() def ask(self, question=True): """ Loop indefinitely until answered() is called. If question is True, a question mark is shown in the center. """ if question: self.center_word('?') self.presentation.run_forever() self.presentation.set(quit=False) self.clear_center_word() def answered(self): """ Abort the current presentation (usually the question mark) after subject input. For thread safety, the screen shouldn't be changed here. """ self.presentation.set(quit=True) def show_fixation_cross(self): """ Display the pyff parameter 'fixation_cross_symbol' for the period of time given by pyff parameter 'fixation_cross_time'. """ self.center_word(self._fixation_cross_symbol) self._trigger(marker.FIXATION_START, wait=True) self.present(self._fixation_cross_time) self._trigger(marker.FIXATION_END, wait=True) def countdown(self): """ Display a countdown according to pyff parameters 'countdown_start' and 'countdown_symbol_duration'. """ self._trigger(marker.COUNTDOWN_START, wait=True) for i in self._iter(reversed(xrange(self._countdown_start + 1))): self.center_word(str(i)) self.present(self._countdown_symbol_duration) self._trigger(marker.COUNTDOWN_END, wait=True) self.clear_center_word() def close(self): """ Shut down the screen. """ self._screen_acquired = False self.screen.close() def quit(self): """ Stop the presentation. """ self.presentation.set(quit=True) self.presentation.set(go_duration=(1, 'frames'))
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()