.. AUTO-GENERATED FILE -- DO NOT EDIT!

nipype.workflows.fsl.preprocess
===============================


:class:`create_featreg_preproc()`
---------------------------------


Create a FEAT preprocessing workflow with registration to one volume of the first run

Parameters
~~~~~~~~~~

name : name of workflow (default: featpreproc)
highpass : boolean (default: True)
whichvol : which volume of the first run to register to ('first', 'middle', 'mean')

Inputs::

    inputspec.func : functional runs (filename or list of filenames)
    inputspec.fwhm : fwhm for smoothing with SUSAN
    inputspec.highpass : HWHM in TRs (if created with highpass=True)

Outputs::

    outputspec.reference : volume to which runs are realigned
    outputspec.motion_parameters : motion correction parameters
    outputspec.realigned_files : motion corrected files
    outputspec.motion_plots : plots of motion correction parameters
    outputspec.mask : mask file used to mask the brain
    outputspec.smoothed_files : smoothed functional data
    outputspec.highpassed_files : highpassed functional data (if highpass=True)
    outputspec.mean : mean file

Example
~~~~~~~

>>> from nipype.workflows.fsl import create_featreg_preproc
>>> import os
>>> preproc = create_featreg_preproc()
>>> preproc.inputs.inputspec.func = ['f3.nii', 'f5.nii']
>>> preproc.inputs.inputspec.fwhm = 5
>>> preproc.inputs.inputspec.highpass = 128./(2*2.5)
>>> preproc.base_dir = '/tmp'
>>> preproc.run() # doctest: +SKIP

>>> preproc = create_featreg_preproc(highpass=False, whichvol='mean')
>>> preproc.inputs.inputspec.func = 'f3.nii'
>>> preproc.inputs.inputspec.fwhm = 5
>>> preproc.base_dir = '/tmp'
>>> preproc.run() # doctest: +SKIP



Graph
~~~~~
.. graphviz::

	digraph featpreproc{

	  label="featpreproc";

	  featpreproc_inputspec[label="inputspec.IdentityInterface.utility"];

	  featpreproc_img2float[label="img2float.ImageMaths.fsl"];

	  featpreproc_extractref[label="extractref.ExtractROI.fsl"];

	  featpreproc_realign[label="realign.MCFLIRT.fsl"];

	  featpreproc_plot_motion[label="plot_motion.PlotMotionParams.fsl", style=filled, colorscheme=greys7 color=2];

	  featpreproc_meanfunc[label="meanfunc.ImageMaths.fsl"];

	  featpreproc_meanfuncmask[label="meanfuncmask.BET.fsl"];

	  featpreproc_maskfunc[label="maskfunc.ImageMaths.fsl"];

	  featpreproc_getthreshold[label="getthreshold.ImageStats.fsl"];

	  featpreproc_threshold[label="threshold.ImageMaths.fsl"];

	  featpreproc_medianval[label="medianval.ImageStats.fsl"];

	  featpreproc_dilatemask[label="dilatemask.ImageMaths.fsl"];

	  featpreproc_maskfunc2[label="maskfunc2.ImageMaths.fsl"];

	  featpreproc_maskfunc3[label="maskfunc3.ImageMaths.fsl"];

	  featpreproc_concat[label="concat.Merge.utility"];

	  featpreproc_select[label="select.Select.utility"];

	  featpreproc_meanscale[label="meanscale.ImageMaths.fsl"];

	  featpreproc_highpass[label="highpass.ImageMaths.fsl"];

	  featpreproc_meanfunc3[label="meanfunc3.ImageMaths.fsl"];

	  featpreproc_outputspec[label="outputspec.IdentityInterface.utility"];

	  featpreproc_inputspec -> featpreproc_img2float;

	  featpreproc_inputspec -> featpreproc_highpass;

	  featpreproc_inputspec -> featpreproc_select;

	  featpreproc_img2float -> featpreproc_extractref;

	  featpreproc_img2float -> featpreproc_extractref;

	  featpreproc_img2float -> featpreproc_realign;

	  featpreproc_extractref -> featpreproc_outputspec;

	  featpreproc_extractref -> featpreproc_realign;

	  featpreproc_realign -> featpreproc_maskfunc2;

	  featpreproc_realign -> featpreproc_maskfunc;

	  featpreproc_realign -> featpreproc_meanfunc;

	  featpreproc_realign -> featpreproc_outputspec;

	  featpreproc_realign -> featpreproc_outputspec;

	  featpreproc_realign -> featpreproc_medianval;

	  featpreproc_realign -> featpreproc_plot_motion;

	  featpreproc_plot_motion -> featpreproc_outputspec;

	  featpreproc_meanfunc -> featpreproc_meanfuncmask;

	  featpreproc_meanfuncmask -> featpreproc_maskfunc;

	  featpreproc_maskfunc -> featpreproc_threshold;

	  featpreproc_maskfunc -> featpreproc_getthreshold;

	  featpreproc_getthreshold -> featpreproc_threshold;

	  featpreproc_threshold -> featpreproc_medianval;

	  featpreproc_threshold -> featpreproc_dilatemask;

	  featpreproc_medianval -> featpreproc_meanscale;

	  featpreproc_dilatemask -> featpreproc_maskfunc2;

	  featpreproc_dilatemask -> featpreproc_maskfunc3;

	  featpreproc_dilatemask -> featpreproc_outputspec;

	  featpreproc_maskfunc2 -> featpreproc_concat;

	  subgraph cluster_featpreproc_susan_smooth {

	      label="susan_smooth";

	    featpreproc_susan_smooth_inputnode[label="inputnode.IdentityInterface.utility"];

	    featpreproc_susan_smooth_median[label="median.ImageStats.fsl"];

	    featpreproc_susan_smooth_mask[label="mask.ImageMaths.fsl"];

	    featpreproc_susan_smooth_meanfunc2[label="meanfunc2.ImageMaths.fsl"];

	    featpreproc_susan_smooth_merge[label="merge.Merge.utility"];

	    featpreproc_susan_smooth_smooth[label="smooth.SUSAN.fsl"];

	    featpreproc_susan_smooth_outputnode[label="outputnode.IdentityInterface.utility"];

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_median;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_median;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_mask;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_mask;

	    featpreproc_susan_smooth_median -> featpreproc_susan_smooth_merge;

	    featpreproc_susan_smooth_median -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_mask -> featpreproc_susan_smooth_meanfunc2;

	    featpreproc_susan_smooth_meanfunc2 -> featpreproc_susan_smooth_merge;

	    featpreproc_susan_smooth_merge -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_smooth -> featpreproc_susan_smooth_outputnode;

	  }

	  featpreproc_maskfunc3 -> featpreproc_concat;

	  featpreproc_concat -> featpreproc_select;

	  featpreproc_select -> featpreproc_meanscale;

	  featpreproc_select -> featpreproc_outputspec;

	  featpreproc_meanscale -> featpreproc_highpass;

	  featpreproc_highpass -> featpreproc_outputspec;

	  featpreproc_highpass -> featpreproc_meanfunc3;

	  featpreproc_meanfunc3 -> featpreproc_outputspec;

	  featpreproc_susan_smooth_outputnode -> featpreproc_maskfunc3;

	  featpreproc_maskfunc2 -> featpreproc_susan_smooth_inputnode;

	  featpreproc_inputspec -> featpreproc_susan_smooth_inputnode;

	  featpreproc_dilatemask -> featpreproc_susan_smooth_inputnode;

	}

:class:`create_fsl_fs_preproc()`
--------------------------------


Create a FEAT preprocessing workflow together with freesurfer

Parameters
~~~~~~~~~~

name : name of workflow (default: preproc)
highpass : boolean (default: True)
whichvol : which volume of the first run to register to ('first', 'middle', 'mean')

Inputs::

    inputspec.func : functional runs (filename or list of filenames)
    inputspec.fwhm : fwhm for smoothing with SUSAN
    inputspec.highpass : HWHM in TRs (if created with highpass=True)
    inputspec.subject_id : freesurfer subject id
    inputspec.subjects_dir : freesurfer subjects dir

Outputs::

    outputspec.reference : volume to which runs are realigned
    outputspec.motion_parameters : motion correction parameters
    outputspec.realigned_files : motion corrected files
    outputspec.motion_plots : plots of motion correction parameters
    outputspec.mask_file : mask file used to mask the brain
    outputspec.smoothed_files : smoothed functional data
    outputspec.highpassed_files : highpassed functional data (if highpass=True)
    outputspec.reg_file : bbregister registration files
    outputspec.reg_cost : bbregister registration cost files

Example
~~~~~~~

>>> import os
>>> from nipype.workflows.fsl import create_fsl_fs_preproc
>>> preproc = create_fsl_fs_preproc(whichvol='first')
>>> preproc.inputs.inputspec.highpass = 128./(2*2.5)
>>> preproc.inputs.inputspec.func = ['f3.nii', 'f5.nii']
>>> preproc.inputs.inputspec.subjects_dir = '.'
>>> preproc.inputs.inputspec.subject_id = 's1'
>>> preproc.inputs.inputspec.fwhm = 6
>>> preproc.run() # doctest: +SKIP



Graph
~~~~~
.. graphviz::

	digraph preproc{

	  label="preproc";

	  preproc_inputspec[label="inputspec.IdentityInterface.utility"];

	  preproc_img2float[label="img2float.ImageMaths.fsl"];

	  preproc_extractref[label="extractref.ExtractROI.fsl"];

	  preproc_realign[label="realign.MCFLIRT.fsl"];

	  preproc_medianval[label="medianval.ImageStats.fsl"];

	  preproc_plot_motion[label="plot_motion.PlotMotionParams.fsl", style=filled, colorscheme=greys7 color=2];

	  preproc_maskfunc[label="maskfunc.ImageMaths.fsl"];

	  preproc_maskfunc3[label="maskfunc3.ImageMaths.fsl"];

	  preproc_concat[label="concat.Merge.utility"];

	  preproc_select[label="select.Select.utility"];

	  preproc_meanscale[label="meanscale.ImageMaths.fsl"];

	  preproc_highpass[label="highpass.ImageMaths.fsl"];

	  preproc_outputspec[label="outputspec.IdentityInterface.utility"];

	  preproc_inputspec -> preproc_select;

	  preproc_inputspec -> preproc_highpass;

	  preproc_inputspec -> preproc_img2float;

	  preproc_img2float -> preproc_extractref;

	  preproc_img2float -> preproc_extractref;

	  preproc_img2float -> preproc_realign;

	  preproc_extractref -> preproc_outputspec;

	  preproc_extractref -> preproc_realign;

	  preproc_realign -> preproc_outputspec;

	  preproc_realign -> preproc_outputspec;

	  preproc_realign -> preproc_medianval;

	  preproc_realign -> preproc_plot_motion;

	  preproc_realign -> preproc_maskfunc;

	  subgraph cluster_preproc_getmask {

	      label="getmask";

	    preproc_getmask_inputspec[label="inputspec.IdentityInterface.utility"];

	    preproc_getmask_fssource[label="fssource.FreeSurferSource.io"];

	    preproc_getmask_register[label="register.BBRegister.freesurfer"];

	    preproc_getmask_threshold[label="threshold.Binarize.freesurfer"];

	    preproc_getmask_transform[label="transform.ApplyVolTransform.freesurfer"];

	    preproc_getmask_dilate[label="dilate.DilateImage.fsl"];

	    preproc_getmask_threshold2[label="threshold2.Binarize.freesurfer"];

	    preproc_getmask_outputspec[label="outputspec.IdentityInterface.utility"];

	    preproc_getmask_inputspec -> preproc_getmask_fssource;

	    preproc_getmask_inputspec -> preproc_getmask_fssource;

	    preproc_getmask_inputspec -> preproc_getmask_register;

	    preproc_getmask_inputspec -> preproc_getmask_register;

	    preproc_getmask_inputspec -> preproc_getmask_register;

	    preproc_getmask_inputspec -> preproc_getmask_register;

	    preproc_getmask_inputspec -> preproc_getmask_transform;

	    preproc_getmask_inputspec -> preproc_getmask_transform;

	    preproc_getmask_fssource -> preproc_getmask_threshold;

	    preproc_getmask_register -> preproc_getmask_transform;

	    preproc_getmask_register -> preproc_getmask_outputspec;

	    preproc_getmask_register -> preproc_getmask_outputspec;

	    preproc_getmask_threshold -> preproc_getmask_transform;

	    preproc_getmask_transform -> preproc_getmask_dilate;

	    preproc_getmask_dilate -> preproc_getmask_threshold2;

	    preproc_getmask_threshold2 -> preproc_getmask_outputspec;

	  }

	  preproc_medianval -> preproc_meanscale;

	  preproc_plot_motion -> preproc_outputspec;

	  preproc_maskfunc -> preproc_concat;

	  subgraph cluster_preproc_susan_smooth {

	      label="susan_smooth";

	    preproc_susan_smooth_inputnode[label="inputnode.IdentityInterface.utility"];

	    preproc_susan_smooth_mask[label="mask.ImageMaths.fsl"];

	    preproc_susan_smooth_meanfunc2[label="meanfunc2.ImageMaths.fsl"];

	    preproc_susan_smooth_median[label="median.ImageStats.fsl"];

	    preproc_susan_smooth_merge[label="merge.Merge.utility"];

	    preproc_susan_smooth_smooth[label="smooth.SUSAN.fsl"];

	    preproc_susan_smooth_outputnode[label="outputnode.IdentityInterface.utility"];

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_smooth;

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_smooth;

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_median;

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_median;

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_mask;

	    preproc_susan_smooth_inputnode -> preproc_susan_smooth_mask;

	    preproc_susan_smooth_mask -> preproc_susan_smooth_meanfunc2;

	    preproc_susan_smooth_meanfunc2 -> preproc_susan_smooth_merge;

	    preproc_susan_smooth_median -> preproc_susan_smooth_merge;

	    preproc_susan_smooth_median -> preproc_susan_smooth_smooth;

	    preproc_susan_smooth_merge -> preproc_susan_smooth_smooth;

	    preproc_susan_smooth_smooth -> preproc_susan_smooth_outputnode;

	  }

	  preproc_maskfunc3 -> preproc_concat;

	  preproc_concat -> preproc_select;

	  preproc_select -> preproc_outputspec;

	  preproc_select -> preproc_meanscale;

	  preproc_meanscale -> preproc_highpass;

	  preproc_highpass -> preproc_outputspec;

	  preproc_maskfunc -> preproc_susan_smooth_inputnode;

	  preproc_inputspec -> preproc_susan_smooth_inputnode;

	  preproc_inputspec -> preproc_getmask_inputspec;

	  preproc_inputspec -> preproc_getmask_inputspec;

	  preproc_getmask_outputspec -> preproc_maskfunc;

	  preproc_getmask_outputspec -> preproc_medianval;

	  preproc_getmask_outputspec -> preproc_susan_smooth_inputnode;

	  preproc_getmask_outputspec -> preproc_outputspec;

	  preproc_getmask_outputspec -> preproc_outputspec;

	  preproc_getmask_outputspec -> preproc_outputspec;

	  preproc_getmask_outputspec -> preproc_maskfunc3;

	  preproc_extractref -> preproc_getmask_inputspec;

	  preproc_susan_smooth_outputnode -> preproc_maskfunc3;

	}

:class:`create_parallelfeat_preproc()`
--------------------------------------


Create a FEAT preprocessing workflow that preprocess each run independently of the others

Parameters
~~~~~~~~~~

name : name of workflow (default: featpreproc)
highpass : boolean (default: True)

Inputs::

    inputspec.func : functional runs (filename or list of filenames)
    inputspec.fwhm : fwhm for smoothing with SUSAN
    inputspec.highpass : HWHM in TRs (if created with highpass=True)

Outputs::

    outputspec.reference : volume to which runs are realigned
    outputspec.motion_parameters : motion correction parameters
    outputspec.realigned_files : motion corrected files
    outputspec.motion_plots : plots of motion correction parameters
    outputspec.mask : mask file used to mask the brain
    outputspec.smoothed_files : smoothed functional data
    outputspec.highpassed_files : highpassed functional data (if highpass=True)
    outputspec.mean : mean file

Example
~~~~~~~

>>> from nipype.workflows.fsl import create_parallelfeat_preproc
>>> import os
>>> preproc = create_parallelfeat_preproc()
>>> preproc.inputs.inputspec.func = ['f3.nii', 'f5.nii']
>>> preproc.inputs.inputspec.fwhm = 5
>>> preproc.inputs.inputspec.highpass = 128./(2*2.5)
>>> preproc.base_dir = '/tmp'
>>> preproc.run() # doctest: +SKIP

>>> preproc = create_parallelfeat_preproc(highpass=False)
>>> preproc.inputs.inputspec.func = 'f3.nii'
>>> preproc.inputs.inputspec.fwhm = 5
>>> preproc.base_dir = '/tmp'
>>> preproc.run() # doctest: +SKIP



Graph
~~~~~
.. graphviz::

	digraph featpreproc{

	  label="featpreproc";

	  featpreproc_inputspec[label="inputspec.IdentityInterface.utility"];

	  featpreproc_img2float[label="img2float.ImageMaths.fsl"];

	  featpreproc_extractref[label="extractref.ExtractROI.fsl"];

	  featpreproc_realign[label="realign.MCFLIRT.fsl"];

	  featpreproc_meanfunc[label="meanfunc.ImageMaths.fsl"];

	  featpreproc_meanfuncmask[label="meanfuncmask.BET.fsl"];

	  featpreproc_maskfunc[label="maskfunc.ImageMaths.fsl"];

	  featpreproc_getthreshold[label="getthreshold.ImageStats.fsl"];

	  featpreproc_threshold[label="threshold.ImageMaths.fsl"];

	  featpreproc_medianval[label="medianval.ImageStats.fsl"];

	  featpreproc_dilatemask[label="dilatemask.ImageMaths.fsl"];

	  featpreproc_maskfunc2[label="maskfunc2.ImageMaths.fsl"];

	  featpreproc_plot_motion[label="plot_motion.PlotMotionParams.fsl", style=filled, colorscheme=greys7 color=2];

	  featpreproc_maskfunc3[label="maskfunc3.ImageMaths.fsl"];

	  featpreproc_concat[label="concat.Merge.utility"];

	  featpreproc_select[label="select.Select.utility"];

	  featpreproc_meanscale[label="meanscale.ImageMaths.fsl"];

	  featpreproc_highpass[label="highpass.ImageMaths.fsl"];

	  featpreproc_meanfunc3[label="meanfunc3.ImageMaths.fsl"];

	  featpreproc_outputspec[label="outputspec.IdentityInterface.utility"];

	  featpreproc_inputspec -> featpreproc_select;

	  featpreproc_inputspec -> featpreproc_highpass;

	  featpreproc_inputspec -> featpreproc_img2float;

	  featpreproc_img2float -> featpreproc_realign;

	  featpreproc_img2float -> featpreproc_extractref;

	  featpreproc_img2float -> featpreproc_extractref;

	  featpreproc_extractref -> featpreproc_outputspec;

	  featpreproc_extractref -> featpreproc_realign;

	  featpreproc_realign -> featpreproc_outputspec;

	  featpreproc_realign -> featpreproc_outputspec;

	  featpreproc_realign -> featpreproc_meanfunc;

	  featpreproc_realign -> featpreproc_medianval;

	  featpreproc_realign -> featpreproc_maskfunc2;

	  featpreproc_realign -> featpreproc_maskfunc;

	  featpreproc_realign -> featpreproc_plot_motion;

	  featpreproc_meanfunc -> featpreproc_meanfuncmask;

	  featpreproc_meanfuncmask -> featpreproc_maskfunc;

	  featpreproc_maskfunc -> featpreproc_getthreshold;

	  featpreproc_maskfunc -> featpreproc_threshold;

	  featpreproc_getthreshold -> featpreproc_threshold;

	  featpreproc_threshold -> featpreproc_medianval;

	  featpreproc_threshold -> featpreproc_dilatemask;

	  featpreproc_medianval -> featpreproc_meanscale;

	  featpreproc_dilatemask -> featpreproc_maskfunc3;

	  featpreproc_dilatemask -> featpreproc_outputspec;

	  featpreproc_dilatemask -> featpreproc_maskfunc2;

	  featpreproc_maskfunc2 -> featpreproc_concat;

	  featpreproc_plot_motion -> featpreproc_outputspec;

	  subgraph cluster_featpreproc_susan_smooth {

	      label="susan_smooth";

	    featpreproc_susan_smooth_inputnode[label="inputnode.IdentityInterface.utility"];

	    featpreproc_susan_smooth_mask[label="mask.ImageMaths.fsl"];

	    featpreproc_susan_smooth_meanfunc2[label="meanfunc2.ImageMaths.fsl"];

	    featpreproc_susan_smooth_median[label="median.ImageStats.fsl"];

	    featpreproc_susan_smooth_merge[label="merge.Merge.utility"];

	    featpreproc_susan_smooth_smooth[label="smooth.SUSAN.fsl"];

	    featpreproc_susan_smooth_outputnode[label="outputnode.IdentityInterface.utility"];

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_median;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_median;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_mask;

	    featpreproc_susan_smooth_inputnode -> featpreproc_susan_smooth_mask;

	    featpreproc_susan_smooth_mask -> featpreproc_susan_smooth_meanfunc2;

	    featpreproc_susan_smooth_meanfunc2 -> featpreproc_susan_smooth_merge;

	    featpreproc_susan_smooth_median -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_median -> featpreproc_susan_smooth_merge;

	    featpreproc_susan_smooth_merge -> featpreproc_susan_smooth_smooth;

	    featpreproc_susan_smooth_smooth -> featpreproc_susan_smooth_outputnode;

	  }

	  featpreproc_maskfunc3 -> featpreproc_concat;

	  featpreproc_concat -> featpreproc_select;

	  featpreproc_select -> featpreproc_outputspec;

	  featpreproc_select -> featpreproc_meanscale;

	  featpreproc_meanscale -> featpreproc_highpass;

	  featpreproc_highpass -> featpreproc_outputspec;

	  featpreproc_highpass -> featpreproc_meanfunc3;

	  featpreproc_meanfunc3 -> featpreproc_outputspec;

	  featpreproc_susan_smooth_outputnode -> featpreproc_maskfunc3;

	  featpreproc_inputspec -> featpreproc_susan_smooth_inputnode;

	  featpreproc_dilatemask -> featpreproc_susan_smooth_inputnode;

	  featpreproc_maskfunc2 -> featpreproc_susan_smooth_inputnode;

	}

:class:`create_susan_smooth()`
------------------------------


Create a SUSAN smoothing workflow

Parameters
~~~~~~~~~~

name : name of workflow (default: susan_smooth)
separate_masks : separate masks for each run

Inputs::

    inputnode.in_files : functional runs (filename or list of filenames)
    inputnode.fwhm : fwhm for smoothing with SUSAN
    inputnode.mask_file : mask used for estimating SUSAN thresholds (but not for smoothing)

Outputs::

    outputnode.smoothed_files : functional runs (filename or list of filenames)

Example
~~~~~~~

>>> from nipype.workflows.fsl import create_susan_smooth
>>> smooth = create_susan_smooth()
>>> smooth.inputs.inputnode.in_files = 'f3.nii'
>>> smooth.inputs.inputnode.fwhm = 5
>>> smooth.inputs.inputnode.mask_file = 'mask.nii'
>>> smooth.run() # doctest: +SKIP



Graph
~~~~~
.. graphviz::

	digraph susan_smooth{

	  label="susan_smooth";

	  susan_smooth_inputnode[label="inputnode.IdentityInterface.utility"];

	  susan_smooth_mask[label="mask.ImageMaths.fsl"];

	  susan_smooth_meanfunc2[label="meanfunc2.ImageMaths.fsl"];

	  susan_smooth_median[label="median.ImageStats.fsl"];

	  susan_smooth_merge[label="merge.Merge.utility"];

	  susan_smooth_smooth[label="smooth.SUSAN.fsl"];

	  susan_smooth_outputnode[label="outputnode.IdentityInterface.utility"];

	  susan_smooth_inputnode -> susan_smooth_median;

	  susan_smooth_inputnode -> susan_smooth_median;

	  susan_smooth_inputnode -> susan_smooth_mask;

	  susan_smooth_inputnode -> susan_smooth_mask;

	  susan_smooth_inputnode -> susan_smooth_smooth;

	  susan_smooth_inputnode -> susan_smooth_smooth;

	  susan_smooth_mask -> susan_smooth_meanfunc2;

	  susan_smooth_meanfunc2 -> susan_smooth_merge;

	  susan_smooth_median -> susan_smooth_merge;

	  susan_smooth_median -> susan_smooth_smooth;

	  susan_smooth_merge -> susan_smooth_smooth;

	  susan_smooth_smooth -> susan_smooth_outputnode;

	}
