def run_ssp(subject): print("processing subject: %s" % subject) meg_subject_dir = op.join(config.meg_dir, subject) print(" Loading runs") for run in config.runs: extension = run + '_sss_raw' raw_fname_in = op.join(meg_subject_dir, config.base_fname.format(**locals())) proj_fname_out = op.splitext(raw_fname_in)[0] + '-proj.fif' eve_ecg_fname_out = op.splitext(raw_fname_in)[0] + '_ecg-eve.fif' eve_eog_fname_out = op.splitext(raw_fname_in)[0] + '_eog-eve.fif' print("Input: ", raw_fname_in) print("Output: ", proj_fname_out) print("Output: ", eve_ecg_fname_out) print("Output: ", eve_eog_fname_out) raw = mne.io.read_raw_fif(raw_fname_in) ecg_projs, ecg_events = \ compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) eog_projs, eog_events = \ compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs) mne.write_events(eve_ecg_fname_out, ecg_events) mne.write_events(eve_eog_fname_out, eog_events)
def ssp_preprocessing(eeg, participant, session_name, reject): try: projs, eog_events = compute_proj_eog(eeg, n_grad=0, n_mag=0, n_eeg=2, reject=reject, average=True) eog_projs = projs[-2:] f_eog = mne.viz.plot_projs_topomap(eog_projs, info=eeg.info, show=False) f_eog.savefig(data_dir + 'results/EOG_projections_' + participant + '_' + session_name + '.png', dpi=500) plt.close(f_eog) eeg = eeg.add_proj(eog_projs[-1:]) eeg = eeg.apply_proj() except Exception as e: print('Problem with EOG plot:', e) return eeg
def run_ssp(subject): print("Processing subject: %s" % subject) meg_subject_dir = op.join(config.meg_dir, subject) print(" Loading one run to compute SSPs") # compute SSP on first run of raw run = config.runs[0] if config.use_maxwell_filter: extension = run + '_sss_raw' else: extension = run + '_filt_raw' raw_fname_in = op.join(meg_subject_dir, config.base_fname.format(**locals())) extension = run + '_ssp-proj' proj_fname_out = op.join(meg_subject_dir, config.base_fname.format(**locals())) print("Input: ", raw_fname_in) print("Output: ", proj_fname_out) raw = mne.io.read_raw_fif(raw_fname_in) # XXX : n_xxx should be options in config print(" Computing SSPs for ECG") ecg_projs, ecg_events = \ compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) print(" Computing SSPs for EOG") eog_projs, eog_events = \ compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject, session=None): # compute SSP on first run of raw run = config.get_runs()[0] bids_path = BIDSPath(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=run, recording=config.rec, space=config.space, extension='.fif', datatype=config.get_datatype(), root=config.deriv_root) # Prepare a name to save the data raw_fname_in = bids_path.copy().update(processing='filt', suffix='raw', check=False) # when saving proj, use run=None proj_fname_out = bids_path.copy().update(run=None, suffix='proj', check=False) msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}' logger.info( gen_log_message(message=msg, step=4, subject=subject, session=session)) if raw_fname_in.copy().update(split='01').fpath.exists(): raw_fname_in.update(split='01') raw = mne.io.read_raw_fif(raw_fname_in) # XXX : n_xxx should be options in config msg = 'Computing SSPs for ECG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) ecg_projs, ecg_events = compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) msg = 'Computing SSPs for EOG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) if config.eog_channels: assert all( [ch_name in raw.ch_names for ch_name in config.eog_channels]) ch_name = ','.join(config.eog_channels) else: ch_name = None eog_projs, eog_events = compute_proj_eog(raw, ch_name=ch_name, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject, session=None): print("Processing subject: %s" % subject) print(" Loading one run to compute SSPs") # Construct the search path for the data file. `sub` is mandatory subject_path = op.join('sub-{}'.format(subject)) # `session` is optional if session is not None: subject_path = op.join(subject_path, 'ses-{}'.format(session)) subject_path = op.join(subject_path, config.kind) # compute SSP on first run of raw run = config.runs[0] bids_basename = make_bids_basename(subject=subject, session=session, task=config.task, acquisition=config.acq, run=run, processing=config.proc, recording=config.rec, space=config.space) # Prepare a name to save the data fpath_deriv = op.join(config.bids_root, 'derivatives', config.PIPELINE_NAME, subject_path) raw_fname_in = \ op.join(fpath_deriv, bids_basename + '_filt_raw.fif') # when saving proj, use bids_basename=None bids_basename = make_bids_basename(subject=subject, session=session, task=config.task, acquisition=config.acq, run=None, processing=config.proc, recording=config.rec, space=config.space) proj_fname_out = op.join(fpath_deriv, bids_basename + '_ssp-proj.fif') print("Input: ", raw_fname_in) print("Output: ", proj_fname_out) raw = mne.io.read_raw_fif(raw_fname_in) # XXX : n_xxx should be options in config print(" Computing SSPs for ECG") ecg_projs, ecg_events = \ compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) print(" Computing SSPs for EOG") eog_projs, eog_events = \ compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def do_pca(raw, proj_nums): ecg_projs, ecg_events = compute_proj_ecg(raw_sss, n_grad=proj_nums[0][0], n_mag=proj_nums[0][1], average=True) eog_projs, eog_events = compute_proj_eog(raw_sss, n_grad=proj_nums[1][0], n_mag=proj_nums[1][1], average=True) raw_sss.info['projs'] += eog_projs + ecg_projs return raw_sss, (ecg_projs, eog_projs, ecg_events, eog_events)
def run_ssp(subject, session=None): deriv_path = config.get_subject_deriv_path(subject=subject, session=session, kind=config.get_kind()) # compute SSP on first run of raw run = config.get_runs()[0] bids_basename = make_bids_basename(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=run, processing=config.proc, recording=config.rec, space=config.space) # Prepare a name to save the data raw_fname_in = op.join(deriv_path, bids_basename + '_filt_raw.fif') # when saving proj, use bids_basename=None bids_basename = make_bids_basename(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=None, processing=config.proc, recording=config.rec, space=config.space) proj_fname_out = op.join(deriv_path, bids_basename + '_ssp-proj.fif') msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}' logger.info( gen_log_message(message=msg, step=4, subject=subject, session=session)) raw = mne.io.read_raw_fif(raw_fname_in) # XXX : n_xxx should be options in config msg = 'Computing SSPs for ECG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) ecg_projs, ecg_events = \ compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) msg = 'Computing SSPs for EOG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) eog_projs, eog_events = \ compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def preproc_gen_ssp(subj_fold, raw, hcp_params, annots): """Helper to apply artifact removal on raw data NOTE: Only use this on one run of data to create projectors. Subsequent runs should load and apply the same projectors. This is required to make sure machine learning algorithm isn't classifying differences in projectors (like the ICA projectors shipped with HCP) instead of differences in activity.""" proj_dir = op.join(hcp_path, subj_fold, 'ssp_pca_fif') check_and_create_dir(proj_dir) # Compute EOG and ECG projectors # XXX Note: do not add these to raw obj, as all raw files need to use the # same projectors. Instead, save and then reapply later preproc.set_eog_ecg_channels(raw) proj_eog1, eog_events1 = compute_proj_eog(raw, ch_name='HEOG', n_jobs=-1) proj_eog2, eog_events2 = compute_proj_eog(raw, ch_name='VEOG', n_jobs=-1) proj_ecg, ecg_events = compute_proj_ecg(raw, ch_name='ECG', n_jobs=-1) # Save to disk so these can be used in future processing all_projs = proj_eog1 + proj_eog2 + proj_ecg write_proj(op.join(proj_dir, 'preproc_all-proj.fif'), all_projs)
def run_ssp(subject, session=None): deriv_path = config.get_subject_deriv_path(subject=subject, session=session, kind=config.get_kind()) # compute SSP on first run of raw run = config.get_runs()[0] bids_basename = BIDSPath(subject=subject, session=session, task=config.get_task(), acquisition=config.acq, run=run, recording=config.rec, space=config.space, prefix=deriv_path) # Prepare a name to save the data raw_fname_in = bids_basename.copy().update(processing='filt', kind=config.get_kind(), extension='.fif') # when saving proj, use run=None proj_fname_out = bids_basename.copy().update(run=None, kind='proj', extension='.fif', check=False) msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}' logger.info( gen_log_message(message=msg, step=4, subject=subject, session=session)) raw = mne.io.read_raw_fif(raw_fname_in) # XXX : n_xxx should be options in config msg = 'Computing SSPs for ECG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) ecg_projs, ecg_events = \ compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) msg = 'Computing SSPs for EOG' logger.debug( gen_log_message(message=msg, step=4, subject=subject, session=session)) eog_projs, eog_events = \ compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
def run_ssp(subject): print("processing subject: %s" % subject) meg_subject_dir = op.join(config.meg_dir, subject) raw_fnames_in = op.join(meg_subject_dir, '%s_audvis_filt_raw.fif' % subject) proj_fnames_out = op.join(meg_subject_dir, '%s_audvis_filt-proj.fif' % subject) print(" Loading runs") for raw_fname_in, proj_fname_out in zip(raw_fnames_in, proj_fnames_out): # XXX TODO raw = mne.io.read_raw_fif(raw_fnames_in) projs, events = compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) ecg_projs = projs[-2:] projs, events = compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) eog_projs = projs[-3:] raw.info['projs'] += eog_projs + ecg_projs raw.apply_proj() raw.save(proj_fnames_out, overwrite=True)
def compute_ecg_eog_proj(raw, ecg=True, eog=True, n_grad_ecg=1, n_grad_eog=1, n_mag_ecg=1, n_mag_eog=1, average=True, vis=False, add_proj=True): if ecg: projs, events_ecg = compute_proj_ecg(raw, n_grad=n_grad_ecg, n_mag=n_mag_ecg, average=average) ecg_projs = projs[-(n_mag_ecg + n_grad_ecg):] if add_proj: raw.info['projs'] += ecg_projs if vis: layout = mne.channels.read_layout('Vectorview-all') names = [name.replace(' ', '') for name in layout.names] layout.names = names mne.viz.plot_projs_topomap(ecg_projs, layout=layout) # Now for EOG if eog: projs, events_eog = compute_proj_eog(raw, n_grad=n_grad_eog, n_mag=n_mag_eog, average=average) eog_projs = projs[-(n_mag_eog + n_grad_eog):] if add_proj: raw.info['projs'] += eog_projs if vis: layout = mne.channels.read_layout('Vectorview-all') names = [name.replace(' ', '') for name in layout.names] layout.names = names mne.viz.plot_projs_topomap(eog_projs, layout=layout) return ecg_projs, eog_projs, events_ecg, events_eog
def run_correlation(subjects_dir, subject, volume_spacing, freq): num_threads(8) frequency = str(freq) DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files') eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz' eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz' fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif' t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz') heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz' fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd-label.fif.gz' src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src-label.fif.gz' cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}-label.fif.gz' raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}-label.fif.gz' raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj-label.fif.gz' source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl' freesurfer_label = f'{DATA_DIR}/{subject}_freesurferlabel_{volume_spacing}-label.pkl' corr_true_file_label = f'{DATA_DIR}/{subject}_corr_ortho_true_{volume_spacing}_{frequency}_label.npy' check_for_files = [] check_for_files.append(corr_true_file_label) file_exist = [f for f in check_for_files if os.path.isfile(f)] file_not_exist = list(set(file_exist) ^ set(check_for_files)) if not file_not_exist: print('correlation files exists...') else: trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration file_trans = pathlib.Path(trans) file_ss = pathlib.Path(src_fname) file_fm = pathlib.Path(fwd_fname) file_proj = pathlib.Path(raw_proj) file_cov = pathlib.Path(cov_fname) file_rawcov = pathlib.Path(raw_cov_fname) t1 = nib.load(t1_fname) if not file_trans.exists(): print (f'{trans} File doesnt exist...') sys.exit(0) info = mne.io.read_info(fname_meg) # plot_registration(info, trans, subject, subjects_dir) print(file_ss) if not file_ss.exists(): src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume', volume_spacing=volume_spacing) src.save(src_fname, overwrite=True) src = mne.read_source_spaces(src_fname) #view_SS_brain(subject, subjects_dir, src) if not file_fm.exists(): forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname) fwd = mne.read_forward_solution(fwd_fname) # sensitivty_plot(subject, subjects_dir, fwd) raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True) srate = raw.info['sfreq'] n_time_samps = raw.n_times time_secs = raw.times ch_names = raw.ch_names n_chan = len(ch_names) freq_res = srate/n_time_samps print('\n') print('-------------------------- Data summary-------------------------------') print(f'Subject {subject}') print(f"Frequency resolution {freq_res} Hz") print(f"The first few channel names are {ch_names[:3]}") print(f"The last time sample at {time_secs[-1]} seconds.") print(f"Sampling Frequency (No of time points/sec) {srate} Hz") print(f"Miscellaneous acquisition info {raw.info['description']}") print(f"Bad channels marked during data acquisition {raw.info['bads']}") print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.") print('------------------------------------------------------------------------') print('\n') # raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True) if not file_proj.exists(): projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063') projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061') projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062') if projs_ecg is not None: mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors raw.info['projs'] += projs_ecg if projs_eog1 is not None: mne.write_proj(eye_proj1, projs_eog1) raw.info['projs'] += projs_eog1 if projs_eog2 is not None: mne.write_proj(eye_proj2, projs_eog2) raw.info['projs'] += projs_eog2 raw.apply_proj() raw.save(raw_proj, proj=True, overwrite=True) print(raw_proj) raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True) print(f'High-pass filtering data at 0.5 Hz') raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir') if not file_cov.exists(): cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest mne.write_cov(cov_fname, cov) cov = mne.read_cov(cov_fname) # cov.plot(raw.info, proj=True, exclude='bads', show_svd=False # raw_proj_applied.crop(tmax=10) do_epochs = False l_freq = freq-2.0 h_freq = freq+2.0 print(f'Band pass filter data [{l_freq}, {h_freq}]') raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq) if do_epochs: print('Segmenting raw data...') events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.) raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5., baseline=None, preload=True) data_cov = mne.compute_covariance(raw_proj_filtered) else: if not file_rawcov.exists(): data_cov = mne.compute_raw_covariance(raw_proj_filtered) mne.write_cov(raw_cov_fname, data_cov) else: data_cov = mne.read_cov(file_rawcov) filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov, pick_ori='max-power', weight_norm='nai') raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert() if do_epochs: stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False) else: stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True) print('Extracting label time course...') atlas = f'{subjects_dir}/{subject}/mri/aparc.a2009s+aseg.mgz' label_ts = mne.extract_label_time_course(stcs, atlas, fwd['src'], return_generator=False) label_ts = [label_ts] # Power Envelope Correlation print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize True') all_corr = envelope_correlation(label_ts, combine=None, orthogonalize="pairwise", log=True, absolute=True, verbose=None) print(f'Correlation saved to {corr_true_file_label}') np.save(corr_true_file_label, all_corr) del stcs
# Compute SSP projections # ----------------------- # # First let's do ECG. projs, events = compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) print(projs) ecg_projs = projs[-2:] mne.viz.plot_projs_topomap(ecg_projs) ############################################################################### # Now let's do EOG. Here we compute an EEG projector, and need to pass # the measurement info so the topomap coordinates can be created. projs, events = compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) print(projs) eog_projs = projs[-3:] mne.viz.plot_projs_topomap(eog_projs, info=raw.info) ############################################################################## # Apply SSP projections # --------------------- # # MNE is handling projections at the level of the info, # so to register them populate the list that you find in the 'proj' field raw.info['projs'] += eog_projs + ecg_projs #############################################################################
def raw_preprocessing(self, raw, use_ica=True, use_ssp=True): # Filter raw.info['bads'] = self.bad_channels # Remove power-line noise raw.notch_filter(np.arange(60, 241, 60), picks=self.picks, filter_length='auto', phase=self.phase) raw.filter(l_freq=self.l_freq, h_freq=self.h_freq, phase=self.phase, fir_window=self.fir_window, fir_design=self.fir_design) # Add EEG reference raw.set_eeg_reference(projection=True) # TODO: some mechanism to control this if use_ica: # supported ica_channels = ['mag', 'grad', 'eeg', 'seeg', 'ecog', 'hbo', 'hbr', 'eog'] ica_picks = mne.pick_types(raw.info, meg=True, eeg=False, eog=False, stim=False, exclude='bads') n_components = 25 decim = 3 # maximum number of components to reject n_max_ecg, n_max_eog = 3, 1 # here we don't expect horizontal EOG components # ica = run_ica(raw, n_components=0.95) ica = ICA(n_components=n_components, method='fastica', noise_cov=None) ica.fit(raw, decim=decim, picks=ica_picks, reject=self.reject) # generate ECG epochs use detection via phase statistics ecg_epochs = create_ecg_epochs(raw, reject=self.reject) ecg_inds, scores = ica.find_bads_ecg(ecg_epochs, method='ctps') ecg_inds = ecg_inds[:n_max_ecg] ica.exclude += ecg_inds # detect EOG by correlation eog_inds, scores = ica.find_bads_eog(raw) eog_inds = eog_inds[:n_max_eog] ica.exclude += eog_inds ica.apply(raw) if use_ssp: if self.ecg: ecg_projs, _ = compute_proj_ecg(raw) raw.info['projs'] += ecg_projs if self.blink: eog_projs, _ = compute_proj_eog(raw) raw.info['projs'] += eog_projs raw.apply_proj() return raw
raw_sss = maxwell_filter(raw, head_pos=head_pos, st_duration=300) raw_sss.save(raw_fname[:-4] + '_sss.fif') else: raw_sss = mne.io.read_raw_fif(raw_fname[:-4] + '_sss.fif', preload=True) # artifact correction ecg_projs, events = compute_proj_ecg(raw_sss, n_grad=3, n_mag=3, n_eeg=0, average=True) print(ecg_projs) mne.viz.plot_projs_topomap(ecg_projs) eog_projs, events = compute_proj_eog(raw_sss, n_grad=3, n_mag=3, n_eeg=0, average=True) print(eog_projs) mne.viz.plot_projs_topomap(eog_projs) raw_sss.info['projs'] += eog_projs + ecg_projs picks = pick_types(raw.info, meg=True, eeg=False, stim=False, eog=False, exclude='bads') reject = dict(mag=5e-12, grad=4000e-13) raw_filt = raw_sss.copy().pick_types(meg=True, eeg=False, stim=False,
def run_correlation(subjects_dir, subject, volume_spacing, freq, ortho_bool): num_threads(8) ortho_flag = str(ortho_bool) frequency = str(freq) DATA_DIR = Path(f'{subjects_dir}', f'{subject}', 'mne_files') eye_proj1 = f'{DATA_DIR}/{subject}_eyes1-proj.fif.gz' eye_proj2 = f'{DATA_DIR}/{subject}_eyes2-proj.fif.gz' fname_meg = f'{DATA_DIR}/{subject}_ses-rest_task-rest.fif' t1_fname = os.path.join(subjects_dir, subject, 'mri', 'T1.mgz') heartbeat_proj = f'{DATA_DIR}/{subject}_heartbeat-proj.fif.gz' fwd_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-fwd.fif.gz' src_fname = f'{DATA_DIR}/{subject}_{volume_spacing}-src.fif.gz' cov_fname = f'{DATA_DIR}/{subject}-cov_{volume_spacing}.fif.gz' raw_cov_fname = f'{DATA_DIR}/{subject}-rawcov_{volume_spacing}.fif.gz' raw_proj = f'{DATA_DIR}/{subject}_ses-rest_task-rest_proj.fif.gz' source_voxel_coords = f'{DATA_DIR}/{subject}_coords_{volume_spacing}.pkl' corr_file_acLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acLeft.npy' corr_file_scLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scLeft.npy' corr_file_vcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcLeft.npy' corr_file_mtLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtLeft.npy' corr_file_mtlLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlLeft.npy' corr_file_smcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcLeft.npy' corr_file_lpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcLeft.npy' corr_file_dpfcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcLeft.npy' corr_file_tmpcLeft = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcLeft.npy' corr_file_acRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_acRight.npy' corr_file_scRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_scRight.npy' corr_file_vcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_vcRight.npy' corr_file_mtRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtRight.npy' corr_file_mtlRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mtlRight.npy' corr_file_smcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_smcRight.npy' corr_file_lpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_lpcRight.npy' corr_file_dpfcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_dpfcRight.npy' corr_file_tmpcRight = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_tmpcRight.npy' corr_file_mpfc = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_mpfc.npy' corr_file_sma = f'{DATA_DIR}/{subject}_{ortho_flag}_{volume_spacing}_{frequency}_sma.npy' check_for_files = [] check_for_files.append(corr_file_acLeft) check_for_files.append(corr_file_scLeft) check_for_files.append(corr_file_vcLeft) check_for_files.append(corr_file_mtLeft) check_for_files.append(corr_file_mtlLeft) check_for_files.append(corr_file_smcLeft) check_for_files.append(corr_file_lpcLeft) check_for_files.append(corr_file_dpfcLeft) check_for_files.append(corr_file_tmpcLeft) check_for_files.append(corr_file_acRight) check_for_files.append(corr_file_scRight) check_for_files.append(corr_file_vcRight) check_for_files.append(corr_file_mtRight) check_for_files.append(corr_file_mtlRight) check_for_files.append(corr_file_smcRight) check_for_files.append(corr_file_lpcRight) check_for_files.append(corr_file_dpfcRight) check_for_files.append(corr_file_tmpcRight) check_for_files.append(corr_file_mpfc) check_for_files.append(corr_file_sma) file_exist = [f for f in check_for_files if os.path.isfile(f)] file_not_exist = list(set(file_exist) ^ set(check_for_files)) if not file_not_exist: print('SC, AC, VC correlation files exists...') else: trans = f'/home/senthilp/caesar/camcan/cc700/camcan_coreg-master/trans/{subject}-trans.fif' # The transformation file obtained by coregistration file_trans = pathlib.Path(trans) file_ss = pathlib.Path(src_fname) file_fm = pathlib.Path(fwd_fname) file_proj = pathlib.Path(raw_proj) file_cov = pathlib.Path(cov_fname) file_rawcov = pathlib.Path(raw_cov_fname) t1 = nib.load(t1_fname) if not file_trans.exists(): print (f'{trans} File doesnt exist...') sys.exit(0) #info = mne.io.read_info(fname_meg) # plot_registration(info, trans, subject, subjects_dir) if not file_ss.exists(): src = compute_SourceSpace(subject, subjects_dir, src_fname, source_voxel_coords, plot=True, ss='volume', volume_spacing=volume_spacing) seed_l_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Left']) seed_r_sc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SSC_Right']) seed_l_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Left']) seed_r_ac = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['AC_Right']) seed_l_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Left']) seed_r_vc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['VC_Right']) seed_l_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Left']) seed_r_mt = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MT+_Right']) seed_l_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Left']) seed_r_mtl = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MTL_Right']) seed_l_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Left']) seed_r_smc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMC_Right']) seed_l_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Left']) seed_r_lpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['LPC_Right']) seed_l_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Left']) seed_r_dpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['DPFC_Right']) seed_l_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Left']) seed_r_tmpc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['TMPC_Right']) seed_mpfc = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['MPFC_MidBrain']) seed_sma = MNI_to_MRI(subject, subjects_dir, t1, ROI_mni['SMA_MidBrain']) src_inuse = np.where(src[0]['inuse'] == 1) loc_l_sc = src_inuse[0][0] loc_r_sc = src_inuse[0][1] loc_l_ac = src_inuse[0][2] loc_r_ac = src_inuse[0][3] loc_l_vc = src_inuse[0][4] loc_r_vc = src_inuse[0][5] loc_l_mt = src_inuse[0][6] loc_r_mt = src_inuse[0][7] loc_l_mtl = src_inuse[0][8] loc_r_mtl = src_inuse[0][9] loc_l_smc = src_inuse[0][10] loc_r_smc = src_inuse[0][11] loc_l_lpc = src_inuse[0][12] loc_r_lpc = src_inuse[0][13] loc_l_dpfc = src_inuse[0][14] loc_r_dpfc = src_inuse[0][15] loc_l_tmpc = src_inuse[0][16] loc_r_tmpc = src_inuse[0][17] loc_mpfc = src_inuse[0][18] loc_sma = src_inuse[0][19] src[0]['rr'][loc_l_sc] = seed_l_sc src[0]['rr'][loc_r_sc] = seed_r_sc src[0]['rr'][loc_l_ac] = seed_l_ac src[0]['rr'][loc_r_ac] = seed_r_ac src[0]['rr'][loc_l_vc] = seed_l_vc src[0]['rr'][loc_r_vc] = seed_r_vc src[0]['rr'][loc_l_mt] = seed_l_mt src[0]['rr'][loc_r_mt] = seed_r_mt src[0]['rr'][loc_l_mtl] = seed_l_mtl src[0]['rr'][loc_r_mtl] = seed_r_mtl src[0]['rr'][loc_l_smc] = seed_l_smc src[0]['rr'][loc_r_smc] = seed_r_smc src[0]['rr'][loc_l_lpc] = seed_l_lpc src[0]['rr'][loc_r_lpc] = seed_r_lpc src[0]['rr'][loc_l_dpfc] = seed_l_dpfc src[0]['rr'][loc_r_dpfc] = seed_r_dpfc src[0]['rr'][loc_l_tmpc] = seed_l_tmpc src[0]['rr'][loc_r_tmpc] = seed_r_tmpc src[0]['rr'][loc_mpfc] = seed_mpfc src[0]['rr'][loc_sma] = seed_sma src.save(src_fname, overwrite=True) src = mne.read_source_spaces(src_fname) #view_SS_brain(subject, subjects_dir, src) if not file_fm.exists(): forward_model(subject, subjects_dir, fname_meg, trans, src, fwd_fname) fwd = mne.read_forward_solution(fwd_fname) # sensitivty_plot(subject, subjects_dir, fwd) raw = mne.io.read_raw_fif(fname_meg, verbose='error', preload=True) srate = raw.info['sfreq'] n_time_samps = raw.n_times time_secs = raw.times ch_names = raw.ch_names n_chan = len(ch_names) freq_res = srate/n_time_samps print('\n') print('-------------------------- Data summary-------------------------------') print(f'Subject {subject}') print(f"Frequency resolution {freq_res} Hz") print(f"The first few channel names are {ch_names[:3]}") print(f"The last time sample at {time_secs[-1]} seconds.") print(f"Sampling Frequency (No of time points/sec) {srate} Hz") print(f"Miscellaneous acquisition info {raw.info['description']}") print(f"Bad channels marked during data acquisition {raw.info['bads']}") print(f"Convert time in sec ( 60s ) to ingeter index {raw.time_as_index(60)}") # Convert time to indices print(f"The raw data object has {n_time_samps} time samples and {n_chan} channels.") print('------------------------------------------------------------------------') print('\n') # raw.plot(n_channels=10, scalings='auto', title='Data from arrays', show=True, block=True) if not file_proj.exists(): projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2, ch_name='ECG063') projs_eog1, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG061') projs_eog2, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='EOG062') if projs_ecg is not None: mne.write_proj(heartbeat_proj, projs_ecg) # Saving projectors raw.info['projs'] += projs_ecg if projs_eog1 is not None: mne.write_proj(eye_proj1, projs_eog1) raw.info['projs'] += projs_eog1 if projs_eog2 is not None: mne.write_proj(eye_proj2, projs_eog2) raw.info['projs'] += projs_eog2 raw.apply_proj() raw.save(raw_proj, proj=True, overwrite=True) print(raw_proj) raw_proj_applied = mne.io.read_raw_fif(raw_proj, verbose='error', preload=True) print(f'High-pass filtering data at 0.5 Hz') raw_proj_applied.filter(l_freq=0.5, h_freq=None, method='iir') if not file_cov.exists(): cov = mne.compute_raw_covariance(raw_proj_applied) # compute before band-pass of interest mne.write_cov(cov_fname, cov) cov = mne.read_cov(cov_fname) # cov.plot(raw.info, proj=True, exclude='bads', show_svd=False # raw_proj_applied.crop(tmax=10) do_epochs = False l_freq = freq-2.0 h_freq = freq+2.0 print(f'Band pass filter data [{l_freq}, {h_freq}]') raw_proj_filtered = raw_proj_applied.filter(l_freq=l_freq, h_freq=h_freq) if do_epochs: print('Segmenting raw data...') events = mne.make_fixed_length_events(raw_proj_filtered, duration=5.) raw_proj_filtered = mne.Epochs(raw_proj_filtered, events=events, tmin=0, tmax=5., baseline=None, preload=True) data_cov = mne.compute_covariance(raw_proj_filtered) else: if not file_rawcov.exists(): data_cov = mne.compute_raw_covariance(raw_proj_filtered) mne.write_cov(raw_cov_fname, data_cov) else: data_cov = mne.read_cov(file_rawcov) filters = make_lcmv(raw_proj_filtered.info, fwd, data_cov, 0.05, cov, pick_ori='max-power', weight_norm='nai') raw_proj_filtered_comp = raw_proj_filtered.apply_hilbert() if do_epochs: stcs = apply_lcmv_epochs(raw_proj_filtered_comp, filters, return_generator=False) else: stcs = apply_lcmv_raw(raw_proj_filtered_comp, filters, verbose=True) stcs = [stcs] # Power Envelope Correlation print(f'Computing Power Envelope Correlation for {subject}....Orthogonalize {ortho_flag}') all_corr = envelope_correlation(stcs, combine=None, orthogonalize=False, log=False, absolute=True, verbose=None) np.save(corr_file_scLeft, all_corr[seed_left_sc]) np.save(corr_file_acLeft, all_corr[seed_left_ac]) np.save(corr_file_vcLeft, all_corr[seed_left_vc]) np.save(corr_file_mtLeft, all_corr[seed_left_mt]) np.save(corr_file_mtlLeft, all_corr[seed_left_mtl]) np.save(corr_file_smcLeft, all_corr[seed_left_smc]) np.save(corr_file_lpcLeft, all_corr[seed_left_lpc]) np.save(corr_file_dpfcLeft, all_corr[seed_left_dpfc]) np.save(corr_file_tmpcLeft, all_corr[seed_left_tmpc]) np.save(corr_file_scRight, all_corr[seed_right_sc]) np.save(corr_file_acRight, all_corr[seed_right_ac]) np.save(corr_file_vcRight, all_corr[seed_right_vc]) np.save(corr_file_mtRight, all_corr[seed_right_mt]) np.save(corr_file_mtlRight, all_corr[seed_right_mtl]) np.save(corr_file_smcRight, all_corr[seed_right_smc]) np.save(corr_file_lpcRight, all_corr[seed_right_lpc]) np.save(corr_file_dpfcRight, all_corr[seed_right_dpfc]) np.save(corr_file_tmpcRight, all_corr[seed_right_tmpc]) np.save(corr_file_mpfc, all_corr[seed_mpfc_index]) np.save(corr_file_sma, all_corr[seed_sma_index]) del stcs
def compute_src_label_ts(subject, crop_to=[0, 250], resample_to=100., bads=None, mag_reject=5e-12, win_len=2000, n_wins=11, verbose=None, lambda2=1. / 9., inv_method='dSPM', extract_ts_mode='mean_flip'): """ Compute source label time series """ """ Compute anatomy """ hcp.make_mne_anatomy(subject, subjects_dir=subjects_dir, hcp_path=hcp_path, recordings_path=hcp_path) """ Read surface labels """ labels = read_labels_from_annot(subject, parc='aparc', subjects_dir=subjects_dir) labels_fsav = read_labels_from_annot('fsaverage', parc='aparc', subjects_dir=subjects_dir) """ Read raw data """ raw = hcp.read_raw(subject=subject, data_type=data_type, hcp_path=hcp_path, run_index=run_index) raw.load_data() raw.crop(crop_to[0], crop_to[1]) raw.resample(resample_to) raw.info['bads'] = bads hcp.preprocessing.set_eog_ecg_channels(raw) hcp.preprocessing.apply_ref_correction(raw) info = raw.info.copy() raw.info['projs'] = [] ecg_ave = create_ecg_epochs(raw).average() eog_ave = create_eog_epochs(raw).average() ssp_eog, _ = compute_proj_eog(raw, n_grad=1, n_mag=1, average=True, reject=dict(mag=mag_reject)) raw.add_proj(ssp_eog, remove_existing=True) n_fft = next_fast_len(int(round(4 * raw.info['sfreq']))) sfreq = raw.info['sfreq'] """ Compute forward model """ src_outputs = hcp.anatomy.compute_forward_stack( subject=subject, subjects_dir=subjects_dir, hcp_path=hcp_path, recordings_path=hcp_path, src_params=dict(add_dist=False), info_from=dict(data_type=data_type, run_index=run_index)) fwd = src_outputs['fwd'] """ Compute noise covariance """ raw_noise = hcp.read_raw(subject=subject, hcp_path=hcp_path, data_type='noise_empty_room') raw_noise.load_data() hcp.preprocessing.apply_ref_correction(raw_noise) raw_noise.add_proj(ssp_eog) noise_cov = compute_raw_covariance(raw_noise, method='oas') """ Compute inverse operator """ raw.info = info inv_op = make_inverse_operator(raw.info, forward=fwd, noise_cov=noise_cov, verbose=verbose) """ Compute source activity """ wins = [[0, win_len]] for i in range(n_wins): new_wins = [ wins[0][0] + (win_len * (i + 1)), wins[0][1] + (win_len * (i + 1)) ] wins.append(new_wins) raw_srcs = [] for win in wins: res = apply_inverse_raw(raw, inv_op, lambda2=lambda2, method=inv_method, label=None, start=win[0], stop=win[1], nave=1, time_func=None, pick_ori=None, buffer_size=None, prepared=False, method_params=None, verbose=verbose) raw_srcs.append(res) """ Compute source label time series """ src = inv_op['src'] label_ts = extract_label_time_course(raw_srcs, labels, src, mode=extract_ts_mode, return_generator=False) return label_ts, sfreq
#def process_maxfilter(subject): raw_fname = op.join(data_path, 'rest', 'sub-' + subject, 'meg', 'rest_raw.fif') raw = mne.io.read_raw_fif(raw_fname, preload=True) raw_length = (raw.last_samp - raw.first_samp) / raw.info['sfreq'] raw.info['bads'] += [u'MEG2113', u'MEG1941', u'MEG1412', u'MEG2331'] raw = mne.preprocessing.maxwell_filter(raw, calibration=cal, cross_talk=ctc, st_duration=35., st_correlation=.96, origin=(0., 0., 0.04)) projs_ecg, ecg_events = compute_proj_ecg(raw, n_grad=1, n_mag=2) projs_eog, eog_events = compute_proj_eog(raw, n_grad=1, n_mag=2) raw.info['projs'] += projs_ecg raw.info['projs'] += projs_eog raw.apply_proj() raw.filter(None, 45, l_trans_bandwidth='auto', h_trans_bandwidth='auto', filter_length='auto', phase='zero', fir_window='hann') cov = mne.compute_raw_covariance(raw, tmin=0, tmax=None)
subject = 'bst_resting' trans = op.join(data_path, 'MEG', 'bst_resting', 'bst_resting-trans.fif') bem = op.join(subjects_dir, subject, 'bem', subject + '-5120-bem-sol.fif') raw_fname = op.join(data_path, 'MEG', 'bst_resting', 'subj002_spontaneous_20111102_01_AUX.ds') crop_to = 60. ############################################################################## # Here we do some things in the name of speed, such as crop (which will # hurt SNR) and downsample. Then we compute SSP projectors and apply them. raw = mne.io.read_raw_ctf(raw_fname, verbose='error') raw.crop(0, crop_to).load_data().pick_types(meg=True, eeg=False).resample(80) raw.apply_gradient_compensation(3) projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2) projs_eog, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='MLT31-4407') raw.info['projs'] += projs_ecg raw.info['projs'] += projs_eog raw.apply_proj() cov = mne.compute_raw_covariance(raw) # compute before band-pass of interest ############################################################################## # Now we band-pass filter our data and create epochs. raw.filter(14, 30) events = mne.make_fixed_length_events(raw, duration=5.) epochs = mne.Epochs(raw, events=events, tmin=0, tmax=5., baseline=None, reject=dict(mag=8e-13), preload=True) del raw ##############################################################################
eog_evoked.plot_joint() ############################################################################### # Just like we did with the heartbeat artifact, we can compute SSP projectors # for the ocular artifact using `~mne.preprocessing.compute_proj_eog`, # which again takes a `~mne.io.Raw` object as input and returns the # requested number of projectors for magnetometers, gradiometers, and EEG # channels (default is two projectors for each channel type). This time, we'll # pass ``no_proj`` parameter (so we get back only the new EOG projectors, not # also the existing projectors in the `~mne.io.Raw` object), and we'll # ignore the events array by assigning it to ``_`` (the conventional way of # handling unwanted return elements in Python). eog_projs, _ = compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, reject=None, no_proj=True) ############################################################################### # Just like with the empty-room and ECG projectors, we can visualize the scalp # distribution: mne.viz.plot_projs_topomap(eog_projs, info=raw.info) ############################################################################### # Now we repeat the plot from above (with empty room and ECG projectors) and # compare it to a plot with empty room, ECG, and EOG projectors, to see how # well the ocular artifacts have been repaired: for title in ('Without', 'With'):
subject = 'bst_resting' trans = op.join(data_path, 'MEG', 'bst_resting', 'bst_resting-trans.fif') bem = op.join(subjects_dir, subject, 'bem', subject + '-5120-bem-sol.fif') raw_fname = op.join(data_path, 'MEG', 'bst_resting', 'subj002_spontaneous_20111102_01_AUX.ds') crop_to = 60. ############################################################################## # Here we do some things in the name of speed, such as crop (which will # hurt SNR) and downsample. Then we compute SSP projectors and apply them. raw = mne.io.read_raw_ctf(raw_fname, verbose='error') raw.crop(0, crop_to).pick_types(meg=True, eeg=False).load_data().resample(80) raw.apply_gradient_compensation(3) projs_ecg, _ = compute_proj_ecg(raw, n_grad=1, n_mag=2) projs_eog, _ = compute_proj_eog(raw, n_grad=1, n_mag=2, ch_name='MLT31-4407') raw.info['projs'] += projs_ecg raw.info['projs'] += projs_eog raw.apply_proj() cov = mne.compute_raw_covariance(raw) # compute before band-pass of interest ############################################################################## # Now we band-pass filter our data and create epochs. raw.filter(14, 30) events = mne.make_fixed_length_events(raw, duration=5.) epochs = mne.Epochs(raw, events=events, tmin=0, tmax=5., baseline=None,
if pieces[-15:] == 'tsss_mc_EOG.fif': final_path = subject_folder + pieces print(final_path) raw = mne.io.read_raw_fif(final_path, preload=True) projection_ecg, ecg_events = compute_proj_ecg(raw, reject=reject, l_freq=1, h_freq=100, tstart=5, ecg_h_freq=25, ecg_l_freq=1, average=True, ch_name='MEG1541') projection_eog, eog_events = compute_proj_eog(raw, reject=reject, l_freq=1, h_freq=40, average=True) raw_ecg_removed = raw.add_proj(projection_ecg, remove_existing=True) raw_all_removed = raw_ecg_removed.add_proj(projection_eog) save_path = subject_folder + pieces[:-4] + '_ssp.fif' print(save_path) raw_all_removed.apply_proj().save(save_path, overwrite=True) del projection_ecg, ecg_events, projection_eog, eog_events del raw_ecg_removed, raw_all_removed log.write(subject + ' processed\n') # second loop for the rest for subject in dirnames: subject_folder = root_path + subject + '/'
def run_ssp(*, cfg, subject, session=None): # compute SSP on first run of raw bids_path = BIDSPath(subject=subject, session=session, task=cfg.task, acquisition=cfg.acq, run=cfg.runs[0], recording=cfg.rec, space=cfg.space, extension='.fif', datatype=cfg.datatype, root=cfg.deriv_root) # Prepare a name to save the data raw_fname_in = bids_path.copy().update(processing='filt', suffix='raw', check=False) # when saving proj, use run=None proj_fname_out = bids_path.copy().update(run=None, suffix='proj', check=False) msg = f'Input: {raw_fname_in}, Output: {proj_fname_out}' logger.info(**gen_log_kwargs(message=msg, subject=subject, session=session)) if raw_fname_in.copy().update(split='01').fpath.exists(): raw_fname_in.update(split='01') raw = mne.io.read_raw_fif(raw_fname_in) msg = 'Computing SSPs for ECG' logger.debug(**gen_log_kwargs(message=msg, subject=subject, session=session)) ecg_projs = [] ecg_epochs = create_ecg_epochs(raw) if len(ecg_epochs) >= config.min_ecg_epochs: if cfg.ssp_reject_ecg == 'autoreject_global': reject_ecg_ = config.get_ssp_reject( ssp_type='ecg', epochs=ecg_epochs) ecg_projs, _ = compute_proj_ecg(raw, average=cfg.ecg_proj_from_average, reject=reject_ecg_, **cfg.n_proj_ecg) else: reject_ecg_ = config.get_ssp_reject( ssp_type='ecg', epochs=None) ecg_projs, _ = compute_proj_ecg(raw, average=cfg.ecg_proj_from_average, reject=reject_ecg_, **cfg.n_proj_ecg) if not ecg_projs: msg = ('Not enough ECG events could be found. No ECG projectors are ' 'computed.') logger.info(**gen_log_kwargs(message=msg, subject=subject, session=session)) msg = 'Computing SSPs for EOG' logger.debug(**gen_log_kwargs(message=msg, subject=subject, session=session)) if cfg.eog_channels: ch_names = cfg.eog_channels assert all([ch_name in raw.ch_names for ch_name in ch_names]) else: ch_names = None eog_projs = [] eog_epochs = create_eog_epochs(raw) if len(eog_epochs) >= config.min_eog_epochs: if cfg.ssp_reject_eog == 'autoreject_global': reject_eog_ = config.get_ssp_reject( ssp_type='eog', epochs=eog_epochs) eog_projs, _ = compute_proj_eog(raw, average=cfg.eog_proj_from_average, reject=reject_eog_, **cfg.n_proj_eog) else: reject_eog_ = config.get_ssp_reject( ssp_type='eog', epochs=None) eog_projs, _ = compute_proj_eog(raw, average=cfg.eog_proj_from_average, reject=reject_eog_, **cfg.n_proj_eog) if not eog_projs: msg = ('Not enough EOG events could be found. No EOG projectors are ' 'computed.') logger.info(**gen_log_kwargs(message=msg, subject=subject, session=session)) mne.write_proj(proj_fname_out, eog_projs + ecg_projs)
# Compute SSP projections # ----------------------- # # First let's do ECG. projs, events = compute_proj_ecg(raw, n_grad=1, n_mag=1, n_eeg=0, average=True) print(projs) ecg_projs = projs[-2:] mne.viz.plot_projs_topomap(ecg_projs) ############################################################################### # Now let's do EOG. Here we compute an EEG projector, and need to pass # the measurement info so the topomap coordinates can be created. projs, events = compute_proj_eog(raw, n_grad=1, n_mag=1, n_eeg=1, average=True) print(projs) eog_projs = projs[-3:] mne.viz.plot_projs_topomap(eog_projs, info=raw.info) ############################################################################## # Apply SSP projections # --------------------- # # MNE is handling projections at the level of the info, # so to register them populate the list that you find in the 'proj' field raw.info['projs'] += eog_projs + ecg_projs #############################################################################
raw.pick_channels(chan_list) # set eog channels raw.set_channel_types({'LOc':'eog','ROc':'eog'}) # load the montage to the raw object raw.set_montage(montage) # we don't filter the eog channels picks=mne.pick_types(raw.info,meg=False,eeg=True,eog=False,stim=False) raw.filter(None,100,l_trans_bandwidth=0.01, h_trans_bandwidth='auto',filter_length=30,picks=picks,)#n_jobs=4) raw.notch_filter(np.arange(60,241,60), picks=picks) # re-reference to the average raw.set_eeg_reference().apply_proj() # compute the eog projects, and here is one parameter we will tune: n_eeg. # too high will throw away too much signal with the noise, but too low, we # will keep too much noise projs, events = compute_proj_eog(raw, n_eeg=3, average=True,reject={'eeg':80,'eog':100},)#n_jobs=4) #layout = mne.channels.find_layout(raw.info,ch_type='eeg') #mne.viz.plot_projs_topomap(projs,layout) raw.info['projs'] += projs[1:] raw.apply_proj() # apply projects fileName = raw_file[:-5] raw.save(saving_dir + fileName+'_raw_ssp.fif',proj=True,overwrite=True) del raw #noise_cov=mne.compute_raw_covariance(raw,picks=picks) working_dir = 'D:\\NING - spindle\\' saving_dir = 'D:\\NING - spindle\\training set\\' sub_folders = [f for f in os.listdir(working_dir) if ('suj' in f)] vhdrs = [] for suj_folder in sub_folders: