def init_smooth_wf(fwhm=None, memcalc=MemoryCalculator(), name="smooth_wf"): """ Smooths a volume within a mask while correcting for the mask edge """ workflow = pe.Workflow(name=name) inputnode = pe.Node( interface=niu.IdentityInterface( fields=["in_file", "mask_file", "fwhm"]), name="inputnode", ) if fwhm is not None: assert isinstance(fwhm, float) inputnode.inputs.fwhm = fwhm smooth = pe.Node(afni.BlurInMask(preserve=True, float_out=True, out_file="blur.nii.gz"), name="smooth") workflow.connect([ ( inputnode, smooth, [("in_file", "in_file"), ("mask_file", "mask"), ("fwhm", "fwhm")], ), ]) outputnode = pe.Node(interface=niu.IdentityInterface(fields=["out_file"]), name="outputnode") workflow.connect(smooth, "out_file", outputnode, "out_file") return workflow
ref_file=cf_files['standard'], out_file = cf_files['masked'], mask_file = cf_files['standard_mask'] ), name = 'masker') #inputmask.inputs.mask_file = cf_files['standard_mask'] else: masker = Node(maths.ApplyMask( in_file=cf_files['bold'], out_file=cf_files['masked'], mask_file=cf_files['standard_mask'] ), name='masker') bim = Node(afni.BlurInMask( out_file=cf_files['smoothed'], mask = cf_files['standard_mask'], fwhm=5.0 ), name='bim') l1 = Node(SpecifyModel( event_files=EVfiles, realignment_parameters=confoundsfile, input_units='secs', time_repetition=2, high_pass_filter_cutoff=100 ), name='l1') l1model = Node(Level1Design( interscan_interval=2, bases={'dgamma': {'derivs': True}}, model_serial_correlations=True,
def FUNCPIPE(): #--- 1) Import modules import os # system functions os.system('clear') import nipype.interfaces.dcm2nii as dcm2nii import nipype.interfaces.io as nio # Data i/o import nipype.interfaces.fsl as fsl # fsl import nipype.interfaces.utility as util # utility import nipype.pipeline.engine as pe # pypeline engine import nipype.interfaces.fsl.utils as fslu import nipype.interfaces.fsl.preprocess as fslp from nipype.interfaces import afni as afni from nipype.interfaces.utility import Function import matplotlib from nilearn import plotting from nilearn import image import os import nipype.interfaces.fsl as fsl # fsl import nipype.interfaces.utility as util # utility import nipype.pipeline.engine as pe # pypeline engine import nipype.interfaces.freesurfer as fs # freesurfer tolist = lambda x: [x] highpass_operand = lambda x:'-bptf %.10f -1'%x #--- 2) Prompt user for directory containing DICOM FILES INITDIR=os.getcwd(); #--- 3) Prompt user for inputs. DICOMDIR=raw_input('Please drag in the directory of\nDICOM files you wish to pre-process\n(ensure there is no blank space at the end)\n') os.system('clear') print ('---\n') DICOMDIR=DICOMDIR.strip('\'"') frac=float(input('Please enter the fractional anisotropy threshold [0 - 1] \n')) os.system('clear') print ('---\n') grad=float(input('Please enter the threshold gradient [-1 - 1] \n')) os.system('clear') print ('---\n') FWHM=float(input('Please enter the FWHM of the smoother (mm) \n')) os.system('clear') print ('---\n') HIGHPASS=float(input('Please enter the High Pass filter cutoff (s)\n')) os.system('clear') print ('---\n') TR=float(input('Please enter the TR (s)\n')) os.system('clear') print ('---\n') #--- 4) Define workflow and input node. workflow = pe.Workflow(name='FUNCPIPE') inputnode = pe.Node(interface=util.IdentityInterface(fields=['fwhm','highpass','TR']),name='inputspec') inputnode.inputs.fwhm=FWHM inputnode.inputs.TR=TR inputnode.inputs.highpass=float(HIGHPASS/(inputnode.inputs.TR*2.5)) #--- 5) Move to directory os.chdir(DICOMDIR) #--- 6) Set up converter node for conversion to nifti converter=pe.Node(interface=dcm2nii.Dcm2nii(),name='CONVERTED') converter.inputs.source_dir=DICOMDIR converter.inputs.gzip_output=bool(1) #--- 7) Set up realigner node to match orientation of MNI 152 realigner=pe.Node(interface=fslu.Reorient2Std(),name='REORIENTED') realigner.inputs.output_type='NIFTI_GZ' workflow.connect(converter,'converted_files',realigner,'in_file') #--- 8) Set up a slice timing node slicetimer=pe.Node(interface=fslp.SliceTimer(),name='SLICETIMED') slicetimer.inputs.interleaved = True workflow.connect(inputnode, 'TR', slicetimer, 'time_repetition') workflow.connect(realigner, 'out_file', slicetimer, 'in_file') #--- 9) Convert to float. img2float = pe.Node(interface=fsl.ImageMaths(out_data_type='float',op_string='',suffix='_dtype'),name='IMG2FLOATED') workflow.connect(slicetimer,'slice_time_corrected_file',img2float,'in_file') #--- 10) Motion correct. motion_correct = pe.Node(interface=fsl.MCFLIRT(save_mats=True,save_plots=True,interpolation='spline'),name='MCORRECTED') workflow.connect(img2float, 'out_file', motion_correct, 'in_file') #--- 11) Despike despiker=pe.Node(interface=afni.Despike(),name='DESPIKED') despiker.inputs.outputtype = 'NIFTI_GZ' workflow.connect(motion_correct,'out_file',despiker,'in_file') #--- 12) Plot motion. plot_motion = pe.Node(interface=fsl.PlotMotionParams(in_source='fsl'),name='MOTIONPLOTTED') plot_motion.iterables = ('plot_type', ['rotations', 'translations']) workflow.connect(motion_correct, 'par_file', plot_motion, 'in_file') #--- 13) Extract extracter=pe.Node(interface=fsl.BET(),name='EXTRACTED') extracter.inputs.frac=float(frac) extracter.inputs.vertical_gradient=float(grad) extracter.inputs.mask=bool(1) extracter.inputs.functional=bool(1) workflow.connect(despiker, 'out_file', extracter, 'in_file') #--- 14) Smooth smoother=pe.MapNode(interface=afni.BlurInMask(),name='SMOOTHED',iterfield=['fwhm']) smoother.inputs.outputtype='NIFTI_GZ' workflow.connect(inputnode, 'fwhm', smoother, 'fwhm') workflow.connect(extracter, 'out_file', smoother, 'in_file') workflow.connect(extracter, 'mask_file', smoother, 'mask') #--- 15) Highpass filter # Filtering node highpass = pe.MapNode(interface=fsl.ImageMaths(suffix='_tempfilt'),name='HIGHPASSED',iterfield=['in_file']) workflow.connect(inputnode, ('highpass', highpass_operand), highpass, 'op_string') workflow.connect(smoother, 'out_file', highpass, 'in_file') #--- 16) Mean functional volume # Need to add back the mean removed by FSL meanfunc = pe.MapNode(interface=fsl.ImageMaths(op_string='-Tmean',suffix='_mean'),name='meanfunc',iterfield=['in_file']) workflow.connect(smoother, 'out_file', meanfunc, 'in_file') #--- 17) Add mean back to highpassed data (FINAL OUTPUT) addmean = pe.MapNode(interface=fsl.BinaryMaths(operation='add'),name='PREPROCESSED',iterfield=['in_file','operand_file']) workflow.connect(highpass, 'out_file', addmean, 'in_file') workflow.connect(meanfunc, 'out_file', addmean, 'operand_file') outputnode = pe.Node(interface=util.IdentityInterface(fields=['highpassed_files']),name='outputnode') workflow.connect(addmean, 'out_file', outputnode, 'highpassed_files') # Utility function for plotting extraction def bplot(in_file,in_file2,in_file3): from nilearn import image from nilearn import plotting import matplotlib niftifiledim=len(image.load_img(in_file).shape) firstim=image.index_img(in_file, 0) firstim2=image.index_img(in_file2, 0) display=plotting.plot_anat(firstim2) display.add_contours(firstim,filled=True, alpha=0.5,levels=[0.2], colors='b') display.add_edges(in_file3) matplotlib.pyplot.show() return niftifiledim #--- 18) Show extraction showextract= pe.Node(Function(input_names=['in_file','in_file2','in_file3'],output_names=['niftifiledim'],function=bplot),name='SHOWEXTRACT') workflow.connect(despiker,'out_file', showextract,'in_file2') workflow.connect(extracter,'out_file', showextract,'in_file') workflow.connect(extracter,'mask_file', showextract,'in_file3') # Utility function for plotting extraction def splot(in_file): from nilearn import image from nilearn import plotting import matplotlib niftifiledim=len(image.load_img(in_file).shape) firstim=image.index_img(in_file, 0) display=plotting.plot_anat(firstim,display_mode='z',cut_coords=10) matplotlib.pyplot.show() return niftifiledim #--- 19) Show smoothing showsmooth= pe.MapNode(Function(input_names=['in_file'],output_names=['niftifiledim'],function=splot),iterfield=['in_file'],name='SHOWSMOOTH') workflow.connect(smoother,'out_file', showsmooth,'in_file') #--- 20) Mean functional volume (for plotting stats) meanfunc2 = pe.Node(interface=fsl.ImageMaths(op_string='-Tmean',suffix='_mean'),name='MEANFUNCTIONAL') workflow.connect(extracter, 'out_file', meanfunc2, 'in_file') workflow.connect(meanfunc2, 'out_file', outputnode, 'mean_functional_volume') #--- 21) Plot workflow workflow.base_dir = DICOMDIR workflow.write_graph(graph2use='exec') #--- 22) Plot workflow result=workflow.run() #--- 23) Show plots #--- 24) Return to initial working directory print ("Workflow completed. Returning to intital directory\n") os.chdir(INITDIR)
def SMOOTHER(): #--- 1) Import modules import nipype.pipeline.engine as pe import os os.system('clear') from glob import glob import nipype.interfaces.fsl.preprocess as fslp from nipype.interfaces import afni as afni import nipype.interfaces.utility as util from nipype.interfaces.utility import Function #--- 2) Record intial working directory INITDIR = os.getcwd() #--- 3) Prompt user for nifti file NIFTIFILE = raw_input( 'Please drag in the functional volume\n(ensure there is no blank space at the end)\n' ) os.system('clear') print '---\n' NIFTIMASK = raw_input( 'Please drag in the mask\n for the functional volume\n(ensure there is no blank space at the end)\n' ) os.system('clear') print '---\n' FWHM = input('Please enter the FWHM (mm) of the smoother\n') os.system('clear') print '---\n' NIFTIFILE = NIFTIFILE.strip('\'"') NIFTIDIR = os.path.split(NIFTIFILE)[0] #--- 3) Move to directory os.chdir(NIFTIDIR) #--- 4) Set up input node inputnode = pe.Node(interface=util.IdentityInterface(fields=['fwhm']), name='inputspec') inputnode.inputs.fwhm = FWHM #--- 5) Set up smoothing node smoother = pe.MapNode(interface=afni.BlurInMask(), name='SMOOTHED', iterfield=['fwhm']) smoother.inputs.outputtype = 'NIFTI_GZ' smoother.inputs.in_file = NIFTIFILE smoother.inputs.mask = NIFTIMASK #--- 6) Function for plotting result def splot(in_file): from nilearn import image from nilearn import plotting import matplotlib niftifiledim = len(image.load_img(in_file).shape) firstim = image.index_img(in_file, 0) display = plotting.plot_anat(firstim, display_mode='z', cut_coords=10) matplotlib.pyplot.show() return niftifiledim #--- 7) Node for plotting smoothing showsmooth = pe.MapNode(Function(input_names=['in_file'], output_names=['niftifiledim'], function=splot), iterfield=['in_file'], name='SHOWSMOOTH') #--- 8) Set up workflow workflow = pe.Workflow(name='SMOOTHER') workflow.base_dir = NIFTIDIR #--- 9) Connect nodes. workflow.connect(inputnode, 'fwhm', smoother, 'fwhm') workflow.connect(smoother, 'out_file', showsmooth, 'in_file') workflow.write_graph(graph2use='exec') #--- 10) Run workflow result = workflow.run() print "Node completed. Returning to intital directory\n" os.chdir(INITDIR)
def first_level_wf(pipeline, subject_id, task_id, output_dir): """ First level workflow """ workflow = pe.Workflow(name='_'.join((pipeline, subject_id, task_id))) inputnode = pe.Node(niu.IdentityInterface(fields=[ 'bold_preproc', 'contrasts', 'confounds', 'brainmask', 'events_file' ]), name='inputnode') outputnode = pe.Node( niu.IdentityInterface(fields=['sigma_pre', 'sigma_post', 'out_stats']), name='outputnode') conf2movpar = pe.Node(niu.Function(function=_confounds2movpar), name='conf2movpar') masker = pe.Node(fsl.ApplyMask(), name='masker') bim = pe.Node(afni.BlurInMask(fwhm=5.0, outputtype='NIFTI_GZ'), name='bim', mem_gb=20) ev = pe.Node(EventsFilesForTask(task=task_id), name='events') l1 = pe.Node(SpecifyModel( input_units='secs', time_repetition=2, high_pass_filter_cutoff=100, parameter_source='FSL', ), name='l1') l1model = pe.Node(fsl.Level1Design(interscan_interval=2, bases={'dgamma': { 'derivs': True }}, model_serial_correlations=True), name='l1design') l1featmodel = pe.Node(fsl.FEATModel(), name='l1model') l1estimate = pe.Node(fsl.FEAT(), name='l1estimate', mem_gb=40) pre_smooth_afni = pe.Node(afni.FWHMx(combine=True, detrend=True, args='-ShowMeClassicFWHM'), name='smooth_pre_afni', mem_gb=20) post_smooth_afni = pe.Node(afni.FWHMx(combine=True, detrend=True, args='-ShowMeClassicFWHM'), name='smooth_post_afni', mem_gb=20) pre_smooth = pe.Node(fsl.SmoothEstimate(), name='smooth_pre', mem_gb=20) post_smooth = pe.Node(fsl.SmoothEstimate(), name='smooth_post', mem_gb=20) def _resels(val): return val**(1 / 3.) def _fwhm(fwhm): from numpy import mean return float(mean(fwhm, dtype=float)) workflow.connect([ (inputnode, masker, [('bold_preproc', 'in_file'), ('brainmask', 'mask_file')]), (inputnode, ev, [('events_file', 'in_file')]), (inputnode, l1model, [('contrasts', 'contrasts')]), (inputnode, conf2movpar, [('confounds', 'in_confounds')]), (inputnode, bim, [('brainmask', 'mask')]), (masker, bim, [('out_file', 'in_file')]), (bim, l1, [('out_file', 'functional_runs')]), (ev, l1, [('event_files', 'event_files')]), (conf2movpar, l1, [('out', 'realignment_parameters')]), (l1, l1model, [('session_info', 'session_info')]), (ev, l1model, [('orthogonalization', 'orthogonalization')]), (l1model, l1featmodel, [('fsf_files', 'fsf_file'), ('ev_files', 'ev_files')]), (l1model, l1estimate, [('fsf_files', 'fsf_file')]), # Smooth (inputnode, pre_smooth, [('bold_preproc', 'zstat_file'), ('brainmask', 'mask_file')]), (bim, post_smooth, [('out_file', 'zstat_file')]), (inputnode, post_smooth, [('brainmask', 'mask_file')]), (pre_smooth, outputnode, [(('resels', _resels), 'sigma_pre')]), (post_smooth, outputnode, [(('resels', _resels), 'sigma_post')]), # Smooth with AFNI (inputnode, pre_smooth_afni, [('bold_preproc', 'in_file'), ('brainmask', 'mask')]), (bim, post_smooth_afni, [('out_file', 'in_file')]), (inputnode, post_smooth_afni, [('brainmask', 'mask')]), ]) # Writing outputs csv = pe.Node(AddCSVRow(in_file=str(output_dir / 'smoothness.csv')), name='addcsv_%s_%s' % (subject_id, pipeline)) csv.inputs.sub_id = subject_id csv.inputs.pipeline = pipeline # Datasinks ds_stats = pe.Node(niu.Function(function=_feat_stats), name='ds_stats') ds_stats.inputs.subject_id = subject_id ds_stats.inputs.task_id = task_id ds_stats.inputs.variant = pipeline ds_stats.inputs.out_path = output_dir setattr(ds_stats.interface, '_always_run', True) workflow.connect([ (outputnode, csv, [('sigma_pre', 'smooth_pre'), ('sigma_post', 'smooth_post')]), (pre_smooth_afni, csv, [(('fwhm', _fwhm), 'fwhm_pre')]), (post_smooth_afni, csv, [(('fwhm', _fwhm), 'fwhm_post')]), (l1estimate, ds_stats, [('feat_dir', 'feat_dir')]), (ds_stats, outputnode, [('out', 'out_stats')]), ]) return workflow
def base_preproc2(trim_realign=True,name='rsfmri_base_preproc'): inputnode = pe.Node( utility.IdentityInterface( fields=['fmri','fmri_mask']), name='inputspec') outputnode = pe.Node( utility.IdentityInterface( fields=['preprocessed','mean','motion']), name='outputspec') # n_trim = pe.Node( # interface=nipypp.Trim(begin_index=3), # name='trim') n_realign = pe.Node( fsl.MCFLIRT(ref_vol=0, save_plots=True, save_rms=True, save_mats=True, stats_imgs=True,), name='realign') n_mean = pe.Node(fsl.MeanImage(),name='mean') n_mask_mean = pe.Node( interface=fsl.ImageMaths(op_string='-mul', suffix='_brain', output_type='NIFTI'), name='mask_mean') #linear with shear/scale in phase direction n_smooth = pe.Node( afni.BlurInMask(fwhm=5.0, out_file='%s_smooth', float_out=True), name = 'smooth') n_bandpass_smooth = pe.Node( afni.Bandpass(highpass=0.005, lowpass=999999, despike=True, blur=5.0, normalize=False, out_file='%s_filt.nii.gz'), name='bandpass_smooth') n_motion_filter = pe.Node( interface = nipypp.RegressOutMotion( motion_source='fsl', regressors_type='voxelwise_translation', global_signal = False, prefix = 'mfilt_', regressors_transform='original+bw_derivatives'), name = 'motion_filter') n_motion_estimates = pe.Node( nipyutils.MotionEstimate(motion_source='fsl'), name='motion_estimates') w=pe.Workflow(name=name) if trim_realign: w.connect([ (inputnode, n_realign, [('fmri','in_file')]), (n_realign, n_motion_filter, [('out_file','in_file'), ('par_file','motion')]), (inputnode, n_motion_filter,[('fmri_mask','mask')]), (n_motion_filter, n_bandpass_smooth, [('out_file','in_file')]), (n_realign, n_mask_mean, [('mean_img', 'in_file')]), (n_realign, n_motion_estimates,[('par_file','motion')]), (inputnode, n_motion_estimates,[('fmri_mask','mask')]), (n_realign, outputnode, [('par_file','motion')]), ]) else: w.connect([ (inputnode, n_bandpass_smooth, [('fmri','in_file')]), (inputnode, n_mean, [('fmri','in_file')]), (n_mean, n_mask_mean, [('out_file', 'in_file')]), ]) w.connect([ (inputnode, n_mask_mean, [('fmri_mask', 'in_file2')]), (inputnode, n_bandpass_smooth, [('fmri_mask','mask')]), (n_bandpass_smooth, outputnode, [('out_file','preprocessed')]), (n_mask_mean, outputnode, [('out_file','mean')]), ]) return w
def base_preproc(trim_realign=True,name='rsfmri_base_preproc'): inputnode = pe.Node( utility.IdentityInterface( fields=['fmri','t1','t1_mask']), name='inputspec') outputnode = pe.Node( utility.IdentityInterface( fields=['preprocessed','mask','mean','motion']), name='outputspec') # n_trim = pe.Node( # interface=nipypp.Trim(begin_index=3), # name='trim') n_realign = pe.Node( fsl.MCFLIRT(ref_vol=0, mean_vol=True, save_plots=True, save_rms=True, save_mats=True, stats_imgs=True,), name='realign') n_mean = pe.Node(fsl.MeanImage(),name='mean') n_mask = pe.Node( interface=afni.Automask( out_file='%s_mask.nii', # brain_file=Undefined, outputtype='NIFTI'), name='mask') n_mask_mean = pe.Node( interface=fsl.ImageMaths(op_string='-mul', suffix='_brain', output_type='NIFTI'), name='mask_mean') n_segment_epi = pe.Node( fsl.FAST( img_type=2, number_classes=3, probability_maps=True, segments=True), name='segment_epi') #linear with shear/scale in phase direction n_coregister_linear = pe.Node( afni.Allineate(epi=True, args='-float',cost='nmi', out_param_file='params.1D', out_matrix='coregister.mat'), name='coregister_linear') n_coregister_gray_linear = pe.Node( afni.Allineate(epi=True, args='-float',cost='nmi', out_param_file='params.1D', out_matrix='coregister.mat'), name='coregister_gray_linear') n_smooth = pe.Node( afni.BlurInMask(fwhm=5.0, out_file='%s_smooth', float_out=True), name = 'smooth') n_bandpass_smooth = pe.Node( afni.Bandpass(highpass=0.005, lowpass=999999, despike=True, blur=5.0, normalize=False, out_file='%s_filt.nii.gz'), name='bandpass_smooth') n_motion_filter = pe.Node( interface = nipypp.RegressOutMotion( motion_source='fsl', regressors_type='voxelwise_translation', global_signal = False, prefix = 'mfilt_', regressors_transform='original+bw_derivatives'), name = 'motion_filter') # spm_path = spm.Info().version()['path'] # epi_tpl = os.path.join(spm_path, 'templates/EPI.nii') """ n_normalize = pe.Node( spm.Normalize(template=epi_tpl, source_image_smoothing=8, template_image_smoothing=0, DCT_period_cutoff=25, affine_regularization_type='mni', jobtype='est'), name='normalize') """ n_motion_estimates = pe.Node( nipyutils.MotionEstimate(motion_source='fsl'), name='motion_estimates') w=pe.Workflow(name=name) if trim_realign: w.connect([ # (inputnode, n_trim, [('fmri','in_file')]), # (inputnode, n_trim, [('fmri','in_file_a'), # (('fmri',n_volumes,-1),'stop_idx')]), # (n_trim, n_realign, [('out_file','in_file')]), (inputnode, n_realign, [('fmri','in_file')]), # (inputnode, n_realign, [('fmri','in_file')]), (n_realign, n_motion_filter, [('out_file','in_file'), ('par_file','motion')]), (n_mask, n_motion_filter,[('out_file','mask')]), (n_motion_filter, n_bandpass_smooth, [('out_file','in_file')]), (n_realign, n_mask, [('out_file','in_file')]), (n_realign, n_mask_mean, [('mean_img', 'in_file')]), (n_realign, n_motion_estimates,[('par_file','motion')]), (n_mask, n_motion_estimates,[('out_file','mask')]), (n_realign, outputnode, [('par_file','motion')]), ]) else: w.connect([ (inputnode, n_bandpass_smooth, [('fmri','in_file')]), (inputnode, n_mean, [('fmri','in_file')]), (inputnode, n_mask, [('fmri','in_file')]), (n_mean, n_mask_mean, [('out_file', 'in_file')]), ]) w.connect([ (n_mask, n_mask_mean, [('out_file', 'in_file2')]), (n_mask, n_bandpass_smooth, [('out_file','mask')]), # (n_mask_mean, n_segment_epi, [('out_file','in_files')]), # (n_mask_mean, n_normalize, [('out_file','source')]), # (n_detrend, n_smooth, [('out_file','in_file')]), # (n_mask, n_smooth, [('out_file', 'mask')]), # (n_smooth, outputnode, [('out_file','preprocessed')]), (n_bandpass_smooth, outputnode, [('out_file','preprocessed')]), (n_mask, outputnode, [('out_file','mask')]), (n_mask_mean, outputnode, [('out_file','mean')]), ]) return w