def get_masker(mask_img=None): if mask_img is None: mask_img = load_mni152_brain_mask() masker = input_data.NiftiMasker(mask_img=mask_img).fit() return masker
########################################################################## # Then we extract the mean time series within the seed region while # regressing out the confounds that # can be found in the dataset's csv file seed_time_series = seed_masker.fit_transform(func_filename, confounds=[confound_filename]) ########################################################################## # Next, we can proceed similarly for the **brain-wide voxel-wise time # series**, using :class:`nilearn.input_data.NiftiMasker` with the same input # arguments as in the seed_masker in addition to smoothing with a 6 mm kernel brain_masker = input_data.NiftiMasker(smoothing_fwhm=6, detrend=True, standardize=True, low_pass=0.1, high_pass=0.01, t_r=2., memory='nilearn_cache', memory_level=1, verbose=0) ########################################################################## # Then we extract the brain-wide voxel-wise time series while regressing # out the confounds as before brain_time_series = brain_masker.fit_transform(func_filename, confounds=[confound_filename]) ########################################################################## # We can now inspect the extracted time series. Note that the **seed time # series** is an array with shape n_volumes, 1), while the # **brain time series** is an array with shape (n_volumes, n_voxels).
) def truncate_colormap(cmap, minval=0.0, maxval=1.0, n=100): new_cmap = colors.LinearSegmentedColormap.from_list( "trunc({n},{a:.2f},{b:.2f})".format(n=cmap.name, a=minval, b=maxval), cmap(np.linspace(minval, maxval, n)), ) return new_cmap from nilearn import image, datasets mean_img = image.load_img("../data/statistical_map.nii") masker = input_data.NiftiMasker(mask_img=image.resample_to_img( datasets.load_mni152_brain_mask(), mean_img, interpolation="nearest")) # plot the image masked_img = masker.fit_transform(mean_img) unmasked_img = masker.inverse_transform(masked_img) display = plotting.plot_glass_brain( unmasked_img, threshold=0, cmap=plt.cm.viridis, colorbar=False, display_mode="xz", axes=ax_glass_brain, ) # ax_glass_brain.text(1, 1, '(a)', fontweight='bold') ax1 = fig.add_axes([0.05, 0.12, 0.4, 0.03]) cmap = truncate_colormap(plt.cm.viridis, minval=0.5)
part_thr = 20 root_p = pal.Path(__file__).resolve().parents[2] / 'data' pheno_p = root_p / 'pheno/ABIDE1_Pheno_PSM_matched_minimum_10.tsv' mask_p = root_p / 'ATLAS/MIST/Parcellations/MIST_mask_nocereb.nii.gz' stab_p = root_p / 'processed/stability/abide_1/abide_1_subtype_stability_mist_20_core_20_within_99.npz' sca_p = root_p / f'preprocessed/seed_maps/abide_1/MIST_{scale}' sca_t = f'sub_{{}}_ses_{{}}_run{{}}_mist_{scale}_nocereb.npy' # Output out_d = root_p / f'processed/stability/abide_1/' out_p = out_d / f'abide_1_subtype_map_stability_mist_{scale}_core_{part_thr:d}_within_{dist_thr*100:.0f}.npy' if not out_d.is_dir(): out_d.mkdir() mask_i = nib.load(str(mask_p)) masker = nii.NiftiMasker(mask_img=mask_i) masker.fit() stab = np.load(stab_p) pheno = pd.read_csv(pheno_p, sep='\t') seed_paths = [ sca_p / sca_t.format(row['SUB_ID'], row['session'], row['run']) for rid, row in pheno.iterrows() ] subject_stack = np.array([np.load(p) for p in seed_paths]) partitions = stab['partitions'][()] train_indices = stab['train_idx'] n_samples = pheno.shape[0] n_boot = len(partitions.keys()) n_networks = subject_stack.shape[2]
##### Step 1 ##### ######################################## ## here we have two "seeds" in the thalamus from Aaron that we would like to calcuate its FC with the whole brain. # This Sprenger study got it right, with the thalamic hot spot at −14/−23/1 and −14/−23/0, https://academic.oup.com/brain/article/135/8/2536/305095 seed1_coords = [(-14, -23, 1)] seed2_coords = [(-14, -23, 0)] #Always double check the coordinate. #nilearn.plotting.plot_anat(cut_coords=seed1_coords[0]) #plt.show() #nilearn.plotting.plot_anat(cut_coords=seed2_coords[0]) #plt.show() seed1_masker = input_data.NiftiSpheresMasker(seed1_coords, radius=5) seed2_masker = input_data.NiftiSpheresMasker(seed2_coords, radius=5) brain_masker = input_data.NiftiMasker() ######################################## ##### Step 2 loop through functional files for MGH subjects ######################################## #get list of all subjects subjects = pd.read_csv('/home/kahwang/bin/example_graph_pipeline/MGH_Subjects', names=['ID'])['ID'].values #input_files = glob.glob('/data/backed_up/shared/MGH/MGH/*/MNINonLinear/rfMRI_REST.nii.gz') # a function to run seed FC and save outputs to a folder def run_seed_fc(s): try: file = '/data/backed_up/shared/MGH/MGH/%s/MNINonLinear/rfMRI_REST.nii.gz' %s ######################################## ##### Step 3 extract seed time-series from the two coordinates and whole brain ########################################
# Remove the rest condition, it is not very interesting non_rest = conditions != b'rest' conditions = conditions[non_rest] y = y[non_rest] # Get the labels of the numerical conditions represented by the vector y unique_conditions, order = np.unique(conditions, return_index=True) # Sort the conditions by the order of appearance unique_conditions = unique_conditions[np.argsort(order)] ### Loading step ############################################################## # For decoding, standardizing is often very important nifti_masker = input_data.NiftiMasker(mask_img=mask_filename, standardize=True, detrend=True, sessions=session, smoothing_fwhm=None, memory="nilearn_cache", memory_level=1) X = nifti_masker.fit_transform(func_filename) X = X[non_rest] session = session[non_rest] # region-level analysis n_perm = 10000 mask = nifti_masker.mask_img_.get_data() atlas_labels = atlas.get_data()[mask > 0] ### Statistical scores ###################################################
import matplotlib.pyplot as plt if __name__ == "__main__": data = sys.argv[1] oscdir = sys.argv[2] transientdir = sys.argv[3] img = image.load_img(data) oscmask = op.join(oscdir, "stats", "zfstat1.nii.gz") transientmask = op.join(transientdir, "stats", "zfstat1.nii.gz") oscmask_ = niutils.bin_img(oscmask, threshold=3.1) transientmask_ = niutils.bin_img(transientmask, threshold=3.1) oscmasker = input_data.NiftiMasker(mask_img=oscmask_, standardize="psc") transientmasker = input_data.NiftiMasker(mask_img=transientmask_, standardize="psc") oscts = oscmasker.fit_transform(img) transientts = transientmasker.fit_transform(img) fig, ax = plt.subplots() ax.text( 0.01, 0.95, f"{data}", transform=ax.transAxes, weight=600, horizontalalignment="left",
embedder = manifold.SpectralEmbedding(1) embedding_l = embedder.fit_transform(overall_means['l']) embedding_r = embedder.fit_transform(overall_means['r']) mask_l = op.join(derivatives, ds, 'mean_mask_mni_space', '_mask_stnl', 'sub-01_desc-stnl_mask_resampled_trans_merged_mean.nii.gz') mask_r = op.join(derivatives, ds, 'mean_mask_mni_space', '_mask_stnr', 'sub-01_desc-stnr_mask_resampled_trans_merged_mean.nii.gz') mask_l = image.math_img('mask > 0.3', mask=mask_l) mask_r = image.math_img('mask > 0.3', mask=mask_r) tmp = op.join( derivatives, ds, 'fmriprep', 'sub-01', 'sub-01_task-randomdotmotion_run-01_space-T1w_desc-preproc_bold.nii.gz') masker_l = input_data.NiftiMasker(mask_l) masker_l.fit(tmp) masker_r = input_data.NiftiMasker(mask_r) masker_r.fit(tmp) masker_l.inverse_transform(embedding_l.T).to_filename( op.join(derivatives, ds, 'embedding', 'group_desc-stnl_embedding.nii.gz')) masker_r.inverse_transform(embedding_r.T).to_filename( op.join(derivatives, ds, 'embedding', 'group_desc-stnr_embedding.nii.gz')) #if __name__ == '__main__': #main('/home/shared/2018/subcortex/bias_task')
/ "derivatives" / "func_smooth-6mm" / subject / "func" / f"{subject}_task-heartbeat_run-1_space-MNI152NLin2009cAsym_desc-preproc-fwhm6mm_bold.nii.gz" ) label = mask.name.split(os.sep)[-1].split(".")[0] out_file = target_path / f"{subject}_task-heartbeat_run-1_desc-{label}_regressors.tsv" if not out_file.is_file(): label = mask.name.split(os.sep)[-1].split(".")[0] mask = str(mask) # load TR and dimension info with open(vol_path) as f: data = json.load(f) tr = data["RepetitionTime"] # extract signal seed_masker = input_data.NiftiMasker(mask, detrend=True, t_r=tr) seed_time_series = seed_masker.fit_transform( func_filename, confounds=str(confounds_path) ) seed_time_series = seed_time_series.mean(axis=1) mean_seed = seed_time_series.mean() seed_time_series -= mean_seed # mean centre np.savetxt(str(out_file), seed_time_series, fmt="%10.5f") print(str(out_file))
func_filenames = adhd_dataset.func # list of 4D nifti files for each subject mean_func_img = mean_img(func_filenames[0]) gm_msk = resample_to_img(source_img=gm_msk, target_img=mean_func_img, interpolation='nearest') #affine_tar, #interpolation='nearest', target_shape=sp.array([61,73,61])) print('First functional nifti image (4D) is at: %s' % func_filenames[0] ) # 4D data nifti_masker = input_data.NiftiMasker( standardize=True, mask_img=gm_msk, # mask_strategy='epi', # memory="nilearn_cache", memory_level=2, smoothing_fwhm=4, detrend=True) # Compute EPI based mask nifti_masker.fit(func_filenames[0]) mask_img = nifti_masker.mask_img_ plot_roi(mask_img, mean_func_img, display_mode='y', cut_coords=4, title="Mask") plt.show() # Load 75 time points per volume nii_img = index_img(func_filenames[0], slice(5, 75)) ref_mskd = nifti_masker.transform(nii_img).T all_data = sp.zeros( (ref_mskd.shape[0], ref_mskd.shape[1], len(func_filenames))) all_data[:, :, 0] = ref_mskd
#data_df = pd.read_csv('../data/interim/csv/info_epi_zscored_df.csv',index_col=[0],header=0) # # # ## In[4]: # # #data_df.tail() # # # ### define whole-brain masker # In[5]: masker = input_data.NiftiMasker( '%s/data/external/MNI152_T1_2mm_brain_mask.nii.gz' % supDir).fit() # ## In[6]: # # #plotting.plot_roi(masker.mask_img_); # # # ### Flip image Left-Right # In[7]: def make_flip(fileName):
def mask_nil(img_data, affine, mask): from nilearn import input_data nimg = nib.Nifti1Image(img_data, affine) mskr = input_data.NiftiMasker(mask) mskd = mskr.fit_transform(nimg) return mskd, mskr
def plot_t(self, fig, show_time_individual=False, show_time_average=False, ica_lookup=None, show_spectrum=False, show_time_group=False, coords=(0, 0, 0), significance_threshold=0.5, *args, **kwargs): # Determine Axes Layout if not (show_time_individual or show_time_average ) and not show_time_group and not show_spectrum: return # no plot to render fig.clear() gs = gridspec.GridSpec(2, 5) if not (show_time_individual or show_time_average) and show_time_group and not show_spectrum: axgr = plt.subplot(gs[:, :]) if not (show_time_individual or show_time_average) and show_time_group and show_spectrum: axgr, axps = plt.subplot(gs[:, 3:]), plt.subplot(gs[:, :3]) if (show_time_individual or show_time_average ) and not show_time_group and not show_spectrum: axts = plt.subplot(gs[:, :]) if (show_time_individual or show_time_average) and show_time_group and not show_spectrum: axts, axgr = plt.subplot(gs[:, 3:]), plt.subplot(gs[:, :3]) if (show_time_individual or show_time_average) and show_time_group and show_spectrum: axts, axgr, axps = plt.subplot(gs[:, 3:]), plt.subplot( gs[0, :3]), plt.subplot(gs[1, :3]) # Process Data & Plot dat = np.abs(self.gd['ica'][ica_lookup]['img'].get_data().astype( np.float)) > significance_threshold masked = image.new_img_like(self.gd['smri']['img'], dat.astype(np.int)) if show_time_individual: try: seed_masker = input_data.NiftiSpheresMasker( mask_img=masked, seeds=[coords], radius=0, detrend=False, standardize=False, t_r=4., memory='nilearn_cache', memory_level=1, verbose=0) ind_ts = seed_masker.fit_transform(self.gd['fmri']['img']) except: ind_ts = [] plt.plot(ind_ts, axes=axts, label='Voxel (%d, %d, %d) Time-Series' % (coords[0], coords[1], coords[2])) plt.xlabel('Time (s)') plt.ylabel('fMRI signal') axts.hold(True) if show_time_average: brain_masker = input_data.NiftiMasker(mask_img=masked, t_r=4., memory='nilearn_cache', memory_level=1, verbose=0) ts = brain_masker.fit_transform(self.gd['fmri']['img']) ave_ts = np.mean(ts, axis=1) plt.plot(ave_ts, axes=axts, label="Average Signal") plt.xlabel('Time (s)') plt.ylabel('fMRI signal') axts.hold(False) if show_time_group: # TODO: Plot Group Logic pass if show_spectrum: # TODO: Plot Power Spectrum Logic pass plt.tight_layout(pad=0.1)
# plt.show() # # break # # # ## clean and z-score the timecourse of each voxel # ### initalizing whole-brain masker objects # In[10]: masker = input_data.NiftiMasker( mask_img='%s/data/external/MNI152_T1_2mm_brain_mask.nii.gz'%supDir, smoothing_fwhm=6, detrend=True, standardize=True).fit() # ## In[11]: # # #plotting.plot_roi( masker.mask_img_ ); # # # ### extract data for one participant # select the participant #
""" Created on Wed Nov 6 15:37:15 2019 @author: Or Duek Global Correlation and Global Correlation regression """ import nilearn from nilearn import input_data import pandas as pd import numpy as np mask_file = '/home/oad4/scratch60/output_kpe1480_1468/fmriprep/sub-1468/ses-1/func/sub-1468_ses-1_task-rest_space-MNI152NLin6Asym_desc-brain_mask.nii.gz'#set a file to create the same voxel map for all subjects brain_masker = input_data.NiftiMasker(mask_img = mask_file, smoothing_fwhm=4, detrend=True, standardize=True, low_pass=0.1, high_pass=0.01, t_r=1., memory='/home/oad4/scratch60/nilearn', memory_level=1, verbose=2) #from nilearn.regions import Parcellations #ward = Parcellations(method='ward', n_parcels=1000, # standardize=True, detrend=True, smoothing_fwhm=2., # low_pass=0.1, high_pass=0.01, t_r=1., # memory='/media/Data/nilearn', memory_level=1, # verbose=1) def removeVars (confoundFile): # this method takes the csv regressors file (from fmriPrep) and chooses a few to confound. You can change those few import pandas as pd import numpy as np
def __init__(self, n_atoms, t_r, n_times_atom=60, hrf_model='scaled_hrf', hrf_atlas='havard', atlas_kwargs=dict(), n_scales='scale122', prox_z='tv', lbda_strategy='ratio', lbda=0.1, rho=2.0, delta_init=1.0, u_init_type='ica', z_init=None, prox_u='l1-positive-simplex', deactivate_v_learning=False, deactivate_z_learning=False, max_iter=100, random_state=None, early_stopping=True, eps=1.0e-5, raise_on_increase=True, cache_dir='__cache__', nb_fit_try=1, n_jobs=1, verbose=0): # model hyperparameters self.t_r = t_r self.n_atoms = n_atoms self.hrf_model = hrf_model self.hrf_atlas = hrf_atlas self.n_scales = n_scales self.deactivate_v_learning = deactivate_v_learning self.deactivate_z_learning = deactivate_z_learning self.n_times_atom = n_times_atom self.prox_z = prox_z self.lbda_strategy = lbda_strategy self.lbda = lbda self.rho = rho self.delta_init = delta_init self.u_init_type = u_init_type self.z_init = z_init self.prox_u = prox_u # convergence parameters self.max_iter = max_iter self.random_state = random_state self.early_stopping = early_stopping self.eps = eps self.raise_on_increase = raise_on_increase # technical parameters self.verbose = verbose self.n_jobs = n_jobs self.cache_dir = cache_dir self.nb_fit_try = nb_fit_try # HRF atlas if self.hrf_atlas == 'havard': self.mask_full_brain, self.atlas_rois = fetch_vascular_atlas() elif self.hrf_atlas == 'basc': n_scales_ = f"scale{int(n_scales)}" res = fetch_atlas_basc_2015(n_scales=n_scales_) self.mask_full_brain, self.atlas_rois = res elif isinstance(self.hrf_atlas, collections.Callable): res = self.hrf_atlas(**atlas_kwargs) self.mask_full_brain, self.atlas_rois = res else: raise ValueError(f"hrf_atlas should belong to ['havard', 'basc', " f"given-function], got {self.hrf_atlas}") self.hrf_rois = dict() # fMRI masker self.masker_ = input_data.NiftiMasker(mask_img=self.mask_full_brain, t_r=self.t_r, memory=self.cache_dir, memory_level=1, verbose=0) # model parameters self.z_hat_ = None self.u_hat_ = None self.a_hat_ = None # derivated model parameters self.Dz_hat_ = None self.v_hat_ = None # auxilaries parameters self.roi_label_from_hrf_idx = None self.v_init_ = None self.lbda_ = lbda self.lobj_ = None self.ltime_ = None
def main(study_dir, subject, roi, res_dir, blocks='combined'): # load task information vols = rsa.load_vol_info(study_dir, subject) if blocks == 'walk': events = vols.query('sequence_type == 1').copy() elif blocks == 'random': events = vols.query('sequence_type == 2').copy() elif blocks in ['combined', 'separate']: events = vols.query('sequence_type > 0').copy() if blocks == 'separate': # separately model trials in walk and random blocks n_item = events['trial_type'].nunique() events['trial_type'] = (events['trial_type'] + (events['sequence_type'] - 1) * n_item) else: raise ValueError(f'Invalid blocks option: {blocks}') # get mask image subject_dir = os.path.join(study_dir, f'tesser_{subject}') mask_image = os.path.join(subject_dir, 'anatomy', 'antsreg', 'data', 'funcunwarpspace', 'rois', 'mni', f'{roi}.nii.gz') # load masked functional images runs = list(range(1, 7)) bold_images = [ os.path.join(subject_dir, 'BOLD', 'antsreg', 'data', f'functional_run_{run}_bold_mcf_brain_corr_notemp.feat', 'filtered_func_data.nii.gz') for run in runs ] masker = input_data.NiftiMasker(mask_img=mask_image, standardize='zscore') image = np.vstack( [masker.fit_transform(bold_image) for bold_image in bold_images]) # load confound files confound = {} for run in runs: confound_file = os.path.join(subject_dir, 'BOLD', f'functional_run_{run}', 'QA', 'confound.txt') confound[run] = np.loadtxt(confound_file) # create full design matrix frame_times = np.arange(image.shape[0] / len(runs)) * 2 n_ev = events['trial_type'].nunique() evs = np.arange(1, n_ev + 1) df_list = [] for run in runs: df_run = fl.make_first_level_design_matrix( frame_times, events=events.query(f'run == {run}'), add_regs=confound[run]) regs = df_run.filter(like='reg', axis=1).columns drifts = df_run.filter(like='drift', axis=1).columns columns = np.hstack((evs, drifts, ['constant'], regs)) df_list.append(df_run.reindex(columns=columns)) df_mat = pd.concat(df_list, axis=0) # with confounds included, the number of regressors varies by run. # Columns missing between runs are set to NaN df_mat.fillna(0, inplace=True) mat = df_mat.to_numpy()[:, :n_ev] nuisance = df_mat.to_numpy()[:, n_ev:] # run Bayesian RSA scan_onsets = np.arange(0, image.shape[0], image.shape[0] / len(runs)) model = brsa.GBRSA() model.fit([image], [mat], nuisance=nuisance, scan_onsets=scan_onsets) # save results if not os.path.exists(res_dir): os.makedirs(res_dir) var_names = [ 'U', 'L', 'C', 'nSNR', 'sigma', 'rho', 'beta', 'beta0', 'X0', 'beta0_null', 'X0_null', 'n_nureg' ] results = {var: getattr(model, var + '_') for var in var_names} out_file = os.path.join(res_dir, f'sub-{subject}_brsa.npz') np.savez(out_file, **results)
'resting-state-0', 'nakatomi1.feat', 'filtered_func_data.nii.gz') confound = join(parent_dir, s, 'session-0', 'resting-state', 'resting-state-0', 'nakatomi1.feat', 'mc', 'prefiltered_func_data_mcf.par') #hypothal_roi = join(roi_dir, s, 'roi', 'hypothal-func.nii.gz') hb_func = join(parent_dir, s, 'session-0', 'anatomical', 'anatomical-0', 'hb-func.nii.gz') hb_roi_qc = join(roi_dir, 'roi-qc', '{0}-hb-func.png'.format(s)) mean_func = mean_img(fmri_file) plotting.plot_roi(hb_func, mean_func, output_file=hb_roi_qc) roi_masker = input_data.NiftiMasker(hb_func, detrend=False, standardize=True, t_r=3., memory='nilearn_cache', memory_level=1, verbose=0) roi_timeseries = roi_masker.fit_transform(fmri_file, confounds=confound) print 'extracted hb timeseries' brain_masker = input_data.NiftiMasker(detrend=False, standardize=True, t_r=3., smoothing_fwhm=3., memory='nilearn_cache', memory_level=1, verbose=1) brain_timeseries = brain_masker.fit_transform(fmri_file, confounds=confound)
tomoya_dir = '/Shared/lss_kahwang_hpc/data/Tomoya/' mdtb_subs = [ 'sub-02', 'sub-04', 'sub-09', 'sub-14', 'sub-17', 'sub-19', 'sub-21', 'sub-24', 'sub-26', 'sub-28', 'sub-31', 'sub-03', 'sub-06', 'sub-12', 'sub-15', 'sub-18', 'sub-20', 'sub-22', 'sub-25', 'sub-27', 'sub-30' ] tomoya_subs = ['sub-01', 'sub-02', 'sub-03', 'sub-04', 'sub-05', 'sub-06'] Schaefer400 = nib.load( '/Shared/lss_kahwang_hpc/ROIs/Schaefer2018_400Parcels_7Networks_order_FSLMNI152_2mm.nii.gz' ) Schaefer400_masker = input_data.NiftiLabelsMasker(Schaefer400) mni_thalamus_mask = nib.load( "/Shared/lss_kahwang_hpc/ROIs//mni_atlas/MNI_thalamus_2mm.nii.gz") mni_thalamus_masker = input_data.NiftiMasker(mni_thalamus_mask) mdtb_fcmats = np.zeros((2445, 400, len(mdtb_subs))) for i, sub in enumerate(mdtb_subs): func_file = nib.load(mdtb_dir + "3dDeconvolve/" + sub + "/FIRmodel_errts_block.nii.gz") cortical_ts = Schaefer400_masker.fit_transform(func_file) roi_ts = mni_thalamus_masker.fit_transform( func_file) #roi_ts = data[np.nonzero(mni_thalamus_mask.get_fdata())] roi_ts = np.delete(roi_ts, np.where(roi_ts.mean(axis=1) == 0)[0], axis=0) cortical_ts = np.delete(cortical_ts, np.where(cortical_ts.mean(axis=1) == 0)[0], axis=0)
def seed_to_voxel_corr(func_filename, confound_filename, resultdir='.', seed_coord=[(0, -52, 18)], output_head='DMN', maps_img='', mask_img=None): #print(func_filename) #print(confound_filename) mask_or_seed = 0 if maps_img == '': mask_or_seed = 1 seed_masker = input_data.NiftiSpheresMasker(seed_coord, radius=8, detrend=True, standardize=True, mask_img=mask_img, verbose=0) #memory='nilearn_cache', memory_level=1, verbose=0) else: mask_or_seed = 0 seed_masker = input_data.NiftiMapsMasker(maps_img=[maps_img], standardize=True, mask_img=mask_img, verbose=0) #memory='nilearn_cache', seed_time_series = seed_masker.fit_transform(func_filename, confounds=[confound_filename]) brain_masker = input_data.NiftiMasker(smoothing_fwhm=6, detrend=True, standardize=True, memory_level=1, verbose=0) brain_time_series = brain_masker.fit_transform( func_filename, confounds=[confound_filename]) ''' fig = plt.figure(figsize=(6,3), dpi=300) plt.plot(seed_time_series) plt.title('Seed time series') plt.xlabel('Scan number') plt.ylabel('Normalized signal') plt.tight_layout() fig.savefig(join(resultdir,'%s_curve.png' % output_head), bbox_inches='tight') ''' seed_based_correlations = np.dot( brain_time_series.T, seed_time_series) / seed_time_series.shape[0] print("seed-based correlation shape: (%s, %s)" % seed_based_correlations.shape) print("seed-based correlation: min = %.3f; max = %.3f" % (seed_based_correlations.min(), seed_based_correlations.max())) seed_based_correlations_fisher_z = np.arctanh(seed_based_correlations) print( "seed-based correlation Fisher-z transformed: min = %.3f; max = %.3f" % (seed_based_correlations_fisher_z.min(), seed_based_correlations_fisher_z.max())) # Finally, we can tranform the correlation array back to a Nifti image # object, that we can save. seed_based_corr_img = brain_masker.inverse_transform( seed_based_correlations.T) seed_based_corr_img.to_filename( join(resultdir, '%s_z.nii.gz') % output_head) ''' display = plotting.plot_stat_map(seed_based_corr_img, threshold=0.3, cut_coords=(0,0,0), draw_cross=False) if mask_or_seed == 1: display.add_markers(marker_coords=seed_coord, marker_color='g', marker_size=20) # At last, we save the plot as pdf. #display.savefig(join(resultdir,'%s_z.pdf') % output_head) display.savefig(join(resultdir,'%s_z.jpg') % output_head) plt.close() ''' return join(resultdir, '%s_z.nii.gz') % output_head
def __init__(self, n_atoms, t_r, n_times_atom=60, hrf_model='scaled_hrf', hrf_atlas='aal3', atlas_kwargs=dict(), n_scales='scale122', prox_z='tv', lbda_strategy='ratio', lbda=0.1, rho=2.0, delta_init=1.0, u_init_type='ica', eta=10.0, z_init=None, prox_u='l1-positive-simplex', deactivate_v_learning=False, shared_spatial_maps=False, deactivate_z_learning=False, idx_first_vols=0, standardize=False, detrend=False, low_pass=None, high_pass=None, max_iter=100, random_state=None, early_stopping=True, eps=1.0e-5, raise_on_increase=True, cache_dir='__cache__', nb_fit_try=1, n_jobs=1, verbose=0): # model hyperparameters self.t_r = t_r self.n_atoms = n_atoms self.hrf_model = hrf_model self.hrf_atlas = hrf_atlas self.n_scales = n_scales self.shared_spatial_maps = shared_spatial_maps self.deactivate_v_learning = deactivate_v_learning self.deactivate_z_learning = deactivate_z_learning self.n_times_atom = n_times_atom self.prox_z = prox_z self.lbda_strategy = lbda_strategy self.lbda = lbda self.rho = rho self.delta_init = delta_init self.u_init_type = u_init_type self.eta = eta self.z_init = z_init self.prox_u = prox_u # convergence parameters self.max_iter = max_iter self.random_state = random_state self.early_stopping = early_stopping self.eps = eps self.raise_on_increase = raise_on_increase # preprocessing parameters self.idx_first_vols = idx_first_vols self.standardize = standardize self.detrend = detrend self.low_pass = low_pass self.high_pass = high_pass # technical parameters self.verbose = verbose self.n_jobs = n_jobs self.cache_dir = cache_dir self.nb_fit_try = nb_fit_try # HRF atlas if self.hrf_atlas == 'aal3': self.mask_full_brain, self.atlas_rois = fetch_aal3_vascular_atlas() elif self.hrf_atlas == 'aal': self.mask_full_brain, self.atlas_rois = fetch_aal_vascular_atlas() elif self.hrf_atlas == 'harvard': res = fetch_harvard_vascular_atlas() self.mask_full_brain, self.atlas_rois = res elif self.hrf_atlas == 'basc': n_scales_ = f"scale{int(n_scales)}" res = fetch_basc_vascular_atlas(n_scales=n_scales_) self.mask_full_brain, self.atlas_rois = res elif hasattr(self.hrf_atlas, '__call__'): res = self.hrf_atlas(**atlas_kwargs) self.mask_full_brain, self.atlas_rois = res else: raise ValueError(f"hrf_atlas should belong to ['aal3', 'harvard', " f"'basc', given-function], got {self.hrf_atlas}") self.hrf_rois = dict() # fMRI masker self.masker_ = input_data.NiftiMasker(mask_img=self.mask_full_brain, t_r=self.t_r, memory=self.cache_dir, memory_level=1, verbose=0) # model parameters self.n_subjects = None self.z_hat_ = None self.u_hat_ = None self.a_hat_ = None self.u_hat_img_ = None self.a_hat_img_ = None # derivated model parameters self.Dz_hat_ = None self.v_hat_ = None # auxilaries parameters self.roi_label_from_hrf_idx = None self.v_init_ = None self.lbda_ = lbda self.lobj_ = None self.ltime_ = None
n_display_samples = 4 memory = 'nilearn_cache' plots = [1, 2, 3] # dataset_fn = datasets.fetch_nyu_rest dataset_fn = datasets.fetch_haxby # Load data dataset = dataset_fn(n_subjects=subject_idx + 1) func_filename = dataset.func[subject_idx] # This is resting-state data: the background has not been removed yet, # thus we need to use mask_strategy='epi' to compute the mask from the # EPI images nifti_masker = input_data.NiftiMasker(memory=memory, memory_level=1, verbose=10, mask_strategy='epi', standardize=False) # Mask the data fmri_masked = nifti_masker.fit_transform(func_filename) mask = nifti_masker.mask_img_.get_data().astype(np.bool) # Augment the features with spatial information. X = np.asarray(np.where(mask)).T.astype(float) factors = (0., 0., 0.) types = (float, float, float) for ai, axis in enumerate(range(3)): data_axis = X[:, axis] data_range = float(data_axis.max() - data_axis.min()) hemi = (data_axis - np.median(data_axis)) / float(data_range) if types[ai] == bool:
def main(derivatives, ds='ds-02'): subjects = ['{:02d}'.format(i) for i in range(1, 16)] subjects.pop(0) # 1 subjects.pop(2) # 4 mask_l = op.join( derivatives, ds, 'mean_mask_mni_space/_mask_stnl', 'sub-01_desc-stnl_mask_resampled_trans_merged_mean.nii.gz') mask_r = op.join( derivatives, ds, 'mean_mask_mni_space/_mask_stnr', 'sub-01_desc-stnr_mask_resampled_trans_merged_mean.nii.gz') mask_l = image.math_img('mask > 0.3', mask=mask_l) mask_r = image.math_img('mask > 0.3', mask=mask_r) #mask = image.load_img(mask) masker_l = input_data.NiftiMasker(mask_l, detrend=True, standardize=True) masker_r = input_data.NiftiMasker(mask_r, detrend=True, standardize=True) data_stn_l = [] data_stn_r = [] for subject in subjects: surfs = [] data_stn_l = [] data_stn_r = [] if subject == '07': n_runs = 2 else: n_runs = 3 for run in range(1, n_runs + 1): lh = surface.load_surf_data( op.join( derivatives, ds, 'smoothed_surfaces/sub-{subject}/func/sub-{subject}_task-randomdotmotion_run-{run:02d}_space-fsaverage_desc-smoothed_hemi-lh.gii' .format(**locals()))).T rh = surface.load_surf_data( op.join( derivatives, ds, 'smoothed_surfaces/sub-{subject}/func/sub-{subject}_task-randomdotmotion_run-{run:02d}_space-fsaverage_desc-smoothed_hemi-rh.gii' .format(**locals()))).T confounds = pd.read_table( op.join( derivatives, ds, 'fmriprep/sub-{subject}/func/sub-{subject}_task-randomdotmotion_run-{run:02d}_desc-confounds_regressors.tsv' .format(**locals()))) confounds.fillna(method='bfill', inplace=True) im = op.join( derivatives, ds, 'fmriprep/sub-{subject}/func/sub-{subject}_task-randomdotmotion_run-{run:02d}_space-T1w_desc-preproc_bold.nii.gz' .format(**locals())) surf = np.concatenate((lh, rh), 1) surf = signal.clean(surf, standardize=True, confounds=confounds[include].values) surfs.append(surf) d = masker_l.fit_transform(im, confounds=confounds[include].values) data_stn_l.append(d) d = masker_r.fit_transform(im, confounds=confounds[include].values) data_stn_r.append(d) surfs = np.array(surfs) data_stn_l = np.array(data_stn_l) data_stn_r = np.array(data_stn_r) rs_l = np.array([ data_stn_l[i].T.dot(surfs[i]) / data_stn_l.shape[1] for i in range(n_runs) ]) rs_r = np.array([ data_stn_r[i].T.dot(surfs[i]) / data_stn_r.shape[1] for i in range(n_runs) ]) np.savez_compressed( op.join(derivatives, ds, 'surface_correlations', 'sub-{subject}_surfs.npz'.format(**locals())), surfs) np.savez_compressed( op.join(derivatives, ds, 'surface_correlations', 'sub-{subject}_stn_l.npz'.format(**locals())), data_stn_l) np.savez_compressed( op.join(derivatives, ds, 'surface_correlations', 'sub-{subject}_stn_r.npz'.format(**locals())), data_stn_r) np.savez_compressed( op.join(derivatives, ds, 'surface_correlations', 'sub-{subject}_rs_l.npz'.format(**locals())), rs_l) np.savez_compressed( op.join(derivatives, ds, 'surface_correlations', 'sub-{subject}_rs_r.npz'.format(**locals())), rs_r)
hb_func = join(roi_dir, '{0}-hb-kb.nii.gz'.format(s)) hb_roi_qc = join(sink_dir, 'roi-qc', '{0}-{1}-hb-func.png'.format(s, run)) avg_func = join(sink_dir, 'mean_func.nii.gz') hb = join(roi_dir, '{0}-{1}-hb-resampled.nii.gz'.format(s, run)) mean_func = mean_img(fmri_file).to_filename(avg_func) hb_resampled = resample_to_img(hb_func, avg_func, interpolation='nearest') hb_resampled.to_filename(hb) plotting.plot_roi(hb, avg_func, output_file=hb_roi_qc) roi_masker = input_data.NiftiMasker(hb, detrend=False, standardize=True, t_r=1.) roi_timeseries = roi_masker.fit_transform(fmri_file) print 'extracted hb timeseries' brain_masker = input_data.NiftiMasker(detrend=False, standardize=True, t_r=1., smoothing_fwhm=3.) brain_timeseries = brain_masker.fit_transform(fmri_file) print 'extracted brain timeseries' hb_ts = np.mean(roi_timeseries, axis=1) #hb = roi_timeseries[:,1] print hb_ts.shape sbc_hb = np.dot(brain_timeseries.T, hb_ts) / hb_ts.shape[0]
def nuisance_regress(inputimg, confoundsfile, inputmask, inputtr=0, conftype="36P", spikethr=0.25, smoothkern=6.0, discardvols=4, highpassval=0.008, lowpassval=0.08): """ returns a nibabel.nifti1.Nifti1Image that is cleaned in following ways: detrending, smoothed, motion parameter regress, spike regress, bandpass filtered, and normalized options for motion paramter regress: 36P, 9P, 6P, or aCompCor signal cleaning params from: Parkes, L., Fulcher, B., Yücel, M., & Fornito, A. (2018). An evaluation of the efficacy, reliability, and sensitivity of motion correction strategies for resting-state functional MRI. NeuroImage, 171, 415-436. Ciric, R., Wolf, D. H., Power, J. D., Roalf, D. R., Baum, G. L., Ruparel, K., ... & Gur, R. C. (2017). Benchmarking of participant-level confound regression strategies for the control of motion artifact in studies of functional connectivity. Neuroimage, 154, 174-187. """ # extract confounds confounds, outlier_stats = get_confounds(confoundsfile, kind=conftype, spikereg_threshold=spikethr) # check highpass low pass if highpassval >= lowpassval: print("high and low pass values dont make sense. exiting") exit(1) # check tr if inputtr == 0: # read the tr from the fourth dimension of zooms, this depends on the input # data being formatted to have the dim4 be the TR... tr = inputimg.header.get_zooms()[3] print("found that tr is: {}".format(str(tr))) if tr == 0: print("thats not a good tr. exiting") exit(1) else: tr = inputtr if inputmask is not None: print("cleaning image with masker") # masker params masker_params = { "mask_img": inputmask, "detrend": True, "standardize": True, "low_pass": lowpassval, "high_pass": highpassval, "t_r": tr, "smoothing_fwhm": smoothkern, "verbose": 1, } # invoke masker masker = input_data.NiftiMasker(**masker_params) # perform the nuisance regression time_series = masker.fit_transform(inputimg, confounds=confounds.values) # inverse masker operation to get the nifti object, n.b. this returns a Nifti1Image!!! outimg = masker.inverse_transform(time_series) else: # no mask! so no masker print("cleaning image with no mask") clean_params = { "confounds": confounds.values, "detrend": True, "standardize": True, "low_pass": lowpassval, "high_pass": highpassval, "t_r": tr, } loadimg = image.load_img(inputimg) outimg = image.clean_img(loadimg, **clean_params) # get rid of the first N volumes #outimgtrim = image.index_img(outimg, np.arange(discardvols, outimg.shape[3])) if discardvols > 0: outimgtrim = image_drop_dummy_trs(outimg, discardvols) else: outimgtrim = outimg return outimgtrim, confounds, outlier_stats
counter=0 #n_perm=100 n_perm=10000 # perm_count=np.zeros([n_perm]) all_perms=np.arange(0, n_perm) #np.arange(0, len(mask_index[0])) n_splits=n_perm/100 all_perms=np.array_split(all_perms, n_splits) maskfile='./mynewgreymask.nii.gz' #MAKE SURE TO HAVE YOUR MASK IN THE CWD gm_mask = nib.load(maskfile) print "mask loaded" print gm_mask.shape main_masker=input_data.NiftiMasker(mask_img=gm_mask) mm=main_masker.fit_transform(gm_mask) #print gm_mask.shape #We also create an index through the mask current_mask=np.array((gm_mask.get_data()==1)) print current_mask.shape[0], current_mask.shape[1],current_mask.shape[2] mask_index=np.array(np.where(current_mask)) print mask_index.shape mask_tree=KDTree(mask_index.T) #np.unravel_index(current_mask, 3) ####mask_coords = np.asarray(list(zip(*mask_index))) #This one will hold the real group statistic #spheres=mask_tree.query_radius(mask_tree, 8) #print len(spheres) stat_map=np.zeros_like(mm).T #This one will hold significances. Both need to have the same shape
def feature_extractor(imgfile, maskfile, featurefile, maskerfile, wardfile, nclusters=[ 1000, ], selectfile=None, targetfile=None, metafile=None, cachefile=None): resultdict = {"imgfile": imgfile, "maskfile": maskfile} # load data print "--loading data" nifti_masker = input_data.NiftiMasker(mask=maskfile, memory=cachefile, memory_level=1, standardize=False) fmri_masked = nifti_masker.fit_transform(imgfile) print "--getting mask" mask = nifti_masker.mask_img_.get_data().astype(np.bool) # saveit joblib.dump(nifti_masker, maskerfile) resultdict["mask"] = mask resultdict["Xmask"] = fmri_masked resultdict["maskerfile"] = maskerfile # get connectivity print "--getting connectivity" shape = mask.shape connectivity = image.grid_to_graph(n_x=shape[0], n_y=shape[1], n_z=shape[2], mask=mask) # saveit resultdict["connectivity"] = connectivity print "--save main file" np.savez(featurefile + "_main.npz", **resultdict) # run ward y = np.load(targetfile)["ymap"] meta = np.load(metafile) train = meta["train"] test = meta["test"] ncv = meta['ycv'] # for each cv set for cvx in range(ncv): trainidx = train[cvx] testidx = test[cvx] resultdict = {} wardfiles = [] selectfiles = [] print "--Running ward %d" % (cvx, ) for ix, nc in enumerate(nclusters): ward = WardAgglomeration(n_clusters=nc, connectivity=connectivity, memory=cachefile) ward.fit(fmri_masked[trainidx]) fmri_reduced_train = ward.transform(fmri_masked[trainidx]) fmri_reduced_test = ward.transform(fmri_masked[testidx]) # saveit subwardfile = wardfile + "_D%d_cv%d.pkl" % ( nc, cvx, ) joblib.dump(ward, subwardfile) resultdict["Xward_%d_train" % (nc, )] = fmri_reduced_train resultdict["Xward_%d_test" % (nc, )] = fmri_reduced_test wardfiles.append(subwardfile) # additional feature selection selector = SelectPercentile(f_classif, percentile=30) selector.fit(fmri_reduced_train, y[trainidx]) fmri_select_train = selector.transform(fmri_reduced_train) fmri_select_test = selector.transform(fmri_reduced_test) # saveit subselectfile = selectfile + "_D%d_cv%d.pkl" % ( nc, cvx, ) joblib.dump(selector, subselectfile) resultdict["Xselect_%d_train" % (nc, )] = fmri_select_train resultdict["Xselect_%d_test" % (nc, )] = fmri_select_test selectfiles.append(subselectfile) resultdict["wardfiles"] = wardfiles resultdict["selectfiles"] = selectfiles # save results print "--save cv result" np.savez(featurefile + "_cv%d.npz" % (cvx, ), **resultdict)
def abide1_partial_seed(scale, confound_scale, confound_rois, n_cpu): # Make sure the confound_rois are in an iterable try: iter(confound_rois) except TypeError: print( f'confound_rois should be an iterable. I will see if I can wrap it in a list' ) if not type(confound_rois) == int: raise Exception( f'confound_rois is not an iterable and also not an integer. It is {type(confound_rois)}. ' f'I cannot deal with this and will end here.') confound_rois = list(confound_rois) # Paths root_p = pal.Path(__file__).resolve().parents[2] / 'data' pheno_p = root_p / 'pheno/ABIDE1_Pheno_PSM_matched_minimum_10.tsv' atlas_p = root_p / f'ATLAS/MIST/Parcellations/MIST_{scale}_nocereb.nii.gz' confound_p = root_p / f'ATLAS/MIST/Parcellations/MIST_{confound_scale}_nocereb.nii.gz' atlas_labels_p = root_p / f'ATLAS/MIST/Parcel_Information/MIST_{scale}_nocereb.csv' confound_labels_p = root_p / f'ATLAS/MIST/Parcel_Information/MIST_{confound_scale}_nocereb.csv' mask_p = root_p / 'ATLAS/MIST/Parcellations/MIST_mask_nocereb.nii.gz' hier_p = root_p / 'ATLAS/MIST/Hierarchy/MIST_PARCEL_ORDER.csv' # Data fc_p = root_p / 'preprocessed/time_series/abide_1/' fc_t = 'fmri_sub{:07}_session{}_run{}_scrubbed.nii.gz' # Output out_t = f'sub_{{}}_ses_{{}}_run{{}}_mist_{scale}_children_of_' \ f'{"_and_".join(map(str, confound_rois))}_mist_{confound_scale}.npy' out_p = root_p / f'preprocessed/seed_maps/abide_1/MIST_{scale}' if not out_p.is_dir(): out_p.mkdir() # Load inputs pheno = pd.read_csv(pheno_p, sep='\t') mask_i = nib.load(str(mask_p)) atlas_labels = pd.read_csv(atlas_labels_p, sep=';') confound_labels = pd.read_csv(confound_labels_p, sep=';') # Get the hierarchy hier = pd.read_csv(hier_p) ordered_labels = list() for i in hier[f's{scale}'].values: if i not in ordered_labels: ordered_labels.append(i) atlas_networks = np.array(ordered_labels) confound_network_list = np.array([ hier.loc[hier[f's{scale}'] == i][f's{confound_scale}'].values[0] for i in ordered_labels ]) mist_mask_i = nib.load(str(mask_p)) masker = nid.NiftiMasker(mask_img=mist_mask_i) masker.fit() # Get the atlas atlas_i = nib.load(str(atlas_p)) confound_i = nib.load(str(confound_p)) atlas = masker.transform(atlas_i) confound = masker.transform(confound_i) # Find the regions and give their names # Pick the atlas child networks that belong to the confound regions confound_names = list( confound_labels.query('roi in @confound_rois')['label'].values) children = np.array([ atlas_roi for confound_roi in confound_rois for atlas_roi in atlas_networks[confound_network_list == confound_roi] ]) children_names = list( atlas_labels.query('roi in @children')['label'].values) print( f'I am generating seed maps for the children of {confound_names} from MIST_{confound_scale} ' f'in MIST_{scale}. These children are:\n{children_names}') # Build the new atlases confound_mask = np.array([ 1 if confound[0, idx] in confound_rois else 0 for idx in range(confound.shape[1]) ]) subset_atlas = np.array([ 0 if not atlas[0, idx] in children else atlas[0, idx] for idx in range(atlas.shape[1]) ]) confound_mask_i = masker.inverse_transform(confound_mask) subset_atlas_i = masker.inverse_transform(subset_atlas) path_list = [ (fc_p / fc_t.format(row['SUB_ID'], row['session'], row['run']), out_p / out_t.format(row['SUB_ID'], row['session'], row['run'])) for rid, row in pheno.iterrows() ] for path_in, path_out in path_list: if not path_in.is_file(): print(f'Path does not exist: {path_in}') func_in_paths, func_out_paths = zip(*path_list) job_list = [{ 'func_in_p': p_in, 'sca_out_p': p_out, 'atlas_img': subset_atlas_i, 'mask_img': mask_i, 'confound_img': confound_mask_i } for p_in, p_out in path_list] with futures.ThreadPoolExecutor(max_workers=n_cpu) as executor: futs = [ executor.submit(asdfc.wrappers.wrap_seed_based_correlation, **job_args) for job_args in job_list ] for future in tqdm(futures.as_completed(futs), total=len(job_list)): pass print('All Done!')
""" ### Load nyu_rest dataset ##################################################### import numpy as np from nilearn import datasets from nilearn import input_data from nilearn.plotting.img_plotting import plot_roi, plot_epi nyu_dataset = datasets.fetch_nyu_rest(n_subjects=1) # This is resting-state data: the background has not been removed yet, # thus we need to use mask_strategy='epi' to compute the mask from the # EPI images nifti_masker = input_data.NiftiMasker(memory='nilearn_cache', mask_strategy='epi', memory_level=1, standardize=False) func_filename = nyu_dataset.func[0] fmri_masked = nifti_masker.fit_transform(func_filename) mask = nifti_masker.mask_img_.get_data().astype(np.bool) ### Ward ###################################################################### # Compute connectivity matrix: which voxel is connected to which from sklearn.feature_extraction import image shape = mask.shape connectivity = image.grid_to_graph(n_x=shape[0], n_y=shape[1], n_z=shape[2], mask=mask)
def sbc_one_session(subject, session, fmriprep_dir, output_dir, tr): confounds_file, brainmask_file, rs_file, anat_file = get_files( fmriprep_dir, subject, session) out_stub = "{}_{}".format(subject, session) # look for output files out_file_nii = os.path.join(output_dir, "sbc_pcc_1_" + out_stub + ".nii.gz") out_file_thresh = os.path.join( output_dir, "sbc_pcc_2_fisherz_thrsh0.5_" + out_stub + ".png") out_file_report = os.path.join(output_dir, "sbc_pcc_9_info_" + out_stub + ".txt") if not (os.path.exists(out_file_thresh) and os.path.exists(out_file_nii) and os.path.exists(out_file_report)): print("*** Running SBC for {} {} ***".format(subject, session)) # see http://nilearn.github.io/auto_examples/03_connectivity/plot_seed_to_voxel_correlation.html pcc_coords = [(0, -52, 18)] lp_freq = 0.1 hp_freq = 0.01 # load confounds confounds, outlier_stats = get_confounds(confounds_file) # extract data from seed ROI seed_masker = input_data.NiftiSpheresMasker(pcc_coords, radius=8, mask_img=brainmask_file, detrend=True, standardize=True, low_pass=lp_freq, high_pass=hp_freq, t_r=tr) seed_time_series = seed_masker.fit_transform( rs_file, confounds=confounds.values) # extract data for the entire brain brain_masker = input_data.NiftiMasker(smoothing_fwhm=6, mask_img=brainmask_file, detrend=True, standardize=True, low_pass=lp_freq, high_pass=hp_freq, t_r=tr) brain_time_series = brain_masker.fit_transform( rs_file, confounds=confounds.values) # calculate correlation seed_based_correlations = np.dot(brain_time_series.T, seed_time_series) / \ seed_time_series.shape[0] seed_based_correlations_fisher_z = np.arctanh(seed_based_correlations) # plot seed_based_correlation_img = brain_masker.inverse_transform( seed_based_correlations_fisher_z.T) seed_based_correlation_img.to_filename(out_file_nii) display = plotting.plot_stat_map(seed_based_correlation_img, threshold=0.5, bg_img=anat_file, cut_coords=pcc_coords[0], title=out_stub + " (fisher z)") display.add_markers(marker_coords=pcc_coords, marker_color='g', marker_size=300) display.savefig(out_file_thresh) display.close() # report report = "Confounds:\n" report += "\n".join(confounds.columns) + "\n\n" report += "lp_freq: {}\n".format(lp_freq) report += "hp_freq: {}\n".format(hp_freq) report += "confounds_file: {}\n".format(confounds_file) report += "brainmask_file: {}\n".format(brainmask_file) report += "rs_file: {}\n".format(rs_file) report += "anat_file: {}\n\n".format(anat_file) report += confounds.to_string() with open(out_file_report, "w") as fi: fi.write(report) else: print("*** SBC for {} {} already computed. Do nothing. ***".format( subject, session))