Measure delay in PsychoPy visual stimulus presentation

delay_analysis.py

import numpy as np
import pandas as pd
import mne


files = ["data/black-white_gaming1.bdf", "data/black-white_standard3.bdf"]
rows = []
n = 100  # expected number of events
mne.set_log_level("ERROR")

for file in files:
    # events from triggers
    raw = mne.io.read_raw(file, preload=True)
    sfreq = raw.info["sfreq"]
    events1 = mne.find_events(raw, uint_cast=True)
    events1 = events1[events1[:, 2] == 1, :]
    raw.pick_channels(["Erg1"])

    # events from photo sensor
    data = np.zeros_like(raw.get_data().squeeze())
    data[np.where(np.diff(raw.get_data().squeeze()) > 0.0025)[0]] = 1
    info = mne.create_info(["Status"], sfreq, "stim")
    stim = mne.io.RawArray(data[np.newaxis, :], info)
    events2 = mne.find_events(stim)
    events2[:, 2] = 2

    raw.plot(events=np.vstack([events1, events2]),
             event_color={1: "cyan", 2: "magenta"},
             start=5, duration=5, scalings=1e-2)

    diff = (events2[:n, 0] - events1[:n, 0]) / sfreq * 1000  # ms
    rows.append((file, np.mean(diff), np.std(diff)))

result = pd.DataFrame.from_records(rows)
result.columns = ["file", "mean", "std"]
print(result)

psychopy_delay.py

from psychopy import core, parallel
from psychopy.visual import Window, Rect
# from pylsl import StreamInfo, StreamOutlet
# import serial


def send(value, parallel=None, serial=None, lsl=None):
    """Send value to selected port/outlet."""
    if parallel is not None:
        parallel.setData(value)
    if serial is not None:
        serial.write(value)
    if lsl is not None:
        lsl.push_sample(value)


port = parallel.ParallelPort(address=0xDFF8)
# port = serial.Serial("COM4")

n_trials = 300
win_size = 1920, 1080  # window size
stim_size = 100, 100  # stimulus size

# pos = win_size[0]/2 - stim_size[0]/2, stim_size[1]/2 - win_size[1]/2  # lower right
pos = stim_size[0]/2 - win_size[0]/2, win_size[1]/2 - stim_size[1]/2  # upper left

win = Window(size=win_size, fullscr=True, color="black", units="pix")

# lsl = StreamOutlet(StreamInfo("Markers", type="Markers", channel_count=1,
#                               channel_format="int32", source_id="Markers"))

rect = Rect(win=win, width=stim_size[0], height=stim_size[1], pos=pos)

core.wait(10)  # wait before paradigm starts

for _ in range(n_trials):
    for trigger, color in ((1, "white"), (0, "black")):
        win.callOnFlip(send, serial=trigger)
        rect.setFillColor(color)
        for n in range(30):  # 30 frames
            rect.draw()
            win.flip()

port.close()
win.close()
core.quit()