def test_read_vhdr_annotations_and_events():
"""Test load brainvision annotations and parse them to events."""
sfreq = 1000.0
expected_orig_time = 1384359243.794231
expected_onset_latency = np.array(
[0, 486., 496., 1769., 1779., 3252., 3262., 4935., 4945., 5999., 6619.,
6629., 7629., 7699.]
)
expected_annot_description = [
'New Segment/', 'Stimulus/S253', 'Stimulus/S255', 'Event/254',
'Stimulus/S255', 'Event/254', 'Stimulus/S255', 'Stimulus/S253',
'Stimulus/S255', 'Response/R255', 'Event/254', 'Stimulus/S255',
'SyncStatus/Sync On', 'Optic/O 1'
]
expected_events = np.stack([
expected_onset_latency,
np.zeros_like(expected_onset_latency),
[99999, 253, 255, 254, 255, 254, 255, 253, 255, 1255, 254, 255, 99998,
2001],
]).astype('int64').T
expected_event_id = {'New Segment/': 99999, 'Stimulus/S253': 253,
'Stimulus/S255': 255, 'Event/254': 254,
'Response/R255': 1255, 'SyncStatus/Sync On': 99998,
'Optic/O 1': 2001}
raw = read_raw_brainvision(vhdr_path, eog=eog)
# validate annotations
assert raw.annotations.orig_time == expected_orig_time
assert_allclose(raw.annotations.onset, expected_onset_latency / sfreq)
assert_array_equal(raw.annotations.description, expected_annot_description)
# validate event extraction
events, event_id = events_from_annotations(raw)
assert_array_equal(events, expected_events)
assert event_id == expected_event_id
# validate that None gives us a sorted list
expected_none_event_id = {desc: idx + 1 for idx, desc in enumerate(sorted(
event_id.keys()))}
events, event_id = events_from_annotations(raw, event_id=None)
assert event_id == expected_none_event_id
# Add some custom ones, plus a 2-digit one
s_10 = 'Stimulus/S 10'
raw.annotations.append([1, 2, 3], 10, ['ZZZ', s_10, 'YYY'])
expected_event_id.update(YYY=10001, ZZZ=10002) # others starting at 10001
expected_event_id[s_10] = 10
_, event_id = events_from_annotations(raw)
assert event_id == expected_event_id
# Concatenating two shouldn't change the resulting event_id
# (BAD and EDGE should be ignored)
with pytest.warns(RuntimeWarning, match='expanding outside'):
raw_concat = concatenate_raws([raw.copy(), raw.copy()])
_, event_id = events_from_annotations(raw_concat)
assert event_id == expected_event_id
def test_read_vhdr_annotations_and_events():
"""Test load brainvision annotations and parse them to events."""
sfreq = 1000.0
expected_orig_time = 1384359243.794231
expected_onset_latency = np.array(
[0, 486., 496., 1769., 1779., 3252., 3262., 4935., 4945., 5999., 6619.,
6629., 7629., 7699.]
)
expected_annot_description = [
'New Segment/', 'Stimulus/S253', 'Stimulus/S255', 'Stimulus/S254',
'Stimulus/S255', 'Stimulus/S254', 'Stimulus/S255', 'Stimulus/S253',
'Stimulus/S255', 'Response/R255', 'Stimulus/S254', 'Stimulus/S255',
'SyncStatus/Sync On', 'Optic/O 1'
]
expected_events = np.stack([
expected_onset_latency,
np.zeros_like(expected_onset_latency),
[99999, 253, 255, 254, 255, 254, 255, 253, 255, 1255, 254, 255, 99998,
2001],
]).astype('int64').T
expected_event_id = {'New Segment/': 99999, 'Stimulus/S253': 253,
'Stimulus/S255': 255, 'Stimulus/S254': 254,
'Response/R255': 1255, 'SyncStatus/Sync On': 99998,
'Optic/O 1': 2001}
raw = read_raw_brainvision(vhdr_path, eog=eog)
# validate annotations
assert raw.annotations.orig_time == expected_orig_time
assert_allclose(raw.annotations.onset, expected_onset_latency / sfreq)
assert_array_equal(raw.annotations.description, expected_annot_description)
# validate event extraction
events, event_id = events_from_annotations(raw)
assert_array_equal(events, expected_events)
assert event_id == expected_event_id
# validate that None gives us a sorted list
expected_none_event_id = {desc: idx + 1 for idx, desc in enumerate(sorted(
event_id.keys()))}
events, event_id = events_from_annotations(raw, event_id=None)
assert event_id == expected_none_event_id
# Add some custom ones, plus a 2-digit one
s_10 = 'Stimulus/S 10'
raw.annotations.append([1, 2, 3], 10, ['ZZZ', s_10, 'YYY'])
expected_event_id.update(YYY=10001, ZZZ=10002) # others starting at 10001
expected_event_id[s_10] = 10
_, event_id = events_from_annotations(raw)
assert event_id == expected_event_id
# Concatenating two shouldn't change the resulting event_id
# (BAD and EDGE should be ignored)
with pytest.warns(RuntimeWarning, match='expanding outside'):
raw_concat = concatenate_raws([raw.copy(), raw.copy()])
_, event_id = events_from_annotations(raw_concat)
assert event_id == expected_event_id
def test_event_id_stability_when_save_and_fif_reload(tmpdir):
"""Test load events from brainvision annotations when read_raw_fif."""
fname = op.join(str(tmpdir), 'bv-raw.fif')
raw = read_raw_brainvision(vhdr_path, eog=eog)
original_events, original_event_id = events_from_annotations(raw)
raw.save(fname)
raw = read_raw_fif(fname)
events, event_id = events_from_annotations(raw)
assert event_id == original_event_id
assert_array_equal(events, original_events)
def test_read_events_curry_are_same_as_bdf(fname):
"""Test events from curry annotations recovers the right events."""
EVENT_ID = {str(ii): ii for ii in range(5)}
REF_EVENTS = find_events(read_raw_bdf(bdf_file, preload=True))
raw = read_raw_curry(fname)
events, _ = events_from_annotations(raw, event_id=EVENT_ID)
assert_allclose(events, REF_EVENTS)
def test_eeglab_event_from_annot():
"""Test all forms of obtaining annotations."""
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
event_id = {'rt': 1, 'square': 2}
raw1 = read_raw_eeglab(input_fname=raw_fname, preload=False)
annotations = read_annotations(raw_fname)
assert len(raw1.annotations) == 154
raw1.set_annotations(annotations)
events_b, _ = events_from_annotations(raw1, event_id=event_id)
assert len(events_b) == 154
def test_find_events_backward_compatibility():
"""Test if events are detected correctly in a typical MNE workflow."""
EXPECTED_EVENTS = [[68, 0, 2], [199, 0, 2], [1024, 0, 3], [1280, 0, 2]]
# test an actual file
raw = read_raw_edf(edf_path, preload=True)
event_id = _get_edf_default_event_id(raw.annotations.description)
event_id.pop('start')
events_from_EFA, _ = events_from_annotations(raw,
event_id=event_id,
use_rounding=False)
assert_array_equal(events_from_EFA, EXPECTED_EVENTS)
def test_find_events_backward_compatibility():
"""Test if events are detected correctly in a typical MNE workflow."""
EXPECTED_EVENTS = [[68, 0, 2],
[199, 0, 2],
[1024, 0, 3],
[1280, 0, 2]]
# test an actual file
raw = read_raw_edf(edf_path, preload=True)
event_id = _get_edf_default_event_id(raw.annotations.description)
event_id.pop('start')
events_from_EFA, _ = events_from_annotations(raw, event_id=event_id,
use_rounding=False)
assert_array_equal(events_from_EFA, EXPECTED_EVENTS)
def test_eeglab_event_from_annot():
"""Test all forms of obtaining annotations."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
montage = op.join(base_dir, 'test_chans.locs')
event_id = {'rt': 1, 'square': 2}
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
preload=False)
annotations = read_annotations(raw_fname)
assert len(raw1.annotations) == 154
raw1.set_annotations(annotations)
events_b, _ = events_from_annotations(raw1, event_id=event_id)
assert len(events_b) == 154
def test_eeglab_event_from_annot():
"""Test all forms of obtaining annotations."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
montage = op.join(base_dir, 'test_chans.locs')
event_id = {'rt': 1, 'square': 2}
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
preload=False)
annotations = read_annotations(raw_fname)
assert len(raw1.annotations) == 154
raw1.set_annotations(annotations)
events_b, _ = events_from_annotations(raw1, event_id=event_id)
assert len(events_b) == 154
def test_load_generator(fname, recwarn):
"""Test IO of annotations from edf and bdf files with raw info."""
raw = read_raw_edf(fname)
assert len(raw.annotations.onset) == 2
found_types = [k for k, v in
channel_indices_by_type(raw.info, picks=None).items()
if v]
assert len(found_types) == 1
events, event_id = events_from_annotations(raw)
ch_names = ['squarewave', 'ramp', 'pulse', 'ECG', 'noise', 'sine 1 Hz',
'sine 8 Hz', 'sine 8.5 Hz', 'sine 15 Hz', 'sine 17 Hz',
'sine 50 Hz']
assert raw.get_data().shape == (11, 120000)
assert raw.ch_names == ch_names
assert event_id == {'RECORD START': 1, 'REC STOP': 2}
assert_array_equal(events, [[0, 0, 1], [120000, 0, 2]])
def test_load_generator(fname, recwarn):
"""Test IO of annotations from edf and bdf files with raw info."""
raw = read_raw_edf(fname)
assert len(raw.annotations.onset) == 2
found_types = [k for k, v in
channel_indices_by_type(raw.info, picks=None).items()
if v]
assert len(found_types) == 1
events, event_id = events_from_annotations(raw)
ch_names = ['squarewave', 'ramp', 'pulse', 'ECG', 'noise', 'sine 1 Hz',
'sine 8 Hz', 'sine 8.5 Hz', 'sine 15 Hz', 'sine 17 Hz',
'sine 50 Hz']
assert raw.get_data().shape == (11, 120000)
assert raw.ch_names == ch_names
assert event_id == {'RECORD START': 1, 'REC STOP': 2}
assert_array_equal(events, [[0, 0, 1], [120000, 0, 2]])
def test_eeglab_event_from_annot(recwarn):
"""Test all forms of obtaining annotations."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
montage = op.join(base_dir, 'test_chans.locs')
event_id = {'rt': 1, 'square': 2}
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False)
events_a = find_events(raw1)
events_b = read_events_eeglab(raw_fname, event_id=event_id)
annotations = read_annotations_eeglab(raw_fname)
assert raw1.annotations is None
raw1.set_annotations(annotations)
events_c, _ = events_from_annotations(raw1, event_id=event_id)
assert_array_equal(events_a, events_b)
assert_array_equal(events_a, events_c)
def test_find_events_and_events_from_annot_are_the_same():
"""Test that old behaviour and new produce the same events."""
EXPECTED_EVENTS = [[68, 0, 2], [199, 0, 2], [1024, 0, 3], [1280, 0, 2]]
raw = read_raw_edf(edf_path, preload=True)
raw_shell = _get_empty_raw_with_valid_annot(edf_path)
assert raw_shell.info['meas_date'] == raw.info['meas_date']
assert raw_shell.info['sfreq'] == raw.info['sfreq']
assert raw_shell.first_samp == raw.first_samp
events_from_find_events = find_events(raw)
assert_array_equal(events_from_find_events, EXPECTED_EVENTS)
annot = read_annotations_edf(edf_path)
raw_shell.set_annotations(annot)
event_id = _get_edf_default_event_id(annot.description)
event_id.pop('start')
events_from_EFA, _ = events_from_annotations(raw_shell,
event_id=event_id,
use_rounding=False)
assert_array_equal(events_from_EFA, events_from_find_events)
def test_eeglab_event_from_annot(recwarn):
"""Test all forms of obtaining annotations."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
montage = op.join(base_dir, 'test_chans.locs')
event_id = {'rt': 1, 'square': 2}
raw1 = read_raw_eeglab(input_fname=raw_fname,
montage=montage,
event_id=event_id,
preload=False)
events_a = find_events(raw1)
events_b = read_events_eeglab(raw_fname, event_id=event_id)
annotations = read_annotations_eeglab(raw_fname)
assert raw1.annotations is None
raw1.set_annotations(annotations)
events_c, _ = events_from_annotations(raw1, event_id=event_id)
assert_array_equal(events_a, events_b)
assert_array_equal(events_a, events_c)
def test_eeglab_event_from_annot():
"""Test all forms of obtaining annotations."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname_mat = op.join(base_dir, 'test_raw.set')
raw_fname = raw_fname_mat
montage = op.join(base_dir, 'test_chans.locs')
event_id = {'rt': 1, 'square': 2}
with pytest.deprecated_call(match='stim_channel'):
raw1 = read_raw_eeglab(input_fname=raw_fname,
montage=montage,
event_id=event_id,
preload=False)
events_a = find_events(raw1)
with pytest.deprecated_call(match='read_events_eeglab'):
events_b = read_events_eeglab(raw_fname, event_id=event_id)
annotations = read_annotations(raw_fname)
assert len(raw1.annotations) == 154
raw1.set_annotations(annotations)
events_c, _ = events_from_annotations(raw1, event_id=event_id)
assert_array_equal(events_a, events_b)
assert_array_equal(events_a, events_c)
def test_find_events_and_events_from_annot_are_the_same():
"""Test that old behaviour and new produce the same events."""
EXPECTED_EVENTS = [[68, 0, 2],
[199, 0, 2],
[1024, 0, 3],
[1280, 0, 2]]
raw = read_raw_edf(edf_path, preload=True, stim_channel='auto')
raw_shell = _get_empty_raw_with_valid_annot(edf_path)
assert raw_shell.info['meas_date'] == raw.info['meas_date']
assert raw_shell.info['sfreq'] == raw.info['sfreq']
assert raw_shell.first_samp == raw.first_samp
events_from_find_events = find_events(raw)
assert_array_equal(events_from_find_events, EXPECTED_EVENTS)
annot = read_annotations(edf_path)
raw_shell.set_annotations(annot)
event_id = _get_edf_default_event_id(annot.description)
event_id.pop('start')
events_from_EFA, _ = events_from_annotations(raw_shell, event_id=event_id,
use_rounding=False)
assert_array_equal(events_from_EFA, events_from_find_events)
def test_read_vhdr_annotations_and_events(tmp_path):
"""Test load brainvision annotations and parse them to events."""
# First we add a custom event that contains a comma in its description
for src, dest in zip((vhdr_path, vmrk_path, eeg_path),
('test.vhdr', 'test.vmrk', 'test.eeg')):
shutil.copyfile(src, tmp_path / dest)
# Commas are encoded as "\1"
with open(tmp_path / 'test.vmrk', 'a') as fout:
fout.write(r"Mk15=Comma\1Type,CommaValue\11,7800,1,0\n")
sfreq = 1000.0
expected_orig_time = _stamp_to_dt((1384359243, 794232))
expected_onset_latency = np.array(
[0, 486., 496., 1769., 1779., 3252., 3262., 4935., 4945., 5999., 6619.,
6629., 7629., 7699., 7799.]
)
expected_annot_description = [
'New Segment/', 'Stimulus/S253', 'Stimulus/S255', 'Event/254',
'Stimulus/S255', 'Event/254', 'Stimulus/S255', 'Stimulus/S253',
'Stimulus/S255', 'Response/R255', 'Event/254', 'Stimulus/S255',
'SyncStatus/Sync On', 'Optic/O 1', 'Comma,Type/CommaValue,1'
]
expected_events = np.stack([
expected_onset_latency,
np.zeros_like(expected_onset_latency),
[99999, 253, 255, 254, 255, 254, 255, 253, 255, 1255, 254, 255, 99998,
2001, 10001],
]).astype('int64').T
expected_event_id = {'New Segment/': 99999, 'Stimulus/S253': 253,
'Stimulus/S255': 255, 'Event/254': 254,
'Response/R255': 1255, 'SyncStatus/Sync On': 99998,
'Optic/O 1': 2001, 'Comma,Type/CommaValue,1': 10001}
raw = read_raw_brainvision(tmp_path / 'test.vhdr', eog=eog)
# validate annotations
assert raw.annotations.orig_time == expected_orig_time
assert_allclose(raw.annotations.onset, expected_onset_latency / sfreq)
assert_array_equal(raw.annotations.description, expected_annot_description)
# validate event extraction
events, event_id = events_from_annotations(raw)
assert_array_equal(events, expected_events)
assert event_id == expected_event_id
# validate that None gives us a sorted list
expected_none_event_id = {desc: idx + 1 for idx, desc in enumerate(sorted(
event_id.keys()))}
events, event_id = events_from_annotations(raw, event_id=None)
assert event_id == expected_none_event_id
# Add some custom ones, plus a 2-digit one
s_10 = 'Stimulus/S 10'
raw.annotations.append([1, 2, 3], 10, ['ZZZ', s_10, 'YYY'])
# others starting at 10001 ...
# we already have "Comma,Type/CommaValue,1" as 10001
expected_event_id.update(YYY=10002, ZZZ=10003)
expected_event_id[s_10] = 10
_, event_id = events_from_annotations(raw)
assert event_id == expected_event_id
# Concatenating two shouldn't change the resulting event_id
# (BAD and EDGE should be ignored)
with pytest.warns(RuntimeWarning, match='expanding outside'):
raw_concat = concatenate_raws([raw.copy(), raw.copy()])
_, event_id = events_from_annotations(raw_concat)
assert event_id == expected_event_id
