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,