def test_002(self): from roistats import collect from nilearn import plotting as nip from nilearn import image from nilearn import datasets from roistats import atlases, plotting import random import numpy as np import pandas as pd atlas = datasets.load_mni152_brain_mask() atlas_fp = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr50-2mm')['maps'] try: labels = atlases.labels('HarvardOxford-Cortical.xml') except Exception: from nilearn import datasets name = 'cort-maxprob-thr50-2mm' labels = datasets.fetch_atlas_harvard_oxford(name)['labels'] # Store them in a dict labels = dict(enumerate(labels)) print(atlas_fp) images = [] for i in range(0, 50): d = np.random.rand(*atlas.dataobj.shape) * atlas.dataobj im = image.new_img_like(atlas, d) im = image.smooth_img(im, 5) _, f = tempfile.mkstemp(suffix='.nii.gz') im.to_filename(f) images.append(f) for each in images[:3]: nip.plot_roi(atlas_fp, bg_img=each) df = collect.roistats_from_maps(images, atlas_fp, subjects=None) df = df.rename(columns=labels) df['group'] = df.index df['age'] = df.apply(lambda row: random.random()*5+50, axis=1) df['group'] = df.apply(lambda row: row['group'] < len(df)/2, axis=1) df['index'] = df.index plotting.boxplot('Temporal Pole', df, covariates=['age'], by='group') _ = plotting.lmplot('Temporal Pole', 'age', df, covariates=[], hue='group', palette='default') cov = df[['age', 'group']] melt = pd.melt(df, id_vars='index', value_vars=labels.values(), var_name='region').set_index('index') melt = melt.join(cov) plotting.hist(melt, by='group', region_colname='region', covariates=['age']) print('Removing images') import os for e in images: os.unlink(e)
def test_fail_fetch_atlas_harvard_oxford(): # specify non-existing atlas item assert_raises_regex(ValueError, 'Invalid atlas name', datasets.fetch_atlas_harvard_oxford, 'not_inside') # specify existing atlas item target_atlas = 'cort-maxprob-thr0-1mm' target_atlas_fname = 'HarvardOxford-' + target_atlas + '.nii.gz' HO_dir = os.path.join(tmpdir, 'fsl', 'data', 'atlases') os.makedirs(HO_dir) nifti_dir = os.path.join(HO_dir, 'HarvardOxford') os.makedirs(nifti_dir) target_atlas_nii = os.path.join(nifti_dir, target_atlas_fname) datasets.load_mni152_template().to_filename(target_atlas_nii) dummy = open(os.path.join(HO_dir, 'HarvardOxford-Cortical.xml'), 'w') dummy.write("<?xml version='1.0' encoding='us-ascii'?> " "<metadata>" "</metadata>") dummy.close() ho = datasets.fetch_atlas_harvard_oxford(target_atlas, data_dir=tmpdir) assert_true(isinstance(nibabel.load(ho.maps), nibabel.Nifti1Image)) assert_true(isinstance(ho.labels, np.ndarray)) assert_true(len(ho.labels) > 0)
def _run_interface(self, runtime): from nilearn import datasets from nilearn.input_data import NiftiLabelsMasker import numpy as np dataset = datasets.fetch_atlas_harvard_oxford( self.inputs.atlas_identifier) atlas_filename = dataset.maps masker = NiftiLabelsMasker(labels_img=atlas_filename, standardize=True, detrend=True, low_pass=0.1, high_pass=0.01, t_r=self.inputs.tr, memory='nilearn_cache', verbose=0) #file_labels = open('/home/brainlab/Desktop/Rudas/Data/Parcellation/AAL from Freesourfer/fs_default.txt', 'r') #labels = [] #for line in file_labels.readlines(): #labels.append(line) #file_labels.close() time_series = masker.fit_transform( self.inputs.in_file, confounds=self.inputs.confounds_file) np.savetxt(self.inputs.time_series_out_file, time_series, fmt='%10.2f', delimiter=',') if self.inputs.plot: from nilearn import plotting from nilearn.connectome import ConnectivityMeasure import matplotlib import matplotlib.pyplot as plt fig, ax = matplotlib.pyplot.subplots() font = {'family': 'normal', 'size': 5} matplotlib.rc('font', **font) correlation_measure = ConnectivityMeasure(kind='correlation') correlation_matrix = correlation_measure.fit_transform( [time_series])[0] # Mask the main diagonal for visualization: np.fill_diagonal(correlation_matrix, 0) plotting.plot_matrix(correlation_matrix, figure=fig, labels=dataset.labels[1:], vmax=0.8, vmin=-0.8, reorder=True) fig.savefig(self.inputs.correlation_matrix_out_file, dpi=1200) return runtime
def plot_roi(data, file_name): dataset = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') atlas_filename = dataset.maps print('Atlas ROIs are located at: %s' % atlas_filename) plotting.plot_roi(atlas_filename, title="harvard oxford altas") plotting.show() return
def _load_4D_func(self, args): if args['atlas'] == 'aal': aal = fetch_atlas_aal() aal = {'file': aal.maps} atlas_filename = aal['file'] else: harvard_oxford = fetch_atlas_harvard_oxford( 'cort-maxprob-thr25-2mm') harvard_oxford = {'file': harvard_oxford.maps} atlas_filename = harvard_oxford['file'] data = Parallel(n_jobs=args['n_cores'])(delayed( _parallelize_4D_func_loading)(f, atlas_filename, args['method']) for f in args['paths']) # Load last func for some meta-data data = np.concatenate(data, axis=0) func = nib.load(args['paths'][0]) self.voxel_idx.append(np.arange(data.shape[1])) self.affine.append(func.affine) self.data_shape.append(func.shape) feature_ids = np.ones(data.shape[1], dtype=np.uint32) * len(self.X) self.featureset_id.append(feature_ids) self.X.append(data)
def get_R_roi(ROI, R): from nilearn.datasets import fetch_atlas_harvard_oxford if ROI == 'Frontal Orbital Cortex': #Cortical atlas for Frontorbital cortex ho_atlas = fetch_atlas_harvard_oxford('cort-maxprob-thr50-2mm') else: #Subortical atlas for left and right accumbens ho_atlas = fetch_atlas_harvard_oxford('sub-maxprob-thr50-2mm') #Define ROI, incl resampling ho_map = nib.load(ho_atlas['maps']) f_ROI_indx = ho_atlas['labels'].index(ROI) ho_map_resamp = image.resample_to_img(ho_map, R, interpolation='nearest') f_ROI_bool = ho_map_resamp.get_fdata() == f_ROI_indx f_ROI_roi = nib.Nifti1Image(f_ROI_bool.astype(int), affine=ho_map_resamp.affine) R_roi = masking.apply_mask(R, f_ROI_roi) return R_roi
def roi_mean(roi_file, data_file, roi_labels=[3, 14, 9, 19, 8, 18, 5, 16, 4, 15], out_file="mean_tsnr.tsv"): """ Calculate Mean of datafile for given ROI. Parameters --------- roi_file: str Filename of Atlas/Roi_File (nifti) data_file: str Filename of data to calculate mean roi_labesl: list of int Select label of roi_file (default: 1) out_file: str Filename to write tsv-formatted output to Return ------ float: mean of roi float: std of roi """ import pdb import numpy as np import nibabel as nib from os.path import abspath from nilearn import datasets dataset_cort = datasets.fetch_atlas_harvard_oxford( 'cort-maxprob-thr25-2mm') print("Calculationg Means") print(data_file) print(roi_file) data = nib.load(data_file).get_data() roi = nib.load(roi_file).get_data() if (data.shape != roi.shape): raise ValueError("Image-shapes do not match") if roi_labels is None: roi_labels = np.unique(roi) mean_vals = [] for roi_label in roi_labels: mean_vals.append([ roi_label, np.mean(data[roi == roi_label]), np.std(data[roi == roi_label]) ]) print(mean_vals) fname = abspath(out_file) np.savetxt(fname, mean_vals, delimiter='\t') return fname
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 extract_label_rois(self, nifti_image): """Extract the 2D ROIs from 4D BOLD image using atlas labels get from nilearn""" atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') # get filename containing atlas info atlas_filename = atlas.maps # Create a masker object to extract signal on the parcellation masker = input_data.NiftiLabelsMasker(labels_img=atlas_filename) # Turned the Nifti data to time-series where each column is a ROI rois_ts = masker.fit_transform(nifti_image) return atlas.labels, rois_ts
def make_masker(scheme): ''' Parameters ---------- scheme : String The type of parcellation wanted. Returns ------- masker: nilearn.input_data.NiftiLabelsMasker Masker of the chosen scheme. labels: list Labels of all the regions in parcellation. ''' if scheme.lower() == "harvox": # 48 regions dataset = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') atlas_filename = dataset.maps labels = dataset.labels[1:] # trim off "background" label masker = NiftiLabelsMasker(labels_img=atlas_filename, standardize=True, high_variance_confounds=True, verbose=1) elif scheme.lower() == "yeo": # 17 regions dataset = datasets.fetch_atlas_yeo_2011() masker = NiftiLabelsMasker(labels_img=dataset['thick_17'], standardize=True, high_variance_confounds=True, verbose=1) labels = [ "Visual A", "Visual B", "Somatomotor A", "Somatomotor B", "Dorsal Attention A", "Dorsal Attention B", "Salience/Ventral Attention A", "Salience/Ventral Attention B", "Limbic A", "Limbic B", "Control C", "Control A", "Control B", "Temporal Parietal", "Default C", "Default A", "Default B" ] # list from valerie-jzr elif scheme.lower() == "aal": # 116 regions dataset = datasets.fetch_atlas_aal(version='SPM12') labels = dataset['labels'] masker = NiftiLabelsMasker(labels_img=dataset['maps'], standardize=True, high_variance_confounds=True, verbose=1) elif scheme.lower() == "schaefer": dataset = datasets.fetch_atlas_schaefer_2018(n_rois=100, yeo_networks=17) labels = dataset['labels'] masker = NiftiLabelsMasker(labels_img=dataset['maps'], standardize=True, high_variance_confounds=True, verbose=1) return masker, labels
def get_atlas_data(map): """ This function takes a map from the HarvardOxford atlas and turns it into a mask we can apply to the NiFTi volumes :param map: the map in the HarvardOxford atlas to use :return: (NiftiLabelsMasker) a masker object """ atlas = datasets.fetch_atlas_harvard_oxford(map) # Retrieve the map from nilearn's datasets module map = atlas.maps # Retrieve the maps from the atlas object masker = input_data.NiftiLabelsMasker(labels_img=map, standardize=True, memory='nilearn_cache') # Turn it into a mask that we can apply return masker # Return it
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 pcc_mask(tmp_path_factory): tmp_path = tmp_path_factory.mktemp(basename="pcc_mask") os.chdir(str(tmp_path)) atlas_img = nib.load(fetch_atlas_harvard_oxford("cort-prob-2mm")["maps"]) atlas = atlas_img.get_fdata() pcc_mask = atlas[..., 29] > 10 pcc_mask_img = new_img_like(atlas_img, pcc_mask, copy_header=True) pcc_mask_fname = Path.cwd() / "pcc.nii.gz" nib.save(pcc_mask_img, pcc_mask_fname) return pcc_mask_fname
def get_ROI_labels(coords, tol=cfg.ROITolerance): """Argument: - coords: (N, [x, y, z]) Returns: - ROIs (N) """ # load atlas from nilearn import datasets, image atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm', symmetric_split=True) labels = atlas['labels'] atlas_map = image.load_img(atlas['maps']) affine = atlas_map.affine[:3, :3] translation = atlas_map.affine[:3, 3] ROIs = [] for coord in coords: data_coords = np.matmul(np.linalg.inv(affine), np.array(coord) - translation) a, b, c = np.apply_along_axis(lambda x: np.round(x, 0), 0, data_coords).astype(int) index = atlas_map.get_data()[a, b, c] roi = ''.join([s[0] for s in labels[index].split() if s[0].isalnum()]) # label acronyms ROIs.append(roi) ROIs = np.array(ROIs) if tol > 0: j = np.where(ROIs != 'B')[0] distances = distance_matrix(coords, coords) np.fill_diagonal(distances, distances.max()) mfnd = np.median( distances.min(axis=-1)) # median first neightbor distance for i in np.where(ROIs == 'B')[0]: fn = distances[ i, j].argmin() # first neighbor in known region (idexed wrt j) if distances[i, j[fn]] < tol * mfnd: ROIs[i] = ROIs[j[fn]] ROIs = [cfg.replacements.get(x, x) for x in ROIs] return ROIs
def get_atlas(atlas_name, verbose=False): """ Get atlas from nilearn. Atlases are currently only HarvardOxford and AAL """ if atlas_name == "HarvardOxford": dataset = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') elif atlas_name == "AAL": dataset = datasets.fetch_atlas_aal() atlas_filename = dataset.maps labels = dataset.labels if verbose: print('Atlas ROIs are located in nifti image (4D) at: %s' % atlas_filename) # 4D data return ((atlas_filename, labels))
def __init__(self, atlas_name="enumerate(('cort-maxprob-thr0-1mm', \ 'cort-maxprob-thr0-2mm', \ 'cort-maxprob-thr25-1mm', \ 'cort-maxprob-thr25-2mm', \ 'cort-maxprob-thr50-1mm', \ 'cort-maxprob-thr50-2mm', \ 'sub-maxprob-thr0-1mm', \ 'sub-maxprob-thr0-2mm', \ 'sub-maxprob-thr25-1mm', \ 'sub-maxprob-thr25-2mm', \ 'sub-maxprob-thr50-1mm', \ 'sub-maxprob-thr50-2mm', \ 'cort-prob-1mm', \ 'cort-prob-2mm', \ 'sub-prob-1mm', \ 'sub-prob-2mm'))", **options): from nilearn import datasets self.dataset = datasets.fetch_atlas_harvard_oxford( atlas_name, **options)
def get_established_parcellation(parcellation="Harvard_Oxford", target_img=None, parcellation_dir=None): if parcellation == "Harvard_Oxford": name = "Harvard_Oxford_cort-prob-2mm" data = datasets.fetch_atlas_harvard_oxford('cort-prob-2mm', data_dir=parcellation_dir) parcel = nibabel.load(data['maps']) labels = data['labels'][1:] # first label is background atlas_threshold = 25 elif parcellation == "smith": name = "smith_rsn70" data = datasets.fetch_atlas_smith_2009( data_dir=parcellation_dir)['rsn70'] parcel = nibabel.load(data) labels = range(parcel.shape[-1]) atlas_threshold = 4 elif parcellation == "glasser": glasser_dir = path.join(parcellation_dir, 'glasser') data = image.load_img( path.join(glasser_dir, 'HCP-MMP1_on_MNI152_ICBM2009a_nlin.nii.gz')) parcel = image.new_img_like(data, (data.get_fdata() + .01).astype(int)) labels = list( np.genfromtxt(path.join(glasser_dir, 'HCP-MMP1_on_MNI152_ICBM2009a_nlin.txt'), dtype=str, usecols=1)) name = 'glasser' atlas_threshold = None # split down midline into lateralized ROIs data_coords = np.where(parcel.get_data()) right_coords = *(i[data_coords[0] > parcel.shape[0] // 2] for i in data_coords), # tuple comprehension parcel.get_data()[right_coords] += len(labels) labels = labels + [l.replace('L_', 'R_') for l in labels] if target_img: parcel = image.resample_to_img(parcel, target_img, interpolation='nearest') return parcel, labels, name, atlas_threshold
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
from nimare.meta.cbma.ale import SCALE from nimare.meta.cbma.mkda import MKDAChi2 ############################################################################### # Load Dataset # ----------------------------------------------------------------------------- # We will assume that the Neurosynth database has already been downloaded and # converted to a NiMARE dataset. dset_file = "neurosynth_nimare_with_abstracts.pkl.gz" dset = Dataset.load(dset_file) ############################################################################### # Define a region of interest # ----------------------------------------------------------------------------- # We'll use the right amygdala from the Harvard-Oxford atlas atlas = datasets.fetch_atlas_harvard_oxford("sub-maxprob-thr50-2mm") img = nib.load(atlas["maps"]) roi_idx = atlas["labels"].index("Right Amygdala") img_vals = np.unique(img.get_fdata()) roi_val = img_vals[roi_idx] roi_img = image.math_img(f"img1 == {roi_val}", img1=img) ############################################################################### # Select studies with a reported coordinate in the ROI # ----------------------------------------------------------------------------- roi_ids = dset.get_studies_by_mask(roi_img) dset_sel = dset.slice(roi_ids) print(f"{len(roi_ids)}/{len(dset.ids)} studies report at least one coordinate in the ROI") ###############################################################################
print(np.shape(bold[task_name])) # Convert nans into zeros bold[task_name][np.isnan(bold[task_name])] = 0 # compute the group assignment label n_subjs_this_task = np.shape(bold[task_name])[-1] n_subjs[task_name] = np.shape(bold[task_name])[-1] print('Data loaded: {} \t shape: {}'.format(task_name, np.shape(bold[task_name]))) # In[6]: # parcels from nilearn import image from nilearn.image.image import mean_img from nilearn.image import resample_to_img atlas = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm', symmetric_split=True) i = np.eye(3) * 3 atlas.maps = image.resample_img(atlas.maps, target_affine=i, interpolation='nearest') if ipynby == 1: plotting.plot_roi(atlas.maps, title='the harvard-oxford parcel') nP = len(atlas.labels) - 1 # rm background region print('number of parcels:\t {}'.format(nP)) masker_ho = NiftiLabelsMasker(labels_img=atlas.maps) index = masker_ho.labels_img.dataobj parcels = atlas.labels parcels[51] = 'Left Juxtapositional Lobule Cortex' parcels[52] = 'Right Juxtapositional Lobule Cortex' template = load_mni152_template() template = image.resample_img(template,
""" A simple example to show how this function works. """ #################################################################### # Grab atlas from Nilearn from nilearn import datasets atlas_name = 'cort-maxprob-thr0-1mm' harvard = datasets.fetch_atlas_harvard_oxford(atlas_name=atlas_name) ##################################################################### # Required inputs for function find_region_names_using_cut_coords dmn_coords = [(0, -52, 18), (-46, -68, 32), (46, -68, 32), (1, 50, -5)] atlas_img = harvard.maps labels = harvard.labels ###################################################################### # Grab function from nilearn_utils import find_region_names_using_cut_coords l, n = find_region_names_using_cut_coords(dmn_coords, atlas_img, labels=labels) # where 'l' indicates new labels generated according to given atlas labels and # coordinates new_labels = l # where 'n' indicates brain regions names labelled, generated according to given
from nilearn.datasets import fetch_atlas_harvard_oxford from nilearn_sandbox.plotting.papaya import papaya_viewer papaya_viewer(fetch_atlas_harvard_oxford('cort-prob-2mm').maps)
2. "filled_contours", maps are shown as contours same as above but with \ fillings inside the contours. 3. "continuous", maps are shown as just color overlays. The :func:`nilearn.plotting.plot_prob_atlas` function displays each map with each different color which are picked randomly from the colormap which is already defined. See :ref:`plotting` for more information to know how to tune the parameters. """ # Load 4D probabilistic atlases from nilearn import datasets # Harvard Oxford Atlas harvard_oxford = datasets.fetch_atlas_harvard_oxford('cort-prob-2mm') harvard_oxford_sub = datasets.fetch_atlas_harvard_oxford('sub-prob-2mm') # Multi Subject Dictionary Learning Atlas msdl = datasets.fetch_atlas_msdl() # Smith ICA Atlas and Brain Maps 2009 smith = datasets.fetch_atlas_smith_2009() # ICBM tissue probability icbm = datasets.fetch_icbm152_2009() # Visualization import matplotlib.pyplot as plt from nilearn import plotting
weighted_stouffers_results = meta.fit(img_dset) meta = nimare.meta.ibma.Fishers() fishers_results = meta.fit(img_dset) meta = nimare.meta.ibma.PermutedOLS() ols_results = meta.fit(img_dset) meta = nimare.meta.ibma.WeightedLeastSquares() wls_results = meta.fit(img_dset) meta = nimare.meta.ibma.Hedges() hedges_results = meta.fit(img_dset) # Use atlas for likelihood-based estimators atlas = datasets.fetch_atlas_harvard_oxford("cort-maxprob-thr25-2mm") # nilearn's NiftiLabelsMasker cannot handle NaNs at the moment, # and some of the NIDM-Results packs' beta images have NaNs at the edge of the # brain. # So, we will create a reduced version of the atlas for this analysis. nan_mask = image.math_img("~np.any(np.isnan(img), axis=3)", img=img_dset.images["beta"].tolist()) nanmasked_atlas = image.math_img( "mask * atlas", mask=nan_mask, atlas=atlas["maps"], ) masker = input_data.NiftiLabelsMasker(nanmasked_atlas) meta = nimare.meta.ibma.VarianceBasedLikelihood(method="reml", mask=masker)
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
func_imgs = data_store[name].func phenotypic = data_store[name].phenotypic motion_confounds = data_store[name].motion_param connectome_regress_confounds = None from utils import data_info shape, affine, _ = data_info(func_imgs[0]) ########################################################################### # Predefined Atlases # ------------------ # Fetch the atlas from nilearn import datasets as nidatasets ho = nidatasets.fetch_atlas_harvard_oxford(atlas_name='cort-maxprob-thr25-2mm', symmetric_split=True) atlas_img = ho.maps # Define atlases for LearnBrainRegions object as dict() atlases = dict() atlases['harvard_oxford'] = atlas_img ########################################################################### # Masker # ------ # Masking the data from nilearn import datasets # Fetch grey matter mask from nilearn shipped with ICBM templates gm_mask = datasets.fetch_icbm152_brain_gm_mask(threshold=0.2)
def load_atlas(name='cort-prob-2mm'): atlas = datasets.fetch_atlas_harvard_oxford(name) labels = atlas['labels'] maps = nilearn.image.load_img(atlas['maps']) return maps, labels
def make_parcellation(data_path, parcellation, parc_type=None, parc_params=None): """ Performs a parcellation which reduces voxel space to regions of interest (brain data). Parameters ---------- data_path : str Path to .nii image. parcellation : str Specify which parcellation that you would like to use. For MNI: 'gordon2014_333', 'power2012_264', For TAL: 'shen2013_278'. It is possible to add the OH subcotical atlas on top of a cortical atlas (e.g. gordon) by adding: '+sub-maxprob-thr0-1mm', '+sub-maxprob-thr0-2mm', 'sub-maxprob-thr25-1mm', 'sub-maxprob-thr25-2mm', '+sub-maxprob-thr50-1mm', '+sub-maxprob-thr50-2mm'. e.g.: gordon2014_333+submaxprob-thr0-2mm' parc_type : str Can be 'sphere' or 'region'. If nothing is specified, the default for that parcellation will be used. parc_params : dict **kwargs for nilearn functions Returns ------- data : array Data after the parcellation. NOTE ---- These functions make use of nilearn. Please cite nilearn if used in a publicaiton. """ if isinstance(parcellation, str): if '+' in parcellation: parcin = parcellation.split('+') parcellation = parcin[0] subcortical = parcin[1] else: subcortical = None if not parc_type or not parc_params: path = teneto.__path__[ 0] + '/data/parcellation_defaults/defaults.json' with open(path) as data_file: defaults = json.load(data_file) if not parc_type: parc_type = defaults[parcellation]['type'] print('Using default parcellation type') if not parc_params: parc_params = defaults[parcellation]['params'] print('Using default parameters') if parc_type == 'sphere': parcellation = teneto.utils.load_parcellation_coords(parcellation) seed = NiftiSpheresMasker(np.array(parcellation), **parc_params) data = seed.fit_transform(data_path) elif parc_type == 'region': path = teneto.__path__[ 0] + '/data/parcellation/' + parcellation + '.nii' region = NiftiLabelsMasker(path, **parc_params) data = region.fit_transform(data_path) else: raise ValueError('Unknown parc_type specified') if subcortical: subatlas = fetch_atlas_harvard_oxford('sub-maxprob-thr0-2mm')['maps'] region = NiftiLabelsMasker(subatlas, **parc_params) data_sub = region.fit_transform(data_path) data = np.hstack([data, data_sub]) return data
###################################################################### # Atlases # ======= destrieux = datasets.fetch_atlas_destrieux_2009() plotting.view_img(destrieux['maps'], resampling_interpolation='nearest', cmap='gist_ncar', symmetric_cmap=False, colorbar=False) plotting.plot_roi(destrieux['maps']) ###################################################################### # Harvard-Oxford probabilistic (4D) atlas harvard_oxford = datasets.fetch_atlas_harvard_oxford('cort-prob-2mm') plotting.plot_prob_atlas(harvard_oxford['maps']) ###################################################################### surf_destrieux = datasets.fetch_atlas_surf_destrieux() fsaverage = datasets.fetch_surf_fsaverage() plotting.view_surf(fsaverage['pial_left'], surf_destrieux['map_left'], cmap='gist_ncar', colorbar=False) ###################################################################### # not needed with master from nilearn import surface fsaverage['sulc_left'] = surface.load_surf_data(fsaverage['sulc_left'])
def DownloadAAL3(PATH): import os from nilearn import datasets if os.path.isfile(PATH + '/AAL3_for_SPM12.tar.gz'): print('The atlas AAL3 has already been downloaded') else: os.system('wget https://www.oxcns.org/AAL3_for_SPM12.tar.gz -P ' + PATH) if os.path.exists(PATH + '/AAL3'): print('The atlas AAL3 has already been unzipped') else: os.system('tar -zxvf ' + PATH + '/AAL3_for_SPM12.tar.gz -C ' + PATH) if os.path.exists(PATH + '/AAL3/AAL3.mat'): print('The atlas labels AAL have already been downloaded') else: os.system( 'wget https://www.dropbox.com/s/eeullhxfv8tk6fg/AAL3.mat?dl=1 -P ' + PATH + '/AAL3') os.system('mv ' + PATH + '/AAL3/AAL3.mat?dl=1 ' + PATH + '/AAL3/AAL3.mat') ################### A_HOx = '/home/lxmera/nilearn_data/fsl/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr25-2mm.nii.gz' if os.path.isfile(A_HOx): print('The atlas Harvard-Oxford has already been downloaded') else: ############################### if os.path.exists('/home/lxmera'): datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') else: print('####################################') print('# #') print('# CAMBIA EL USUARIO #') print('# #') print('####################################') mat2 = A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat' if os.path.isfile(mat2): print('The atlas labels Harvard-Oxford have already been downloaded') else: os.system( 'wget https://www.dropbox.com/s/t0keqsapcbdl10b/labelsHof.mat?dl=1 -P ' + A_HOx[:A_HOx.rfind('/')]) os.system('mv ' + A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat?dl=1 ' + A_HOx[:A_HOx.rfind('/')] + '/labelsHof.mat') A_MSDL = '/home/lxmera/nilearn_data/msdl_atlas/MSDL_rois/msdl_rois.nii' if os.path.isfile(A_MSDL): print('The atlas MSDL has already been downloaded') else: ############################### if os.path.exists('/home/lxmera'): datasets.fetch_atlas_msdl() else: print('####################################') print('# #') print('# CAMBIA EL USUARIO #') print('# #') print('####################################') mat3 = A_MSDL[:A_MSDL.rfind('/')] + '/labelsMSDL.mat' if os.path.isfile(mat3): print('The atlas labels MSDL have already been downloaded') else: os.system( 'wget https://www.dropbox.com/s/j18tleliudcx2yn/labelsMSDL.mat?dl=1 -P ' + A_MSDL[:A_MSDL.rfind('/')]) os.system('mv ' + A_MSDL[:A_MSDL.rfind('/')] + '/labelsMSDL.mat?dl=1 ' + A_MSDL[:A_MSDL.rfind('/')] + '/labelsMSDL.mat') atlas = PATH + '/AAL3/AAL3.nii.gz' mat = PATH + '/AAL3/AAL3.mat' return atlas, mat, A_HOx, mat2, A_MSDL, mat3
subjects = analysis_parameters['subjects'] source = analysis_parameters['source'] language = analysis_parameters['language'] i = 0 #paths.path2derivatives = '/Users/alexpsq/Code/NeuroSpin/LePetitPrince/derivatives' # to delete #paths.path2data = '/Users/alexpsq/Code/NeuroSpin/LePetitPrince/data' ########################################################################### ############################## Scatter plots ############################## ########################################################################### if 'scatter_plots' in args.analysis[0]: # retrieve default atlas (= set of ROI) atlas = datasets.fetch_atlas_harvard_oxford(params.atlas) labels = atlas['labels'] maps = nilearn.image.load_img(atlas['maps']) # extract data for index_mask in range(len(labels) - 1): mask = math_img('img > 50', img=index_img(maps, index_mask)) masker = NiftiMasker(mask_img=mask, memory='nilearn_cache', verbose=5) masker.fit() for analysis in analysis_parameters['scatter_plots']: for subject in subjects: subject = Subjects().get_subject(int(subject)) model1 = [ os.path.join(
from nilearn import datasets from nilearn import image ho = datasets.fetch_atlas_harvard_oxford('sub-prob-2mm', data_dir=None, symmetric_split=False, resume=True, verbose=1) lables = [ 'Left Caudate', 'Right Caudate', 'Left Putamen', 'Right Putamen', 'Left Thalamus', 'Right Thalamus', 'Left Accumbens', 'Right Accumbens', 'Left Pallidum', 'Right Pallidum' ] indexs = [ho.labels.index(i) - 1 for i in lables] import nibabel as nib img = nib.load(ho.maps) ho_prob = img.get_fdata() affine = img.affine header = img.header import numpy as np at = np.zeros([91, 109, 91]) for i in indexs: tt = ho_prob[:, :, :, i] at[tt > 33] = i + 1
""" Basic Atlas plotting ======================= Plot the regions of a reference atlas (here the Harvard-Oxford atlas). """ ########################################################################## # Retrieving the atlas data # ------------------------- from nilearn import datasets dataset = datasets.fetch_atlas_harvard_oxford('cort-maxprob-thr25-2mm') atlas_filename = dataset.maps print('Atlas ROIs are located at: %s' % atlas_filename) ########################################################################### # Visualizing the Harvard-Oxford atlas # ------------------------------------ from nilearn import plotting plotting.plot_roi(atlas_filename, title="Harvard Oxford atlas") plotting.show()
def make_parcellation(data_path, parcellation, parc_type=None, parc_params=None): """ Performs a parcellation which reduces voxel space to regions of interest (brain data). Parameters ---------- data_path : str Path to .nii image. parcellation : str Specify which parcellation that you would like to use. For MNI: 'gordon2014_333', 'power2012_264', For TAL: 'shen2013_278'. It is possible to add the OH subcotical atlas on top of a cortical atlas (e.g. gordon) by adding: '+OH' (for oxford harvard subcortical atlas) and '+SUIT' for SUIT cerebellar atlas. e.g.: gordon2014_333+OH+SUIT' parc_type : str Can be 'sphere' or 'region'. If nothing is specified, the default for that parcellation will be used. parc_params : dict **kwargs for nilearn functions Returns ------- data : array Data after the parcellation. NOTE ---- These functions make use of nilearn. Please cite nilearn if used in a publicaiton. """ if isinstance(parcellation, str): parcin = '' if '+' in parcellation: parcin = parcellation parcellation = parcellation.split('+')[0] if '+OH' in parcin: subcortical = True else: subcortical = None if '+SUIT' in parcin: cerebellar = True else: cerebellar = None if not parc_type or not parc_params: path = tenetopath[0] + '/data/parcellation_defaults/defaults.json' with open(path) as data_file: defaults = json.load(data_file) if not parc_type: parc_type = defaults[parcellation]['type'] print('Using default parcellation type') if not parc_params: parc_params = defaults[parcellation]['params'] print('Using default parameters') if parc_type == 'sphere': parcellation = load_parcellation_coords(parcellation) seed = NiftiSpheresMasker(np.array(parcellation), **parc_params) data = seed.fit_transform(data_path) elif parc_type == 'region': path = tenetopath[0] + '/data/parcellation/' + parcellation + '.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data = region.fit_transform(data_path) else: raise ValueError('Unknown parc_type specified') if subcortical: subatlas = fetch_atlas_harvard_oxford('sub-maxprob-thr0-2mm')['maps'] region = NiftiLabelsMasker(subatlas, **parc_params) data_sub = region.fit_transform(data_path) data = np.hstack([data, data_sub]) if cerebellar: path = tenetopath[0] + '/data/parcellation/Cerebellum-SUIT_space-MNI152NLin2009cAsym.nii.gz' region = NiftiLabelsMasker(path, **parc_params) data_cerebellar = region.fit_transform(data_path) data = np.hstack([data, data_cerebellar]) return data