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)
Esempio n. 2
0
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)
Esempio n. 6
0
 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()
Esempio n. 8
0
File: view.py Progetto: chrox/pyff
 def __init_viewports(self):
     """ Provide a standard viewport. """
     self._standard_viewport = Viewport(screen=self.screen)
     self.add_viewport(self._standard_viewport)
Esempio n. 9
0
        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()
Esempio n. 10
0
# 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:
Esempio n. 11
0
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()
Esempio n. 12
0
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'))
Esempio n. 13
0
    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)
                                          ])
Esempio n. 14
0
 def __init_viewports(self):
     """ Provide a standard viewport. """
     self._standard_viewport = Viewport(screen=self.screen)
     self.add_viewport(self._standard_viewport)
Esempio n. 15
0
#!/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()
Esempio n. 16
0
        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:
Esempio n. 17
0
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()
Esempio n. 18
0
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
Esempio n. 19
0
# 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()
Esempio n. 20
0
    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
Esempio n. 21
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
Esempio n. 22
0
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
Esempio n. 23
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()
Esempio n. 24
0
File: view.py Progetto: chrox/pyff
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'))
Esempio n. 25
0
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()