Merge pull request #304 from CAMBI-tech/vep-calib

VEP calibration

Author: lawhead

bcipy/display/demo/components/demo_layouts.py

@@ -132,7 +132,7 @@ def demo_vep(win: visual.Window):
     layout = centered(width_pct=0.9, height_pct=0.9)
     layout.parent = win
 
-    box_config = BoxConfiguration(layout, num_boxes=4, height_pct=0.28)
+    box_config = BoxConfiguration(layout, height_pct=0.28)
     size = box_config.box_size
     positions = box_config.positions
 

bcipy/display/demo/vep/demo_calibration_vep.py

@@ -1,15 +1,17 @@
+"""Demo VEP display"""
 import logging
 import sys
-
-from psychopy import core
+from typing import Any, List
 
 from bcipy.display import (InformationProperties, VEPStimuliProperties,
                            init_display_window)
 from bcipy.display.components.layout import centered
 from bcipy.display.components.task_bar import CalibrationTaskBar
+from bcipy.display.paradigm.vep.codes import DEFAULT_FLICKER_RATES
 from bcipy.display.paradigm.vep.display import VEPDisplay
 from bcipy.display.paradigm.vep.layout import BoxConfiguration
 from bcipy.helpers.clock import Clock
+from bcipy.helpers.system_utils import get_screen_info
 
 root = logging.getLogger()
 root.setLevel(logging.DEBUG)
@@ -26,61 +28,82 @@
     info_text=['VEP Display Demo'],
 )
 
-task_text = ['1/4', '2/4', '3/4', '4/4']
-num_boxes = 6
-
+task_text = ['1/3', '2/3', '3/3']
+stim_screen = 0
 window_parameters = {
     'full_screen': False,
     'window_height': 700,
     'window_width': 700,
-    'stim_screen': 1,
+    'stim_screen': stim_screen,
     'background_color': 'black'
 }
 win = init_display_window(window_parameters)
 win.recordFrameIntervals = True
-frameRate = win.getActualFrameRate()
+frame_rate = win.getActualFrameRate()
+if not frame_rate:
+    # Allow the demo to work using the configured rate.
+    frame_rate = get_screen_info(stim_screen).rate
 
-print(f'Monitor refresh rate: {frameRate} Hz')
+print(f'Monitor refresh rate: {frame_rate} Hz')
 
-box_colors = ['#00FF80', '#FFFFB3', '#CB99FF', '#FB8072', '#80B1D3', '#FF8232']
-stim_color = [[color] for i, color in enumerate(box_colors) if i < num_boxes]
+stim_color = [
+    'green', 'red', '#00FF80', '#FFFFB3', '#CB99FF', '#FB8072', '#80B1D3',
+    '#FF8232'
+]
 
 layout = centered(width_pct=0.95, height_pct=0.80)
-box_config = BoxConfiguration(layout, num_boxes=num_boxes)
+box_config = BoxConfiguration(layout, height_pct=0.30)
 
 experiment_clock = Clock()
 len_stimuli = 10
-stimuli = VEPStimuliProperties(
-    stim_color=stim_color,
+stim_props = VEPStimuliProperties(
+    stim_font=font,
     stim_pos=box_config.positions,
     stim_height=0.1,
-    stim_font=font,
-    timing=(1, 0.5, 2, 4),  # prompt, fixation, animation, stimuli
+    timing=[4, 0.5, 4],  # target, fixation, stimuli
+    stim_color=stim_color,
+    inquiry=[],
     stim_length=1,  # how many times to stimuli
-)
-task_bar = CalibrationTaskBar(win,
-                              inquiry_count=4,
-                              current_index=0,
-                              font=font)
-vep = VEPDisplay(win, experiment_clock, stimuli, task_bar, info, box_config=box_config)
-timing = []
+    animation_seconds=2.0)
+task_bar = CalibrationTaskBar(win, inquiry_count=3, current_index=0, font=font)
+vep = VEPDisplay(win,
+                 experiment_clock,
+                 stim_props,
+                 task_bar,
+                 info,
+                 box_config=box_config,
+                 flicker_rates=DEFAULT_FLICKER_RATES,
+                 should_prompt_target=True,
+                 frame_rate=frame_rate)
 wait_seconds = 2
 
+inquiries: List[List[Any]] = [[
+    'U', '+', ['C', 'M', 'S'], ['D', 'P', 'X', '_'], ['L', 'U', 'Y'],
+    ['E', 'K', 'O'], ['<', 'A', 'F', 'H', 'I', 'J', 'N', 'Q', 'R', 'V', 'Z'],
+    ['B', 'G', 'T', 'W']
+],
+    [
+    'D', '+', ['O', 'X'], ['D'], ['P', 'U'],
+    ['<', 'B', 'E', 'G', 'H', 'J', 'K', 'L', 'R', 'T'],
+    ['A', 'C', 'F', 'I', 'M', 'N', 'Q', 'V', 'Y', '_'],
+    ['S', 'W', 'Z']
+],
+    [
+    'S', '+', ['A', 'J', 'K', 'T', 'V', 'W'], ['S'], ['_'],
+    ['E', 'G', 'M', 'R'],
+    [
+        '<', 'B', 'C', 'D', 'H', 'I', 'L', 'N', 'O', 'P', 'Q',
+        'U', 'X', 'Z'
+    ], ['F', 'Y']
+]]
+
+timing = []
 # loop over the text and colors, present the stimuli and record the timing
-for txt in task_text:
+for i, txt in enumerate(task_text):
     vep.update_task_bar(txt)
-    if num_boxes == 4:
-        stim = [['A', 'B'], ['Z'], ['P'], ['R', 'W']]
-    if num_boxes == 6:
-        stim = [['A'], ['B'], ['Z', 'X'], ['P', 'I'], ['R'], ['W', 'C']]
-    vep.schedule_to(stimuli=stim)
+    inq = inquiries[i]
+    vep.schedule_to(stimuli=inq)
     timing += vep.do_inquiry()
 
-    # show the wait screen, this will only happen once
-    while wait_seconds > 0:
-        wait_seconds -= 1
-        vep.wait_screen(f"Waiting for {wait_seconds}s", color='white')
-        core.wait(1)
-
 print(timing)
 win.close()

bcipy/display/main.py

@@ -1,7 +1,7 @@
 # mypy: disable-error-code="assignment,empty-body"
 from abc import ABC, abstractmethod
 from logging import Logger
-from typing import Optional, List, Tuple, Union
+from typing import Any, List, Optional, Tuple, Union
 
 from psychopy import visual
 
@@ -33,7 +33,7 @@ def do_inquiry(self) -> List[float]:
         ...
 
     @abstractmethod
-    def wait_screen(self) -> None:
+    def wait_screen(self, *args, **kwargs) -> None:
         """Wait Screen.
 
         Define what happens on the screen when a user pauses a session.
@@ -265,15 +265,15 @@ def __init__(
 
 class VEPStimuliProperties(StimuliProperties):
 
-    def __init__(
-            self,
-            stim_font: str,
-            stim_pos: List[Tuple[float, float]],
-            stim_height: float,
-            timing: Optional[Tuple[float, float, float]] = None,
-            stim_color: Optional[List[List[str]]] = None,
-            inquiry: Optional[List[List[str]]] = None,
-            stim_length: int = 1):
+    def __init__(self,
+                 stim_font: str,
+                 stim_pos: List[Tuple[float, float]],
+                 stim_height: float,
+                 timing: List[float],
+                 stim_color: List[str],
+                 inquiry: List[List[Any]],
+                 stim_length: int = 1,
+                 animation_seconds: float = 1.0):
         """Initialize VEP Stimuli Parameters.
         stim_color(List[str]): Ordered list of colors to apply to VEP stimuli
         stim_font(str): Font to apply to all VEP stimuli
@@ -293,6 +293,7 @@ def __init__(
         # dynamic properties, must be a a list of lists where each list is a different box
         self.stim_colors = stim_color
         self.stim_inquiry = inquiry
+        self.animation_seconds = animation_seconds
 
     def build_init_stimuli(self, window: visual.Window) -> None:
         """"Build Initial Stimuli."""

bcipy/display/paradigm/vep/codes.py

@@ -0,0 +1,81 @@
+"""Functions related to VEP flash rates"""
+import logging
+from typing import List
+
+import numpy as np
+
+from bcipy.helpers.exceptions import BciPyCoreException
+
+log = logging.getLogger(__name__)
+
+# These rates work for a 60hz display
+DEFAULT_FLICKER_RATES = [4, 5, 6, 10, 12, 15]
+
+
+def create_vep_codes(length=32, count=4) -> List[List[int]]:
+    """Create a list of random VEP codes.
+
+    length - how many bits in each code. This should be greater than or equal to the refresh rate
+        if using these to flicker. For example, if the refresh rate is 60Hz, then the length should
+        be at least 60.
+    count - how many codes to generate, each will be unique.
+    """
+    np.random.seed(1)
+    return [np.random.randint(2, size=length) for _ in range(count)]
+
+
+def ssvep_to_code(refresh_rate: int = 60, flicker_rate: int = 10) -> List[int]:
+    """Convert SSVEP to Code.
+
+    Converts a SSVEP (steady state visual evoked potential; ex. 10 Hz) to a code (0,1)
+    given the refresh rate of the monitor (Hz) provided and a desired flicker rate (Hz).
+
+    TODO: https://www.pivotaltracker.com/story/show/186522657
+    Consider an additional parameter for the number of seconds.
+
+    Parameters:
+    -----------
+        refresh_rate: int, refresh rate of the monitor (Hz)
+        flicker_rate: int, desired flicker rate (Hz)
+    Returns:
+    --------
+        list of 0s and 1s that represent the code for the SSVEP on the monitor.
+    """
+    if flicker_rate > refresh_rate:
+        raise BciPyCoreException(
+            'flicker rate cannot be greater than refresh rate')
+    if flicker_rate <= 1:
+        raise BciPyCoreException('flicker rate must be greater than 1')
+
+    # get the number of frames per flicker
+    length_flicker = refresh_rate / flicker_rate
+
+    if length_flicker.is_integer():
+        length_flicker = int(length_flicker)
+    else:
+        err_message = f'flicker rate={flicker_rate} is not an integer multiple of refresh rate={refresh_rate}'
+        log.exception(err_message)
+        raise BciPyCoreException(err_message)
+
+    # start the first frames as off (0) for length of flicker;
+    # it will then toggle on (1)/ off (0) for length of flicker until all frames are filled for refresh rate.
+    t = 0
+    codes = []
+    for _ in range(flicker_rate):
+        codes += [t] * length_flicker
+        t = 1 - t
+
+    return codes
+
+
+def round_refresh_rate(rate: float) -> int:
+    """Round the given display rate to the nearest 10s value.
+
+    >>> round_refresh_rate(59.12)
+    60
+    >>> round_refresh_rate(61.538)
+    60
+    >>> round_refresh_rate(121.23)
+    120
+    """
+    return int(round(rate, -1))