def test_fetch_atlas_destrieux_2009_atlas(): datadir = os.path.join(tmpdir, 'destrieux_2009') os.mkdir(datadir) dummy = open( os.path.join(datadir, 'destrieux2009_rois_labels_lateralized.csv'), 'w') dummy.write("name,index") dummy.close() bunch = datasets.fetch_atlas_destrieux_2009(data_dir=tmpdir, verbose=0) assert_equal(len(url_request.urls), 1) assert_equal( bunch['maps'], os.path.join(tmpdir, 'destrieux_2009', 'destrieux2009_rois_lateralized.nii.gz')) dummy = open(os.path.join(datadir, 'destrieux2009_rois_labels.csv'), 'w') dummy.write("name,index") dummy.close() bunch = datasets.fetch_atlas_destrieux_2009(lateralized=False, data_dir=tmpdir, verbose=0) assert_equal(len(url_request.urls), 1) assert_equal( bunch['maps'], os.path.join(tmpdir, 'destrieux_2009', 'destrieux2009_rois.nii.gz'))
def coordinate_label(mni_coord, atlas='aal', thresh=None, ret_proba=False): if atlas == 'aal': atl = datasets.fetch_atlas_aal() atl.prob = False elif atlas == 'harvard_oxford': atl = datasets.fetch_atlas_harvard_oxford('cort-prob-2mm') atl.prob = True elif atlas == 'destrieux': atl = datasets.fetch_atlas_destrieux_2009() atl.indices = atl.labels['index'] atl.labels = atl.labels['name'] atl.prob = False atl_map = load_img(atl.maps) atl_aff = atl_map.affine if atl.prob == True: atl_labels = atl.labels if atl.prob == False: atl_labels = atl.labels atl_indices = atl.indices labels_out = list() for coord in mni_coord: mat_coord = np.asarray(resampling.coord_transform( coord[0], coord[1], coord[2], np.linalg.inv(atl_aff)), dtype=int) if atl.prob == True and ret_proba == True: lab_out = get_prob_atlas_label(atl_map, atl_labels, mat_coord, thresh=thresh) elif atl.prob == True and ret_proba == False: lab_out, _ = get_prob_atlas_label(atl_map, atl_labels, mat_coord, thresh=thresh) elif atl.prob == False: lab_out = get_atlas_label(atl_map, atl_labels, atl_indices, mat_coord) labels_out.append(lab_out) return labels_out
def test_fetch_atlas_destrieux_2009_atlas(): datadir = os.path.join(tmpdir, 'destrieux_2009') os.mkdir(datadir) dummy = open(os.path.join( datadir, 'destrieux2009_rois_labels_lateralized.csv'), 'w') dummy.write("name,index") dummy.close() bunch = datasets.fetch_atlas_destrieux_2009(data_dir=tmpdir, verbose=0) assert_equal(len(url_request.urls), 1) assert_equal(bunch['maps'], os.path.join( tmpdir, 'destrieux_2009', 'destrieux2009_rois_lateralized.nii.gz')) dummy = open(os.path.join( datadir, 'destrieux2009_rois_labels.csv'), 'w') dummy.write("name,index") dummy.close() bunch = datasets.fetch_atlas_destrieux_2009( lateralized=False, data_dir=tmpdir, verbose=0) assert_equal(len(url_request.urls), 1) assert_equal(bunch['maps'], os.path.join( tmpdir, 'destrieux_2009', 'destrieux2009_rois.nii.gz'))
def get_atlas(name): if name == "destrieux_2009": atlas = datasets.fetch_atlas_destrieux_2009() atlas_filename = atlas['maps'] elif name == "harvard_oxford": atlas = datasets.fetch_atlas_harvard_oxford("cort-maxprob-thr25-2mm") atlas_filename = atlas['maps'] elif name == "aal": atlas = datasets.fetch_atlas_aal() atlas_filename = atlas['maps'] elif name == "smith_2009": atlas = datasets.fetch_atlas_smith_2009() atlas_filename = atlas['rsn70'] else: raise ValueError('Atlas name unkown') return atlas_filename
def add_destrieux(nl): nl.new_symbol(name="destrieux") destrieux_atlas = datasets.fetch_atlas_destrieux_2009() destrieux_atlas_image = nib.load(destrieux_atlas["maps"]) destrieux_labels = dict(destrieux_atlas["labels"]) destrieux_set = set() for k, v in destrieux_labels.items(): if k == 0: continue destrieux_set.add(( v.decode("utf8"), ExplicitVBR.from_spatial_image_label(destrieux_atlas_image, k), )) nl.add_tuple_set(destrieux_set, name="destrieux")
def setup_(self): nl = fe.NeurolangDL() destrieux_atlas = datasets.fetch_atlas_destrieux_2009() yeo_atlas = datasets.fetch_atlas_yeo_2011() img = nib.load(destrieux_atlas['maps']) aff = img.affine data = img.get_data() rset = [] for label, name in destrieux_atlas['labels']: if label == 0: continue voxels = np.transpose((data == label).nonzero()) if len(voxels) == 0: continue rset.append((name.decode('utf8'), fe.ExplicitVBR(voxels, aff, image_dim=img.shape, prebuild_tree=True))) nl.add_tuple_set(rset, name='destrieux') img = nib.load(yeo_atlas['thick_17']) aff = img.affine data = img.get_data().squeeze() rset = [] for label in range(1, 18): name = str(label) if label == 0: continue voxels = np.transpose((data == label).nonzero()) if len(voxels) == 0: continue rset.append((name, fe.ExplicitVBR(voxels, aff, image_dim=data.shape, prebuild_tree=True))) nl.add_tuple_set(rset, name='yeo') self.nl = nl
def fetch_atlases(atlas_names): """Fetch atlases provided by name(s) Parameters ---------- atlas_names : str or list of str Grab atlas from web given the name. Few are shipped with FSL and Nilearn. Valid options: ['harvard_oxford', 'destrieux', 'diedrichsen', 'juelich', 'jhu', 'mist', 'yeo_networks7', 'yeo_networks17'] Returns ------- data : dict Bunch of atlases """ data = {} atlas_names = _check_atlases(atlas_names) for atlas_name in atlas_names: if atlas_name == 'harvard_oxford': name = 'cort-maxprob-thr25-2mm' data[atlas_name] = datasets.fetch_atlas_harvard_oxford(name) elif atlas_name == 'destrieux': data[atlas_name] = datasets.fetch_atlas_destrieux_2009() elif atlas_name == 'diedrichsen': data[atlas_name] = _fetch_atlas_diedrichsen('maxprob-thr25-2mm') elif atlas_name == 'juelich': data[atlas_name] = _fetch_atlas_juelich('maxprob-thr25-2mm') elif atlas_name == 'jhu': data[atlas_name] = _fetch_atlas_jhu('labels-2mm') elif atlas_name == 'mist': data[atlas_name] = fetch_mist() elif atlas_name in ['yeo_networks7', 'yeo_networks17']: data[atlas_name] = fetch_yeo(atlas_name) else: raise ValueError("Not a valid atlas. Given atlas is exhausted") return data
os.mkdir(write_dir) # Access to the data data_dir = os.path.join(SMOOTH_DERIVATIVES, 'group') mask_gm = nib.load(os.path.join(data_dir, 'gm_mask.nii.gz')) ref_affine, ref_shape = mask_gm.affine, mask_gm.shape # df = make_db('/neurospin/ibc/smooth_derivatives') df = data_parser(derivatives=SMOOTH_DERIVATIVES, conditions=CONTRASTS) #conditions = df.contrast[df.modality == 'bold'].unique() conditions = CONTRASTS.contrast.values n_conditions = len(conditions) # Mask of the ROI # intersect with GM mask atlas = datasets.fetch_atlas_destrieux_2009() # 29: left hemisphere # 104 right hemisphere roi_index = 29 roi_mask = math_img('im1 == %d' % roi_index, im1=atlas.maps) roi_mask = resample_img(roi_mask, ref_affine, ref_shape, interpolation='nearest') masker = NiftiMasker(mask_img=roi_mask, memory=mem).fit() path_train = {} path_test = {} X_train = [] X_test = [] subjects = df.subject.unique()
def load_database(): return datasets.fetch_atlas_destrieux_2009(data_dir="neurolang_data")
def plot_vol_scatter(vol,ax=None, pointint = 2,c='b',alpha=0.6,s=12., xlim=[0,100],ylim=[0,100],zlim=[0,100],marker='o',figsize=(20,20), linewidth=0.05,show_bb=True,bb=None,bg_img=None, bg_params = {'alpha': 0.5,'s': 20.,'linewidth': 0.005,'marker':'.', 'c': 'k'}, bg_pointint=15): if type(vol) == str: if os.path.isfile(vol): img = nib.load(vol) dat = img.get_data() elif type(vol) == nib.Nifti1Image: img = vol dat = img.get_data() else: Exception('image file type not recognized') xs,ys,zs = np.nonzero(dat>0) idx = np.arange(0,xs.shape[0])#,pointint) if not ax: fig = plt.figure(figsize=figsize) ax = fig.gca(projection='3d') ax.set_aspect('equal') ax.set_xlim([xlim[0],xlim[1]]) ax.set_ylim([ylim[0],ylim[1]]) ax.set_zlim([zlim[0],zlim[1]]) ax.scatter3D(xs[idx],ys[idx],zs[idx],c=c,alpha=alpha,s=s, marker=marker,linewidths=linewidth) if bg_img == 'nilearn_destrieux': dest = fetch_atlas_destrieux_2009() bg_img = resample_to_img(nib.load(dest['maps']), img,interpolation='nearest') if bg_img != None: bg_dat = bg_img.get_data() xs,ys,zs = np.nonzero(bg_dat>0) idx = np.arange(0,xs.shape[0],bg_pointint) ax.scatter3D(xs[idx],ys[idx],zs[idx],**bg_params) if show_bb: if bb == None: bb = get_bounding_box_inds(dat) if len(bb) == 6: xmin,xmax,ymin,ymax,zmin,zmax = bb elif bb.shape == (3,2): [[xmin,xmax],[ymin,ymax],[zmin,zmax]] = bb else: Exception('Bounding box not recognized') corners = np.array(list(product([xmin,xmax], [ymin,ymax], [zmin,zmax]))) cornerpairs = list(combinations(corners,2)) linestoplot = [(s,e) for (s,e) in cornerpairs \ if ((np.abs(s-e) == 0).sum() == 2)] for (s,e) in linestoplot: ax.plot3D(*zip(s,e), color=c) return ax
# view.open_in_browser() view ############################################################################## # Impact of plot parameters on visualization # ------------------------------------------ # # You can specify arguments to be passed on to the function # :func:`nilearn.surface.vol_to_surf` using `vol_to_surf_kwargs`. This allows # fine-grained control of how the input 3D image is resampled and interpolated - # for example if you are viewing a volumetric atlas, you would want to avoid # averaging the labels between neighboring regions. Using nearest-neighbor # interpolation with zero radius will achieve this. destrieux = datasets.fetch_atlas_destrieux_2009(legacy_format=False) view = plotting.view_img_on_surf( destrieux.maps, surf_mesh="fsaverage", vol_to_surf_kwargs={ "n_samples": 1, "radius": 0.0, "interpolation": "nearest" }, symmetric_cmap=False, ) # view.open_in_browser() view
def get_labelled_atlas(query, data_dir=None, return_labels=True): """Parses input query to determine which atlas to fetch and what version of the atlas to use (if applicable). Parameters ---------- query : str Input string in the following format: nilearn:{atlas_name}:{atlas_parameters}. The following can be for `atlas_name`: 'destrieux', 'yeo', 'aal', 'talairach', and 'schaefer'. `atlas_parameters` is not available for the `destrieux` atlas. data_dir : str, optional Directory in which to save atlas data. By default None, which creates a ~/nilearn_data/ directory as per nilearn. return_labels : bool, optional Whether to return atlas labels. Default is True. Not available for the 'basc' atlas. Returns ------- str, list or None The atlas image and the accompanying labels (if provided) Raises ------ ValueError Raised when the query does is not formatted correctly or if the no match found. """ # extract parameters params = query.split(':') if len(params) == 3: _, atlas_name, sub_param = params elif len(params) == 2: _, atlas_name = params sub_param = None else: raise ValueError('Incorrect atlas query string provided') # get atlas if atlas_name == 'destrieux': atlas = fetch_atlas_destrieux_2009(lateralized=True, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'yeo': atlas = fetch_atlas_yeo_2011(data_dir=data_dir) img = atlas[sub_param] if '17' in sub_param: labels = pd.read_csv(atlas['colors_17'], sep=r'\s+')['NONE'].tolist() elif atlas_name == 'aal': version = 'SPM12' if sub_param is None else sub_param atlas = fetch_atlas_aal(version=version, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'basc': version, scale = sub_param.split('-') atlas = fetch_atlas_basc_multiscale_2015(version=version, data_dir=data_dir) img = atlas['scale{}'.format(scale.zfill(3))] labels = None elif atlas_name == 'talairach': atlas = fetch_atlas_talairach(level_name=sub_param, data_dir=data_dir) img = atlas['maps'] labels = atlas['labels'] elif atlas_name == 'schaefer': n_rois, networks, resolution = sub_param.split('-') # corrected version of schaefer labels until fixed in nilearn correct_url = ('https://raw.githubusercontent.com/ThomasYeoLab/CBIG/' 'v0.14.3-Update_Yeo2011_Schaefer2018_labelname/' 'stable_projects/brain_parcellation/' 'Schaefer2018_LocalGlobal/Parcellations/MNI/') atlas = fetch_atlas_schaefer_2018(n_rois=int(n_rois), yeo_networks=int(networks), resolution_mm=int(resolution), data_dir=data_dir, base_url=correct_url) img = atlas['maps'] labels = atlas['labels'] else: raise ValueError('No atlas detected. Check query string') if not return_labels: labels = None else: labels = labels.astype(str).tolist() return img, labels
def get_atlas_rois(atlas, roi_idx, hemisphere, res=None, path=None): """ Extract ROIs from a given atlas. Parameters ---------- atlas : str Atlas dataset to be downloaded through nilearn's dataset_fetch_atlas functionality. roi_idx: list List of int of the ROI(s) you want to extract from the atlas. If not sure, use get_atlas_info. hemisphere: list List of str, that is hemispheres of the ROI(s) you want to extract. Can be ['left'], ['right'] or ['left', 'right']. res: str Specific version of atlas to be downloaded. Only necessary for Harvard-Oxford and Talairach. Please check nilearns respective documentation at https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_harvard_oxford.html or https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_talairach.html path: str Path to where the extracted ROI(s) will be saved to. If None, ROI(s) will be saved in the current working directory. Returns ------- list_rois: list A list of the extracted ROIs. Examples -------- >>> get_atlas_rois('aal', [1, 2, 3], ['left', 'right'], path='/home/urial/Desktop') list_rois """ if atlas == 'aal': atl_ds = datasets.fetch_atlas_aal() elif atlas == 'harvard_oxford': if res is None: print( 'Please provide the specific version of the Harvard-Oxford atlas you would like to use.' ) else: atl_ds = datasets.fetch_atlas_harvard_oxford(res) elif atlas == 'destriuex': atl_ds = datasets.fetch_atlas_destrieux_2009() elif atlas == 'msdl': atl_ds = datasets.fetch_atlas_msdl() elif atlas == 'talairach': if res is None: print( 'Please provide the level of the Talairach atlas you would like to use.' ) else: atl_ds = datasets.fetch_atlas_talairach(level_name=res) elif atlas == 'pauli_2017': atl_ds = datasets.fetch_atlas_pauli_2017() if roi_idx is None: print('Please provide the indices of the ROIs you want to extract.') elif hemisphere is None: print( 'Please provide the hemisphere(s) from which you want to extract ROIs.' ) for label in roi_idx: for hemi in hemisphere: roi_ex = Node(PickAtlas(), name='roi_ex') roi_ex.inputs.atlas = atl_ds.maps roi_ex.inputs.labels = label roi_ex.inputs.hemi = hemi if path is None: roi_ex.inputs.output_file = '%s_%s_%s.nii.gz' % ( atlas, str(label), hemi) roi_ex.run() list_rois = glob('%s_*.nii.gz' % atlas) elif path: roi_ex.inputs.output_file = opj( path, '%s_%s_%s.nii.gz' % (atlas, str(label), hemi)) roi_ex.run() list_rois = glob(opj(path, '%s_*.nii.gz' % atlas)) print('The following ROIs were extracted: ') print('\n'.join(map(str, list_rois))) return list_rois
def get_atlas_info(atlas, res=None): """ Gather all information from a specified atlas, including the path to the atlas maps, as well as labels and their indexes. Parameters ---------- atlas : str Atlas dataset to be downloaded through nilearn's dataset_fetch_atlas functionality. res: str Specific version of atlas to be downloaded. Only necessary for Harvard-Oxford and Talairach. Please check nilearns respective documentation at https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_harvard_oxford.html or https://nilearn.github.io/modules/generated/nilearn.datasets.fetch_atlas_talairach.html Returns ------- atlas_info_df : pandas dataframe A pandas dataframe containing information about the ROIs and their indexes included in a given atlas. atl_ds.maps : str Path to the atlas maps. Examples -------- >>> get_atlas_info('aal') atlas_info_df atl_ds.maps """ if atlas == 'aal': atl_ds = datasets.fetch_atlas_aal() elif atlas == 'harvard_oxford': if res is None: print( 'Please provide the specific version of the Harvard-Oxford atlas you would like to use.' ) else: atl_ds = datasets.fetch_atlas_harvard_oxford(res) elif atlas == 'destriuex': atl_ds = datasets.fetch_atlas_destrieux_2009() elif atlas == 'msdl': atl_ds = datasets.fetch_atlas_msdl() elif atlas == 'talairach': if res is None: print( 'Please provide the level of the Talairach atlas you would like to use.' ) else: atl_ds = datasets.fetch_atlas_talairach(level_name=res) elif atlas == 'pauli_2017': atl_ds = datasets.fetch_atlas_pauli_2017() index = [] labels = [] for ind, label in enumerate(atl_ds.labels): index.append(ind) if atlas == 'destriuex': labels.append(label[1]) else: labels.append(label) atlas_info_df = pd.DataFrame({'index': index, 'label': labels}) return atlas_info_df, atl_ds.maps
def main( workdir, outdir, atlas, kernel, sparsity, affinity, approach, gradients, subcort, neurosynth, neurosynth_file, sleuth_file, nimare_dataset, roi_mask, term, topic, ): workdir = op.join(workdir, "tmp") if op.isdir(workdir): shutil.rmtree(workdir) os.makedirs(workdir) atlas_name = "atlas-{0}".format(atlas) kernel_name = "kernel-{0}".format(kernel) sparsity_name = "sparsity-{0}".format(sparsity) affinity_name = "affinity-{0}".format(affinity) approach_name = "approach-{0}".format(approach) gradients_name = "gradients-{0}".format(gradients) dset = None # handle neurosynth dataset, if called if neurosynth: if neurosynth_file is None: ns_data_dir = op.join(workdir, "neurosynth") dataset_file = op.join(ns_data_dir, "neurosynth_dataset.pkl.gz") # download neurosynth dataset if necessary if not op.isfile(dataset_file): neurosynth_download(ns_data_dir) else: dataset_file = neurosynth_file dset = Dataset.load(dataset_file) dataset_name = "dataset-neurosynth" # handle sleuth text file, if called if sleuth_file is not None: dset = convert_sleuth_to_dataset(sleuth_file, target="mni152_2mm") dataset_name = "dataset-{0}".format(op.basename(sleuth_file).split(".")[0]) if nimare_dataset is not None: dset = Dataset.load(nimare_dataset) dataset_name = "dataset-{0}".format(op.basename(nimare_dataset).split(".")[0]) if dset: # slice studies, if needed if roi_mask is not None: roi_ids = dset.get_studies_by_mask(roi_mask) print( "{}/{} studies report at least one coordinate in the " "ROI".format(len(roi_ids), len(dset.ids)) ) dset_sel = dset.slice(roi_ids) dset = dset_sel dataset_name = "dataset-neurosynth_mask-{0}".format( op.basename(roi_mask).split(".")[0] ) if term is not None: labels = ["Neurosynth_TFIDF__{label}".format(label=label) for label in [term]] term_ids = dset.get_studies_by_label(labels=labels, label_threshold=0.1) print( "{}/{} studies report association " "with the term {}".format(len(term_ids), len(dset.ids), term) ) dset_sel = dset.slice(term_ids) dset = dset_sel # img_inds = np.nonzero(dset.masker.mask_img.get_fdata()) # unused # vox_locs = np.unravel_index(img_inds, dset.masker.mask_img.shape) # unused dataset_name = "dataset-neurosynth_term-{0}".format(term) if topic is not None: topics = [ "Neurosynth_{version}__{topic}".format(version=topic[0], topic=topic) for topic in topic[1:] ] topics_ids = [] for topic in topics: topic_ids = dset.annotations.id[np.where(dset.annotations[topic])[0]].tolist() topics_ids.extend(topic_ids) print( "{}/{} studies report association " "with the term {}".format(len(topic_ids), len(dset.ids), topic) ) topics_ids_unique = np.unique(topics_ids) print("{} unique ids".format(len(topics_ids_unique))) dset_sel = dset.slice(topics_ids_unique) dset = dset_sel # img_inds = np.nonzero(dset.masker.mask_img.get_fdata()) # unused # vox_locs = np.unravel_index(img_inds, dset.masker.mask_img.shape) # unused dataset_name = "dataset-neurosynth_topic-{0}".format("_".join(topic[1:])) if ( neurosynth or (sleuth_file is not None) or (nimare_dataset is not None) ): # set kernel for MA smoothing if kernel == "peaks2maps": print("Running peak2maps") k = Peaks2MapsKernel(resample_to_mask=True) elif kernel == "alekernel": print("Running alekernel") k = ALEKernel(fwhm=15) if atlas is not None: if atlas == "harvard-oxford": print("Parcellating using the Harvard Oxford Atlas") # atlas_labels = atlas.labels[1:] # unused atlas_shape = atlas.maps.shape atlas_affine = atlas.maps.affine atlas_data = atlas.maps.get_fdata() elif atlas == "aal": print("Parcellating using the AAL Atlas") atlas = datasets.fetch_atlas_aal() # atlas_labels = atlas.labels # unused atlas_shape = nib.load(atlas.maps).shape atlas_affine = nib.load(atlas.maps).affine atlas_data = nib.load(atlas.maps).get_fdata() elif atlas == "craddock-2012": print("Parcellating using the Craddock-2012 Atlas") atlas = datasets.fetch_atlas_craddock_2012() elif atlas == "destrieux-2009": print("Parcellating using the Destrieux-2009 Atlas") atlas = datasets.fetch_atlas_destrieux_2009(lateralized=True) # atlas_labels = atlas.labels[3:] # unused atlas_shape = nib.load(atlas.maps).shape atlas_affine = nib.load(atlas.maps).affine atlas_data = nib.load(atlas.maps).get_fdata() elif atlas == "msdl": print("Parcellating using the MSDL Atlas") atlas = datasets.fetch_atlas_msdl() elif atlas == "surface": print("Generating surface vertices") if atlas != "fsaverage5" and atlas != "hcp": imgs = k.transform(dset, return_type="image") masker = NiftiLabelsMasker( labels_img=atlas.maps, standardize=True, memory="nilearn_cache" ) time_series = masker.fit_transform(imgs) else: # change to array for other approach imgs = k.transform(dset, return_type="image") print(np.shape(imgs)) if atlas == "fsaverage5": fsaverage = fetch_surf_fsaverage(mesh="fsaverage5") pial_left = fsaverage.pial_left pial_right = fsaverage.pial_right medial_wall_inds_left = surface.load_surf_data( "./templates/lh.Medial_wall.label" ) print(np.shape(medial_wall_inds_left)) medial_wall_inds_right = surface.load_surf_data( "./templates/rh.Medial_wall.label" ) print(np.shape(medial_wall_inds_right)) sulc_left = fsaverage.sulc_left sulc_right = fsaverage.sulc_right elif atlas == "hcp": pial_left = "./templates/S1200.L.pial_MSMAll.32k_fs_LR.surf.gii" pial_right = "./templates/S1200.R.pial_MSMAll.32k_fs_LR.surf.gii" medial_wall_inds_left = np.where( nib.load("./templates/hcp.tmp.lh.dscalar.nii").get_fdata()[0] == 0 )[0] medial_wall_inds_right = np.where( nib.load("./templates/hcp.tmp.rh.dscalar.nii").get_fdata()[0] == 0 )[0] left_verts = 32492 - len(medial_wall_inds_left) sulc_left = nib.load( "./templates/S1200.sulc_MSMAll.32k_fs_LR.dscalar.nii" ).get_fdata()[0][0:left_verts] sulc_left = np.insert( sulc_left, np.subtract( medial_wall_inds_left, np.arange(len(medial_wall_inds_left)) ), 0, ) sulc_right = nib.load( "./templates/S1200.sulc_MSMAll.32k_fs_LR.dscalar.nii" ).get_fdata()[0][left_verts:] sulc_right = np.insert( sulc_right, np.subtract( medial_wall_inds_right, np.arange(len(medial_wall_inds_right)) ), 0, ) surf_lh = surface.vol_to_surf( imgs, pial_left, radius=6.0, interpolation="nearest", kind="ball", n_samples=None, mask_img=dset.masker.mask_img, ) surf_rh = surface.vol_to_surf( imgs, pial_right, radius=6.0, interpolation="nearest", kind="ball", n_samples=None, mask_img=dset.masker.mask_img, ) surfs = np.transpose(np.vstack((surf_lh, surf_rh))) del surf_lh, surf_rh # handle cortex first coords_left = surface.load_surf_data(pial_left)[0] coords_left = np.delete(coords_left, medial_wall_inds_left, axis=0) coords_right = surface.load_surf_data(pial_right)[0] coords_right = np.delete(coords_right, medial_wall_inds_right, axis=0) print("Left Hemipshere Vertices") surface_macms_lh, inds_discard_lh = build_macms(dset, surfs, coords_left) print(np.shape(surface_macms_lh)) print(inds_discard_lh) print("Right Hemipshere Vertices") surface_macms_rh, inds_discard_rh = build_macms(dset, surfs, coords_right) print(np.shape(surface_macms_rh)) print(len(inds_discard_rh)) lh_vertices_total = np.shape(surface_macms_lh)[0] rh_vertices_total = np.shape(surface_macms_rh)[0] time_series = np.transpose(np.vstack((surface_macms_lh, surface_macms_rh))) print(np.shape(time_series)) del surface_macms_lh, surface_macms_rh if subcort: subcort_img = nib.load("templates/rois-subcortical_mni152_mask.nii.gz") subcort_vox = np.asarray(np.where(subcort_img.get_fdata())) subcort_mm = vox2mm(subcort_vox.T, subcort_img.affine) print("Subcortical Voxels") subcort_macm, inds_discard_subcort = build_macms(dset, surfs, subcort_mm) num_subcort_vox = np.shape(subcort_macm)[0] print(inds_discard_subcort) time_series = np.hstack((time_series, np.asarray(subcort_macm).T)) print(np.shape(time_series)) time_series = time_series.astype("float32") print("calculating correlation matrix") correlation = ConnectivityMeasure(kind="correlation") time_series = correlation.fit_transform([time_series])[0] print(np.shape(time_series)) if affinity == "cosine": time_series = calculate_affinity(time_series, 10 * sparsity) else: time_series = np.transpose(k.transform(dset, return_type="array")) print("Performing gradient analysis") gradients, statistics = embed.compute_diffusion_map( time_series, alpha=0.5, return_result=True, overwrite=True ) pickle.dump(statistics, open(op.join(workdir, "statistics.p"), "wb")) # if subcortical included in gradient decomposition, remove gradient scores if subcort: subcort_grads = gradients[np.shape(gradients)[0] - num_subcort_vox :, :] subcort_grads = insert(subcort_grads, inds_discard_subcort) gradients = gradients[0 : np.shape(gradients)[0] - num_subcort_vox, :] # get left hemisphere gradient scores, and insert 0's where medial wall is gradients_lh = gradients[0:lh_vertices_total, :] if len(inds_discard_lh) > 0: gradients_lh = insert(gradients_lh, inds_discard_lh) gradients_lh = insert(gradients_lh, medial_wall_inds_left) # get right hemisphere gradient scores and insert 0's where medial wall is gradients_rh = gradients[-rh_vertices_total:, :] if len(inds_discard_rh) > 0: gradients_rh = insert(gradients_rh, inds_discard_rh) gradients_rh = insert(gradients_rh, medial_wall_inds_right) grad_dict = { "grads_lh": gradients_lh, "grads_rh": gradients_rh, "pial_left": pial_left, "sulc_left": sulc_left, "pial_right": pial_right, "sulc_right": sulc_right, } if subcort: grad_dict["subcort_grads"] = subcort_grads pickle.dump(grad_dict, open(op.join(workdir, "gradients.p"), "wb")) # map the gradient to the parcels for i in range(np.shape(gradients)[1]): if atlas is not None: if atlas == "fsaverage5" or atlas == "hcp": plot_surfaces(grad_dict, i, workdir) if subcort: tmpimg = masking.unmask(subcort_grads[:, i], subcort_img) nib.save(tmpimg, op.join(workdir, "gradient-{0}.nii.gz".format(i))) else: tmpimg = np.zeros(atlas_shape) for j, n in enumerate(np.unique(atlas_data)[1:]): inds = atlas_data == n tmpimg[inds] = gradients[j, i] nib.save( nib.Nifti1Image(tmpimg, atlas_affine), op.join(workdir, "gradient-{0}.nii.gz".format(i)), ) else: tmpimg = np.zeros(np.prod(dset.masker.mask_img.shape)) inds = np.ravel_multi_index( np.nonzero(dset.masker.mask_img.get_fdata()), dset.masker.mask_img.shape ) tmpimg[inds] = gradients[:, i] nib.save( nib.Nifti1Image( np.reshape(tmpimg, dset.masker.mask_img.shape), dset.masker.mask_img.affine ), op.join(workdir, "gradient-{0}.nii.gz".format(i)), ) os.system( "python3 /Users/miriedel/Desktop/GitHub/surflay/make_figures.py " "-f {grad_image} --colormap jet".format( grad_image=op.join(workdir, "gradient-{0}.nii.gz".format(i)) ) ) output_dir = op.join( outdir, ( f"{dataset_name}_{atlas_name}_{kernel_name}_{sparsity_name}_{gradients_name}_" f"{affinity_name}_{approach_name}" ) ) shutil.copytree(workdir, output_dir) shutil.rmtree(workdir)
def process(self): raw_dir = '/'.join([self.root, 'raw']) fs_subject_dir = osp.join(raw_dir, self.raw_file_names[0], 'freesurfer/5.1') # copy .annot to SUBJECT_DIR os.system('cp {} {}'.format(osp.join(raw_dir, self.raw_file_names[2]), fs_subject_dir)) os.system('cp {} {}'.format(osp.join(raw_dir, self.raw_file_names[3]), fs_subject_dir)) # process fs outputs shell_script_path = osp.join(os.getcwd(), 'fs_preproc.sh') process_fs_output(fs_subject_dir, shell_script_path) if self.atlas == 'HCPMMP1': fs_subject_dir = osp.join(fs_subject_dir, 'all_output') # `all_output` hardcoded # phenotypic for label s3_pheno_path = '/'.join([self.root, 'raw', self.raw_file_names[1]]) pheno_df = pd.read_csv(s3_pheno_path) # load atlas for fmri if self.atlas == 'HCPMMP1': # load and transform atlas atlas_nii_file = '/'.join( [self.root, 'raw', self.raw_file_names[4]]) atlas_img = image.load_img(atlas_nii_file) # split left and right hemisphere atlas_img.get_data()[atlas_img.get_data()[:int(atlas_img.shape[0] / 2 + 1), :, :].nonzero()] += \ atlas_img.get_data().max() num_nodes = 360 elif self.atlas == 'destrieux': from nilearn.datasets import fetch_atlas_destrieux_2009 atlas_nii_file = fetch_atlas_destrieux_2009().maps atlas_img = image.load_img(atlas_nii_file) num_nodes = 148 # read FreeSurfer output anatomical_features_dict = read_fs_stats(fs_subject_dir, self.atlas) # make subject_ids subject_ids = list(anatomical_features_dict.keys()) if self.site == 'ALL': import urllib all_subject_ids_path = 'https://raw.githubusercontent.com/parisots/population-gcn/master/subject_IDs.txt' response = urllib.request.urlopen(all_subject_ids_path) all_subject_ids = [ s.decode() for s in response.read().splitlines() ] subject_ids = [s for s in subject_ids if s[-5:] in all_subject_ids] assert len(subject_ids) == 871 # process the data data_list = [] failed_subject_list = [] for subject in tqdm(subject_ids, desc='subject_list'): try: y, sex, iq, site_id, subject_id = label_from_pheno( pheno_df, subject) # read anatomical features from dict lh_df, rh_df = anatomical_features_dict[subject] node_features = torch.from_numpy( np.concatenate([ lh_df[self.anatomical_feature_names].values, rh_df[self.anatomical_feature_names].values ])).float() if node_features.shape[0] != num_nodes: # check missing nodes, for 'destrieux' continue # path for preprocessed functional MRI fmri_nii_file = '/'.join([ self.root, 'raw', 'Outputs', self.pipeline, self.strategy, self.derivative, "{}_func_preproc.nii.gz".format(subject) ]) # nilearn masker and corr masker = NiftiLabelsMasker(labels_img=atlas_img, standardize=True, memory='nilearn_cache', verbose=5) correlation_measure = ConnectivityMeasure(kind='correlation') time_series = masker.fit_transform(fmri_nii_file) # 0 in regions # for i in range(num_nodes): # assert np.any(time_series[:, i]) # handle broken file in ABIDE preprocessed filternoglobal if subject == 'UM_1_0050302': time_series = nilearn.signal.clean(time_series.transpose(), low_pass=0.1, high_pass=0.01, t_r=2).transpose() if subject == 'Leuven_2_0050730': time_series = nilearn.signal.clean(time_series.transpose(), low_pass=0.1, high_pass=0.01, t_r=1.6667).transpose() # optional data augmentation if self.resample_ts: time_series_list = resample_temporal(time_series) elif self.dfc_resample: time_series_list = window_slpit_ts(time_series, window=30, step=5) else: time_series_list = [time_series] # correlation form time series connectivity_matrix_list = correlation_measure.fit_transform( time_series_list) for adj, time_series in zip(connectivity_matrix_list, time_series_list): time_series, raw_adj = torch.tensor( time_series), torch.tensor(adj) adj_statistics = get_adj_statistics(adj) padded_time_series = torch.zeros(30, 360) padded_time_series[:time_series.shape[0]] = time_series padded_time_series = padded_time_series.t() # transform adj # np.fill_diagonal(adj, 0) # remove self-loop for transform adj = self.transform_edge( adj) if self.transform_edge is not None else adj # set a threshold for adj if self.threshold is not None: adj = top_k_percent_adj(adj, self.threshold) assert check_strongly_connected(adj) # create torch_geometric Data edge_index, edge_weight = from_scipy_sparse_matrix( coo_matrix(adj)) data = Data(x=node_features, edge_index=edge_index, edge_attr=edge_weight, y=y) # additional node feature data.adj_statistics = adj_statistics data.time_series, data.raw_adj = padded_time_series, raw_adj # phenotypic data data.sex, data.iq, data.site_id, data.subject_id = sex, iq, site_id, subject_id data.num_nodes = data.x.shape[0] data_list.append(data) except Exception as e: print(e) logging.warning("failed at subject {}".format(subject)) failed_subject_list.append(subject) # with open('failed_fmri_subject_list', 'w') as f: # f.write("\n".join(failed_subject_list)) print("failed_subject_list", failed_subject_list) if self.site == 'ALL': data_list = repermute(data_list, all_subject_ids) self.data, self.slices = self.collate(data_list) torch.save((self.data, self.slices), self.processed_paths[0])