def test_events_long():
"""Test events."""
data_path = testing.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_trunc_raw.fif'
raw = read_raw_fif(raw_fname, preload=True)
raw_tmin, raw_tmax = 0, 90
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
# select gradiometers
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
# load data with usual Epochs for later verification
raw = concatenate_raws([raw, raw.copy(), raw.copy(), raw.copy(),
raw.copy(), raw.copy()])
assert 110 < raw.times[-1] < 130
raw_cropped = raw.copy().crop(raw_tmin, raw_tmax)
events_offline = find_events(raw_cropped)
epochs_offline = Epochs(raw_cropped, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6),
baseline=None)
epochs_offline.drop_bad()
# create the mock-client object
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6), baseline=None,
isi_max=1.)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=raw_tmin, tmax=raw_tmax,
buffer_size=1000)
expected_events = epochs_offline.events.copy()
expected_events[:, 0] = expected_events[:, 0] - raw_cropped.first_samp
assert np.all(expected_events[:, 0] <=
(raw_tmax - tmax) * raw.info['sfreq'])
assert_array_equal(rt_epochs.events, expected_events)
assert len(rt_epochs) == len(epochs_offline)
data_picks = pick_types(epochs_offline.info, meg='grad', eeg=False,
eog=True,
stim=False, exclude=raw.info['bads'])
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
if ev_num == 0:
X_rt = ev.data[None, data_picks, :]
y_rt = int(ev.comment) # comment attribute contains the event_id
else:
X_rt = np.concatenate((X_rt, ev.data[None, data_picks, :]), axis=0)
y_rt = np.append(y_rt, int(ev.comment))
X_offline = epochs_offline.get_data()[:, data_picks, :]
y_offline = epochs_offline.events[:, 2]
assert_array_equal(X_rt, X_offline)
assert_array_equal(y_rt, y_offline)
def test_fieldtrip_rtepochs(free_tcp_port, tmpdir):
"""Test FieldTrip RtEpochs."""
raw_tmax = 7
raw = read_raw_fif(raw_fname, preload=True)
raw.crop(tmin=0, tmax=raw_tmax)
events_offline = find_events(raw, stim_channel='STI 014')
event_id = list(np.unique(events_offline[:, 2]))
tmin, tmax = -0.2, 0.5
epochs_offline = Epochs(raw, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax)
epochs_offline.drop_bad()
isi_max = (np.max(np.diff(epochs_offline.events[:, 0])) /
raw.info['sfreq']) + 1.0
neuromag2ft_fname = op.realpath(op.join(os.environ['NEUROMAG2FT_ROOT'],
'neuromag2ft'))
# Works with neuromag2ft-3.0.2
cmd = (neuromag2ft_fname, '--file', raw_fname, '--speed', '8.0',
'--bufport', str(free_tcp_port))
with running_subprocess(cmd, after='terminate', verbose=False):
data_rt = None
events_ids_rt = None
with pytest.warns(RuntimeWarning, match='Trying to guess it'):
with FieldTripClient(host='localhost', port=free_tcp_port,
tmax=raw_tmax, wait_max=2) as rt_client:
# get measurement info guessed by MNE-Python
raw_info = rt_client.get_measurement_info()
assert ([ch['ch_name'] for ch in raw_info['chs']] ==
[ch['ch_name'] for ch in raw.info['chs']])
# create the real-time epochs object
epochs_rt = RtEpochs(rt_client, event_id, tmin, tmax,
stim_channel='STI 014', isi_max=isi_max)
epochs_rt.start()
time.sleep(0.5)
for ev_num, ev in enumerate(epochs_rt.iter_evoked()):
if ev_num == 0:
data_rt = ev.data[None, :, :]
events_ids_rt = int(
ev.comment) # comment attribute contains event_id
else:
data_rt = np.concatenate(
(data_rt, ev.data[None, :, :]), axis=0)
events_ids_rt = np.append(events_ids_rt,
int(ev.comment))
_call_base_epochs_public_api(epochs_rt, tmpdir)
epochs_rt.stop(stop_receive_thread=True)
assert_array_equal(events_ids_rt, epochs_rt.events[:, 2])
assert_array_equal(data_rt, epochs_rt.get_data())
assert len(epochs_rt) == len(epochs_offline)
assert_array_equal(events_ids_rt, epochs_offline.events[:, 2])
assert_allclose(epochs_rt.get_data(), epochs_offline.get_data(),
rtol=1.e-5, atol=1.e-8) # defaults of np.isclose
def test_events_sampledata():
""" based on examples/realtime/plot_compute_rt_decoder.py"""
data_path = sample.data_path()
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif'
raw = read_raw_fif(raw_fname, preload=True)
raw_tmin, raw_tmax = 0, 90
tmin, tmax = -0.2, 0.5
event_id = dict(aud_l=1, vis_l=3)
# select gradiometers
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
# load data with usual Epochs for later verification
raw_cropped = raw.copy().crop(raw_tmin, raw_tmax)
events_offline = find_events(raw_cropped)
epochs_offline = Epochs(raw_cropped, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6),
baseline=None)
epochs_offline.drop_bad()
# create the mock-client object
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks, decim=1,
reject=dict(grad=4000e-13, eog=150e-6), baseline=None,
isi_max=1.)
rt_epochs.start()
rt_client.send_data(rt_epochs, picks, tmin=raw_tmin, tmax=raw_tmax,
buffer_size=1000)
expected_events = epochs_offline.events.copy()
expected_events[:, 0] = expected_events[:, 0] - raw_cropped.first_samp
assert np.all(expected_events[:, 0] <=
(raw_tmax - tmax) * raw.info['sfreq'])
assert_array_equal(rt_epochs.events, expected_events)
assert len(rt_epochs) == len(epochs_offline)
data_picks = pick_types(epochs_offline.info, meg='grad', eeg=False,
eog=True,
stim=False, exclude=raw.info['bads'])
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
if ev_num == 0:
X_rt = ev.data[None, data_picks, :]
y_rt = int(ev.comment) # comment attribute contains the event_id
else:
X_rt = np.concatenate((X_rt, ev.data[None, data_picks, :]), axis=0)
y_rt = np.append(y_rt, int(ev.comment))
X_offline = epochs_offline.get_data()[:, data_picks, :]
y_offline = epochs_offline.events[:, 2]
assert_array_equal(X_rt, X_offline)
assert_array_equal(y_rt, y_offline)
def test_fieldtrip_rtepochs(free_tcp_port, tmpdir):
"""Test FieldTrip RtEpochs."""
raw_tmax = 7
raw = read_raw_fif(raw_fname, preload=True)
raw.crop(tmin=0, tmax=raw_tmax)
events_offline = find_events(raw, stim_channel='STI 014')
event_id = list(np.unique(events_offline[:, 2]))
tmin, tmax = -0.2, 0.5
epochs_offline = Epochs(raw, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax)
epochs_offline.drop_bad()
isi_max = (np.max(np.diff(epochs_offline.events[:, 0])) /
raw.info['sfreq']) + 1.0
kill_signal = _start_buffer_thread(free_tcp_port)
try:
data_rt = None
events_ids_rt = None
with pytest.warns(RuntimeWarning, match='Trying to guess it'):
with FieldTripClient(host='localhost', port=free_tcp_port,
tmax=raw_tmax, wait_max=2) as rt_client:
# get measurement info guessed by MNE-Python
raw_info = rt_client.get_measurement_info()
assert ([ch['ch_name'] for ch in raw_info['chs']] ==
[ch['ch_name'] for ch in raw.info['chs']])
# create the real-time epochs object
epochs_rt = RtEpochs(rt_client, event_id, tmin, tmax,
stim_channel='STI 014', isi_max=isi_max)
epochs_rt.start()
time.sleep(0.5)
for ev_num, ev in enumerate(epochs_rt.iter_evoked()):
if ev_num == 0:
data_rt = ev.data[None, :, :]
events_ids_rt = int(
ev.comment) # comment attribute contains event_id
else:
data_rt = np.concatenate(
(data_rt, ev.data[None, :, :]), axis=0)
events_ids_rt = np.append(events_ids_rt,
int(ev.comment))
_call_base_epochs_public_api(epochs_rt, tmpdir)
epochs_rt.stop(stop_receive_thread=True)
assert_array_equal(events_ids_rt, epochs_rt.events[:, 2])
assert_array_equal(data_rt, epochs_rt.get_data())
assert len(epochs_rt) == len(epochs_offline)
assert_array_equal(events_ids_rt, epochs_offline.events[:, 2])
assert_allclose(epochs_rt.get_data(), epochs_offline.get_data(),
rtol=1.e-5, atol=1.e-8) # defaults of np.isclose
finally:
kill_signal.put(False) # stop the buffer
def test_fieldtrip_rtepochs(free_tcp_port, tmpdir):
"""Test FieldTrip RtEpochs."""
raw_tmax = 7
raw = read_raw_fif(raw_fname, preload=True)
raw.crop(tmin=0, tmax=raw_tmax)
events_offline = find_events(raw, stim_channel='STI 014')
event_id = list(np.unique(events_offline[:, 2]))
tmin, tmax = -0.2, 0.5
epochs_offline = Epochs(raw, events_offline, event_id=event_id,
tmin=tmin, tmax=tmax)
epochs_offline.drop_bad()
isi_max = (np.max(np.diff(epochs_offline.events[:, 0])) /
raw.info['sfreq']) + 1.0
kill_signal = _start_buffer_thread(free_tcp_port)
try:
data_rt = None
events_ids_rt = None
with pytest.warns(RuntimeWarning, match='Trying to guess it'):
with FieldTripClient(host='localhost', port=free_tcp_port,
tmax=raw_tmax, wait_max=2) as rt_client:
# get measurement info guessed by MNE-Python
raw_info = rt_client.get_measurement_info()
assert ([ch['ch_name'] for ch in raw_info['chs']] ==
[ch['ch_name'] for ch in raw.info['chs']])
# create the real-time epochs object
epochs_rt = RtEpochs(rt_client, event_id, tmin, tmax,
stim_channel='STI 014', isi_max=isi_max)
epochs_rt.start()
time.sleep(0.5)
for ev_num, ev in enumerate(epochs_rt.iter_evoked()):
if ev_num == 0:
data_rt = ev.data[None, :, :]
events_ids_rt = int(
ev.comment) # comment attribute contains event_id
else:
data_rt = np.concatenate(
(data_rt, ev.data[None, :, :]), axis=0)
events_ids_rt = np.append(events_ids_rt,
int(ev.comment))
_call_base_epochs_public_api(epochs_rt, tmpdir)
epochs_rt.stop(stop_receive_thread=True)
assert_array_equal(events_ids_rt, epochs_rt.events[:, 2])
assert_array_equal(data_rt, epochs_rt.get_data())
assert len(epochs_rt) == len(epochs_offline)
assert_array_equal(events_ids_rt, epochs_offline.events[:, 2])
assert_allclose(epochs_rt.get_data(), epochs_offline.get_data(),
rtol=1.e-5, atol=1.e-8) # defaults of np.isclose
finally:
kill_signal.put(False) # stop the buffer
data_picks = mne.pick_types(rt_epochs.info,
meg='grad',
eeg=False,
eog=True,
stim=False,
exclude=raw.info['bads'])
ax = plt.subplot(111)
ax.set_xlabel('Trials')
ax.set_ylabel('Classification score (% correct)')
ax.set_title('Real-time decoding')
ax.set_xlim([min_trials, 50])
ax.set_ylim([30, 105])
plt.axhline(50, color='k', linestyle='--', label="Chance level")
plt.show(block=False)
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
print("Just got epoch %d" % (ev_num + 1))
if ev_num == 0:
X = ev.data[None, data_picks, :]
y = int(ev.comment) # the comment attribute contains the event_id
else:
X = np.concatenate((X, ev.data[None, data_picks, :]), axis=0)
y = np.append(y, int(ev.comment))
if ev_num >= min_trials:
cv = ShuffleSplit(5, test_size=0.2, random_state=42)
scores_t = cross_val_score(concat_classifier, X, y, cv=cv,
n_jobs=1) * 100
scores_x, scores, std_scores = [], [], []
filt = FilterEstimator(rt_epochs.info, 1, 40)
scaler = preprocessing.StandardScaler()
vectorizer = EpochsVectorizer()
clf = SVC(C=1, kernel='linear')
concat_classifier = Pipeline([('filter', filt), ('vector', vectorizer),
('scaler', scaler), ('svm', clf)])
data_picks = mne.pick_types(rt_epochs.info, meg='grad', eeg=False, eog=True,
stim=False, exclude=raw.info['bads'])
for ev_num, ev in enumerate(rt_epochs.iter_evoked()):
print("Just got epoch %d" % (ev_num + 1))
if ev_num == 0:
X = ev.data[None, data_picks, :]
y = int(ev.comment) # the comment attribute contains the event_id
else:
X = np.concatenate((X, ev.data[None, data_picks, :]), axis=0)
y = np.append(y, int(ev.comment))
if ev_num >= min_trials:
cv = ShuffleSplit(len(y), 5, test_size=0.2, random_state=42)
scores_t = cross_val_score(concat_classifier, X, y, cv=cv,
n_jobs=1) * 100
def test_find_events():
"""Test find_events in rt_epochs."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
# make sure next() works even if no iter-method has been called before
rt_epochs.next()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 1
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 3
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# output='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 5
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events at the beginning of the buffer
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 1000:1005] = 5
raw._update_times()
# Check that we find events that start at the beginning of the buffer
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events over different buffers
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 997:1003] = 5
raw._update_times()
for min_dur in [0.002, 0.004]:
find_events = dict(consecutive=False, min_duration=min_dur)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10,
buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# create the real-time epochs object
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
stim_channel='STI 014',
picks=picks,
reject=dict(grad=4000e-13, eog=150e-6),
decim=1,
isi_max=10.0,
proj=None)
# start the acquisition
rt_epochs.start()
for ii, ev in enumerate(rt_epochs.iter_evoked()):
print("Just got epoch %d" % (ii + 1))
ev.pick_types(meg=True, eog=False)
if ii == 0:
evoked = ev
else:
evoked = mne.combine_evoked([evoked, ev], weights='nave')
ax[0].cla()
ax[1].cla() # clear axis
plot_events(rt_epochs.events[-5:],
sfreq=ev.info['sfreq'],
first_samp=-rt_client.tmin_samp,
axes=ax[0])
def test_find_events():
"""Test find_events in rt_epochs."""
raw = read_raw_fif(raw_fname, preload=True, verbose=False)
picks = pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 1
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 3
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# output='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 5
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events at the beginning of the buffer
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 1000:1005] = 5
raw._update_times()
# Check that we find events that start at the beginning of the buffer
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle events over different buffers
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 997:1003] = 5
raw._update_times()
for min_dur in [0.002, 0.004]:
find_events = dict(consecutive=False, min_duration=min_dur)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10,
buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert ev.comment == str(events[ii])
assert ii == 0
tmax=30, wait_max=5, info=info) as rt_client:
# get measurement info guessed by MNE-Python
raw_info = rt_client.get_measurement_info()
# select gradiometers
picks = mne.pick_types(raw_info, meg='grad', eeg=False, eog=True,
stim=True, exclude=bads)
# create the real-time epochs object and start acquisition
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax,
stim_channel='STI 014', picks=picks,
reject=dict(grad=4000e-13, eog=150e-6),
decim=1, isi_max=2.0, proj=None)
rt_epochs.start()
for ii, ev in enumerate(rt_epochs.iter_evoked()):
print("Just got epoch %d" % (ii + 1))
ev.pick_types(meg=True, eog=False)
if ii == 0:
evoked = ev
else:
evoked = mne.combine_evoked([evoked, ev], weights='nave')
ax[0].cla()
ax[1].cla() # clear axis
plot_events(rt_epochs.events[-5:], sfreq=ev.info['sfreq'],
first_samp=-rt_client.tmin_samp, axes=ax[0])
# plot on second subplot
def test_find_events():
"""Test find_events in rt_epochs."""
raw = mne.io.read_raw_fif(raw_fname, preload=True, verbose=False)
picks = mne.pick_types(raw.info, meg='grad', eeg=False, eog=True,
stim=True, exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=[stim_channel])
# Reset some data for ease of comparison
raw._first_samps[0] = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
raw._update_times()
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 1)
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 3)
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 0)
# ouput='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client, event_id, tmin, tmax, picks=picks,
stim_channel='STI 014', isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 5)
def test_find_events():
"""Test find_events in rt_epochs."""
raw = mne.io.Raw(raw_fname, preload=True, verbose=False)
picks = mne.pick_types(raw.info,
meg='grad',
eeg=False,
eog=True,
stim=True,
exclude=raw.info['bads'])
event_id = [0, 5, 6]
tmin, tmax = -0.2, 0.5
stim_channel = 'STI 014'
stim_channel_idx = pick_channels(raw.info['ch_names'],
include=stim_channel)
# Reset some data for ease of comparison
raw.first_samp = 0
raw.info['sfreq'] = 1000
# Test that we can handle consecutive events with no gap
raw._data[stim_channel_idx, :] = 0
raw._data[stim_channel_idx, 500:520] = 5
raw._data[stim_channel_idx, 520:530] = 6
raw._data[stim_channel_idx, 530:532] = 5
raw._data[stim_channel_idx, 540] = 6
# consecutive=False
find_events = dict(consecutive=False)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 1)
# consecutive=True
find_events = dict(consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 6]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 3)
# min_duration=0.002
find_events = dict(consecutive=False, min_duration=0.002)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 0)
# ouput='step', consecutive=True
find_events = dict(output='step', consecutive=True)
rt_client = MockRtClient(raw)
rt_epochs = RtEpochs(rt_client,
event_id,
tmin,
tmax,
picks=picks,
stim_channel='STI 014',
isi_max=0.5,
find_events=find_events)
rt_client.send_data(rt_epochs, picks, tmin=0, tmax=10, buffer_size=1000)
rt_epochs.start()
events = [5, 6, 5, 0, 6, 0]
for ii, ev in enumerate(rt_epochs.iter_evoked()):
assert_true(ev.comment == str(events[ii]))
assert_true(ii == 5)