def filterFSL(input_file, highpass, tempMean): outputSFRGR = os.path.join( os.path.dirname(input_file), os.path.basename(input_file).split('SRGR')[0]) + 'SFRGR.nii.gz' myHP = fsl.TemporalFilter(in_file=input_file, highpass_sigma=highpass, args='-add ' + tempMean, out_file=outputSFRGR) print(myHP.cmdline) myHP.run() input_file = outputSFRGR output_file = os.path.join( os.path.dirname(input_file), os.path.basename(input_file).split('.')[0]) + '_thres_mask.nii.gz' #input_file = getMean(input_file,'HPmean') thres = fsl.Threshold(in_file=input_file, thresh=17, out_file=output_file, output_datatype='float', use_robust_range=True, args='-Tmean -bin') print(thres.cmdline) thres.run() return outputSFRGR
def test_TemporalFilter(tmp_path): seed(a=0x4d3c732f) array = np.random.rand(10, 10, 10, 100) * 1000 + 10000 img = nib.Nifti1Image(array, np.eye(4)) os.chdir(str(tmp_path)) in_file = "img.nii.gz" nib.save(img, in_file) instance = TemporalFilter() instance.inputs.in_file = in_file instance.inputs.lowpass_sigma = 12 instance.inputs.highpass_sigma = 125 result = instance.run() r0 = nib.load(result.outputs.out_file).get_fdata() instance = fsl.TemporalFilter() instance.inputs.in_file = in_file instance.inputs.lowpass_sigma = 12 instance.inputs.highpass_sigma = 125 result = instance.run() r1 = nib.load(result.outputs.out_file).get_fdata() assert np.allclose(r0, r1)
def test_TemporalFilter(tmp_path): seed(a=0x4D3C732F) array = np.random.rand(10, 10, 10, 100) * 1000 + 10000 img = nib.Nifti1Image(array, np.eye(4)) assert isinstance(img.header, nib.Nifti1Header) img.header.set_data_dtype(np.float64) os.chdir(str(tmp_path)) in_file = "img.nii.gz" nib.save(img, in_file) instance = TemporalFilter() instance.inputs.in_file = in_file instance.inputs.lowpass_sigma = 12 instance.inputs.highpass_sigma = 125 result = instance.run() assert result.outputs is not None r0 = nib.load(result.outputs.out_file).get_fdata() instance = fsl.TemporalFilter() instance.inputs.in_file = in_file instance.inputs.lowpass_sigma = 12 instance.inputs.highpass_sigma = 125 result = instance.run() assert result.outputs is not None r1 = nib.load(result.outputs.out_file).get_fdata() assert np.allclose(r0, r1)
def mod_filter(in_file, algorithm, lowpass_freq, highpass_freq, tr): import os from nipype.utils.filemanip import fname_presuffix if algorithm == 'fsl': import nipype.interfaces.fsl as fsl filter = fsl.TemporalFilter() filter.inputs.in_file = in_file if highpass_freq < 0: filter.inputs.highpass_sigma = -1 else: filter.inputs.highpass_sigma = 1 / (2 * tr * highpass_freq) if lowpass_freq < 0: filter.inputs.lowpass_sigma = -1 else: filter.inputs.lowpass_sigma = 1 / (2 * tr * lowpass_freq) res = filter.run() out_file = res.outputs.out_file else: import nitime.fmri.io as io from nitime.analysis import FilterAnalyzer import nibabel as nib import numpy as np T = io.time_series_from_file(in_file, TR=tr) if highpass_freq < 0: highpass_freq = 0 if lowpass_freq < 0: lowpass_freq = None filt_order = np.floor(T.shape[3] / 3) if filt_order % 2 == 1: filt_order -= 1 F = FilterAnalyzer(T, ub=lowpass_freq, lb=highpass_freq, filt_order=filt_order) if algorithm == 'IIR': Filtered_data = F.iir.data suffix = '_iir_filt' elif algorithm == 'Boxcar': Filtered_data = F.filtered_boxcar.data suffix = '_boxcar_filt' elif algorithm == 'Fourier': Filtered_data = F.filtered_fourier.data suffix = '_fourier_filt' elif algorithm == 'FIR': Filtered_data = F.fir.data suffix = '_fir_filt' else: raise ValueError('Unknown Nitime filtering algorithm: %s' % algorithm) out_file = fname_presuffix(in_file, suffix=suffix, newpath=os.getcwd()) out_img = nib.Nifti1Image(Filtered_data, nib.load(in_file).get_affine()) out_img.to_filename(out_file) return out_file
def create_filtering_workflow(name="filter", hpf_cutoff=128, TR=2, output_name="timeseries"): """Scale and high-pass filter the timeseries.""" inputnode = Node(IdentityInterface(["timeseries", "mask_file"]), "inputs") # Grand-median scale within the brain mask scale = MapNode(ScaleTimeseries(statistic="median", target=10000), ["in_file", "mask_file"], "scale") # Gaussian running-line filter if hpf_cutoff is None: hpf_sigma = -1 else: hpf_sigma = (hpf_cutoff / 2.0) / TR filter = MapNode(fsl.TemporalFilter(highpass_sigma=hpf_sigma), "in_file", "filter") # Possibly replace the mean # (In later versions of FSL, the highpass filter removes the # mean component. Put it back, but be flexible so this isn't # broken on older versions of FSL). replacemean = MapNode(ReplaceMean(output_name=output_name), ["orig_file", "filtered_file"], "replacemean") # Compute a final mean functional volume meanfunc = MapNode(fsl.MeanImage(out_file="mean_func.nii.gz"), "in_file", "meanfunc") outputnode = Node(IdentityInterface(["timeseries", "mean_file"]), "outputs") filtering = Workflow(name) filtering.connect([ (inputnode, scale, [("timeseries", "in_file"), ("mask_file", "mask_file")]), (scale, filter, [("out_file", "in_file")]), (scale, replacemean, [("out_file", "orig_file")]), (filter, replacemean, [("out_file", "filtered_file")]), (replacemean, meanfunc, [("out_file", "in_file")]), (replacemean, outputnode, [("out_file", "timeseries")]), (meanfunc, outputnode, [("out_file", "mean_file")]), ]) return filtering
def create_denoise_pipeline(name='denoise'): # workflow denoise = Workflow(name='denoise') # Define nodes inputnode = Node(interface=util.IdentityInterface(fields=[ 'anat_brain', 'brain_mask', 'epi_denoised', 'highpass_sigma', 'lowpass_sigma', 'tr' ]), name='inputnode') outputnode = Node( interface=util.IdentityInterface(fields=[ # FL added fullspectrum 'normalized_file' ]), name='outputnode') # bandpass filter denoised file bandpass_filter = Node( fsl.TemporalFilter(out_file='rest_denoised_bandpassed.nii.gz'), name='bandpass_filter') bandpass_filter.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, bandpass_filter, [('highpass_sigma', 'highpass_sigma'), ('lowpass_sigma', 'lowpass_sigma')]), # (filter2, bandpass_filter, [('out_res', 'in_file')]), # (filter2, outputnode, [('out_res', 'ts_fullspectrum')]), (inputnode, bandpass_filter, [('epi_denoised', 'in_file')]) ]) # time-normalize scans normalize_time = Node(util.Function(input_names=['in_file', 'tr'], output_names=['out_file'], function=time_normalizer), name='normalize_time') normalize_time.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, normalize_time, [('tr', 'tr')]), (bandpass_filter, normalize_time, [('out_file', 'in_file')]), (normalize_time, outputnode, [('out_file', 'normalized_file')]) ]) return denoise
def create_resting_preproc(name='restpreproc'): """Create a "resting" time series preprocessing workflow The noise removal is based on Behzadi et al. (2007) Parameters ---------- name : name of workflow (default: restpreproc) Inputs:: inputspec.func : functional run (filename or list of filenames) Outputs:: outputspec.noise_mask_file : voxels used for PCA to derive noise components outputspec.filtered_file : bandpass filtered and noise-reduced time series Example ------- >>> TR = 3.0 >>> wf = create_resting_preproc() >>> wf.inputs.inputspec.func = 'f3.nii' >>> wf.inputs.inputspec.num_noise_components = 6 >>> wf.inputs.inputspec.highpass_sigma = 100/(2*TR) >>> wf.inputs.inputspec.lowpass_sigma = 12.5/(2*TR) >>> wf.run() # doctest: +SKIP """ restpreproc = pe.Workflow(name=name) # Define nodes inputnode = pe.Node(interface=util.IdentityInterface(fields=[ 'func', 'num_noise_components', 'highpass_sigma', 'lowpass_sigma' ]), name='inputspec') outputnode = pe.Node(interface=util.IdentityInterface(fields=[ 'noise_mask_file', 'filtered_file', 'motion_rms_files', 'motion_par_file', 'realigned_file', 'mask_file', 'outlier_files', 'intensity_files', 'outlier_plots' ]), name='outputspec') slicetimer = pe.Node(fsl.SliceTimer(), name='slicetimer') realigner = create_realign_flow() art_detector = pe.Node(ArtifactDetect(), name='art_detector') art_detector.inputs.parameter_source = 'FSL' art_detector.inputs.mask_type = 'spm_global' art_detector.inputs.global_threshold = .5 art_detector.inputs.norm_threshold = .6 art_detector.inputs.use_differences = [True, True] ## [Movement, Intensity] art_detector.inputs.zintensity_threshold = 3 art_detector.inputs.intersect_mask = True '''Mask smoother node, added by Pablo Polosecki to use EPI mask''' mask_smoother = pe.Node(util.Function(input_names=['vol_in'], output_names=['out_vol'], function=morph_open_close), name='mask_smoother') tsnr = pe.Node(TSNR(regress_poly=2), name='tsnr') getthresh = pe.Node(interface=fsl.ImageStats(op_string='-k %s -p 98'), name='getthreshold') threshold_stddev = pe.Node(fsl.Threshold(), name='threshold') ''' Mask conjunction, to limit noisy voxels to those inside brain mask''' conj_masker = pe.Node(fsl.BinaryMaths(operation='mul'), name='conj_masker') compcor = pe.Node(util.Function( input_names=['realigned_file', 'noise_mask_file', 'num_components'], output_names=['noise_components'], function=extract_noise_components), name='compcorr') # cat_regressors = pe.Node(util.Function(input_names=['file1', # 'file2'], # output_names=['out_fn'], # function=concatetante_reg_files), # name='cat_regressors') remove_noise = pe.Node(fsl.FilterRegressor(filter_all=True), name='remove_noise') bandpass_filter = pe.Node(fsl.TemporalFilter(), name='bandpass_filter') # Define connections restpreproc.connect(inputnode, 'func', slicetimer, 'in_file') restpreproc.connect(slicetimer, 'slice_time_corrected_file', realigner, 'inputspec.func') restpreproc.connect(realigner, 'outputspec.realigned_file', tsnr, 'in_file') restpreproc.connect(tsnr, 'stddev_file', threshold_stddev, 'in_file') restpreproc.connect(tsnr, 'stddev_file', getthresh, 'in_file') restpreproc.connect(mask_smoother, 'out_vol', getthresh, 'mask_file') restpreproc.connect(getthresh, 'out_stat', threshold_stddev, 'thresh') restpreproc.connect(realigner, 'outputspec.realigned_file', compcor, 'realigned_file') restpreproc.connect(inputnode, 'num_noise_components', compcor, 'num_components') restpreproc.connect(tsnr, 'detrended_file', remove_noise, 'in_file') # Combiinng compcorr with motion regressors: #restpreproc.connect(compcor, 'noise_components', # cat_regressors, 'file1') #restpreproc.connect(realigner, 'outputspec.par_file', # cat_regressors, 'file2') #restpreproc.connect(cat_regressors, 'out_fn', # remove_noise, 'design_file') restpreproc.connect(compcor, 'noise_components', remove_noise, 'design_file') restpreproc.connect(inputnode, 'highpass_sigma', bandpass_filter, 'highpass_sigma') restpreproc.connect(inputnode, 'lowpass_sigma', bandpass_filter, 'lowpass_sigma') restpreproc.connect(remove_noise, 'out_file', bandpass_filter, 'in_file') restpreproc.connect(conj_masker, 'out_file', outputnode, 'noise_mask_file') restpreproc.connect(bandpass_filter, 'out_file', outputnode, 'filtered_file') restpreproc.connect(realigner, 'outputspec.rms_files', outputnode, 'motion_rms_files') restpreproc.connect(realigner, 'outputspec.par_file', outputnode, 'motion_par_file') restpreproc.connect(realigner, 'outputspec.realigned_file', outputnode, 'realigned_file') restpreproc.connect(realigner, 'outputspec.realigned_file', art_detector, 'realigned_files') restpreproc.connect(realigner, 'outputspec.par_file', art_detector, 'realignment_parameters') restpreproc.connect(art_detector, 'mask_files', mask_smoother, 'vol_in') restpreproc.connect(mask_smoother, 'out_vol', outputnode, 'mask_file') restpreproc.connect(art_detector, 'outlier_files', outputnode, 'outlier_files') restpreproc.connect(art_detector, 'intensity_files', outputnode, 'intensity_files') #restpreproc.connect(art_detector, 'plot_files', # outputnode, 'outlier_plots') restpreproc.connect(mask_smoother, 'out_vol', conj_masker, 'in_file') restpreproc.connect(threshold_stddev, 'out_file', conj_masker, 'operand_file') restpreproc.connect(conj_masker, 'out_file', compcor, 'noise_mask_file') return restpreproc
# ======================================================================================================== # In[17]: # Global Intensity Normalization by multiplying by the scaling value # the grand-mean intensity normalisation factor ( to give a median brain intensity of 10000 ) # grand mean scaling Intensity_Normalization = Node(fsl.BinaryMaths(), name='Intensity_Normalization') Intensity_Normalization.inputs.operation = 'mul' # ======================================================================================================== # In[18]: # fslmaths ${folder}_mcf_2highres_intnorm -bptf 25 -1 -add tempMean ${folder}_mcf_2highres_tempfilt; # sigma[vol] = filter_width[secs]/(2*TR[secs]) high_pass_filter = Node(fsl.TemporalFilter(), name='high_pass_filter') high_pass_filter.inputs.highpass_sigma = 22.5 # 90s / (2*2(TR)) # ======================================================================================================== # In[19] # Get the mean image Get_Mean_Image = Node(fsl.MeanImage(), name='Get_Mean_Image') Get_Mean_Image.inputs.dimension = 'T' # Add the mean image to the filtered image Add_Mean_Image = Node(fsl.BinaryMaths(), name='Add_Mean_Image') Add_Mean_Image.inputs.operation = 'add' # ======================================================================================================== # In[20]:
Scale_Median_Intensity = Node(name = 'Scale_Median_Intensity', interface = Function(input_names = ['median_intensity'], output_names = ['scaling'], function = Scale_Median_Intensity)) #----------------------------------------------------------------------------------------------------- #Global Intensity Normalization by multiplying by the scaling value #the grand-mean intensity normalisation factor ( to give a median brain intensity of 10000 ) #grand mean scaling Intensity_Normalization = Node(fsl.BinaryMaths(), name = 'Intensity_Normalization') Intensity_Normalization.inputs.operation = 'mul' #----------------------------------------------------------------------------------------------------- # fslmaths ${folder}_mcf_2highres_intnorm -bptf 25 -1 -add tempMean ${folder}_mcf_2highres_tempfilt; High_Pass_Filter = Node(fsl.TemporalFilter(), name = 'High_Pass_Filter') High_Pass_Filter.inputs.highpass_sigma = 22.5 #----------------------------------------------------------------------------------------------------- #Get the mean image Get_Mean_Image = Node(fsl.MeanImage(), name = 'Get_Mean_Image') Get_Mean_Image.inputs.dimension = 'T' #Add the mean image to the filtered image Add_Mean_Image = Node(fsl.BinaryMaths(), name = 'Add_Mean_Image') Add_Mean_Image.inputs.operation = 'add' #----------------------------------------------------------------------------------------------------- # In[15]: #Fit the design to the voxels time-series
def create_denoise_pipeline(name='denoise'): # workflow denoise = Workflow(name='denoise') # Define nodes inputnode = Node(interface=util.IdentityInterface(fields=[ 'anat_brain', 'brain_mask', 'flirt_mat', 'unwarped_mean', 'epi_coreg', 'highpass_sigma', 'tr' ]), name='inputnode') outputnode = Node(interface=util.IdentityInterface(fields=[ 'wmcsf_mask', 'brain2epi', 'wmcsf_mask2epi', 'combined_motion', 'comp_regressor', 'comp_F', 'comp_pF', 'out_betas', 'ts_fullspectrum', 'normalized_file' ]), name='outputnode') # run fast to get tissue probability classes fast = Node(fsl.FAST(), name='fast') denoise.connect([(inputnode, fast, [('anat_brain', 'in_files')])]) # functions to select tissue classes def selectindex(files, idx): import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename( np.array(filename_to_list(files))[idx].tolist()) def selectsingle(files, idx): return files[idx] # binarize tissue classes binarize_tissue = MapNode( fsl.ImageMaths(op_string='-nan -thr 0.99 -ero -bin'), iterfield=['in_file'], name='binarize_tissue') denoise.connect([ (fast, binarize_tissue, [(('partial_volume_files', selectindex, [0, 2]), 'in_file')]), ]) # combine tissue classes to noise mask wmcsf_mask = Node(fsl.BinaryMaths(operation='add', out_file='wmcsf_mask.nii'), name='wmcsf_mask') denoise.connect([(binarize_tissue, wmcsf_mask, [(('out_file', selectsingle, 0), 'in_file'), (('out_file', selectsingle, 1), 'operand_file')]), (wmcsf_mask, outputnode, [('out_file', 'wmcsf_mask')])]) # project wm_csf mask from anatomical to original epi space using inverse FLIRT-matrix invmat = Node(fsl.ConvertXFM(), name='invmat') invmat.inputs.invert_xfm = True apply_inv = Node(fsl.ApplyXfm(), name='apply_inv') apply_inv.inputs.apply_xfm = True denoise.connect([(inputnode, invmat, [('flirt_mat', 'in_file')]), (invmat, apply_inv, [('out_file', 'in_matrix_file')]), (inputnode, apply_inv, [('unwarped_mean', 'reference')]), (wmcsf_mask, apply_inv, [('out_file', 'in_file')]), (apply_inv, outputnode, [('out_file', 'wmcsf_mask2epi')]) ]) #project brain to epi space as a checkup apply_inv_brain = Node(fsl.ApplyXfm(), name='apply_inv_brain') apply_inv_brain.inputs.apply_xfm = True denoise.connect([ (invmat, apply_inv_brain, [('out_file', 'in_matrix_file')]), (inputnode, apply_inv_brain, [('unwarped_mean', 'reference')]), (inputnode, apply_inv_brain, [('anat_brain', 'in_file')]), (apply_inv_brain, outputnode, [('out_file', 'brain2epi')]) ]) #no artifact detection and motion regression done because of AROMA # create filter with compcor components createfilter2 = Node(util.Function(input_names=[ 'realigned_file', 'mask_file', 'num_components', 'extra_regressors' ], output_names=['out_files'], function=extract_noise_components), name='makecompcorfilter') createfilter2.inputs.num_components = 6 createfilter2.inputs.extra_regressors = None createfilter2.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, createfilter2, [('epi_coreg', 'realigned_file')]), (apply_inv, createfilter2, [('out_file', 'mask_file')]), (createfilter2, outputnode, [('out_files', 'comp_regressor')]), ]) # regress compcor and other noise components filter2 = Node(fsl.GLM(out_f_name='F_noise.nii.gz', out_pf_name='pF_noise.nii.gz', out_res_name='rest2anat_denoised.nii.gz', output_type='NIFTI_GZ', demean=True), name='filternoise') filter2.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, filter2, [('epi_coreg', 'in_file')]), (createfilter2, filter2, [('out_files', 'design')]), (inputnode, filter2, [('brain_mask', 'mask')]), (filter2, outputnode, [('out_f', 'comp_F'), ('out_pf', 'comp_pF'), ('out_file', 'out_betas')])]) # write TR into header again (glms remove it) # do not use mri_convert interface as it has a bug (already fixed in niyppe master) fix_tr = Node(util.Function(input_names=['in_file', 'TR_sec'], output_names=['out_file'], function=fix_TR_fs), name='fix_tr') denoise.connect(inputnode, 'tr', fix_tr, 'TR_sec') denoise.connect(filter2, 'out_res', fix_tr, 'in_file') #use only highpass filter (because high-frequency content (otherwise filtered by lowpass is already considered in AROMA)) highpass_filter = Node( fsl.TemporalFilter(out_file='rest_denoised_highpassed.nii'), name='highpass_filter') highpass_filter.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, highpass_filter, [('highpass_sigma', 'highpass_sigma')]), (fix_tr, highpass_filter, [('out_file', 'in_file')]), (fix_tr, outputnode, [('out_file', 'ts_fullspectrum')])]) # time-normalize scans (could be set to percent change etc. but here NO normalization is used # http://nipy.org/nitime/api/generated/nitime.fmri.io.html) normalize_time = Node(util.Function(input_names=['in_file', 'tr'], output_names=['out_file'], function=time_normalizer), name='normalize_time') normalize_time.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, normalize_time, [('tr', 'tr')]), (highpass_filter, normalize_time, [('out_file', 'in_file')]), (normalize_time, outputnode, [('out_file', 'normalized_file')]) ]) return denoise
NodeHash_f58d230.inputs.dimension = 3 NodeHash_f58d230.inputs.fwhm = 5 NodeHash_f58d230.inputs.use_median = 1 #Wraps command **fslmaths** NodeHash_10dc3c10 = pe.MapNode(interface = fsl.ApplyMask(), name = 'NodeName_10dc3c10', iterfield = ['in_file', 'mask_file']) #Custom interface wrapping function Getinormscale NodeHash_1c9d2280 = pe.MapNode(interface = firstlevelhelpers.Getinormscale, name = 'NodeName_1c9d2280', iterfield = ['medianval']) #Wraps command **fslmaths** NodeHash_2ee27f90 = pe.MapNode(interface = fsl.BinaryMaths(), name = 'NodeName_2ee27f90', iterfield = ['in_file', 'operand_value']) NodeHash_2ee27f90.inputs.operation = 'mul' #Wraps command **fslmaths** NodeHash_c0d1e30 = pe.MapNode(interface = fsl.TemporalFilter(), name = 'NodeName_c0d1e30', iterfield = ['in_file']) NodeHash_c0d1e30.inputs.highpass_sigma = 25 #Wraps command **fslmaths** NodeHash_17446a20 = pe.MapNode(interface = fsl.MeanImage(), name = 'NodeName_17446a20', iterfield = ['in_file']) NodeHash_17446a20.inputs.dimension = 'T' #Wraps command **fslmaths** NodeHash_b5a5810 = pe.MapNode(interface = fsl.BinaryMaths(), name = 'NodeName_b5a5810', iterfield = ['in_file', 'operand_file']) NodeHash_b5a5810.inputs.operation = 'add' #Makes a model specification compatible with spm/fsl designers. NodeHash_1e7a3420 = pe.MapNode(interface = modelgen.SpecifyModel(), name = 'NodeName_1e7a3420', iterfield = ['functional_runs', 'subject_info']) NodeHash_1e7a3420.inputs.high_pass_filter_cutoff = 0 NodeHash_1e7a3420.inputs.input_units = 'secs' NodeHash_1e7a3420.inputs.time_repetition = 2.0
name='NodeName_1becb6b0', iterfield=['in_file', 'mask_file']) #Custom interface wrapping function Getinormscale NodeHash_1dce7160 = pe.MapNode(interface=firstlevelhelpers.Getinormscale, name='NodeName_1dce7160', iterfield=['medianval']) #Wraps command **fslmaths** NodeHash_1de5d180 = pe.MapNode(interface=fsl.BinaryMaths(), name='NodeName_1de5d180', iterfield=['in_file', 'operand_value']) NodeHash_1de5d180.inputs.operation = 'mul' #Wraps command **fslmaths** NodeHash_1e98cad0 = pe.MapNode(interface=fsl.TemporalFilter(), name='NodeName_1e98cad0', iterfield=['in_file']) NodeHash_1e98cad0.inputs.highpass_sigma = 25 #Wraps command **fslmaths** NodeHash_1e558730 = pe.MapNode(interface=fsl.MeanImage(), name='NodeName_1e558730', iterfield=['in_file']) NodeHash_1e558730.inputs.dimension = 'T' #Wraps command **fslmaths** NodeHash_1fdac460 = pe.MapNode(interface=fsl.BinaryMaths(), name='NodeName_1fdac460', iterfield=['in_file', 'operand_file']) NodeHash_1fdac460.inputs.operation = 'add'
NodeHash_1a5fa380.inputs.dimension = 3 NodeHash_1a5fa380.inputs.fwhm = 5 NodeHash_1a5fa380.inputs.use_median = 1 #Wraps command **fslmaths** NodeHash_1ba8b6a0 = pe.MapNode(interface = fsl.ApplyMask(), name = 'NodeName_1ba8b6a0', iterfield = ['in_file', 'mask_file']) #Custom interface wrapping function Getinormscale NodeHash_1b378470 = pe.MapNode(interface = firstlevelhelpers.Getinormscale, name = 'NodeName_1b378470', iterfield = ['medianval']) #Wraps command **fslmaths** NodeHash_1b3754f0 = pe.MapNode(interface = fsl.BinaryMaths(), name = 'NodeName_1b3754f0', iterfield = ['in_file', 'operand_value']) NodeHash_1b3754f0.inputs.operation = 'mul' #Wraps command **fslmaths** NodeHash_1b252520 = pe.MapNode(interface = fsl.TemporalFilter(), name = 'NodeName_1b252520', iterfield = ['in_file']) NodeHash_1b252520.inputs.highpass_sigma = 25 #Wraps command **fslmaths** NodeHash_1cb2c540 = pe.MapNode(interface = fsl.MeanImage(), name = 'NodeName_1cb2c540', iterfield = ['in_file']) NodeHash_1cb2c540.inputs.dimension = 'T' #Wraps command **fslmaths** NodeHash_1e361a00 = pe.MapNode(interface = fsl.BinaryMaths(), name = 'NodeName_1e361a00', iterfield = ['in_file', 'operand_file']) NodeHash_1e361a00.inputs.operation = 'add' #Makes a model specification compatible with spm/fsl designers. NodeHash_1f14a780 = pe.MapNode(interface = modelgen.SpecifyModel(), name = 'NodeName_1f14a780', iterfield = ['functional_runs', 'subject_info']) NodeHash_1f14a780.inputs.high_pass_filter_cutoff = 0 NodeHash_1f14a780.inputs.input_units = 'secs' NodeHash_1f14a780.inputs.time_repetition = 2.0
def create_denoise_pipeline(working_dir, ds_dir, name='denoise'): # workflow denoise_wf = Workflow(name=name) denoise_wf.base_dir = os.path.join(working_dir, 'LeiCA_resting', 'rsfMRI_preprocessing') # I/O NODES inputnode = Node(interface=util.IdentityInterface(fields=[ 'subject_id', 'epi', 'mean_epi', 'par_moco', 'struct_2_epi_mat', 'MNI_2_epi_warp', 'lat_ventricle_mask_MNI', 'wm_mask', 'csf_mask', 'brain_mask_epiSpace', 'TR_ms', 'lp_cutoff_freq', 'hp_cutoff_freq' ]), name='inputnode') outputnode = Node(interface=util.IdentityInterface( fields=['outlier_files', 'rs_preprocessed']), name='outputnode') ds = Node(nio.DataSink(base_directory=ds_dir), name='ds') ds.inputs.substitutions = [('_TR_id_', 'TR_')] ######### TRANSFORM MASKS wm_mask_epiSpace = Node(fsl.ApplyXfm(apply_xfm=True, interp='nearestneighbour'), name='wm_mask_epiSpace') wm_mask_epiSpace.inputs.out_file = 'wm_mask_epiSpace.nii.gz' denoise_wf.connect([(inputnode, wm_mask_epiSpace, [('wm_mask', 'in_file'), ('mean_epi', 'reference'), ('struct_2_epi_mat', 'in_matrix_file')])]) denoise_wf.connect(wm_mask_epiSpace, 'out_file', ds, 'masks.wm_mask_epiSpace') csf_mask_epiSpace = Node(fsl.ApplyXfm(apply_xfm=True, interp='nearestneighbour'), name='csf_mask_epiSpace') denoise_wf.connect([(inputnode, csf_mask_epiSpace, [('csf_mask', 'in_file'), ('mean_epi', 'reference'), ('struct_2_epi_mat', 'in_matrix_file')])]) # MOVE LATERAL VENTRICLE MASK INTO EPI SPACE lat_ventricle_mask_epiSpace = Node(fsl.ApplyWarp(interp='nn'), name='lat_ventricle_mask_epiSpace') denoise_wf.connect(inputnode, 'lat_ventricle_mask_MNI', lat_ventricle_mask_epiSpace, 'in_file') denoise_wf.connect(inputnode, 'mean_epi', lat_ventricle_mask_epiSpace, 'ref_file') denoise_wf.connect(inputnode, 'MNI_2_epi_warp', lat_ventricle_mask_epiSpace, 'field_file') # CONFINE INDIVIDUAL CSF MASK TO LATERAL VENTRICLES csf_mask_lat_ventricles_epiSpace = Node( fsl.maths.BinaryMaths(operation='mul'), name='csf_mask_lat_ventricles_epiSpace') csf_mask_lat_ventricles_epiSpace.inputs.out_file = 'csf_mask_epiSpace.nii.gz' denoise_wf.connect(csf_mask_epiSpace, 'out_file', csf_mask_lat_ventricles_epiSpace, 'in_file') denoise_wf.connect(lat_ventricle_mask_epiSpace, 'out_file', csf_mask_lat_ventricles_epiSpace, 'operand_file') denoise_wf.connect(csf_mask_lat_ventricles_epiSpace, 'out_file', ds, 'masks.csf_mask_lat_ventr_epiSpace') # TR CONVERSION def get_TR_in_sec_fct(TR_ms): return TR_ms / 1000.0 get_TR_in_sec = Node(util.Function(input_names=['TR_ms'], output_names=['TR_sec'], function=get_TR_in_sec_fct), name='get_TR_in_sec') denoise_wf.connect(inputnode, 'TR_ms', get_TR_in_sec, 'TR_ms') # RUN ARTIFACT DETECTION artifact = Node(rapidart.ArtifactDetect(save_plot=True, use_norm=True, parameter_source='FSL', mask_type='file', norm_threshold=1, zintensity_threshold=3, use_differences=[True, False]), name='artifact') artifact.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise_wf.connect(inputnode, 'epi', artifact, 'realigned_files') denoise_wf.connect([(inputnode, artifact, [('par_moco', 'realignment_parameters')])]) denoise_wf.connect(inputnode, 'brain_mask_epiSpace', artifact, 'mask_file') denoise_wf.connect([ (artifact, ds, [('norm_files', 'denoise.artefact.@combined_motion'), ('outlier_files', 'denoise.artefact.@outlier'), ('intensity_files', 'denoise.artefact.@intensity'), ('statistic_files', 'denoise.artefact.@outlierstats'), ('plot_files', 'denoise.artefact.@outlierplots')]) ]) denoise_wf.connect(artifact, 'outlier_files', outputnode, 'outlier_files') ############################ def combine_motion_parameters_with_outliers_fct(motion_params, outliers_file, spike_reg): """Adapted from rom https://github.com/nipy/nipype/blob/master/examples/ rsfmri_vol_surface_preprocessing_nipy.py#L261 """ import numpy as np import os if spike_reg: out_params = np.genfromtxt(motion_params) try: outlier_val = np.genfromtxt(outliers_file) except IOError: outlier_val = np.empty((0)) for index in np.atleast_1d(outlier_val): outlier_vector = np.zeros((out_params.shape[0], 1)) outlier_vector[index] = 1 out_params = np.hstack((out_params, outlier_vector)) out_file = os.path.join(os.getcwd(), "motion_outlier_regressor.txt" ) #"filter_regressor%02d.txt" % idx) np.savetxt(out_file, out_params, fmt="%.8f") else: out_file = motion_params return out_file ############################ # COMPUTE MOTION DERIVATIVES (FRISTON24) friston24 = Node(util.Function( input_names=['in_file'], output_names=['friston_par'], function=cpac_generate_motion_statistics.calc_friston_twenty_four), name='friston24') denoise_wf.connect(inputnode, 'par_moco', friston24, 'in_file') # CREATE OUTLIER DUMMY REGRESSOR AND COMBINE WITH FRISTON24 motion_and_outlier_regressor = Node(util.Function( input_names=['motion_params', 'outliers_file', 'spike_reg'], output_names=['out_file'], function=combine_motion_parameters_with_outliers_fct), name='motion_and_outlier_regressor') motion_and_outlier_regressor.inputs.spike_reg = True denoise_wf.connect(friston24, 'friston_par', motion_and_outlier_regressor, 'motion_params') denoise_wf.connect(artifact, 'outlier_files', motion_and_outlier_regressor, 'outliers_file') # EXTRACT SIGNAL FROM WM AND CSF FOR COMPCOR wm_sig = Node(util.Function(input_names=['data_file', 'mask_file'], output_names=['out_file'], function=extract_signal_from_tissue), name='wm_sig') denoise_wf.connect(inputnode, 'epi', wm_sig, 'data_file') denoise_wf.connect(wm_mask_epiSpace, 'out_file', wm_sig, 'mask_file') csf_sig = Node(util.Function(input_names=['data_file', 'mask_file'], output_names=['out_file'], function=extract_signal_from_tissue), name='csf_sig') denoise_wf.connect(inputnode, 'epi', csf_sig, 'data_file') denoise_wf.connect(csf_mask_lat_ventricles_epiSpace, 'out_file', csf_sig, 'mask_file') nuisance_selector = { 'compcor': True, 'wm': False, 'csf': False, 'gm': False, 'global': False, 'pc1': False, 'motion': True, 'linear': True, 'quadratic': True } nuisance_reg = Node(util.Function( input_names=[ 'subject', 'selector', 'wm_sig_file', 'csf_sig_file', 'gm_sig_file', 'motion_file', 'compcor_ncomponents' ], output_names=['residual_file', 'regressors_file'], function=cpac_nuisance.calc_residuals), name='nuisance_reg') nuisance_reg.inputs.compcor_ncomponents = 5 nuisance_reg.inputs.selector = nuisance_selector denoise_wf.connect(inputnode, 'epi', nuisance_reg, 'subject') denoise_wf.connect(wm_sig, 'out_file', nuisance_reg, 'wm_sig_file') denoise_wf.connect(csf_sig, 'out_file', nuisance_reg, 'csf_sig_file') denoise_wf.connect(motion_and_outlier_regressor, 'out_file', nuisance_reg, 'motion_file') denoise_wf.connect(nuisance_reg, 'regressors_file', ds, 'denoise.regression.regressor') denoise_wf.connect(nuisance_reg, 'residual_file', ds, 'epis.01_denoised') ############################ # BANDPASS FILTER # sigma calculation see # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1205&L=FSL&P=R57592&1=FSL&9=A&I=-3&J=on&d=No+Match%3BMatch%3BMatches&z=4 def calc_bp_sigma_fct(TR_sec, cutoff_freq): sigma = 1. / (2 * TR_sec * cutoff_freq) return sigma calc_lp_sigma = Node(util.Function(input_names=['TR_sec', 'cutoff_freq'], output_names=['sigma'], function=calc_bp_sigma_fct), name='calc_lp_sigma') denoise_wf.connect(get_TR_in_sec, 'TR_sec', calc_lp_sigma, 'TR_sec') denoise_wf.connect(inputnode, 'lp_cutoff_freq', calc_lp_sigma, 'cutoff_freq') calc_hp_sigma = Node(util.Function(input_names=['TR_sec', 'cutoff_freq'], output_names=['sigma'], function=calc_bp_sigma_fct), name='calc_hp_sigma') denoise_wf.connect(get_TR_in_sec, 'TR_sec', calc_hp_sigma, 'TR_sec') denoise_wf.connect(inputnode, 'hp_cutoff_freq', calc_hp_sigma, 'cutoff_freq') bp_filter = Node(fsl.TemporalFilter(), name='bp_filter') bp_filter.plugin_args = {'submit_specs': 'request_memory = 4000'} denoise_wf.connect(nuisance_reg, 'residual_file', bp_filter, 'in_file') denoise_wf.connect(calc_lp_sigma, 'sigma', bp_filter, 'lowpass_sigma') denoise_wf.connect(calc_hp_sigma, 'sigma', bp_filter, 'highpass_sigma') denoise_wf.connect(bp_filter, 'out_file', ds, 'epis.02_denoised_BP') # TIME-NORMALIZE SCAN normalize_time = Node(util.Function(input_names=['in_file', 'tr'], output_names=['out_file'], function=time_normalizer), name='normalize_time') #fixme req mem needed? #normalize_time.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise_wf.connect(bp_filter, 'out_file', normalize_time, 'in_file') denoise_wf.connect(get_TR_in_sec, 'TR_sec', normalize_time, 'tr') denoise_wf.connect(normalize_time, 'out_file', outputnode, 'rs_preprocessed') denoise_wf.connect(normalize_time, 'out_file', ds, 'epis.03_denoised_BP_tNorm') denoise_wf.write_graph(dotfilename=denoise_wf.name, graph2use='flat', format='pdf') return denoise_wf
def init_bold_filt_wf(variant=None, memcalc=MemoryCalculator()): assert variant is not None name = make_variant_bold_filt_wf_name(variant) workflow = pe.Workflow(name=name) inputnode = pe.Node( niu.IdentityInterface(fields=[ *in_attrs_from_func_preproc_wf, *in_attrs_from_anat_preproc_wf, "metadata" ]), name="inputnode", ) workflow.add_nodes([inputnode]) metadatanode = pe.Node(niu.IdentityInterface(fields=["repetition_time"]), name="metadatanode") workflow.connect([(inputnode, metadatanode, [ (("metadata", get_repetition_time), "repetition_time") ])]) bandpass = None ortendpoint = None boldfileendpoint = (inputnode, "bold_std") tagdict = dict(variant) # smoothing is done first if "smoothed" in tagdict: fwhm = float(tagdict["smoothed"]) smooth_workflow = init_smooth_wf(fwhm=fwhm) workflow.connect(inputnode, "bold_mask_std", smooth_workflow, "inputnode.mask_file") workflow.connect(*boldfileendpoint, smooth_workflow, "inputnode.in_file") boldfileendpoint = (smooth_workflow, "outputnode.out_file") if "grand_mean_scaled" in tagdict: grand_mean = tagdict["grand_mean_scaled"] assert isinstance(grand_mean, float) grandmeanscaling = pe.Node( interface=GrandMeanScaling(grand_mean=grand_mean), name="grandmeanscaling") workflow.connect(*boldfileendpoint, grandmeanscaling, "in_file") workflow.connect(inputnode, "bold_mask_std", grandmeanscaling, "mask_file") boldfileendpoint = (grandmeanscaling, "out_file") need_to_add_mean = False boldfileendpoint_for_meanfunc = boldfileendpoint # if we use gaussian band-pass filtering, we cannot orthogonalize these regressors # with respect to the filter, as afni tproject doesn't support this filter type # as such we need to remove them before to not re-introduce filtered-out variance simultaneous_bandpass_and_ort = True if "band_pass_filtered" in tagdict: type = first(tagdict["band_pass_filtered"]) if type == "gaussian": simultaneous_bandpass_and_ort = False confounds_to_remove_before_filtering = set(("aroma_motion_[0-9]+", )) if (not simultaneous_bandpass_and_ort and "confounds_removed" in tagdict and not confounds_to_remove_before_filtering.isdisjoint( tagdict["confounds_removed"])): confoundsremovedset = set(tagdict["confounds_removed"]) preconfoundsremoved = confounds_to_remove_before_filtering & confoundsremovedset postconfoundsremoved = confoundsremovedset - confounds_to_remove_before_filtering if len(postconfoundsremoved) == 0: del tagdict["confounds_removed"] else: tagdict["confounds_removed"] = postconfoundsremoved ortendpoint, _ = make_confoundsendpoint("pre", workflow, boldfileendpoint, list(preconfoundsremoved), memcalc) tproject = pe.Node(afni.TProject(polort=1, out_file="tproject.nii"), name="pretproject") workflow.connect(*boldfileendpoint, tproject, "in_file") workflow.connect(metadatanode, "repetition_time", tproject, "TR") workflow.connect(*ortendpoint, tproject, "ort") boldfileendpoint = (tproject, "out_file") need_to_add_mean = True if "band_pass_filtered" in tagdict: type = first(tagdict["band_pass_filtered"]) if type == "frequency_based": bandpass = tagdict["band_pass_filtered"][1:] elif type == "gaussian": def calc_highpass_sigma(temporal_filter_width=None, repetition_time=None): highpass_sigma = temporal_filter_width / (2.0 * repetition_time) return highpass_sigma calchighpasssigma = pe.Node( interface=niu.Function( input_names=["temporal_filter_width", "repetition_time"], output_names=["highpass_sigma"], function=calc_highpass_sigma, ), name="calchighpasssigma", ) workflow.connect(metadatanode, "repetition_time", calchighpasssigma, "repetition_time") calchighpasssigma.inputs.temporal_filter_width = second( tagdict["band_pass_filtered"]) highpass = pe.Node(fsl.TemporalFilter(), name="gaussianfilter") workflow.connect(calchighpasssigma, "highpass_sigma", highpass, "highpass_sigma") workflow.connect(*boldfileendpoint, highpass, "in_file") need_to_add_mean = True if "confounds_removed" in tagdict: confoundnames = tagdict["confounds_removed"] if len(confoundnames) > 0: ortendpoint, _ = make_confoundsendpoint("post", workflow, boldfileendpoint, confoundnames, memcalc) if bandpass is not None or ortendpoint is not None: tproject = pe.Node(afni.TProject(polort=1, out_file="tproject.nii"), name="tproject") workflow.connect(*boldfileendpoint, tproject, "in_file") workflow.connect(metadatanode, "repetition_time", tproject, "TR") if bandpass is not None: tproject.inputs.bandpass = bandpass if ortendpoint is not None: workflow.connect(*ortendpoint, tproject, "ort") boldfileendpoint = (tproject, "out_file") need_to_add_mean = True if need_to_add_mean is True: meanfunc = pe.Node(interface=fsl.ImageMaths(op_string="-Tmean", suffix="_mean"), name="meanfunc") workflow.connect(*boldfileendpoint_for_meanfunc, meanfunc, "in_file") addmean = pe.Node(interface=fsl.BinaryMaths(operation="add"), name="addmean") workflow.connect(*boldfileendpoint, addmean, "in_file") workflow.connect(meanfunc, "out_file", addmean, "operand_file") boldfileendpoint = (addmean, "out_file") applymask = pe.Node( interface=fsl.ApplyMask(), name="applymask", mem_gb=memcalc.volume_std_gb, ) workflow.connect(*boldfileendpoint, applymask, "in_file") workflow.connect(inputnode, "bold_mask_std", applymask, "mask_file") boldfileendpoint = (applymask, "out_file") endpoints = [boldfileendpoint] # boldfile is finished if "confounds_extract" in tagdict: # last confoundnames = tagdict["confounds_extract"] confoundsextractendpoint, confoundsextractendpointwithheader = make_confoundsendpoint( "extract", workflow, boldfileendpoint, confoundnames, memcalc) endpoints.append(confoundsextractendpoint) endpoints.append(confoundsextractendpointwithheader) outnames = [f"out{i+1}" for i in range(len(endpoints))] outputnode = pe.Node( niu.IdentityInterface(fields=[*outnames, "mask_file"]), name="outputnode", ) workflow.connect(inputnode, "bold_mask_std", outputnode, "mask_file") for outname, endpoint in zip(outnames, endpoints): workflow.connect(*endpoint, outputnode, outname) return workflow
#pipe.connect(changedim, 'out_file', compcor, 'inputspec.func') ######################################################################################################################## # median angle correction from mypype.workflows.preproc.median_angle import create_median_angle_correction medang = create_median_angle_correction() medang.inputs.inputspec.target_angle = 90 pipe.connect(changedim, 'out_file', medang, 'inputspec.subject') ######################################################################################################################## # node for bandpass filter bandpass_filter = pe.MapNode( fsl.TemporalFilter(), # TODO: into preprocess workflow name='07_bandpass_filter', iterfield=['in_file']) bandpass_filter.inputs.highpass_sigma = 100 / (2 * _TR_) bandpass_filter.inputs.lowpass_sigma = 12.5 / (2 * _TR_) #pipe.connect(compcor, 'outputspec.residual_file', bandpass_filter, 'in_file') pipe.connect(medang, 'outputspec.subject', bandpass_filter, 'in_file') ######################################################################################################################## # node for reho reho = reho.create_reho(wf_name="08_reho") reho.inputs.inputspec.cluster_size = 27 pipe.connect(bandpass_filter, 'out_file', reho, 'inputspec.rest_res_filt') pipe.connect(preproc, 'outputspec.func_brain_mask', reho, 'inputspec.rest_mask')
my_fsl_Threshold.inputs.args = '-bin' #Anatomical compcor: for inputs and outputs, see CompCor. my_confounds_ACompCor = pe.Node(interface=confounds.ACompCor(), name='my_confounds_ACompCor', iterfield=['']) my_confounds_ACompCor.inputs.num_components = 2 #Wraps command **fsl_regfilt** my_fsl_FilterRegressor = pe.Node(interface=fsl.FilterRegressor(), name='my_fsl_FilterRegressor', iterfield=['']) my_fsl_FilterRegressor.inputs.filter_columns = [1, 2] #Wraps command **fslmaths** my_fsl_TemporalFilter = pe.Node(interface=fsl.TemporalFilter(), name='my_fsl_TemporalFilter', iterfield=['']) my_fsl_TemporalFilter.inputs.highpass_sigma = 25 #Change the name of a file based on a mapped format string. my_utility_Rename = pe.Node(interface=utility.Rename(), name='my_utility_Rename', iterfield=['']) my_utility_Rename.inputs.format_string = "/output/filtered.nii.gz" #Create a workflow to connect all those nodes analysisflow = nipype.Workflow('MyWorkflow') analysisflow.connect(my_io_S3DataGrabber, "outfiles", my_fsl_SliceTimer, "in_file") analysisflow.connect(my_fsl_SliceTimer, "slice_time_corrected_file",
#Wraps command **fslmaths** NodeHash_30f6760 = pe.Node(interface=fsl.Threshold(), name='NodeName_30f6760') NodeHash_30f6760.inputs.args = '-bin' #Anatomical compcor: for inputs and outputs, see CompCor. NodeHash_325da10 = pe.Node(interface=confounds.ACompCor(), name='NodeName_325da10') NodeHash_325da10.inputs.num_components = 2 #Wraps command **fsl_regfilt** NodeHash_430d1e0 = pe.Node(interface=fsl.FilterRegressor(), name='NodeName_430d1e0') NodeHash_430d1e0.inputs.filter_columns = [1, 2] #Wraps command **fslmaths** NodeHash_77e3220 = pe.Node(interface=fsl.TemporalFilter(), name='NodeName_77e3220') NodeHash_77e3220.inputs.highpass_sigma = 25 #Generic datasink module to store structured outputs NodeHash_99576b0 = pe.Node(interface=io.DataSink(), name='NodeName_99576b0') #Create a workflow to connect all those nodes analysisflow = nipype.Workflow('MyWorkflow') analysisflow.connect(NodeHash_30f69e0, 'outfiles', NodeHash_1d000c0, 'in_file') analysisflow.connect(NodeHash_1d000c0, 'slice_time_corrected_file', NodeHash_22f2e80, 'in_file') analysisflow.connect(NodeHash_22f2e80, 'out_file', NodeHash_50c02c0, 'in_file') analysisflow.connect(NodeHash_50c02c0, 'stddev_file', NodeHash_3ac27f0, 'in_file') analysisflow.connect(NodeHash_3ac27f0, 'out_stat', NodeHash_30f6760, 'thresh')
def process_rest(wf_name='proc_rest'): def get_element(list, index): return list[index] rest = pe.Workflow(wf_name) inputnode = pe.Node(interface=util.IdentityInterface( fields=['preprocessed_func', 'func_brain_mask']), name='inputspec') outputnode = pe.Node(interface=util.IdentityInterface(fields=['out']), name='outputspec') ######################################################################################################################## # node for bandpass filter bandpass_filter = pe.MapNode( fsl.TemporalFilter(), # TODO: into preprocess workflow name='05_bandpass_filter_cc', iterfield=['in_file']) #bandpass_filter.inputs.highpass_sigma = 100 / (2 * _TR_) #bandpass_filter.inputs.lowpass_sigma = 12.5 / (2 * _TR_) # 1. frequency band: 0.1-0.05 Hz # 2. frequency band: 0.05-0.02 Hz # 3. frequency band: 0.02-0.01 Hz # 4. frequency band: 0.01-0.002 Hz # 3. frequency band: 0.1-0.01 Hz # standard broadband bandpass_filter.iterables = [('highpass_sigma', [ 20 / (2 * _TR_), 50 / (2 * _TR_), 100 / (2 * _TR_), 500 / (2 * _TR_), 100 / (2 * _TR_) ]), ('lowpass_sigma', [ 10 / (2 * _TR_), 20 / (2 * _TR_), 50 / (2 * _TR_), 100 / (2 * _TR_), 10 / (2 * _TR_) ])] bandpass_filter.synchronize = True rest.connect(inputnode, 'preprocessed_func', bandpass_filter, 'in_file') #pipe.connect(changedim, 'out_file', bandpass_filter, 'in_file') ######################################################################################################################## # node for reho import mypype.workflows.rest.reho as reho reho = reho.create_reho(wf_name="06_reho_cc") reho.inputs.inputspec.cluster_size = 27 rest.connect(bandpass_filter, 'out_file', reho, 'inputspec.rest_res_filt') rest.connect(inputnode, 'func_brain_mask', reho, 'inputspec.rest_mask') ######################################################################################################################## # smooth reho maps smooth = prpc.create_susan_smooth("08_smooth_reho_cc") smooth.inputs.inputnode.fwhm = 12. #smooth.get_node( "smooth").iterables=[('fwhm', [4., 6., 8., 10., 12., 14.])] #TODO: to sigma??? rest.connect(reho, 'outputspec.raw_reho_map', smooth, 'inputnode.in_files') rest.connect(inputnode, 'func_brain_mask', smooth, 'inputnode.mask_file') ######################################################################################################################## # compute centrality #graph=cent.create_resting_state_graphs(wf_name='07_centrality_cc', multipleTemplate=True) #graph.inputs.centrality_options.method_options=[True, True] #graph.inputs.inputspec.method_option=1 #graph.get_node( "calculate_centrality").iterables=[('method_option', [0,1,2]), # ('threshold_option', [1,1,2]), # ('threshold', [0.3, 0.3,0.6])] #graph.get_node( "calculate_centrality").synchronize = True #graph.inputs.inputspec.template = '/opt/shared/etc/std/new/standard-wistar_5mm_brain_mask.nii.gz' #graph.inputs.inputspec.threshold=0.5 #graph.inputs.inputspec.threshold_option=1 #graph.inputs.inputspec.weight_options=[False, True] #rest.connect(bandpass_filter, 'out_file', graph, 'inputspec.subject') #rest.connect(inputnode, 'func_brain_mask', graph, 'inputspec.template') ######################################################################################################################## # get fisrt element of results #get_element=pe.MapNode(interface=util.Function(input_names = ['list','index'], # output_names = ['out'], # function = get_element), # name = 'get_element', # iterfield=['list']) #get_element.inputs.index=0 #rest.connect(graph, 'outputspec.centrality_outputs', get_element, 'list') ######################################################################################################################## # smooth centrality maps #smoothc = prpc.create_susan_smooth("09_smooth_centrality_cc", separate_masks=True) #smooth.get_node( "smooth").iterables=[('fwhm', [4., 6., 8., 10., 12., 14.])] #TODO: to sigma??? #smoothc.inputs.inputnode.fwhm=12. #rest.connect(inputnode, 'func_brain_mask', smoothc, 'inputnode.mask_file') #rest.connect(get_element, 'out', smoothc, 'inputnode.in_files') return rest
def create_denoise_pipeline(name='denoise'): # workflow denoise = Workflow(name='denoise') # Define nodes inputnode = Node(interface=util.IdentityInterface(fields=[ 'anat_brain', 'brain_mask', 'epi2anat_dat', 'unwarped_mean', 'epi_coreg', 'moco_par', 'highpass_sigma', 'lowpass_sigma', 'tr' ]), name='inputnode') outputnode = Node(interface=util.IdentityInterface(fields=[ 'wmcsf_mask', 'brain_mask_resamp', 'brain_mask2epi', 'combined_motion', 'outlier_files', 'intensity_files', 'outlier_stats', 'outlier_plots', 'mc_regressor', 'mc_F', 'mc_pF', 'comp_regressor', 'comp_F', 'comp_pF', 'normalized_file' ]), name='outputnode') # run fast to get tissue probability classes fast = Node(fsl.FAST(), name='fast') denoise.connect([(inputnode, fast, [('anat_brain', 'in_files')])]) # functions to select tissue classes def selectindex(files, idx): import numpy as np from nipype.utils.filemanip import filename_to_list, list_to_filename return list_to_filename( np.array(filename_to_list(files))[idx].tolist()) def selectsingle(files, idx): return files[idx] # resample tissue classes resample_tissue = MapNode(afni.Resample(resample_mode='NN', outputtype='NIFTI_GZ'), iterfield=['in_file'], name='resample_tissue') denoise.connect([ (inputnode, resample_tissue, [('epi_coreg', 'master')]), (fast, resample_tissue, [(('partial_volume_files', selectindex, [0, 2]), 'in_file')]), ]) # binarize tissue classes binarize_tissue = MapNode( fsl.ImageMaths(op_string='-nan -thr 0.99 -ero -bin'), iterfield=['in_file'], name='binarize_tissue') denoise.connect([ (resample_tissue, binarize_tissue, [('out_file', 'in_file')]), ]) # combine tissue classes to noise mask wmcsf_mask = Node(fsl.BinaryMaths(operation='add', out_file='wmcsf_mask_lowres.nii.gz'), name='wmcsf_mask') denoise.connect([(binarize_tissue, wmcsf_mask, [(('out_file', selectsingle, 0), 'in_file'), (('out_file', selectsingle, 1), 'operand_file')]), (wmcsf_mask, outputnode, [('out_file', 'wmcsf_mask')])]) # resample brain mask resample_brain = Node(afni.Resample( resample_mode='NN', outputtype='NIFTI_GZ', out_file='T1_brain_mask_lowres.nii.gz'), name='resample_brain') denoise.connect([(inputnode, resample_brain, [('brain_mask', 'in_file'), ('epi_coreg', 'master')]), (resample_brain, outputnode, [('out_file', 'brain_mask_resamp')])]) # project brain mask into original epi space fpr quality assessment brainmask2epi = Node(fs.ApplyVolTransform( interp='nearest', inverse=True, transformed_file='T1_brain_mask2epi.nii.gz', ), name='brainmask2epi') denoise.connect([ (inputnode, brainmask2epi, [('brain_mask', 'target_file'), ('epi2anat_dat', 'reg_file'), ('unwarped_mean', 'source_file')]), (brainmask2epi, outputnode, [('transformed_file', 'brain_mask2epi')]) ]) # perform artefact detection artefact = Node(ra.ArtifactDetect(save_plot=True, use_norm=True, parameter_source='FSL', mask_type='file', norm_threshold=1, zintensity_threshold=3, use_differences=[True, False]), name='artefact') artefact.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, artefact, [('epi_coreg', 'realigned_files'), ('moco_par', 'realignment_parameters')]), (resample_brain, artefact, [('out_file', 'mask_file')]), (artefact, outputnode, [('norm_files', 'combined_motion'), ('outlier_files', 'outlier_files'), ('intensity_files', 'intensity_files'), ('statistic_files', 'outlier_stats'), ('plot_files', 'outlier_plots')]) ]) # Compute motion regressors motreg = Node(util.Function( input_names=['motion_params', 'order', 'derivatives'], output_names=['out_files'], function=motion_regressors), name='getmotionregress') motreg.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, motreg, [('moco_par', 'motion_params')])]) # Create a filter to remove motion and art confounds createfilter1 = Node(util.Function( input_names=['motion_params', 'comp_norm', 'outliers', 'detrend_poly'], output_names=['out_files'], function=build_filter1), name='makemotionbasedfilter') createfilter1.inputs.detrend_poly = 2 createfilter1.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (motreg, createfilter1, [('out_files', 'motion_params')]), ( artefact, createfilter1, [ #('norm_files', 'comp_norm'), ('outlier_files', 'outliers') ]), (createfilter1, outputnode, [('out_files', 'mc_regressor')]) ]) # regress out motion and art confounds filter1 = Node(fsl.GLM(out_f_name='F_mcart.nii.gz', out_pf_name='pF_mcart.nii.gz', out_res_name='rest_mc_denoised.nii.gz', demean=True), name='filtermotion') filter1.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, filter1, [('epi_coreg', 'in_file')]), (createfilter1, filter1, [(('out_files', list_to_filename), 'design')]), (filter1, outputnode, [('out_f', 'mc_F'), ('out_pf', 'mc_pF')])]) # create filter with compcor components createfilter2 = Node(util.Function(input_names=[ 'realigned_file', 'mask_file', 'num_components', 'extra_regressors' ], output_names=['out_files'], function=extract_noise_components), name='makecompcorfilter') createfilter2.inputs.num_components = 6 createfilter2.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (createfilter1, createfilter2, [(('out_files', list_to_filename), 'extra_regressors')]), (filter1, createfilter2, [('out_res', 'realigned_file')]), (wmcsf_mask, createfilter2, [('out_file', 'mask_file')]), (createfilter2, outputnode, [('out_files', 'comp_regressor')]), ]) # regress compcor and other noise components filter2 = Node(fsl.GLM(out_f_name='F_noise.nii.gz', out_pf_name='pF_noise.nii.gz', out_res_name='rest2anat_denoised.nii.gz', demean=True), name='filternoise') filter2.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(filter1, filter2, [('out_res', 'in_file')]), (createfilter2, filter2, [('out_files', 'design')]), (resample_brain, filter2, [('out_file', 'mask')]), (filter2, outputnode, [('out_f', 'comp_F'), ('out_pf', 'comp_pF')])]) # bandpass filter denoised file bandpass_filter = Node( fsl.TemporalFilter(out_file='rest_denoised_bandpassed.nii.gz'), name='bandpass_filter') bandpass_filter.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, bandpass_filter, [('highpass_sigma', 'highpass_sigma'), ('lowpass_sigma', 'lowpass_sigma')]), (filter2, bandpass_filter, [('out_res', 'in_file')])]) # time-normalize scans normalize_time = Node(util.Function(input_names=['in_file', 'tr'], output_names=['out_file'], function=time_normalizer), name='normalize_time') normalize_time.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([ (inputnode, normalize_time, [('tr', 'tr')]), (bandpass_filter, normalize_time, [('out_file', 'in_file')]), (normalize_time, outputnode, [('out_file', 'normalized_file')]) ]) return denoise
def create_workflow(self, flow, inputnode, outputnode): smoothing_output = pe.Node(interface=util.IdentityInterface(fields=["smoothing_output"]),name="smoothing_output") if self.config.smoothing > 0.0: smoothing = pe.Node(interface=fsl.SpatialFilter(operation='mean',kernel_shape = 'gauss'),name="smoothing") smoothing.inputs.kernel_size = self.config.smoothing flow.connect([ (inputnode,smoothing,[("preproc_file","in_file")]), (smoothing,smoothing_output,[("out_file","smoothing_output")]) ]) else: flow.connect([ (inputnode,smoothing_output,[("preproc_file","smoothing_output")]) ]) discard_output = pe.Node(interface=util.IdentityInterface(fields=["discard_output"]),name="discard_output") if self.config.discard_n_volumes > 0: discard = pe.Node(interface=discard_tp(n_discard=self.config.discard_n_volumes),name='discard_volumes') flow.connect([ (smoothing_output,discard,[("smoothing_output","in_file")]), (discard,discard_output,[("out_file","discard_output")]) ]) else: flow.connect([ (smoothing_output,discard_output,[("smoothing_output","discard_output")]) ]) nuisance_output = pe.Node(interface=util.IdentityInterface(fields=["nuisance_output"]),name="nuisance_output") if self.config.wm or self.config.global_nuisance or self.config.csf or self.config.motion: nuisance = pe.Node(interface=nuisance_regression(),name="nuisance_regression") nuisance.inputs.global_nuisance=self.config.global_nuisance nuisance.inputs.csf_nuisance=self.config.csf nuisance.inputs.wm_nuisance=self.config.wm nuisance.inputs.motion_nuisance=self.config.motion nuisance.inputs.n_discard=self.config.discard_n_volumes flow.connect([ (discard_output,nuisance,[("discard_output","in_file")]), (inputnode,nuisance,[("eroded_brain","brainfile")]), (inputnode,nuisance,[("eroded_csf","csf_file")]), (inputnode,nuisance,[("eroded_wm","wm_file")]), (inputnode,nuisance,[("motion_par_file","motion_file")]), (inputnode,nuisance,[("registered_roi_volumes","gm_file")]), (nuisance,nuisance_output,[("out_file","nuisance_output")]) ]) else: flow.connect([ (discard_output,nuisance_output,[("discard_output","nuisance_output")]) ]) detrending_output = pe.Node(interface=util.IdentityInterface(fields=["detrending_output"]),name="detrending_output") if self.config.detrending: detrending = pe.Node(interface=Detrending(),name='detrending') flow.connect([ (nuisance_output,detrending,[("nuisance_output","in_file")]), (inputnode,detrending,[("registered_roi_volumes","gm_file")]), (detrending,detrending_output,[("out_file","detrending_output")]) ]) else: flow.connect([ (nuisance_output,detrending_output,[("nuisance_output","detrending_output")]) ]) filter_output = pe.Node(interface=util.IdentityInterface(fields=["filter_output"]),name="filter_output") if self.config.lowpass_filter > 0 or self.config.highpass_filter > 0: filtering = pe.Node(interface=fsl.TemporalFilter(),name='temporal_filter') filtering.inputs.lowpass_sigma = self.config.lowpass_filter filtering.inputs.highpass_sigma = self.config.highpass_filter flow.connect([ (detrending_output,filtering,[("detrending_output","in_file")]), (filtering,filter_output,[("out_file","filter_output")]) ]) else: flow.connect([ (detrending_output,filter_output,[("detrending_output","filter_output")]) ]) if self.config.scrubbing: scrubbing = pe.Node(interface=Scrubbing(),name='scrubbing') flow.connect([ (filter_output,scrubbing,[("filter_output","in_file")]), (inputnode,scrubbing,[("registered_wm","wm_mask")]), (inputnode,scrubbing,[("registered_roi_volumes","gm_file")]), (inputnode,scrubbing,[("motion_par_file","motion_parameters")]), (scrubbing,outputnode,[("fd_npy","FD")]), (scrubbing,outputnode,[("dvars_npy","DVARS")]) ]) flow.connect([ (filter_output,outputnode,[("filter_output","func_file")]) ])
def create_denoise_pipeline(name='denoise'): # workflow denoise = Workflow(name='denoise') # Define nodes inputnode = Node(interface=util.IdentityInterface(fields=['brain_mask', 'epi_coreg', 'wmseg', 'csfseg', 'highpass_freq', 'tr']), name='inputnode') outputnode = Node(interface=util.IdentityInterface(fields=['wmcsf_mask', 'combined_motion', 'comp_regressor', 'comp_F', 'comp_pF', 'out_betas', 'ts_fullspectrum', 'ts_filtered']), name='outputnode') # combine tissue classes to noise mask wmcsf_mask = Node(fsl.BinaryMaths(operation='add', out_file='wmcsf_mask.nii'), name='wmcsf_mask') denoise.connect([(inputnode, wmcsf_mask, [('wmseg', 'in_file'), ('csfseg', 'operand_file')])]) #resample + binarize wm_csf mask to epi resolution. resample_wmcsf= Node(afni.Resample(resample_mode='NN', outputtype='NIFTI_GZ', out_file='wmcsf_mask_lowres.nii.gz'), name = 'resample_wmcsf') bin_wmcsf_mask=Node(fsl.utils.ImageMaths(), name="bin_wmcsf_mask") bin_wmcsf_mask.inputs.op_string='-nan -thr 0.99 -ero -bin' denoise.connect([(wmcsf_mask, resample_wmcsf, [('out_file', 'in_file')]), (inputnode, resample_wmcsf, [('brain_mask', 'master')]), (resample_wmcsf, bin_wmcsf_mask,[('out_file', 'in_file')]), (bin_wmcsf_mask, outputnode, [('out_file', 'wmcsf_mask')]) ]) #no other denoising filters created here because AROMA performs already well. compcor=Node(conf.ACompCor(), name="compcor") compcor.inputs.num_components=5 #https://www.sciencedirect.com/science/article/pii/S105381191400175X?via%3Dihub denoise.connect([ (inputnode, compcor, [('epi_coreg', 'realigned_file')]), (bin_wmcsf_mask, compcor, [('out_file', 'mask_files')]), ]) def create_designs(compcor_regressors,epi_coreg,mask): import numpy as np import pandas as pd import os from nilearn.input_data import NiftiMasker brain_masker = NiftiMasker(mask_img = mask, smoothing_fwhm=None, standardize=False, memory='nilearn_cache', memory_level=5, verbose=2) whole_brain = brain_masker.fit_transform(epi_coreg) avg_signal = np.mean(whole_brain,axis=1) all_regressors=pd.read_csv(compcor_regressors,sep='\t') #add global signal. all_regressors['global_signal']=avg_signal fn=os.getcwd()+'/all_regressors.txt' all_regressors.to_csv(fn, sep='\t', index=False) return [fn, compcor_regressors] #create a list of design to loop over. create_design = Node(util.Function(input_names=['compcor_regressors','epi_coreg','mask'], output_names=['reg_list'], function=create_designs), name='create_design') denoise.connect([ (compcor, create_design, [('components_file', 'compcor_regressors')]), (inputnode, create_design, [('epi_coreg', 'epi_coreg')]), (inputnode, create_design, [('brain_mask', 'mask')]) ]) # regress compcor and other noise components filter2 = MapNode(fsl.GLM(out_f_name='F_noise.nii.gz', out_pf_name='pF_noise.nii.gz', out_res_name='rest2anat_denoised.nii.gz', output_type='NIFTI_GZ', demean=True), iterfield=['design'], name='filternoise') filter2.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(inputnode, filter2, [('epi_coreg', 'in_file')]), #(createfilter2, filter2, [('out_files', 'design')]), #(compcor, filter2, [('components_file', 'design')]), (create_design, filter2, [('reg_list', 'design')]), (inputnode, filter2, [('brain_mask', 'mask')]), (filter2, outputnode, [('out_f', 'comp_F'), ('out_pf', 'comp_pF'), ('out_file', 'out_betas'), ('out_res', 'ts_fullspectrum'), ]) ]) def calc_sigma(TR,highpass): # https://www.jiscmail.ac.uk/cgi-bin/webadmin?A2=ind1205&L=FSL&P=R57592&1=FSL&9=A&I=-3&J=on&d=No+Match%3BMatch%3BMatches&z=4 sigma=1. / (2 * TR * highpass) return sigma calc_s=Node(util.Function(input_names=['TR', 'highpass'], output_names=['sigma'], function=calc_sigma), name='calc_s') denoise.connect(inputnode, 'tr', calc_s, 'TR') denoise.connect(inputnode, 'highpass_freq', calc_s, 'highpass') #use only highpass filter (because high-frequency content is already somewhat filtered in AROMA)) highpass_filter = MapNode(fsl.TemporalFilter(out_file='rest_denoised_highpassed.nii'), name='highpass_filter', iterfield=['in_file']) highpass_filter.plugin_args = {'submit_specs': 'request_memory = 17000'} denoise.connect([(calc_s, highpass_filter, [('sigma', 'highpass_sigma')]), (filter2, highpass_filter, [('out_res', 'in_file')]), (highpass_filter, outputnode, [('out_file', 'ts_filtered')]) ]) return denoise
pipe.connect(getdim, 'out_pixdim2', changedim, 'ydim') pipe.connect(getdim, 'out_pixdim3', changedim, 'zdim') ######################################################################################################################## # median angle correction from mypype.workflows.preproc.median_angle import create_median_angle_correction medang=create_median_angle_correction() medang.inputs.inputspec.target_angle=66 pipe.connect(changedim, 'out_file', ) ######################################################################################################################## # node for bandpass filter bandpass_filter = pe.MapNode(fsl.TemporalFilter(), # TODO: into preprocess workflow name='07_bandpass_filter', iterfield=['in_file']) bandpass_filter.inputs.highpass_sigma = 100 / (2 * _TR_) bandpass_filter.inputs.lowpass_sigma = 12.5 / (2 * _TR_) #pipe.connect(changedim, 'out_file', bandpass_filter, 'in_file') pipe.connect(medang, 'subject', bandpass_filter, 'in_file') ######################################################################################################################## # calculate_centrality graph=cent.create_resting_state_graphs(wf_name='08_centrality') #graph.inputs.centrality_options.method_options=[True, True] #graph.inputs.inputspec.method_option=1 graph.get_node( "calculate_centrality").iterables=[('method_option', [1,1,1]),
def create_resting_preproc(name='restpreproc'): """Create a "resting" time series preprocessing workflow The noise removal is based on Behzadi et al. (2007) Parameters ---------- name : name of workflow (default: restpreproc) Inputs:: inputspec.func : functional run (filename or list of filenames) Outputs:: outputspec.noise_mask_file : voxels used for PCA to derive noise components outputspec.filtered_file : bandpass filtered and noise-reduced time series Example ------- >>> TR = 3.0 >>> wf = create_resting_preproc() >>> wf.inputs.inputspec.func = 'f3.nii' >>> wf.inputs.inputspec.num_noise_components = 6 >>> wf.inputs.inputspec.highpass_sigma = 100/(2*TR) >>> wf.inputs.inputspec.lowpass_sigma = 12.5/(2*TR) >>> wf.run() # doctest: +SKIP """ restpreproc = pe.Workflow(name=name) # Define nodes inputnode = pe.Node(interface=util.IdentityInterface(fields=[ 'func', 'num_noise_components', 'highpass_sigma', 'lowpass_sigma' ]), name='inputspec') outputnode = pe.Node(interface=util.IdentityInterface(fields=[ 'noise_mask_file', 'filtered_file', ]), name='outputspec') slicetimer = pe.Node(fsl.SliceTimer(), name='slicetimer') realigner = create_realign_flow() tsnr = pe.Node(TSNR(regress_poly=2), name='tsnr') getthresh = pe.Node(interface=fsl.ImageStats(op_string='-p 98'), name='getthreshold') threshold_stddev = pe.Node(fsl.Threshold(), name='threshold') compcor = pe.Node(util.Function( input_names=['realigned_file', 'noise_mask_file', 'num_components'], output_names=['noise_components'], function=extract_noise_components), name='compcorr') remove_noise = pe.Node(fsl.FilterRegressor(filter_all=True), name='remove_noise') bandpass_filter = pe.Node(fsl.TemporalFilter(), name='bandpass_filter') # Define connections restpreproc.connect(inputnode, 'func', slicetimer, 'in_file') restpreproc.connect(slicetimer, 'slice_time_corrected_file', realigner, 'inputspec.func') restpreproc.connect(realigner, 'outputspec.realigned_file', tsnr, 'in_file') restpreproc.connect(tsnr, 'stddev_file', threshold_stddev, 'in_file') restpreproc.connect(tsnr, 'stddev_file', getthresh, 'in_file') restpreproc.connect(getthresh, 'out_stat', threshold_stddev, 'thresh') restpreproc.connect(realigner, 'outputspec.realigned_file', compcor, 'realigned_file') restpreproc.connect(threshold_stddev, 'out_file', compcor, 'noise_mask_file') restpreproc.connect(inputnode, 'num_noise_components', compcor, 'num_components') restpreproc.connect(tsnr, 'detrended_file', remove_noise, 'in_file') restpreproc.connect(compcor, 'noise_components', remove_noise, 'design_file') restpreproc.connect(inputnode, 'highpass_sigma', bandpass_filter, 'highpass_sigma') restpreproc.connect(inputnode, 'lowpass_sigma', bandpass_filter, 'lowpass_sigma') restpreproc.connect(remove_noise, 'out_file', bandpass_filter, 'in_file') restpreproc.connect(threshold_stddev, 'out_file', outputnode, 'noise_mask_file') restpreproc.connect(bandpass_filter, 'out_file', outputnode, 'filtered_file') return restpreproc
Threshold.inputs.args = '-bin' #Anatomical compcor: for inputs and outputs, see CompCor. NoiseComponents = pe.MapNode(interface=confounds.ACompCor(), name='NoiseComponents', iterfield=['realigned_file', 'mask_files']) NoiseComponents.inputs.num_components = 2 #Wraps command **fsl_regfilt** RegressionFilter = pe.MapNode(interface=fsl.FilterRegressor(), name='RegressionFilter', iterfield=['in_file', 'design_file']) RegressionFilter.inputs.filter_columns = [1, 2] #Wraps command **fslmaths** BandpassFilter = pe.MapNode(interface=fsl.TemporalFilter(), name='BandpassFilter', iterfield=['in_file']) BandpassFilter.inputs.highpass_sigma = 25 #Wraps the executable command ``bet``. BrainExtraction = pe.Node(interface=fsl.BET(), name='BrainExtraction') #Generic datasink module to store structured outputs io_DataSink = pe.Node(interface=io.DataSink(), name='io_DataSink') io_DataSink.inputs.base_directory = '/output/' #Basic interface class generates identity mappings Parameters = pe.Node(utility.IdentityInterface(fields=["subj_id", "run_num"]), name='Parameters', iterfield=['subj_id'])