mscheltienne
commented
9 hours ago I don't think acquisitin_delay and tmax can interact in such a way, I think you are facing a different issue which yields the rejection of all events. If you take the tutorial Epoching a Stream in real-time, it comes down to:
import time
import numpy as np
from mne import annotations_from_events, find_events
from mne.io import read_raw_fif
from mne_lsl.datasets import sample
from mne_lsl.lsl import resolve_streams
from mne_lsl.player import PlayerLSL
from mne_lsl.stream import EpochsStream, StreamLSL
fname = sample.data_path() / "mne-sample" / "sample_audvis_raw.fif"
raw = read_raw_fif(fname, preload=False).pick(("meg", "stim")).load_data()
events = find_events(raw, stim_channel="STI 014")
events = events[np.isin(events[:, 2], (1, 2))] # keep only events with ID 1 and 2
annotations = annotations_from_events(
events,
raw.info["sfreq"],
event_desc={1: "ignore", 2: "event"},
first_samp=raw.first_samp,
)
annotations.duration += 0.1 # set duration since annotations_from_events sets it to 0
raw.set_annotations(annotations)
player = PlayerLSL(
raw, chunk_size=200, name="tutorial-epochs-2", source_id="test", annotations=True
).start()
resolve_streams()
stream = StreamLSL(bufsize=4, name="tutorial-epochs-2", source_id="test")
stream.connect(acquisition_delay=0.1, processing_flags="all")
stream.info["bads"] = ["MEG 2443"] # remove bad channel
stream.filter(None, 40, picks="grad") # filter signal
stream_events = StreamLSL(
bufsize=20, name="tutorial-epochs-2-annotations", source_id="test"
)
stream_events.connect(acquisition_delay=0.1, processing_flags="all")
epochs = EpochsStream(
stream,
bufsize=20, # number of epoch held in the buffer
event_id=None,
event_channels="event", # this argument now selects the events of interest
event_stream=stream_events,
tmin=-0.2,
tmax=0.5,
baseline=(None, 0),
picks="grad",
).connect(acquisition_delay=0.1)
while epochs.n_new_epochs < 10:
time.sleep(0.5)
data = epochs.get_data(n_epochs=epochs.n_new_epochs)
epochs.disconnect()
stream.disconnect()
stream_events.disconnect()
player.stop()Where you have acquisition_delay set to 0.1 and tmax to 0.5; matching your condition. Yet epochs are acquired.
acquisition_delay simply sets a timer. Every tick, the acquisition thread will look if new data is available. The new data is always associated with its LSL timestamps.
tmin / tmax simply define how you cut the epoch out of the LSL timeline, as you would in MNE-Python with a Raw / Epoch object.
The steps in _prune_events are: https://github.com/mne-tools/mne-lsl/blob/1c60e82e70ed4f203a4a627b6b26ccc89864d9cc/src/mne_lsl/stream/epochs.py#L896-L928
- removing events outside of the event_id, i.e. removing events you did not request.
- get the events position in the stream times after removing events outside of ts, ie.
- the stream you wish to epoch has currently samples betweem
ts[0]andts[-1] - the event stream you use to epoch has currently samples between
ts_events[0]andts_events[-1], and in those samples it has the events at the timestampts_events[events[:, 0]] - thus, based on the 2 previous points, we select events which have LSL timestamps overlapping with the timestamps of the LSL stream to epoch
- the stream you wish to epoch has currently samples betweem
- remove events which can't fit an entire epoch and/or are outside of the buffer, i.e.
- now that we only have events which are within the StreamLSL buffer, let's apply tmin and tmax and figure out if the StreamLSL buffer actually fits the entire epoch
- for instance, if an event woud be add t=2s and the buffer holds 2.3s and tmax is set to 0.5 seconds, we are missing 0.2 seconds of data for now (which will get in the buffer at some point)
- remove events which have already been moved to the buffer, i.e. since this function is called on every acquisition step (controlled by
acquisition_delay), we might have already cut-out the epoch from the stream- if I take the previous example, in a future acquisition step the event would be add t=1.8s, and now with a buffer of 2.3s and tmax of 0.5s, we can cut the entire epoch out.
If all of your epochs are dropped, I think the likely reasons is: https://github.com/mne-tools/mne-lsl/blob/1c60e82e70ed4f203a4a627b6b26ccc89864d9cc/src/mne_lsl/stream/epochs.py#L911C1-L916C81
I would increase the buffer size of both StreamLSL object.
mzgsxs
Hi I'm trying to understand and use EpochsStream class for my work.
It seems that if I use a separate event stream, connect with acquisition_delay < tmax, EpochsStream will always reject the events in ts_event. Is this behavior normal and expected or should this be considered as a bug?
https://github.com/mne-tools/mne-lsl/blob/1c60e82e70ed4f203a4a627b6b26ccc89864d9cc/src/mne_lsl/stream/epochs.py#L921
maybe it should be checked here, to see if it's smaller than tmax?
https://github.com/mne-tools/mne-lsl/blob/1c60e82e70ed4f203a4a627b6b26ccc89864d9cc/src/mne_lsl/stream/epochs.py#L317
thank you