def test_data(): """Test reading raw kit files """ raw_py = kit.read_raw_kit(input_fname=op.join(data_dir, 'test.sqd'), mrk_fname=op.join(data_dir, 'test_mrk.sqd'), elp_fname=op.join(data_dir, 'test_elp.txt'), hsp_fname=op.join(data_dir, 'test_hsp.txt'), sns_fname=op.join(data_dir, 'sns.txt'), stim=range(167, 159, -1), stimthresh=1, preload=True) # Binary file only stores the sensor channels py_picks = pick_types(raw_py.info, exclude='bads') raw_bin = op.join(data_dir, 'test_bin.fif') raw_bin = Raw(raw_bin, preload=True) bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads') data_bin, _ = raw_bin[bin_picks] data_py, _ = raw_py[py_picks] # this .mat was generated using the Yokogawa MEG Reader data_Ykgw = op.join(data_dir, 'test_Ykgw.mat') data_Ykgw = scipy.io.loadmat(data_Ykgw)['data'] data_Ykgw = data_Ykgw[py_picks] assert_array_almost_equal(data_py, data_Ykgw) py_picks = pick_types(raw_py.info, stim=True, exclude='bads') data_py, _ = raw_py[py_picks] assert_array_almost_equal(data_py, data_bin)
def test_epochs_proj(): """Test handling projection (apply proj in Raw or in Epochs) """ exclude = raw.info["bads"] + ["MEG 2443", "EEG 053"] # bads + 2 more this_picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, eog=True, exclude=exclude) epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True) assert_true(all(p["active"] == True for p in epochs.info["projs"])) evoked = epochs.average() assert_true(all(p["active"] == True for p in evoked.info["projs"])) data = epochs.get_data() raw_proj = fiff.Raw(raw_fname, proj=True) epochs_no_proj = Epochs( raw_proj, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=False ) data_no_proj = epochs_no_proj.get_data() assert_true(all(p["active"] == True for p in epochs_no_proj.info["projs"])) evoked_no_proj = epochs_no_proj.average() assert_true(all(p["active"] == True for p in evoked_no_proj.info["projs"])) assert_true(epochs_no_proj.proj == True) # as projs are active from Raw assert_array_almost_equal(data, data_no_proj, decimal=8) # make sure we can exclude avg ref this_picks = fiff.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True, exclude=exclude) epochs = Epochs( raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True, add_eeg_ref=True ) assert_true(_has_eeg_average_ref_proj(epochs.info["projs"])) epochs = Epochs( raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True, add_eeg_ref=False ) assert_true(not _has_eeg_average_ref_proj(epochs.info["projs"]))
def test_data(): """Test reading raw kit files """ raw_py = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim=list(range(167, 159, -1)), slope='+', stimthresh=1, preload=True) print(repr(raw_py)) # Binary file only stores the sensor channels py_picks = pick_types(raw_py.info, exclude='bads') raw_bin = op.join(data_dir, 'test_bin.fif') raw_bin = Raw(raw_bin, preload=True) bin_picks = pick_types(raw_bin.info, stim=True, exclude='bads') data_bin, _ = raw_bin[bin_picks] data_py, _ = raw_py[py_picks] # this .mat was generated using the Yokogawa MEG Reader data_Ykgw = op.join(data_dir, 'test_Ykgw.mat') data_Ykgw = scipy.io.loadmat(data_Ykgw)['data'] data_Ykgw = data_Ykgw[py_picks] assert_array_almost_equal(data_py, data_Ykgw) py_picks = pick_types(raw_py.info, stim=True, ref_meg=False, exclude='bads') data_py, _ = raw_py[py_picks] assert_array_almost_equal(data_py, data_bin)
def test_set_eeg_reference(): """ Test rereference eeg data""" raw = Raw(fif_fname, preload=True) # Rereference raw data by creating a copy of original data reref, ref_data = set_eeg_reference(raw, ['EEG 001', 'EEG 002'], copy=True) # Separate EEG channels from other channel types picks_eeg = pick_types(raw.info, meg=False, eeg=True, exclude='bads') picks_other = pick_types(raw.info, meg=True, eeg=False, eog=True, stim=True, exclude='bads') # Get the raw EEG data and other channel data raw_eeg_data = raw[picks_eeg][0] raw_other_data = raw[picks_other][0] # Get the rereferenced EEG data and channel other reref_eeg_data = reref[picks_eeg][0] unref_eeg_data = reref_eeg_data + ref_data # Undo rereferencing of EEG channels reref_other_data = reref[picks_other][0] # Check that both EEG data and other data is the same assert_array_equal(raw_eeg_data, unref_eeg_data) assert_array_equal(raw_other_data, reref_other_data) # Test that data is modified in place when copy=False reref, ref_data = set_eeg_reference(raw, ['EEG 001', 'EEG 002'], copy=False) assert_true(raw is reref)
def test_raw_to_nitime(): """ Test nitime export """ raw = Raw(fif_fname, preload=True) picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw_ts = raw.to_nitime(picks=picks) assert_true(raw_ts.data.shape[0] == len(picks)) raw = Raw(fif_fname, preload=False) picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw_ts = raw.to_nitime(picks=picks) assert_true(raw_ts.data.shape[0] == len(picks)) raw = Raw(fif_fname, preload=True) picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw_ts = raw.to_nitime(picks=picks, copy=False) assert_true(raw_ts.data.shape[0] == len(picks)) raw = Raw(fif_fname, preload=False) picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw_ts = raw.to_nitime(picks=picks, copy=False) assert_true(raw_ts.data.shape[0] == len(picks))
def test_compensation_mne(): """Test comensation by comparing with MNE """ def make_evoked(fname, comp): raw = Raw(fname, compensation=comp) picks = pick_types(raw.info, meg=True, ref_meg=True) events = np.array([[0, 0, 1]], dtype=np.int) evoked = Epochs(raw, events, 1, 0, 20e-3, picks=picks).average() return evoked def compensate_mne(fname, comp): tmp_fname = '%s-%d.fif' % (fname[:-4], comp) cmd = ['mne_compensate_data', '--in', fname, '--out', tmp_fname, '--grad', str(comp)] run_subprocess(cmd) return read_evokeds(tmp_fname)[0] # save evoked response with default compensation fname_default = op.join(tempdir, 'ctf_default-ave.fif') make_evoked(ctf_comp_fname, None).save(fname_default) for comp in [0, 1, 2, 3]: evoked_py = make_evoked(ctf_comp_fname, comp) evoked_c = compensate_mne(fname_default, comp) picks_py = pick_types(evoked_py.info, meg=True, ref_meg=True) picks_c = pick_types(evoked_c.info, meg=True, ref_meg=True) assert_allclose(evoked_py.data[picks_py], evoked_c.data[picks_c], rtol=1e-3, atol=1e-17)
def test_brainvision_data(): """Test reading raw Brain Vision files """ raw_py = read_raw_brainvision(vhdr_path, elp_path, elp_names, preload=True) picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads') data_py, times_py = raw_py[picks] print(raw_py) # to test repr print(raw_py.info) # to test Info repr # compare with a file that was generated using MNE-C raw_bin = Raw(eeg_bin, preload=True) picks = pick_types(raw_py.info, meg=False, eeg=True, exclude='bads') data_bin, times_bin = raw_bin[picks] assert_array_almost_equal(data_py, data_bin) assert_array_almost_equal(times_py, times_bin) # Make sure EOG channels are marked correctly raw_py = read_raw_brainvision(vhdr_path, elp_path, elp_names, eog=eog, preload=True) for ch in raw_py.info['chs']: if ch['ch_name'] in eog: assert_equal(ch['kind'], FIFF.FIFFV_EOG_CH) elif ch['ch_name'] in elp_names: assert_equal(ch['kind'], FIFF.FIFFV_EEG_CH) elif ch['ch_name'] == 'STI 014': assert_equal(ch['kind'], FIFF.FIFFV_STIM_CH) else: raise RuntimeError("Unknown Channel: %s" % ch['ch_name'])
def test_rank_estimation(): """Test raw rank estimation """ raw = Raw(fif_fname) n_meg = len(pick_types(raw.info, meg=True, eeg=False, exclude="bads")) n_eeg = len(pick_types(raw.info, meg=False, eeg=True, exclude="bads")) raw = Raw(fif_fname, preload=True) assert_array_equal(raw.estimate_rank(), n_meg + n_eeg) raw = Raw(fif_fname, preload=False) raw.apply_proj() n_proj = len(raw.info["projs"]) assert_array_equal(raw.estimate_rank(tstart=10, tstop=20), n_meg + n_eeg - n_proj)
def test_detrend(): """Test detrending of epochs """ # test first-order epochs_1 = Epochs(raw, events[:4], event_id, tmin, tmax, picks=picks, baseline=None, detrend=1) epochs_2 = Epochs(raw, events[:4], event_id, tmin, tmax, picks=picks, baseline=None, detrend=None) data_picks = fiff.pick_types(epochs_1.info, meg=True, eeg=True, exclude='bads') evoked_1 = epochs_1.average() evoked_2 = epochs_2.average() evoked_2.detrend(1) # Due to roundoff these won't be exactly equal, but they should be close assert_true(np.allclose(evoked_1.data, evoked_2.data, rtol=1e-8, atol=1e-20)) # test zeroth-order case for preload in [True, False]: epochs_1 = Epochs(raw, events[:4], event_id, tmin, tmax, picks=picks, baseline=(None, None), preload=preload) epochs_2 = Epochs(raw, events[:4], event_id, tmin, tmax, picks=picks, baseline=None, preload=preload, detrend=0) a = epochs_1.get_data() b = epochs_2.get_data() # All data channels should be almost equal assert_true(np.allclose(a[:, data_picks, :], b[:, data_picks, :], rtol=1e-16, atol=1e-20)) # There are non-M/EEG channels that should not be equal: assert_true(not np.allclose(a, b))
def test_filter(): """ Test filtering and Raw.apply_function interface """ raw = Raw(fif_fname, preload=True) picks_meg = pick_types(raw.info, meg=True) picks = picks_meg[:4] raw_lp = deepcopy(raw) raw_lp.filter(0.0, 4.0, picks=picks, n_jobs=2) raw_hp = deepcopy(raw) raw_lp.filter(8.0, None, picks=picks, n_jobs=2) raw_bp = deepcopy(raw) raw_bp.filter(4.0, 8.0, picks=picks) data, _ = raw[picks, :] lp_data, _ = raw_lp[picks, :] hp_data, _ = raw_hp[picks, :] bp_data, _ = raw_bp[picks, :] assert_array_almost_equal(data, lp_data + hp_data + bp_data) # make sure we didn't touch other channels data, _ = raw[picks_meg[4:], :] bp_data, _ = raw_bp[picks_meg[4:], :] assert_array_equal(data, bp_data)
def test_ems(): """Test event-matched spatial filters""" raw = fiff.Raw(raw_fname, preload=False) # create unequal number of events events = read_events(event_name) events[-2, 2] = 3 picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), preload=True) assert_raises(ValueError, compute_ems, epochs, ['aud_l', 'vis_l']) epochs.equalize_event_counts(epochs.event_id, copy=False) assert_raises(KeyError, compute_ems, epochs, ['blah', 'hahah']) surrogates, filters, conditions = compute_ems(epochs) assert_equal(list(set(conditions)), [1, 3]) events = read_events(event_name) event_id2 = dict(aud_l=1, aud_r=2, vis_l=3) epochs = Epochs(raw, events, event_id2, tmin, tmax, picks=picks, baseline=(None, 0), preload=True) epochs.equalize_event_counts(epochs.event_id, copy=False) n_expected = sum([len(epochs[k]) for k in ['aud_l', 'vis_l']]) assert_raises(ValueError, compute_ems, epochs) surrogates, filters, conditions = compute_ems(epochs, ['aud_r', 'vis_l']) assert_equal(n_expected, len(surrogates)) assert_equal(n_expected, len(conditions)) assert_equal(list(set(conditions)), [2, 3]) raw.close()
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 test_apply_mne_inverse_epochs(): """Test MNE with precomputed inverse operator on Epochs """ event_id, tmin, tmax = 1, -0.2, 0.5 picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014']) reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) flat = dict(grad=1e-15, mag=1e-15) events = read_events(fname_event)[:15] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject, flat=flat) stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label, pick_normal=True) assert_true(len(stcs) == 4) assert_true(3 < stcs[0].data.max() < 10) data = sum(stc.data for stc in stcs) / len(stcs) flip = label_sign_flip(label, inverse_operator['src']) label_mean = np.mean(data, axis=0) label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0) assert_true(label_mean.max() < label_mean_flip.max())
def test_concatenatechannels(): """Test methods of ConcatenateChannels """ raw = fiff.Raw(raw_fname, preload=False) events = read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] with warnings.catch_warnings(record=True) as w: epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), preload=True) epochs_data = epochs.get_data() concat = ConcatenateChannels(epochs.info) y = epochs.events[:, -1] X = concat.fit_transform(epochs_data, y) # Check data dimensions assert_true(X.shape[0] == epochs_data.shape[0]) assert_true(X.shape[1] == epochs_data.shape[1] * epochs_data.shape[2]) assert_array_equal(concat.fit(epochs_data, y).transform(epochs_data), X) # Check if data is preserved n_times = epochs_data.shape[2] assert_array_equal(epochs_data[0, 0, 0:n_times], X[0, 0:n_times]) # Test init exception assert_raises(ValueError, concat.fit, epochs, y) assert_raises(ValueError, concat.transform, epochs, y)
def test_scaler(): """Test methods of Scaler """ raw = fiff.Raw(raw_fname, preload=False) events = read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), preload=True) epochs_data = epochs.get_data() scaler = Scaler(epochs.info) y = epochs.events[:, -1] # np invalid divide value warnings with warnings.catch_warnings(record=True): X = scaler.fit_transform(epochs_data, y) assert_true(X.shape == epochs_data.shape) X2 = scaler.fit(epochs_data, y).transform(epochs_data) assert_array_equal(X2, X) # Test init exception assert_raises(ValueError, scaler.fit, epochs, y) assert_raises(ValueError, scaler.transform, epochs, y)
def test_preload_modify(): """ Test preloading and modifying data """ for preload in [False, True, 'memmap.dat']: raw = Raw(fif_fname, preload=preload) nsamp = raw.last_samp - raw.first_samp + 1 picks = pick_types(raw.info, meg='grad', exclude='bads') data = np.random.randn(len(picks), nsamp / 2) try: raw[picks, :nsamp / 2] = data except RuntimeError as err: if not preload: continue else: raise err tmp_fname = op.join(tempdir, 'raw.fif') raw.save(tmp_fname) raw_new = Raw(tmp_fname) data_new, _ = raw_new[picks, :nsamp / 2] assert_array_almost_equal(data, data_new)
def test_preload_modify(): """ Test preloading and modifying data """ for preload in [False, True, "memmap.dat"]: raw = Raw(fif_fname, preload=preload) nsamp = raw.last_samp - raw.first_samp + 1 picks = pick_types(raw.info, meg="grad", exclude="bads") data = np.random.randn(len(picks), nsamp / 2) try: raw[picks, : nsamp / 2] = data except RuntimeError as err: if not preload: continue else: raise err tmp_fname = op.join(tempdir, "raw.fif") raw.save(tmp_fname, overwrite=True) raw_new = Raw(tmp_fname) data_new, _ = raw_new[picks, : nsamp / 2] assert_allclose(data, data_new)
def test_regularized_csp(): """Test Common Spatial Patterns algorithm using regularized covariance """ raw = fiff.Raw(raw_fname, preload=False) events = read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude='bads') picks = picks[1:13:3] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), preload=True) epochs_data = epochs.get_data() n_channels = epochs_data.shape[1] n_components = 3 reg_cov = [None, 0.05, 'lws', 'oas'] for reg in reg_cov: csp = CSP(n_components=n_components, reg=reg) csp.fit(epochs_data, epochs.events[:, -1]) y = epochs.events[:, -1] X = csp.fit_transform(epochs_data, y) assert_true(csp.filters_.shape == (n_channels, n_channels)) assert_true(csp.patterns_.shape == (n_channels, n_channels)) assert_array_almost_equal(csp.fit(epochs_data, y). transform(epochs_data), X) # test init exception assert_raises(ValueError, csp.fit, epochs_data, np.zeros_like(epochs.events)) assert_raises(ValueError, csp.fit, epochs, y) assert_raises(ValueError, csp.transform, epochs, y) csp.n_components = n_components sources = csp.transform(epochs_data) assert_true(sources.shape[1] == n_components)
def test_psd(): """Test PSD estimation """ raw = fiff.Raw(raw_fname) exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more # picks MEG gradiometers picks = fiff.pick_types(raw.info, meg='mag', eeg=False, stim=False, exclude=exclude) picks = picks[:2] tmin, tmax = 0, 10 # use the first 60s of data fmin, fmax = 2, 70 # look at frequencies between 5 and 70Hz NFFT = 124 # the FFT size (NFFT). Ideally a power of 2 psds, freqs = compute_raw_psd(raw, tmin=tmin, tmax=tmax, picks=picks, fmin=fmin, fmax=fmax, NFFT=NFFT, n_jobs=1, proj=False) psds_proj, freqs = compute_raw_psd(raw, tmin=tmin, tmax=tmax, picks=picks, fmin=fmin, fmax=fmax, NFFT=NFFT, n_jobs=1, proj=True) assert_array_almost_equal(psds, psds_proj) assert_true(psds.shape == (len(picks), len(freqs))) assert_true(np.sum(freqs < 0) == 0) assert_true(np.sum(psds < 0) == 0)
def test_reject_epochs(): """Test of epochs rejection """ event_id = 1 tmin = -0.2 tmax = 0.5 # Setup for reading the raw data raw = fiff.Raw(raw_fname) events = mne.read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True, include=['STI 014']) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=1000e-12, mag=4e-12, eeg=80e-6, eog=150e-6), flat=dict(grad=1e-15, mag=1e-15)) data = epochs.get_data() n_events = len(epochs.events) n_clean_epochs = len(data) # Should match # mne_process_raw --raw test_raw.fif --projoff \ # --saveavetag -ave --ave test.ave --filteroff assert n_events > n_clean_epochs assert n_clean_epochs == 3
def test_plot_ica_panel(): """Test plotting of ICA panel """ ica_picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=False, ecg=False, eog=False, exclude="bads") cov = read_cov(cov_fname) ica = ICA(noise_cov=cov, n_components=2, max_pca_components=3, n_pca_components=3) ica.decompose_raw(raw, picks=ica_picks) ica.plot_sources_raw(raw)
def test_brainvision_data(): """Test reading raw Brain Vision files """ raw_py = read_raw_brainvision(vhdr_path, elp_fname=elp_path, ch_names=ch_names, preload=True) picks = pick_types(raw_py.info, meg=False, eeg=True, exclude="bads") data_py, times_py = raw_py[picks] print(raw_py) # to test repr print(raw_py.info) # to test Info repr # this fif was generated using MNE-C raw_bin = Raw(eeg_bin, preload=True) picks = pick_types(raw_py.info, meg=False, eeg=True, exclude="bads") data_bin, times_bin = raw_bin[picks] assert_array_almost_equal(data_py, data_bin) assert_array_almost_equal(times_py, times_bin)
def test_stim_ch(): """Test raw kit stim ch """ raw = read_raw_kit(sqd_path, mrk_path, elp_path, hsp_path, stim='<', slope='+', preload=True) stim_pick = pick_types(raw.info, meg=False, stim=True, exclude='bads') stim1, _ = raw[stim_pick] stim2 = np.array(raw.read_stim_ch(), ndmin=2) assert_array_equal(stim1, stim2)
def test_source_psd_epochs(): """Test multi-taper source PSD computation in label from epochs""" raw = fiff.Raw(fname_data) inverse_operator = read_inverse_operator(fname_inv) label = read_label(fname_label) event_id, tmin, tmax = 1, -0.2, 0.5 lambda2, method = 1. / 9., 'dSPM' bandwidth = 8. fmin, fmax = 0, 100 picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) events = find_events(raw) epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject) # only look at one epoch epochs.drop_bad_epochs() one_epochs = epochs[:1] # return list stc_psd = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax)[0] # return generator stcs = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax, return_generator=True) for stc in stcs: stc_psd_gen = stc assert_array_almost_equal(stc_psd.data, stc_psd_gen.data) # compare with direct computation stc = apply_inverse_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_normal=True, label=label)[0] sfreq = epochs.info['sfreq'] psd, freqs = multitaper_psd(stc.data, sfreq=sfreq, bandwidth=bandwidth, fmin=fmin, fmax=fmax) assert_array_almost_equal(psd, stc_psd.data) assert_array_almost_equal(freqs, stc_psd.times)
def test_evoked_detrend(): """Test for detrending evoked data """ ave = read_evoked(fname, 0) ave_normal = read_evoked(fname, 0) ave.detrend(0) ave_normal.data -= np.mean(ave_normal.data, axis=1)[:, np.newaxis] picks = pick_types(ave.info, meg=True, eeg=True, exclude='bads') assert_true(np.allclose(ave.data[picks], ave_normal.data[picks], rtol=1e-8, atol=1e-16))
def test_io_raw(): """Test IO for raw data (Neuromag + CTF) """ for fname in [fif_fname, ctf_fname]: raw = Raw(fname) nchan = raw.info['nchan'] ch_names = raw.info['ch_names'] meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M'] n_channels = 100 meg_channels_idx = meg_channels_idx[:n_channels] start, stop = raw.time_to_index(0, 5) data, times = raw[meg_channels_idx, start:(stop + 1)] meg_ch_names = [ch_names[k] for k in meg_channels_idx] # Set up pick list: MEG + STI 014 - bad channels include = ['STI 014'] include += meg_ch_names picks = pick_types(raw.info, meg=True, eeg=False, stim=True, misc=True, include=include, exclude=raw.info['bads']) print "Number of picked channels : %d" % len(picks) # Writing with drop_small_buffer True raw.save('raw.fif', picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=True) raw2 = Raw('raw.fif') sel = pick_channels(raw2.ch_names, meg_ch_names) data2, times2 = raw2[sel, :] assert_true(times2.max() <= 3) # Writing raw.save('raw.fif', picks, tmin=0, tmax=5) if fname == fif_fname: assert_true(len(raw.info['dig']) == 146) raw2 = Raw('raw.fif') sel = pick_channels(raw2.ch_names, meg_ch_names) data2, times2 = raw2[sel, :] assert_array_almost_equal(data, data2) assert_array_almost_equal(times, times2) assert_array_almost_equal(raw.info['dev_head_t']['trans'], raw2.info['dev_head_t']['trans']) assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq']) if fname == fif_fname: assert_array_almost_equal(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r']) fname = op.join(op.dirname(__file__), 'data', 'test_raw.fif')
def test_io_egi(): """Test importing EGI simple binary files""" # test default with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always', category=RuntimeWarning) _ = read_raw_egi(egi_fname, include=None) assert_equal(len(w), 1) assert_true(w[0].category == RuntimeWarning) msg = 'Did not find any event code with more than one event.' assert_true(msg in '%s' % w[0].message) include = ['TRSP', 'XXX1'] raw = read_raw_egi(egi_fname, include=include) _ = repr(raw) _ = repr(raw.info) # analysis:ignore, noqa assert_equal('eeg' in raw, True) out_fname = op.join(tempdir, 'test_egi_raw.fif') raw.save(out_fname) raw2 = Raw(out_fname, preload=True) data1, times1 = raw[:10, :] data2, times2 = raw2[:10, :] assert_array_almost_equal(data1, data2) assert_array_almost_equal(times1, times2) eeg_chan = [c for c in raw.ch_names if 'EEG' in c] assert_equal(len(eeg_chan), 256) picks = pick_types(raw.info, eeg=True) assert_equal(len(picks), 256) assert_equal('STI 014' in raw.ch_names, True) events = find_events(raw, stim_channel='STI 014') assert_equal(len(events), 2) # ground truth assert_equal(np.unique(events[:, 1])[0], 0) assert_true(np.unique(events[:, 0])[0] != 0) assert_true(np.unique(events[:, 2])[0] != 0) triggers = np.array([[0, 1, 1, 0], [0, 0, 1, 0]]) # test trigger functionality assert_raises(RuntimeError, _combine_triggers, triggers, None) triggers = np.array([[0, 1, 0, 0], [0, 0, 1, 0]]) events_ids = [12, 24] new_trigger = _combine_triggers(triggers, events_ids) assert_array_equal(np.unique(new_trigger), np.unique([0, 12, 24])) assert_raises(ValueError, read_raw_egi, egi_fname, include=['Foo']) assert_raises(ValueError, read_raw_egi, egi_fname, exclude=['Bar']) for ii, k in enumerate(include, 1): assert_true(k in raw.event_id) assert_true(raw.event_id[k] == ii)
def test_tfr_with_inverse_operator(): """Test time freq with MNE inverse computation""" tmin, tmax, event_id = -0.2, 0.5, 1 # Setup for reading the raw data raw = fiff.Raw(fname_data) events = find_events(raw) inverse_operator = read_inverse_operator(fname_inv) include = [] exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more # picks MEG gradiometers picks = fiff.pick_types(raw.info, meg=True, eeg=False, eog=True, stim=False, include=include, exclude=exclude) # Load condition 1 event_id = 1 events3 = events[:3] # take 3 events to keep the computation time low epochs = Epochs(raw, events3, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) # Compute a source estimate per frequency band bands = dict(alpha=[10, 10]) label = read_label(fname_label) stcs = source_band_induced_power(epochs, inverse_operator, bands, n_cycles=2, use_fft=False, pca=True, label=label) stc = stcs['alpha'] assert_true(len(stcs) == len(bands.keys())) assert_true(np.all(stc.data > 0)) assert_array_almost_equal(stc.times, epochs.times) stcs_no_pca = source_band_induced_power(epochs, inverse_operator, bands, n_cycles=2, use_fft=False, pca=False, label=label) assert_array_almost_equal(stcs['alpha'].data, stcs_no_pca['alpha'].data) # Compute a source estimate per frequency band epochs = Epochs(raw, events[:10], event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) frequencies = np.arange(7, 30, 2) # define frequencies of interest power, phase_lock = source_induced_power(epochs, inverse_operator, frequencies, label, baseline=(-0.1, 0), baseline_mode='percent', n_cycles=2, n_jobs=1) assert_true(np.all(phase_lock > 0)) assert_true(np.all(phase_lock <= 1)) assert_true(np.max(power) > 10)
def test_hilbert(): """ Test computation of analytic signal using hilbert """ raw = Raw(fif_fname, preload=True) picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw2 = raw.copy() raw.apply_hilbert(picks) raw2.apply_hilbert(picks, envelope=True, n_jobs=2) env = np.abs(raw._data[picks, :]) assert_array_almost_equal(env, raw2._data[picks, :])
def test_hilbert(): """ Test computation of analytic signal using hilbert """ raw = Raw(fif_fname, preload=True) picks_meg = pick_types(raw.info, meg=True, exclude="bads") picks = picks_meg[:4] raw2 = raw.copy() raw.apply_hilbert(picks) raw2.apply_hilbert(picks, envelope=True, n_jobs=2) env = np.abs(raw._data[picks, :]) assert_allclose(env, raw2._data[picks, :], rtol=1e-2, atol=1e-13)
tol=1e-4, weights=stc_dspm, weights_min=8., debias=True, wsize=16, tstep=4, window=0.05, return_residual=True) # Crop to remove edges stc.crop(tmin=-0.05, tmax=0.3) evoked.crop(tmin=-0.05, tmax=0.3) residual.crop(tmin=-0.05, tmax=0.3) ylim = dict(eeg=[-10, 10], grad=[-200, 250], mag=[-600, 600]) picks = fiff.pick_types(evoked.info, meg='grad', exclude='bads') evoked.plot(picks=picks, ylim=ylim, proj=True, titles=dict(grad='Evoked Response (grad)')) picks = fiff.pick_types(residual.info, meg='grad', exclude='bads') residual.plot(picks=picks, ylim=ylim, proj=True, titles=dict(grad='Residual (grad)')) ############################################################################### # View in 2D and 3D ("glass" brain like 3D plot) plot_sparse_source_estimates(forward['src'], stc,
""" ================================== Reading and writing an evoked file ================================== """ # Author: Alexandre Gramfort <*****@*****.**> # # License: BSD (3-clause) print __doc__ from mne import fiff from mne.datasets import sample from mne.viz import plot_evoked data_path = sample.data_path('.') fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked = fiff.Evoked(fname, setno=0, baseline=(None, 0), proj=True) ############################################################################### # Show result picks = fiff.pick_types(evoked.info, meg=True, eeg=True, exclude=evoked.info['bads']) # Pick channels to view plot_evoked(evoked, picks=picks)
data_path = sample.data_path() ############################################################################### # Set parameters raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' event_id, tmin, tmax = 1, -0.2, 0.5 # Setup for reading the raw data raw = fiff.Raw(raw_fname) events = mne.read_events(event_fname) # pick magnetometer channels picks = fiff.pick_types(raw.info, meg='mag', stim=False, eog=True, include=[], exclude='bads') # Note. if the reject parameter is not None but proj == False # each epoch will be projected to inform the rejection decision. # If, in this mode, the epoch is considered good, # instead of the projected epochs an the original data will be included in the # epochs object. This allows us to have both, rejection and the option to delay # the application of our SSP projectors. This also works for preloaded data. epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks,
def test_io_raw(): """Test IO for raw data (Neuromag + CTF + gz) """ # test unicode io for chars in [b'\xc3\xa4\xc3\xb6\xc3\xa9', b'a']: with Raw(fif_fname) as r: desc1 = r.info['description'] = chars.decode('utf-8') temp_file = op.join(tempdir, 'raw.fif') r.save(temp_file, overwrite=True) with Raw(temp_file) as r2: desc2 = r2.info['description'] assert_equal(desc1, desc2) # Let's construct a simple test for IO first raw = Raw(fif_fname, preload=True) raw.crop(0, 3.5) # put in some data that we know the values of data = np.random.randn(raw._data.shape[0], raw._data.shape[1]) raw._data[:, :] = data # save it somewhere fname = op.join(tempdir, 'test_copy_raw.fif') raw.save(fname, buffer_size_sec=1.0) # read it in, make sure the whole thing matches raw = Raw(fname) assert_true(np.allclose(data, raw[:, :][0], 1e-6, 1e-20)) # let's read portions across the 1-sec tag boundary, too inds = raw.time_as_index([1.75, 2.25]) sl = slice(inds[0], inds[1]) assert_true(np.allclose(data[:, sl], raw[:, sl][0], 1e-6, 1e-20)) # now let's do some real I/O fnames_in = [fif_fname, fif_gz_fname, ctf_fname] fnames_out = ['raw.fif', 'raw.fif.gz', 'raw.fif'] for fname_in, fname_out in zip(fnames_in, fnames_out): fname_out = op.join(tempdir, fname_out) raw = Raw(fname_in) nchan = raw.info['nchan'] ch_names = raw.info['ch_names'] meg_channels_idx = [k for k in range(nchan) if ch_names[k][0] == 'M'] n_channels = 100 meg_channels_idx = meg_channels_idx[:n_channels] start, stop = raw.time_as_index([0, 5]) data, times = raw[meg_channels_idx, start:(stop + 1)] meg_ch_names = [ch_names[k] for k in meg_channels_idx] # Set up pick list: MEG + STI 014 - bad channels include = ['STI 014'] include += meg_ch_names picks = pick_types(raw.info, meg=True, eeg=False, stim=True, misc=True, ref_meg=True, include=include, exclude='bads') # Writing with drop_small_buffer True raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=True, overwrite=True) raw2 = Raw(fname_out, preload=True) sel = pick_channels(raw2.ch_names, meg_ch_names) data2, times2 = raw2[sel, :] assert_true(times2.max() <= 3) # Writing raw.save(fname_out, picks, tmin=0, tmax=5, overwrite=True) if fname_in == fif_fname or fname_in == fif_fname + '.gz': assert_true(len(raw.info['dig']) == 146) raw2 = Raw(fname_out) sel = pick_channels(raw2.ch_names, meg_ch_names) data2, times2 = raw2[sel, :] assert_true(np.allclose(data, data2, 1e-6, 1e-20)) assert_allclose(times, times2) assert_allclose(raw.info['sfreq'], raw2.info['sfreq'], rtol=1e-5) # check transformations for trans in ['dev_head_t', 'dev_ctf_t', 'ctf_head_t']: if raw.info[trans] is None: assert_true(raw2.info[trans] is None) else: assert_array_equal(raw.info[trans]['trans'], raw2.info[trans]['trans']) # check transformation 'from' and 'to' if trans.startswith('dev'): from_id = FIFF.FIFFV_COORD_DEVICE else: from_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD if trans[4:8] == 'head': to_id = FIFF.FIFFV_COORD_HEAD else: to_id = FIFF.FIFFV_MNE_COORD_CTF_HEAD for raw_ in [raw, raw2]: assert_true(raw_.info[trans]['from'] == from_id) assert_true(raw_.info[trans]['to'] == to_id) if fname_in == fif_fname or fname_in == fif_fname + '.gz': assert_allclose(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
def test_filter(): """Test filtering (FIR and IIR) and Raw.apply_function interface """ raw = Raw(fif_fname, preload=True).crop(0, 7, False) sig_dec = 11 sig_dec_notch = 12 sig_dec_notch_fit = 12 picks_meg = pick_types(raw.info, meg=True, exclude='bads') picks = picks_meg[:4] raw_lp = raw.copy() raw_lp.filter(0., 4.0 - 0.25, picks=picks, n_jobs=2) raw_hp = raw.copy() raw_hp.filter(8.0 + 0.25, None, picks=picks, n_jobs=2) raw_bp = raw.copy() raw_bp.filter(4.0 + 0.25, 8.0 - 0.25, picks=picks) raw_bs = raw.copy() raw_bs.filter(8.0 + 0.25, 4.0 - 0.25, picks=picks, n_jobs=2) data, _ = raw[picks, :] lp_data, _ = raw_lp[picks, :] hp_data, _ = raw_hp[picks, :] bp_data, _ = raw_bp[picks, :] bs_data, _ = raw_bs[picks, :] assert_array_almost_equal(data, lp_data + bp_data + hp_data, sig_dec) assert_array_almost_equal(data, bp_data + bs_data, sig_dec) raw_lp_iir = raw.copy() raw_lp_iir.filter(0., 4.0, picks=picks, n_jobs=2, method='iir') raw_hp_iir = raw.copy() raw_hp_iir.filter(8.0, None, picks=picks, n_jobs=2, method='iir') raw_bp_iir = raw.copy() raw_bp_iir.filter(4.0, 8.0, picks=picks, method='iir') lp_data_iir, _ = raw_lp_iir[picks, :] hp_data_iir, _ = raw_hp_iir[picks, :] bp_data_iir, _ = raw_bp_iir[picks, :] summation = lp_data_iir + hp_data_iir + bp_data_iir assert_array_almost_equal(data[:, 100:-100], summation[:, 100:-100], sig_dec) # make sure we didn't touch other channels data, _ = raw[picks_meg[4:], :] bp_data, _ = raw_bp[picks_meg[4:], :] assert_array_equal(data, bp_data) bp_data_iir, _ = raw_bp_iir[picks_meg[4:], :] assert_array_equal(data, bp_data_iir) # do a very simple check on line filtering raw_bs = raw.copy() with warnings.catch_warnings(record=True): warnings.simplefilter('always') raw_bs.filter(60.0 + 0.5, 60.0 - 0.5, picks=picks, n_jobs=2) data_bs, _ = raw_bs[picks, :] raw_notch = raw.copy() raw_notch.notch_filter(60.0, picks=picks, n_jobs=2, method='fft') data_notch, _ = raw_notch[picks, :] assert_array_almost_equal(data_bs, data_notch, sig_dec_notch) # now use the sinusoidal fitting raw_notch = raw.copy() raw_notch.notch_filter(None, picks=picks, n_jobs=2, method='spectrum_fit') data_notch, _ = raw_notch[picks, :] data, _ = raw[picks, :] assert_array_almost_equal(data, data_notch, sig_dec_notch_fit)
import pylab as pl import mne from mne import fiff from mne.datasets import sample data_path = sample.data_path('..') ############################################################################### # Set parameters raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' # Setup for reading the raw data raw = fiff.Raw(raw_fname) event_id = 998 eog_events = mne.artifacts.find_eog_events(raw, event_id) # Read epochs picks = fiff.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=True) tmin, tmax = -0.2, 0.2 epochs = mne.Epochs(raw, eog_events, event_id, tmin, tmax, picks=picks) data = epochs.get_data() print "Number of detected EOG artifacts : %d" % len(data) ############################################################################### # Plot EOG artifacts pl.plot(1e3 * epochs.times, np.squeeze(data).T) pl.xlabel('Times (ms)') pl.ylabel('EOG (muV)') pl.show()
def test_time_frequency(): """Test time frequency transform (PSD and phase lock) """ # Set parameters event_id = 1 tmin = -0.2 tmax = 0.5 # Setup for reading the raw data raw = fiff.Raw(raw_fname) events = read_events(event_fname) include = [] exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more # picks MEG gradiometers picks = fiff.pick_types(raw.info, meg='grad', eeg=False, stim=False, include=include, exclude=exclude) picks = picks[:2] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0)) data = epochs.get_data() times = epochs.times frequencies = np.arange(6, 20, 5) # define frequencies of interest Fs = raw.info['sfreq'] # sampling in Hz n_cycles = frequencies / float(4) power, phase_lock = induced_power(data, Fs=Fs, frequencies=frequencies, n_cycles=n_cycles, use_fft=True) assert_true(power.shape == (len(picks), len(frequencies), len(times))) assert_true(power.shape == phase_lock.shape) assert_true(np.sum(phase_lock >= 1) == 0) assert_true(np.sum(phase_lock <= 0) == 0) power, phase_lock = induced_power(data, Fs=Fs, frequencies=frequencies, n_cycles=2, use_fft=False) assert_true(power.shape == (len(picks), len(frequencies), len(times))) assert_true(power.shape == phase_lock.shape) assert_true(np.sum(phase_lock >= 1) == 0) assert_true(np.sum(phase_lock <= 0) == 0) tfr = cwt_morlet(data[0], Fs, frequencies, use_fft=True, n_cycles=2) assert_true(tfr.shape == (len(picks), len(frequencies), len(times))) single_power = single_trial_power(data, Fs, frequencies, use_fft=False, n_cycles=2) assert_array_almost_equal(np.mean(single_power), power)
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': 1}) 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])
def test_epochs_proj(): """Test handling projection (apply proj in Raw or in Epochs) """ exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more this_picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, eog=True, exclude=exclude) epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True) assert_true(all(p['active'] is True for p in epochs.info['projs'])) evoked = epochs.average() assert_true(all(p['active'] is True for p in evoked.info['projs'])) data = epochs.get_data() raw_proj = fiff.Raw(raw_fname, proj=True) epochs_no_proj = Epochs(raw_proj, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=False) data_no_proj = epochs_no_proj.get_data() assert_true(all(p['active'] is True for p in epochs_no_proj.info['projs'])) evoked_no_proj = epochs_no_proj.average() assert_true(all(p['active'] is True for p in evoked_no_proj.info['projs'])) assert_true(epochs_no_proj.proj is True) # as projs are active from Raw assert_array_almost_equal(data, data_no_proj, decimal=8) # make sure we can exclude avg ref this_picks = fiff.pick_types(raw.info, meg=True, eeg=True, stim=True, eog=True, exclude=exclude) epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True, add_eeg_ref=True) assert_true(_has_eeg_average_ref_proj(epochs.info['projs'])) epochs = Epochs(raw, events[:4], event_id, tmin, tmax, picks=this_picks, baseline=(None, 0), proj=True, add_eeg_ref=False) assert_true(not _has_eeg_average_ref_proj(epochs.info['projs']))
# Setup for reading the raw data raw = fiff.Raw(raw_fname) events = mne.read_events(event_fname) # Plot raw data fig = raw.plot(events=events) # Set up pick list: EEG + STI 014 - bad channels (modify to your needs) include = [] # or stim channels ['STI 014'] raw.info['bads'] += ['EEG 053'] # bads + 1 more # pick EEG channels picks = fiff.pick_types(raw.info, meg=False, eeg=True, stim=False, eog=True, include=include, exclude='bads') # Read epochs epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(eeg=80e-6, eog=150e-6), preload=True) epochs.plot()
fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif' fname_raw = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' fname_event = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' # Load data inverse_operator = read_inverse_operator(fname_inv) raw = Raw(fname_raw) events = mne.read_events(fname_event) # Add a bad channel raw.info['bads'] += ['MEG 2443'] # Pick MEG channels picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=True, exclude='bads') # Define epochs for left-auditory condition event_id, tmin, tmax = 1, -0.2, 0.5 epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(mag=4e-12, grad=4000e-13, eog=150e-6)) # Compute inverse solution and for each epoch. By using "return_generator=True"
from mne.viz import iter_topography from mne.fixes import partial from mne import fiff from mne.time_frequency import compute_raw_psd import matplotlib.pyplot as plt from mne.datasets import sample data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' raw = fiff.Raw(raw_fname, preload=True) raw.filter(1, 20) picks = fiff.pick_types(raw.info, meg=True, exclude=[]) tmin, tmax = 0, 120 # use the first 120s of data fmin, fmax = 2, 20 # look at frequencies between 2 and 20Hz n_fft = 2048 # the FFT size (NFFT). Ideally a power of 2 psds, freqs = compute_raw_psd(raw, picks=picks, tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax) psds = 10 * np.log10(psds) # scale to dB def my_callback(ax, ch_idx): """ This block of code is executed once you click on one of the channel axes
'test_raw.fif') event_name = op.join(op.dirname(__file__), '..', '..', 'fiff', 'tests', 'data', 'test-eve.fif') evoked_nf_name = op.join(op.dirname(__file__), '..', '..', 'fiff', 'tests', 'data', 'test-nf-ave.fif') test_cov_name = op.join(op.dirname(__file__), '..', '..', 'fiff', 'tests', 'data', 'test-cov.fif') event_id, tmin, tmax = 1, -0.2, 0.5 raw = fiff.Raw(raw_fname, preload=True) events = read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=False, exclude=raw.info['bads']) # for testing eog functionality picks2 = fiff.pick_types(raw.info, meg=True, stim=False, ecg=False, eog=True, exclude=raw.info['bads']) reject = dict(grad=1000e-12, mag=4e-12, eeg=80e-6, eog=150e-6) flat = dict(grad=1e-15, mag=1e-15) test_cov = cov.read_cov(test_cov_name)
elif chan == 'PZ': pl.subplot(3, 3, 8) pl.title("PZ") ##pl.title(1.0, 1.0, 'PZ', fontsize='medium', verticalalignment='top') elif chan == 'C5': pl.subplot(3, 3, 4) pl.title("C5") ##pl.title(1.0, 1.0, 'C5', fontsize='medium', verticalalignment='top') else: pl.subplot(3, 3, 6) pl.title("C6") ##pl.title(1.0, 1.0, 'C6', fontsize='medium', verticalalignment='top') sel = fiff.pick_types(evoked.info, meg=False, eeg=False, include=[chan], exclude="bads") print sel data = evoked.data[sel] * 1e6 ##Mean region_mean = np.mean(data, 0) ###plotting commands pl.plot(times, region_mean, color=colorList[c], linewidth=lWidth) #plot the data #pl.title(chan) pl.ylim([eegymin, eegymax]) #set the y limits pl.xlim([eegxmin, eegxmax]) #set the x limits pl.box('off') # turn off the box frame
def test_find_layout(): """Test finding layout""" with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') find_layout(chs=test_info['chs']) assert_true(w[0].category == DeprecationWarning) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') find_layout(test_info['chs']) assert_true(w[0].category == DeprecationWarning) assert_raises(ValueError, find_layout, dict()) assert_raises(ValueError, find_layout, test_info, ch_type='meep') sample_info = Raw(fif_fname).info grads = pick_types(sample_info, meg='grad') sample_info2 = pick_info(sample_info, grads) mags = pick_types(sample_info, meg='mag') sample_info3 = pick_info(sample_info, mags) # mock new convention sample_info4 = copy.deepcopy(sample_info) for ii, name in enumerate(sample_info4['ch_names']): new = name.replace(' ', '') sample_info4['ch_names'][ii] = new sample_info4['chs'][ii]['ch_name'] = new mags = pick_types(sample_info, meg=False, eeg=True) sample_info5 = pick_info(sample_info, mags) lout = find_layout(sample_info, ch_type=None) assert_true(lout.kind == 'Vectorview-all') assert_true(all(' ' in k for k in lout.names)) lout = find_layout(sample_info2, ch_type='meg') assert_true(lout.kind == 'Vectorview-all') # test new vector-view lout = find_layout(sample_info4, ch_type=None) assert_true(lout.kind == 'Vectorview-all') assert_true(all(not ' ' in k for k in lout.names)) lout = find_layout(sample_info, ch_type='grad') assert_true(lout.kind == 'Vectorview-grad') lout = find_layout(sample_info2) assert_true(lout.kind == 'Vectorview-grad') lout = find_layout(sample_info2, ch_type='grad') assert_true(lout.kind == 'Vectorview-grad') lout = find_layout(sample_info2, ch_type='meg') assert_true(lout.kind == 'Vectorview-all') lout = find_layout(sample_info, ch_type='mag') assert_true(lout.kind == 'Vectorview-mag') lout = find_layout(sample_info3) assert_true(lout.kind == 'Vectorview-mag') lout = find_layout(sample_info3, ch_type='mag') assert_true(lout.kind == 'Vectorview-mag') lout = find_layout(sample_info3, ch_type='meg') assert_true(lout.kind == 'Vectorview-all') # lout = find_layout(sample_info, ch_type='eeg') assert_true(lout.kind == 'EEG') lout = find_layout(sample_info5) assert_true(lout.kind == 'EEG') lout = find_layout(sample_info5, ch_type='eeg') assert_true(lout.kind == 'EEG') # no common layout, 'meg' option not supported fname_bti_raw = op.join(bti_dir, 'exported4D_linux.fif') lout = find_layout(Raw(fname_bti_raw).info) assert_true(lout.kind == 'magnesWH3600') lout = find_layout(Raw(fname_ctf_raw).info) assert_true(lout.kind == 'CTF-275') lout = find_layout(read_raw_kit(fname_kit_157).info) assert_true(lout.kind == 'KIT-157') sample_info5['dig'] = [] assert_raises(RuntimeError, find_layout, sample_info5)
warnings.simplefilter('always') # enable b/c these tests throw warnings base_dir = op.join(op.dirname(__file__), '..', 'fiff', 'tests', 'data') raw_fname = op.join(base_dir, 'test_raw.fif') event_name = op.join(base_dir, 'test-eve.fif') evoked_nf_name = op.join(base_dir, 'test-nf-ave.fif') event_id, tmin, tmax = 1, -0.2, 0.5 event_id_2 = 2 raw = fiff.Raw(raw_fname, add_eeg_ref=False) events = read_events(event_name) picks = fiff.pick_types(raw.info, meg=True, eeg=True, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=1000e-12, mag=4e-12, eeg=80e-6, eog=150e-6) flat = dict(grad=1e-15, mag=1e-15) tempdir = _TempDir() def test_epochs_bad_baseline(): """Test Epochs initialization with bad baseline parameters """ assert_raises(ValueError, Epochs, raw, events, None, -0.1, 0.3, (-0.2, 0)) assert_raises(ValueError, Epochs, raw, events, None, -0.1, 0.3, (0, 0.4))
tmin, tmax = 0, 60 # use the first 60s of data fmin, fmax = 2, 300 # look at frequencies between 2 and 300Hz n_fft = 2048 # the FFT size (NFFT). Ideally a power of 2 plt.ion() # Let's first check out all channel types raw.plot_psds(area_mode='range', tmax=10.0) # Now let's focus on a smaller subset: # Pick MEG magnetometers in the Left-temporal region selection = read_selection('Left-temporal') picks = fiff.pick_types(raw.info, meg='mag', eeg=False, eog=False, stim=False, exclude='bads', selection=selection) # Let's just look at the first few channels for demonstration purposes picks = picks[:4] plt.figure() ax = plt.axes() raw.plot_psds(tmin=tmin, tmax=tmax, fmin=fmin, fmax=fmax, n_fft=n_fft, n_jobs=1,
data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' subjects_dir = data_path + '/subjects' tmin = -0.2 tmax = 0.3 # Use a lower tmax to reduce multiple comparisons # Setup for reading the raw data raw = fiff.Raw(raw_fname) events = mne.read_events(event_fname) ############################################################################### # Read epochs for all channels, removing a bad one raw.info['bads'] += ['MEG 2443'] picks = fiff.pick_types(raw.info, meg=True, eog=True, exclude='bads') # we'll load all four conditions that make up the 'two ways' of our ANOVA event_id = dict(l_aud=1, r_aud=2, l_vis=3, r_vis=4) reject = dict(grad=1000e-13, mag=4000e-15, eog=150e-6) epochs = mne.Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject, preload=True) # Equalize trial counts to eliminate bias (which would otherwise be
else: pl.subplot(122) for c in range(2): for subj in subjects: file = data_path + args.subjType + subj + '/ave_projon/' + args.subjType + subj + '_' + args.protocol + '-ave.fif' #print file #print 'set ', condList[c] evoked = mne.fiff.read_evoked(file, setno=condList[c], baseline=(-100, 0)) badChanSet = set( evoked.info['bads']) #These two lines remove bad channels goodChannelList = list(set(channelList) - badChanSet) sel = fiff.pick_types(evoked.info, meg=False, eeg=False, include=goodChannelList) data = evoked.data[sel] square = np.power(data, 2) meanSquare = np.mean(square, 0) rmsSubj = np.power(meanSquare, .5) #print rmsSubj[0] if subj == subjects[0]: rmsAll = rmsSubj else: rmsAll = np.vstack((rmsAll, rmsSubj)) rmsGA = np.mean(rmsAll, 0) times = evoked.times * 1000 pl.plot(times, rmsGA * 1e13, color=colorList[c], linewidth=lWidth)
def test_array(): """Test creating raw from array """ # creating raw = Raw(fif_fname).crop(2, 5, copy=False) data, times = raw[:, :] sfreq = raw.info['sfreq'] ch_names = [(ch[4:] if 'STI' not in ch else ch) for ch in raw.info['ch_names']] # change them, why not #del raw types = list() for ci in range(102): types.extend(('grad', 'grad', 'mag')) types.extend(['stim'] * 9) types.extend(['eeg'] * 60) # wrong length assert_raises(ValueError, create_info, ch_names, sfreq, types) # bad entry types.append('foo') assert_raises(KeyError, create_info, ch_names, sfreq, types) types[-1] = 'eog' info = create_info(ch_names, sfreq, types) raw2 = RawArray(data, info) data2, times2 = raw2[:, :] assert_allclose(data, data2) assert_allclose(times, times2) # saving temp_fname = op.join(tempdir, 'raw.fif') raw2.save(temp_fname) raw3 = Raw(temp_fname) data3, times3 = raw3[:, :] assert_allclose(data, data3) assert_allclose(times, times3) # filtering picks = pick_types(raw2.info, misc=True, exclude='bads')[:4] assert_equal(len(picks), 4) raw_lp = raw2.copy() with warnings.catch_warnings(record=True): raw_lp.filter(0., 4.0 - 0.25, picks=picks, n_jobs=2) raw_hp = raw2.copy() with warnings.catch_warnings(record=True): raw_hp.filter(8.0 + 0.25, None, picks=picks, n_jobs=2) raw_bp = raw2.copy() with warnings.catch_warnings(record=True): raw_bp.filter(4.0 + 0.25, 8.0 - 0.25, picks=picks) raw_bs = raw2.copy() with warnings.catch_warnings(record=True): raw_bs.filter(8.0 + 0.25, 4.0 - 0.25, picks=picks, n_jobs=2) data, _ = raw2[picks, :] lp_data, _ = raw_lp[picks, :] hp_data, _ = raw_hp[picks, :] bp_data, _ = raw_bp[picks, :] bs_data, _ = raw_bs[picks, :] sig_dec = 11 assert_array_almost_equal(data, lp_data + bp_data + hp_data, sig_dec) assert_array_almost_equal(data, bp_data + bs_data, sig_dec) # plotting import matplotlib matplotlib.use('Agg') # for testing don't use X server raw2.plot() raw2.plot_psds() # epoching events = find_events(raw2, stim_channel='STI 014') events[:, 2] = 1 assert_true(len(events) > 2) epochs = Epochs(raw2, events, 1, -0.2, 0.4, preload=True) epochs.plot_drop_log() epochs.plot() evoked = epochs.average() evoked.plot()
def test_apply_mne_inverse_epochs(): """Test MNE with precomputed inverse operator on Epochs """ inverse_operator = read_inverse_operator(fname_inv) label_lh = read_label(fname_label % 'Aud-lh') label_rh = read_label(fname_label % 'Aud-rh') event_id, tmin, tmax = 1, -0.2, 0.5 raw = Raw(fname_raw) picks = pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) flat = dict(grad=1e-15, mag=1e-15) events = read_events(fname_event)[:15] epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject, flat=flat) stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_lh, pick_ori="normal") assert_true(len(stcs) == 4) assert_true(3 < stcs[0].data.max() < 10) assert_true(stcs[0].subject == 'sample') data = sum(stc.data for stc in stcs) / len(stcs) flip = label_sign_flip(label_lh, inverse_operator['src']) label_mean = np.mean(data, axis=0) label_mean_flip = np.mean(flip[:, np.newaxis] * data, axis=0) assert_true(label_mean.max() < label_mean_flip.max()) # test extracting a BiHemiLabel stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_rh, pick_ori="normal") stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", label=label_lh + label_rh, pick_ori="normal") n_lh = len(stcs[0].data) assert_array_almost_equal(stcs[0].data, stcs_bh[0].data[:n_lh]) assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:]) # test without using a label (so delayed computation is used) stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM", pick_ori="normal") assert_true(stcs[0].subject == 'sample') label_stc = stcs[0].in_label(label_rh) assert_true(label_stc.subject == 'sample') assert_array_almost_equal(stcs_rh[0].data, label_stc.data)
def test_tfr_with_inverse_operator(): """Test time freq with MNE inverse computation""" tmin, tmax, event_id = -0.2, 0.5, 1 # Setup for reading the raw data raw = fiff.Raw(fname_data) events = find_events(raw, stim_channel='STI 014') inverse_operator = read_inverse_operator(fname_inv) raw.info['bads'] += ['MEG 2443', 'EEG 053'] # bads + 2 more # picks MEG gradiometers picks = fiff.pick_types(raw.info, meg=True, eeg=False, eog=True, stim=False, exclude='bads') # Load condition 1 event_id = 1 events3 = events[:3] # take 3 events to keep the computation time low epochs = Epochs(raw, events3, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) # Compute a source estimate per frequency band bands = dict(alpha=[10, 10]) label = read_label(fname_label) stcs = source_band_induced_power(epochs, inverse_operator, bands, n_cycles=2, use_fft=False, pca=True, label=label) stc = stcs['alpha'] assert_true(len(stcs) == len(list(bands.keys()))) assert_true(np.all(stc.data > 0)) assert_array_almost_equal(stc.times, epochs.times) stcs_no_pca = source_band_induced_power(epochs, inverse_operator, bands, n_cycles=2, use_fft=False, pca=False, label=label) assert_array_almost_equal(stcs['alpha'].data, stcs_no_pca['alpha'].data) # Compute a source estimate per frequency band epochs = Epochs(raw, events[:10], event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=dict(grad=4000e-13, eog=150e-6), preload=True) frequencies = np.arange(7, 30, 2) # define frequencies of interest power, phase_lock = source_induced_power(epochs, inverse_operator, frequencies, label, baseline=(-0.1, 0), baseline_mode='percent', n_cycles=2, n_jobs=1) assert_true(np.all(phase_lock > 0)) assert_true(np.all(phase_lock <= 1)) assert_true(np.max(power) > 10)
############################################################################### # Set parameters raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' event_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw-eve.fif' event_id, tmin, tmax = 1, -0.2, 0.5 # Setup for reading the raw data raw = fiff.Raw(raw_fname) events = mne.read_events(event_fname) # Set up pick list: EEG + MEG - bad channels (modify to your needs) exclude = raw.info['bads'] + ['MEG 2443', 'EEG 053'] # bads + 2 more picks = fiff.pick_types(raw.info, meg='grad', eeg=False, stim=False, eog=True, exclude=exclude) # Read epochs epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, eog=150e-6))
""" # Author: Denis Engemann <d.engemann@fz-juelichde> # Alexandre Gramfort <*****@*****.**> # # License: BSD (3-clause) print(__doc__) from mne import fiff from mne.datasets import sample from nitime.viz import plot_tseries import matplotlib.pyplot as plt data_path = sample.data_path() fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked = fiff.Evoked(fname, setno=0, baseline=(None, 0), proj=True) # Pick channels to view picks = fiff.pick_types(evoked.info, meg='grad', eeg=False, exclude='bads') evoked_ts = evoked.to_nitime(picks=picks) plot_tseries(evoked_ts) plt.show()
fname_cov = data_path + '/MEG/sample/sample_audvis-cov.fif' label_name = 'Aud-lh' fname_label = data_path + '/MEG/sample/labels/%s.label' % label_name ############################################################################### # Get epochs event_id, tmin, tmax = 1, -0.2, 0.5 # Setup for reading the raw data raw = Raw(raw_fname) raw.info['bads'] = ['MEG 2443', 'EEG 053'] # 2 bads channels events = mne.read_events(event_fname) # Set up pick list: EEG + MEG - bad channels (modify to your needs) left_temporal_channels = mne.read_selection('Left-temporal') picks = pick_types(raw.info, meg=True, eeg=False, stim=True, eog=True, exclude='bads', selection=left_temporal_channels) # Read epochs epochs = mne.Epochs(raw, events, event_id, tmin, tmax, proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, mag=4e-12, eog=150e-6)) evoked = epochs.average() forward = mne.read_forward_solution(fname_fwd) noise_cov = mne.read_cov(fname_cov) noise_cov = mne.cov.regularize(noise_cov, evoked.info, mag=0.05, grad=0.05, eeg=0.1, proj=True) data_cov = mne.compute_covariance(epochs, tmin=0.04, tmax=0.15) stc = lcmv(evoked, forward, noise_cov, data_cov, reg=0.01)
""" # Author: Denis Engemann <d.engemann@fz-juelichde> # Alexandre Gramfort <*****@*****.**> # # License: BSD (3-clause) print __doc__ from mne import fiff from mne.datasets import sample from nitime.viz import plot_tseries import pylab as pl data_path = sample.data_path('..') fname = data_path + '/MEG/sample/sample_audvis-ave.fif' # Reading evoked = fiff.Evoked(fname, setno=0, baseline=(None, 0), proj=True) picks = fiff.pick_types(evoked.info, meg='grad', eeg=False, exclude=evoked.info['bads']) # Pick channels to view evoked_ts = evoked.to_nitime(picks=picks) plot_tseries(evoked_ts) pl.show()
from mne import fiff from mne.datasets import sample data_path = sample.data_path() fname = data_path + '/MEG/sample/sample_audvis_raw.fif' raw = fiff.Raw(fname) # Set up pick list: MEG + STI 014 - bad channels want_meg = True want_eeg = False want_stim = False include = ['STI 014'] raw.info['bads'] += ['MEG 2443', 'EEG 053'] # bad channels + 2 more picks = fiff.pick_types(raw.info, meg=want_meg, eeg=want_eeg, stim=want_stim, include=include, exclude='bads') some_picks = picks[:5] # take 5 first start, stop = raw.time_as_index([0, 15]) # read the first 15s of data data, times = raw[some_picks, start:(stop + 1)] # save 150s of MEG data in FIF file raw.save('sample_audvis_meg_raw.fif', tmin=0, tmax=150, picks=picks, overwrite=True) ############################################################################### # Show MEG data raw.plot()
############################################################################### # Set parameters raw_fname = data_path + '/MEG/sample/sample_audvis_raw.fif' # Setup for reading the raw data raw = fiff.Raw(raw_fname) event_id = 999 ecg_events, _, _ = mne.artifacts.find_ecg_events(raw, event_id, ch_name='MEG 1531') # Read epochs picks = fiff.pick_types(raw.info, meg=False, eeg=False, stim=False, eog=False, include=['MEG 1531']) tmin, tmax = -0.1, 0.1 epochs = mne.Epochs(raw, ecg_events, event_id, tmin, tmax, picks=picks, proj=False) data = epochs.get_data() print "Number of detected ECG artifacts : %d" % len(data) ###############################################################################
def make_evoked(fname, comp): raw = Raw(fname, compensation=comp) picks = pick_types(raw.info, meg=True, ref_meg=True) events = np.array([[0, 0, 1]], dtype=np.int) evoked = Epochs(raw, events, 1, 0, 20e-3, picks=picks).average() return evoked
def test_source_psd_epochs(): """Test multi-taper source PSD computation in label from epochs""" raw = fiff.Raw(fname_data) inverse_operator = read_inverse_operator(fname_inv) label = read_label(fname_label) event_id, tmin, tmax = 1, -0.2, 0.5 lambda2, method = 1. / 9., 'dSPM' bandwidth = 8. fmin, fmax = 0, 100 picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True, ecg=True, eog=True, include=['STI 014'], exclude='bads') reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6) events = find_events(raw, stim_channel='STI 014') epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks, baseline=(None, 0), reject=reject) # only look at one epoch epochs.drop_bad_epochs() one_epochs = epochs[:1] # return list stc_psd = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_ori="normal", label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax)[0] # return generator stcs = compute_source_psd_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_ori="normal", label=label, bandwidth=bandwidth, fmin=fmin, fmax=fmax, return_generator=True) for stc in stcs: stc_psd_gen = stc assert_array_almost_equal(stc_psd.data, stc_psd_gen.data) # compare with direct computation stc = apply_inverse_epochs(one_epochs, inverse_operator, lambda2=lambda2, method=method, pick_ori="normal", label=label)[0] sfreq = epochs.info['sfreq'] psd, freqs = multitaper_psd(stc.data, sfreq=sfreq, bandwidth=bandwidth, fmin=fmin, fmax=fmax) assert_array_almost_equal(psd, stc_psd.data) assert_array_almost_equal(freqs, stc_psd.times)