def test_anisotropic_sphere_extraction(): data = np.random.RandomState(42).random_sample((3, 3, 3, 5)) affine = np.eye(4) affine[0, 0] = 2 affine[2, 2] = 2 img = nibabel.Nifti1Image(data, affine) masker = NiftiSpheresMasker([(2, 1, 2)], radius=1) # Test the fit masker.fit() # Test the transform s = masker.transform(img) mask = np.zeros((3, 3, 3), dtype=np.bool) mask[1, :, 1] = True assert_array_equal(s[:, 0], np.mean(data[mask], axis=0)) # Now with a mask mask_img = np.zeros((3, 2, 3)) mask_img[1, 0, 1] = 1 affine_2 = affine.copy() affine_2[0, 0] = 4 mask_img = nibabel.Nifti1Image(mask_img, affine=affine_2) masker = NiftiSpheresMasker([(2, 1, 2)], radius=1, mask_img=mask_img) masker.fit() s = masker.transform(img) assert_array_equal(s[:, 0], data[1, 0, 1])
def test_small_radius(): affine = np.eye(4) shape = (3, 3, 3) data = np.random.random(shape) mask = np.zeros(shape) mask[1, 1, 1] = 1 mask[2, 2, 2] = 1 affine = np.eye(4) * 1.2 seed = (1.4, 1.4, 1.4) masker = NiftiSpheresMasker([seed], radius=0.1, mask_img=nibabel.Nifti1Image(mask, affine)) masker.fit_transform(nibabel.Nifti1Image(data, affine)) # Test if masking is taken into account mask[1, 1, 1] = 0 mask[1, 1, 0] = 1 masker = NiftiSpheresMasker([seed], radius=0.1, mask_img=nibabel.Nifti1Image(mask, affine)) assert_raises_regex(ValueError, 'Sphere around seed #0 is empty', masker.fit_transform, nibabel.Nifti1Image(data, affine)) masker = NiftiSpheresMasker([seed], radius=1.6, mask_img=nibabel.Nifti1Image(mask, affine)) masker.fit_transform(nibabel.Nifti1Image(data, affine))
def test_gaussian_coord_smoothing(): coords = [(0.0, 0.0, 0.0), (10.0, -10.0, 30.0)] computed_img = img_utils.gaussian_coord_smoothing(coords) masker = NiftiSpheresMasker(coords + [(-10.0, 10.0, -30)]).fit() values = masker.transform(computed_img)[0] assert (values[:2] > computed_img.get_data().max() / 2.0).all() assert values[-1] == pytest.approx(0.0)
def test_seed_extraction(): data = np.random.random((3, 3, 3, 5)) img = nibabel.Nifti1Image(data, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)]) # Test the fit masker.fit() # Test the transform s = masker.transform(img) assert_array_equal(s[:, 0], data[1, 1, 1])
def extract_timeseries_coords(filename, raw_coords, confounds=None): """Because the power parcellation is given in coordinates and not labels, we dedicate an exclusive function to deal with it. """ coords = np.vstack( (raw_coords.rois['x'], raw_coords.rois['y'], raw_coords.rois['z'])).T spheres_masker = NiftiSpheresMasker(seeds=coords, radius=5., standardize=True) time_series = spheres_masker.fit_transform(filename, confounds=confounds) return time_series
def signal_extract(data,atlas,t_r=2.2,masker_type='Spheres',saveas='file'): """ Extracts BOLD time-series from regions of interest Parameters ---------- data: Filenames of subjects. atlas: regions or coordinates to extract signals from. masker_type : Type of masker used to extract BOLD signals . types are : 'Spheres','Maps','Labels' saveas : Destination to save and load output (.npz) Returns --------- subject_ts : array-like , 2-D (n_subjects,n_regions) Array of BOLD time-series """ subjects_ts=[] if os.path.exists(saveas): subjects_ts=np.load(saveas)['arr_0'] else: if masker_type== 'Spheres': masker = NiftiSpheresMasker( seeds=atlas, smoothing_fwhm=6, radius=4 ,mask_img=brainmask, detrend=False, standardize=True, low_pass=0.1, high_pass=0.01, t_r=t_r) elif masker_type == 'Maps': masker = NiftiMapsMasker(maps_img=atlas,mask_img=brainmask,standardize=True, high_pass=0.01,low_pass=0.1,detrend=False,t_r=t_r, memory_level=2,smoothing_fwhm=5,resampling_target='data', memory=mem,verbose=5) elif masker_type == 'Labels': masker = NiftiLabelsMasker(labels_img=atlas,mask_img=brainmask,standardize=True, high_pass=0.01,low_pass=0.1,detrend=False,t_r=t_r, memory_level=2,smoothing_fwhm=5,resampling_target='data', memory=mem,verbose=5) else: raise ValueError("Please provide masker type") for func_file in data: time_series = masker.fit_transform(func_file) subjects_ts.append(time_series) np.savez(saveas,subjects_ts) return subjects_ts
def fit(self): # Create mask print("Fit the SphereMasker...") self.n_seeds = int(self.seeds_img.get_data().sum()) # Pass our xform_fn for a callback on each seed. self.sphere_masker = NiftiSpheresMasker( seeds=self.seeds_img, mask_img=self.seeds_img, radius=self.radius, xform_fn=self.rsa_on_ball_axis_1, standardize=False) # no mem self.sphere_masker.fit()
def _fmri_roi_extract_image(data, atlas_path, atlas_type, radius, overlap_ok,mask = None): if 'label' in atlas_type: logging.debug('Labels Extract') label_masker = NiftiLabelsMasker(atlas_path, mask_img=mask) timeseries = label_masker.fit_transform(data) if 'sphere' in atlas_type: atlas_path = np.loadtxt(atlas_path) logging.debug('Sphere Extract') spheres_masker = NiftiSpheresMasker(atlas_path, float(radius),mask_img=mask, allow_overlap = overlap_ok) timeseries = spheres_masker.fit_transform(data) if 'maps' in atlas_type: logging.debug('Maps Extract') maps_masker = NiftiMapsMasker(atlas_path,mask_img=mask, allow_overlap = overlap_ok) timeseries = maps_masker.fit_transform(data) timeseries[timeseries == 0.0] = np.nan return timeseries
def extract_parcellation_time_series(in_data, parcellation_name, parcellations_dict, bp_freqs, tr): ''' Depending on parcellation['is_probabilistic'] this function chooses either NiftiLabelsMasker or NiftiMapsMasker to extract the time series of each parcel if bp_freq: data is band passfiltered at (hp, lp), if (None,None): no filter, if (None, .1) only lp... tr in ms (e.g. from freesurfer ImageInfo()) returns np.array with parcellation time series and saves this array also to parcellation_time_series_file, and path to pickled masker object ''' from nilearn.input_data import NiftiLabelsMasker, NiftiMapsMasker, NiftiSpheresMasker import os, pickle import numpy as np if parcellations_dict[parcellation_name][ 'is_probabilistic'] == True: # use probab. nilearn masker = NiftiMapsMasker( maps_img=parcellations_dict[parcellation_name]['nii_path'], standardize=True) elif parcellations_dict[parcellation_name]['is_probabilistic'] == 'sphere': atlas = pickle.load( open(parcellations_dict[parcellation_name]['nii_path'])) coords = atlas.rois masker = NiftiSpheresMasker(coords, radius=5, allow_overlap=True, standardize=True) else: # 0/1 labels masker = NiftiLabelsMasker( labels_img=parcellations_dict[parcellation_name]['nii_path'], standardize=True) # add bandpass filter (only executes if freq not None hp, lp = bp_freqs masker.low_pass = lp masker.high_pass = hp if tr is not None: masker.t_r = tr else: masker.t_r = None masker.standardize = True masker_file = os.path.join(os.getcwd(), 'masker.pkl') with open(masker_file, 'w') as f: pickle.dump(masker, f) parcellation_time_series = masker.fit_transform(in_data) parcellation_time_series_file = os.path.join( os.getcwd(), 'parcellation_time_series.npy') np.save(parcellation_time_series_file, parcellation_time_series) return parcellation_time_series, parcellation_time_series_file, masker_file
def build_series(brain4d): coords = [ (30, -45, -10), (0, -85, 10), (0, 47, 30), (-35, -20, 50), ] masker = NiftiSpheresMasker( coords, radius=5, detrend=True, standardize=True, low_pass=0.1, high_pass=0.01, t_r=2, ) series = masker.fit_transform(brain4d) return series
def report_flm_adhd_dmn(): # pragma: no cover t_r = 2. slice_time_ref = 0. n_scans = 176 pcc_coords = (0, -53, 26) adhd_dataset = nilearn.datasets.fetch_adhd(n_subjects=1) seed_masker = NiftiSpheresMasker([pcc_coords], radius=10, detrend=True, standardize=True, low_pass=0.1, high_pass=0.01, t_r=2., memory='nilearn_cache', memory_level=1, verbose=0) seed_time_series = seed_masker.fit_transform(adhd_dataset.func[0]) frametimes = np.linspace(0, (n_scans - 1) * t_r, n_scans) design_matrix = make_first_level_design_matrix(frametimes, hrf_model='spm', add_regs=seed_time_series, add_reg_names=["pcc_seed"]) dmn_contrast = np.array([1] + [0] * (design_matrix.shape[1] - 1)) contrasts = {'seed_based_glm': dmn_contrast} first_level_model = FirstLevelModel(t_r=t_r, slice_time_ref=slice_time_ref) first_level_model = first_level_model.fit(run_imgs=adhd_dataset.func[0], design_matrices=design_matrix) report = make_glm_report( first_level_model, contrasts=contrasts, title='ADHD DMN Report', cluster_threshold=15, height_control='bonferroni', min_distance=8., plot_type='glass', report_dims=(1200, 'a'), ) output_filename = 'generated_report_flm_adhd_dmn.html' output_filepath = os.path.join(REPORTS_DIR, output_filename) report.save_as_html(output_filepath) report.get_iframe()
def _set_volume_masker(roi_file, as_voxels=False, **kwargs): """Check and see if multiple ROIs exist in atlas file""" if not isinstance(roi_file, str): raise ValueError('roi_file must be a file name string') if roi_file.endswith('.csv') or roi_file.endswith('.tsv'): roi = _read_coords(roi_file) n_rois = len(roi) print(' {} region(s) detected from coordinates'.format(n_rois)) if kwargs.get('radius') is None: warnings.warn('No radius specified for coordinates; setting ' 'to nilearn.input_data.NiftiSphereMasker default ' 'of extracting from a single voxel') masker = NiftiSpheresMasker(roi, **kwargs) elif roi_file.endswith('.nii.gz'): # remove args for NiftiSpheresMasker if 'radius' in kwargs: kwargs.pop('radius') if 'allow_overlap' in kwargs: kwargs.pop('allow_overlap') roi_img = image.load_img(roi_file) if len(roi_img.shape) == 4: n_rois = roi_img.shape[-1] print(' {} region(s) detected from {}'.format(n_rois, roi_img.get_filename())) masker = NiftiMapsMasker(roi_img, allow_overlap=True,**kwargs) else: n_rois = len(np.unique(roi_img.get_fdata())) - 1 print(' {} region(s) detected from {}'.format(n_rois, roi_img.get_filename())) if n_rois > 1: masker = NiftiLabelsMasker(roi_img, **kwargs) elif n_rois == 1: # binary mask for single ROI if as_voxels: if 'mask_img' in kwargs: kwargs.pop('mask_img') masker = NiftiMasker(roi_img, **kwargs) else: # more computationally efficient if only wanting the mean masker = NiftiLabelsMasker(roi_img, **kwargs) else: raise ValueError('No ROI detected; check ROI file') else: raise ValueError('Invalid file type for roi_file. Must be one of: ' '.nii.gz, .csv, .tsv') return masker, n_rois
def test_is_nifti_spheres_masker_give_nans(): affine = np.eye(4) data_with_nans = np.zeros((10, 10, 10), dtype=np.float32) data_with_nans[:, :, :] = np.nan data_without_nans = np.random.random((9, 9, 9)) indices = np.nonzero(data_without_nans) # Leaving nans outside of some data data_with_nans[indices] = data_without_nans[indices] img = nibabel.Nifti1Image(data_with_nans, affine) seed = [(7, 7, 7)] # Interaction of seed with nans masker = NiftiSpheresMasker(seeds=seed, radius=2.) assert_false(np.isnan(np.sum(masker.fit_transform(img)))) mask = np.ones((9, 9, 9)) mask_img = nibabel.Nifti1Image(mask, affine) # When mask_img is provided, the seed interacts within the brain, so no nan masker = NiftiSpheresMasker(seeds=seed, radius=2., mask_img=mask_img) assert_false(np.isnan(np.sum(masker.fit_transform(img))))
def test_sphere_extraction(): data = np.random.random((3, 3, 3, 5)) img = nibabel.Nifti1Image(data, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1) # Test the fit masker.fit() # Test the transform s = masker.transform(img) mask = np.zeros((3, 3, 3), dtype=np.bool) mask[:, 1, 1] = True mask[1, :, 1] = True mask[1, 1, :] = True assert_array_equal(s[:, 0], np.mean(data[mask], axis=0)) # Now with a mask mask_img = np.zeros((3, 3, 3)) mask_img[1, :, :] = 1 mask_img = nibabel.Nifti1Image(mask_img, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1, mask_img=mask_img) masker.fit() s = masker.transform(img) assert_array_equal( s[:, 0], np.mean(data[np.logical_and(mask, mask_img.get_data())], axis=0))
def test_nifti_spheres_masker_overlap(): # Test resampling in NiftiMapsMasker affine = np.eye(4) shape = (5, 5, 5) data = np.random.random(shape + (5,)) fmri_img = nibabel.Nifti1Image(data, affine) seeds = [(0, 0, 0), (2, 2, 2)] overlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) overlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=False) noverlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=False) assert_raises_regex(ValueError, 'Overlap detected', noverlapping_masker.fit_transform, fmri_img)
def _set_masker(roi_file, as_voxels=False, **kwargs): """Check and see if multiple ROIs exist in atlas file""" if isinstance(roi_file, str) and roi_file.endswith('.tsv'): roi = _read_coords(roi_file) n_rois = len(roi) is_coords = True print(' {} region(s) detected from coordinates'.format(n_rois)) else: roi = load_img(roi_file) n_rois = len(np.unique(roi.get_data())) - 1 is_coords = False print(' {} region(s) detected from {}'.format(n_rois, roi.get_filename())) if is_coords: if kwargs.get('radius') is None: warnings.warn('No radius specified for coordinates; setting ' 'to nilearn.input_data.NiftiSphereMasker default ' 'of extracting from a single voxel') masker = NiftiSpheresMasker(roi, **kwargs) else: if 'radius' in kwargs: kwargs.pop('radius') if 'allow_overlap' in kwargs: kwargs.pop('allow_overlap') if n_rois > 1: masker = NiftiLabelsMasker(roi, **kwargs) elif n_rois == 1: # single binary ROI mask if as_voxels: if 'mask_img' in kwargs: kwargs.pop('mask_img') masker = NiftiMasker(roi, **kwargs) else: # more computationally efficient if only wanting the mean of ROI masker = NiftiLabelsMasker(roi, **kwargs) else: raise ValueError('No ROI detected; check ROI file') return masker
def test_sphere_extraction(): data = np.random.random((3, 3, 3, 5)) img = nibabel.Nifti1Image(data, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1) # Test the fit masker.fit() # Test the transform s = masker.transform(img) mask = np.zeros((3, 3, 3), dtype=np.bool) mask[:, 1, 1] = True mask[1, :, 1] = True mask[1, 1, :] = True assert_array_equal(s[:, 0], np.mean(data[mask], axis=0)) # Now with a mask mask_img = np.zeros((3, 3, 3)) mask_img[1, :, :] = 1 mask_img = nibabel.Nifti1Image(mask_img, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1, mask_img=mask_img) masker.fit() s = masker.transform(img) assert_array_equal(s[:, 0], np.mean(data[np.logical_and(mask, mask_img.get_data())], axis=0))
def test_anisotropic_sphere_extraction(): data = np.random.random((3, 3, 3, 5)) affine = np.eye(4) affine[0, 0] = 2 affine[2, 2] = 2 img = nibabel.Nifti1Image(data, affine) masker = NiftiSpheresMasker([(2, 1, 2)], radius=1) # Test the fit masker.fit() # Test the transform s = masker.transform(img) mask = np.zeros((3, 3, 3), dtype=np.bool) mask[1, :, 1] = True assert_array_equal(s[:, 0], np.mean(data[mask], axis=0)) # Now with a mask mask_img = np.zeros((3, 2, 3)) mask_img[1, 0, 1] = 1 affine_2 = affine.copy() affine_2[0, 0] = 4 mask_img = nibabel.Nifti1Image(mask_img, affine=affine_2) masker = NiftiSpheresMasker([(2, 1, 2)], radius=1, mask_img=mask_img) masker.fit() s = masker.transform(img) assert_array_equal(s[:, 0], data[1, 0, 1])
def test_standardization(): data = np.random.RandomState(42).random_sample((3, 3, 3, 5)) img = nibabel.Nifti1Image(data, np.eye(4)) # test zscore masker = NiftiSpheresMasker([(1, 1, 1)], standardize='zscore') # Test the fit s = masker.fit_transform(img) np.testing.assert_almost_equal(s.mean(), 0) np.testing.assert_almost_equal(s.std(), 1) # test psc masker = NiftiSpheresMasker([(1, 1, 1)], standardize='psc') # Test the fit s = masker.fit_transform(img) np.testing.assert_almost_equal(s.mean(), 0) np.testing.assert_almost_equal( s.ravel(), data[1, 1, 1] / data[1, 1, 1].mean() * 100 - 100, )
def test_is_nifti_spheres_masker_give_nans(): affine = np.eye(4) data_with_nans = np.zeros((10, 10, 10), dtype=np.float32) data_with_nans[:, :, :] = np.nan data_without_nans = np.random.RandomState(42).random_sample((9, 9, 9)) indices = np.nonzero(data_without_nans) # Leaving nans outside of some data data_with_nans[indices] = data_without_nans[indices] img = nibabel.Nifti1Image(data_with_nans, affine) seed = [(7, 7, 7)] # Interaction of seed with nans masker = NiftiSpheresMasker(seeds=seed, radius=2.) assert not np.isnan(np.sum(masker.fit_transform(img))) mask = np.ones((9, 9, 9)) mask_img = nibabel.Nifti1Image(mask, affine) # When mask_img is provided, the seed interacts within the brain, so no nan masker = NiftiSpheresMasker(seeds=seed, radius=2., mask_img=mask_img) assert not np.isnan(np.sum(masker.fit_transform(img)))
class RsaSearchlight(object): def __init__(self, mask_img, seeds_img, radius=10., distance_method='correlation', memory_params=None): # Defs self.memory_params = memory_params or dict() self.seeds_img = seeds_img self.mask_img = mask_img self.radius = radius self.distance_method = distance_method def rsa_on_ball_axis_1(self, sphere_data): """ Data: axis=1: [nvoxels, nslices] """ # sphere_data could be a single voxel; in this case, we'll get # nan similarity_comparisons = pdist(sphere_data.T, self.distance_method) self.similarity_comparisons[self.si, :] = similarity_comparisons self.n_voxels[self.si] = sphere_data.shape[0] self.si += 1 if self.memory_params.get('verbose', 0) > 1 and self.si % 100 == 99: print 'Processed %s of %s...' % (self.si + 1, self.n_seeds) return similarity_comparisons.std() # output value for all slices def fit(self): # Create mask print("Fit the SphereMasker...") self.n_seeds = int(self.seeds_img.get_data().sum()) # Pass our xform_fn for a callback on each seed. self.sphere_masker = NiftiSpheresMasker( seeds=self.seeds_img, mask_img=self.seeds_img, radius=self.radius, xform_fn=self.rsa_on_ball_axis_1, standardize=False) # no mem self.sphere_masker.fit() def transform(self, func_img): print("Transforming the image...") n_images = func_img.shape[3] n_compares = n_images * (n_images - 1) / 2 # These are computed within the callback. self.si = 0 self.n_voxels = np.empty((self.n_seeds)) self.similarity_comparisons = np.empty((self.n_seeds, n_compares)) similarity_std = self.sphere_masker.transform(func_img) # Pull the values off of self, set locally. n_voxels = self.n_voxels similarity_comparisons = self.similarity_comparisons delattr(self, 'si') delattr(self, 'n_voxels') delattr(self, 'similarity_comparisons') # Clean up good_seeds = np.logical_not( np.isnan(similarity_comparisons.mean(axis=1))) n_voxels = n_voxels[good_seeds] similarity_comparisons = similarity_comparisons[good_seeds] similarity_std = similarity_std[:, good_seeds] # slices x seeds return similarity_comparisons, similarity_std, n_voxels def visualize(self, similarity_comparisons, similarity_std=None, anat_img=None, labels=None): print("Plotting the results...") self.visualize_seeds(anat_img=anat_img) self.visualize_mask(anat_img=anat_img) self.visualize_comparisons( similarity_comparisons=similarity_comparisons, labels=labels, anat_img=anat_img) self.visualize_comparisons_std(similarity_std=similarity_std, anat_img=anat_img) def visualize_seeds(self, anat_img=None): plot_roi(self.sphere_masker.seeds_img_, bg_img=anat_img, title='seed img') def visualize_mask(self, anat_img=None): plot_roi(self.sphere_masker.mask_img_, bg_img=anat_img, title='mask img') def visualize_comparisons(self, similarity_comparisons, labels=None, anat_img=None): # Plot (up to) twenty comparisons. plotted_similarity = similarity_comparisons[:, 0] plotted_img = self.sphere_masker.inverse_transform( plotted_similarity.T) plot_stat_map(plotted_img, bg_img=anat_img, title='RSA comparison %s vs. %s' % tuple(labels[:2])) # Plot mosaic of up to 20 # Choose the comparisons idx = np.linspace(0, similarity_comparisons.shape[1] - 1, 20) idx = np.unique(np.round(idx).astype(int)) # if there's less than 20 # Make (and filter) titles if labels is None: titles = None else: titles = [] for ai, label1 in enumerate(labels): for bi, label2 in enumerate(labels[(ai + 1):]): titles.append('%s vs. %s' % (label1, label2)) titles = np.asarray(titles)[idx] # Create the image plotted_similarity = similarity_comparisons[:, idx] plotted_img = self.sphere_masker.inverse_transform( plotted_similarity.T) fh = plt.figure(figsize=(18, 10)) plot_mosaic_stat_map(plotted_img, colorbar=False, display_mode='z', bg_img=anat_img, cut_coords=1, figure=fh, title=titles) def visualize_comparisons_std(self, similarity_std, anat_img=None): if similarity_std is not None: RSA_std_img = self.sphere_masker.inverse_transform( similarity_std[0]) plot_stat_map(RSA_std_img, bg_img=anat_img, title='RSA std')
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
def test_nifti_spheres_masker_overlap(): # Test resampling in NiftiMapsMasker affine = np.eye(4) shape = (5, 5, 5) data = np.random.RandomState(42).random_sample(shape + (5, )) fmri_img = nibabel.Nifti1Image(data, affine) seeds = [(0, 0, 0), (2, 2, 2)] overlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) overlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=False) noverlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=False) with pytest.raises(ValueError, match='Overlap detected'): noverlapping_masker.fit_transform(fmri_img)
# Find the coordinates of the peak from nibabel.affines import apply_affine values = z_map.get_data() coord_peaks = np.dstack( np.unravel_index(np.argsort(values.ravel()), values.shape))[0, 0, :] coord_mm = apply_affine(z_map.affine, coord_peaks) ############################################################################### # We create a masker for the voxel (allowing us to detrend the signal) # and extract the time course from nilearn.input_data import NiftiSpheresMasker mask = NiftiSpheresMasker([coord_mm], radius=3, detrend=True, standardize=True, high_pass=None, low_pass=None, t_r=7.) sig = mask.fit_transform(fmri_img) ########################################################## # Let's plot the signal and the theoretical response plt.plot(frame_times, sig, label='voxel %d %d %d' % tuple(coord_mm)) plt.plot(design_matrix['active'], color='red', label='model') plt.xlabel('scan') plt.legend() plt.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: '+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
def calc_sc_sphere(in_file, coords, coords_labels, MNI_brain_mask, radius, FWHM): from nilearn.input_data import NiftiMasker, NiftiSpheresMasker import numpy as np import os # MNI mask MNI_brain_mask = MNI_brain_mask # probabilistic seed regions, 4d nifti file & corresponding labels coords = coords coords_labels = coords_labels # extract time series from coords seed_masker = NiftiSpheresMasker(coords, radius=radius, standardize=True, memory='nilearn_cache', memory_level=5, verbose=5) seed_time_series_array = seed_masker.fit_transform(in_file) # extract time series brain-wide brain_masker = NiftiMasker(mask_img=MNI_brain_mask, smoothing_fwhm=FWHM, standardize=True, memory='nilearn_cache', memory_level=5, verbose=2) brain_time_series = brain_masker.fit_transform(in_file) # check if length of coords_labels is equal to number of seed time series # (dependend on number of coordinate sets given with "coords") # break if not equal if len(coords_labels) == seed_time_series_array.shape[1]: icoord = 0 corr_maps_dict = dict.fromkeys(coords_labels) for seed in coords_labels: print("##################################") print(seed) print("##################################") # assign extracted seed time series from seed_time_series_array # at column icoord to seed_time_series & transpose it (because otherwise they have not the right dimensions?) seed_time_series = np.matrix(seed_time_series_array[:, icoord]).T # compute correlation of all voxels with seed regions seed_based_correlations = np.dot(brain_time_series.T, seed_time_series) / \ seed_time_series.shape[0] # increase imask to iterate through columns of seed_time_series_array icoord = icoord + 1 # Fisher-z transform the data to achieve a normal distribution seed_based_correlations_fisher_z = np.arctanh( seed_based_correlations) # transform the 2 dim matrix with the value of each voxel back to a 3 dim image seed_based_correlation_img = brain_masker.inverse_transform( seed_based_correlations_fisher_z.T) print("##################################") # initialize an empty file & "fill" it with the calculated img, necessary becaus nipype needs file types or so... aehm hmm out_file = os.path.abspath('corr_map_' + seed + '_rad5.nii.gz') seed_based_correlation_img.to_filename(out_file) corr_maps_dict[seed] = out_file return corr_maps_dict else: print( "#####################################################################################" ) print( "#####################################################################################" ) print( "Number of labels in prob_masks_labels and volumes in prob_masks does not match!!!!!!!" ) print( "#####################################################################################" ) print( "#####################################################################################" )
# Prepare timing t_r = 2. slice_time_ref = 0. n_scans = 176 # Prepare seed pcc_coords = (0, -53, 26) ######################################################################### # Estimate contrasts # ------------------ # Specify the contrasts seed_masker = NiftiSpheresMasker([pcc_coords], radius=10, detrend=True, standardize=True, low_pass=0.1, high_pass=0.01, t_r=2., memory='nilearn_cache', memory_level=1, verbose=0) seed_time_series = seed_masker.fit_transform(adhd_dataset.func[0]) frametimes = np.linspace(0, (n_scans - 1) * t_r, n_scans) design_matrix = make_first_level_design_matrix(frametimes, hrf_model='spm', add_regs=seed_time_series, add_reg_names=["pcc_seed"]) dmn_contrast = np.array([1] + [0]*(design_matrix.shape[1]-1)) contrasts = {'seed_based_glm': dmn_contrast} ######################################################################### # Perform first level analysis # ---------------------------- # Setup and fit GLM first_level_model = FirstLevelModel(t_r=t_r, slice_time_ref=slice_time_ref)
def test_errors(): masker = NiftiSpheresMasker(([1, 2]), radius=.2) with pytest.raises(ValueError, match='Seeds must be a list .+'): masker.fit()
def atlas_masker_spheres(coords, radius): masker = NiftiSpheresMasker(coords, radius) assert isinstance(masker, object) return masker
def test_errors(): masker = NiftiSpheresMasker(([1, 2]), radius=.2) assert_raises_regex(ValueError, 'Seeds must be a list .+', masker.fit)
def test_nifti_spheres_masker_inverse_overlap(): rng = np.random.RandomState(42) # Test overlapping data in inverse_transform affine = np.eye(4) shape = (5, 5, 5) data = rng.random_sample(shape + (5, )) fmri_img = nibabel.Nifti1Image(data, affine) # Apply mask image - to allow inversion mask_img = new_img_like(fmri_img, np.ones(shape)) seeds = [(0, 0, 0), (2, 2, 2)] # Inverse data inv_data = rng.random_sample(len(seeds)) overlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=True, mask_img=mask_img).fit() overlapping_masker.inverse_transform(inv_data) overlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=True, mask_img=mask_img).fit() overlap = overlapping_masker.inverse_transform(inv_data) # Test whether overlapping data is averaged assert_array_almost_equal(get_data(overlap)[1, 1, 1], np.mean(inv_data)) noverlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=False, mask_img=mask_img).fit() noverlapping_masker.inverse_transform(inv_data) noverlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=False, mask_img=mask_img).fit() with pytest.raises(ValueError, match='Overlap detected'): noverlapping_masker.inverse_transform(inv_data)
def test_nifti_spheres_masker_overlap(): # Test resampling in NiftiMapsMasker affine = np.eye(4) shape = (5, 5, 5) data = np.random.random(shape + (5, )) fmri_img = nibabel.Nifti1Image(data, affine) seeds = [(0, 0, 0), (2, 2, 2)] overlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) overlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=True) overlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=1, allow_overlap=False) noverlapping_masker.fit_transform(fmri_img) noverlapping_masker = NiftiSpheresMasker(seeds, radius=2, allow_overlap=False) assert_raises_regex(ValueError, 'Overlap detected', noverlapping_masker.fit_transform, fmri_img)
def test_small_radius_inverse(): affine = np.eye(4) shape = (3, 3, 3) data = np.random.RandomState(42).random_sample(shape) mask = np.zeros(shape) mask[1, 1, 1] = 1 mask[2, 2, 2] = 1 affine = np.eye(4) * 1.2 seed = (1.4, 1.4, 1.4) masker = NiftiSpheresMasker([seed], radius=0.1, mask_img=nibabel.Nifti1Image(mask, affine)) spheres_data = masker.fit_transform(nibabel.Nifti1Image(data, affine)) masker.inverse_transform(spheres_data) # Test if masking is taken into account mask[1, 1, 1] = 0 mask[1, 1, 0] = 1 masker = NiftiSpheresMasker([seed], radius=0.1, mask_img=nibabel.Nifti1Image(mask, affine)) masker.fit(nibabel.Nifti1Image(data, affine)) with pytest.raises(ValueError, match='These spheres are empty'): masker.inverse_transform(spheres_data) masker = NiftiSpheresMasker([seed], radius=1.6, mask_img=nibabel.Nifti1Image(mask, affine)) masker.fit(nibabel.Nifti1Image(data, affine)) masker.inverse_transform(spheres_data)
def test_nifti_spheres_masker_inverse_transform(): # Applying the sphere_extraction example from above backwards data = np.random.RandomState(42).random_sample((3, 3, 3, 5)) img = nibabel.Nifti1Image(data, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1) # Test the fit masker.fit() # Transform data with pytest.raises(ValueError, match='Please provide mask_img'): masker.inverse_transform(data[0, 0, 0, :]) # Mask describes the extend of the masker's sphere mask = np.zeros((3, 3, 3), dtype=np.bool) mask[:, 1, 1] = True mask[1, :, 1] = True mask[1, 1, :] = True # Now with a mask mask_img = np.zeros((3, 3, 3)) mask_img[1, :, :] = 1 mask_img = nibabel.Nifti1Image(mask_img, np.eye(4)) masker = NiftiSpheresMasker([(1, 1, 1)], radius=1, mask_img=mask_img) masker.fit() s = masker.transform(img) # Create an array mask array_mask = np.logical_and(mask, get_data(mask_img)) inverse_map = masker.inverse_transform(s) # Testing whether mask is applied to inverse transform assert_array_equal( np.mean(get_data(inverse_map), axis=-1) != 0, array_mask) # Test whether values are preserved assert_array_equal(get_data(inverse_map)[array_mask].mean(0), s[:, 0]) # Test whether the mask's shape is applied assert_array_equal(inverse_map.shape[:3], mask_img.shape)
def signal_extract(func_data=None,confounds=None,atlas_img=None,masker_type='Spheres',smoothing_fwhm=6,high_pass=0.01,low_pass=0.1,t_r=2.2,detrend=False,saveas='file'): """ Extracts BOLD time-series from regions of interest Parameters ---------- func_data: functional images ( Default= None ) confounds: Confounds file used to clean signals ( Default= None ) atlas_img: regions or coordinates to extract signals from ( Default= None ) masker_type : Type of masker used to extract BOLD signals . types are : 'Spheres','Maps','Labels' smoothing_fwhm : Smoothing width applied to signals in mm ( Default= 6 mm ) high_pass, low_pass: Bandpass-Filtering ( Default= 0.01-0.1 Hz ) detrend: Detrending signals ( Default= False ) saveas : Destination to save and load output (.npz) Returns --------- subject_ts : array-like , 2-D (n_subjects,n_regions) Array of BOLD time-series """ subjects_ts=[] if os.path.exists(saveas): subjects_ts=np.load(saveas)['arr_0'] else: if if masker_type== 'Spheres': masker = NiftiSpheresMasker( seeds=atlas_img, smoothing_fwhm=smoothing_fwhm, radius=4 ,mask_img=brainmask, detrend=False, standardize=True, low_pass=low_pass, high_pass=high_pass, t_r=t_r ) elif masker_type == 'Maps': masker = NiftiMapsMasker( maps_img=atlas_img,mask_img=brainmask,standardize=True, low_pass=low_pass, high_pass=high_pass, t_r=t_r, memory_level=2,smoothing_fwhm=smoothing_fwhm,resampling_target='data', memory=mem,verbose=5 ) elif masker_type == 'Labels': masker = NiftiLabelsMasker( labels_img=atlas_img,mask_img=brainmask,standardize=True, high_pass=high_pass,low_pass=low_pass,detrend=False,t_r=t_r, memory_level=2,smoothing_fwhm=smoothing_fwhm,resampling_target='data', memory=mem,verbose=5 ) else: raise ValueError("Please provide masker type") if confounds is not None: for func_file, confound_file in zip(func_data,confounds): time_series = masker.fit_transform(func_file,confounds=confound_file) subjects_ts.append(time_series) np.savez(saveas,subjects_ts) else: for func_file in data: time_series = masker.fit_transform(func_file) subjects_ts.append(time_series) np.savez(saveas,subjects_ts) return subjects_ts