def create_non_uniformity_correct_4D_file(auto_clip=False, clip_low=7, clip_high=200, n_procs=12): """non_uniformity_correct_4D_file corrects functional files for nonuniformity on a timepoint by timepoint way. Internally it implements a workflow to split the in_file, correct each separately and then merge them back together. This is an ugly workaround as we have to find the output of the workflow's datasink somewhere, but it should work. Parameters ---------- in_file : str Absolute path to nifti-file. auto_clip : bool (default: False) whether to let 3dUniformize decide on clipping boundaries clip_low : float (default: 7), lower clipping bound for 3dUniformize clip_high : float (default: 200), higher clipping bound for 3dUniformize n_procs : int (default: 12), the number of processes to run the internal workflow with Returns ------- out_file : non-uniformity corrected file List of absolute paths to nifti-files. """ # nodes input_node = pe.Node(IdentityInterface( fields=['in_file', 'auto_clip', 'clip_low', 'clip_high', 'output_directory', 'sub_id']), name='inputspec') split = pe.Node(Function(input_names='in_file', output_names=['out_files'], function=split_4D_to_3D), name='split') uniformer = pe.MapNode( Uniformize(clip_high=clip_high, clip_low=clip_low, auto_clip=auto_clip, outputtype='NIFTI_GZ'), name='uniformer', iterfield=['in_file']) merge = pe.MapNode(fsl.Merge(dimension='t'), name='merge', iterfield=['in_files']) datasink = pe.Node(nio.DataSink(infields=['topup'], container=''), name='sinker') datasink.inputs.parameterization = False # workflow nuc_wf = pe.Workflow(name='nuc') nuc_wf.connect(input_node, 'sub_id', datasink, 'container') nuc_wf.connect(input_node, 'output_directory', datasink, 'base_directory') nuc_wf.connect(input_node, 'in_file', split, 'in_file') nuc_wf.connect(split, 'out_files', uniformer, 'in_file') nuc_wf.connect(uniformer, 'out_file', merge, 'in_files') nuc_wf.connect(merge, 'merged_file', datasink, 'uni') # nuc_wf.run('MultiProc', plugin_args={'n_procs': n_procs}) # out_file = glob.glob(os.path.join(td, 'uni', fn_base + '_0000*.nii.gz'))[0] return nuc_wf
def vol2png(qcname, tag="", overlay=True, overlayiterated=True): import PUMI.func_preproc.Onevol as onevol QCDir = os.path.abspath(globals._SinkDir_ + "/" + globals._QCDir_) if not os.path.exists(QCDir): os.makedirs(QCDir) if tag: tag = "_" + tag inputspec = pe.Node( utility.IdentityInterface(fields=['bg_image', 'overlay_image']), name='inputspec') analysisflow = pe.Workflow(name=qcname + tag + '_qc') myonevol_bg = onevol.onevol_workflow(wf_name="onebg") analysisflow.connect(inputspec, 'bg_image', myonevol_bg, 'inputspec.func') if overlay and not overlayiterated: #myonevol_ol = onevol.onevol_workflow(wf_name="oneol") #analysisflow.connect(inputspec, 'overlay_image', myonevol_ol, 'inputspec.func') slicer = pe.MapNode(interface=fsl.Slicer(), iterfield=['in_file'], name='slicer') # Create png images for quality check if overlay and overlayiterated: myonevol_ol = onevol.onevol_workflow(wf_name="oneol") analysisflow.connect(inputspec, 'overlay_image', myonevol_ol, 'inputspec.func') slicer = pe.MapNode(interface=fsl.Slicer(), iterfield=['in_file', 'image_edges'], name='slicer') if not overlay: slicer = pe.MapNode(interface=fsl.Slicer(), iterfield=['in_file'], name='slicer') slicer.inputs.image_width = 2000 slicer.inputs.out_file = qcname # set output all axial slices into one picture slicer.inputs.sample_axial = 5 #slicer.inputs.middle_slices = True # Save outputs which are important ds_qc = pe.Node(interface=io.DataSink(), name='ds_qc') ds_qc.inputs.base_directory = QCDir ds_qc.inputs.regexp_substitutions = [("(\/)[^\/]*$", tag + ".ppm")] analysisflow.connect(myonevol_bg, 'outputspec.func1vol', slicer, 'in_file') if overlay and not overlayiterated: analysisflow.connect(inputspec, 'overlay_image', slicer, 'image_edges') if overlay and overlayiterated: analysisflow.connect(myonevol_ol, 'outputspec.func1vol', slicer, 'image_edges') analysisflow.connect(slicer, 'out_file', ds_qc, qcname) return analysisflow
def fMRI2QC(qcname, tag="", SinkDir=".", QCDIR="QC", indiv_atlas=False): import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import PUMI.plot.image as plot QCDir = os.path.abspath(globals._SinkDir_ + "/" + globals._QCDir_) if not os.path.exists(QCDir): os.makedirs(QCDir) if tag: tag = "_" + tag # Basic interface class generates identity mappings inputspec = pe.Node( utility.IdentityInterface(fields=['func', 'atlas', 'confounds']), name='inputspec') inputspec.inputs.atlas = globals._FSLDIR_ + '/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr25-3mm.nii.gz' if indiv_atlas: plotfmri = pe.MapNode(interface=Function( input_names=['func', 'atlaslabels', 'confounds', 'output_file'], output_names=['plotfile'], function=plot.plot_fmri_qc), iterfield=['func', 'confounds', 'atlaslabels'], name="qc_fmri") else: plotfmri = pe.MapNode(interface=Function( input_names=['func', 'atlaslabels', 'confounds', 'output_file'], output_names=['plotfile'], function=plot.plot_fmri_qc), iterfield=['func', 'confounds'], name="qc_fmri") plotfmri.inputs.output_file = "qc_fmri.png" # default atlas works only for standardized, 3mm-resoultion data # Save outputs which are important ds_qc = pe.Node(interface=io.DataSink(), name='ds_qc') ds_qc.inputs.base_directory = QCDir ds_qc.inputs.regexp_substitutions = [("(\/)[^\/]*$", tag + ".png")] # Create a workflow analysisflow = nipype.Workflow(name=qcname + tag + '_qc') analysisflow.connect(inputspec, 'func', plotfmri, 'func') analysisflow.connect(inputspec, 'atlas', plotfmri, 'atlaslabels') analysisflow.connect(inputspec, 'confounds', plotfmri, 'confounds') analysisflow.connect(plotfmri, 'plotfile', ds_qc, qcname) return analysisflow
def create_anat_noise_roi_workflow(SinkTag="func_preproc", wf_name="create_noise_roi"): """ Creates an anatomical noise ROI for use with compcor inputs are awaited from the (BBR-based) func2anat registration and are already transformed to functional space Tamas Spisak 2018 """ import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import PUMI.utils.globals as globals # Basic interface class generates identity mappings inputspec = pe.Node( utility.IdentityInterface(fields=['wm_mask', 'ventricle_mask']), name='inputspec') # Basic interface class generates identity mappings outputspec = pe.Node(utility.IdentityInterface(fields=['noise_roi']), name='outputspec') SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) wf = nipype.Workflow(wf_name) # erode WM mask in functional space erode_mask = pe.MapNode(fsl.ErodeImage(), iterfield=['in_file'], name="erode_wm_mask") wf.connect(inputspec, 'wm_mask', erode_mask, 'in_file') # add ventricle and eroded WM masks add_masks = pe.MapNode(fsl.ImageMaths(op_string=' -add'), iterfield=['in_file', 'in_file2'], name="addimgs") wf.connect(inputspec, 'ventricle_mask', add_masks, 'in_file') wf.connect(erode_mask, 'out_file', add_masks, 'in_file2') wf.connect(add_masks, 'out_file', outputspec, 'noise_roi') return wf
def test_savgol_filter_node(): sg_node = pe.MapNode(interface=Savgol_filter, name='savgol_filt', iterfield=['in_file']) sg_node.inputs.in_file = func_data res = sg_node.run() for f in res.outputs.out_file: assert (op.isfile(f))
def create_melodic_workflow(name='melodic', template=None, varnorm=True): input_node = pe.Node(IdentityInterface(fields=['in_file']), name='inputspec') output_node = pe.Node(IdentityInterface(fields=['out_dir']), name='outputspec') if template is None: template = op.join(op.dirname(op.dirname(op.abspath(__file__))), 'data', 'fsf_templates', 'melodic_template.fsf') melodic4fix_node = pe.MapNode(interface=Melodic4fix, iterfield=['in_file', 'out_dir'], name='melodic4fix') # Don't know if this works. Could also set these defaults inside the # melodic4fix node definition... melodic4fix_node.inputs.template = template melodic4fix_node.inputs.varnorm = varnorm rename_ica = pe.MapNode(Function(input_names=['in_file'], output_names=['out_file'], function=extract_task), name='rename_ica', iterfield=['in_file']) mel4fix_workflow = pe.Workflow(name=name) mel4fix_workflow.connect(input_node, 'in_file', melodic4fix_node, 'in_file') mel4fix_workflow.connect(input_node, 'in_file', rename_ica, 'in_file') mel4fix_workflow.connect(rename_ica, 'out_file', melodic4fix_node, 'out_dir') mel4fix_workflow.connect(melodic4fix_node, 'out_dir', output_node, 'out_dir') return mel4fix_workflow
def create_motion_confound_workflow(order=2, fd_cutoff=.2, name='motion_confound'): input_node = pe.Node(interface=IdentityInterface( fields=['par_file', 'output_directory', 'sub_id']), name='inputspec') output_node = pe.Node( interface=IdentityInterface(fields=['out_fd', 'out_ext_moco']), name='outputspec') datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False extend_motion_parameters = pe.MapNode(Extend_motion_parameters, iterfield=['par_file'], name='extend_motion_parameters') extend_motion_parameters.inputs.order = order framewise_disp = pe.MapNode(FramewiseDisplacement(parameter_source='FSL'), iterfield=['in_file'], name='framewise_disp') mcf_wf = pe.Workflow(name=name) mcf_wf.connect(input_node, 'output_directory', datasink, 'base_directory') mcf_wf.connect(input_node, 'sub_id', datasink, 'container') mcf_wf.connect(input_node, 'par_file', extend_motion_parameters, 'par_file') mcf_wf.connect(input_node, 'par_file', framewise_disp, 'in_file') mcf_wf.connect(extend_motion_parameters, 'out_ext', output_node, 'out_ext_moco') mcf_wf.connect(framewise_disp, 'out_file', output_node, 'out_fd') mcf_wf.connect(extend_motion_parameters, 'out_ext', datasink, 'confounds') mcf_wf.connect(framewise_disp, 'out_file', datasink, 'confounds.@df') return mcf_wf
def regTimeseriesQC(qcname, tag="", SinkDir=".", QCDIR="QC"): import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import PUMI.plot.timeseries as plot QCDir = os.path.abspath(globals._SinkDir_ + "/" + globals._QCDir_) if not os.path.exists(QCDir): os.makedirs(QCDir) if tag: tag = "_" + tag # Basic interface class generates identity mappings inputspec = pe.Node( utility.IdentityInterface(fields=['timeseries', 'modules', 'atlas']), name='inputspec') inputspec.inputs.atlas = None plotregts = pe.MapNode(interface=Function( input_names=['timeseries', 'modules', 'output_file', 'atlas'], output_names=['plotfile'], function=plot.plot_carpet_ts), iterfield=['timeseries'], name="qc_timeseries") plotregts.inputs.output_file = "qc_timeseries.png" # Save outputs which are important ds_qc = pe.Node(interface=io.DataSink(), name='ds_qc') ds_qc.inputs.base_directory = QCDir ds_qc.inputs.regexp_substitutions = [("(\/)[^\/]*$", tag + ".png")] # Create a workflow analysisflow = nipype.Workflow(name=qcname + tag + '_qc') analysisflow.connect(inputspec, 'timeseries', plotregts, 'timeseries') analysisflow.connect(inputspec, 'atlas', plotregts, 'atlas') analysisflow.connect(inputspec, 'modules', plotregts, 'modules') analysisflow.connect(plotregts, 'plotfile', ds_qc, qcname) return analysisflow
def bbr_workflow(SinkTag="func_preproc", wf_name="func2anat"): """ Modified version of CPAC.registration.registration: `source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/registration/registration.html` BBR registration of functional image to anat. Workflow inputs: :param func: One volume of the 4D fMRI (The one which is the closest to the fieldmap recording in time should be chosen- e.g: if fieldmap was recorded after the fMRI the last volume of it should be chosen). :param skull: The oriented high res T1w image. :param anat_wm_segmentation: WM probability mask in . :param anat_csf_segmentation: CSF probability mask in :param bbr_schedule: Parameters which specifies BBR options. :param SinkDir: :param SinkTag: The output directory in which the returned images (see workflow outputs) could be found. Workflow outputs: :return: bbreg_workflow - workflow func="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/s002/func_data.nii.gz", skull="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz", anat_wm_segmentation="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/anat_preproc/fast/fast__prob_2.nii.gz", Balint Kincses [email protected] 2018 """ import os import nipype.pipeline as pe from nipype.interfaces.utility import Function import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import nipype.interfaces.io as io import PUMI.func_preproc.Onevol as onevol import PUMI.utils.QC as qc import PUMI.utils.globals as globals SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) # Define inputs of the workflow inputspec = pe.Node(utility.IdentityInterface(fields=[ 'func', 'skull', 'anat_wm_segmentation', 'anat_gm_segmentation', 'anat_csf_segmentation', 'anat_ventricle_segmentation' ]), name='inputspec') myonevol = onevol.onevol_workflow() # trilinear interpolation is used by default in linear registration for func to anat linear_reg = pe.MapNode(interface=fsl.FLIRT(), iterfield=['in_file', 'reference'], name='linear_func_to_anat') linear_reg.inputs.cost = 'corratio' linear_reg.inputs.dof = 6 linear_reg.inputs.out_matrix_file = "lin_mat" # WM probability map is thresholded and masked wm_bb_mask = pe.MapNode(interface=fsl.ImageMaths(), iterfield=['in_file'], name='wm_bb_mask') wm_bb_mask.inputs.op_string = '-thr 0.5 -bin' # CSf probability map is thresholded and masked csf_bb_mask = pe.MapNode(interface=fsl.ImageMaths(), iterfield=['in_file'], name='csf_bb_mask') csf_bb_mask.inputs.op_string = '-thr 0.5 -bin' # GM probability map is thresholded and masked gm_bb_mask = pe.MapNode(interface=fsl.ImageMaths(), iterfield=['in_file'], name='gm_bb_mask') gm_bb_mask.inputs.op_string = '-thr 0.1 -bin' # liberal mask to capture all gm signal # ventricle probability map is thresholded and masked vent_bb_mask = pe.MapNode(interface=fsl.ImageMaths(), iterfield=['in_file'], name='vent_bb_mask') vent_bb_mask.inputs.op_string = '-thr 0.8 -bin -ero -dilM' # stricter threshold and some morphology for compcor # add the CSF and WM masks #add_masks=pe.MapNode(interface=fsl.ImageMaths(), # iterfield=['in_file','in_file2'], # name='add_masks') #add_masks.inputs.op_string = ' -add' # A function is defined for define bbr argumentum which says flirt to perform bbr registration # for each element of the list, due to MapNode def bbreg_args(bbreg_target): return '-cost bbr -wmseg ' + bbreg_target bbreg_arg_convert = pe.MapNode(interface=Function( input_names=["bbreg_target"], output_names=["arg"], function=bbreg_args), iterfield=['bbreg_target'], name="bbr_arg_converter") # BBR registration within the FLIRT node bbreg_func_to_anat = pe.MapNode( interface=fsl.FLIRT(), iterfield=['in_file', 'reference', 'in_matrix_file', 'args'], name='bbreg_func_to_anat') bbreg_func_to_anat.inputs.dof = 6 # calculate the inverse of the transformation matrix (of func to anat) convertmatrix = pe.MapNode(interface=fsl.ConvertXFM(), iterfield=['in_file'], name="convertmatrix") convertmatrix.inputs.invert_xfm = True # use the invers registration (anat to func) to transform anatomical csf mask reg_anatmask_to_func1 = pe.MapNode( interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'), iterfield=['in_file', 'reference', 'in_matrix_file'], name='anatmasks_to_func1') #reg_anatmask_to_func1.inputs.apply_xfm = True # use the invers registration (anat to func) to transform anatomical wm mask reg_anatmask_to_func2 = pe.MapNode( interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'), iterfield=['in_file', 'reference', 'in_matrix_file'], name='anatmasks_to_func2') #reg_anatmask_to_func2.inputs.apply_xfm = True # use the invers registration (anat to func) to transform anatomical gm mask reg_anatmask_to_func3 = pe.MapNode( interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'), iterfield=['in_file', 'reference', 'in_matrix_file'], name='anatmasks_to_func3') # reg_anatmask_to_func2.inputs.apply_xfm = True # use the invers registration (anat to func) to transform anatomical gm mask reg_anatmask_to_func4 = pe.MapNode( interface=fsl.FLIRT(apply_xfm=True, interp='nearestneighbour'), iterfield=['in_file', 'reference', 'in_matrix_file'], name='anatmasks_to_func4') # reg_anatmask_to_func2.inputs.apply_xfm = True # Create png images for quality check myqc = qc.vol2png("func2anat") # Save outputs which are important ds = pe.Node(interface=io.DataSink(), name='ds_nii') ds.inputs.base_directory = SinkDir ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] # Define outputs of the workflow outputspec = pe.Node(utility.IdentityInterface(fields=[ 'func_sample2anat', 'example_func', 'func_to_anat_linear_xfm', 'anat_to_func_linear_xfm', 'csf_mask_in_funcspace', 'wm_mask_in_funcspace', 'gm_mask_in_funcspace', 'ventricle_mask_in_funcspace' ]), name='outputspec') analysisflow = pe.Workflow(name=wf_name) analysisflow.base_dir = '.' analysisflow.connect(inputspec, 'func', myonevol, 'inputspec.func') analysisflow.connect(myonevol, 'outputspec.func1vol', linear_reg, 'in_file') analysisflow.connect(inputspec, 'skull', linear_reg, 'reference') analysisflow.connect(linear_reg, 'out_matrix_file', bbreg_func_to_anat, 'in_matrix_file') analysisflow.connect(myonevol, 'outputspec.func1vol', bbreg_func_to_anat, 'in_file') analysisflow.connect(inputspec, 'anat_wm_segmentation', bbreg_arg_convert, 'bbreg_target') analysisflow.connect(bbreg_arg_convert, 'arg', bbreg_func_to_anat, 'args') analysisflow.connect(inputspec, 'skull', bbreg_func_to_anat, 'reference') analysisflow.connect(bbreg_func_to_anat, 'out_matrix_file', convertmatrix, 'in_file') analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func1, 'in_matrix_file') analysisflow.connect(myonevol, 'outputspec.func1vol', reg_anatmask_to_func1, 'reference') analysisflow.connect(csf_bb_mask, 'out_file', reg_anatmask_to_func1, 'in_file') analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func2, 'in_matrix_file') analysisflow.connect(myonevol, 'outputspec.func1vol', reg_anatmask_to_func2, 'reference') analysisflow.connect(wm_bb_mask, 'out_file', reg_anatmask_to_func2, 'in_file') analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func3, 'in_matrix_file') analysisflow.connect(myonevol, 'outputspec.func1vol', reg_anatmask_to_func3, 'reference') analysisflow.connect(gm_bb_mask, 'out_file', reg_anatmask_to_func3, 'in_file') analysisflow.connect(convertmatrix, 'out_file', reg_anatmask_to_func4, 'in_matrix_file') analysisflow.connect(myonevol, 'outputspec.func1vol', reg_anatmask_to_func4, 'reference') analysisflow.connect(vent_bb_mask, 'out_file', reg_anatmask_to_func4, 'in_file') analysisflow.connect(inputspec, 'anat_wm_segmentation', wm_bb_mask, 'in_file') analysisflow.connect(inputspec, 'anat_csf_segmentation', csf_bb_mask, 'in_file') analysisflow.connect(inputspec, 'anat_gm_segmentation', gm_bb_mask, 'in_file') analysisflow.connect(inputspec, 'anat_ventricle_segmentation', vent_bb_mask, 'in_file') analysisflow.connect(bbreg_func_to_anat, 'out_file', outputspec, 'func_sample2anat') analysisflow.connect(bbreg_func_to_anat, 'out_matrix_file', outputspec, 'func_to_anat_linear_xfm') analysisflow.connect(reg_anatmask_to_func1, 'out_file', outputspec, 'csf_mask_in_funcspace') analysisflow.connect(reg_anatmask_to_func2, 'out_file', outputspec, 'wm_mask_in_funcspace') analysisflow.connect(reg_anatmask_to_func3, 'out_file', outputspec, 'gm_mask_in_funcspace') analysisflow.connect(reg_anatmask_to_func4, 'out_file', outputspec, 'ventricle_mask_in_funcspace') analysisflow.connect(myonevol, 'outputspec.func1vol', outputspec, 'example_func') analysisflow.connect(convertmatrix, 'out_file', outputspec, 'anat_to_func_linear_xfm') analysisflow.connect(bbreg_func_to_anat, 'out_file', ds, "func2anat") analysisflow.connect(bbreg_func_to_anat, 'out_file', myqc, 'inputspec.bg_image') analysisflow.connect(wm_bb_mask, 'out_file', myqc, 'inputspec.overlay_image') return analysisflow
datagrab.inputs.field_template = dict( func=sys.argv[2], struct=sys.argv[1]) # specified by command line arguments datagrab.inputs.sort_filelist = True # sink: file - idx relationship!! pop_id = pe.Node(interface=utils_convert.List2TxtFile, name='pop_id') pop_id.inputs.rownum = 0 pop_id.inputs.out_file = "subject_IDs.txt" ds_id = pe.Node(interface=nio.DataSink(), name='ds_pop_id') ds_id.inputs.regexp_substitutions = [("(\/)[^\/]*$", "IDs.txt")] ds_id.inputs.base_directory = globals._SinkDir_ # build the actual pipeline reorient_struct = pe.MapNode(fsl.utils.Reorient2Std(), iterfield=['in_file'], name="reorient_struct") reorient_func = pe.MapNode(fsl.utils.Reorient2Std(), iterfield=['in_file'], name="reorient_func") myanatproc = anatproc.AnatProc(stdreg=_regtype_) myanatproc.inputs.inputspec.bet_fract_int_thr = 0.3 # feel free to adjust, a nice bet is important! myanatproc.inputs.inputspec.bet_vertical_gradient = -0.3 # feel free to adjust, a nice bet is important! # try scripts/opt_bet.py to optimise these parameters mybbr = bbr.bbr_workflow() # Add arbitrary number of nii images wthin the same space. The default is to add csf and wm masks for anatcompcor calculation. #myadding=adding.addimgs_workflow(numimgs=2) add_masks = pe.MapNode(fsl.ImageMaths(op_string=' -add'), iterfield=['in_file', 'in_file2'],
def func2mni(stdreg, carpet_plot="", wf_name='func2mni', SinkTag="func_preproc"): """ stdreg: either globals._RegType_.ANTS or globals._RegType_.FSL (do default value to make sure the user has to decide explicitly) Transaform 4D functional image to MNI space. carpet_plot: string specifying the tag parameter for carpet plot of the standardized MRI measurement (default is "": no carpet plot) if not "", inputs atlaslabels and confounds should be defined (it might work with defaults, though) Workflow inputs: :param func :param linear_reg_mtrx :param nonlinear_reg_mtrx :param reference_brain :param atlas (optional) :param confounds (optional) :param confound_names (optional) Workflow outputs: :return: anat2mni_workflow - workflow anat="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres.nii.gz", brain="/home/balint/Dokumentumok/phd/essen/PAINTER/probe/MS001/highres_brain.nii.gz", Balint Kincses [email protected] 2018 """ import os import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import nipype.interfaces.fsl as fsl import nipype.interfaces.ants as ants from nipype.interfaces.c3 import C3dAffineTool import PUMI.utils.globals as globals import PUMI.func_preproc.Onevol as onevol import PUMI.utils.QC as qc import nipype.interfaces.io as io from nipype.interfaces.utility import Function SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) inputspec = pe.Node( utility.IdentityInterface(fields=[ 'func', 'anat', # only obligatory if stdreg==globals._RegType_.ANTS 'linear_reg_mtrx', 'nonlinear_reg_mtrx', 'reference_brain', 'atlas', 'confounds', 'confound_names' ]), name='inputspec') inputspec.inputs.atlas = globals._FSLDIR_ + '/data/atlases/HarvardOxford/HarvardOxford-cort-maxprob-thr25-2mm.nii.gz' inputspec.inputs.reference_brain = globals._FSLDIR_ + "/data/standard/MNI152_T1_3mm_brain.nii.gz" #3mm by default # TODO: this does not work with the iterfiled definition for ref_file below: # TODO: it should be sepcified in a function argument, whether it shopuld be iterated #TODO_ready: ANTS #TODO: make resampling voxel size for func parametrizable # apply transformation martices if stdreg == globals._RegType_.FSL: applywarp = pe.MapNode(interface=fsl.ApplyWarp(interp="spline", ), iterfield=['in_file', 'field_file', 'premat'], name='applywarp') myqc = qc.vol2png("func2mni", wf_name + "_FSL", overlayiterated=False) myqc.inputs.slicer.image_width = 500 # 500 # for the 2mm template myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 2mm template else: #ANTs # source file for C3dAffineToolmust not be 4D, so we extract the one example vol myonevol = onevol.onevol_workflow() # concat premat and ants transform bbr2ants = pe.MapNode( interface=C3dAffineTool(fsl2ras=True, itk_transform=True), iterfield=['source_file', 'transform_file', 'reference_file'], # output: 'itk_transform' name="bbr2ants") #concat trfs into a list trflist = pe.MapNode(interface=Function( input_names=['trf_first', 'trf_second'], output_names=['trflist'], function=transformlist), iterfield=['trf_first', 'trf_second'], name="collect_trf") applywarp = pe.MapNode(interface=ants.ApplyTransforms( interpolation="BSpline", input_image_type=3), iterfield=['input_image', 'transforms'], name='applywarp') myqc = qc.vol2png("func2mni", wf_name + "_ANTS3", overlayiterated=False) myqc.inputs.slicer.image_width = 500 # 500 # for the 2mm template myqc.inputs.slicer.threshold_edges = 0.1 # 0.1 # for the 2mm template if carpet_plot: fmri_qc = qc.fMRI2QC("carpet_plots", tag=carpet_plot) outputspec = pe.Node(utility.IdentityInterface(fields=['func_std']), name='outputspec') # Save outputs which are important ds_nii = pe.Node(interface=io.DataSink(), name='ds_nii') ds_nii.inputs.base_directory = SinkDir ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", wf_name + ".nii.gz")] analysisflow = pe.Workflow(wf_name) analysisflow.base_dir = '.' if stdreg == globals._RegType_.FSL: analysisflow.connect(inputspec, 'func', applywarp, 'in_file') analysisflow.connect(inputspec, 'linear_reg_mtrx', applywarp, 'premat') analysisflow.connect(inputspec, 'nonlinear_reg_mtrx', applywarp, 'field_file') analysisflow.connect(inputspec, 'reference_brain', applywarp, 'ref_file') analysisflow.connect(applywarp, 'out_file', outputspec, 'func_std') analysisflow.connect(applywarp, 'out_file', myqc, 'inputspec.bg_image') analysisflow.connect(inputspec, 'reference_brain', myqc, 'inputspec.overlay_image') analysisflow.connect(applywarp, 'out_file', ds_nii, 'func2mni') else: # ANTs analysisflow.connect(inputspec, 'func', myonevol, 'inputspec.func') analysisflow.connect(myonevol, 'outputspec.func1vol', bbr2ants, 'source_file') analysisflow.connect(inputspec, 'linear_reg_mtrx', bbr2ants, 'transform_file') analysisflow.connect(inputspec, 'anat', bbr2ants, 'reference_file') analysisflow.connect(bbr2ants, 'itk_transform', trflist, 'trf_first') analysisflow.connect(inputspec, 'nonlinear_reg_mtrx', trflist, 'trf_second') analysisflow.connect(trflist, 'trflist', applywarp, 'transforms') analysisflow.connect(inputspec, 'func', applywarp, 'input_image') analysisflow.connect(inputspec, 'reference_brain', applywarp, 'reference_image') analysisflow.connect(applywarp, 'output_image', outputspec, 'func_std') analysisflow.connect(applywarp, 'output_image', myqc, 'inputspec.bg_image') analysisflow.connect(inputspec, 'reference_brain', myqc, 'inputspec.overlay_image') analysisflow.connect(applywarp, 'output_image', ds_nii, 'func2mni') if carpet_plot: if stdreg == globals._RegType_.FSL: analysisflow.connect(applywarp, 'out_file', fmri_qc, 'inputspec.func') else: # ANTs analysisflow.connect(applywarp, 'output_image', fmri_qc, 'inputspec.func') analysisflow.connect(inputspec, 'atlas', fmri_qc, 'inputspec.atlas') analysisflow.connect(inputspec, 'confounds', fmri_qc, 'inputspec.confounds') return analysisflow
def extract_timeseries(SinkTag="connectivity", wf_name="extract_timeseries", modularise=True): ######################################################################## # Extract timeseries ######################################################################## import nipype.interfaces.nilearn as learn import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.io as io from nipype.interfaces.utility import Function import PUMI.utils.globals as globals import PUMI.utils.QC as qc import os SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) # Identitiy mapping for input variables inputspec = pe.Node( utility.IdentityInterface(fields=[ 'std_func', 'atlas_file', # nii labelmap (or 4D probmaps) 'labels', # list of short names to regions 'modules' # list of modules of regions ]), name='inputspec') # re-label atlas, so that regions corresponding to the same modules follow each other if modularise: relabel_atls = pe.Node(interface=Function( input_names=['atlas_file', 'modules', 'labels'], output_names=[ 'relabelled_atlas_file', 'reordered_modules', 'reordered_labels', 'newlabels_file' ], function=relabel_atlas), name='relabel_atlas') # Save outputs which are important ds_nii = pe.Node(interface=io.DataSink(), name='ds_relabeled_atlas') ds_nii.inputs.base_directory = SinkDir ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] # Save outputs which are important ds_newlabels = pe.Node(interface=io.DataSink(), name='ds_newlabels') ds_newlabels.inputs.base_directory = SinkDir ds_newlabels.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".tsv")] extract_timesereies = pe.MapNode( interface=learn.SignalExtraction(detrend=False), iterfield=['in_file'], name='extract_timeseries') # Save outputs which are important ds_txt = pe.Node(interface=io.DataSink(), name='ds_txt') ds_txt.inputs.base_directory = SinkDir ds_txt.inputs.regexp_substitutions = [("(\/)[^\/]*$", wf_name + ".tsv")] #QC timeseries_qc = qc.regTimeseriesQC("regional_timeseries", tag=wf_name) outputspec = pe.Node(utility.IdentityInterface(fields=[ 'timeseries_file', 'relabelled_atlas_file', 'reordered_modules', 'reordered_labels' ]), name='outputspec') # Create workflow analysisflow = pe.Workflow(wf_name) analysisflow.connect(inputspec, 'std_func', extract_timesereies, 'in_file') if modularise: analysisflow.connect(inputspec, 'atlas_file', relabel_atls, 'atlas_file') analysisflow.connect(inputspec, 'modules', relabel_atls, 'modules') analysisflow.connect(inputspec, 'labels', relabel_atls, 'labels') analysisflow.connect(relabel_atls, 'relabelled_atlas_file', extract_timesereies, 'label_files') analysisflow.connect(relabel_atls, 'reordered_labels', extract_timesereies, 'class_labels') analysisflow.connect(relabel_atls, 'reordered_modules', timeseries_qc, 'inputspec.modules') analysisflow.connect(relabel_atls, 'relabelled_atlas_file', timeseries_qc, 'inputspec.atlas') analysisflow.connect(relabel_atls, 'relabelled_atlas_file', ds_nii, 'atlas_relabeled') analysisflow.connect(relabel_atls, 'newlabels_file', ds_newlabels, 'atlas_relabeled') analysisflow.connect(relabel_atls, 'relabelled_atlas_file', outputspec, 'relabelled_atlas_file') analysisflow.connect(relabel_atls, 'reordered_labels', outputspec, 'reordered_labels') analysisflow.connect(relabel_atls, 'reordered_modules', outputspec, 'reordered_modules') else: analysisflow.connect(inputspec, 'atlas_file', extract_timesereies, 'label_files') analysisflow.connect(inputspec, 'labels', extract_timesereies, 'class_labels') analysisflow.connect(inputspec, 'modules', timeseries_qc, 'inputspec.modules') analysisflow.connect(inputspec, 'atlas_file', timeseries_qc, 'inputspec.atlas') analysisflow.connect(inputspec, 'atlas_file', outputspec, 'relabelled_atlas_file') analysisflow.connect(inputspec, 'labels', outputspec, 'reordered_labels') analysisflow.connect(inputspec, 'modules', outputspec, 'reordered_modules') analysisflow.connect(extract_timesereies, 'out_file', ds_txt, 'regional_timeseries') analysisflow.connect(extract_timesereies, 'out_file', timeseries_qc, 'inputspec.timeseries') analysisflow.connect(extract_timesereies, 'out_file', outputspec, 'timeseries_file') return analysisflow
def create_retroicor_workflow(name = 'retroicor', order_or_timing = 'order'): """ Creates RETROICOR regressors Example ------- Inputs:: inputnode.in_file - The .log file acquired together with EPI sequence Outputs:: outputnode.regressor_files """ # Define nodes: input_node = pe.Node(niu.IdentityInterface(fields=['in_files', 'phys_files', 'nr_dummies', 'MB_factor', 'tr', 'slice_direction', 'phys_sample_rate', 'slice_timing', 'slice_order', 'hr_rvt', ]), name='inputspec') # the slice time preprocessing node before we go into popp (PreparePNM) slice_times_from_gradients = pe.MapNode(niu.Function(input_names=['in_file', 'phys_file', 'nr_dummies', 'MB_factor', 'sample_rate'], output_names=['out_file', 'fig_file'], function=_distill_slice_times_from_gradients), name='slice_times_from_gradients', iterfield = ['in_file','phys_file']) slice_times_to_txt_file = pe.Node(niu.Function(input_names=['slice_times'], output_names=['out_file'], function=_slice_times_to_txt_file), name='slice_times_to_txt_file') pnm_prefixer = pe.MapNode(niu.Function(input_names=['filename'], output_names=['out_string'], function=_preprocess_nii_files_to_pnm_evs_prefix), name='pnm_prefixer', iterfield = ['filename']) prepare_pnm = pe.MapNode(PreparePNM(), name='prepare_pnm', iterfield = ['in_file']) pnm_evs = pe.MapNode(PNMtoEVs(), name='pnm_evs', iterfield = ['functional_epi', 'cardiac', 'resp', 'hr', 'rvt', 'prefix']) # Define output node output_node = pe.Node(niu.IdentityInterface(fields=['new_phys', 'fig_file', 'evs']), name='outputspec') ######################################################################################## # workflow ######################################################################################## retroicor_workflow = pe.Workflow(name=name) # align phys-log data to nifti retroicor_workflow.connect(input_node, 'in_files', slice_times_from_gradients, 'in_file') retroicor_workflow.connect(input_node, 'phys_files', slice_times_from_gradients, 'phys_file') retroicor_workflow.connect(input_node, 'nr_dummies', slice_times_from_gradients, 'nr_dummies') retroicor_workflow.connect(input_node, 'MB_factor', slice_times_from_gradients, 'MB_factor') retroicor_workflow.connect(input_node, 'phys_sample_rate', slice_times_from_gradients, 'sample_rate') # conditional here, for the creation of a separate slice timing file if order_or_timing is 'timing' # order_or_timing can also be 'order' if order_or_timing == 'timing': retroicor_workflow.connect(input_node, 'slice_timing', slice_times_to_txt_file, 'slice_times') # prepare pnm: retroicor_workflow.connect(input_node, 'phys_sample_rate', prepare_pnm, 'sampling_rate') retroicor_workflow.connect(input_node, 'tr', prepare_pnm, 'tr') retroicor_workflow.connect(slice_times_from_gradients, 'out_file', prepare_pnm, 'in_file') retroicor_workflow.connect(input_node, 'hr_rvt', prepare_pnm, 'hr_rvt') # pnm evs: retroicor_workflow.connect(input_node, 'in_files', pnm_prefixer, 'filename') retroicor_workflow.connect(pnm_prefixer, 'out_string', pnm_evs, 'prefix') retroicor_workflow.connect(input_node, 'in_files', pnm_evs, 'functional_epi') retroicor_workflow.connect(input_node, 'slice_direction', pnm_evs, 'slice_dir') retroicor_workflow.connect(input_node, 'tr', pnm_evs, 'tr') if order_or_timing == 'timing': retroicor_workflow.connect(slice_times_to_txt_file, 'out_file', pnm_evs, 'slice_timing') elif order_or_timing == 'order': retroicor_workflow.connect(input_node, 'slice_order', pnm_evs, 'slice_order') retroicor_workflow.connect(prepare_pnm, 'card', pnm_evs, 'cardiac') retroicor_workflow.connect(prepare_pnm, 'resp', pnm_evs, 'resp') retroicor_workflow.connect(prepare_pnm, 'hr', pnm_evs, 'hr') retroicor_workflow.connect(prepare_pnm, 'rvt', pnm_evs, 'rvt') retroicor_workflow.connect(slice_times_from_gradients, 'out_file', output_node, 'new_phys') retroicor_workflow.connect(slice_times_from_gradients, 'fig_file', output_node, 'fig_file') retroicor_workflow.connect(pnm_evs, 'evs', output_node, 'evs') return retroicor_workflow
def create_VWM_anti_pp_workflow(analysis_info, name='VWM-anti'): """Summary Parameters ---------- analysis_info : TYPE Description name : str, optional Description Returns ------- TYPE Description """ import os.path as op import nipype.pipeline as pe import tempfile import glob from nipype.interfaces import fsl from nipype.interfaces.utility import Function, Merge, IdentityInterface from nipype.interfaces.io import SelectFiles, DataSink from nipype.interfaces.ants import ApplyTransforms from bids.grabbids import BIDSLayout # Importing of custom nodes from spynoza packages; assumes that spynoza is installed: # pip install git+https://github.com/spinoza-centre/spynoza.git@develop from spynoza.filtering.nodes import Savgol_filter, Savgol_filter_confounds from spynoza.conversion.nodes import psc from spynoza.utils import get_scaninfo, pickfirst from utils import mask_nii_2_hdf5, nistats_confound_glm, mask_to_tsv input_node = pe.Node(IdentityInterface( fields=['bids_directory', 'fmriprep_directory', 'output_directory', 'mask_directory', 'sub_id']), name='inputspec') BIDSNiiGrabber = pe.Node(Function(function=get_niftis, input_names=["subject_id", "data_dir", "task", "space"], output_names=["nii_files"]), name="BIDSNiiGrabber") BIDSNiiGrabber.inputs.space = 'mni' BIDSEventsGrabber = pe.Node(Function(function=get_events, input_names=["subject_id", "data_dir", "task"], output_names=["event_files"]), name="BIDSEventsGrabber") BIDSConfoundsGrabber = pe.Node(Function(function=get_confounds, input_names=["subject_id", "data_dir", "task"], output_names=["confounds_tsv_files"]), name="BIDSConfoundsGrabber") MaskGrabber = pe.Node(Function(function=get_masks, input_names=["mask_directory"], output_names=["mask_files"]), name="MaskGrabber") HDF5PSCMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_psc_masker') HDF5PSCMasker.inputs.folder_alias = 'psc' HDF5PSCMasker.inputs.hdf5_file = op.join(tempfile.mkdtemp(), 'roi.h5') HDF5PSCNuisMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_psc_nuis_masker') HDF5PSCNuisMasker.inputs.folder_alias = 'psc_nuis' # HDF5StatsMasker = pe.Node(Function(input_names = ['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names = ['hdf5_file'], # function = mask_nii_2_hdf5), # name = 'hdf5_stats_masker') # HDF5StatsMasker.inputs.folder_alias = 'stats' HDF5ROIMasker = pe.Node(Function(input_names=['in_files', 'mask_files', 'hdf5_file', 'folder_alias'], output_names=['hdf5_file'], function=mask_nii_2_hdf5), name='hdf5_roi_masker') HDF5ROIMasker.inputs.folder_alias = 'rois' ConfoundGLM = pe.MapNode(Function(input_names=['nifti_file', 'confounds_file', 'which_confounds'], output_names=['output_pdf', 'output_nifti'], function=nistats_confound_glm), name='nistats_confound_glm', iterfield=["nifti_file", "confounds_file"]) ConfoundGLM.inputs.which_confounds = analysis_info['nuisance_columns'] # VolTransNode = pe.MapNode(interface=fsl.preprocess.ApplyXFM(apply_xfm=False, apply_isoxfm=True, interp='sinc'), # name='vol_trans', iterfield = ['in_file']) # VolTransNode = pe.MapNode(interface=ApplyTransforms(transforms='identity', interpolation='LanczosWindowedSinc'), # name='vol_trans', iterfield = ['input_image']) ThreshNode = pe.MapNode(fsl.Threshold(thresh=analysis_info['MNI_mask_threshold'], args='-bin', output_datatype='int'), name='thresh', iterfield=['in_file']) TSVMasker = pe.MapNode(Function(input_names=['in_file', 'mask_files'], output_names=['out_file'], function=mask_to_tsv), iterfield=['in_file'], name='tsv_masker') ROIResampler = pe.Node(Function(input_names=['mni_roi_files', 'mni_epi_space_file'], output_names=['output_roi_files'], function=resample_rois), name='roi_resampler') sgfilter = pe.MapNode(interface=Savgol_filter, name='sgfilter', iterfield=['in_file']) sgfilter_confounds = pe.MapNode(interface=Savgol_filter_confounds, name='sgfilter_confounds', iterfield=['confounds']) # Both fmri data and nuisances are filtered with identical parameters sgfilter.inputs.polyorder = sgfilter_confounds.inputs.polyorder = analysis_info[ 'sgfilter_polyorder'] sgfilter.inputs.deriv = sgfilter_confounds.inputs.deriv = analysis_info['sgfilter_deriv'] sgfilter.inputs.window_length = sgfilter_confounds.inputs.window_length = analysis_info[ 'sgfilter_window_length'] sgfilter.inputs.tr = sgfilter_confounds.inputs.tr = analysis_info['RepetitionTime'] # set the psc function psc.inputs.func = analysis_info['psc_function'] datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False ######################################################################################## # workflow ######################################################################################## # the actual top-level workflow VWM_anti_pp_workflow = pe.Workflow(name=name) # data source VWM_anti_pp_workflow.connect( input_node, 'bids_directory', BIDSEventsGrabber, 'data_dir') VWM_anti_pp_workflow.connect(input_node, 'sub_id', BIDSEventsGrabber, 'subject_id') VWM_anti_pp_workflow.connect( input_node, 'fmriprep_directory', BIDSNiiGrabber, 'data_dir') VWM_anti_pp_workflow.connect(input_node, 'sub_id', BIDSNiiGrabber, 'subject_id') VWM_anti_pp_workflow.connect( input_node, 'fmriprep_directory', BIDSConfoundsGrabber, 'data_dir') VWM_anti_pp_workflow.connect(input_node, 'sub_id', BIDSConfoundsGrabber, 'subject_id') VWM_anti_pp_workflow.connect( input_node, 'mask_directory', MaskGrabber, 'mask_directory') # filter and psc VWM_anti_pp_workflow.connect(BIDSNiiGrabber, 'nii_files', sgfilter, 'in_file') VWM_anti_pp_workflow.connect(sgfilter, 'out_file', psc, 'in_file') # do the same filtering on confounds VWM_anti_pp_workflow.connect(BIDSConfoundsGrabber, 'confounds_tsv_files', sgfilter_confounds, 'confounds') # cleanup GLM VWM_anti_pp_workflow.connect(psc, 'out_file', ConfoundGLM, 'nifti_file') VWM_anti_pp_workflow.connect( sgfilter_confounds, 'out_file', ConfoundGLM, 'confounds_file') # preparing masks, ANTS and fsl not working correctly # ANTs # pearl_pp_workflow.connect(BIDSNiiGrabber, ('nii_files', pickfirst), VolTransNode, 'reference_image') # pearl_pp_workflow.connect(MaskGrabber, 'mask_files', VolTransNode, 'input_image') # fsl # pearl_pp_workflow.connect(BIDSNiiGrabber, ('nii_files', pickfirst), VolTransNode, 'reference') # pearl_pp_workflow.connect(MaskGrabber, 'mask_files', VolTransNode, 'in_file') # pearl_pp_workflow.connect(VolTransNode, 'output_image', ThreshNode, 'in_file') VWM_anti_pp_workflow.connect( BIDSNiiGrabber, ('nii_files', pickfirst), ROIResampler, 'mni_epi_space_file') VWM_anti_pp_workflow.connect( MaskGrabber, 'mask_files', ROIResampler, 'mni_roi_files') VWM_anti_pp_workflow.connect( ROIResampler, 'output_roi_files', ThreshNode, 'in_file') # masking data VWM_anti_pp_workflow.connect(psc, 'out_file', HDF5PSCMasker, 'in_files') VWM_anti_pp_workflow.connect(ThreshNode, 'out_file', HDF5PSCMasker, 'mask_files') VWM_anti_pp_workflow.connect( ConfoundGLM, 'output_nifti', HDF5PSCNuisMasker, 'in_files') VWM_anti_pp_workflow.connect(ThreshNode, 'out_file', HDF5PSCNuisMasker, 'mask_files') VWM_anti_pp_workflow.connect( HDF5PSCMasker, 'hdf5_file', HDF5PSCNuisMasker, 'hdf5_file') # needs stats before we do a masker.... # pearl_pp_workflow.connect(VolTransNode, 'out_file', HDF5StatsMasker, 'in_files') # pearl_pp_workflow.connect(ThreshNode, 'out_file', HDF5StatsMasker, 'mask_files') # pearl_pp_workflow.connect(HDF5PSCNuisMasker, 'hdf5_file', HDF5StatsMasker, 'hdf5_file') VWM_anti_pp_workflow.connect( ROIResampler, 'output_roi_files', HDF5ROIMasker, 'in_files') VWM_anti_pp_workflow.connect(ThreshNode, 'out_file', HDF5ROIMasker, 'mask_files') VWM_anti_pp_workflow.connect( HDF5PSCNuisMasker, 'hdf5_file', HDF5ROIMasker, 'hdf5_file') # mask to .tsv, for one timecourse per roi VWM_anti_pp_workflow.connect( ROIResampler, 'output_roi_files', TSVMasker, 'mask_files') VWM_anti_pp_workflow.connect( ConfoundGLM, 'output_nifti', TSVMasker, 'in_file') # set up output folder VWM_anti_pp_workflow.connect( input_node, 'output_directory', datasink, 'base_directory') # connect all outputs to datasink VWM_anti_pp_workflow.connect( ConfoundGLM, 'output_nifti', datasink, 'confound_glm') VWM_anti_pp_workflow.connect( BIDSEventsGrabber, 'event_files', datasink, 'events') VWM_anti_pp_workflow.connect(sgfilter, 'out_file', datasink, 'sg_filter') VWM_anti_pp_workflow.connect( sgfilter_confounds, 'out_file', datasink, 'sg_filter_confound') VWM_anti_pp_workflow.connect(psc, 'out_file', datasink, 'psc') VWM_anti_pp_workflow.connect( ROIResampler, 'output_roi_files', datasink, 'masks_f') VWM_anti_pp_workflow.connect(ThreshNode, 'out_file', datasink, 'masks_b') VWM_anti_pp_workflow.connect(TSVMasker, 'out_file', datasink, 'tsv') VWM_anti_pp_workflow.connect(HDF5PSCNuisMasker, 'hdf5_file', datasink, 'h5') VWM_anti_pp_workflow.connect( ConfoundGLM, 'output_pdf', datasink, 'confound_glm_report') return VWM_anti_pp_workflow
data_filt = data - data_filt + data_filt.mean(axis=-1)[:, np.newaxis] data_filt = data_filt.reshape(dims) img = nib.Nifti1Image(data_filt, affine=affine, header=header) new_name = os.path.basename(in_file).split('.')[:-2][0] + '_sg.nii.gz' out_file = os.path.abspath(new_name) nib.save(img, out_file) return out_file Savgol_filter = Function( function=savgol_filter, input_names=['in_file', 'polyorder', 'deriv', 'window_length', 'tr'], output_names=['out_file']) sgfilter = pe.MapNode(interface=Savgol_filter, name='sgfilter', iterfield=['in_file']) def savgol_filter_confounds(confounds, tr, polyorder=3, deriv=0, window_length=120): import pandas as pd from scipy.signal import savgol_filter import numpy as np import os confounds_table = pd.read_table(confounds)
def fast_workflow(SinkTag="anat_preproc", wf_name="tissue_segmentation"): """ Borrowed from the PUMI project: https://github.com/spisakt/PUMI Balint Kincses [email protected] 2019 Modified version of CPAC.seg_preproc.seg_preproc `source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/seg_preproc/seg_preproc.html` Do the segmentation of a brain extracted T1w image. Workflow inputs: :param brain: The brain extracted image, the output of the better_workflow. :param init_transform: The standard to anat linear transformation matrix (which is calculated in the Anat2MNI.py script). Beware of the resolution of the reference (standard) image, the default value is 2mm. :param priorprob: A list of tissue probability maps in the prior (=reference=standard) space. By default it must be 3 element(in T1w images the CSF, GM, WM order is valid) :param SinkDir: :param SinkTag: The output directory in which the returned images (see workflow outputs) could be found. Workflow outputs: :return: fast_workflow - workflow Balint Kincses [email protected] 2018 """ #This is a Nipype generator. Warning, here be dragons. #!/usr/bin/env python import sys import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import nipype.interfaces.io as io #import PUMI.utils.QC as qc #import PUMI.utils.globals as globals SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) #Basic interface class generates identity mappings inputspec = pe.Node(utility.IdentityInterface( fields=['brain', 'stand2anat_xfm', 'priorprob']), name='inputspec') # inputspec.inputs.stand2anat_xfm='/home/analyser/Documents/PAINTER/probewith2subj/preprocess_solvetodos/anat2mni_fsl/inv_linear_reg0_xfm/mapflow/_inv_linear_reg0_xfm0/anat_brain_flirt_inv.mat' #TODO_ready set standard mask to 2mm inputspec.inputs.priorprob = [ globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_csf.hdr', globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_gray.hdr', globals._FSLDIR_ + '/data/standard/tissuepriors/avg152T1_white.hdr' ] # TODO_ready: use prior probabilioty maps # Wraps command **fast** fast = pe.MapNode(interface=fsl.FAST(), iterfield=['in_files', 'init_transform'], name='fast') fast.inputs.img_type = 1 fast.inputs.segments = True fast.inputs.probability_maps = True fast.inputs.out_basename = 'fast_' #myqc = qc.vol2png("tissue_segmentation", overlay=False) #myqc.inputs.slicer.colour_map = globals._FSLDIR_ + '/etc/luts/renderjet.lut' # Basic interface class generates identity mappings outputspec = pe.Node(utility.IdentityInterface(fields=[ 'probmap_csf', 'probmap_gm', 'probmap_wm', 'mixeltype', 'parvol_csf', 'parvol_gm', 'parvol_wm', 'partial_volume_map' ]), name='outputspec') # Save outputs which are important ds = pe.Node(interface=io.DataSink(), name='ds') ds.inputs.base_directory = SinkDir ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] def pickindex(vec, i): #print "************************************************************************************************************************************************" #print vec #print i return [x[i] for x in vec] #Create a workflow to connect all those nodes analysisflow = nipype.Workflow(wf_name) analysisflow.base_dir = '.' analysisflow.connect(inputspec, 'brain', fast, 'in_files') analysisflow.connect(inputspec, 'stand2anat_xfm', fast, 'init_transform') analysisflow.connect(inputspec, 'priorprob', fast, 'other_priors') # analysisflow.connect(inputspec, 'stand_csf' ,fast,('other_priors', pickindex, 0)) # analysisflow.connect(inputspec, 'stand_gm' ,fast,('other_priors', pickindex, 1)) # analysisflow.connect(inputspec, 'stand_wm' ,fast,('other_priors', pickindex, 2)) #nalysisflow.connect(fast, 'probability_maps', outputspec, 'probability_maps') analysisflow.connect(fast, ('probability_maps', pickindex, 0), outputspec, 'probmap_csf') analysisflow.connect(fast, ('probability_maps', pickindex, 1), outputspec, 'probmap_gm') analysisflow.connect(fast, ('probability_maps', pickindex, 2), outputspec, 'probmap_wm') analysisflow.connect(fast, 'mixeltype', outputspec, 'mixeltype') #analysisflow.connect(fast, 'partial_volume_files', outputspec, 'partial_volume_files') analysisflow.connect(fast, ('partial_volume_files', pickindex, 0), outputspec, 'parvol_csf') analysisflow.connect(fast, ('partial_volume_files', pickindex, 0), outputspec, 'parvol_gm') analysisflow.connect(fast, ('partial_volume_files', pickindex, 0), outputspec, 'parvol_wm') analysisflow.connect(fast, 'partial_volume_map', outputspec, 'partial_volume_map') analysisflow.connect(fast, ('probability_maps', pickindex, 0), ds, 'fast_csf') analysisflow.connect(fast, ('probability_maps', pickindex, 1), ds, 'fast_gm') analysisflow.connect(fast, ('probability_maps', pickindex, 2), ds, 'fast_wm') #analysisflow.connect(fast, 'partial_volume_map', myqc, 'inputspec.bg_image') return analysisflow
#Generic datagrabber module that wraps around glob in an NodeHash_1e88370 = pe.Node(io.S3DataGrabber(infields=['sub_id', 'run_id'], outfields=['func']), name='NodeName_1e88370') NodeHash_1e88370.inputs.bucket = 'openneuro' NodeHash_1e88370.inputs.sort_filelist = True NodeHash_1e88370.inputs.template = '%s/func/%s_task-simon_%s_bold.nii.gz' NodeHash_1e88370.inputs.anon = True NodeHash_1e88370.inputs.bucket_path = 'ds000101/ds000101_R2.0.0/uncompressed/' NodeHash_1e88370.inputs.local_directory = '/tmp' NodeHash_1e88370.inputs.template_args = dict( func=[['sub_id', 'sub_id', 'run_id']]) #Wraps command **3dvolreg** NodeHash_19153b0 = pe.MapNode(interface=afni.Volreg(), name='NodeName_19153b0', iterfield=['in_file']) NodeHash_19153b0.inputs.outputtype = 'NIFTI_GZ' #Generic datasink module to store structured outputs NodeHash_2b96290 = pe.Node(interface=io.DataSink(), name='NodeName_2b96290') NodeHash_2b96290.inputs.base_directory = '/tmp' #Create a workflow to connect all those nodes analysisflow = nipype.Workflow('MyWorkflow') analysisflow.connect(NodeHash_24ff4a0, 'sub_id', NodeHash_2b96290, 'container') analysisflow.connect(NodeHash_24ff4a0, 'run_id', NodeHash_1e88370, 'run_id') analysisflow.connect(NodeHash_24ff4a0, 'sub_id', NodeHash_1e88370, 'sub_id') analysisflow.connect(NodeHash_1e88370, 'func', NodeHash_19153b0, 'in_file') analysisflow.connect(NodeHash_19153b0, 'oned_file', NodeHash_2b96290, 'moco.moco_params')
import nipype.interfaces.fsl as fsl import PUMI.func_preproc.FieldMapper as fm datagrab = pe.Node(nio.DataGrabber( outfields=['func', 'phase', 'magnitude', 'TE1', 'TE2', 'dwelltime']), name='data_grabber') datagrab.inputs.base_directory = os.getcwd() # do we need this? datagrab.inputs.template = "*/*" # do we need this? datagrab.inputs.field_template = dict(func=sys.argv[1], phase=sys.argv[2], magnitude=sys.argv[3]) datagrab.inputs.sort_filelist = True reorient_func = pe.MapNode(fsl.utils.Reorient2Std(), iterfield=['in_file'], name="reorient_func") myfm = fm.fieldmapper(TE1=4.9, TE2=7.3, dwell_time=0.00035, unwarp_direction="y-") totalWorkflow = nipype.Workflow('fm_probe') totalWorkflow.base_dir = '.' totalWorkflow.connect([ (datagrab, reorient_func, [('func', 'in_file')]), (reorient_func, myfm, [('out_file', 'inputspec.in_file')]), (datagrab, myfm, [('phase', 'inputspec.phase')]), (datagrab, myfm, [('magnitude', 'inputspec.magnitude')]),
def create_confound_workflow(name='confound'): input_node = pe.Node(interface=IdentityInterface(fields=[ 'in_file', 'par_file', 'fast_files', 'highres2epi_mat', 'n_comp_tcompcor', 'n_comp_acompcor', 'output_directory', 'sub_id' ]), name='inputspec') output_node = pe.Node(interface=IdentityInterface(fields=[ 'all_confounds', ]), name='outputspec') datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False compute_DVARS = pe.MapNode(ComputeDVARS(save_all=True, remove_zerovariance=True), iterfield=['in_file', 'in_mask'], name='compute_DVARS') motion_wf = create_motion_confound_workflow(order=2) confound_wf = pe.Workflow(name=name) confound_wf.connect(input_node, 'par_file', motion_wf, 'inputspec.par_file') confound_wf.connect(input_node, 'sub_id', motion_wf, 'inputspec.sub_id') confound_wf.connect(input_node, 'output_directory', motion_wf, 'inputspec.output_directory') compcor_wf = create_compcor_workflow() confound_wf.connect(input_node, 'in_file', compcor_wf, 'inputspec.in_file') confound_wf.connect(input_node, 'fast_files', compcor_wf, 'inputspec.fast_files') confound_wf.connect(input_node, 'highres2epi_mat', compcor_wf, 'inputspec.highres2epi_mat') confound_wf.connect(input_node, 'n_comp_tcompcor', compcor_wf, 'inputspec.n_comp_tcompcor') confound_wf.connect(input_node, 'n_comp_acompcor', compcor_wf, 'inputspec.n_comp_acompcor') confound_wf.connect(input_node, 'sub_id', compcor_wf, 'inputspec.sub_id') confound_wf.connect(input_node, 'output_directory', compcor_wf, 'inputspec.output_directory') confound_wf.connect(compcor_wf, 'outputspec.epi_mask', compute_DVARS, 'in_mask') confound_wf.connect(input_node, 'in_file', compute_DVARS, 'in_file') concat = pe.MapNode(Concat_confound_files, iterfield=['ext_par_file', 'fd_file', 'dvars_file'], name='concat') confound_wf.connect(motion_wf, 'outputspec.out_ext_moco', concat, 'ext_par_file') confound_wf.connect(motion_wf, 'outputspec.out_fd', concat, 'fd_file') confound_wf.connect(compcor_wf, 'outputspec.acompcor_file', concat, 'acompcor_file') #confound_wf.connect(compcor_wf, 'outputspec.tcompcor_file', concat, # 'tcompcor_file') confound_wf.connect(compute_DVARS, 'out_all', concat, 'dvars_file') confound_wf.connect(input_node, 'sub_id', datasink, 'sub_id') confound_wf.connect(input_node, 'output_directory', datasink, 'base_directory') confound_wf.connect(concat, 'out_file', datasink, 'confounds') return confound_wf
def extract_timeseries_nativespace(SinkTag="connectivity", wf_name="extract_timeseries_nativespace", global_signal=True): # this workflow transforms atlas back to native space and uses TsExtractor import os import nipype import nipype.pipeline as pe import nipype.interfaces.io as io import nipype.interfaces.utility as utility import PUMI.func_preproc.func2standard as transform import PUMI.utils.globals as globals import PUMI.utils.QC as qc SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) wf = nipype.Workflow(wf_name) inputspec = pe.Node( utility.IdentityInterface(fields=[ 'atlas', 'labels', 'modules', 'anat', # only obligatory if stdreg==globals._RegType_.ANTS 'inv_linear_reg_mtrx', 'inv_nonlinear_reg_mtrx', 'func', 'gm_mask', 'confounds', 'confound_names' ]), name="inputspec") # transform atlas back to native EPI spaces! atlas2native = transform.atlas2func(stdreg=globals._regType_) wf.connect(inputspec, 'atlas', atlas2native, 'inputspec.atlas') wf.connect(inputspec, 'anat', atlas2native, 'inputspec.anat') wf.connect(inputspec, 'inv_linear_reg_mtrx', atlas2native, 'inputspec.inv_linear_reg_mtrx') wf.connect(inputspec, 'inv_nonlinear_reg_mtrx', atlas2native, 'inputspec.inv_nonlinear_reg_mtrx') wf.connect(inputspec, 'func', atlas2native, 'inputspec.func') wf.connect(inputspec, 'gm_mask', atlas2native, 'inputspec.example_func') wf.connect(inputspec, 'confounds', atlas2native, 'inputspec.confounds') wf.connect(inputspec, 'confound_names', atlas2native, 'inputspec.confound_names') # extract timeseries extract_timeseries = pe.MapNode(interface=utility.Function( input_names=['labels', 'labelmap', 'func', 'mask', 'global_signal'], output_names=['out_file', 'labels', 'out_gm_label'], function=TsExtractor), iterfield=['labelmap', 'func', 'mask'], name='extract_timeseries') extract_timeseries.inputs.global_signal = global_signal wf.connect(atlas2native, 'outputspec.atlas2func', extract_timeseries, 'labelmap') wf.connect(inputspec, 'labels', extract_timeseries, 'labels') wf.connect(inputspec, 'gm_mask', extract_timeseries, 'mask') wf.connect(inputspec, 'func', extract_timeseries, 'func') # Save outputs which are important ds_regts = pe.Node(interface=io.DataSink(), name='ds_regts') ds_regts.inputs.base_directory = globals._SinkDir_ ds_regts.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".tsv")] wf.connect(extract_timeseries, 'out_file', ds_regts, 'regional_timeseries') # QC timeseries_qc = qc.regTimeseriesQC("regional_timeseries", tag=wf_name) wf.connect(inputspec, 'modules', timeseries_qc, 'inputspec.modules') wf.connect(inputspec, 'atlas', timeseries_qc, 'inputspec.atlas') wf.connect(extract_timeseries, 'out_file', timeseries_qc, 'inputspec.timeseries') # Basic interface class generates identity mappings outputspec = pe.Node( utility.IdentityInterface(fields=['timeseries', 'out_gm_label']), name='outputspec') wf.connect(extract_timeseries, 'out_file', outputspec, 'timeseries') wf.connect(extract_timeseries, 'out_gm_label', outputspec, 'out_gm_label') return wf
import nipype.interfaces.utility as utility import PUMI.func_preproc.info.info_get as info_get import PUMI.utils.utils_convert as utils_convert import nipype.interfaces.afni as afni import nipype.interfaces.io as io OutJSON = SinkDir + "/outputs.JSON" WorkingDirectory = "." #Basic interface class generates identity mappings NodeHash_6040006ae640 = pe.Node(utility.IdentityInterface(fields=['func','slicetiming_txt']), name = 'NodeName_6040006ae640') NodeHash_6040006ae640.inputs.func = func NodeHash_6040006ae640.inputs.slicetiming_txt = slicetiming_txt #Custom interface wrapping function TR NodeHash_6000004b9860 = pe.MapNode(interface = info_get.TR, name = 'NodeName_6000004b9860', iterfield = ['in_file']) #Custom interface wrapping function Str2Float NodeHash_6040006ae9a0 = pe.MapNode(interface = utils_convert.Str2Float, name = 'NodeName_6040006ae9a0', iterfield = ['str']) #Custom interface wrapping function Float2Str NodeHash_6040004aee80 = pe.MapNode(interface = utils_convert.Float2Str, name = 'NodeName_6040004aee80', iterfield = ['float']) #Wraps command **3dTshift** NodeHash_6040004ad140 = pe.MapNode(interface = afni.TShift(), name = 'NodeName_6040004ad140', iterfield = ['in_file', 'tr']) NodeHash_6040004ad140.inputs.rltplus = True NodeHash_6040004ad140.inputs.outputtype = "NIFTI_GZ" NodeHash_6040004ad140.inputs.terminal_output = 'allatonce' #Generic datasink module to store structured outputs NodeHash_6080008b3d40 = pe.Node(interface = io.DataSink(), name = 'NodeName_6080008b3d40')
import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.io as io import nipype.interfaces.fsl as fsl import firstlevelhelpers import nipype.algorithms.modelgen as modelgen WorkingDirectory = "~/Porcupipelines/ThisStudy" #Basic interface class generates identity mappings NodeHash_2c4dda0 = pe.Node(utility.IdentityInterface(fields=['sub_id']), name = 'NodeName_2c4dda0') NodeHash_2c4dda0.inputs.sub_id = ['sub-02', 'sub-03', 'sub-04', 'sub-05', 'sub-06', 'sub-07', 'sub-08', 'sub-09', 'sub-10', 'sub-11', 'sub-12', 'sub-13', 'sub-14', 'sub-15', 'sub-16', 'sub-17', 'sub-18', 'sub-19', 'sub-20', 'sub-21'] #Generic datagrabber module that wraps around glob in an NodeHash_17173a00 = pe.MapNode(io.S3DataGrabber(infields=['field_template','sub_id'], outfields=['func','events','anat']), name = 'NodeName_17173a00', iterfield = ['sub_id']) NodeHash_17173a00.inputs.anon = True NodeHash_17173a00.inputs.bucket = 'openneuro' NodeHash_17173a00.inputs.bucket_path = 'ds000101/ds000101_R2.0.0/uncompressed/' NodeHash_17173a00.inputs.local_directory = '/tmp' NodeHash_17173a00.inputs.sort_filelist = True NodeHash_17173a00.inputs.template = '*' NodeHash_17173a00.inputs.template_args = dict(func=[['sub_id', 'sub_id']], events=[['sub_id', 'sub_id']], anat=[['sub_id', 'sub_id']]) NodeHash_17173a00.inputs.field_template = dict(func='%s/func/%s_task-simon_run-1_bold.nii.gz', events='%s/func/%s_task-simon_run-1_events.tsv', anat='%s/anat/%s_T1w.nii.gz') #Wraps command **bet** NodeHash_20af2180 = pe.MapNode(interface = fsl.BET(), name = 'NodeName_20af2180', iterfield = ['in_file']) NodeHash_20af2180.inputs.frac = 0.3 NodeHash_20af2180.inputs.robust = True #Wraps command **fast**
def compcor_workflow(SinkTag="func_preproc", wf_name="compcor"): """ `source: -` Component based noise reduction method (Behzadi et al.,2007): Regressing out principal components from noise ROIs. Here the aCompCor is used. Workflow inputs: :param func_aligned: The reoriented and realigned functional image. :param mask_files: Mask files which determine ROI(s). The default mask is the :param components_file :param num_componenets: :param pre_filter: Detrend time series prior to component extraction. :param TR :param SinkDir: :param SinkTag: The output directory in which the returned images (see workflow outputs) could be found in a subdirectory directory specific for this workflow. Workflow outputs: :return: slt_workflow - workflow Balint Kincses [email protected] 2018 """ import os import nipype import nipype.pipeline as pe import nipype.algorithms.confounds as cnf import PUMI.func_preproc.info.info_get as info_get import PUMI.utils.utils_convert as utils_convert import nipype.interfaces.io as io import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import PUMI.utils.QC as qc import PUMI.utils.globals as globals SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) # Basic interface class generates identity mappings inputspec = pe.Node( utility.IdentityInterface(fields=['func_aligned', 'mask_file']), name='inputspec') myqc = qc.vol2png("compcor_noiseroi") # Save outputs which are important ds_nii = pe.Node(interface=io.DataSink(), name='ds_nii') ds_nii.inputs.base_directory = SinkDir ds_nii.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] # standardize timeseries prior to compcor. added by tspisak scale = pe.MapNode(interface=utility.Function(input_names=['in_file'], output_names=['scaled_file'], function=scale_vol), iterfield=['in_file'], name='scale_func') # Calculate compcor files compcor = pe.MapNode( interface=cnf.ACompCor(pre_filter='polynomial', header_prefix="", num_components=5), iterfield=['realigned_file', 'repetition_time', 'mask_files'], name='compcor') # Custom interface wrapping function Float2Str func_str2float = pe.MapNode(interface=utils_convert.Str2Float, iterfield=['str'], name='func_str2float') # Drop first line of the Acompcor function output drop_firstline = pe.MapNode(interface=utils_convert.DropFirstLine, iterfield=['txt'], name='drop_firstline') # Custom interface wrapping function TR TRvalue = pe.MapNode(interface=info_get.TR, iterfield=['in_file'], name='TRvalue') # Basic interface class generates identity mappings outputspec = pe.Node(utility.IdentityInterface(fields=['components_file']), name='outputspec') # save data out with Datasink ds_text = pe.Node(interface=io.DataSink(), name='ds_txt') ds_text.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".txt")] ds_text.inputs.base_directory = SinkDir # Create a workflow to connect all those nodes analysisflow = nipype.Workflow(wf_name) analysisflow.connect(inputspec, 'func_aligned', scale, 'in_file') analysisflow.connect(scale, 'scaled_file', compcor, 'realigned_file') analysisflow.connect(inputspec, 'func_aligned', TRvalue, 'in_file') analysisflow.connect(TRvalue, 'TR', func_str2float, 'str') analysisflow.connect(func_str2float, 'float', compcor, 'repetition_time') #analysisflow.connect(TRvalue, 'TR', compcor, 'repetition_time') analysisflow.connect(inputspec, 'mask_file', compcor, 'mask_files') analysisflow.connect(compcor, 'components_file', drop_firstline, 'txt') analysisflow.connect(drop_firstline, 'droppedtxtfloat', outputspec, 'components_file') analysisflow.connect(compcor, 'components_file', ds_text, 'compcor_noise') analysisflow.connect(inputspec, 'func_aligned', myqc, 'inputspec.bg_image') analysisflow.connect(inputspec, 'mask_file', myqc, 'inputspec.overlay_image') analysisflow.connect(inputspec, 'mask_file', ds_nii, 'compcor_noise_mask') return analysisflow
# sink: file - idx relationship!! pop_id = pe.Node(interface=utils_convert.List2TxtFile, name='pop_id') pop_id.inputs.rownum = 0 pop_id.inputs.out_file = "subject_IDs.txt" totalWorkflow.connect(datagrab, 'bold', pop_id, 'in_list') ds_id = pe.Node(interface=io.DataSink(), name='ds_pop_id') ds_id.inputs.regexp_substitutions = [("(\/)[^\/]*$", "IDs.txt")] ds_id.inputs.base_directory = globals._SinkDir_ totalWorkflow.connect(pop_id, 'txt_file', ds_id, 'subjects') # build the actual pipeline reorient_struct = pe.MapNode(fsl.utils.Reorient2Std(output_type='NIFTI_GZ'), iterfield=['in_file'], name="reorient_struct") totalWorkflow.connect(datagrab, 'T1w', reorient_struct, 'in_file') reorient_func = pe.MapNode(fsl.utils.Reorient2Std(output_type='NIFTI_GZ'), iterfield=['in_file'], name="reorient_func") totalWorkflow.connect(datagrab, 'bold', reorient_func, 'in_file') # prior probmaps for FAST are now switched off by default in PUMI # ToDo: make settable myanatproc = anatproc.AnatProc(stdreg=globals._regType_) myanatproc.inputs.inputspec.bet_fract_int_thr = opts.bet_fract_int_thr #0.3 # feel free to adjust, a nice bet is important! myanatproc.inputs.inputspec.bet_vertical_gradient = opts.bet_vertical_gradient #-0.3 # feel free to adjust, a nice bet is important! # try scripts/opt_bet.py to optimise these parameters totalWorkflow.connect(reorient_struct, 'out_file', myanatproc, 'inputspec.anat')
def onevol_workflow(SinkTag="anat_preproc", wf_name="get_example_vol"): ''' This function receive the raw functional image and return its last volume for registration purposes. MORE: It also returns information from the header file. Workflow inputs: :param func: Functional image. :param SinkDir: :param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found. Workflow outputs: :return: onevol_workflow - workflow Balint Kincses [email protected] 2018 ''' import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import PUMI.func_preproc.info.info_get as info_get import nipype.interfaces.io as io import PUMI.utils.globals as globals SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) # Basic interface class generates identity mappings inputspec = pe.Node(utility.IdentityInterface(fields=['func']), name='inputspec') #inputspec.inputs.func = "/home/balint/Dokumentumok/phd/essen/PAINTER/probe/s002/func_data.nii.gz" # Get dimension infos idx = pe.MapNode(interface=info_get.tMinMax, iterfield=['in_files'], name='idx') # Get the last volume of the func image fslroi = pe.MapNode(fsl.ExtractROI(), iterfield=['in_file', 't_min'], name='fslroi') fslroi.inputs.t_size = 1 # Basic interface class generates identity mappings outputspec = pe.Node(utility.IdentityInterface(fields=['func1vol']), name='outputspec') # Generic datasink module to store structured outputs ds = pe.Node(interface=io.DataSink(), name='ds') ds.inputs.base_directory = SinkDir ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] analysisflow = nipype.Workflow(wf_name) analysisflow.connect(inputspec, 'func', idx, 'in_files') analysisflow.connect(inputspec, 'func', fslroi, 'in_file') analysisflow.connect(idx, 'refvolidx', fslroi, 't_min') analysisflow.connect(fslroi, 'roi_file', ds, 'funclastvol') analysisflow.connect(fslroi, 'roi_file', outputspec, 'func1vol') return analysisflow
def create_B0_workflow(name='b0_unwarping', scanner='philips'): """ Does B0 field unwarping Example ------- >>> nipype_epicorrect = create_unwarping_workflow('unwarp',) >>> unwarp.inputs.input_node.in_file = 'subj1_run1_bold.nii.gz' >>> unwarp.inputs.input_node.fieldmap_mag = 'subj1_run1_mag.nii.gz' >>> unwarp.inputs.input_node.fieldmap_pha = 'subj1_run1_phas.nii.gz' >>> unwarp.inputs.input_node.wfs = 12.223 >>> unwarp.inputs.input_node.epi_factor = 35.0 >>> unwarp.inputs.input_node.acceleration = 3.0 >>> unwarp.inputs.input_node.te_diff = 0.005 >>> unwarp.inputs.input_node.phase_encoding_direction = 'y' >>> nipype_epicorrect.run() Inputs:: input_node.in_file - Volume acquired with EPI sequence input_node.fieldmap_mag - Magnitude of the fieldmap input_node.fieldmap_pha - Phase difference of the fieldmap input_node.wfs - Water-fat-shift in pixels input_node.epi_factor - EPI factor input_node.acceleration - Acceleration factor used for EPI parallel imaging (SENSE) input_node.te_diff - Time difference between TE in seconds. input_node.phase_encoding_direction - Unwarp direction (default should be "y") Outputs:: outputnode.epi_corrected """ # Nodes: # ------ # Define input and workflow: input_node = pe.Node(name='inputspec', interface=IdentityInterface(fields=[ 'in_files', 'fieldmap_mag', 'fieldmap_pha', 'wfs', 'epi_factor', 'acceleration', 'echo_spacing', 'te_diff', 'phase_encoding_direction' ])) # Normalize phase difference of the fieldmap phase to be [-pi, pi) norm_pha = pe.Node(interface=Prepare_phasediff, name='normalize_phasediff') # Mask the magnitude of the fieldmap mask_mag = pe.Node(fsl.BET(mask=True), name='mask_magnitude') mask_mag_dil = pe.Node(interface=Dilate_mask, name='mask_dilate') # Unwrap fieldmap phase using FSL PRELUDE prelude = pe.Node(fsl.PRELUDE(process3d=True), name='phase_unwrap') # Convert unwrapped fieldmap phase to radials per second: radials_per_second = pe.Node(interface=Radials_per_second, name='radials_ps') # in case of SIEMENS scanner: prepare_fieldmap = pe.Node(PrepareFieldmap(), name='prepare_fieldmap') # Register unwrapped fieldmap (rad/s) to epi, using the magnitude of the fieldmap registration = pe.MapNode(fsl.FLIRT(bins=256, cost='corratio', dof=6, interp='trilinear', searchr_x=[-10, 10], searchr_y=[-10, 10], searchr_z=[-10, 10]), iterfield=['reference'], name='registration') # transform unwrapped fieldmap (rad/s) applyxfm = pe.MapNode(fsl.ApplyXFM(interp='trilinear'), iterfield=['reference', 'in_matrix_file'], name='apply_xfm') # compute effective echospacing: echo_spacing_philips = pe.Node(interface=Compute_echo_spacing_philips, name='echo_spacing_philips') echo_spacing_siemens = pe.Node(interface=Compute_echo_spacing_siemens, name='echo_spacing_siemens') te_diff_in_ms = pe.Node(interface=TE_diff_ms, name='te_diff_in_ms') # Unwarp with FSL Fugue fugue = pe.MapNode(interface=fsl.FUGUE(median_2dfilter=True), iterfield=['in_file', 'unwarped_file', 'fmap_in_file'], name='fugue') # Convert unwrapped fieldmap phase to radials per second: out_file = pe.MapNode(interface=Make_output_filename, iterfield=['in_file'], name='out_file') # Define output node outputnode = pe.Node( IdentityInterface(fields=['out_files', 'field_coefs']), name='outputspec') # Workflow: # --------- unwarp_workflow = pe.Workflow(name=name) unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file') # registration: unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file') unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file') unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file') unwarp_workflow.connect(input_node, 'in_files', registration, 'reference') if scanner == 'philips': # prepare fieldmap: unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha, 'in_file') unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude, 'magnitude_file') unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file') unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file') unwarp_workflow.connect(prelude, 'unwrapped_phase_file', radials_per_second, 'in_file') unwarp_workflow.connect(input_node, 'te_diff', radials_per_second, 'asym') # transform fieldmap: unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm, 'in_file') unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm, 'in_matrix_file') unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference') # compute echo spacing: unwarp_workflow.connect(input_node, 'wfs', echo_spacing_philips, 'wfs') unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing_philips, 'epi_factor') unwarp_workflow.connect(input_node, 'acceleration', echo_spacing_philips, 'acceleration') unwarp_workflow.connect(echo_spacing_philips, 'echo_spacing', fugue, 'dwell_time') elif scanner == 'siemens': unwarp_workflow.connect(input_node, 'te_diff', te_diff_in_ms, 'te_diff') # prepare fieldmap: unwarp_workflow.connect(mask_mag, 'out_file', prepare_fieldmap, 'in_magnitude') unwarp_workflow.connect(input_node, 'fieldmap_pha', prepare_fieldmap, 'in_phase') unwarp_workflow.connect(te_diff_in_ms, 'te_diff', prepare_fieldmap, 'delta_TE') # transform fieldmap: unwarp_workflow.connect(prepare_fieldmap, 'out_fieldmap', applyxfm, 'in_file') unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm, 'in_matrix_file') unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference') # compute echo spacing: unwarp_workflow.connect(input_node, 'acceleration', echo_spacing_siemens, 'acceleration') unwarp_workflow.connect(input_node, 'echo_spacing', echo_spacing_siemens, 'echo_spacing') unwarp_workflow.connect(echo_spacing_siemens, 'echo_spacing', fugue, 'dwell_time') unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file') unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file') unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file') unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time') unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue, 'unwarp_direction') unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files') unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs') # # Connect # unwarp_workflow.connect(input_node, 'in_files', out_file, 'in_file') # unwarp_workflow.connect(input_node, 'fieldmap_pha', norm_pha, 'in_file') # unwarp_workflow.connect(input_node, 'fieldmap_mag', mask_mag, 'in_file') # unwarp_workflow.connect(mask_mag, 'mask_file', mask_mag_dil, 'in_file') # unwarp_workflow.connect(input_node, 'fieldmap_mag', prelude, 'magnitude_file') # unwarp_workflow.connect(norm_pha, 'out_file', prelude, 'phase_file') # unwarp_workflow.connect(mask_mag_dil, 'out_file', prelude, 'mask_file') # unwarp_workflow.connect(prelude, 'unwrapped_phase_file', radials_per_second, 'in_file') # unwarp_workflow.connect(input_node, 'te_diff', radials_per_second, 'asym') # unwarp_workflow.connect(mask_mag, 'out_file', registration, 'in_file') # unwarp_workflow.connect(input_node, 'in_files', registration, 'reference') # unwarp_workflow.connect(radials_per_second, 'out_file', applyxfm, 'in_file') # unwarp_workflow.connect(registration, 'out_matrix_file', applyxfm, 'in_matrix_file') # unwarp_workflow.connect(input_node, 'in_files', applyxfm, 'reference') # if compute_echo_spacing: # unwarp_workflow.connect(input_node, 'wfs', echo_spacing, 'wfs') # unwarp_workflow.connect(input_node, 'epi_factor', echo_spacing, 'epi_factor') # unwarp_workflow.connect(input_node, 'acceleration', echo_spacing, 'acceleration') # unwarp_workflow.connect(echo_spacing, 'echo_spacing', fugue, 'dwell_time') # else: # unwarp_workflow.connect(input_node, 'echo_spacing', fugue, 'dwell_time') # unwarp_workflow.connect(input_node, 'in_files', fugue, 'in_file') # unwarp_workflow.connect(out_file, 'out_file', fugue, 'unwarped_file') # unwarp_workflow.connect(applyxfm, 'out_file', fugue, 'fmap_in_file') # unwarp_workflow.connect(input_node, 'te_diff', fugue, 'asym_se_time') # unwarp_workflow.connect(input_node, 'phase_encoding_direction', fugue, 'unwarp_direction') # unwarp_workflow.connect(fugue, 'unwarped_file', outputnode, 'out_files') # unwarp_workflow.connect(applyxfm, 'out_file', outputnode, 'field_coefs') return unwarp_workflow
def bet_workflow(Robust=True, fmri=False, SinkTag="anat_preproc", wf_name="brain_extraction"): """ Modified version of CPAC.anat_preproc.anat_preproc: `source: https://fcp-indi.github.io/docs/developer/_modules/CPAC/anat_preproc/anat_preproc.html` Creates a brain extracted image and its mask from a T1w anatomical image. Workflow inputs: :param anat: The reoriented anatomical file. :param SinkDir: :param SinkTag: The output directiry in which the returned images (see workflow outputs) could be found. Workflow outputs: :return: bet_workflow - workflow Balint Kincses [email protected] 2018 """ import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import nipype.interfaces.fsl as fsl import nipype.interfaces.io as io import PUMI.utils.QC as qc import PUMI.utils.globals as globals import PUMI.func_preproc.Onevol as onevol SinkDir = os.path.abspath(globals._SinkDir_ + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) #Basic interface class generates identity mappings inputspec = pe.Node( utility.IdentityInterface(fields=[ 'in_file', 'opt_R', 'fract_int_thr', # optional 'vertical_gradient' ]), # optional name='inputspec') inputspec.inputs.opt_R = Robust if fmri: inputspec.inputs.fract_int_thr = globals._fsl_bet_fract_int_thr_func_ else: inputspec.inputs.fract_int_thr = globals._fsl_bet_fract_int_thr_anat_ inputspec.inputs.vertical_gradient = globals._fsl_bet_vertical_gradient_ #Wraps command **bet** bet = pe.MapNode(interface=fsl.BET(), iterfield=['in_file'], name='bet') bet.inputs.mask = True # bet.inputs.robust=Robust if fmri: bet.inputs.functional = True myonevol = onevol.onevol_workflow(wf_name="onevol") applymask = pe.MapNode(fsl.ApplyMask(), iterfield=['in_file', 'mask_file'], name="apply_mask") myqc = qc.vol2png(wf_name, overlay=True) #Basic interface class generates identity mappings outputspec = pe.Node( utility.IdentityInterface(fields=['brain', 'brain_mask']), name='outputspec') # Save outputs which are important ds = pe.Node(interface=io.DataSink(), name='ds') ds.inputs.base_directory = SinkDir ds.inputs.regexp_substitutions = [("(\/)[^\/]*$", ".nii.gz")] #Create a workflow to connect all those nodes analysisflow = nipype.Workflow( wf_name) # The name here determine the folder of the workspace analysisflow.base_dir = '.' analysisflow.connect(inputspec, 'in_file', bet, 'in_file') analysisflow.connect(inputspec, 'opt_R', bet, 'robust') analysisflow.connect(inputspec, 'fract_int_thr', bet, 'frac') analysisflow.connect(inputspec, 'vertical_gradient', bet, 'vertical_gradient') analysisflow.connect(bet, 'mask_file', outputspec, 'brain_mask') if fmri: analysisflow.connect(bet, 'mask_file', myonevol, 'inputspec.func') analysisflow.connect(myonevol, 'outputspec.func1vol', applymask, 'mask_file') analysisflow.connect(inputspec, 'in_file', applymask, 'in_file') analysisflow.connect(applymask, 'out_file', outputspec, 'brain') else: analysisflow.connect(bet, 'out_file', outputspec, 'brain') analysisflow.connect(bet, 'out_file', ds, 'bet_brain') analysisflow.connect(bet, 'mask_file', ds, 'brain_mask') analysisflow.connect(inputspec, 'in_file', myqc, 'inputspec.bg_image') analysisflow.connect(bet, 'out_file', myqc, 'inputspec.overlay_image') return analysisflow
def addimgs_workflow(numimgs=2, SinkDir=".", SinkTag="func_preproc", WorkingDirectory="."): """ `source: -` Add any number of images whic are in the same space. The input files must be NIFTI files. Workflow inputs: :param any number of .nii(.gz) files. :param SinkDir: :param SinkTag: The output directory in which the returned images (see workflow outputs) could be found in a subdirectory directory specific for this workflow. Workflow outputs: :return: addimgs_workflow - workflow Balint Kincses [email protected] 2018 """ import os import nipype import nipype.pipeline as pe import nipype.interfaces.utility as utility import PUMI.utils.utils_convert as utils_convert from nipype.interfaces.utility import Function import nipype.interfaces.fsl as fsl SinkDir = os.path.abspath(SinkDir + "/" + SinkTag) if not os.path.exists(SinkDir): os.makedirs(SinkDir) inputs=[] for i in range(1, numimgs + 1): inputs.append("par" + str(i)) # Basic interface class generates identity mappings inputspec = pe.Node(utility.IdentityInterface(fields=inputs), name='inputspec') # Add masks with FSL add_masks = pe.MapNode(fsl.ImageMaths(op_string=' -add'), iterfield=inputs, name="addimgs") outputspec = pe.Node(utility.IdentityInterface(fields=['added_imgs']), name='outputspec') # Create workflow analysisflow = nipype.Workflow('addimgsWorkflow') analysisflow.base_dir = '.' #connect for i in range(1, numimgs + 1): actparam = "par" + str(i) analysisflow.connect(inputspec, actparam, add_masks, actparam) #analysisflow.connect(inputspec, inputs, add_masks, inputs) analysisflow.connect(add_masks, 'out_file', outputspec, 'added_imgs') return analysisflow
import nipype.interfaces.io as io OutJSON = SinkDir + "/outputs.JSON" #Basic interface class generates identity mappings NodeHash_604000eb5d20 = pe.Node(utility.IdentityInterface(fields=['func','magnitude','phase','TE1','TE2','dwell_time','unwarp_direction']), name = 'NodeName_604000eb5d20') NodeHash_604000eb5d20.inputs.func = func NodeHash_604000eb5d20.inputs.magnitude = magnitude NodeHash_604000eb5d20.inputs.phase = phase NodeHash_604000eb5d20.inputs.TE1 = TE1 NodeHash_604000eb5d20.inputs.TE2 = TE2 NodeHash_604000eb5d20.inputs.dwell_time = dwell_time NodeHash_604000eb5d20.inputs.unwarp_direction = unwarp_direction #Wraps command **bet** NodeHash_604000cba700 = pe.MapNode(interface = fsl.BET(), name = 'NodeName_604000cba700', iterfield = ['in_file']) NodeHash_604000cba700.inputs.mask = True #Wraps command **fslmaths** NodeHash_600001ab26c0 = pe.MapNode(interface = fsl.ErodeImage(), name = 'NodeName_600001ab26c0', iterfield = ['in_file']) #Wraps command **fslmaths** NodeHash_60c0018a6e40 = pe.MapNode(interface = fsl.ErodeImage(), name = 'NodeName_60c0018a6e40', iterfield = ['in_file']) #Custom interface wrapping function SubTwo NodeHash_60c0018a4860 = pe.Node(interface = utils_math.SubTwo, name = 'NodeName_60c0018a4860') #Custom interface wrapping function Abs NodeHash_600001eab220 = pe.Node(interface = utils_math.Abs, name = 'NodeName_600001eab220') #Wraps command **fsl_prepare_fieldmap**
def create_preprocessing_workflow(analysis_params, name='yesno_3T'): import os.path as op import nipype.pipeline as pe from nipype.interfaces import fsl from nipype.interfaces.utility import Function, Merge, IdentityInterface from nipype.interfaces.io import SelectFiles, DataSink from IPython import embed as shell # Importing of custom nodes from spynoza packages; assumes that spynoza is installed: # pip install git+https://github.com/spinoza-centre/spynoza.git@develop from spynoza.utils import get_scaninfo, pickfirst, average_over_runs, set_nifti_intercept_slope from spynoza.uniformization.workflows import create_non_uniformity_correct_4D_file from spynoza.unwarping.b0.workflows import create_B0_workflow from spynoza.motion_correction.workflows import create_motion_correction_workflow from spynoza.registration.workflows import create_registration_workflow from spynoza.filtering.nodes import sgfilter from spynoza.conversion.nodes import psc from spynoza.denoising.retroicor.workflows import create_retroicor_workflow from spynoza.masking.workflows import create_masks_from_surface_workflow from spynoza.glm.nodes import fit_nuisances ######################################################################################## # nodes ######################################################################################## input_node = pe.Node( IdentityInterface(fields=[ 'task', # main 'sub_id', # main 'ses_id', # main 'raw_data_dir', # main 'output_directory', # main 'sub_FS_id', # main 'FS_subject_dir', # motion correction 'RepetitionTime', # motion correction 'which_file_is_EPI_space', # motion correction 'standard_file', # registration 'topup_conf_file', # unwarping 'EchoTimeDiff', # unwarping 'EpiFactor', # unwarping 'SenseFactor', # unwarping 'WaterFatShift', # unwarping 'PhaseEncodingDirection', # unwarping 'EchoSpacing' # unwarping 'psc_func', # percent signal change 'sg_filter_window_length', # temporal filtering 'sg_filter_order', # temporal filtering 'SliceEncodingDirection', # retroicor 'PhysiologySampleRate', # retroicor 'SliceTiming', # retroicor 'SliceOrder', # retroicor 'NumberDummyScans', # retroicor 'MultiBandFactor', # retroicor 'hr_rvt', # retroicor 'av_func', # extra 'EchoTime', # extra 'bd_design_matrix_file', # extra ]), name='inputspec') for param in analysis_params: exec('input_node.inputs.{} = analysis_params[param]'.format(param)) # i/o node datasource_templates = dict( func= '{sub_id}/{ses_id}/func/{sub_id}_{ses_id}_task-{task}*_bold.nii.gz', magnitude='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*magnitude.nii.gz', phasediff='{sub_id}/{ses_id}/fmap/{sub_id}_{ses_id}*phasediff.nii.gz', #physio='{sub_id}/{ses_id}/func/*{task}*physio.*', #events='{sub_id}/{ses_id}/func/*{task}*_events.pickle', #eye='{sub_id}/{ses_id}/func/*{task}*_eyedata.edf' ) datasource = pe.Node(SelectFiles(datasource_templates, sort_filelist=True, raise_on_empty=False), name='datasource') output_node = pe.Node(IdentityInterface( fields=(['temporal_filtered_files', 'percent_signal_change_files'])), name='outputspec') # nodes for setting the slope/intercept of incoming niftis to (1, 0) # this is apparently necessary for the B0 map files int_slope_B0_magnitude = pe.Node(Function( input_names=['in_file'], output_names=['out_file'], function=set_nifti_intercept_slope), name='int_slope_B0_magnitude') int_slope_B0_phasediff = pe.Node(Function( input_names=['in_file'], output_names=['out_file'], function=set_nifti_intercept_slope), name='int_slope_B0_phasediff') # reorient nodes reorient_epi = pe.MapNode(interface=fsl.Reorient2Std(), name='reorient_epi', iterfield=['in_file']) reorient_B0_magnitude = pe.Node(interface=fsl.Reorient2Std(), name='reorient_B0_magnitude') reorient_B0_phasediff = pe.Node(interface=fsl.Reorient2Std(), name='reorient_B0_phasediff') # bet_epi = pe.MapNode(interface= # fsl.BET(frac=analysis_parameters['bet_f_value'], vertical_gradient = analysis_parameters['bet_g_value'], # functional=True, mask = True), name='bet_epi', iterfield=['in_file']) datasink = pe.Node(DataSink(), name='sinker') datasink.inputs.parameterization = False ######################################################################################## # workflow ######################################################################################## # the actual top-level workflow preprocessing_workflow = pe.Workflow(name=name) preprocessing_workflow.base_dir = op.join(analysis_params['base_dir'], 'temp/') # data source preprocessing_workflow.connect(input_node, 'raw_data_dir', datasource, 'base_directory') preprocessing_workflow.connect(input_node, 'sub_id', datasource, 'sub_id') preprocessing_workflow.connect(input_node, 'ses_id', datasource, 'ses_id') preprocessing_workflow.connect(input_node, 'task', datasource, 'task') # and data sink preprocessing_workflow.connect(input_node, 'output_directory', datasink, 'base_directory') # BET (we don't do this, because we expect the raw data in the bids folder to be betted # already for anonymization purposes) # preprocessing_workflow.connect(datasource, 'func', bet_epi, 'in_file') # non-uniformity correction # preprocessing_workflow.connect(bet_epi, 'out_file', nuc, 'in_file') # preprocessing_workflow.connect(datasource, 'func', nuc, 'in_file') # reorient images preprocessing_workflow.connect(datasource, 'func', reorient_epi, 'in_file') preprocessing_workflow.connect(datasource, 'magnitude', reorient_B0_magnitude, 'in_file') preprocessing_workflow.connect(datasource, 'phasediff', reorient_B0_phasediff, 'in_file') preprocessing_workflow.connect(reorient_epi, 'out_file', datasink, 'reorient') #B0 field correction: if analysis_params['B0_or_topup'] == 'B0': # set slope/intercept to unity for B0 map preprocessing_workflow.connect(reorient_B0_magnitude, 'out_file', int_slope_B0_magnitude, 'in_file') preprocessing_workflow.connect(reorient_B0_phasediff, 'out_file', int_slope_B0_phasediff, 'in_file') #B0 field correction: if 'EchoSpacing' in analysis_params: B0_wf = create_B0_workflow(name='B0', scanner='siemens') preprocessing_workflow.connect(input_node, 'EchoSpacing', B0_wf, 'inputspec.echo_spacing') else: B0_wf = create_B0_workflow(name='B0', scanner='philips') preprocessing_workflow.connect(input_node, 'WaterFatShift', B0_wf, 'inputspec.wfs') preprocessing_workflow.connect(input_node, 'EpiFactor', B0_wf, 'inputspec.epi_factor') preprocessing_workflow.connect(input_node, 'SenseFactor', B0_wf, 'inputspec.acceleration') preprocessing_workflow.connect(reorient_epi, 'out_file', B0_wf, 'inputspec.in_files') preprocessing_workflow.connect(int_slope_B0_magnitude, 'out_file', B0_wf, 'inputspec.fieldmap_mag') preprocessing_workflow.connect(int_slope_B0_phasediff, 'out_file', B0_wf, 'inputspec.fieldmap_pha') preprocessing_workflow.connect(input_node, 'EchoTimeDiff', B0_wf, 'inputspec.te_diff') preprocessing_workflow.connect(input_node, 'PhaseEncodingDirection', B0_wf, 'inputspec.phase_encoding_direction') preprocessing_workflow.connect(B0_wf, 'outputspec.field_coefs', datasink, 'B0.fieldcoef') preprocessing_workflow.connect(B0_wf, 'outputspec.out_files', datasink, 'B0') # motion correction motion_proc = create_motion_correction_workflow( 'moco', method=analysis_params['moco_method']) if analysis_params['B0_or_topup'] == 'B0': preprocessing_workflow.connect(B0_wf, 'outputspec.out_files', motion_proc, 'inputspec.in_files') elif analysis_params['B0_or_topup'] == 'neither': preprocessing_workflow.connect(bet_epi, 'out_file', motion_proc, 'inputspec.in_files') preprocessing_workflow.connect(input_node, 'RepetitionTime', motion_proc, 'inputspec.tr') preprocessing_workflow.connect(input_node, 'output_directory', motion_proc, 'inputspec.output_directory') preprocessing_workflow.connect(input_node, 'which_file_is_EPI_space', motion_proc, 'inputspec.which_file_is_EPI_space') # registration reg = create_registration_workflow(analysis_params, name='reg') preprocessing_workflow.connect(input_node, 'output_directory', reg, 'inputspec.output_directory') preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', reg, 'inputspec.EPI_space_file') preprocessing_workflow.connect(input_node, 'sub_FS_id', reg, 'inputspec.freesurfer_subject_ID') preprocessing_workflow.connect(input_node, 'FS_subject_dir', reg, 'inputspec.freesurfer_subject_dir') preprocessing_workflow.connect(input_node, 'standard_file', reg, 'inputspec.standard_file') # temporal filtering preprocessing_workflow.connect(input_node, 'sg_filter_window_length', sgfilter, 'window_length') preprocessing_workflow.connect(input_node, 'sg_filter_order', sgfilter, 'polyorder') preprocessing_workflow.connect(motion_proc, 'outputspec.motion_corrected_files', sgfilter, 'in_file') preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf') # node for percent signal change preprocessing_workflow.connect(input_node, 'psc_func', psc, 'func') preprocessing_workflow.connect(sgfilter, 'out_file', psc, 'in_file') preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc') # # retroicor functionality # if analysis_params['perform_physio'] == 1: # retr = create_retroicor_workflow(name = 'retroicor', order_or_timing = analysis_params['retroicor_order_or_timing']) # # # # retroicor can take the crudest form of epi file, so that it proceeds quickly # preprocessing_workflow.connect(datasource, 'func', retr, 'inputspec.in_files') # preprocessing_workflow.connect(datasource, 'physio', retr, 'inputspec.phys_files') # preprocessing_workflow.connect(input_node, 'analysis_params.nr_dummies', retr, 'inputspec.nr_dummies') # preprocessing_workflow.connect(input_node, 'analysis_params.MultiBandFactor', retr, 'inputspec.MB_factor') # preprocessing_workflow.connect(input_node, 'analysis_params.tr', retr, 'inputspec.tr') # preprocessing_workflow.connect(input_node, 'analysis_params.SliceEncodingDirection', retr, 'inputspec.slice_direction') # preprocessing_workflow.connect(input_node, 'analysis_params.SliceTiming', retr, 'inputspec.slice_timing') # preprocessing_workflow.connect(input_node, 'analysis_params.SliceOrder', retr, 'inputspec.slice_order') # preprocessing_workflow.connect(input_node, 'analysis_params.PhysiologySampleRate', retr, 'inputspec.phys_sample_rate') # preprocessing_workflow.connect(input_node, 'analysis_params.hr_rvt', retr, 'inputspec.hr_rvt') # # # fit nuisances from retroicor # # preprocessing_workflow.connect(retr, 'outputspec.evs', fit_nuis, 'slice_regressor_list') # # preprocessing_workflow.connect(motion_proc, 'outputspec.extended_motion_correction_parameters', fit_nuis, 'vol_regressors') # # preprocessing_workflow.connect(psc, 'out_file', fit_nuis, 'in_file') # # # preprocessing_workflow.connect(fit_nuis, 'res_file', av_r, 'in_files') # # preprocessing_workflow.connect(retr, 'outputspec.new_phys', datasink, 'phys.log') # preprocessing_workflow.connect(retr, 'outputspec.fig_file', datasink, 'phys.figs') # preprocessing_workflow.connect(retr, 'outputspec.evs', datasink, 'phys.evs') # # preprocessing_workflow.connect(fit_nuis, 'res_file', datasink, 'phys.res') # # preprocessing_workflow.connect(fit_nuis, 'rsq_file', datasink, 'phys.rsq') # # preprocessing_workflow.connect(fit_nuis, 'beta_file', datasink, 'phys.betas') # # # preprocessing_workflow.connect(av_r, 'out_file', datasink, 'av_r') # # ######################################################################################## # # masking stuff if doing mri analysis # ######################################################################################## # # all_mask_opds = ['dc'] + analysis_parameters[u'avg_subject_RS_label_folders'] # all_mask_lds = [''] + analysis_parameters[u'avg_subject_RS_label_folders'] # # # loop across different folders to mask # # untested as yet. # masking_list = [] # dilate_list = [] # for opd, label_directory in zip(all_mask_opds,all_mask_lds): # dilate_list.append( # pe.MapNode(interface=fsl.maths.DilateImage( # operation = 'mean', kernel_shape = 'sphere', kernel_size = analysis_parameters['dilate_kernel_size']), # name='dilate_'+label_directory, iterfield=['in_file'])) # # masking_list.append(create_masks_from_surface_workflow(name = 'masks_from_surface_'+label_directory)) # # masking_list[-1].inputs.inputspec.label_directory = label_directory # masking_list[-1].inputs.inputspec.fill_thresh = 0.005 # masking_list[-1].inputs.inputspec.re = '*.label' # # preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', masking_list[-1], 'inputspec.EPI_space_file') # preprocessing_workflow.connect(input_node, 'output_directory', masking_list[-1], 'inputspec.output_directory') # preprocessing_workflow.connect(input_node, 'FS_subject_dir', masking_list[-1], 'inputspec.freesurfer_subject_dir') # preprocessing_workflow.connect(input_node, 'FS_ID', masking_list[-1], 'inputspec.freesurfer_subject_ID') # preprocessing_workflow.connect(reg, 'rename_register.out_file', masking_list[-1], 'inputspec.reg_file') # # preprocessing_workflow.connect(masking_list[-1], 'outputspec.masks', dilate_list[-1], 'in_file') # preprocessing_workflow.connect(dilate_list[-1], 'out_file', datasink, 'masks.'+opd) # # # # surface-based label import in to EPI space, but now for RS labels # # these should have been imported to the subject's FS folder, # # see scripts/annot_conversion.sh # RS_masks_from_surface = create_masks_from_surface_workflow(name = 'RS_masks_from_surface') # RS_masks_from_surface.inputs.inputspec.label_directory = analysis_parameters['avg_subject_label_folder'] # RS_masks_from_surface.inputs.inputspec.fill_thresh = 0.005 # RS_masks_from_surface.inputs.inputspec.re = '*.label' # # preprocessing_workflow.connect(motion_proc, 'outputspec.EPI_space_file', RS_masks_from_surface, 'inputspec.EPI_space_file') # preprocessing_workflow.connect(input_node, 'output_directory', RS_masks_from_surface, 'inputspec.output_directory') # preprocessing_workflow.connect(input_node, 'FS_subject_dir', RS_masks_from_surface, 'inputspec.freesurfer_subject_dir') # preprocessing_workflow.connect(input_node, 'FS_ID', RS_masks_from_surface, 'inputspec.freesurfer_subject_ID') # preprocessing_workflow.connect(reg, 'rename_register.out_file', RS_masks_from_surface, 'inputspec.reg_file') # # preprocessing_workflow.connect(RS_masks_from_surface, 'outputspec.masks', RS_dilate_cortex, 'in_file') # preprocessing_workflow.connect(RS_dilate_cortex, 'out_file', datasink, 'masks.'+analysis_parameters['avg_subject_label_folder']) ######################################################################################## # wrapping up, sending data to datasink ######################################################################################## # preprocessing_workflow.connect(bet_epi, 'out_file', datasink, 'bet.epi') # preprocessing_workflow.connect(bet_epi, 'mask_file', datasink, 'bet.epimask') # preprocessing_workflow.connect(bet_topup, 'out_file', datasink, 'bet.topup') # preprocessing_workflow.connect(bet_topup, 'mask_file', datasink, 'bet.topupmask') # preprocessing_workflow.connect(nuc, 'out_file', datasink, 'nuc') # preprocessing_workflow.connect(sgfilter, 'out_file', datasink, 'tf') # preprocessing_workflow.connect(psc, 'out_file', datasink, 'psc') # preprocessing_workflow.connect(datasource, 'physio', datasink, 'phys') return preprocessing_workflow