Merge branch 'tek-visionegg'

Author: venthur

src/FeedbackBase/VisionEggFeedback.py

@@ -138,8 +138,8 @@ def _trigger(self, trigger, wait=False):
         if wait:
             time.sleep(0.03)
 
-    def stimulus_sequence(self, prepare, presentation_time, suspendable=True,
-                          pre_stimulus_function=None):
+    def stimulus_sequence(self, prepare, presentation_time=None,
+                          suspendable=True, pre_stimulus_function=None):
         """ Returns an object presenting a series of stimuli.
         @param prepare: This is the core connection between the sequence
         handler and user code. It can either be a generator (so
@@ -151,6 +151,8 @@ def stimulus_sequence(self, prepare, presentation_time, suspendable=True,
         single stimulus, in seconds. Can also be a sequence of values.
         If the prepare function doesn't terminate when the sequence is
         exhausted, it is restarted.
+        If the argument is a sequence, any element that is a sequence
+        again is used as an interval for random duration selection.
         @param suspendable: Whether the sequence should halt when pause
         is pressed.
         @param pre_stimulus_function: If given, it is called exactly

src/lib/speller/__init__.py

@@ -23,6 +23,7 @@
 class Speller(object):
     __stimulus = None
     __sequences = None
+    __stim_gen = None
 
     def __init__(self):
         self.__init_attributes()
@@ -44,6 +45,7 @@ def __init_attributes(self):
         self.countdown_start = 1
         # allow classifier input to be simulated by keyboard
         self.allow_keyboard_input = True
+        self.target_present_time = .1
 
     def update_parameters(self):
         super(Speller, self).update_parameters()
@@ -55,6 +57,14 @@ def stimulus(self, f):
         self.__stimulus = f
         return f
 
+    @classmethod
+    def stimulus_generator(self, **kw):
+        def decorate(f):
+            self.__stim_gen = f
+            return f
+        self.__stim_gen_kw = kw
+        return decorate
+
     @classmethod
     def sequences(self, f):
         self.__sequences = f
@@ -71,6 +81,9 @@ def _setup_trial(self):
                                        self)
         if self.__stimulus:
             self._trial._sequence = getattr(self, self.__stimulus.__name__)
+        elif self.__stim_gen:
+            self._trial._sequence = self._stimulus_generator
+            self.__stimulus_generator = getattr(self, self.__stim_gen.__name__)
 
     def _setup_input_handler(self):
         input_handler_type = self._trial_name + 'InputHandler'
@@ -103,3 +116,7 @@ def on_control_event(self, data):
         cls = data.get('cl_output', None)
         if cls is not None:
             self._input_handler.eeg_select(cls)
+
+    def _stimulus_generator(self, *a, **kw):
+        self.stimulus_sequence(self.__stimulus_generator(*a, **kw),
+                               **self.__stim_gen_kw).run()

src/lib/speller/experiment.py

@@ -35,6 +35,7 @@ def __init__(self, view, trial, phrases, input_handler, flag, iter, config):
         self._nr_sequences = config.nr_sequences
         self._countdown = config.phrase_countdown
         self._min_dist = config.min_dist
+        self._target_present_time = config.target_present_time
 
     def run(self):
         self._input_handler.start_experiment(self)
@@ -65,6 +66,7 @@ def run(self):
 
     def trial(self, index, target):
         self._trial.target(target)
+        self._view.present(self._target_present_time)
         Experiment.trial(self)
         if self._flag:
             self._view.next_target()

src/lib/vision_egg/model/color_word.py

@@ -1,4 +1,4 @@
-__copyright__ = """ Copyright (c) 2010 Torsten Schmits
+__copyright__ = """ Copyright (c) 2010-2011 Torsten Schmits
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -54,7 +54,7 @@ def set_target(self, target):
         if isinstance(target, int) and 0 <= target <= len(self.text):
             self._target = self.text[target]
             self._target_index = target
-        elif isinstance(target, (str, unicode)) and target in self.text:
+        elif isinstance(target, basestring) and target in self.text:
             self._target = target
             self._target_index = self.text.index(target)
         else:

src/lib/vision_egg/util/frame_counter.py

@@ -1,4 +1,4 @@
-__copyright__ = """ Copyright (c) 2010 Torsten Schmits
+__copyright__ = """ Copyright (c) 2010-2011 Torsten Schmits
 
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
@@ -36,9 +36,12 @@ def run(self):
             logging.getLogger('FrameCounter').error(unicode(e))
 
     def step(self):
-        pygame.display.flip()
+        self.sync()
         self.frame += 1
 
+    def sync(self):
+        pygame.display.flip()
+
     def lock(self):
         self._locked_frame = self.frame
 

src/lib/vision_egg/util/stimulus.py

@@ -1,4 +1,4 @@
-__copyright__ = """ Copyright (c) 2010 Torsten Schmits
+__copyright__ = """ Copyright (c) 2010-2011 Torsten Schmits
 
 This program is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
@@ -17,9 +17,9 @@
 
 from time import sleep
 from datetime import datetime, timedelta
-import collections, logging, itertools
+import collections, logging, itertools, random
 
-import pygame, VisionEgg
+import VisionEgg
 
 from lib.vision_egg.util.frame_counter import FrameCounter
 
@@ -29,11 +29,73 @@
 def _frames(time):
     return int(round(float(time) * _refresh_rate))
 
+def _is_seq(l):
+    return isinstance(l, collections.Sequence)
+
+class StimulusTime(object):
+    def __init__(self, time, vsync=True):
+        self._vsync = vsync
+        self._frames = None
+        self.set(time)
+
+    def set(self, time):
+        self._adapted = self._time = time
+        if self:
+            self._frames = _frames(self._time)
+            if self._vsync:
+                self._adapted = round(self._frames * _frame_duration, 6)
+
+    @property
+    def time(self):
+        return timedelta(seconds=self._adapted)
+
+    @property
+    def original(self):
+        return self._time
+
+    @property
+    def adapted(self):
+        return self._adapted
+
+    @property
+    def frames(self):
+        return self._frames
+
+    def __call__(self, frames):
+        return self.frames if frames else self.time
+
+    def __nonzero__(self):
+        return self._time is not None
+
+class RandomStimulusTime(StimulusTime):
+    def __init__(self, interval, *a, **kw):
+        self._interval = interval
+        StimulusTime.__init__(self, 0, *a, **kw)
+
+    def _resample(self):
+        self.set(random.uniform(*self._interval))
+
+    @property
+    def original(self):
+        return 'random(%s, %s)' % tuple(self._interval)
+
+    @property
+    def adapted(self):
+        return self.original
+
+    def __call__(self, frames):
+        self._resample()
+        return StimulusTime.__call__(self, frames)
+
+def _stimulus_time(time, vsync):
+    typ = lambda t: RandomStimulusTime if _is_seq(t) else StimulusTime
+    return typ(time)(time, vsync=vsync)
+
 class StimulusPainter(object):
     """ Painter for a series of stimuli. """
     def __init__(self, prepare, wait, view, flag, wait_style_fixed=False,
                  print_frames=False, suspendable=True, pre_stimulus=None,
-                 frame_transition=False):
+                 frame_transition=False, vsync=True):
         self._prepare_func = prepare
         self._wait_times = itertools.cycle(wait)
         self._view = view
@@ -43,10 +105,12 @@ def __init__(self, prepare, wait, view, flag, wait_style_fixed=False,
         self._suspendable = suspendable
         self._pre_stimulus = pre_stimulus
         self._frame_transition = frame_transition
+        self._vsync = vsync
         self._logger = logging.getLogger('StimulusPainter')
         self._frame_counter = FrameCounter(self._flag)
         self._suspended_time = timedelta()
         self._wait = self._frame_wait if frame_transition else self._time_wait
+        self._online_times = []
 
     def run(self):
         if self._print_frames or self._frame_transition:
@@ -67,7 +131,7 @@ def run(self):
     def _frame_wait(self):
         next_interval = self._next_duration
         while self._flag and self._frame_counter.last_interval < next_interval:
-            sleep(0.001)
+            self._frame_counter.sync()
         if self._print_frames:
             self._logger.debug('Frames after waiting: %d' %
                                self._frame_counter.last_interval)
@@ -94,15 +158,18 @@ def _present(self):
         if self._print_frames:
             self._logger.debug('Frames before stimulus change: %d' %
                                self._frame_counter.last_interval)
-            self._frame_counter.lock()
         if self._pre_stimulus is not None:
             self._pre_stimulus()
+        self._frame_counter.lock()
         self._view.update()
 
     @property
     def _next_duration(self):
-        nxt = self._wait_times.next() + self._suspended
-        return nxt
+        try:
+            nxt = self._online_times.pop(0) or self._wait_times.next()
+        except StopIteration:
+            raise Exception('No specified stimulus times available!')
+        return nxt(self._frame_transition) + self._suspended
 
     @property
     def _suspended(self):
@@ -116,9 +183,13 @@ def _do_prepare(self):
 
 class StimulusIterator(StimulusPainter):
     """ Painter using an iterator. """
+    def __init__(self, *a, **kw):
+        StimulusPainter.__init__(self, *a, **kw)
+
     def _do_prepare(self):
         try:
-            self._prepare_func.next()
+            nxt = self._prepare_func.next()
+            self._online_times.append(_stimulus_time(nxt, self._vsync))
             return True
         except StopIteration:
             return False
@@ -138,37 +209,41 @@ def __init__(self, view, flag, print_frames=False, vsync_times=False,
         self._frame_transition = frame_transition
         self._logger = logging.getLogger('StimulusSequenceFactory')
 
-    def create(self, prepare, times, wait_style_fixed, suspendable=True,
-               pre_stimulus=None):
+    def create(self, prepare, times=None, wait_style_fixed=True,
+               suspendable=True, pre_stimulus=None):
         """ Create a StimulusPainter using the preparation object
         prepare, with given presentation times and wait style.
         If suspendable is True, the sequence halts when on_pause is
         pressed.
         Global parameters from pyff are used as given in __init__.
         """
-        if not isinstance(times, collections.Sequence):
-            times = [times]
-        times = self._adapt_times(times)
-        typ = StimulusIterator if hasattr(prepare, '__iter__') else \
-               StimulusSequence
-        if not self._frame_transition:
-            times = [timedelta(seconds=t) for t in times]
+        if times is None:
+            times = []
+        else:
+            times = self._times(times)
+            self._debug_times(times)
+        typ = (StimulusIterator if hasattr(prepare, '__iter__') else
+               StimulusSequence)
         return typ(prepare, times, self._view, self._flag,
                    wait_style_fixed=wait_style_fixed,
                    print_frames=self._print_frames, suspendable=suspendable,
                    pre_stimulus=pre_stimulus,
-                   frame_transition=self._frame_transition)
+                   frame_transition=self._frame_transition,
+                   vsync=self._vsync_times)
+
+    def _times(self, times):
+        if not _is_seq(times):
+            times = [times]
+        return [_stimulus_time(t, vsync=self._vsync_times) for t in times]
 
-    def _adapt_times(self, times):
-        frames = [_frames(time) for time in times]
-        new_times = [round(t * _frame_duration, 6) for t in frames]
+    def _debug_times(self, times):
+        original = [t.original for t in times]
+        adapted = [t.adapted for t in times]
+        frames = [t.frames for t in times]
         if self._frame_transition:
             text = ('Adapted stimulus times %s to %s frames (%s)' %
-                    (times, frames, new_times))
-            times = frames
+                    (original, frames, adapted))
             self._logger.debug(text)
         elif self._vsync_times:
-            text = 'Adapted stimulus times %s to %s' % (times, new_times)
-            times = new_times
+            text = 'Adapted stimulus times %s to %s' % (original, adapted)
             self._logger.debug(text)
-        return times