def test_read_ica_eeglab():
"""Test read_ica_eeglab function."""
fname = op.join(test_base_dir, "EEGLAB", "test_raw.set")
fname_cleaned_matlab = op.join(test_base_dir, "EEGLAB",
"test_raw.cleaned.set")
raw = read_raw_eeglab(fname, preload=True)
raw_eeg = _check_load_mat(fname, None)
raw_cleaned_matlab = read_raw_eeglab(fname_cleaned_matlab,
preload=True)
mark_to_remove = ["manual"]
comp_info = raw_eeg.marks["comp_info"]
if len(comp_info["flags"].shape) > 1:
ind_comp_to_drop = [np.where(flags)[0]
for flags, label in zip(comp_info["flags"],
comp_info["label"])
if label in mark_to_remove]
ind_comp_to_drop = np.unique(np.concatenate(ind_comp_to_drop))
else:
ind_comp_to_drop = np.where(comp_info["flags"])[0]
ica = read_ica_eeglab(fname)
_assert_ica_attributes(ica)
raw_cleaned = ica.apply(raw.copy(), exclude=ind_comp_to_drop)
assert_allclose(raw_cleaned_matlab.get_data(), raw_cleaned.get_data(),
rtol=1e-05, atol=1e-08)
def test_position_information(one_chanpos_fname):
"""Test reading file with 3 channels - one without position information."""
nan = np.nan
EXPECTED_LOCATIONS_FROM_FILE = np.array([
[-4., 1., 7., 0., 0., 0., nan, nan, nan, nan, nan, nan],
[-5., 2., 8., 0., 0., 0., nan, nan, nan, nan, nan, nan],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
])
EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
])
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_FILE)
# To accommodate the new behavior so that:
# read_raw_eeglab(.. montage=montage) and raw.set_montage(montage)
# behaves the same we need to flush the montage. otherwise we get
# a mix of what is in montage and in the file
raw = read_raw_eeglab(
input_fname=one_chanpos_fname,
preload=True,
).set_montage(None) # Flush the montage builtin within input_fname
_assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_MONTAGE)
_assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_MONTAGE)
def test_io_set():
"""Test importing EEGLAB .set files"""
from scipy import io
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile,
montage=montage)
raw = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage)
raw2 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
assert_array_equal(raw[:][0], raw2[:][0])
# one warning per each preload=False or str with raw_fname_onefile
assert_equal(len(w), 3)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = read_epochs_eeglab(epochs_fname)
epochs2 = read_epochs_eeglab(epochs_fname_onefile)
# 3 warnings for each read_epochs_eeglab because there are 3 epochs
# associated with multiple events
assert_equal(len(w), 6)
assert_array_equal(epochs.get_data(), epochs2.get_data())
# test different combinations of events and event_ids
temp_dir = _TempDir()
out_fname = op.join(temp_dir, 'test-eve.fif')
write_events(out_fname, epochs.events)
event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3}
epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id)
epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
None, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
epochs.events, None)
# test if .dat file raises an error
eeg = io.loadmat(epochs_fname, struct_as_record=False,
squeeze_me=True)['EEG']
eeg.data = 'epochs_fname.dat'
bad_epochs_fname = op.join(temp_dir, 'test_epochs.set')
io.savemat(bad_epochs_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': eeg.data,
'epoch': eeg.epoch, 'event': eeg.event,
'chanlocs': eeg.chanlocs}})
shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'),
op.join(temp_dir, 'test_epochs.dat'))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert_raises(NotImplementedError, read_epochs_eeglab,
bad_epochs_fname)
assert_equal(len(w), 3)
def test_io_set_raw(fname):
"""Test importing EEGLAB .set files."""
_test_raw_reader(read_raw_eeglab, input_fname=fname,
montage=montage)
# test that preloading works
raw0 = read_raw_eeglab(input_fname=fname, montage=montage,
preload=True)
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=fname, montage=montage,
preload=False, uint16_codec='ascii')
def test_montage():
"""Test montage."""
fname = op.join(base_dir, 'test_raw.set')
raw_none = read_raw_eeglab(input_fname=fname, montage=None, preload=False)
montage = _fake_montage(raw_none.info['ch_names'])
raw_montage = read_raw_eeglab(input_fname=fname, montage=montage,
preload=False)
raw_none.set_montage(montage)
# Check they are the same
assert_array_equal(raw_none.get_data(), raw_montage.get_data())
assert object_diff(raw_none.info['dig'], raw_montage.info['dig']) == ''
assert object_diff(raw_none.info['chs'], raw_montage.info['chs']) == ''
def test_1020_selection():
"""Test making a 10/20 selection dict."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname = op.join(base_dir, 'test_raw.set')
loc_fname = op.join(base_dir, 'test_chans.locs')
raw = read_raw_eeglab(raw_fname, preload=True)
montage = read_custom_montage(loc_fname)
raw = raw.rename_channels(dict(zip(raw.ch_names, montage.ch_names)))
raw.set_montage(montage)
for input in ("a_string", 100, raw, [1, 2]):
pytest.raises(TypeError, make_1020_channel_selections, input)
sels = make_1020_channel_selections(raw.info)
# are all frontal channels placed before all occipital channels?
for name, picks in sels.items():
fs = min([
ii for ii, pick in enumerate(picks)
if raw.ch_names[pick].startswith("F")
])
ps = max([
ii for ii, pick in enumerate(picks)
if raw.ch_names[pick].startswith("O")
])
assert fs > ps
# are channels in the correct selection?
fz_c3_c4 = [raw.ch_names.index(ch) for ch in ("Fz", "C3", "C4")]
for channel, roi in zip(fz_c3_c4, ("Midline", "Left", "Right")):
assert channel in sels[roi]
def read_raw_eeglab_from_source(source: str, channels_to_drop=None) -> Raw:
'''
Read raw EEGLAB .set data from source
Args:
str source: Path to .set data
list channels_to_drop: The list of channel names to drop (EOG channels)
:return: Raw raw: The object containing EEGLAB .set data
See Also
--------
mne.io.read_raw_eeglab : Documentation of parameters.
'''
try:
raw = read_raw_eeglab(source, preload=True).set_annotations(None)
except Exception as e:
logging.error(f'Error while trying to read {source}, error: {e}')
raise
if channels_to_drop is not None:
matched_channels = []
for channel in channels_to_drop:
matched_channels.extend([
raw_ch_name for raw_ch_name in raw.ch_names
if channel in raw_ch_name
])
raw = raw.drop_channels(ch_names=matched_channels)
return raw
def test_export_raw_eeglab(tmp_path):
"""Test saving a Raw instance to EEGLAB's set format."""
raw = read_raw_fif(fname_raw, preload=True)
raw.apply_proj()
temp_fname = op.join(str(tmp_path), 'test.set')
raw.export(temp_fname)
raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names])
raw_read = read_raw_eeglab(temp_fname, preload=True)
assert raw.ch_names == raw_read.ch_names
cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz
cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']])
assert_allclose(cart_coords, cart_coords_read)
assert_allclose(raw.times, raw_read.times)
assert_allclose(raw.get_data(), raw_read.get_data())
# test overwrite
with pytest.raises(FileExistsError, match='Destination file exists'):
raw.export(temp_fname, overwrite=False)
raw.export(temp_fname, overwrite=True)
# test pathlib.Path files
raw.export(Path(temp_fname), overwrite=True)
# test warning with unapplied projectors
raw = read_raw_fif(fname_raw, preload=True)
with pytest.warns(RuntimeWarning,
match='Raw instance has unapplied projectors.'):
raw.export(temp_fname, overwrite=True)
def test_ica_eeg():
"""Test ICA on EEG."""
method = 'fastica'
raw_fif = read_raw_fif(fif_fname, preload=True)
raw_eeglab = read_raw_eeglab(input_fname=eeglab_fname,
preload=True)
for raw in [raw_fif, raw_eeglab]:
events = make_fixed_length_events(raw, 99999, start=0, stop=0.3,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = []
picks_all.extend(picks_meg)
picks_all.extend(picks_eeg)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2, random_state=0, max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst, picks=picks)
_assert_ica_attributes(ica)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
with pytest.warns(RuntimeWarning, match='MISC channel'):
raw = read_raw_ctf(ctf_fname2, preload=True)
events = make_fixed_length_events(raw, 99999, start=0, stop=0.2,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = picks_meg + picks_eeg
for comp in [0, 1]:
raw.apply_gradient_compensation(comp)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2, random_state=0, max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst)
_assert_ica_attributes(ica)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
def test_io_set_raw(fname):
"""Test importing EEGLAB .set files."""
montage = _read_eeglab_montage(montage_path)
montage.ch_names = [
'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names))
]
kws = dict(reader=read_raw_eeglab, input_fname=fname)
if fname.endswith('test_raw_chanloc.set'):
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw0 = _test_raw_reader(**kws)
elif '_h5' in fname: # should be safe enough, and much faster
raw0 = read_raw_eeglab(fname, preload=True)
else:
raw0 = _test_raw_reader(**kws)
# test that preloading works
if fname.endswith('test_raw_chanloc.set'):
raw0.set_montage(montage, on_missing='ignore')
# crop to check if the data has been properly preloaded; we cannot
# filter as the snippet of raw data is very short
raw0.crop(0, 1)
else:
raw0.set_montage(montage)
raw0.filter(1,
None,
l_trans_bandwidth='auto',
filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
read_raw_kws = dict(input_fname=fname, preload=False, uint16_codec='ascii')
if fname.endswith('test_raw_chanloc.set'):
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage, on_missing='ignore')
else:
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage)
# Annotations
if fname != raw_fname_chanloc:
assert len(raw0.annotations) == 154
assert set(raw0.annotations.description) == {'rt', 'square'}
assert_array_equal(raw0.annotations.duration, 0.)
def test_position_information(one_chanpos_fname):
"""Test reading file with 3 channels - one without position information."""
nan = np.nan
EXPECTED_LOCATIONS_FROM_FILE = np.array([
[-4., 1., 7., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
])
EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([
[-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
[0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_FILE)
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
if montage is not None:
raw.set_montage(None) # flushing
raw.set_montage(montage, update_ch_names=False)
_assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_MONTAGE)
# To acomodate the new behavior so that:
# read_raw_eeglab(.. montage=montage) and raw.set_montage(montage)
# behaves the same we need to flush the montage. otherwise we get
# a mix of what is in montage and in the file
foo = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
foo.set_montage(None) # flushing
foo.set_montage(montage, update_ch_names=False)
_assert_array_allclose_nan(np.array([ch['loc'] for ch in foo.info['chs']]),
EXPECTED_LOCATIONS_FROM_MONTAGE)
# Mixed montage: from the file and from montage
foo = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
foo.set_montage(montage, update_ch_names=False)
mixed = np.array([
[-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
_assert_array_allclose_nan(np.array([ch['loc'] for ch in foo.info['chs']]),
mixed)
def test_ica_eeg():
"""Test ICA on EEG."""
method = 'fastica'
raw_fif = read_raw_fif(fif_fname, preload=True)
with pytest.warns(RuntimeWarning, match='events'):
raw_eeglab = read_raw_eeglab(input_fname=eeglab_fname,
montage=eeglab_montage, preload=True)
for raw in [raw_fif, raw_eeglab]:
events = make_fixed_length_events(raw, 99999, start=0, stop=0.3,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = []
picks_all.extend(picks_meg)
picks_all.extend(picks_eeg)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2, random_state=0, max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst, picks=picks)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
with pytest.warns(RuntimeWarning, match='MISC channel'):
raw = read_raw_ctf(ctf_fname2, preload=True)
events = make_fixed_length_events(raw, 99999, start=0, stop=0.2,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = picks_meg + picks_eeg
for comp in [0, 1]:
raw.apply_gradient_compensation(comp)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2, random_state=0, max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
def plot_data(self):
if self.fname == '':
self.log_print('There is no file selected. Please select a file\n')
print('There is no file selected. Please select a file')
else:
self.log_print('Plotting data...')
raw = io.read_raw_eeglab(str(self.fname)) #109_raw.set
raw.plot(block=True)
def test_io_set_raw(fname):
"""Test importing EEGLAB .set files."""
montage = _read_eeglab_montage(montage_path)
montage.ch_names = [
'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names))
]
_test_raw_reader(read_raw_eeglab, input_fname=fname)
# test that preloading works
raw0 = read_raw_eeglab(input_fname=fname, preload=True)
raw0.set_montage(montage)
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=fname,
preload=False, uint16_codec='ascii')
raw0.set_montage(montage)
def test_io_set_raw(fname):
"""Test importing EEGLAB .set files."""
montage = _read_eeglab_montage(montage_path)
montage.ch_names = [
'EEG {0:03d}'.format(ii) for ii in range(len(montage.ch_names))
]
kws = dict(reader=read_raw_eeglab, input_fname=fname)
if fname.endswith('test_raw_chanloc.set'):
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
_test_raw_reader(**kws)
else:
_test_raw_reader(**kws)
# test that preloading works
read_raw_kws = dict(input_fname=fname, preload=True)
if fname.endswith('test_raw_chanloc.set'):
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage, on_missing='ignore')
# crop to check if the data has been properly preloaded; we cannot
# filter as the snippet of raw data is very short
raw0.crop(0, 1)
else:
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage)
raw0.filter(1,
None,
l_trans_bandwidth='auto',
filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
read_raw_kws = dict(input_fname=fname, preload=False, uint16_codec='ascii')
if fname.endswith('test_raw_chanloc.set'):
with pytest.warns(RuntimeWarning,
match="The data contains 'boundary' events"):
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage, on_missing='ignore')
else:
raw0 = read_raw_eeglab(**read_raw_kws)
raw0.set_montage(montage)
def test_montage():
"""Test montage."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
fname = op.join(base_dir, 'test_raw.set')
# montage = op.join(base_dir, 'test_chans.locs')
raw_none = read_raw_eeglab(input_fname=fname, montage=None, preload=False)
montage = _fake_montage(raw_none.info['ch_names'])
raw_montage = read_raw_eeglab(input_fname=fname,
montage=montage,
preload=False)
raw_none.set_montage(montage)
assert object_diff(raw_none.info['dig'], raw_montage.info['dig']) == ''
# assert object_diff(raw_none.info['chs'], raw_montage.info['chs']) == ''
diff = object_diff(raw_none.info['chs'],
raw_montage.info['chs']).splitlines()
for dd in diff:
assert 'coord_frame' in dd
def frequency_filter(self, fname, lfreq, hfreq):
if fname == '':
self.log_print('There is no file selected. Please select a file\n')
print('There is no file selected. Please select a file')
else:
fname = io.read_raw_eeglab(str(fname))
fname.load_data()
fname.filter(lfreq, hfreq)
fname.plot()
self.log_print('Filter applied\n')
print('Filter applied')
def test_fidsposition_information():
"""Test reading file with 3 fiducial locations."""
raw = read_raw_eeglab(raw_fname_chanloc_fids)
montage = raw.get_montage()
pos = montage.get_positions()
assert pos['nasion'] is not None
assert pos['lpa'] is not None
assert pos['rpa'] is not None
assert len(pos['nasion']) == 3
assert len(pos['lpa']) == 3
assert len(pos['rpa']) == 3
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_position_information(one_chanpos_fname):
"""Test reading file with 3 channels - one without position information."""
nan = np.nan
EXPECTED_LOCATIONS_FROM_FILE = np.array([
[-4., 1., 7., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[-5., 2., 8., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
])
EXPECTED_LOCATIONS_FROM_MONTAGE = np.array([
[-0.56705965, 0.67706631, 0.46906776, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan, nan],
[0, 0.99977915, -0.02101571, 0, 0, 0, 0, 0, 0, 0, 0, 0],
])
montage = _read_eeglab_montage(montage_path)
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
assert_array_equal(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_FILE)
# To acomodate the new behavior so that:
# read_raw_eeglab(.. montage=montage) and raw.set_montage(montage)
# behaves the same we need to flush the montage. otherwise we get
# a mix of what is in montage and in the file
raw = read_raw_eeglab(
input_fname=one_chanpos_fname,
preload=True,
).set_montage(None) # Flush the montage builtin within input_fname
with pytest.raises(ValueError):
raw.set_montage(montage, update_ch_names=False)
_msg = (
'DigMontage is a only a subset of info. '
'Did not set 1 channel positions:\nunknown'
)
with pytest.warns(RuntimeWarning, match=_msg):
raw.set_montage(montage, update_ch_names=False, raise_if_subset=False)
_assert_array_allclose_nan(np.array([ch['loc'] for ch in raw.info['chs']]),
EXPECTED_LOCATIONS_FROM_MONTAGE)
def test_eeglab_read_annotations():
"""Test annotations onsets are timestamps (+ validate some)."""
annotations = read_annotations(raw_fname_mat)
validation_samples = [0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
expected_onset = np.array([1.00, 1.69, 2.08, 4.70, 7.71, 11.30, 17.18,
20.20, 26.12, 29.14, 35.25, 44.30, 47.15])
assert annotations.orig_time is None
assert_array_almost_equal(annotations.onset[validation_samples],
expected_onset, decimal=2)
# test if event durations are imported correctly
raw = read_raw_eeglab(raw_fname_event_duration, preload=True)
# file contains 3 annotations with 0.5 s (64 samples) duration each
assert_allclose(raw.annotations.duration, np.ones(3) * 0.5)
def test_eeglab_read_annotations():
"""Test annotations onsets are timestamps (+ validate some)."""
annotations = read_annotations(raw_fname_mat)
validation_samples = [0, 1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
expected_onset = np.array([1.00, 1.69, 2.08, 4.70, 7.71, 11.30, 17.18,
20.20, 26.12, 29.14, 35.25, 44.30, 47.15])
assert annotations.orig_time is None
assert_array_almost_equal(annotations.onset[validation_samples],
expected_onset, decimal=2)
# test if event durations are imported correctly
raw = read_raw_eeglab(raw_fname_event_duration, preload=True)
# file contains 3 annotations with 0.5 s (64 samples) duration each
assert_allclose(raw.annotations.duration, np.ones(3) * 0.5)
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_export_eeglab(tmpdir):
"""Test saving a Raw instance to EEGLAB's set format."""
fname = Path(__file__).parent / "data" / "test_raw.fif"
raw = read_raw_fif(fname)
raw.load_data()
temp_fname = op.join(str(tmpdir), 'test.set')
raw.export(temp_fname)
raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names])
raw_read = read_raw_eeglab(temp_fname, preload=True)
assert raw.ch_names == raw_read.ch_names
cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz
cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']])
assert_allclose(cart_coords, cart_coords_read)
assert_allclose(raw.times, raw_read.times)
assert_allclose(raw.get_data(), raw_read.get_data())
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(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(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 _get_single_subject_data(
self,
subject: Union[str, int],
verbose: Optional[Union[bool, str, int]] = None
) -> Dict[str, Dict[str, Raw]]:
dests = self.data_path(subject)
# DON'T KNOW CHANNEL NAMES!!!
# montage = make_standard_montage('standard_1005')
# montage.ch_names = [ch_name.upper() for ch_name in montage.ch_names]
sess = dict()
for isess, run_dests in enumerate(dests):
runs = dict()
for irun, run_array in enumerate(run_dests):
raw = read_raw_eeglab(run_array, preload=True)
raw = upper_ch_names(raw)
# raw.set_montage(montage)
raw.annotations.delete(0)
runs['run_{:d}'.format(irun)] = raw
sess['session_{:d}'.format(isess)] = runs
return sess
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_1020_selection():
"""Test making a 10/20 selection dict."""
base_dir = op.join(testing.data_path(download=False), 'EEGLAB')
raw_fname = op.join(base_dir, 'test_raw.set')
loc_fname = op.join(base_dir, 'test_chans.locs')
raw = read_raw_eeglab(raw_fname, montage=loc_fname)
for input in ("a_string", 100, raw, [1, 2]):
pytest.raises(TypeError, make_1020_channel_selections, input)
sels = make_1020_channel_selections(raw.info)
# are all frontal channels placed before all occipital channels?
for name, picks in sels.items():
fs = min([ii for ii, pick in enumerate(picks)
if raw.ch_names[pick].startswith("F")])
ps = max([ii for ii, pick in enumerate(picks)
if raw.ch_names[pick].startswith("O")])
assert fs > ps
# are channels in the correct selection?
fz_c3_c4 = [raw.ch_names.index(ch) for ch in ("Fz", "C3", "C4")]
for channel, roi in zip(fz_c3_c4, ("Midline", "Left", "Right")):
assert channel in sels[roi]
def read_info(path):
from PySide2.QtCore import QUrl
from mne.io import read_raw_cnt, read_raw_eeglab
list_path = [QUrl(i).toLocalFile() for i in path]
try:
raw = {
k: read_raw_cnt(k,
montage=None,
preload=True,
stim_channel=False,
verbose=None)
if k.endswith("cnt") else read_raw_eeglab(k,
montage=None,
preload=True,
stim_channel=False,
verbose=None)
for k in list_path
}
info = list()
sfreq = list()
for signal in raw:
raw_info = raw[signal].info
info.append(raw_info['subject_info'])
sfreq.append(raw_info['sfreq'])
del raw
return info, sfreq
except IOError:
print('An error occurred trying to read the file.')
except ImportError:
print('No file found.')
except:
print('Cant read file')
finally:
print('Upload info correctly')
def test_export_raw_eeglab(tmp_path):
"""Test saving a Raw instance to EEGLAB's set format."""
fname = (Path(__file__).parent.parent.parent / "io" / "tests" / "data" /
"test_raw.fif")
raw = read_raw_fif(fname)
raw.load_data()
temp_fname = op.join(str(tmp_path), 'test.set')
raw.export(temp_fname)
raw.drop_channels([ch for ch in ['epoc'] if ch in raw.ch_names])
raw_read = read_raw_eeglab(temp_fname, preload=True)
assert raw.ch_names == raw_read.ch_names
cart_coords = np.array([d['loc'][:3] for d in raw.info['chs']]) # just xyz
cart_coords_read = np.array([d['loc'][:3] for d in raw_read.info['chs']])
assert_allclose(cart_coords, cart_coords_read)
assert_allclose(raw.times, raw_read.times)
assert_allclose(raw.get_data(), raw_read.get_data())
# test overwrite
with pytest.raises(FileExistsError, match='Destination file exists'):
raw.export(temp_fname, overwrite=False)
raw.export(temp_fname, overwrite=True)
# test pathlib.Path files
raw.export(Path(temp_fname), overwrite=True)
def read_raw(path):
"""
:rtype: object
:param path: Path of the files that contain the signal
:return:
"""
from PySide2.QtCore import QUrl
from mne.io import read_raw_cnt, read_raw_eeglab
import numpy as np
import os
# list_path = path.split(',')
list_path = [QUrl(i).toLocalFile() for i in path]
print(f'Signal path list: {list_path}')
try:
# Read raw signal
raw = {
k: read_raw_cnt(k,
montage=None,
preload=True,
stim_channel=False,
verbose=None)
if k.endswith("cnt") else read_raw_eeglab(k,
montage=None,
preload=True,
stim_channel=False,
verbose=None)
for k in list_path
}
# raw = {k: read_raw_cnt(k, montage = None, preload = True,
# stim_channel = False, verbose = None) for k in list_path}
# Print the multiples upload signals
for signal in raw:
print(f'\033[1;32;40m {raw[signal]} \033[0m \n')
print(f'\033[1;33;40m {raw[signal].info} \033[0m \n')
b = []
value_path = []
# Values in a numpy array in a dict way
raw2np = {i: np.squeeze(raw[i].get_data())
for i in raw
} # This contain the entire already uploaded data
for keys in raw2np.keys():
print(f'\033[1;32;40m Key: {keys} \033[0m \n ')
print(f'\033[1;35;40m Values: {raw2np[keys]} \033[0m \n')
np_path = str(keys).replace(
'.cnt' if str(keys).endswith('cnt') else '.set', '.npz')
print('Path keys ', np_path)
np.savez_compressed(np_path, raw2np[keys])
# print(np.load(np_path)) # Organizar esto en otro hilo pero bien organizado para cargarlo despues
value_path.append(os.path.join(os.getcwd(), np_path))
b.append(
np.load(np_path)
) # List with the values, each position is a different file
print(f'Value path: {value_path}')
# Update in settings the value path
print(os.getcwd() + "--" + str(keys))
# print(b.__len__(), b[0].shape, b[1].shape)
return value_path
except IOError:
print('An error occurred trying to read the file.')
except ImportError:
print('No file found.')
except:
print('Cant read file')
finally:
print('Upload signal(s) correctly')
def mne_switch(file, ext, downsample, preload=True, **kwargs):
"""Read sleep datasets using mne.io.
Parameters
----------
file : string
Filename (without extension).
ext : string
File extension (e.g. '.edf'').
preload : bool | True
Preload data in memory.
kwargs : dict | {}
Further arguments to pass to the mne.io.read function.
Returns
-------
sf : float
The original sampling-frequency.
downsample : float
The down-sampling frequency used.
dsf : int
The down-sampling factor.
data : array_like
The raw data of shape (n_channels, n_points)
channels : list
List of channel names.
n : int
Number of time points before down-sampling.
start_time : datetime.time
The time offset.
"""
from mne import io
# Get full path :
path = file + ext
# Preload :
if preload is False:
preload = 'temp.dat'
kwargs['preload'] = preload
if ext.lower() in ['.edf', '.bdf', '.gdf']: # EDF / BDF / GDF
raw = io.read_raw_edf(path, **kwargs)
elif ext.lower == '.set': # EEGLAB
raw = io.read_raw_eeglab(path, **kwargs)
elif ext.lower() in ['.egi', '.mff']: # EGI / MFF
raw = io.read_raw_egi(path, **kwargs)
elif ext.lower() == '.cnt': # CNT
raw = io.read_raw_cnt(path, **kwargs)
elif ext.lower() == '.vhdr': # BrainVision
raw = io.read_raw_brainvision(path, **kwargs)
else:
raise IOError("File not supported by mne-python.")
raw.pick_types(meg=True, eeg=True, ecg=True, emg=True) # Remove stim lines
sf = raw.info['sfreq']
dsf, downsample = get_dsf(downsample, sf)
channels = raw.info['ch_names']
data = raw._data
# Conversion Volt (MNE) to microVolt (Visbrain):
if raw._raw_extras[0] is not None and 'units' in raw._raw_extras[0]:
units = raw._raw_extras[0]['units'][0:data.shape[0]]
data /= np.array(units).reshape(-1, 1)
n = data.shape[1]
start_time = datetime.time(0, 0, 0) # raw.info['meas_date']
anot = raw.annotations
return sf, downsample, dsf, data[:, ::dsf], channels, n, start_time, anot
def test_io_set():
"""Test importing EEGLAB .set files."""
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
# main tests, and test missing event_id
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname,
montage=montage)
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile,
montage=montage)
for want in ('Events like', 'consist entirely', 'could not be mapped',
'string preload is not supported'):
assert_true(any(want in str(ww.message) for ww in w))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
# test finding events in continuous data
event_id = {'rt': 1, 'square': 2}
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=True)
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False)
raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage,
event_id=event_id)
raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id)
raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
Epochs(raw0, find_events(raw0), event_id)
epochs = Epochs(raw1, find_events(raw1), event_id)
assert_equal(len(find_events(raw4)), 0) # no events without event_id
assert_equal(epochs["square"].average().nave, 80) # 80 with
assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0])
assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1])
assert_equal(len(w), 4)
# 1 for preload=False / str with fname_onefile, 3 for dropped events
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero') # test that preloading works
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False,
uint16_codec='ascii')
# test old EEGLAB version event import
eeg = io.loadmat(raw_fname, struct_as_record=False,
squeeze_me=True)['EEG']
for event in eeg.event: # old version allows integer events
event.type = 1
assert_equal(read_events_eeglab(eeg)[-1, -1], 1)
eeg.event = eeg.event[0] # single event
assert_equal(read_events_eeglab(eeg)[-1, -1], 1)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = read_epochs_eeglab(epochs_fname)
epochs2 = read_epochs_eeglab(epochs_fname_onefile)
# one warning for each read_epochs_eeglab because both files have epochs
# associated with multiple events
assert_equal(len(w), 2)
assert_array_equal(epochs.get_data(), epochs2.get_data())
# test different combinations of events and event_ids
temp_dir = _TempDir()
out_fname = op.join(temp_dir, 'test-eve.fif')
write_events(out_fname, epochs.events)
event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3}
epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id)
assert_equal(len(epochs.events), 4)
assert_true(epochs.preload)
assert_true(epochs._bad_dropped)
epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
None, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
epochs.events, None)
# test reading file with one event
eeg = io.loadmat(raw_fname, struct_as_record=False,
squeeze_me=True)['EEG']
one_event_fname = op.join(temp_dir, 'test_one_event.set')
io.savemat(one_event_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt',
'epoch': eeg.epoch, 'event': eeg.event[0],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}})
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
op.join(temp_dir, 'test_one_event.fdt'))
event_id = {eeg.event[0].type: 1}
read_raw_eeglab(input_fname=one_event_fname, montage=montage,
event_id=event_id, preload=True)
# test overlapping events
overlap_fname = op.join(temp_dir, 'test_overlap_event.set')
io.savemat(overlap_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt',
'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}})
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
op.join(temp_dir, 'test_overlap_event.fdt'))
event_id = {'rt': 1, 'square': 2}
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw = read_raw_eeglab(input_fname=overlap_fname,
montage=montage, event_id=event_id,
preload=True)
assert_equal(len(w), 1) # one warning for the dropped event
events_stimchan = find_events(raw)
events_read_events_eeglab = read_events_eeglab(overlap_fname, event_id)
assert_true(len(events_stimchan) == 1)
assert_true(len(events_read_events_eeglab) == 2)
# test reading file with one channel
one_chan_fname = op.join(temp_dir, 'test_one_channel.set')
io.savemat(one_chan_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 1, 'data': np.random.random((1, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': {'labels': 'E1', 'Y': -6.6069,
'X': 6.3023, 'Z': -2.9423},
'times': eeg.times[:3], 'pnts': 3}})
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# no warning for 'no events found'
assert_equal(len(w), 0)
# test reading file with 3 channels - one without position information
# first, create chanlocs structured array
ch_names = ['F3', 'unknown', 'FPz']
x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan]
dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')]
chanlocs = np.zeros((3,), dtype=dt)
for ind, vals in enumerate(zip(ch_names, x, y, z)):
for fld in range(4):
chanlocs[ind][dt[fld][0]] = vals[fld]
if LooseVersion(np.__version__) == '1.14.0':
# There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes
# this write to fail!
raise SkipTest('Need to fix bug in NumPy 1.14.0!')
# save set file
one_chanpos_fname = op.join(temp_dir, 'test_chanpos.set')
io.savemat(one_chanpos_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 3, 'data': np.random.random((3, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3}})
# load it
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
# one warning because some channels are not found in Montage
assert_equal(len(w), 1)
# position should be present for first two channels
for i in range(2):
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([-chanlocs[i]['Y'],
chanlocs[i]['X'],
chanlocs[i]['Z']]))
# position of the last channel should be zero
assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3)
# test reading channel names from set and positions from montage
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True,
montage=montage)
# one warning because some channels are not found in Montage
assert_equal(len(w), 1)
# when montage was passed - channel positions should be taken from there
correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3,
[0., 0.99977915, -0.02101571]]
for ch_ind in range(3):
assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3],
np.array(correct_pos[ch_ind]))
# test reading channel names but not positions when there is no X (only Z)
# field in the EEG.chanlocs structure
nopos_chanlocs = chanlocs[['labels', 'Z']]
nopos_fname = op.join(temp_dir, 'test_no_chanpos.set')
io.savemat(nopos_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3,
'data': np.random.random((3, 2)), 'epoch': eeg.epoch,
'event': eeg.epoch, 'chanlocs': nopos_chanlocs,
'times': eeg.times[:2], 'pnts': 2}})
# load the file
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
raw = read_raw_eeglab(input_fname=nopos_fname, preload=True)
# test that channel names have been loaded but not channel positions
for i in range(3):
assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i])
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([0., 0., 0.]))
def test_io_set_raw(fnames, tmpdir):
"""Test importing EEGLAB .set files."""
tmpdir = str(tmpdir)
raw_fname, raw_fname_onefile = fnames
with pytest.warns(RuntimeWarning) as w:
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname,
montage=montage)
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile,
montage=montage)
for want in ('Events like', 'consist entirely', 'could not be mapped',
'string preload is not supported'):
assert (any(want in str(ww.message) for ww in w))
with pytest.warns(RuntimeWarning) as w:
# test finding events in continuous data
event_id = {'rt': 1, 'square': 2}
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=True)
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False)
raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage,
event_id=event_id)
raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id)
raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
[w.pop(DeprecationWarning) for _ in range(5)] # read_events_eeglab
assert raw0.filenames[0].endswith('.fdt') # .set with additional .fdt
assert raw2.filenames[0].endswith('.set') # standalone .set
Epochs(raw0, find_events(raw0), event_id)
epochs = Epochs(raw1, find_events(raw1), event_id)
assert len(find_events(raw4)) == 0 # no events without event_id
assert epochs["square"].average().nave == 80 # 80 with
assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0])
assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1])
# 1 for preload=False / str with fname_onefile, 3 for dropped events
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero') # test that preloading works
while 'FutureWarning' in [xx._category_name for xx in w]:
w.pop(FutureWarning)
while 'ImportWarning' in [xx._category_name for xx in w]:
w.pop(ImportWarning)
assert len(w) == 4 # check `preload=False` raises RuntimeWarning
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False,
uint16_codec='ascii')
# test old EEGLAB version event import (read old version)
eeg = io.loadmat(raw_fname_mat, struct_as_record=False,
squeeze_me=True)['EEG']
for event in eeg.event: # old version allows integer events
event.type = 1
assert_equal(read_events_eeglab(eeg)[-1, -1], 1)
eeg.event = eeg.event[0] # single event
eeg.event.latency = float(eeg.event.latency) - .1 # test rounding
assert_equal(read_events_eeglab(eeg)[-1, -1], 1)
# test reading file with one event (read old version)
eeg = io.loadmat(raw_fname_mat, struct_as_record=False,
squeeze_me=True)['EEG']
one_event_fname = op.join(tmpdir, 'test_one_event.set')
io.savemat(one_event_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt',
'epoch': eeg.epoch, 'event': eeg.event[0],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
one_event_fname.replace('.set', '.fdt'))
event_id = {eeg.event[0].type: 1}
test_raw = read_raw_eeglab(input_fname=one_event_fname, montage=montage,
event_id=event_id, preload=True)
# test that sample indices are read python-wise (zero-based)
assert find_events(test_raw)[0, 0] == round(eeg.event[0].latency) - 1
# test negative event latencies
negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set')
evnts = deepcopy(eeg.event[0])
evnts.latency = 0
io.savemat(negative_latency_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt',
'epoch': eeg.epoch, 'event': evnts,
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
negative_latency_fname.replace('.set', '.fdt'))
event_id = {eeg.event[0].type: 1}
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname, preload=True,
event_id=event_id, montage=montage)
# test overlapping events
overlap_fname = op.join(tmpdir, 'test_overlap_event.set')
io.savemat(overlap_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt',
'epoch': eeg.epoch, 'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
overlap_fname.replace('.set', '.fdt'))
event_id = {'rt': 1, 'square': 2}
with pytest.warns(RuntimeWarning, match='will be dropped'):
raw = read_raw_eeglab(input_fname=overlap_fname,
montage=montage, event_id=event_id,
preload=True)
events_stimchan = find_events(raw)
events_read_events_eeglab = read_events_eeglab(overlap_fname, event_id)
assert (len(events_stimchan) == 1)
assert (len(events_read_events_eeglab) == 2)
# test reading file with one channel
one_chan_fname = op.join(tmpdir, 'test_one_channel.set')
io.savemat(one_chan_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 1, 'data': np.random.random((1, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': {'labels': 'E1', 'Y': -6.6069,
'X': 6.3023, 'Z': -2.9423},
'times': eeg.times[:3], 'pnts': 3}},
appendmat=False, oned_as='row')
with pytest.warns(None) as w:
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# no warning for 'no events found'
w.pop(DeprecationWarning)
assert len(w) == 0
# test reading file with 3 channels - one without position information
# first, create chanlocs structured array
ch_names = ['F3', 'unknown', 'FPz']
x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan]
dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')]
chanlocs = np.zeros((3,), dtype=dt)
for ind, vals in enumerate(zip(ch_names, x, y, z)):
for fld in range(4):
chanlocs[ind][dt[fld][0]] = vals[fld]
if LooseVersion(np.__version__) == '1.14.0':
# There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes
# this write to fail!
raise SkipTest('Need to fix bug in NumPy 1.14.0!')
# save set file
one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set')
io.savemat(one_chanpos_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 3, 'data': np.random.random((3, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': chanlocs, 'times': eeg.times[:3], 'pnts': 3}},
appendmat=False, oned_as='row')
# load it
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
# position should be present for first two channels
for i in range(2):
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([-chanlocs[i]['Y'],
chanlocs[i]['X'],
chanlocs[i]['Z']]))
# position of the last channel should be zero
assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3)
# test reading channel names from set and positions from montage
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True,
montage=montage)
# when montage was passed - channel positions should be taken from there
correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3,
[0., 0.99977915, -0.02101571]]
for ch_ind in range(3):
assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3],
np.array(correct_pos[ch_ind]))
# test reading channel names but not positions when there is no X (only Z)
# field in the EEG.chanlocs structure
nopos_chanlocs = chanlocs[['labels', 'Z']]
nopos_fname = op.join(tmpdir, 'test_no_chanpos.set')
io.savemat(nopos_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3,
'data': np.random.random((3, 2)), 'epoch': eeg.epoch,
'event': eeg.epoch, 'chanlocs': nopos_chanlocs,
'times': eeg.times[:2], 'pnts': 2}},
appendmat=False, oned_as='row')
# load the file
raw = read_raw_eeglab(input_fname=nopos_fname, preload=True)
# test that channel names have been loaded but not channel positions
for i in range(3):
assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i])
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([np.nan, np.nan, np.nan]))
def test_io_set_raw(fnames, tmpdir):
"""Test importing EEGLAB .set files."""
tmpdir = str(tmpdir)
raw_fname, raw_fname_onefile = fnames
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage)
# test that preloading works
raw0 = read_raw_eeglab(input_fname=raw_fname,
montage=montage,
preload=True)
raw0.filter(1,
None,
l_trans_bandwidth='auto',
filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=raw_fname,
montage=montage,
preload=False,
uint16_codec='ascii')
# test reading file with one event (read old version)
eeg = io.loadmat(raw_fname_mat, struct_as_record=False,
squeeze_me=True)['EEG']
# test negative event latencies
negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set')
evnts = deepcopy(eeg.event[0])
evnts.latency = 0
io.savemat(negative_latency_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch,
'event': evnts,
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
negative_latency_fname.replace('.set', '.fdt'))
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname,
preload=True,
montage=montage)
evnts.latency = -1
io.savemat(negative_latency_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch,
'event': evnts,
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
with pytest.raises(ValueError, match='event sample index is negative'):
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname,
preload=True,
montage=montage)
# test overlapping events
overlap_fname = op.join(tmpdir, 'test_overlap_event.set')
io.savemat(overlap_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_overlap_event.fdt',
'epoch': eeg.epoch,
'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
overlap_fname.replace('.set', '.fdt'))
# test reading file with one channel
one_chan_fname = op.join(tmpdir, 'test_one_channel.set')
io.savemat(one_chan_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': 1,
'data': np.random.random((1, 3)),
'epoch': eeg.epoch,
'event': eeg.epoch,
'chanlocs': {
'labels': 'E1',
'Y': -6.6069,
'X': 6.3023,
'Z': -2.9423
},
'times': eeg.times[:3],
'pnts': 3
}
},
appendmat=False,
oned_as='row')
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# test reading file with 3 channels - one without position information
# first, create chanlocs structured array
ch_names = ['F3', 'unknown', 'FPz']
x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan]
dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')]
nopos_dt = [('labels', 'S10'), ('Z', 'f8')]
chanlocs = np.zeros((3, ), dtype=dt)
nopos_chanlocs = np.zeros((3, ), dtype=nopos_dt)
for ind, vals in enumerate(zip(ch_names, x, y, z)):
for fld in range(4):
chanlocs[ind][dt[fld][0]] = vals[fld]
if fld in (0, 3):
nopos_chanlocs[ind][dt[fld][0]] = vals[fld]
# In theory this should work and be simpler, but there is an obscure
# SciPy writing bug that pops up sometimes:
# nopos_chanlocs = np.array(chanlocs[['labels', 'Z']])
if LooseVersion(np.__version__) == '1.14.0':
# There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes
# this write to fail!
raise SkipTest('Need to fix bug in NumPy 1.14.0!')
# save set file
one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set')
io.savemat(one_chanpos_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': 3,
'data': np.random.random((3, 3)),
'epoch': eeg.epoch,
'event': eeg.epoch,
'chanlocs': chanlocs,
'times': eeg.times[:3],
'pnts': 3
}
},
appendmat=False,
oned_as='row')
# load it
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
# position should be present for first two channels
for i in range(2):
assert_array_equal(
raw.info['chs'][i]['loc'][:3],
np.array([-chanlocs[i]['Y'], chanlocs[i]['X'], chanlocs[i]['Z']]))
# position of the last channel should be zero
assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3)
# test reading channel names from set and positions from montage
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname,
preload=True,
montage=montage)
# when montage was passed - channel positions should be taken from there
correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3,
[0., 0.99977915, -0.02101571]]
for ch_ind in range(3):
assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3],
np.array(correct_pos[ch_ind]))
# test reading channel names but not positions when there is no X (only Z)
# field in the EEG.chanlocs structure
nopos_fname = op.join(tmpdir, 'test_no_chanpos.set')
io.savemat(nopos_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': 3,
'data': np.random.random((3, 2)),
'epoch': eeg.epoch,
'event': eeg.epoch,
'chanlocs': nopos_chanlocs,
'times': eeg.times[:2],
'pnts': 2
}
},
appendmat=False,
oned_as='row')
# load the file
raw = read_raw_eeglab(input_fname=nopos_fname, preload=True)
# test that channel names have been loaded but not channel positions
for i in range(3):
assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i])
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([np.nan, np.nan, np.nan]))
def test_io_set():
"""Test importing EEGLAB .set files"""
from scipy import io
with warnings.catch_warnings(record=True) as w1:
warnings.simplefilter('always')
# main tests, and test missing event_id
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname,
montage=montage)
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile,
montage=montage)
assert_equal(len(w1), 20)
# f3 or preload_false and a lot for dropping events
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
# test finding events in continuous data
event_id = {'rt': 1, 'square': 2}
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=True)
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False)
raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage,
event_id=event_id)
raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id)
raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
Epochs(raw0, find_events(raw0), event_id)
epochs = Epochs(raw1, find_events(raw1), event_id)
assert_equal(len(find_events(raw4)), 0) # no events without event_id
assert_equal(epochs["square"].average().nave, 80) # 80 with
assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0])
assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1])
assert_equal(len(w), 4)
# 1 for preload=False / str with fname_onefile, 3 for dropped events
raw0.filter(1, None) # test that preloading works
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = read_epochs_eeglab(epochs_fname)
epochs2 = read_epochs_eeglab(epochs_fname_onefile)
# 3 warnings for each read_epochs_eeglab because there are 3 epochs
# associated with multiple events
assert_equal(len(w), 6)
assert_array_equal(epochs.get_data(), epochs2.get_data())
# test different combinations of events and event_ids
temp_dir = _TempDir()
out_fname = op.join(temp_dir, 'test-eve.fif')
write_events(out_fname, epochs.events)
event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3}
epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id)
epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
None, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
epochs.events, None)
# test reading file with one event
eeg = io.loadmat(raw_fname, struct_as_record=False,
squeeze_me=True)['EEG']
one_event_fname = op.join(temp_dir, 'test_one_event.set')
io.savemat(one_event_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt',
'epoch': eeg.epoch, 'event': eeg.event[0],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}})
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
op.join(temp_dir, 'test_one_event.fdt'))
event_id = {eeg.event[0].type: 1}
read_raw_eeglab(input_fname=one_event_fname, montage=montage,
event_id=event_id, preload=True)
# test if .dat file raises an error
eeg = io.loadmat(epochs_fname, struct_as_record=False,
squeeze_me=True)['EEG']
eeg.data = 'epochs_fname.dat'
bad_epochs_fname = op.join(temp_dir, 'test_epochs.set')
io.savemat(bad_epochs_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': eeg.data,
'epoch': eeg.epoch, 'event': eeg.event,
'chanlocs': eeg.chanlocs}})
shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'),
op.join(temp_dir, 'test_epochs.dat'))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert_raises(NotImplementedError, read_epochs_eeglab,
bad_epochs_fname)
assert_equal(len(w), 3)
def mne_switch(file, ext, downsample, preload=True, **kwargs):
"""Read sleep datasets using mne.io.
Parameters
----------
file : string
Filename (without extension).
ext : string
File extension (e.g. '.edf'').
preload : bool | True
Preload data in memory.
kwargs : dict | {}
Further arguments to pass to the mne.io.read function.
Returns
-------
sf : float
The original sampling-frequency.
downsample : float
The down-sampling frequency used.
dsf : int
The down-sampling factor.
data : array_like
The raw data of shape (n_channels, n_points)
channels : list
List of channel names.
n : int
Number of time points before down-sampling.
start_time : datetime.time
The time offset.
"""
from mne import io
# Get full path :
path = file + ext
# Preload :
if preload is False:
preload = 'temp.dat'
kwargs['preload'] = preload
if ext.lower() in ['.edf', '.bdf', '.gdf']: # EDF / BDF / GDF
raw = io.read_raw_edf(path, **kwargs)
elif ext.lower == '.set': # EEGLAB
raw = io.read_raw_eeglab(path, **kwargs)
elif ext.lower() in ['.egi', '.mff']: # EGI / MFF
raw = io.read_raw_egi(path, **kwargs)
elif ext.lower() == '.cnt': # CNT
raw = io.read_raw_cnt(path, **kwargs)
elif ext.lower() == '.vhdr': # BrainVision
raw = io.read_raw_brainvision(path, **kwargs)
else:
raise IOError("File not supported by mne-python.")
raw.pick_types(meg=True, eeg=True, ecg=True, emg=True) # Remove stim lines
sf = raw.info['sfreq']
dsf, downsample = get_dsf(downsample, sf)
channels = raw.info['ch_names']
data = raw._data
# Conversion Volt (MNE) to microVolt (Visbrain):
if raw._raw_extras[0] is not None and 'units' in raw._raw_extras[0]:
units = raw._raw_extras[0]['units'][0:data.shape[0]]
data /= np.array(units).reshape(-1, 1)
n = data.shape[1]
start_time = datetime.time(0, 0, 0) # raw.info['meas_date']
anot = raw.annotations
return sf, downsample, dsf, data[:, ::dsf], channels, n, start_time, anot
def test_io_set_raw(fnames, tmpdir):
"""Test importing EEGLAB .set files."""
tmpdir = str(tmpdir)
raw_fname, raw_fname_onefile = fnames
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname,
montage=montage)
# test that preloading works
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
preload=True)
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero')
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
preload=False, uint16_codec='ascii')
# test reading file with one event (read old version)
eeg = io.loadmat(raw_fname_mat, struct_as_record=False,
squeeze_me=True)['EEG']
# test negative event latencies
negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set')
evnts = deepcopy(eeg.event[0])
evnts.latency = 0
io.savemat(negative_latency_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch, 'event': evnts,
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
negative_latency_fname.replace('.set', '.fdt'))
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname, preload=True,
montage=montage)
evnts.latency = -1
io.savemat(negative_latency_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch, 'event': evnts,
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
with pytest.raises(ValueError, match='event sample index is negative'):
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname, preload=True,
montage=montage)
# test overlapping events
overlap_fname = op.join(tmpdir, 'test_overlap_event.set')
io.savemat(overlap_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_overlap_event.fdt',
'epoch': eeg.epoch,
'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}},
appendmat=False, oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
overlap_fname.replace('.set', '.fdt'))
# test reading file with one channel
one_chan_fname = op.join(tmpdir, 'test_one_channel.set')
io.savemat(one_chan_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 1, 'data': np.random.random((1, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': {'labels': 'E1', 'Y': -6.6069,
'X': 6.3023, 'Z': -2.9423},
'times': eeg.times[:3], 'pnts': 3}},
appendmat=False, oned_as='row')
with pytest.warns(None) as w:
read_raw_eeglab(input_fname=one_chan_fname, preload=True,
stim_channel=False)
# no warning for 'no events found'
assert len(w) == 0
# test reading file with 3 channels - one without position information
# first, create chanlocs structured array
ch_names = ['F3', 'unknown', 'FPz']
x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan]
dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')]
nopos_dt = [('labels', 'S10'), ('Z', 'f8')]
chanlocs = np.zeros((3,), dtype=dt)
nopos_chanlocs = np.zeros((3,), dtype=nopos_dt)
for ind, vals in enumerate(zip(ch_names, x, y, z)):
for fld in range(4):
chanlocs[ind][dt[fld][0]] = vals[fld]
if fld in (0, 3):
nopos_chanlocs[ind][dt[fld][0]] = vals[fld]
# In theory this should work and be simpler, but there is an obscure
# SciPy writing bug that pops up sometimes:
# nopos_chanlocs = np.array(chanlocs[['labels', 'Z']])
if LooseVersion(np.__version__) == '1.14.0':
# There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes
# this write to fail!
raise SkipTest('Need to fix bug in NumPy 1.14.0!')
# save set file
one_chanpos_fname = op.join(tmpdir, 'test_chanpos.set')
io.savemat(one_chanpos_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 3, 'data': np.random.random((3, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': chanlocs, 'times': eeg.times[:3],
'pnts': 3}},
appendmat=False, oned_as='row')
# load it
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True)
# position should be present for first two channels
for i in range(2):
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([-chanlocs[i]['Y'],
chanlocs[i]['X'],
chanlocs[i]['Z']]))
# position of the last channel should be zero
assert_array_equal(raw.info['chs'][-1]['loc'][:3], [np.nan] * 3)
# test reading channel names from set and positions from montage
with pytest.warns(RuntimeWarning, match='did not have a position'):
raw = read_raw_eeglab(input_fname=one_chanpos_fname, preload=True,
montage=montage)
# when montage was passed - channel positions should be taken from there
correct_pos = [[-0.56705965, 0.67706631, 0.46906776], [np.nan] * 3,
[0., 0.99977915, -0.02101571]]
for ch_ind in range(3):
assert_array_almost_equal(raw.info['chs'][ch_ind]['loc'][:3],
np.array(correct_pos[ch_ind]))
# test reading channel names but not positions when there is no X (only Z)
# field in the EEG.chanlocs structure
nopos_fname = op.join(tmpdir, 'test_no_chanpos.set')
io.savemat(nopos_fname,
{'EEG': {'trials': eeg.trials, 'srate': eeg.srate, 'nbchan': 3,
'data': np.random.random((3, 2)), 'epoch': eeg.epoch,
'event': eeg.epoch, 'chanlocs': nopos_chanlocs,
'times': eeg.times[:2], 'pnts': 2}},
appendmat=False, oned_as='row')
# load the file
raw = read_raw_eeglab(input_fname=nopos_fname, preload=True,
stim_channel=False)
# test that channel names have been loaded but not channel positions
for i in range(3):
assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i])
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([np.nan, np.nan, np.nan]))
def test_io_set():
"""Test importing EEGLAB .set files"""
from scipy import io
with warnings.catch_warnings(record=True) as w1:
warnings.simplefilter('always')
# main tests, and test missing event_id
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname,
montage=montage)
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile,
montage=montage)
assert_equal(len(w1), 20)
# f3 or preload_false and a lot for dropping events
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
# test finding events in continuous data
event_id = {'rt': 1, 'square': 2}
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=True)
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False)
raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage,
event_id=event_id)
raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id)
raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
Epochs(raw0, find_events(raw0), event_id)
epochs = Epochs(raw1, find_events(raw1), event_id)
assert_equal(len(find_events(raw4)), 0) # no events without event_id
assert_equal(epochs["square"].average().nave, 80) # 80 with
assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0])
assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1])
assert_equal(len(w), 4)
# 1 for preload=False / str with fname_onefile, 3 for dropped events
raw0.filter(1, None, l_trans_bandwidth='auto', filter_length='auto',
phase='zero') # test that preloading works
# test that using uin16_codec does not break stuff
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage,
event_id=event_id, preload=False,
uint16_codec='ascii')
# test old EEGLAB version event import
eeg = io.loadmat(raw_fname, struct_as_record=False,
squeeze_me=True)['EEG']
for event in eeg.event: # old version allows integer events
event.type = 1
assert_equal(_read_eeglab_events(eeg)[-1, -1], 1)
eeg.event = eeg.event[0] # single event
assert_equal(_read_eeglab_events(eeg)[-1, -1], 1)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
epochs = read_epochs_eeglab(epochs_fname)
epochs2 = read_epochs_eeglab(epochs_fname_onefile)
# one warning for each read_epochs_eeglab because both files have epochs
# associated with multiple events
assert_equal(len(w), 2)
assert_array_equal(epochs.get_data(), epochs2.get_data())
# test different combinations of events and event_ids
temp_dir = _TempDir()
out_fname = op.join(temp_dir, 'test-eve.fif')
write_events(out_fname, epochs.events)
event_id = {'S255/S8': 1, 'S8': 2, 'S255/S9': 3}
epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id)
assert_equal(len(epochs.events), 4)
epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
None, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname,
epochs.events, None)
# test reading file with one event
eeg = io.loadmat(raw_fname, struct_as_record=False,
squeeze_me=True)['EEG']
one_event_fname = op.join(temp_dir, 'test_one_event.set')
io.savemat(one_event_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': 'test_one_event.fdt',
'epoch': eeg.epoch, 'event': eeg.event[0],
'chanlocs': eeg.chanlocs, 'pnts': eeg.pnts}})
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
op.join(temp_dir, 'test_one_event.fdt'))
event_id = {eeg.event[0].type: 1}
read_raw_eeglab(input_fname=one_event_fname, montage=montage,
event_id=event_id, preload=True)
# test reading file with one channel
one_chan_fname = op.join(temp_dir, 'test_one_channel.set')
io.savemat(one_chan_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': 1, 'data': np.random.random((1, 3)),
'epoch': eeg.epoch, 'event': eeg.epoch,
'chanlocs': {'labels': 'E1', 'Y': -6.6069,
'X': 6.3023, 'Z': -2.9423},
'times': eeg.times[:3], 'pnts': 3}})
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# no warning for 'no events found'
assert_equal(len(w), 0)
# test if .dat file raises an error
eeg = io.loadmat(epochs_fname, struct_as_record=False,
squeeze_me=True)['EEG']
eeg.data = 'epochs_fname.dat'
bad_epochs_fname = op.join(temp_dir, 'test_epochs.set')
io.savemat(bad_epochs_fname, {'EEG':
{'trials': eeg.trials, 'srate': eeg.srate,
'nbchan': eeg.nbchan, 'data': eeg.data,
'epoch': eeg.epoch, 'event': eeg.event,
'chanlocs': eeg.chanlocs}})
shutil.copyfile(op.join(base_dir, 'test_epochs.fdt'),
op.join(temp_dir, 'test_epochs.dat'))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert_raises(NotImplementedError, read_epochs_eeglab,
bad_epochs_fname)
assert_equal(len(w), 1)
def test_io_set_raw_more(tmpdir):
"""Test importing EEGLAB .set files."""
tmpdir = str(tmpdir)
eeg = io.loadmat(raw_fname_mat, struct_as_record=False,
squeeze_me=True)['EEG']
# test reading file with one event (read old version)
negative_latency_fname = op.join(tmpdir, 'test_negative_latency.set')
evnts = deepcopy(eeg.event[0])
evnts.latency = 0
io.savemat(negative_latency_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch,
'event': evnts,
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
negative_latency_fname.replace('.set', '.fdt'))
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname, preload=True)
# test negative event latencies
evnts.latency = -1
io.savemat(negative_latency_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_negative_latency.fdt',
'epoch': eeg.epoch,
'event': evnts,
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
with pytest.raises(ValueError, match='event sample index is negative'):
with pytest.warns(RuntimeWarning, match="has a sample index of -1."):
read_raw_eeglab(input_fname=negative_latency_fname, preload=True)
# test overlapping events
overlap_fname = op.join(tmpdir, 'test_overlap_event.set')
io.savemat(overlap_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_overlap_event.fdt',
'epoch': eeg.epoch,
'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
shutil.copyfile(op.join(base_dir, 'test_raw.fdt'),
overlap_fname.replace('.set', '.fdt'))
read_raw_eeglab(input_fname=overlap_fname, preload=True)
# test reading file when the EEG.data name is wrong
io.savemat(overlap_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_overla_event.fdt',
'epoch': eeg.epoch,
'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
with pytest.warns(RuntimeWarning, match="must have changed on disk"):
read_raw_eeglab(input_fname=overlap_fname, preload=True)
# raise error when both EEG.data and fdt name from set are wrong
overlap_fname = op.join(tmpdir, 'test_ovrlap_event.set')
io.savemat(overlap_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': eeg.nbchan,
'data': 'test_overla_event.fdt',
'epoch': eeg.epoch,
'event': [eeg.event[0], eeg.event[0]],
'chanlocs': eeg.chanlocs,
'pnts': eeg.pnts
}
},
appendmat=False,
oned_as='row')
with pytest.raises(FileNotFoundError, match="not find the .fdt data file"):
read_raw_eeglab(input_fname=overlap_fname, preload=True)
# test reading file with one channel
one_chan_fname = op.join(tmpdir, 'test_one_channel.set')
io.savemat(one_chan_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': 1,
'data': np.random.random((1, 3)),
'epoch': eeg.epoch,
'event': eeg.epoch,
'chanlocs': {
'labels': 'E1',
'Y': -6.6069,
'X': 6.3023,
'Z': -2.9423
},
'times': eeg.times[:3],
'pnts': 3
}
},
appendmat=False,
oned_as='row')
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# test reading file with 3 channels - one without position information
# first, create chanlocs structured array
ch_names = ['F3', 'unknown', 'FPz']
x, y, z = [1., 2., np.nan], [4., 5., np.nan], [7., 8., np.nan]
dt = [('labels', 'S10'), ('X', 'f8'), ('Y', 'f8'), ('Z', 'f8')]
nopos_dt = [('labels', 'S10'), ('Z', 'f8')]
chanlocs = np.zeros((3, ), dtype=dt)
nopos_chanlocs = np.zeros((3, ), dtype=nopos_dt)
for ind, vals in enumerate(zip(ch_names, x, y, z)):
for fld in range(4):
chanlocs[ind][dt[fld][0]] = vals[fld]
if fld in (0, 3):
nopos_chanlocs[ind][dt[fld][0]] = vals[fld]
# In theory this should work and be simpler, but there is an obscure
# SciPy writing bug that pops up sometimes:
# nopos_chanlocs = np.array(chanlocs[['labels', 'Z']])
if LooseVersion(np.__version__) == '1.14.0':
# There is a bug in 1.14.0 (or maybe with SciPy 1.0.0?) that causes
# this write to fail!
raise SkipTest('Need to fix bug in NumPy 1.14.0!')
# test reading channel names but not positions when there is no X (only Z)
# field in the EEG.chanlocs structure
nopos_fname = op.join(tmpdir, 'test_no_chanpos.set')
io.savemat(nopos_fname, {
'EEG': {
'trials': eeg.trials,
'srate': eeg.srate,
'nbchan': 3,
'data': np.random.random((3, 2)),
'epoch': eeg.epoch,
'event': eeg.epoch,
'chanlocs': nopos_chanlocs,
'times': eeg.times[:2],
'pnts': 2
}
},
appendmat=False,
oned_as='row')
# load the file
raw = read_raw_eeglab(input_fname=nopos_fname, preload=True)
# test that channel names have been loaded but not channel positions
for i in range(3):
assert_equal(raw.info['chs'][i]['ch_name'], ch_names[i])
assert_array_equal(raw.info['chs'][i]['loc'][:3],
np.array([np.nan, np.nan, np.nan]))
def test_io_set():
"""Test importing EEGLAB .set files"""
from scipy import io
with warnings.catch_warnings(record=True) as w1:
warnings.simplefilter("always")
# main tests, and test missing event_id
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname, montage=montage)
_test_raw_reader(read_raw_eeglab, input_fname=raw_fname_onefile, montage=montage)
assert_equal(len(w1), 20)
# f3 or preload_false and a lot for dropping events
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
# test finding events in continuous data
event_id = {"rt": 1, "square": 2}
raw0 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=True)
raw1 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id, preload=False)
raw2 = read_raw_eeglab(input_fname=raw_fname_onefile, montage=montage, event_id=event_id)
raw3 = read_raw_eeglab(input_fname=raw_fname, montage=montage, event_id=event_id)
raw4 = read_raw_eeglab(input_fname=raw_fname, montage=montage)
Epochs(raw0, find_events(raw0), event_id)
epochs = Epochs(raw1, find_events(raw1), event_id)
assert_equal(len(find_events(raw4)), 0) # no events without event_id
assert_equal(epochs["square"].average().nave, 80) # 80 with
assert_array_equal(raw0[:][0], raw1[:][0], raw2[:][0], raw3[:][0])
assert_array_equal(raw0[:][-1], raw1[:][-1], raw2[:][-1], raw3[:][-1])
assert_equal(len(w), 4)
# 1 for preload=False / str with fname_onefile, 3 for dropped events
raw0.filter(1, None, l_trans_bandwidth="auto", filter_length="auto", phase="zero") # test that preloading works
# test that using uint16_codec does not break stuff
raw0 = read_raw_eeglab(
input_fname=raw_fname, montage=montage, event_id=event_id, preload=False, uint16_codec="ascii"
)
# test old EEGLAB version event import
eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)["EEG"]
for event in eeg.event: # old version allows integer events
event.type = 1
assert_equal(_read_eeglab_events(eeg)[-1, -1], 1)
eeg.event = eeg.event[0] # single event
assert_equal(_read_eeglab_events(eeg)[-1, -1], 1)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
epochs = read_epochs_eeglab(epochs_fname)
epochs2 = read_epochs_eeglab(epochs_fname_onefile)
# one warning for each read_epochs_eeglab because both files have epochs
# associated with multiple events
assert_equal(len(w), 2)
assert_array_equal(epochs.get_data(), epochs2.get_data())
# test different combinations of events and event_ids
temp_dir = _TempDir()
out_fname = op.join(temp_dir, "test-eve.fif")
write_events(out_fname, epochs.events)
event_id = {"S255/S8": 1, "S8": 2, "S255/S9": 3}
epochs = read_epochs_eeglab(epochs_fname, epochs.events, event_id)
assert_equal(len(epochs.events), 4)
assert_true(epochs.preload)
assert_true(epochs._bad_dropped)
epochs = read_epochs_eeglab(epochs_fname, out_fname, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname, None, event_id)
assert_raises(ValueError, read_epochs_eeglab, epochs_fname, epochs.events, None)
# test reading file with one event
eeg = io.loadmat(raw_fname, struct_as_record=False, squeeze_me=True)["EEG"]
one_event_fname = op.join(temp_dir, "test_one_event.set")
io.savemat(
one_event_fname,
{
"EEG": {
"trials": eeg.trials,
"srate": eeg.srate,
"nbchan": eeg.nbchan,
"data": "test_one_event.fdt",
"epoch": eeg.epoch,
"event": eeg.event[0],
"chanlocs": eeg.chanlocs,
"pnts": eeg.pnts,
}
},
)
shutil.copyfile(op.join(base_dir, "test_raw.fdt"), op.join(temp_dir, "test_one_event.fdt"))
event_id = {eeg.event[0].type: 1}
read_raw_eeglab(input_fname=one_event_fname, montage=montage, event_id=event_id, preload=True)
# test reading file with one channel
one_chan_fname = op.join(temp_dir, "test_one_channel.set")
io.savemat(
one_chan_fname,
{
"EEG": {
"trials": eeg.trials,
"srate": eeg.srate,
"nbchan": 1,
"data": np.random.random((1, 3)),
"epoch": eeg.epoch,
"event": eeg.epoch,
"chanlocs": {"labels": "E1", "Y": -6.6069, "X": 6.3023, "Z": -2.9423},
"times": eeg.times[:3],
"pnts": 3,
}
},
)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
read_raw_eeglab(input_fname=one_chan_fname, preload=True)
# no warning for 'no events found'
assert_equal(len(w), 0)
# test if .dat file raises an error
eeg = io.loadmat(epochs_fname, struct_as_record=False, squeeze_me=True)["EEG"]
eeg.data = "epochs_fname.dat"
bad_epochs_fname = op.join(temp_dir, "test_epochs.set")
io.savemat(
bad_epochs_fname,
{
"EEG": {
"trials": eeg.trials,
"srate": eeg.srate,
"nbchan": eeg.nbchan,
"data": eeg.data,
"epoch": eeg.epoch,
"event": eeg.event,
"chanlocs": eeg.chanlocs,
}
},
)
shutil.copyfile(op.join(base_dir, "test_epochs.fdt"), op.join(temp_dir, "test_epochs.dat"))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
assert_raises(NotImplementedError, read_epochs_eeglab, bad_epochs_fname)
assert_equal(len(w), 1)
