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

interfaces.spm.preprocess
=========================


.. _nipype.interfaces.spm.preprocess.ApplyDeformations:


.. index:: ApplyDeformations

ApplyDeformations
-----------------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L1162>`__

Inputs::

        [Mandatory]
        deformation_field: (an existing file name)
        in_files: (an existing file name)
        reference_volume: (an existing file name)

        [Optional]
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        paths: (a directory name)
                Paths to add to matlabpath
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs

Outputs::

        out_files: (an existing file name)

.. _nipype.interfaces.spm.preprocess.Coregister:


.. index:: Coregister

Coregister
----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L302>`__

Use spm_coreg for estimating cross-modality rigid body alignment

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=39

Examples
~~~~~~~~

>>> import nipype.interfaces.spm as spm
>>> coreg = spm.Coregister()
>>> coreg.inputs.target = 'functional.nii'
>>> coreg.inputs.source = 'structural.nii'
>>> coreg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        source: (an existing file name)
                file to register to target
        target: (an existing file name)
                reference file to register to

        [Optional]
        apply_to_files: (an existing file name)
                files to apply transformation to
        cost_function: ('mi' or 'nmi' or 'ecc' or 'ncc')
                cost function, one of: 'mi' - Mutual Information,
                 'nmi' - Normalised Mutual Information,
                 'ecc' - Entropy Correlation Coefficient,
                 'ncc' - Normalised Cross Correlation
        fwhm: (a list of from 2 to 2 items which are a float)
                gaussian smoothing kernel width (mm)
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        jobtype: ('estwrite' or 'estimate' or 'write', nipype default value:
                 estwrite)
                one of: estimate, write, estwrite
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        out_prefix: (a string, nipype default value: r)
                coregistered output prefix
        paths: (a directory name)
                Paths to add to matlabpath
        separation: (a list of items which are a float)
                sampling separation in mm
        tolerance: (a list of items which are a float)
                acceptable tolerance for each of 12 params
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        write_interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        write_mask: (a boolean)
                True/False mask output image
        write_wrap: (a list of from 3 to 3 items which are an integer)
                Check if interpolation should wrap in [x,y,z]

Outputs::

        coregistered_files: (an existing file name)
                Coregistered other files
        coregistered_source: (an existing file name)
                Coregistered source files

.. _nipype.interfaces.spm.preprocess.CreateWarped:


.. index:: CreateWarped

CreateWarped
------------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L1103>`__

Apply a flow field estimated by DARTEL to create warped images

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=202

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> create_warped = spm.CreateWarped()
>>> create_warped.inputs.image_files = ['rc1s1.nii', 'rc1s2.nii']
>>> create_warped.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s2_Template.nii']
>>> create_warped.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        flowfield_files: (an existing file name)
                DARTEL flow fields u_rc1*
        image_files: (an existing file name)
                A list of files to be warped

        [Optional]
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        iterations: (0 <= an integer <= 9)
                The number of iterations: log2(number of time steps)
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        modulate: (a boolean)
                Modulate images
        paths: (a directory name)
                Paths to add to matlabpath
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs

Outputs::

        warped_files: (a list of items which are an existing file name)

.. _nipype.interfaces.spm.preprocess.DARTEL:


.. index:: DARTEL

DARTEL
------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L924>`__

Use spm DARTEL to create a template and flow fields

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=197

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> dartel = spm.DARTEL()
>>> dartel.inputs.image_files = [['rc1s1.nii','rc1s2.nii'],['rc2s1.nii', 'rc2s2.nii']]
>>> dartel.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        image_files: (a list of items which are a list of items which are an
                 existing file name)
                A list of files to be segmented

        [Optional]
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        iteration_parameters: (a list of from 3 to 12 items which are a tuple
                 of the form: (1 <= an integer <= 10, a tuple of the form: (a float,
                 a float, a float), 1 or 2 or 4 or 8 or 16 or 32 or 64 or 128 or 256
                 or 512, 0 or 0.5 or 1 or 2 or 4 or 8 or 16 or 32))
                List of tuples for each iteration
                 - Inner iterations
                 - Regularization parameters
                 - Time points for deformation model
                 - smoothing parameter
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        optimization_parameters: (a tuple of the form: (a float, 1 <= an
                 integer <= 8, 1 <= an integer <= 8))
                Optimization settings a tuple
                 - LM regularization
                 - cycles of multigrid solver
                 - relaxation iterations
        paths: (a directory name)
                Paths to add to matlabpath
        regularization_form: ('Linear' or 'Membrane' or 'Bending')
                Form of regularization energy term
        template_prefix: (a string, nipype default value: Template)
                Prefix for template
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs

Outputs::

        dartel_flow_fields: (a list of items which are an existing file name)
                DARTEL flow fields
        final_template_file: (an existing file name)
                final DARTEL template
        template_files: (a list of items which are an existing file name)
                Templates from different stages of iteration

.. _nipype.interfaces.spm.preprocess.DARTELNorm2MNI:


.. index:: DARTELNorm2MNI

DARTELNorm2MNI
--------------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L1017>`__

Use spm DARTEL to normalize data to MNI space

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=200

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> nm = spm.DARTELNorm2MNI()
>>> nm.inputs.template_file = 'Template_6.nii'
>>> nm.inputs.flowfield_files = ['u_rc1s1_Template.nii', 'u_rc1s3_Template.nii']
>>> nm.inputs.apply_to_files = ['c1s1.nii', 'c1s3.nii']
>>> nm.inputs.modulate = True
>>> nm.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        apply_to_files: (an existing file name)
                Files to apply the transform to
        flowfield_files: (an existing file name)
                DARTEL flow fields u_rc1*
        template_file: (an existing file name)
                DARTEL template

        [Optional]
        bounding_box: (a tuple of the form: (a float, a float, a float, a
                 float, a float, a float))
                Voxel sizes for output file
        fwhm: (a list of from 3 to 3 items which are a float or a float)
                3-list of fwhm for each dimension
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        modulate: (a boolean)
                Modulate out images - no modulation preserves concentrations
        paths: (a directory name)
                Paths to add to matlabpath
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        voxel_size: (a tuple of the form: (a float, a float, a float))
                Voxel sizes for output file

Outputs::

        normalization_parameter_file: (an existing file name)
                Transform parameters to MNI space
        normalized_files: (an existing file name)
                Normalized files in MNI space

.. _nipype.interfaces.spm.preprocess.NewSegment:


.. index:: NewSegment

NewSegment
----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L697>`__

Use spm_preproc8 (New Segment) to separate structural images into different
tissue classes. Supports multiple modalities.

NOTE: This interface currently supports single channel input only

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=185

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> seg = spm.NewSegment()
>>> seg.inputs.channel_files = 'structural.nii'
>>> seg.inputs.channel_info = (0.0001, 60, (True, True))
>>> seg.run() # doctest: +SKIP

For VBM pre-processing [http://www.fil.ion.ucl.ac.uk/~john/misc/VBMclass10.pdf],
TPM.nii should be replaced by /path/to/spm8/toolbox/Seg/TPM.nii

>>> seg = NewSegment()
>>> seg.inputs.channel_files = 'structural.nii'
>>> tissue1 = (('TPM.nii', 1), 2, (True,True), (False, False))
>>> tissue2 = (('TPM.nii', 2), 2, (True,True), (False, False))
>>> tissue3 = (('TPM.nii', 3), 2, (True,False), (False, False))
>>> tissue4 = (('TPM.nii', 4), 2, (False,False), (False, False))
>>> tissue5 = (('TPM.nii', 5), 2, (False,False), (False, False))
>>> seg.inputs.tissues = [tissue1, tissue2, tissue3, tissue4, tissue5]
>>> seg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        channel_files: (an existing file name)
                A list of files to be segmented

        [Optional]
        affine_regularization: ('mni' or 'eastern' or 'subj' or 'none')
                mni, eastern, subj, none
        channel_info: (a tuple of the form: (a float, a float, a tuple of the
                 form: (a boolean, a boolean)))
                A tuple with the following fields:
                 - bias reguralisation (0-10)
                 - FWHM of Gaussian smoothness of bias
                 - which maps to save (Corrected, Field) - a tuple of two boolean
                values
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        paths: (a directory name)
                Paths to add to matlabpath
        sampling_distance: (a float)
                Sampling distance on data for parameter estimation
        tissues: (a list of items which are a tuple of the form: (a tuple of
                 the form: (an existing file name, an integer), an integer, a tuple
                 of the form: (a boolean, a boolean), a tuple of the form: (a
                 boolean, a boolean)))
                A list of tuples (one per tissue) with the following fields:
                 - tissue probability map (4D), 1-based index to frame
                 - number of gaussians
                 - which maps to save [Native, DARTEL] - a tuple of two boolean
                values
                 - which maps to save [Unmodulated, Modulated] - a tuple of two
                boolean values
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        warping_regularization: (a float)
                Aproximate distance between sampling points.
        write_deformation_fields: (a list of from 2 to 2 items which are a
                 boolean)
                Which deformation fields to write:[Inverse, Forward]

Outputs::

        bias_corrected_images: (an existing file name)
                bias corrected images
        bias_field_images: (an existing file name)
                bias field images
        dartel_input_images: (a list of items which are a list of items which
                 are an existing file name)
                dartel imported class images
        forward_deformation_field: (an existing file name)
        inverse_deformation_field: (an existing file name)
        modulated_class_images: (a list of items which are a list of items
                 which are an existing file name)
                modulated+normalized class images
        native_class_images: (a list of items which are a list of items which
                 are an existing file name)
                native space probability maps
        normalized_class_images: (a list of items which are a list of items
                 which are an existing file name)
                normalized class images
        transformation_mat: (an existing file name)
                Normalization transformation

.. _nipype.interfaces.spm.preprocess.Normalize:


.. index:: Normalize

Normalize
---------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L428>`__

use spm_normalise for warping an image to a template

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=51

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> norm = spm.Normalize()
>>> norm.inputs.source = 'functional.nii'
>>> norm.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        parameter_file: (a file name)
                normalization parameter file*_sn.mat
                mutually_exclusive: source, template
        source: (an existing file name)
                file to normalize to template
                mutually_exclusive: parameter_file
        template: (an existing file name)
                template file to normalize to
                mutually_exclusive: parameter_file

        [Optional]
        DCT_period_cutoff: (a float)
                Cutoff of for DCT bases (opt)
        affine_regularization_type: ('mni' or 'size' or 'none')
                mni, size, none (opt)
        apply_to_files: (an existing file name or a list of items which are
                 an existing file name)
                files to apply transformation to (opt)
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        jobtype: ('estwrite' or 'est' or 'write', nipype default value:
                 estwrite)
                one of: est, write, estwrite (opt, estwrite)
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        nonlinear_iterations: (an integer)
                Number of iterations of nonlinear warping (opt)
        nonlinear_regularization: (a float)
                the amount of the regularization for the nonlinear part of the
                normalization (opt)
        out_prefix: (a string, nipype default value: w)
                normalized output prefix
        paths: (a directory name)
                Paths to add to matlabpath
        source_image_smoothing: (a float)
                source smoothing (opt)
        source_weight: (a file name)
                name of weighting image for source (opt)
        template_image_smoothing: (a float)
                template smoothing (opt)
        template_weight: (a file name)
                name of weighting image for template (opt)
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        write_bounding_box: (a list of from 2 to 2 items which are a list of
                 from 3 to 3 items which are a float)
                3x2-element list of lists (opt)
        write_interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        write_preserve: (a boolean)
                True/False warped images are modulated (opt,)
        write_voxel_sizes: (a list of from 3 to 3 items which are a float)
                3-element list (opt)
        write_wrap: (a list of items which are an integer)
                Check if interpolation should wrap in [x,y,z] - list of bools (opt)

Outputs::

        normalization_parameters: (an existing file name)
                MAT files containing the normalization parameters
        normalized_files: (an existing file name)
                Normalized other files
        normalized_source: (an existing file name)
                Normalized source files

.. _nipype.interfaces.spm.preprocess.Realign:


.. index:: Realign

Realign
-------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L168>`__

Use spm_realign for estimating within modality rigid body alignment

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=25

Examples
~~~~~~~~

>>> import nipype.interfaces.spm as spm
>>> realign = spm.Realign()
>>> realign.inputs.in_files = 'functional.nii'
>>> realign.inputs.register_to_mean = True
>>> realign.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_files: (a list of items which are an existing file name or an
                 existing file name)
                list of filenames to realign
        register_to_mean: (a boolean, nipype default value: True)
                Indicate whether realignment is done to the mean image

        [Optional]
        fwhm: (a floating point number >= 0.0)
                gaussian smoothing kernel width
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        jobtype: ('estwrite' or 'estimate' or 'write', nipype default value:
                 estwrite)
                one of: estimate, write, estwrite
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        out_prefix: (a string, nipype default value: r)
                realigned output prefix
        paths: (a directory name)
                Paths to add to matlabpath
        quality: (0.0 <= a floating point number <= 1.0)
                0.1 = fast, 1.0 = precise
        separation: (a floating point number >= 0.0)
                sampling separation in mm
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        weight_img: (an existing file name)
                filename of weighting image
        wrap: (a list of from 3 to 3 items which are an integer)
                Check if interpolation should wrap in [x,y,z]
        write_interp: (0 <= an integer <= 7)
                degree of b-spline used for interpolation
        write_mask: (a boolean)
                True/False mask output image
        write_which: (a list of items which are a value of type 'int', nipype
                 default value: [2, 1])
                determines which images to reslice
        write_wrap: (a list of from 3 to 3 items which are an integer)
                Check if interpolation should wrap in [x,y,z]

Outputs::

        mean_image: (an existing file name)
                Mean image file from the realignment
        modified_in_files: (a list of items which are an existing file name
                 or an existing file name)
                Copies of all files passed to in_files. Headers will have been
                modified to align all images with the first, or optionally to first
                do that, extract a mean image, and re-align to that mean image.
        realigned_files: (a list of items which are an existing file name or
                 an existing file name)
                If jobtype is write or estwrite, these will be the resliced files.
                Otherwise, they will be copies of in_files that have had their
                headers rewritten.
        realignment_parameters: (an existing file name)
                Estimated translation and rotation parameters

.. _nipype.interfaces.spm.preprocess.Segment:


.. index:: Segment

Segment
-------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L588>`__

use spm_segment to separate structural images into different
tissue classes.

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=43

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> seg = spm.Segment()
>>> seg.inputs.data = 'structural.nii'
>>> seg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        data: (an existing file name)
                one scan per subject

        [Optional]
        affine_regularization: ('mni' or 'eastern' or 'subj' or 'none' or '')
                Possible options: "mni", "eastern", "subj", "none" (no
                reguralisation), "" (no affine registration)
        bias_fwhm: (30 or 40 or 50 or 60 or 70 or 80 or 90 or 100 or 110 or
                 120 or 130 or 'Inf')
                FWHM of Gaussian smoothness of bias
        bias_regularization: (0 or 1e-05 or 0.0001 or 0.001 or 0.01 or 0.1 or
                 1 or 10)
                no(0) - extremely heavy (10)
        clean_masks: ('no' or 'light' or 'thorough')
                clean using estimated brain mask ('no','light','thorough')
        csf_output_type: (a list of from 3 to 3 items which are a boolean)
                Options to produce CSF images: c3*.img, wc3*.img and mwc3*.img.
                 None: [False,False,False],
                 Native Space: [False,False,True],
                 Unmodulated Normalised: [False,True,False],
                 Modulated Normalised: [True,False,False],
                 Native + Unmodulated Normalised: [False,True,True],
                 Native + Modulated Normalised: [True,False,True],
                 Native + Modulated + Unmodulated: [True,True,True],
                 Modulated + Unmodulated Normalised: [True,True,False]
        gaussians_per_class: (a list of items which are an integer)
                num Gaussians capture intensity distribution
        gm_output_type: (a list of from 3 to 3 items which are a boolean)
                Options to produce grey matter images: c1*.img, wc1*.img and
                mwc1*.img.
                 None: [False,False,False],
                 Native Space: [False,False,True],
                 Unmodulated Normalised: [False,True,False],
                 Modulated Normalised: [True,False,False],
                 Native + Unmodulated Normalised: [False,True,True],
                 Native + Modulated Normalised: [True,False,True],
                 Native + Modulated + Unmodulated: [True,True,True],
                 Modulated + Unmodulated Normalised: [True,True,False]
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        mask_image: (an existing file name)
                Binary image to restrict parameter estimation
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        paths: (a directory name)
                Paths to add to matlabpath
        sampling_distance: (a float)
                Sampling distance on data for parameter estimation
        save_bias_corrected: (a boolean)
                True/False produce a bias corrected image
        tissue_prob_maps: (a list of items which are an existing file name)
                list of gray, white & csf prob. (opt,)
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        warp_frequency_cutoff: (a float)
                Cutoff of DCT bases
        warping_regularization: (a float)
                Controls balance between parameters and data
        wm_output_type: (a list of from 3 to 3 items which are a boolean)
                Options to produce white matter images: c2*.img, wc2*.img and
                mwc2*.img.
                 None: [False,False,False],
                 Native Space: [False,False,True],
                 Unmodulated Normalised: [False,True,False],
                 Modulated Normalised: [True,False,False],
                 Native + Unmodulated Normalised: [False,True,True],
                 Native + Modulated Normalised: [True,False,True],
                 Native + Modulated + Unmodulated: [True,True,True],
                 Modulated + Unmodulated Normalised: [True,True,False]

Outputs::

        bias_corrected_image: (a file name)
                bias-corrected version of input image
        inverse_transformation_mat: (an existing file name)
                Inverse normalization info
        modulated_csf_image: (a file name)
                modulated, normalized csf probability map
        modulated_gm_image: (a file name)
                modulated, normalized grey probability map
        modulated_input_image: (a file name)
                bias-corrected version of input image
        modulated_wm_image: (a file name)
                modulated, normalized white probability map
        native_csf_image: (a file name)
                native space csf probability map
        native_gm_image: (a file name)
                native space grey probability map
        native_wm_image: (a file name)
                native space white probability map
        normalized_csf_image: (a file name)
                normalized csf probability map
        normalized_gm_image: (a file name)
                normalized grey probability map
        normalized_wm_image: (a file name)
                normalized white probability map
        transformation_mat: (an existing file name)
                Normalization transformation

.. _nipype.interfaces.spm.preprocess.SliceTiming:


.. index:: SliceTiming

SliceTiming
-----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L63>`__

Use spm to perform slice timing correction.

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=19

Examples
~~~~~~~~

>>> from nipype.interfaces.spm import SliceTiming
>>> st = SliceTiming()
>>> st.inputs.in_files = 'functional.nii'
>>> st.inputs.num_slices = 32
>>> st.inputs.time_repetition = 6.0
>>> st.inputs.time_acquisition = 6. - 6./32.
>>> st.inputs.slice_order = range(32,0,-1)
>>> st.inputs.ref_slice = 1
>>> st.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_files: (a list of items which are an existing file name or an
                 existing file name)
                list of filenames to apply slice timing
        num_slices: (an integer)
                number of slices in a volume
        ref_slice: (an integer)
                1-based Number of the reference slice
        slice_order: (a list of items which are an integer)
                1-based order in which slices are acquired
        time_acquisition: (a float)
                time of volume acquisition. usually calculated as TR-(TR/num_slices)
        time_repetition: (a float)
                time between volume acquisitions (start to start time)

        [Optional]
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        out_prefix: (a string, nipype default value: a)
                slicetimed output prefix
        paths: (a directory name)
                Paths to add to matlabpath
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs

Outputs::

        timecorrected_files: (a list of items which are an existing file name
                 or an existing file name)
                slice time corrected files

.. _nipype.interfaces.spm.preprocess.Smooth:


.. index:: Smooth

Smooth
------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L838>`__

Use spm_smooth for 3D Gaussian smoothing of image volumes.

http://www.fil.ion.ucl.ac.uk/spm/doc/manual.pdf#page=57

Examples
~~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> smooth = spm.Smooth()
>>> smooth.inputs.in_files = 'functional.nii'
>>> smooth.inputs.fwhm = [4, 4, 4]
>>> smooth.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_files: (an existing file name)
                list of files to smooth

        [Optional]
        data_type: (an integer)
                Data type of the output images (opt)
        fwhm: (a list of from 3 to 3 items which are a float or a float)
                3-list of fwhm for each dimension (opt)
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        implicit_masking: (a boolean)
                A mask implied by a particular voxel value
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        out_prefix: (a string, nipype default value: s)
                smoothed output prefix
        paths: (a directory name)
                Paths to add to matlabpath
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs

Outputs::

        smoothed_files: (an existing file name)
                smoothed files

.. _nipype.interfaces.spm.preprocess.VBMSegment:


.. index:: VBMSegment

VBMSegment
----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/spm/preprocess.py#L1328>`__

Use VBM8 toolbox to separate structural images into different
tissue classes.

Example
~~~~~~~
>>> import nipype.interfaces.spm as spm
>>> seg = spm.VBMSegment()
>>> seg.inputs.tissues = 'TPM.nii'
>>> seg.inputs.dartel_template = 'Template_1_IXI550_MNI152.nii'
>>> seg.inputs.bias_corrected_native = True
>>> seg.inputs.gm_native = True
>>> seg.inputs.wm_native = True
>>> seg.inputs.csf_native = True
>>> seg.inputs.pve_label_native = True
>>> seg.inputs.deformation_field = (True, False)
>>> seg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_files: (an existing file name)
                A list of files to be segmented

        [Optional]
        bias_corrected_affine: (a boolean, nipype default value: False)
        bias_corrected_native: (a boolean, nipype default value: False)
        bias_corrected_normalized: (a boolean, nipype default value: True)
        bias_fwhm: (30 or 40 or 50 or 60 or 70 or 80 or 90 or 100 or 110 or
                 120 or 130 or 'Inf', nipype default value: 60)
                FWHM of Gaussian smoothness of bias
        bias_regularization: (0 or 1e-05 or 0.0001 or 0.001 or 0.01 or 0.1 or
                 1 or 10, nipype default value: 0.0001)
                no(0) - extremely heavy (10)
        cleanup_partitions: (an integer, nipype default value: 1)
                0=None,1=light,2=thorough
        csf_dartel: (0 <= an integer <= 2, nipype default value: 0)
                0=None,1=rigid(SPM8 default),2=affine
        csf_modulated_normalized: (0 <= an integer <= 2, nipype default
                 value: 2)
                0=none,1=affine+non-linear(SPM8 default),2=non-linear only
        csf_native: (a boolean, nipype default value: False)
        csf_normalized: (a boolean, nipype default value: False)
        dartel_template: (an existing file name)
        deformation_field: (a tuple of the form: (a boolean, a boolean),
                 nipype default value: (0, 0))
                forward and inverse field
        display_results: (a boolean, nipype default value: True)
        gaussians_per_class: (a tuple of the form: (an integer, an integer,
                 an integer, an integer, an integer, an integer), nipype default
                 value: (2, 2, 2, 3, 4, 2))
                number of gaussians for each tissue class
        gm_dartel: (0 <= an integer <= 2, nipype default value: 0)
                0=None,1=rigid(SPM8 default),2=affine
        gm_modulated_normalized: (0 <= an integer <= 2, nipype default value:
                 2)
                0=none,1=affine+non-linear(SPM8 default),2=non-linear only
        gm_native: (a boolean, nipype default value: False)
        gm_normalized: (a boolean, nipype default value: False)
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        jacobian_determinant: (a boolean, nipype default value: False)
        matlab_cmd: (a string)
                matlab command to use
        mfile: (a boolean, nipype default value: True)
                Run m-code using m-file
        mrf_weighting: (a float, nipype default value: 0.15)
        paths: (a directory name)
                Paths to add to matlabpath
        pve_label_dartel: (0 <= an integer <= 2, nipype default value: 0)
                0=None,1=rigid(SPM8 default),2=affine
        pve_label_native: (a boolean, nipype default value: False)
        pve_label_normalized: (a boolean, nipype default value: False)
        sampling_distance: (a float, nipype default value: 3)
                Sampling distance on data for parameter estimation
        spatial_normalization: ('high' or 'low', nipype default value: high)
        tissues: (an existing file name)
                tissue probability map
        use_mcr: (a boolean)
                Run m-code using SPM MCR
        use_sanlm_denoising_filter: (0 <= an integer <= 2, nipype default
                 value: 2)
                0=No denoising, 1=denoising,2=denoising multi-threaded
        use_v8struct: (a boolean, nipype default value: True)
                Generate SPM8 and higher compatible jobs
        warping_regularization: (a float, nipype default value: 4)
                Controls balance between parameters and data
        wm_dartel: (0 <= an integer <= 2, nipype default value: 0)
                0=None,1=rigid(SPM8 default),2=affine
        wm_modulated_normalized: (0 <= an integer <= 2, nipype default value:
                 2)
                0=none,1=affine+non-linear(SPM8 default),2=non-linear only
        wm_native: (a boolean, nipype default value: False)
        wm_normalized: (a boolean, nipype default value: False)

Outputs::

        bias_corrected_images: (an existing file name)
                bias corrected images
        dartel_input_images: (a list of items which are a list of items which
                 are an existing file name)
                dartel imported class images
        forward_deformation_field: (an existing file name)
        inverse_deformation_field: (an existing file name)
        jacobian_determinant_images: (an existing file name)
        modulated_class_images: (a list of items which are a list of items
                 which are an existing file name)
                modulated+normalized class images
        native_class_images: (a list of items which are a list of items which
                 are an existing file name)
                native space probability maps
        normalized_bias_corrected_images: (an existing file name)
                bias corrected images
        normalized_class_images: (a list of items which are a list of items
                 which are an existing file name)
                normalized class images
        pve_label_native_images: (an existing file name)
        pve_label_normalized_images: (an existing file name)
        pve_label_registered_images: (an existing file name)
        transformation_mat: (an existing file name)
                Normalization transformation
