def adaptive_parcellation(fwd, inv, subject, subjects_dir, hemi='both'): """ """ # Magic happens # res = mne.minimum_norm.make_inverse_resolution_matrix(fwd, inv) # ... # However, here's a magicless example labels_aparc = mne.read_labels_from_annot(subject, parc='aparc', hemi='lh', subjects_dir=subjects_dir) # add frontal pole label to lh vertices = labels_aparc[5].vertices label1 = mne.Label(vertices, hemi='lh', name='frontalpole', subject=subject, color=(1,0,0,1)) # add label of rightmost vertices to rh vertices = inv['src'][1]['vertno'] vertices = [vv for vv in vertices if inv['src'][1]['rr'][vv, 0] > 0.05] label2 = mne.Label(vertices, hemi='rh', name='lateral', subject=subject, color=(0,1,0,1)) label2 = label2.fill(inv['src']) labels = [label1, label2] return labels
def merge_labels(subject, fmri_names): utils.delete_folder_files(op.join(MMVT_DIR, subject, 'fmri', 'labels')) vertices_labels_lookup = utils.load( op.join(MMVT_DIR, subject, 'aparc.DKTatlas40_vertices_labels_lookup.pkl')) output_fol = utils.make_dir(op.join(MMVT_DIR, subject, 'fmri', 'labels')) for fmri_name in fmri_names: labels = [] for hemi in utils.HEMIS: surf_fname = op.join( MMVT_DIR, subject, 'fmri', 'fmri_{}_{}.npy'.format( fmri_name.replace('_insulaopercula', ''), hemi)) surf_data = np.load(surf_fname) vertices_indices = np.where(surf_data >= 0.95)[0] if len(vertices_indices) == 0: continue insulaopercula_vertices = [] vertices, _ = utils.read_pial(subject, MMVT_DIR, hemi) for vert_ind in tqdm(vertices_indices): vert_label = vertices_labels_lookup[hemi][vert_ind] if vert_label.startswith( 'insula' ): # or vert_label.startswith('parsopercularis') insulaopercula_vertices.append(vert_ind) label = mne.Label(insulaopercula_vertices, vertices[insulaopercula_vertices], hemi=hemi, name=fmri_name, subject=subject) labels.append(label) label.save(op.join(output_fol, '{}.label'.format(fmri_name))) anat.labels_to_annot(subject, atlas=fmri_name, labels=labels) anat.calc_labeles_contours(subject, fmri_name)
def get_volume_labels(volume): labels = [] for val, vol in enumerate(volume): vertices = np.sort(vol['vertno']) pos = vol['rr'][vertices] values = np.full(len(vertices), 200 + val) if vol['seg_name'].endswith('lh'): hemi = 'lh' elif vol['seg_name'].endswith('rh'): hemi = 'rh' lab = mne.Label(vertices=vertices, pos=pos, values=values, hemi=hemi, comment=vol['seg_name'], name=vol['seg_name'], filename=None, subject=vol['subject_his_id'], verbose=None) labels.append(lab) return labels
def loadannot_gifti(parcname, subject, subjects_dir, labnam=None, surf_type='pial', surf_struct=None, quiet=False): import numpy as np from nibabel import gifti fname = os.path.join(subjects_dir, subject, 'label', 'lh.%s.%sgii' % (parcname, '%s')) fname = match_gifti_intent(fname, 'label') annot_lh = gifti.read(parse.hemineutral(fname) % 'lh') annot_rh = gifti.read(parse.hemineutral(fname) % 'rh') #unpack the annotation data labdict_lh = parse.appendhemis(annot_lh.labeltable.get_labels_as_dict(), "lh_") labv_lh = map(labdict_lh.get, annot_lh.darrays[0].data) labdict_rh = parse.appendhemis(annot_rh.labeltable.get_labels_as_dict(), "rh_") labv_rh = map(labdict_rh.get, annot_rh.darrays[0].data) labv = labv_lh + labv_rh #return labv #The objective is now to create MNE label files for these on the fly vertices = np.vstack((surf_struct.lh_verts, surf_struct.rh_verts)) mne_labels = [] for lab in labnam: cur_lab_verts = np.flatnonzero(np.array(labv) == lab) cur_lab_pos = vertices[cur_lab_verts] cur_lab = mne.Label(cur_lab_verts, pos=cur_lab_pos / 1000, hemi=lab[:2], name=parse.demangle_hemi(lab)) mne_labels.append(cur_lab) return mne_labels
def label_from_annot(sss, subject, subjects_dir, parc=None, color=(0, 0, 0)): """Label for known regions of a source space Parameters ---------- sss : mne.SourceSpaces Source space. subject : str MRI-subject. subjects_dir : str MRI subjects-directory. parc : str Parcellation name. color : matplotlib color Label color. Returns ------- label : mne.Label Label encompassing known regions of ``parc`` in ``sss``. """ fname = SourceSpace._ANNOT_PATH.format(subjects_dir=subjects_dir, subject=subject, hemi='%s', parc=parc) # find vertices for each hemisphere labels = [] for hemi, ss in zip(('lh', 'rh'), sss): annotation, _, names = read_annot(fname % hemi) bad = [-1, names.index(b'unknown')] keep = ~np.in1d(annotation[ss['vertno']], bad) if np.any(keep): label = mne.Label(ss['vertno'][keep], hemi=hemi, color=color) labels.append(label) # combine hemispheres if len(labels) == 2: lh, rh = labels return lh + rh elif len(labels) == 1: return labels.pop(0) else: raise RuntimeError("No vertices left")
def create_functional_rois(subject, contrast_name, clusters_labels_fname='', func_rois_folder=''): if clusters_labels_fname == '': clusters_labels = utils.load( op.join(BLENDER_ROOT_DIR, subject, 'fmri', 'clusters_labels_{}.npy'.format(contrast_name))) if func_rois_folder == '': func_rois_folder = op.join(SUBJECTS_DIR, subject, 'mmvt', 'fmri', 'functional_rois', '{}_labels'.format(contrast_name)) utils.delete_folder_files(func_rois_folder) for cl in clusters_labels: cl_name = 'fmri_{}_{:.2f}'.format(cl['name'], cl['max']) new_label = mne.Label(cl['vertices'], cl['coordinates'], hemi=cl['hemi'], name=cl_name, filename=None, subject=subject, verbose=None) new_label.save(op.join(func_rois_folder, cl_name))
# let's plot this matrix fig, ax = plt.subplots(figsize=(4, 4)) ax.imshow(corr, cmap='viridis', clim=np.percentile(corr, [5, 95])) fig.tight_layout() ############################################################################## # Compute the degree and plot it # ------------------------------ # sphinx_gallery_thumbnail_number = 2 threshold_prop = 0.15 # percentage of strongest edges to keep in the graph degree = mne.connectivity.degree(corr, threshold_prop=threshold_prop) stc = mne.labels_to_stc(labels, degree) stc = stc.in_label( mne.Label(inv['src'][0]['vertno'], hemi='lh') + mne.Label(inv['src'][1]['vertno'], hemi='rh')) brain = stc.plot(clim=dict(kind='percent', lims=[75, 85, 95]), colormap='gnuplot', subjects_dir=subjects_dir, views='dorsal', hemi='both', smoothing_steps=25, time_label='Beta band') ############################################################################## # References # ---------- # .. [1] Hipp JF, Hawellek DJ, Corbetta M, Siegel M, Engel AK (2012) # Large-scale cortical correlation structure of spontaneous # oscillatory activity. Nature Neuroscience 15:884–890
labels = mne.labels_from_parc('fsaverage', parc='Yeo2011_7Networks_N1000')[0] net_labels = labels[:-2] # the last two are the medial wall # fill them in so we can morph them later for label in net_labels: label.values.fill(1.0) labels = mne.labels_from_parc('fsaverage', parc='aparc')[0] # because the labels represent the whole network, I'll need to compute connecitvity among all sources within the label, instead of extracting one time course per label. But that turned out to be a HUGE matrix, so let's identify the intersection of aparc labels and Yeo labels, and just use those. But we need to compute the intersection using fsaverage, to make sure every subject has the same number of labels. avg_intersects = [] for net in net_labels: label_intersect = [] for l in labels: verts_in_both = np.intersect1d(l.vertices, net.vertices) if len(verts_in_both) > 0: label_intersect.append( mne.Label(vertices=verts_in_both, hemi=net.hemi, subject=net.subject, name=net.name)) avg_intersects.append(label_intersect) for subj in subjs[95:115]: er_fname = empty_room_dir + 'empty_room_' + closest_empty_room[ subj] + '_raw.fif' raw_fname = data_dir + 'fifs/rest/%s_rest_LP100_CP3_DS300_raw.fif' % subj fwd_fname = data_dir + 'analysis/rest/%s_rest_LP100_CP3_DS300_raw-5-fwd.fif' % subj forward = mne.read_forward_solution(fwd_fname, surf_ori=True) raw = mne.fiff.Raw(raw_fname, preload=True, compensation=3) er_raw = mne.fiff.Raw(er_fname, preload=True, compensation=3) picks = mne.fiff.pick_channels_regexp(raw.info['ch_names'], 'M..-*') raw.filter(l_freq=1, h_freq=50, picks=picks) er_raw.filter(l_freq=1, h_freq=50, picks=picks)
#%% find eye and arm vertices of primary motor cortex eyelabels = {} armlabels = {} for hemi in ['lh', 'rh']: mlabels = mne.read_labels_from_annot('fsaverage', parc='HCPMMP1_motor', hemi=hemi) m1label, = mne.read_labels_from_annot('fsaverage', parc='HCPMMP1_5_8', hemi=hemi, regexp='_4_') get_label = lambda pat: [label for label in mlabels if label.name.find(pat) >= 0][0] eyelabels[hemi] = mne.Label( np.intersect1d(m1label.vertices, get_label('Ocular').vertices), hemi=hemi, name='M1_eye', subject=m1label.subject) armlabels[hemi] = mne.Label( np.intersect1d(m1label.vertices, get_label('UpperExtremity').vertices), hemi=hemi, name='M1_arm', subject=m1label.subject) #%% load data subjects = helpers.find_available_subjects(megdatadir=helpers.megdatadir) srcfile = os.path.join(ss.bem_dir, srcfile) epochs_mean = pd.read_hdf(srcfile, 'epochs_mean') epochs_std = pd.read_hdf(srcfile, 'epochs_std')
temp = temp3.in_label(V1_label_lh) v1_vertices = temp.vertices[0] ############################################################################### """ Just to visualize the new ROI """ mask = np.logical_and(times >= 0.08, times <= 0.12) lh_label = temp3.in_label(V1_label_lh) data = np.max(lh_label.data[:,mask],axis=1) lh_label.data[data < 1.72] = 0. temp_labels, _ = mne.stc_to_label(lh_label, src='fsaverage', smooth=False, subjects_dir=fs_dir, connected=False) temp = temp3.in_label(temp_labels) v1_vertices = temp.vertices[0] new_label = mne.Label(v1_vertices, hemi='lh') brain3_1.add_label(new_label, borders=True, color='k') ############################################################################### mask = np.logical_and(times >= 0.38, times <= 0.42) lh_label = temp3.in_label(TE2p_label_lh) data = np.mean(lh_label.data[:,mask],axis=1) lh_label.data[data < 1.72] = 0. temp_labels, _ = mne.stc_to_label(lh_label, src='fsaverage', smooth=False, subjects_dir=fs_dir, connected=False) temp = temp3.in_label(temp_labels) ventral_vertices = temp.vertices[0] lh_label = temp3.in_label(PH_label_lh) data = np.mean(lh_label.data[:,mask],axis=1) lh_label.data[data < 1.72] = 0.
def simulate_raw_data(self): """ Simulates raw data """ def expand_sim_stc_data(orig_times, t_index, data, interval): template = np.zeros((data.shape[0], len(orig_times))) template[:, t_index:t_index + interval] = data return template print("Generating simulated raw data...") if not self.data_template: self.data_template = self.__create_data_template() if self.n_dipoles == 1: time_steps = int(self.samples_per_dipole * self.spacing_t_steps * (1 + self.empty_signal)) else: time_steps = int(self.samples_per_dipole * (self.n_simulations + self.spacing_t_steps) * (1 + self.empty_signal)) data_template = self.data_template.copy() data_template = data_template.crop( 0., data_template.times[time_steps]) # Crop a suitable piece of data t_delta = np.mean(np.gradient(data_template.times)) times = np.arange(time_steps) * t_delta sim_stc = simulate_sparse_stc( self.src, n_dipoles=0, times=times, data_fun=self.data_func) # Create empty time series s = 0 lh_labels = mne.Label(self.lh_labels, hemi="lh") rh_labels = mne.Label(self.rh_labels, hemi="rh") lh_labels.values = np.zeros(lh_labels.values.shape) rh_labels.values = np.zeros(rh_labels.values.shape) # TODO: selection of hemisphere(s) self.times_per_dipole = int(self.samples_per_dipole * (1 + self.empty_signal)) if self.n_dipoles == 1: print( "Simulating 1 dipole in each vertex of the right hemisphere.") for rh in range(0, len(rh_labels.values)): template = sim_stc.copy() #lh_labels2 = lh_labels #lh_labels2.values[rh] = 1. rh_labels2 = rh_labels rh_labels2.values[rh] = 1. sim_stc2 = simulate_sparse_stc( self.src, n_dipoles=1, times=times[s:s + self.times_per_dipole], data_fun=self.data_func, labels=[rh_labels2]) # TODO: use labels for deterministically simulating all vertices sim_stc.expand(sim_stc2.vertices), sim_stc2.expand( sim_stc.vertices), template.expand(sim_stc2.vertices) template.data[:, :] = expand_sim_stc_data( times, s, sim_stc2.data, self.times_per_dipole) sim_stc += template s += self.times_per_dipole else: print("Simulating up to %s dipoles on the right hemisphere." % self.n_dipoles) for t in range(0, len(times), self.times_per_dipole): template = sim_stc.copy() dipoles = random.randint(2, self.n_dipoles) label_indices = sorted( random.sample(range(0, len(rh_labels)), dipoles)) chosen_label = rh_labels chosen_labels = [] for l in label_indices: chosen_label.values[l] = 1. chosen_labels.append(chosen_label) chosen_label.values[l] = 0. # TODO there may be a bug in MNE-Python 0.14.1 where forward model dipoles are mapped to non-unique # source space vertices, e.g. in this case rh vertices 298 and 411 both map to source space vertex # 112071 which raises an error in source_estimate.py at line 434 try: sim_stc2 = simulate_sparse_stc( self.src, n_dipoles=dipoles, times=times[t:t + self.times_per_dipole], data_fun=self.data_func, labels=chosen_labels) except ValueError: s -= self.times_per_dipole continue sim_stc.expand(sim_stc2.vertices), sim_stc2.expand( sim_stc.vertices), template.expand(sim_stc2.vertices) template.data[:, :] = expand_sim_stc_data( times, t, sim_stc2.data, self.times_per_dipole) sim_stc.data[:, :] = sim_stc.data + template.data t += 1 if s >= self.n_simulations: break # Remove unnecessary zeros from series # sim_stc._data = sim_stc.data[:, ~np.all(abs(sim_stc.data) < 1e-20, axis=0)] # TODO: add some zeroes to compensate? #sim_stc.times = sim_stc.times[:sim_stc.data.shape[1]] #template_times = np.arange(sim_stc.data.shape[1]) * (t_delta * (1 + self.empty_signal)) #data_template = data_template.crop(0., template_times[-1]) self.sim_data = simulate_raw(data_template, sim_stc, self.trans_path, self.src, self.bem_path, cov='simple', iir_filter=self.iir_filter, ecg=self.ecg, blink=self.blink, n_jobs=CPU_THREADS, verbose=self.verbose, use_cps=True) # self.cov = self.compute_covariance(self.simulate_evokeds(self.sim_data)) self.sim_data = self.raw_preprocessing(self.sim_data) self.sim_stc = sim_stc self.cov = mne.compute_raw_covariance(self.sim_data, reject=self.reject, n_jobs=CPU_THREADS) return self.sim_data, self.sim_stc
w_vertices = PGi_label_lh.vertices temp = PGs_label_lh.vertices w_vertices = np.unique(np.append(w_vertices, temp)) """ V1 """ v1_vertices = V1_label_lh.vertices os.chdir(os.path.join(raw_dir, session1[n])) os.chdir('inverse') fn = 'Conditions_40-sss_eq_' + session1[n] + '-ave.fif' fn_inv = session1[n] + '-inv.fif' inv = mne.minimum_norm.read_inverse_operator(fn_inv, verbose=None) temp_frontal_label_lh = mne.Label(broca_vertices, hemi='lh', subject=subs[n]) temp_temporal_label_lh = mne.Label(w_vertices, hemi='lh', subject=subs[n]) temp_ventral_label_lh = mne.Label(ventral_vertices, hemi='lh', subject=subs[n]) temp_v1_label_lh = mne.Label(v1_vertices, hemi='lh', subject=subs[n]) frontal_label_lh = temp_frontal_label_lh.morph(subject_from='fsaverage', subject_to=subs[n], subjects_dir=fs_dir, n_jobs=18) temporal_label_lh = temp_temporal_label_lh.morph(subject_from='fsaverage', subject_to=subs[n], subjects_dir=fs_dir, n_jobs=18)
# compute ROI level envelop power aec = envelope_correlation(label_ts) assert aec.shape == (len(rois), len(rois)) # compute ROI laplacian as per Ginset # TODO cite paper _, deg_lap = csgraph.laplacian(aec, return_diag=True) data[si, ix] = deg_lap # compute ROI degree degree = mne.connectivity.degree(aec, threshold_prop=0.2) # if not np.allclose(deg_lap, degree): # warnings.warn("mne.connectivity.degree NOT equal to laplacian") stc = mne.labels_to_stc(rois, degree) stc = stc.in_label( mne.Label(inv["src"][0]["vertno"], hemi="lh") + mne.Label(inv["src"][1]["vertno"], hemi="rh") ) morph = mne.compute_source_morph( stc, subject_from=None, subject_to="fsaverage", subjects_dir=defaults.subjects_dir, ) a_lst[kk].append(morph.apply(stc)) A_lst.append(a_lst) arrayostcs = np.array([[v[ii] for ii in defaults.bands] for v in A_lst]).squeeze() src = mne.read_source_spaces( op.join(defaults.subjects_dir, "fsaverage", "bem", "fsaverage-oct6-src.fif") )
vertnos = used_nodes[used_vertnos] return vertnos closes_vertnos = closest_nodes(stim_coords['surf'], surf[0], fwd['src'][0]['vertno']) stim_vert = surf[0][closes_vertnos] pulse = 5e-6 def data_fun(times): data = np.hstack((np.repeat(0, 1000), -pulse, -pulse, pulse, pulse, np.repeat(0, 997))) return data times = np.linspace(-0.5, 0.5, 2001) lab = mne.Label(closes_vertnos, subject=subj, pos=stim_vert, hemi='lh', name='stim') stc = simulate_sparse_stc(fwd1['src'], n_dipoles=1, times=times, location='center', subject=subj, subjects_dir=subjects_dir, random_state=42, labels=[lab], data_fun=data_fun) plot_sparse_source_estimates(fwd1['src'], stc, high_resolution=True) fwd['src'].plot(trans=trans, subjects_dir=subjects_dir) info['sfreq'] = 2000 #iir_filter = fit_iir_model_raw(raw, order=5, picks=picks, tmin=60, tmax=180)[1] nave = 30 # simulate average of 100 epochs evoked_sim = simulate_evoked(fwd, stc, info, cov, nave=nave, use_cps=True, iir_filter=None)