def test_io_complex(): """Test IO with complex data types """ dtypes = [np.complex64, np.complex128] raw = Raw(fif_fname, preload=True) picks = np.arange(5) start, stop = raw.time_as_index([0, 5]) data_orig, _ = raw[picks, start:stop] for di, dtype in enumerate(dtypes): imag_rand = np.array(1j * np.random.randn(data_orig.shape[0], data_orig.shape[1]), dtype) raw_cp = raw.copy() raw_cp._data = np.array(raw_cp._data, dtype) raw_cp._data[picks, start:stop] += imag_rand # this should throw an error because it's complex with warnings.catch_warnings(record=True) as w: raw_cp.save(op.join(tempdir, 'raw.fif'), picks, tmin=0, tmax=5) # warning only gets thrown on first instance assert_equal(len(w), 1 if di == 0 else 0) raw2 = Raw(op.join(tempdir, 'raw.fif')) raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_array_almost_equal(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp]) # with preloading raw2 = Raw(op.join(tempdir, 'raw.fif'), preload=True) raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_array_almost_equal(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp])
def test_io_raw(): """Test IO for raw data (Neuromag + CTF + gz) """ 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): 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, include=include, exclude=raw.info["bads"] ) print "Number of picked channels : %d" % len(picks) # Writing with drop_small_buffer True raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=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) 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_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_in == fif_fname or fname_in == fif_fname + ".gz": assert_array_almost_equal(raw.info["dig"][0]["r"], raw2.info["dig"][0]["r"])
def test_io_complex(): """Test IO with complex data types """ dtypes = [np.complex64, np.complex128] raw = Raw(fif_fname, preload=True) picks = np.arange(5) start, stop = raw.time_as_index([0, 5]) data_orig, _ = raw[picks, start:stop] for di, dtype in enumerate(dtypes): imag_rand = np.array( 1j * np.random.randn(data_orig.shape[0], data_orig.shape[1]), dtype) raw_cp = raw.copy() raw_cp._data = np.array(raw_cp._data, dtype) raw_cp._data[picks, start:stop] += imag_rand # this should throw an error because it's complex with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') raw_cp.save(op.join(tempdir, 'raw.fif'), picks, tmin=0, tmax=5, overwrite=True) # warning gets thrown on every instance b/c simplifilter('always') assert_equal(len(w), 1) raw2 = Raw(op.join(tempdir, 'raw.fif')) raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_allclose(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp]) # with preloading raw2 = Raw(op.join(tempdir, 'raw.fif'), preload=True) raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_allclose(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp])
def test_io_complex(): """Test IO with complex data types """ dtypes = [np.complex64, np.complex128] raw = Raw(fif_fname, preload=True) picks = np.arange(5) start, stop = raw.time_as_index([0, 5]) data_orig, _ = raw[picks, start:stop] for di, dtype in enumerate(dtypes): imag_rand = np.array( 1j * np.random.randn(data_orig.shape[0], data_orig.shape[1]), dtype) raw_cp = deepcopy(raw) raw_cp._data = np.array(raw_cp._data, dtype) raw_cp._data[picks, start:stop] += imag_rand # this should throw an error because it's complex with warnings.catch_warnings(record=True) as w: raw_cp.save('raw.fif', picks, tmin=0, tmax=5) # warning only gets thrown on first instance assert_equal(len(w), 1 if di == 0 else 0) raw2 = Raw('raw.fif') raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_array_almost_equal(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp]) # with preloading raw2 = Raw('raw.fif', preload=True) raw2_data, _ = raw2[picks, :] n_samp = raw2_data.shape[1] assert_array_almost_equal(raw2_data[:, :n_samp], raw_cp._data[picks, :n_samp])
def test_raw_index_as_time(): """ Test index as time conversion""" raw = Raw(fif_fname, preload=True) t0 = raw.index_as_time([0], True)[0] t1 = raw.index_as_time([100], False)[0] t2 = raw.index_as_time([100], True)[0] assert_true((t2 - t1) == t0) # ensure we can go back and forth t3 = raw.index_as_time(raw.time_as_index([0], True), True) assert_array_almost_equal(t3, [0.0], 2) t3 = raw.index_as_time(raw.time_as_index(raw.info['sfreq'], True), True) assert_array_almost_equal(t3, [raw.info['sfreq']], 2) t3 = raw.index_as_time(raw.time_as_index(raw.info['sfreq'], False), False) assert_array_almost_equal(t3, [raw.info['sfreq']], 2) i0 = raw.time_as_index(raw.index_as_time([0], True), True) assert_true(i0[0] == 0) i1 = raw.time_as_index(raw.index_as_time([100], True), True) assert_true(i1[0] == 100) # Have to add small amount of time because we truncate via int casting i1 = raw.time_as_index(raw.index_as_time([100.0001], False), False) assert_true(i1[0] == 100)
def test_io_raw(): """Test IO for raw data (Neuromag + CTF + gz) """ # 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'])
raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' ############################################################################### # get raw data raw = Raw(raw_fname) # set picks picks = mne.fiff.pick_types(raw.info, meg=True, eeg=False, eog=False, stim=False, exclude='bads') # pick times relative to the onset of the MEG measurement. start, stop = raw.time_as_index([100, 115], use_first_samp=False) # export to nitime using a copy of the data raw_ts = raw.to_nitime(start=start, stop=stop, picks=picks, copy=True) ############################################################################### # explore some nitime timeseries features # get start print raw_ts.t0 # get duration print raw_ts.duration # get sample duration (sampling interval) print raw_ts.sampling_interval
# plot spatial sensitivities of EOG and ECG ICA components title = 'Spatial patterns of ICA components for ECG+EOG (Magnetometers)' source_idx = range(15) ica.plot_topomap([ecg_source_idx, eog_source_idx], ch_type='mag') plt.suptitle(title, fontsize=12) ############################################################################### # Show MEG data before and after ICA cleaning. # We now add the eog artifacts to the ica.exclusion list ica.exclude += [eog_source_idx] # Restore sensor space data raw_ica = ica.pick_sources_raw(raw, include=None) start_compare, stop_compare = raw.time_as_index([100, 106]) data, times = raw[picks, start_compare:stop_compare] data_clean, _ = raw_ica[picks, start_compare:stop_compare] plt.figure() plt.plot(times, data.T) plt.xlabel('time (s)') plt.xlim(100, 106) plt.ylabel('Raw MEG data (T)') y0, y1 = plt.ylim() plt.figure() plt.plot(times, data_clean.T) plt.xlabel('time (s)') plt.xlim(100, 106)
data_path = sample.data_path('..') fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif' fname_raw = data_path + '/MEG/sample/sample_audvis_raw.fif' label_name = 'Aud-lh' fname_label = data_path + '/MEG/sample/labels/%s.label' % label_name snr = 1.0 # use smaller SNR for raw data lambda2 = 1.0 / snr ** 2 method = "sLORETA" # use sLORETA method (could also be MNE or dSPM) # Load data raw = Raw(fname_raw) inverse_operator = read_inverse_operator(fname_inv) label = mne.read_label(fname_label) start, stop = raw.time_as_index([0, 15]) # read the first 15s of data # Compute inverse solution stc = apply_inverse_raw(raw, inverse_operator, lambda2, method, label, start, stop, pick_normal=False) # Save result in stc files stc.save('mne_%s_raw_inverse_%s' % (method, label_name)) ############################################################################### # View activation time-series pl.plot(1e3 * stc.times, stc.data[::100, :].T) pl.xlabel('time (ms)') pl.ylabel('%s value' % method) pl.show()
def test_raw_time_as_index(): """ Test time as index conversion""" raw = Raw(fif_fname, preload=True) first_samp = raw.time_as_index([0], True)[0] assert_true(raw.first_samp == -first_samp)
# explained variance. Also we decide to use 64 PCA components before mixing # back to sensor space. These include the PCA components supplied to ICA plus # additional PCA components up to rank 64 of the MEG data. # This allows to control the trade-off between denoising and preserving signal. ica = ICA(n_components=0.90, n_pca_components=64, max_pca_components=100, noise_cov=None, random_state=0) print ica # 1 minute exposure should be sufficient for artifact detection. # However, rejection performance may significantly improve when using # the entire data range start, stop = raw.time_as_index([100, 160]) # decompose sources for raw data ica.decompose_raw(raw, start=start, stop=stop, picks=picks) print ica sources = ica.get_sources_raw(raw, start=start, stop=stop) # setup reasonable time window for inspection start_plot, stop_plot = raw.time_as_index([100, 103]) # plot components ica.plot_sources_raw(raw, start=start_plot, stop=stop_plot) ############################################################################### # Automatically find the ECG component using correlation with ECG signal.
def test_io_raw(): """Test IO for raw data (Neuromag + CTF + gz) """ 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, 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) 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) 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_array_almost_equal(data, data2) assert_array_almost_equal(times, times2) assert_array_almost_equal(raw.info['sfreq'], raw2.info['sfreq']) # 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_array_almost_equal(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
def test_io_raw(): """Test IO for raw data (Neuromag + CTF + gz) """ 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): 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, include=include, exclude=raw.info['bads']) print "Number of picked channels : %d" % len(picks) # Writing with drop_small_buffer True raw.save(fname_out, picks, tmin=0, tmax=4, buffer_size_sec=3, drop_small_buffer=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) 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_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_in == fif_fname or fname_in == fif_fname + '.gz': assert_array_almost_equal(raw.info['dig'][0]['r'], raw2.info['dig'][0]['r'])
# explained variance. ica = ICA(n_components=0.90, max_pca_components=100, noise_cov=None, random_state=0) # For maximum rejection performance we will compute the decomposition on # the entire time range # decompose sources for raw data, select n_components by explained variance ica.decompose_raw(raw, start=None, stop=None, picks=picks) print ica sources = ica.get_sources_raw(raw) # setup reasonable time window for inspection start_plot, stop_plot = raw.time_as_index([100, 103]) # plot components ica.plot_sources_raw(raw, start=start_plot, stop=stop_plot) ############################################################################### # Automatically find the ECG component using correlation with ECG signal # As we don't have an ECG channel we use one that correlates a lot with heart # beats: 'MEG 1531'. We can directly pass the name to the find_sources method. # We select the pearson correlation from scipy stats via string label. # The function is internally modified to be applicable to 2D arrays and, # hence, returns product-moment correlation scores for each ICA source. eog_scores = ica.find_sources_raw(raw, target='EOG 061', score_func='pearsonr')
def __call__(self, sender, **kwargs): """post save callback entry point. logger.debug('MNE-init()') :param sender: The model class. :param instance: The actual instance being saved. :param created: A boolean; True if a new record was created. :type created: bool """ logger.error('MNE-call()') instance = kwargs.get('instance') schema = self.getSchema() filepath = instance.get_absolute_filepath() raw_fname = filepath """:only process MNE fif files""" if not filepath.endswith('.fif'): return None try: logger.error('MNE-fif image found') #handle MNE files #get raw data raw = Raw(raw_fname) metadata_dump = dict() ############################################################################### # explore some nitime timeseries features logger.error('step 1') # get start #metadata_dump['start'] = raw.t0 logger.error('step 1.0') # get sampling frequnecy metadata_dump['sampling_frequency'] = raw.info['sfreq'] logger.error('step 1.1') # get bad channel lists metadata_dump['bads'] = raw.info['bads'] logger.error('step 1.2') # get projects metadata_dump['projects'] = raw.info['projs'] # get measure date metadata_dump['measure_date'] = raw.info['meas_date'] # get measure id metadata_dump['measure_id'] = raw.info['meas_id'] # get file id logger.error('image_information ' + raw.info['file_id']) #metadata_dump['image_information'] = 'Some fixed value' #metadata_dump['image_information'] = raw.info['comps'] logger.error('step 1.2.1') metadata_dump['experimenter'] = raw.info['experimenter'] logger.error(metadata_dump['experimenter']) logger.error('step 1.2.2') metadata_dump['description'] = raw.info['description'] logger.error(metadata_dump['description']) #logger.error('step 1.2.3') #metadata_dump['proj_id'] = raw.info['proj_id'] #logger.error(metadata_dump['proj_id']) logger.error('step 1.2.3') metadata_dump['proj_name'] = raw.info['proj_name'] logger.error(metadata_dump['proj_name']) #logger.error('step 1.2.5') #metadata_dump['chs'] = raw.info['chs'] #logger.error(metadata_dump['chs']) #logger.error('step 1.2.6') #metadata_dump['secs'] = raw.info['meas_id']['secs'] #logger.error('step 1.2.7') #metadata_dump['usecs'] = raw.info['meas_id']['usecs'] #logger.error('step 1.2.8') #metadata_dump['comps'] = raw.info['comps'] #logger.error(metadata_dump['comps']) #logger.error('step 1.2.9') #metadata_dump['acq_pars'] = raw.info['acq_pars'] #logger.error(metadata_dump['acq_pars']) logger.error('step 1.2.4') metadata_dump['acq_stim'] = raw.info['acq_stim'] logger.error(metadata_dump['acq_stim']) #logger.error('step 1.2.11') #metadata_dump['dig'] = raw.info['dig'] #logger.error(metadata_dump['dig']) logger.error('step 1.2.5') metadata_dump['number_of_channels'] = raw.info['nchan'] logger.error(raw.info['nchan']) logger.error('step 1.2.6') metadata_dump['number_of_timepoints'] = raw.n_times logger.error(metadata_dump['number_of_timepoints']) logger.error('step 1.2.7') metadata_dump['channel_names'] = "".join(raw.ch_names) #STI numberOfSTI = 0 for term in raw.ch_names: if term.startswith('STI'): numberOfSTI += 1 metadata_dump['numberOfSTI'] = numberOfSTI #EOG numberOfEOG = 0 for term2 in raw.ch_names: if term2.startswith('EOG'): numberOfEOG += 1 metadata_dump['numberOfEOG'] = numberOfEOG #EEG numberOfEEG = 0 for term3 in raw.ch_names: if term3.startswith('EEG'): numberOfEEG += 1 metadata_dump['numberOfEEG'] = numberOfEEG #MEG numberOfMEG = 0 for term4 in raw.ch_names: if term4.startswith('MEG'): numberOfMEG += 1 metadata_dump['numberOfMEG'] = numberOfMEG # get duration #metadata_dump['duration'] = raw.duration # get sample duration (sampling interval) #metadata_dump['sampling_interval'] = raw.info['sampling_interval'] # get exported raw information #metadata_dump['raw_info'] = raw.metadata.keys() # get channel names (attribute added during export) #logger.error('step 1.2.10') #metadata_dump['channel_names'] = raw.ch_names #logger.error(raw.ch_names) #metadata_dump['channel_names'] = raw_ts.ch_names[:3] # get The width of the transition band of the highpass filter metadata_dump['highpass'] = raw.info['highpass'] # get The width of the transition band of the lowpass filter metadata_dump['lowpass'] = raw.info['lowpass'] logger.error('step 2') ############################################################################### #Plot graph want_meg = True want_eeg = False want_stim = False include = [] exclude = raw.info['bads'] logger.error('step 2.1') picks = mne.fiff.pick_types(raw.info, meg=want_meg, eeg=want_eeg,stim=want_stim, include=include, exclude=exclude) 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)] logger.error('step 2.2') import matplotlib.pyplot as pl pl.close('all') pl.plot(times, data.T) pl.xlabel('time (s)') pl.ylabel('MEG data (T)') logger.error('step 2.3') #outputextension = "png" #tf = tempfile.TemporaryFile(delete=False) #outputfilename = tf.name pl.savefig('/opt/mytardis/data/staging/test1.png') #tf.close() logger.error('step 2.4') previewImage64 = self.base64_encode_file('/opt/mytardis/data/staging/test1.png') #os.remove(outputfilename) logger.error('step 2.5') if previewImage64: metadata_dump['previewImage'] = previewImage64 self.saveMetadata(instance, schema, metadata_dump) except Exception, e: logger.debug(e) return None
from mne.fiff import Raw from mne.datasets import sample data_path = sample.data_path() raw_fname = data_path + '/MEG/sample/sample_audvis_filt-0-40_raw.fif' ############################################################################### # get raw data raw = Raw(raw_fname) # set picks picks = mne.fiff.pick_types(raw.info, meg=True, eeg=False, eog=False, stim=False, exclude='bads') # pick times relative to the onset of the MEG measurement. start, stop = raw.time_as_index([100, 115], use_first_samp=False) # export to nitime using a copy of the data raw_ts = raw.to_nitime(start=start, stop=stop, picks=picks, copy=True) ############################################################################### # explore some nitime timeseries features # get start print raw_ts.t0 # get duration print raw_ts.duration # get sample duration (sampling interval) print raw_ts.sampling_interval
# Instead of the actual number of components here we pass a float value # between 0 and 1 to select n_components by a percentage of # explained variance. Also we decide to use 64 PCA components before mixing # back to sensor space. These include the PCA components supplied to ICA plus # additional PCA components up to rank 64 of the MEG data. # This allows to control the trade-off between denoising and preserving signal. ica = ICA(n_components=0.90, n_pca_components=64, max_pca_components=100, noise_cov=None, random_state=0) print ica # 1 minute exposure should be sufficient for artifact detection. # However, rejection performance may significantly improve when using # the entire data range start, stop = raw.time_as_index([100, 160]) # decompose sources for raw data ica.decompose_raw(raw, start=start, stop=stop, picks=picks) print ica sources = ica.get_sources_raw(raw, start=start, stop=stop) # setup reasonable time window for inspection start_plot, stop_plot = raw.time_as_index([100, 103]) # plot components ica.plot_sources_raw(raw, start=start_plot, stop=stop_plot) ############################################################################### # Automatically find the ECG component using correlation with ECG signal.
title = 'Spatial patterns of ICA components for ECG+EOG (Magnetometers)' source_idx = range(15) ica.plot_topomap([ecg_source_idx, eog_source_idx], ch_type='mag') plt.suptitle(title, fontsize=12) ############################################################################### # Show MEG data before and after ICA cleaning. # We now add the eog artifacts to the ica.exclusion list ica.exclude += [eog_source_idx] # Restore sensor space data and keep all PCA components raw_ica = ica.pick_sources_raw(raw, include=None, n_pca_components=1.0) # let's now compare the date before and after cleaning. start_compare, stop_compare = raw.time_as_index([100, 106]) data, times = raw[picks, start_compare:stop_compare] data_clean, _ = raw_ica[picks, start_compare:stop_compare] # first the raw data plt.figure() plt.plot(times, data.T, color='r') plt.plot(times, data_clean.T, color='k') plt.xlabel('time (s)') plt.xlim(100, 106) plt.show() # now the affected channel affected_idx = raw.ch_names.index('MEG 1531') plt.figure() plt.plot(times, data[affected_idx], color='r')
def test_raw_time_as_index(): """ Test index as time conversion""" raw = Raw(fif_fname, preload=True) first_samp = raw.time_as_index([0], True)[0] assert_true(raw.first_samp == -first_samp)
data_path = sample.data_path() fname_inv = data_path + '/MEG/sample/sample_audvis-meg-oct-6-meg-inv.fif' fname_raw = data_path + '/MEG/sample/sample_audvis_raw.fif' label_name = 'Aud-lh' fname_label = data_path + '/MEG/sample/labels/%s.label' % label_name snr = 1.0 # use smaller SNR for raw data lambda2 = 1.0 / snr ** 2 method = "sLORETA" # use sLORETA method (could also be MNE or dSPM) # Load data raw = Raw(fname_raw) inverse_operator = read_inverse_operator(fname_inv) label = mne.read_label(fname_label) start, stop = raw.time_as_index([0, 15]) # read the first 15s of data # Compute inverse solution stc = apply_inverse_raw(raw, inverse_operator, lambda2, method, label, start, stop, pick_ori=None) # Save result in stc files stc.save('mne_%s_raw_inverse_%s' % (method, label_name)) ############################################################################### # View activation time-series plt.plot(1e3 * stc.times, stc.data[::100, :].T) plt.xlabel('time (ms)') plt.ylabel('%s value' % method) plt.show()