def test_export_epochs_eeglab(tmp_path, preload):
"""Test saving an Epochs instance to EEGLAB's set format."""
raw, events = _get_data()[:2]
raw.load_data()
epochs = Epochs(raw, events, preload=preload)
temp_fname = op.join(str(tmp_path), 'test.set')
epochs.export(temp_fname)
epochs.drop_channels(
[ch for ch in ['epoc', 'STI 014'] if ch in epochs.ch_names])
epochs_read = read_epochs_eeglab(temp_fname)
assert epochs.ch_names == epochs_read.ch_names
cart_coords = np.array([d['loc'][:3]
for d in epochs.info['chs']]) # just xyz
cart_coords_read = np.array(
[d['loc'][:3] for d in epochs_read.info['chs']])
assert_allclose(cart_coords, cart_coords_read)
assert_array_equal(epochs.events[:, 0], epochs_read.events[:,
0]) # latency
assert epochs.event_id.keys() == epochs_read.event_id.keys() # just keys
assert_allclose(epochs.times, epochs_read.times)
assert_allclose(epochs.get_data(), epochs_read.get_data())
# test overwrite
with pytest.raises(FileExistsError, match='Destination file exists'):
epochs.export(temp_fname, overwrite=False)
epochs.export(temp_fname, overwrite=True)
# test pathlib.Path files
epochs.export(Path(temp_fname), overwrite=True)
def test_drop_channels_mixin():
"""Test channels-dropping functionality
"""
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0))
drop_ch = epochs.ch_names[:3]
ch_names = epochs.ch_names[3:]
epochs.drop_channels(drop_ch)
assert_equal(ch_names, epochs.ch_names)
assert_equal(len(ch_names), epochs.get_data().shape[1])
def test_equalize_channels():
"""Test equalization of channels
"""
epochs1 = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), proj=False)
epochs2 = epochs1.copy()
ch_names = epochs1.ch_names[2:]
epochs1.drop_channels(epochs1.ch_names[:1])
epochs2.drop_channels(epochs2.ch_names[1:2])
my_comparison = [epochs1, epochs2]
equalize_channels(my_comparison)
for e in my_comparison:
assert_equal(ch_names, e.ch_names)
def test_equalize_channels():
"""Test equalization of channels
"""
epochs1 = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=(None, 0), proj=False)
epochs2 = epochs1.copy()
ch_names = epochs1.ch_names[2:]
epochs1.drop_channels(epochs1.ch_names[:1])
epochs2.drop_channels(epochs2.ch_names[1:2])
my_comparison = [epochs1, epochs2]
equalize_channels(my_comparison)
for e in my_comparison:
assert_equal(ch_names, e.ch_names)
def test_plot_psd_epochs_ctf(raw_ctf):
"""Test plotting CTF epochs psd (+topomap)."""
evts = make_fixed_length_events(raw_ctf)
epochs = Epochs(raw_ctf, evts, preload=True)
pytest.raises(RuntimeError, epochs.plot_psd_topomap,
bands=[(0, 0.01, 'foo')]) # no freqs in range
epochs.plot_psd_topomap()
# EEG060 is flat in this dataset
for dB in [True, False]:
with pytest.warns(UserWarning, match='for channel EEG060'):
epochs.plot_psd(dB=dB)
epochs.drop_channels(['EEG060'])
epochs.plot_psd(spatial_colors=False, average=False)
def test_drop_channels_mixin():
"""Test channels-dropping functionality
"""
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0))
drop_ch = epochs.ch_names[:3]
ch_names = epochs.ch_names[3:]
epochs.drop_channels(drop_ch)
assert_equal(ch_names, epochs.ch_names)
assert_equal(len(ch_names), epochs.get_data().shape[1])
def get_raw_eeg_data(cls, tmin=0., tmax=4.):
for file in cls.gdf_files_names:
t_min, t_max = 0., 4.
path = cls.directory + file
raw_edf = read_raw_edf(path)
events = cls.manage_edf_events(raw=raw_edf)
picks = pick_types(raw_edf.info,
meg=False,
eeg=True,
stim=False,
eog=False,
exclude='bads')
events = cls.exclude_rejected_trials(events=events)
temp1 = Epochs(raw_edf,
events,
cls.event_id,
t_min,
t_max,
proj=True,
picks=picks,
baseline=None,
preload=True)
temp = temp1.drop_channels(
ch_names={'EOG:ch01', 'EOG:ch02', 'EOG:ch03'})
temp = temp.copy().crop(tmin=tmin.__float__(),
tmax=tmax.__float__())
keys = list(cls.event_id.keys())
indices = list(range(len(keys)))
for index, key in zip(indices, keys):
cls.data[key].append(temp.__getitem__(keys[index]).get_data())
cls.concatenate_data()
def test_drop_channels_mixin():
"""Test channels-dropping functionality
"""
# here without picks to get additional coverage
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=None, baseline=(None, 0))
drop_ch = epochs.ch_names[:3]
ch_names = epochs.ch_names[3:]
ch_names_orig = epochs.ch_names
dummy = epochs.drop_channels(drop_ch, copy=True)
assert_equal(ch_names, dummy.ch_names)
assert_equal(ch_names_orig, epochs.ch_names)
assert_equal(len(ch_names_orig), epochs.get_data().shape[1])
epochs.drop_channels(drop_ch)
assert_equal(ch_names, epochs.ch_names)
assert_equal(len(ch_names), epochs.get_data().shape[1])
def test_plot_psd_epochs_ctf():
"""Test plotting CTF epochs psd (+topomap)."""
raw = read_raw_ctf(ctf_fname, preload=True)
evts = make_fixed_length_events(raw)
epochs = Epochs(raw, evts, preload=True)
pytest.raises(RuntimeError,
epochs.plot_psd_topomap,
bands=[(0, 0.01, 'foo')]) # no freqs in range
epochs.plot_psd_topomap()
# EEG060 is flat in this dataset
err_str = r'channel\(s\) EEG060\.'
for dB in [True, False]:
with pytest.warns(UserWarning, match=err_str):
epochs.plot_psd(dB=dB)
epochs.drop_channels(['EEG060'])
epochs.plot_psd(spatial_colors=False, average=False)
plt.close('all')
def test_drop_channels_mixin():
"""Test channels-dropping functionality
"""
# here without picks to get additional coverage
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=None,
baseline=(None, 0))
drop_ch = epochs.ch_names[:3]
ch_names = epochs.ch_names[3:]
ch_names_orig = epochs.ch_names
dummy = epochs.drop_channels(drop_ch, copy=True)
assert_equal(ch_names, dummy.ch_names)
assert_equal(ch_names_orig, epochs.ch_names)
assert_equal(len(ch_names_orig), epochs.get_data().shape[1])
epochs.drop_channels(drop_ch)
assert_equal(ch_names, epochs.ch_names)
assert_equal(len(ch_names), epochs.get_data().shape[1])
def test_export_epochs_eeglab(tmpdir, preload):
"""Test saving an Epochs instance to EEGLAB's set format."""
raw, events = _get_data()[:2]
raw.load_data()
epochs = Epochs(raw, events, preload=preload)
temp_fname = op.join(str(tmpdir), 'test.set')
epochs.export(temp_fname)
epochs.drop_channels(
[ch for ch in ['epoc', 'STI 014'] if ch in epochs.ch_names])
epochs_read = read_epochs_eeglab(temp_fname)
assert epochs.ch_names == epochs_read.ch_names
cart_coords = np.array([d['loc'][:3]
for d in epochs.info['chs']]) # just xyz
cart_coords_read = np.array(
[d['loc'][:3] for d in epochs_read.info['chs']])
assert_allclose(cart_coords, cart_coords_read)
assert_array_equal(epochs.events[:, 0], epochs_read.events[:,
0]) # latency
assert epochs.event_id.keys() == epochs_read.event_id.keys() # just keys
assert_allclose(epochs.times, epochs_read.times)
assert_allclose(epochs.get_data(), epochs_read.get_data())
def test_read_write_epochs():
"""Test epochs from raw files with IO as fif file
"""
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0))
evoked = epochs.average()
data = epochs.get_data()
epochs_no_id = Epochs(raw, pick_events(events, include=event_id), None, tmin, tmax, picks=picks, baseline=(None, 0))
assert_array_equal(data, epochs_no_id.get_data())
eog_picks = pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True, exclude="bads")
eog_ch_names = [raw.ch_names[k] for k in eog_picks]
epochs.drop_channels(eog_ch_names)
assert_true(len(epochs.info["chs"]) == len(epochs.ch_names) == epochs.get_data().shape[1])
data_no_eog = epochs.get_data()
assert_true(data.shape[1] == (data_no_eog.shape[1] + len(eog_picks)))
# test decim kwarg
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
epochs_dec = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), decim=4)
assert_equal(len(w), 1)
data_dec = epochs_dec.get_data()
assert_array_equal(data[:, :, epochs_dec._decim_idx], data_dec)
evoked_dec = epochs_dec.average()
assert_array_equal(evoked.data[:, epochs_dec._decim_idx], evoked_dec.data)
n = evoked.data.shape[1]
n_dec = evoked_dec.data.shape[1]
n_dec_min = n // 4
assert_true(n_dec_min <= n_dec <= n_dec_min + 1)
assert_true(evoked_dec.info["sfreq"] == evoked.info["sfreq"] / 4)
# test IO
epochs.save(op.join(tempdir, "test-epo.fif"))
epochs_read = read_epochs(op.join(tempdir, "test-epo.fif"))
assert_array_almost_equal(epochs_read.get_data(), epochs.get_data())
assert_array_equal(epochs_read.times, epochs.times)
assert_array_almost_equal(epochs_read.average().data, evoked.data)
assert_equal(epochs_read.proj, epochs.proj)
bmin, bmax = epochs.baseline
if bmin is None:
bmin = epochs.times[0]
if bmax is None:
bmax = epochs.times[-1]
baseline = (bmin, bmax)
assert_array_almost_equal(epochs_read.baseline, baseline)
assert_array_almost_equal(epochs_read.tmin, epochs.tmin, 2)
assert_array_almost_equal(epochs_read.tmax, epochs.tmax, 2)
assert_equal(epochs_read.event_id, epochs.event_id)
epochs.event_id.pop("1")
epochs.event_id.update({"a:a": 1}) # test allow for ':' in key
epochs.save(op.join(tempdir, "foo-epo.fif"))
epochs_read2 = read_epochs(op.join(tempdir, "foo-epo.fif"))
assert_equal(epochs_read2.event_id, epochs.event_id)
# add reject here so some of the epochs get dropped
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject)
epochs.save(op.join(tempdir, "test-epo.fif"))
# ensure bad events are not saved
epochs_read3 = read_epochs(op.join(tempdir, "test-epo.fif"))
assert_array_equal(epochs_read3.events, epochs.events)
data = epochs.get_data()
assert_true(epochs_read3.events.shape[0] == data.shape[0])
# test copying loaded one (raw property)
epochs_read4 = epochs_read3.copy()
assert_array_almost_equal(epochs_read4.get_data(), data)
# test equalizing loaded one (drop_log property)
epochs_read4.equalize_event_counts(epochs.event_id)
epochs.drop_epochs([1, 2], reason="can we recover orig ID?")
epochs.save("test-epo.fif")
epochs_read5 = read_epochs("test-epo.fif")
assert_array_equal(epochs_read5.selection, epochs.selection)
assert_array_equal(epochs_read5.drop_log, epochs.drop_log)
# Test that one can drop channels on read file
epochs_read5.drop_channels(epochs_read5.ch_names[:1])
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
epochs_badname = op.join(tempdir, "test-bad-name.fif.gz")
epochs.save(epochs_badname)
read_epochs(epochs_badname)
assert_true(len(w) == 2)
def test_read_write_epochs():
"""Test epochs from raw files with IO as fif file
"""
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0))
evoked = epochs.average()
data = epochs.get_data()
epochs_no_id = Epochs(raw,
pick_events(events, include=event_id),
None,
tmin,
tmax,
picks=picks,
baseline=(None, 0))
assert_array_equal(data, epochs_no_id.get_data())
eog_picks = fiff.pick_types(raw.info,
meg=False,
eeg=False,
stim=False,
eog=True,
exclude='bads')
eog_ch_names = [raw.ch_names[k] for k in eog_picks]
epochs.drop_channels(eog_ch_names)
assert_true(
len(epochs.info['chs']) == len(epochs.ch_names) ==
epochs.get_data().shape[1])
data_no_eog = epochs.get_data()
assert_true(data.shape[1] == (data_no_eog.shape[1] + len(eog_picks)))
# test decim kwarg
with warnings.catch_warnings(record=True) as w:
epochs_dec = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
decim=4)
assert_equal(len(w), 1)
data_dec = epochs_dec.get_data()
assert_array_equal(data[:, :, epochs_dec._decim_idx], data_dec)
evoked_dec = epochs_dec.average()
assert_array_equal(evoked.data[:, epochs_dec._decim_idx], evoked_dec.data)
n = evoked.data.shape[1]
n_dec = evoked_dec.data.shape[1]
n_dec_min = n // 4
assert_true(n_dec_min <= n_dec <= n_dec_min + 1)
assert_true(evoked_dec.info['sfreq'] == evoked.info['sfreq'] / 4)
# test IO
epochs.save(op.join(tempdir, 'test-epo.fif'))
epochs_read = read_epochs(op.join(tempdir, 'test-epo.fif'))
assert_array_almost_equal(epochs_read.get_data(), epochs.get_data())
assert_array_equal(epochs_read.times, epochs.times)
assert_array_almost_equal(epochs_read.average().data, evoked.data)
assert_equal(epochs_read.proj, epochs.proj)
bmin, bmax = epochs.baseline
if bmin is None:
bmin = epochs.times[0]
if bmax is None:
bmax = epochs.times[-1]
baseline = (bmin, bmax)
assert_array_almost_equal(epochs_read.baseline, baseline)
assert_array_almost_equal(epochs_read.tmin, epochs.tmin, 2)
assert_array_almost_equal(epochs_read.tmax, epochs.tmax, 2)
assert_equal(epochs_read.event_id, epochs.event_id)
epochs.event_id.pop('1')
epochs.event_id.update({'a:a': 1}) # test allow for ':' in key
epochs.save(op.join(tempdir, 'foo-epo.fif'))
epochs_read2 = read_epochs(op.join(tempdir, 'foo-epo.fif'))
assert_equal(epochs_read2.event_id, epochs.event_id)
# add reject here so some of the epochs get dropped
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
reject=reject)
epochs.save(op.join(tempdir, 'test-epo.fif'))
# ensure bad events are not saved
epochs_read3 = read_epochs(op.join(tempdir, 'test-epo.fif'))
assert_array_equal(epochs_read3.events, epochs.events)
data = epochs.get_data()
assert_true(epochs_read3.events.shape[0] == data.shape[0])
# test copying loaded one (raw property)
epochs_read4 = epochs_read3.copy()
assert_array_almost_equal(epochs_read4.get_data(), data)
# test equalizing loaded one (drop_log property)
epochs_read4.equalize_event_counts(epochs.event_id)
epochs.drop_epochs([1, 2], reason='can we recover orig ID?')
epochs.save('test-epo.fif')
epochs_read5 = read_epochs('test-epo.fif')
assert_array_equal(epochs_read5.selection, epochs.selection)
assert_array_equal(epochs_read5.drop_log, epochs.drop_log)
# Test that one can drop channels on read file
epochs_read5.drop_channels(epochs_read5.ch_names[:1])
# strip channel names of "." characters
raw.rename_channels(lambda x: x.strip('.'))
# Apply band-pass filter
raw.filter(7., 30., fir_design='firwin', skip_by_annotation='edge')
events = find_events(raw, shortest_event=0, stim_channel='STI 014')
picks = pick_types(raw.info, meg=False, eeg=True, stim=False, eog=False,
exclude='bads')
# Read epochs (train will be done only between 1 and 2s)
# Testing will be done with a running classifier
epochs = Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks,
baseline=None, preload=True)
epochs.drop_channels(['Fc5','Fc3','Fc1','Fcz','Fc2','Fc4','Fc6','C5','Cz','C6','Cp5','Cp3','Cp1','Cpz',
'Cp2','Cp4', 'Cp6','Fp1','Fpz','Fp2','Af7','Af3','Afz','Af4','Af8', 'F7','F5','F3', 'F1', 'Fz', 'F2',
'F4', 'F6','F8','Ft7','Ft8','T7','T8','T9','T10','Tp7','Tp8', 'P7','P5','P3','P1','Pz','P2','P4','P6',
'P8','Po7','Po3','Poz','Po4','Po8','O1','Oz','O2','Iz'])
csp = CSP(n_components=4, reg=None, log=True, norm_trace=False)
l =np.array(train_data["Left"][:-2]).swapaxes(-1,-2)
r = np.array(train_data["Right"][:-1]).swapaxes(-1,-2)
n = np.array(train_data["Rest"][1:-1]).swapaxes(-1,-2).reshape(4,8,2525)
epoch2 = np.concatenate([l2,r2,n2])
csp.fit_transform(epoch2,[1,1,1,1,1,0,0,0,0])
layout = read_layout('EEG1005')
csp.plot_patterns(epochs.info, layout=layout, ch_type='eeg',
units='Patterns (AU)', size=1.5)
subject_2 = subject + '_2'
if os.path.exists(op.join(path_data, subject_2)):
epochs_list = list()
fname1 = op.join(path_data, subject,
'epochs_%s%s_1.fif' % (event_type, suffix))
epochs = mne.read_epochs(fname1)
# Copy dev_head_t of the first session to the second session
dev_head_t = epochs.info['dev_head_t']
epochs_list.append(epochs)
fname2 = op.join(path_data, subject + '_2',
'epochs_%s%s_2.fif' % (event_type, suffix))
epochs = mne.read_epochs(fname2)
epochs.info['dev_head_t'] = dev_head_t
if subject == 'sub01_YFAALKWR_JA': # miss button 2 recordings on
# 1st session for s01
epochs.drop_channels(['UADC007-2104'])
epochs_list.append(epochs)
epochs = concatenate_epochs(epochs_list)
fname = op.join(path_data, subject,
'epochs_%s%s.fif' % (event_type, suffix))
epochs.save(fname)
# delete epoch-1 and epoch-2 to keep only the concatenate one
os.remove(fname1)
os.remove(fname2)
# concatenate behavior files
fname1 = op.join(path_data, subject, 'behavior_%s_1.hdf5' % event_type)
events1 = read_hdf5(fname1)
fname2 = op.join(path_data, subject_2,
'behavior_%s_2.hdf5' % event_type)
events2 = read_hdf5(fname2)
frames = [events1, events2]
def pow(epochs: mne.Epochs, fmin: float, fmax: float, n_fft: int,
n_per_seg: int, epochs_average: bool) -> tuple:
"""
Computes the Power Spectral Density (PSD) on Epochs.
Arguments:
epochs: A participant's Epochs object, for a condition (can result from the
concatenation of Epochs from different files with the same condition).
Epochs are MNE objects: data are stored in arrays of shape
(n_epochs, n_channels, n_times) and parameter information is stored
in a dictionary.
fmin, fmax: minimum and maximum frequencies of interest for PSD calculation,
floats in Hz.
n_fft: The length of FFT used, must be ``>= n_per_seg`` (default: 256).
The segments will be zero-padded if ``n_fft > n_per_seg``.
If n_per_seg is None, n_fft must be <= number of time points
in the data.
n_per_seg : int | None
Length of each Welch segment (windowed with a Hamming window). Defaults
to None, which sets n_per_seg equal to n_fft.
epochs_average: option to collapse the time course or not, boolean.
If False, PSD won't be averaged over epochs (the time
course is maintained).
If True, PSD values are averaged over epochs.
Note:
The function can be iterated on the group and/or on conditions
(for epochs in epochs['epochs_%s_%s_%s' % (subj, group, cond_name)]).
The PSD distribution on the group can be visualized to check normality
for statistics.
Returns:
freq_list, psd:
- freq_list: list of frequencies in the actual frequency band of interest
(frequency bin) used for PSD calculation.
- psd: PSD value for each epoch, each channel, and each frequency,
ndarray (n_epochs, n_channels, n_frequencies).
Note that if time_resolved == True, PSD values are averaged
across epochs.
"""
# dropping EOG channels (incompatible with connectivity map model in stats)
for ch in epochs.info['chs']:
if ch['kind'] == 202: # FIFFV_EOG_CH
epochs.drop_channels([ch['ch_name']])
# computing power spectral density on epochs signal
# average in the 1-second window around event (mean, but can choose 'median')
kwargs = dict(fmin=fmin,
fmax=fmax,
n_fft=n_fft,
n_per_seg=n_per_seg,
n_jobs=1)
psds, freq_list = psd_welch(epochs, **kwargs, average='mean',
picks='all') # or median
if epochs_average is True:
# averaging power across epochs for each channel ch and each frequency f
psd = np.mean(psds, axis=0)
else:
psd = psds
psd_tuple = namedtuple('PSD', ['freq_list', 'psd'])
return psd_tuple(freq_list=freq_list, psd=psd)
