def test_compute_proj_epochs():
"""Test SSP computation on epochs"""
event_id, tmin, tmax = 1, -0.2, 0.3
raw = Raw(raw_fname, preload=True)
events = read_events(event_fname)
bad_ch = 'MEG 2443'
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
exclude=[])
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj(op.join(tempdir, 'proj.fif.gz'), projs)
for p_fname in [proj_fname, proj_gz_fname,
op.join(tempdir, 'proj.fif.gz')]:
projs2 = read_proj(p_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1['desc'] == p2['desc'])
assert_true(p1['data']['col_names'] == p2['data']['col_names'])
assert_true(p1['active'] == p2['active'])
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save(op.join(tempdir, 'foo.fif'))
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
assert_true(len(projs_evoked) == 2)
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2)
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
def computeSSP(EEG, info, threshold):
'''
Computes SSP projections of epoched EEG data.
# Arguments
EEG: MNE EpochsArray data structure
Epoched EEG data in MNE format.
info: MNE info structure
Threshold: float
Value between 0 and 1.
# Returns
threshold_projs: list
List of SSP projection vectors above the pre-defined threshold (variance explained).
'''
projs = mne.compute_proj_epochs(EEG, n_eeg=10, n_jobs=1, verbose=True)
p = [projs[i]['explained_var'] for i in range(10)]
# If variance explained is above the pre-defined threshold, use the SSP projection vector
threshold_idx = analyzeVar(p, threshold)
threshold_projs = [] # List with projections above the threshold
for idx in threshold_idx:
threshold_projs.append(projs[idx])
return threshold_projs
def computeSSP(EEG, info, threshold):
'''
Computes SSP projections of epoched EEG data (bandpass filtered and resampled to 100Hz).
# Input
- EEG: Epoched and processed EEG
- info: mne info struct
- threshold: Value between 0 and 1, only uses the SSP projection vector if it explains more than the pre-defined threshold.
# Output
- Array of SSP projection vectors above a pre-defined threshold (variance explained).
'''
print('Computing SSP based on epochs')
projs = mne.compute_proj_epochs(EEG, n_eeg=10, n_jobs=1, verbose=True)
p = [projs[i]['explained_var'] for i in range(10)]
# If variance explained is above a certain threshold, use the SSP vector for projection
threshold_idx = analyzeVar(p, threshold)
threshold_projs = [] # List with projections above a chosen threshold
for idx in threshold_idx:
threshold_projs.append(projs[idx])
return threshold_projs
def test_compute_proj():
"""Test SSP computation"""
event_id, tmin, tmax = 1, -0.2, 0.3
raw = Raw(raw_fname)
events = read_events(event_fname)
exclude = []
bad_ch = 'MEG 2443'
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
exclude=exclude)
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0)
projs2 = read_proj(proj_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1['desc'] == p2['desc'])
assert_true(p1['data']['col_names'] == p2['data']['col_names'])
assert_true(p1['active'] == p2['active'])
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 7)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save('foo.fif')
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
def denoise_projs(epochs, apply=True):
'''
# Estimate SSP denoise projectors for the [epochs]
- @epochs: The epochs whose SSP projectors are computed and applied
- @apply: Whether apply_proj to the epochs, default by True
see 'https://mne.tools/stable/auto_tutorials/preprocessing/plot_45_projectors_background.html#computing-projectors' for detail
'''
projs = mne.compute_proj_epochs(epochs)
for p in projs:
epochs.add_proj(p)
if apply:
epochs.apply_proj()
return epochs
def compute_spatial_vectors(epochs, n_grad=2, n_mag=2, n_eeg=2):
"""Compute SSP (spatial space projection) vectors
Parameters
----------
epochs : instance of Epochs
The epochs containing the artifact.
n_grad : int
Number of vectors for gradiometers.
n_mag : int
Number of vectors for gradiometers.
n_eeg : int
Number of vectors for gradiometers.
Returns
-------
projs: list
List of projection vectors.
"""
import mne # XXX : ugly due to circular mess in imports
return mne.compute_proj_epochs(epochs, n_grad, n_mag, n_eeg)
def compute_spatial_vectors(epochs, n_grad=2, n_mag=2, n_eeg=2):
"""Compute SSP (spatial space projection) vectors
Parameters
----------
epochs : instance of Epochs
The epochs containing the artifact.
n_grad : int
Number of vectors for gradiometers.
n_mag : int
Number of vectors for gradiometers.
n_eeg : int
Number of vectors for gradiometers.
Returns
-------
projs: list
List of projection vectors.
"""
import mne # XXX : ugly due to circular mess in imports
return mne.compute_proj_epochs(epochs, n_grad, n_mag, n_eeg)
def computeSSP(EEG, info, threshold):
'''
Computes SSP projections of epoched EEG data.
Returns a list of SSP projection vectors above the pre-defined threshold (variance explained).
'''
projs = mne.compute_proj_epochs(EEG,
n_grad=2,
n_mag=2,
n_eeg=20,
n_jobs=1,
verbose=True)
p = [projs[i]['explained_var'] for i in range(20)]
# If variance explained is above the pre-defined threshold, use the SSP projection vector
threshold_idx = analyzeVar(p, threshold)
threshold_projs = [] # List with projections above the threshold
for idx in threshold_idx:
threshold_projs.append(projs[idx])
return threshold_projs
# Conversion from samples to times:
onsets = annotations_df['onset'].values / raw.info['sfreq']
durations = annotations_df['duration'].values / raw.info['sfreq']
descriptions = map(str, annotations_df['label'].values)
annotations = mne.Annotations(onsets, durations, descriptions)
raw.annotations = annotations
del onsets, durations, descriptions
###############################################################################
# Here we compute the saccade and EOG projectors for magnetometers and add
# them to the raw data. The projectors are added to both runs.
saccade_epochs = mne.Epochs(raw, saccades_events, 1, 0., 0.5, preload=True,
reject_by_annotation=False)
projs_saccade = mne.compute_proj_epochs(saccade_epochs, n_mag=1, n_eeg=0,
desc_prefix='saccade')
if use_precomputed:
proj_fname = op.join(data_path, 'MEG', 'bst_auditory',
'bst_auditory-eog-proj.fif')
projs_eog = mne.read_proj(proj_fname)[0]
else:
projs_eog, _ = mne.preprocessing.compute_proj_eog(raw.load_data(),
n_mag=1, n_eeg=0)
raw.add_proj(projs_saccade)
raw.add_proj(projs_eog)
del saccade_epochs, saccades_events, projs_eog, projs_saccade # To save memory
###############################################################################
# Visually inspect the effects of projections. Click on 'proj' button at the
# bottom right corner to toggle the projectors on/off. EOG events can be
# plotted by adding the event list as a keyword argument. As the bad segments
def compute_proj_ecg(in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq,
h_freq, average, preload, filter_length, n_jobs, ch_name,
reject, avg_ref, bads):
"""Compute SSP/PCA projections for ECG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
# Reading fif File
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = prefix + '_ecg_avg_proj.fif'
else:
ecg_proj_fname = prefix + '_ecg_proj.fif'
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None,
picks=picks, reject=reject, proj=True)
projs_init = raw.info['projs']
if average:
evoked = epochs.average()
projs = mne.compute_proj_evoked(evoked, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
projs = mne.compute_proj_epochs(epochs, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
if preload is not None and os.path.exists(preload):
os.remove(preload)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs + projs_init)
print 'Done.'
del onsets, durations, descriptions
###############################################################################
# Here we compute the saccade and EOG projectors for magnetometers and add
# them to the raw data. The projectors are added to both runs.
saccade_epochs = mne.Epochs(raw,
saccades_events,
1,
0.,
0.5,
preload=True,
baseline=(None, None),
reject_by_annotation=False)
projs_saccade = mne.compute_proj_epochs(saccade_epochs,
n_mag=1,
n_eeg=0,
desc_prefix='saccade')
if use_precomputed:
proj_fname = op.join(data_path, 'MEG', 'bst_auditory',
'bst_auditory-eog-proj.fif')
projs_eog = mne.read_proj(proj_fname)[0]
else:
projs_eog, _ = mne.preprocessing.compute_proj_eog(raw.load_data(),
n_mag=1,
n_eeg=0)
raw.add_proj(projs_saccade)
raw.add_proj(projs_eog)
del saccade_epochs, saccades_events, projs_eog, projs_saccade # To save memory
###############################################################################
# Visually inspect the effects of projections. Click on 'proj' button at the
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, average, filter_length, n_jobs, ch_name,
reject, avg_ref, bads, preload, flat):
"""Compute SSP/PCA projections for ECG/EOG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif'
else:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif'
print 'Reading fif File'
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
# if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'):
# save after 84s of MEG data in FIF file
# raw = raw[: , 84:]
#raw.save('sample_audvis_meg_raw.fif', tmin=84)
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
make_lingua(ecg_event_fname)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False,
eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False,
eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info,
meg=True,
eeg=True,
eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs_ecg = mne.Epochs(raw,
ecg_events,
None,
tmin,
tmax,
baseline=None,
picks=picks,
reject=reject,
proj=True)
print epochs_ecg
projs_init = raw.info['projs']
if average:
evoked_ecg = epochs_ecg.average()
projs_ecg = mne.compute_proj_evoked(evoked_ecg,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_ecg, n_grad, n_mag, n_eeg
projs_ecg = mne.compute_proj_epochs(epochs_ecg,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(
ecg_proj_fname, projs_ecg + projs_init
) ## Original Projections written along with the ecg projections.
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg)
return in_fif_fname, ecg_proj_fname, out_fif_fname
def compute_proj_wrap(epochs, average, **kwargs):
if average:
return compute_proj_evoked(epochs.average(), **kwargs)
else:
return compute_proj_epochs(epochs, **kwargs)
def test_compute_proj_epochs(tmp_path):
"""Test SSP computation on epochs."""
tempdir = str(tmp_path)
event_id, tmin, tmax = 1, -0.2, 0.3
raw = read_raw_fif(raw_fname, preload=True)
events = read_events(event_fname)
bad_ch = 'MEG 2443'
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=False,
eog=False,
exclude=[])
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=None,
proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs)
for p_fname in [
proj_fname, proj_gz_fname,
op.join(tempdir, 'test-proj.fif.gz')
]:
projs2 = read_proj(p_fname)
assert len(projs) == len(projs2)
for p1, p2 in zip(projs, projs2):
assert p1['desc'] == p2['desc']
assert p1['data']['col_names'] == p2['data']['col_names']
assert p1['active'] == p2['active']
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
if p2['explained_var']:
assert_array_almost_equal(p1['explained_var'],
p2['explained_var'])
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert nproj == 2
assert U.shape[1] == 2
# test that you can save them
with epochs.info._unlock():
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save(op.join(tempdir, 'foo-ave.fif'))
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
assert len(projs_evoked) == 2
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs,
n_grad=1,
n_mag=1,
n_eeg=0,
n_jobs=1,
desc_prefix='foobar')
assert all('foobar' in x['desc'] for x in projs)
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
# test warnings on bad filenames
proj_badname = op.join(tempdir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-proj.fif'):
write_proj(proj_badname, projs)
with pytest.warns(RuntimeWarning, match='-proj.fif'):
read_proj(proj_badname)
# bad inputs
fname = op.join(tempdir, 'out-proj.fif')
with pytest.raises(TypeError, match='projs'):
write_proj(fname, 'foo')
with pytest.raises(TypeError, match=r'projs\[0\] must be .*'):
write_proj(fname, ['foo'])
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg,
l_freq, h_freq, average, filter_length, n_jobs, ch_name,
reject, avg_ref, bads, preload):
#####Defining filenames
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
eog_event_fname = in_path + 'ssp/' + prefix + '_PYeog-eve.fif'
if average:
eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif'
else:
eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif'
####Reading in raw data
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
print 'Running EOG SSP computation'
eog_events, _ = mne.artifacts.find_eog_events(
raw
) # since our copy of the mne.artifacts.events.py script returns two parameters.
print "Writing EOG events in %s" % eog_event_fname
mne.write_events(eog_event_fname, eog_events)
make_lingua(eog_event_fname)
print 'Computing EOG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False,
ecg=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False,
ecg=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0:
del reject['ecg']
picks_eog = mne.fiff.pick_types(raw.info,
meg=True,
eeg=True,
ecg=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs)
epochs_eog = mne.Epochs(raw,
eog_events,
None,
tmin,
tmax,
baseline=None,
picks=picks_eog,
reject=reject,
proj=True)
projs_init = raw.info['projs']
if average:
evoked_eog = epochs_eog.average()
projs_eog = mne.compute_proj_evoked(evoked_eog,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_eog, n_grad, n_mag, n_eeg
projs_eog = mne.compute_proj_epochs(epochs_eog,
n_grad=n_grad,
n_mag=n_mag,
n_eeg=n_eeg)
print "Writing EOG projections in %s" % eog_proj_fname
mne.write_proj(eog_proj_fname, projs_eog)
return in_fif_fname, eog_proj_fname, out_fif_fname
def compute_proj_eog(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload):
#####Defining filenames
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
eog_event_fname = in_path + 'ssp/'+ prefix + '_PYeog-eve.fif'
if average:
eog_proj_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_eog_avg_proj_raw.fif'
else:
eog_proj_fname = in_path + 'ssp/' + prefix + '_PYeog_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_PYeog_proj_raw.fif'
####Reading in raw data
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
print 'Running EOG SSP computation'
eog_events, _= mne.artifacts.find_eog_events(raw) # since our copy of the mne.artifacts.events.py script returns two parameters.
print "Writing EOG events in %s" % eog_event_fname
mne.write_events(eog_event_fname, eog_events)
make_lingua(eog_event_fname)
print 'Computing EOG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, ecg=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, ecg=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, ecg=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, ecg=True)) == 0:
del reject['ecg']
picks_eog = mne.fiff.pick_types(raw.info, meg=True, eeg=True, ecg=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks_eog, l_freq, h_freq, filter_length, n_jobs)
epochs_eog = mne.Epochs(raw, eog_events, None, tmin, tmax, baseline=None,
picks=picks_eog, reject=reject, proj=True)
projs_init = raw.info['projs']
if average:
evoked_eog = epochs_eog.average()
projs_eog = mne.compute_proj_evoked(evoked_eog, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_eog, n_grad, n_mag, n_eeg
projs_eog = mne.compute_proj_epochs(epochs_eog, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
print "Writing EOG projections in %s" % eog_proj_fname
mne.write_proj(eog_proj_fname, projs_eog)
return in_fif_fname, eog_proj_fname, out_fif_fname
def test_compute_proj_epochs():
"""Test SSP computation on epochs."""
tempdir = _TempDir()
event_id, tmin, tmax = 1, -0.2, 0.3
raw = read_raw_fif(raw_fname, preload=True)
events = read_events(event_fname)
bad_ch = "MEG 2443"
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude=[])
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj(op.join(tempdir, "test-proj.fif.gz"), projs)
for p_fname in [proj_fname, proj_gz_fname, op.join(tempdir, "test-proj.fif.gz")]:
projs2 = read_proj(p_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1["desc"] == p2["desc"])
assert_true(p1["data"]["col_names"] == p2["data"]["col_names"])
assert_true(p1["active"] == p2["active"])
# compare with sign invariance
p1_data = p1["data"]["data"] * np.sign(p1["data"]["data"][0, 0])
p2_data = p2["data"]["data"] * np.sign(p2["data"]["data"][0, 0])
if bad_ch in p1["data"]["col_names"]:
bad = p1["data"]["col_names"].index("MEG 2443")
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
if p2["explained_var"]:
assert_array_almost_equal(p1["explained_var"], p2["explained_var"])
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info["projs"] += projs
evoked = epochs.average()
evoked.save(op.join(tempdir, "foo-ave.fif"))
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
assert_true(len(projs_evoked) == 2)
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2, desc_prefix="foobar")
assert_true(all("foobar" in x["desc"] for x in projs))
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
proj_badname = op.join(tempdir, "test-bad-name.fif.gz")
write_proj(proj_badname, projs)
read_proj(proj_badname)
assert_naming(w, "test_proj.py", 2)
def test_compute_proj_epochs():
"""Test SSP computation on epochs"""
tempdir = _TempDir()
event_id, tmin, tmax = 1, -0.2, 0.3
raw = Raw(raw_fname, preload=True)
events = read_events(event_fname)
bad_ch = 'MEG 2443'
picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=False,
eog=False,
exclude=[])
epochs = Epochs(raw,
events,
event_id,
tmin,
tmax,
picks=picks,
baseline=None,
proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs)
for p_fname in [
proj_fname, proj_gz_fname,
op.join(tempdir, 'test-proj.fif.gz')
]:
projs2 = read_proj(p_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1['desc'] == p2['desc'])
assert_true(p1['data']['col_names'] == p2['data']['col_names'])
assert_true(p1['active'] == p2['active'])
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
if p2['explained_var']:
assert_array_almost_equal(p1['explained_var'],
p2['explained_var'])
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save(op.join(tempdir, 'foo-ave.fif'))
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
assert_true(len(projs_evoked) == 2)
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs,
n_grad=1,
n_mag=1,
n_eeg=0,
n_jobs=2,
desc_prefix='foobar')
assert_true(all('foobar' in x['desc'] for x in projs))
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
# test warnings on bad filenames
clean_warning_registry()
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
proj_badname = op.join(tempdir, 'test-bad-name.fif.gz')
write_proj(proj_badname, projs)
read_proj(proj_badname)
print([ww.message for ww in w])
assert_equal(len(w), 2)
def compute_proj_ecg(in_path, in_fif_fname, tmin, tmax, n_grad, n_mag, n_eeg, l_freq, h_freq, average, filter_length, n_jobs, ch_name, reject, avg_ref, bads, preload, flat):
"""Compute SSP/PCA projections for ECG/EOG artifacts
Parameters
----------
in_fif_fname: string
Raw fif File
XXX
"""
if in_fif_fname.endswith('_raw.fif') or in_fif_fname.endswith('-raw.fif'):
prefix = in_fif_fname[:-8]
else:
prefix = in_fif_fname[:-4]
ecg_event_fname = in_path + 'ssp/' + prefix + '_ecg-eve.fif'
if average:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_avg_proj_raw.fif'
else:
ecg_proj_fname = in_path + 'ssp/' + prefix + '_ecg_proj.fif'
out_fif_fname = in_path + 'ssp/' + prefix + '_ecg_proj_raw.fif'
print 'Reading fif File'
in_fif_fname = in_path + in_fif_fname
raw = mne.fiff.Raw(in_fif_fname, preload=preload)
# if (in_path == '/cluster/kuperberg/SemPrMM/MEG/data/ya30/'):
# save after 84s of MEG data in FIF file
# raw = raw[: , 84:]
#raw.save('sample_audvis_meg_raw.fif', tmin=84)
print 'Running ECG SSP computation'
ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, ch_name=ch_name)
print "Writing ECG events in %s" % ecg_event_fname
mne.write_events(ecg_event_fname, ecg_events)
make_lingua(ecg_event_fname)
if avg_ref:
print "Adding average EEG reference projection."
eeg_proj = mne.fiff.proj.make_eeg_average_ref_proj(raw.info)
raw.info['projs'].append(eeg_proj)
print 'Computing ECG projector'
# Handler rejection parameters
if len(mne.fiff.pick_types(raw.info, meg='grad', eeg=False, eog=False)) == 0:
del reject['grad']
if len(mne.fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False)) == 0:
del reject['mag']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=True, eog=False)) == 0:
del reject['eeg']
if len(mne.fiff.pick_types(raw.info, meg=False, eeg=False, eog=True)) == 0:
del reject['eog']
picks = mne.fiff.pick_types(raw.info, meg=True, eeg=True, eog=True,
exclude=raw.info['bads'] + bads)
if l_freq is None and h_freq is not None:
raw.high_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is None:
raw.low_pass_filter(picks, h_freq, filter_length, n_jobs)
if l_freq is not None and h_freq is not None:
raw.band_pass_filter(picks, l_freq, h_freq, filter_length, n_jobs)
epochs_ecg = mne.Epochs(raw, ecg_events, None, tmin, tmax, baseline=None,
picks=picks, reject=reject, proj=True)
print epochs_ecg
projs_init = raw.info['projs']
if average:
evoked_ecg = epochs_ecg.average()
projs_ecg = mne.compute_proj_evoked(evoked_ecg, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
else:
print epochs_ecg, n_grad, n_mag, n_eeg
projs_ecg = mne.compute_proj_epochs(epochs_ecg, n_grad=n_grad, n_mag=n_mag,
n_eeg=n_eeg)
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg + projs_init) ## Original Projections written along with the ecg projections.
print "Writing ECG projections in %s" % ecg_proj_fname
mne.write_proj(ecg_proj_fname, projs_ecg)
return in_fif_fname, ecg_proj_fname, out_fif_fname
def preprocEEG(eeg,
EEGfile,
SSP=True,
threshold=0.1,
SSP_start_end=None,
reject=None,
events_list=None,
reject_ch=None,
set_ref=1,
prefilter=0,
flat=None):
'''
Preprocesses epoched EEG data.
# Input
- eeg: Epoched EEG data in the following format: (trials, time samples, channels).
- EEGfile: .csv file with raw EEG recordings (for computing SSP projection vectors). If EEGfile == [], the SSP projection vectors are computed based on epochs.
- SSP: Whether to apply SSP projections.
- Threshold: Value between 0 and 1, only uses the SSP projection vector if it explains more than the pre-defined threshold.
- SSP_start_end: Pre-defined "start" and "end" time points (array consisting of two floats) for the length of raw EEG to use for SSP projection vector analysis. Acquired from extractEpochs function.
- reject_ch: Whether to reject pre-defined channels.
- set_ref: Use average reference
- prefilter: Filter before epoch extraction
- flat: reject channels having close to no variation
# Preprocessing
- Linear detrending (channel-wise)
- EpochsArray format in MNE
- Reject channels (if reject_ch == True)
- Bandpass filter
- Resample to 100Hz
- SSP (if ssp == True)
- Reject bad channels/epochs (if ??)
- Baseline correction
- Rereference to average
- Baseline correction
# Output
- epochs: Epoched EEG data in MNE EpochsArray
- projs: SSP projection vectors
'''
# INFO
channel_names = [
'P7', 'P4', 'Cz', 'Pz', 'P3', 'P8', 'O1', 'O2', 'T8', 'F8', 'C4', 'F4',
'Fp2', 'Fz', 'C3', 'F3', 'Fp1', 'T7', 'F7', 'Oz', 'PO3', 'AF3', 'FC5',
'FC1', 'CP5', 'CP1', 'CP2', 'CP6', 'AF4', 'FC2', 'FC6', 'PO4'
]
channel_types = ['eeg'] * 32
sfreq = 500 # in Hertz
montage = 'standard_1020' # Or 1010
info = mne.create_info(channel_names, sfreq, channel_types, montage)
info['description'] = 'Enobio'
#if reject_ch == 'true':
# info['bads'] = ['Fp1','Fp2','Fz','AF3','AF4','T7','T8','F7','F8']
eeg = detrend(eeg, axis=1, type='linear')
no_trials = eeg.shape[0]
axis_move = np.moveaxis(eeg, [1, 2], [-1, -2]) # Rearrange into MNE format
tmin = -0.1
if events_list is not None: # if categories are included
event_id = dict(scene=0, face=1)
n_epochs = len(events_list)
events_list = [int(i) for i in events_list]
events = np.c_[np.arange(n_epochs),
np.zeros(n_epochs, int), events_list]
else:
event_id = None
events = None
epochs = mne.EpochsArray(axis_move,
info,
events=events,
tmin=tmin,
event_id=event_id,
baseline=None)
if reject_ch == True:
bads = ['Fp1', 'Fp2', 'Fz', 'AF3', 'AF4', 'T7', 'T8', 'F7', 'F8']
epochs.drop_channels(bads)
# Bandpass filtering
epochs.filter(HP, LP, fir_design='firwin', phase=phase)
# Resampling to 100 Hz
epochs.resample(100, npad='auto')
# Apply SSP (computed based on the raw/not epoched EEG)
if SSP == True:
if not EEGfile:
print('Computing SSP based on epochs')
all_projs = mne.compute_proj_epochs(epochs,
n_eeg=10,
n_jobs=1,
verbose=True)
p = [all_projs[i]['explained_var'] for i in range(10)]
# If variance explained is above a certain threshold, use the SSP vector for projection
threshold_idx = analyzeVar(p, threshold)
projs = [] # List with projections above a chosen threshold
for idx in threshold_idx:
projs.append(all_projs[idx])
else:
if reject_ch == None:
projs = computeSSP(EEGfile,
threshold,
SSP_start_end,
reject_ch=None)
if reject_ch == True:
projs = computeSSP(EEGfile,
threshold,
SSP_start_end,
reject_ch=True)
# Apply projection to the epochs already defined
epochs.add_proj(projs)
epochs.apply_proj()
else:
projs = []
if reject is not None:
epochs_copy = epochs.copy()
epochs_copy.drop_bad(reject=reject, flat=flat, verbose=None)
log = epochs_copy.drop_log
not_blank = np.concatenate([x for x in (log) if x])
bad_channels, bad_counts = np.unique(not_blank, return_counts=True)
#bad_channels=[bad_channels[a] for a in range(len(bad_channels))]
thres = 0.05 * no_trials
bad_above_thres = bad_channels[bad_counts > thres]
if len(bad_above_thres):
print(1)
epochs.info['bads'] = bad_above_thres
print('Dropping channels:', bad_above_thres)
epochs.interpolate_bads(reset_bads=True)
# repeat looking for bad epochs
epochs_copy = epochs.copy()
epochs_copy.drop_bad(reject=reject, flat=flat, verbose=None)
log = epochs_copy.drop_log
bad_epochs = [i for i, x in enumerate(log) if x]
epochs.drop(bad_epochs, reason='Reject')
epochs.apply_baseline(baseline=(None, 0))
# Rereferencing
epochs.set_eeg_reference()
# Apply baseline after filtering
epochs.apply_baseline(baseline=(None, 0))
return epochs, projs
def test_compute_proj_epochs():
"""Test SSP computation on epochs."""
tempdir = _TempDir()
event_id, tmin, tmax = 1, -0.2, 0.3
raw = read_raw_fif(raw_fname, preload=True)
events = read_events(event_fname)
bad_ch = 'MEG 2443'
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
exclude=[])
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj(op.join(tempdir, 'test-proj.fif.gz'), projs)
for p_fname in [proj_fname, proj_gz_fname,
op.join(tempdir, 'test-proj.fif.gz')]:
projs2 = read_proj(p_fname)
assert len(projs) == len(projs2)
for p1, p2 in zip(projs, projs2):
assert p1['desc'] == p2['desc']
assert p1['data']['col_names'] == p2['data']['col_names']
assert p1['active'] == p2['active']
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
if p2['explained_var']:
assert_array_almost_equal(p1['explained_var'],
p2['explained_var'])
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert nproj == 2
assert U.shape[1] == 2
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save(op.join(tempdir, 'foo-ave.fif'))
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
assert len(projs_evoked) == 2
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1,
desc_prefix='foobar')
assert all('foobar' in x['desc'] for x in projs)
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_allclose(proj, proj_par, rtol=1e-8, atol=1e-16)
# test warnings on bad filenames
proj_badname = op.join(tempdir, 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-proj.fif'):
write_proj(proj_badname, projs)
with pytest.warns(RuntimeWarning, match='-proj.fif'):
read_proj(proj_badname)
def test_compute_proj():
"""Test SSP computation"""
event_id, tmin, tmax = 1, -0.2, 0.3
raw = Raw(raw_fname, preload=True)
events = read_events(event_fname)
exclude = []
bad_ch = 'MEG 2443'
picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False,
exclude=exclude)
epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
baseline=None, proj=False)
evoked = epochs.average()
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=1)
write_proj('proj.fif.gz', projs)
for p_fname in [proj_fname, proj_gz_fname, 'proj.fif.gz']:
projs2 = read_proj(p_fname)
assert_true(len(projs) == len(projs2))
for p1, p2 in zip(projs, projs2):
assert_true(p1['desc'] == p2['desc'])
assert_true(p1['data']['col_names'] == p2['data']['col_names'])
assert_true(p1['active'] == p2['active'])
# compare with sign invariance
p1_data = p1['data']['data'] * np.sign(p1['data']['data'][0, 0])
p2_data = p2['data']['data'] * np.sign(p2['data']['data'][0, 0])
if bad_ch in p1['data']['col_names']:
bad = p1['data']['col_names'].index('MEG 2443')
mask = np.ones(p1_data.size, dtype=np.bool)
mask[bad] = False
p1_data = p1_data[:, mask]
p2_data = p2_data[:, mask]
corr = np.corrcoef(p1_data, p2_data)[0, 1]
assert_array_almost_equal(corr, 1.0, 5)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
epochs.info['projs'] += projs
evoked = epochs.average()
evoked.save('foo.fif')
projs = read_proj(proj_fname)
projs_evoked = compute_proj_evoked(evoked, n_grad=1, n_mag=1, n_eeg=0)
# XXX : test something
# test parallelization
projs = compute_proj_epochs(epochs, n_grad=1, n_mag=1, n_eeg=0, n_jobs=2)
projs = activate_proj(projs)
proj_par, _, _ = make_projector(projs, epochs.ch_names, bads=[])
assert_array_equal(proj, proj_par)
# Test that the raw projectors work
for ii in (1, 2, 4, 8, 12, 24):
raw = Raw(raw_fname)
projs = compute_proj_raw(raw, duration=ii-0.1, n_grad=1, n_mag=1,
n_eeg=0)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save('foo_%d_raw.fif' % ii)
# Test that purely continuous (no duration) raw projection works
raw = Raw(raw_fname)
projs = compute_proj_raw(raw, duration=None, n_grad=1, n_mag=1, n_eeg=0)
# test that you can compute the projection matrix
projs = activate_proj(projs)
proj, nproj, U = make_projector(projs, epochs.ch_names, bads=[])
assert_true(nproj == 2)
assert_true(U.shape[1] == 2)
# test that you can save them
raw.info['projs'] += projs
raw.save('foo_rawproj_continuous_raw.fif')
