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

interfaces.fsl.utils
====================


.. _nipype.interfaces.fsl.utils.AvScale:


.. index:: AvScale

AvScale
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L833>`__

Wraps the executable command ``avscale``.

Use FSL avscale command to extract info from mat file output of FLIRT

Examples
~~~~~~~~

>>> avscale = AvScale()
>>> avscale.inputs.mat_file = 'flirt.mat'
>>> res = avscale.run()  # doctest: +SKIP

Inputs::

        [Optional]
        ref_file: (an existing file name)
                reference file to get center of rotation
                argument: ``%s``, position: -1
        mat_file: (an existing file name)
                mat file to read
                argument: ``%s``, position: -2
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        all_param: (a boolean)
                argument: ``--allparams``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``

Outputs::

        average_scaling: (a float)
                Average Scaling
        determinant: (a float)
                Determinant
        backward_half_transform: (a list of items which are a list of items
                  which are a float)
                Backwards Half Transform
        forward_half_transform: (a list of items which are a list of items
                  which are a float)
                Forward Half Transform
        scales: (a list of items which are a float)
                Scales (x,y,z)
        translations: (a list of items which are a float)
                translations
        rot_angles: (a list of items which are a float)
                rotation angles
        left_right_orientation_preserved: (a boolean)
                True if LR orientation preserved
        skews: (a list of items which are a float)
                Skews
        rotation_translation_matrix: (a list of items which are a list of
                  items which are a float)
                Rotation and Translation Matrix

.. _nipype.interfaces.fsl.utils.Complex:


.. index:: Complex

Complex
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1941>`__

Wraps the executable command ``fslcomplex``.

fslcomplex is a tool for converting complex data

Examples
~~~~~~~~

>>> cplx = Complex()
>>> cplx.inputs.complex_in_file = "complex.nii"
>>> cplx.real_polar = True
>>> res = cplx.run() # doctest: +SKIP

Inputs::

        [Optional]
        real_cartesian: (a boolean)
                argument: ``-realcartesian``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        end_vol: (an integer (int or long))
                argument: ``%d``, position: -1
        complex_split: (a boolean)
                argument: ``-complexsplit``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        start_vol: (an integer (int or long))
                argument: ``%d``, position: -2
        complex_cartesian: (a boolean)
                argument: ``-complex``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        real_polar: (a boolean)
                argument: ``-realpolar``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        imaginary_out_file: (a file name)
                argument: ``%s``, position: -3
                mutually_exclusive: complex_out_file, magnitude_out_file,
                  phase_out_file, real_polar, complex_cartesian, complex_polar,
                  complex_split, complex_merge
        phase_out_file: (a file name)
                argument: ``%s``, position: -3
                mutually_exclusive: complex_out_file, real_out_file,
                  imaginary_out_file, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        complex_merge: (a boolean)
                argument: ``-complexmerge``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge, start_vol, end_vol
        magnitude_out_file: (a file name)
                argument: ``%s``, position: -4
                mutually_exclusive: complex_out_file, real_out_file,
                  imaginary_out_file, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        complex_in_file: (an existing file name)
                argument: ``%s``, position: 2
        magnitude_in_file: (an existing file name)
                argument: ``%s``, position: 2
        complex_out_file: (a file name)
                argument: ``%s``, position: -3
                mutually_exclusive: complex_out_file, magnitude_out_file,
                  phase_out_file, real_out_file, imaginary_out_file, real_polar,
                  real_cartesian
        real_in_file: (an existing file name)
                argument: ``%s``, position: 2
        complex_polar: (a boolean)
                argument: ``-complexpolar``, position: 1
                mutually_exclusive: real_polar, real_cartesian, complex_cartesian,
                  complex_polar, complex_split, complex_merge
        real_out_file: (a file name)
                argument: ``%s``, position: -4
                mutually_exclusive: complex_out_file, magnitude_out_file,
                  phase_out_file, real_polar, complex_cartesian, complex_polar,
                  complex_split, complex_merge
        imaginary_in_file: (an existing file name)
                argument: ``%s``, position: 3
        complex_in_file2: (an existing file name)
                argument: ``%s``, position: 3
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        phase_in_file: (an existing file name)
                argument: ``%s``, position: 3
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        magnitude_out_file: (a file name)
        phase_out_file: (a file name)
        real_out_file: (a file name)
        imaginary_out_file: (a file name)
        complex_out_file: (a file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ConvertWarp:


.. index:: ConvertWarp

ConvertWarp
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2286>`__

Wraps the executable command ``convertwarp``.

Use FSL `convertwarp <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/fnirt/warp_utils.html>`_
for combining multiple transforms into one.


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import ConvertWarp
>>> warputils = ConvertWarp()
>>> warputils.inputs.warp1 = "warpfield.nii"
>>> warputils.inputs.reference = "T1.nii"
>>> warputils.inputs.relwarp = True
>>> warputils.inputs.output_type = "NIFTI_GZ"
>>> warputils.cmdline # doctest: +ELLIPSIS
'convertwarp --ref=T1.nii --rel --warp1=warpfield.nii --out=T1_concatwarp.nii.gz'
>>> res = warputils.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        reference: (an existing file name)
                Name of a file in target space of the full transform.
                argument: ``--ref=%s``, position: 1

        [Optional]
        jacobian_max: (a float)
                Maximum acceptable Jacobian value for constraint (default 100.0)
                argument: ``--jmax=%f``
        out_file: (a file name)
                Name of output file, containing warps that are the combination of
                all those given as arguments. The format of this will be a field-
                file (rather than spline coefficients) with any affine components
                included.
                argument: ``--out=%s``, position: -1
        warp2: (an existing file name)
                Name of file containing secondary warp-fields/coefficients (after
                warp1/midmat but before postmat). This could e.g. be a fnirt-
                transform from the average of a group of subjects to some standard
                space (e.g. MNI152).
                argument: ``--warp2=%s``
        warp1: (an existing file name)
                Name of file containing initial warp-fields/coefficients (follows
                premat). This could e.g. be a fnirt-transform from a subjects
                structural scan to an average of a group of subjects.
                argument: ``--warp1=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        midmat: (an existing file name)
                Name of file containing mid-warp-affine transform
                argument: ``--midmat=%s``
        shift_direction: (u'y-' or u'y' or u'x' or u'x-' or u'z' or u'z-')
                Indicates the direction that the distortions from --shiftmap goes.
                It depends on the direction and polarity of the phase-encoding in
                the EPI sequence.
                argument: ``--shiftdir=%s``
                requires: shift_in_file
        out_abswarp: (a boolean)
                If set it indicates that the warps in --out should be absolute, i.e.
                the values in --out are displacements from the coordinates in --ref.
                argument: ``--absout``
                mutually_exclusive: out_relwarp
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        premat: (an existing file name)
                filename for pre-transform (affine matrix)
                argument: ``--premat=%s``
        out_relwarp: (a boolean)
                If set it indicates that the warps in --out should be relative, i.e.
                the values in --out are displacements from the coordinates in --ref.
                argument: ``--relout``
                mutually_exclusive: out_abswarp
        cons_jacobian: (a boolean)
                Constrain the Jacobian of the warpfield to lie within specified
                min/max limits.
                argument: ``--constrainj``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        jacobian_min: (a float)
                Minimum acceptable Jacobian value for constraint (default 0.01)
                argument: ``--jmin=%f``
        relwarp: (a boolean)
                If set it indicates that the warps in --warp1/2 should be
                interpreted as relative. I.e. the values in --warp1/2 are
                displacements from the coordinates in the next space.
                argument: ``--rel``
                mutually_exclusive: abswarp
        abswarp: (a boolean)
                If set it indicates that the warps in --warp1 and --warp2 should be
                interpreted as absolute. I.e. the values in --warp1/2 are the
                coordinates in the next space, rather than displacements. This flag
                is ignored if --warp1/2 was created by fnirt, which always creates
                relative displacements.
                argument: ``--abs``
                mutually_exclusive: relwarp
        shift_in_file: (an existing file name)
                Name of file containing a "shiftmap", a non-linear transform with
                displacements only in one direction (applied first, before premat).
                This would typically be a fieldmap that has been pre-processed using
                fugue that maps a subjects functional (EPI) data onto an undistorted
                space (i.e. a space that corresponds to his/her true anatomy).
                argument: ``--shiftmap=%s``
        postmat: (an existing file name)
                Name of file containing an affine transform (applied last). It could
                e.g. be an affine transform that maps the MNI152-space into a better
                approximation to the Talairach-space (if indeed there is one).
                argument: ``--postmat=%s``

Outputs::

        out_file: (an existing file name)
                Name of output file, containing the warp as field or coefficients.

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ConvertXFM:


.. index:: ConvertXFM

ConvertXFM
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1489>`__

Wraps the executable command ``convert_xfm``.

Use the FSL utility convert_xfm to modify FLIRT transformation matrices.

Examples
~~~~~~~~

>>> import nipype.interfaces.fsl as fsl
>>> invt = fsl.ConvertXFM()
>>> invt.inputs.in_file = "flirt.mat"
>>> invt.inputs.invert_xfm = True
>>> invt.inputs.out_file = 'flirt_inv.mat'
>>> invt.cmdline
'convert_xfm -omat flirt_inv.mat -inverse flirt.mat'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input transformation matrix
                argument: ``%s``, position: -1

        [Optional]
        out_file: (a file name)
                final transformation matrix
                argument: ``-omat %s``, position: 1
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        in_file2: (an existing file name)
                second input matrix (for use with fix_scale_skew or concat_xfm)
                argument: ``%s``, position: -2
        fix_scale_skew: (a boolean)
                use secondary matrix to fix scale and skew
                argument: ``-fixscaleskew``, position: -3
                mutually_exclusive: invert_xfm, concat_xfm, fix_scale_skew
                requires: in_file2
        invert_xfm: (a boolean)
                invert input transformation
                argument: ``-inverse``, position: -3
                mutually_exclusive: invert_xfm, concat_xfm, fix_scale_skew
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        concat_xfm: (a boolean)
                write joint transformation of two input matrices
                argument: ``-concat``, position: -3
                mutually_exclusive: invert_xfm, concat_xfm, fix_scale_skew
                requires: in_file2

Outputs::

        out_file: (an existing file name)
                output transformation matrix

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.CopyGeom:


.. index:: CopyGeom

CopyGeom
--------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L56>`__

Wraps the executable command ``fslcpgeom``.

Use fslcpgeom to copy the header geometry information to another image.
Copy certain parts of the header information (image dimensions, voxel
dimensions, voxel dimensions units string, image orientation/origin or
qform/sform info) from one image to another. Note that only copies from
Analyze to Analyze or Nifti to Nifti will work properly. Copying from
different files will result in loss of information or potentially incorrect
settings.

Inputs::

        [Mandatory]
        dest_file: (an existing file name)
                destination image
                argument: ``%s``, position: 1
        in_file: (an existing file name)
                source image
                argument: ``%s``, position: 0

        [Optional]
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        ignore_dims: (a boolean)
                Do not copy image dimensions
                argument: ``-d``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_file: (an existing file name)
                image with new geometry header

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ExtractROI:


.. index:: ExtractROI

ExtractROI
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L438>`__

Wraps the executable command ``fslroi``.

Uses FSL Fslroi command to extract region of interest (ROI)
from an image.

You can a) take a 3D ROI from a 3D data set (or if it is 4D, the
same ROI is taken from each time point and a new 4D data set is
created), b) extract just some time points from a 4D data set, or
c) control time and space limits to the ROI.  Note that the
arguments are minimum index and size (not maximum index).  So to
extract voxels 10 to 12 inclusive you would specify 10 and 3 (not
10 and 12).


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import ExtractROI
>>> from nipype.testing import anatfile
>>> fslroi = ExtractROI(in_file=anatfile, roi_file='bar.nii', t_min=0,
...                     t_size=1)
>>> fslroi.cmdline == 'fslroi %s bar.nii 0 1' % anatfile
True

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file
                argument: ``%s``, position: 0

        [Optional]
        z_size: (an integer (int or long))
                argument: ``%d``, position: 7
        crop_list: (a list of items which are a tuple of the form: (an
                  integer (int or long), an integer (int or long)))
                list of two tuples specifying crop options
                argument: ``%s``, position: 2
                mutually_exclusive: x_min, x_size, y_min, y_size, z_min, z_size,
                  t_min, t_size
        t_min: (an integer (int or long))
                argument: ``%d``, position: 8
        y_min: (an integer (int or long))
                argument: ``%d``, position: 4
        y_size: (an integer (int or long))
                argument: ``%d``, position: 5
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        z_min: (an integer (int or long))
                argument: ``%d``, position: 6
        t_size: (an integer (int or long))
                argument: ``%d``, position: 9
        x_size: (an integer (int or long))
                argument: ``%d``, position: 3
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        x_min: (an integer (int or long))
                argument: ``%d``, position: 2
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        roi_file: (a file name)
                output file
                argument: ``%s``, position: 1

Outputs::

        roi_file: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.FilterRegressor:


.. index:: FilterRegressor

FilterRegressor
---------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L680>`__

Wraps the executable command ``fsl_regfilt``.

Data de-noising by regressing out part of a design matrix

Uses simple OLS regression on 4D images

Inputs::

        [Mandatory]
        filter_columns: (a list of items which are an integer (int or long))
                (1-based) column indices to filter out of the data
                argument: ``-f '%s'``, position: 4
                mutually_exclusive: filter_all
        design_file: (an existing file name)
                name of the matrix with time courses (e.g. GLM design or MELODIC
                mixing matrix)
                argument: ``-d %s``, position: 3
        filter_all: (a boolean)
                use all columns in the design file in denoising
                argument: ``-f '%s'``, position: 4
                mutually_exclusive: filter_columns
        in_file: (an existing file name)
                input file name (4D image)
                argument: ``-i %s``, position: 1

        [Optional]
        var_norm: (a boolean)
                perform variance-normalization on data
                argument: ``--vn``
        out_file: (a file name)
                output file name for the filtered data
                argument: ``-o %s``, position: 2
        out_vnscales: (a boolean)
                output scaling factors for variance normalization
                argument: ``--out_vnscales``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        mask: (an existing file name)
                mask image file name
                argument: ``-m %s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_file: (an existing file name)
                output file name for the filtered data

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ImageMaths:


.. index:: ImageMaths

ImageMaths
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L590>`__

Wraps the executable command ``fslmaths``.

Use FSL fslmaths command to allow mathematical manipulation of images
`FSL info <http://www.fmrib.ox.ac.uk/fslcourse/lectures/practicals/intro/index.htm#fslutils>`_


Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> from nipype.testing import anatfile
>>> maths = fsl.ImageMaths(in_file=anatfile, op_string= '-add 5',
...                        out_file='foo_maths.nii')
>>> maths.cmdline == 'fslmaths %s -add 5 foo_maths.nii' % anatfile
True

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                argument: ``%s``, position: 1

        [Optional]
        op_string: (a unicode string)
                string defining the operation, i. e. -add
                argument: ``%s``, position: 2
        out_data_type: (u'char' or u'short' or u'int' or u'float' or
                  u'double' or u'input')
                output datatype, one of (char, short, int, float, double, input)
                argument: ``-odt %s``, position: -1
        out_file: (a file name)
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        in_file2: (an existing file name)
                argument: ``%s``, position: 3
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        mask_file: (an existing file name)
                use (following image>0) to mask current image
                argument: ``-mas %s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        suffix: (a unicode string)
                out_file suffix

Outputs::

        out_file: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ImageMeants:


.. index:: ImageMeants

ImageMeants
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L164>`__

Wraps the executable command ``fslmeants``.

Use fslmeants for printing the average timeseries (intensities) to
the screen (or saves to a file). The average is taken over all voxels
in the mask (or all voxels in the image if no mask is specified)

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file for computing the average timeseries
                argument: ``-i %s``, position: 0

        [Optional]
        use_mm: (a boolean)
                use mm instead of voxel coordinates (for -c option)
                argument: ``--usemm``
        nobin: (a boolean)
                do not binarise the mask for calculation of Eigenvariates
                argument: ``--no_bin``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        out_file: (a file name)
                name of output text matrix
                argument: ``-o %s``
        mask: (an existing file name)
                input 3D mask
                argument: ``-m %s``
        show_all: (a boolean)
                show all voxel time series (within mask) instead of averaging
                argument: ``--showall``
        transpose: (a boolean)
                output results in transpose format (one row per voxel/mean)
                argument: ``--transpose``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        eig: (a boolean)
                calculate Eigenvariate(s) instead of mean (output will have 0 mean)
                argument: ``--eig``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        order: (an integer (int or long), nipype default value: 1)
                select number of Eigenvariates
                argument: ``--order=%d``
        spatial_coord: (a list of items which are an integer (int or long))
                <x y z> requested spatial coordinate (instead of mask)
                argument: ``-c %s``

Outputs::

        out_file: (an existing file name)
                path/name of output text matrix

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.ImageStats:


.. index:: ImageStats

ImageStats
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L746>`__

Wraps the executable command ``fslstats``.

Use FSL fslstats command to calculate stats from images
`FSL info
<http://www.fmrib.ox.ac.uk/fslcourse/lectures/practicals/intro/index.htm#fslutils>`_


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import ImageStats
>>> from nipype.testing import funcfile
>>> stats = ImageStats(in_file=funcfile, op_string= '-M')
>>> stats.cmdline == 'fslstats %s -M'%funcfile
True

Inputs::

        [Mandatory]
        op_string: (a unicode string)
                string defining the operation, options are applied in order, e.g. -M
                -l 10 -M will report the non-zero mean, apply a threshold and then
                report the new nonzero mean
                argument: ``%s``, position: 3
        in_file: (an existing file name)
                input file to generate stats of
                argument: ``%s``, position: 2

        [Optional]
        split_4d: (a boolean)
                give a separate output line for each 3D volume of a 4D timeseries
                argument: ``-t``, position: 1
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        mask_file: (an existing file name)
                mask file used for option -k %s
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_stat: (any value)
                stats output

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.InvWarp:


.. index:: InvWarp

InvWarp
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1818>`__

Wraps the executable command ``invwarp``.

Use FSL Invwarp to invert a FNIRT warp


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import InvWarp
>>> invwarp = InvWarp()
>>> invwarp.inputs.warp = "struct2mni.nii"
>>> invwarp.inputs.reference = "anatomical.nii"
>>> invwarp.inputs.output_type = "NIFTI_GZ"
>>> invwarp.cmdline
'invwarp --out=struct2mni_inverse.nii.gz --ref=anatomical.nii --warp=struct2mni.nii'
>>> res = invwarp.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        warp: (an existing file name)
                Name of file containing warp-coefficients/fields. This would
                typically be the output from the --cout switch of fnirt (but can
                also use fields, like the output from --fout).
                argument: ``--warp=%s``
        reference: (an existing file name)
                Name of a file in target space. Note that the target space is now
                different from the target space that was used to create the --warp
                file. It would typically be the file that was specified with the
                --in argument when running fnirt.
                argument: ``--ref=%s``

        [Optional]
        niter: (an integer (int or long))
                Determines how many iterations of the gradient-descent search that
                should be run.
                argument: ``--niter=%d``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        inverse_warp: (a file name)
                Name of output file, containing warps that are the "reverse" of
                those in --warp. This will be a field-file (rather than a file of
                spline coefficients), and it will have any affine component included
                as part of the displacements.
                argument: ``--out=%s``
        regularise: (a float)
                Regularization strength (deafult=1.0).
                argument: ``--regularise=%f``
        relative: (a boolean)
                If set it indicates that the warps in --warp should be interpreted
                as relative. I.e. the values in --warp are displacements from the
                coordinates in the --ref space. If set it also indicates that the
                output --out should be relative.
                argument: ``--rel``
                mutually_exclusive: absolute
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        noconstraint: (a boolean)
                Do not apply Jacobian constraint
                argument: ``--noconstraint``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        jacobian_min: (a float)
                Minimum acceptable Jacobian value for constraint (default 0.01)
                argument: ``--jmin=%f``
        jacobian_max: (a float)
                Maximum acceptable Jacobian value for constraint (default 100.0)
                argument: ``--jmax=%f``
        absolute: (a boolean)
                If set it indicates that the warps in --warp should be interpreted
                as absolute, provided that it is not created by fnirt (which always
                uses relative warps). If set it also indicates that the output --out
                should be absolute.
                argument: ``--abs``
                mutually_exclusive: relative

Outputs::

        inverse_warp: (an existing file name)
                Name of output file, containing warps that are the "reverse" of
                those in --warp.

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Merge:


.. index:: Merge

Merge
-----

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L358>`__

Wraps the executable command ``fslmerge``.

Use fslmerge to concatenate images

Images can be concatenated across time, x, y, or z dimensions. Across the
time (t) dimension the TR is set by default to 1 sec.

Note: to set the TR to a different value, specify 't' for dimension and
specify the TR value in seconds for the tr input. The dimension will be
automatically updated to 'tr'.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import Merge
>>> merger = Merge()
>>> merger.inputs.in_files = ['functional2.nii', 'functional3.nii']
>>> merger.inputs.dimension = 't'
>>> merger.inputs.output_type = 'NIFTI_GZ'
>>> merger.cmdline
'fslmerge -t functional2_merged.nii.gz functional2.nii functional3.nii'
>>> merger.inputs.tr = 2.25
>>> merger.cmdline
'fslmerge -tr functional2_merged.nii.gz functional2.nii functional3.nii 2.25'

Inputs::

        [Mandatory]
        in_files: (a list of items which are an existing file name)
                argument: ``%s``, position: 2
        dimension: (u't' or u'x' or u'y' or u'z' or u'a')
                dimension along which to merge, optionally set tr input when
                dimension is t
                argument: ``-%s``, position: 0

        [Optional]
        merged_file: (a file name)
                argument: ``%s``, position: 1
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        tr: (a float)
                use to specify TR in seconds (default is 1.00 sec), overrides
                dimension and sets it to tr
                argument: ``%.2f``, position: -1
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        merged_file: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.MotionOutliers:


.. index:: MotionOutliers

MotionOutliers
--------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2690>`__

Wraps the executable command ``fsl_motion_outliers``.

Use FSL fsl_motion_outliers`http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/FSLMotionOutliers`_ to find outliers in timeseries (4d) data.
Examples
~~~~~~~~
>>> from nipype.interfaces.fsl import MotionOutliers
>>> mo = MotionOutliers()
>>> mo.inputs.in_file = "epi.nii"
>>> mo.cmdline # doctest: +ELLIPSIS
'fsl_motion_outliers -i epi.nii -o epi_outliers.txt -p epi_metrics.png -s epi_metrics.txt'
>>> res = mo.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                unfiltered 4D image
                argument: ``-i %s``

        [Optional]
        dummy: (an integer (int or long))
                number of dummy scans to delete (before running anything and
                creating EVs)
                argument: ``--dummy=%d``
        out_file: (a file name)
                output outlier file name
                argument: ``-o %s``
        no_motion_correction: (a boolean)
                do not run motion correction (assumed already done)
                argument: ``--nomoco``
        metric: (u'refrms' or u'dvars' or u'refmse' or u'fd' or u'fdrms')
                metrics: refrms - RMS intensity difference to reference volume as
                metric [default metric], refmse - Mean Square Error version of
                refrms (used in original version of fsl_motion_outliers), dvars -
                DVARS, fd - frame displacement, fdrms - FD with RMS matrix
                calculation
                argument: ``--%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        mask: (an existing file name)
                mask image for calculating metric
                argument: ``-m %s``
        out_metric_values: (a file name)
                output metric values (DVARS etc.) file name
                argument: ``-s %s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        out_metric_plot: (a file name)
                output metric values plot (DVARS etc.) file name
                argument: ``-p %s``
        threshold: (a float)
                specify absolute threshold value (otherwise use box-plot cutoff =
                P75 + 1.5*IQR)
                argument: ``--thresh=%g``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_metric_plot: (an existing file name)
        out_file: (an existing file name)
        out_metric_values: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Overlay:


.. index:: Overlay

Overlay
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L989>`__

Wraps the executable command ``overlay``.

Use FSL's overlay command to combine background and statistical images
    into one volume


Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> combine = fsl.Overlay()
>>> combine.inputs.background_image = 'mean_func.nii.gz'
>>> combine.inputs.auto_thresh_bg = True
>>> combine.inputs.stat_image = 'zstat1.nii.gz'
>>> combine.inputs.stat_thresh = (3.5, 10)
>>> combine.inputs.show_negative_stats = True
>>> res = combine.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        stat_thresh: (a tuple of the form: (a float, a float))
                min and max values for the statistical overlay
                argument: ``%.2f %.2f``, position: 7
        background_image: (an existing file name)
                image to use as background
                argument: ``%s``, position: 4
        bg_thresh: (a tuple of the form: (a float, a float))
                min and max values for background intensity
                argument: ``%.3f %.3f``, position: 5
                mutually_exclusive: auto_thresh_bg, full_bg_range, bg_thresh
        full_bg_range: (a boolean)
                use full range of background image
                argument: ``-A``, position: 5
                mutually_exclusive: auto_thresh_bg, full_bg_range, bg_thresh
        auto_thresh_bg: (a boolean)
                automatically threshold the background image
                argument: ``-a``, position: 5
                mutually_exclusive: auto_thresh_bg, full_bg_range, bg_thresh
        stat_image: (an existing file name)
                statistical image to overlay in color
                argument: ``%s``, position: 6

        [Optional]
        use_checkerboard: (a boolean)
                use checkerboard mask for overlay
                argument: ``-c``, position: 3
        show_negative_stats: (a boolean)
                display negative statistics in overlay
                argument: ``%s``, position: 8
                mutually_exclusive: stat_image2
        stat_image2: (an existing file name)
                second statistical image to overlay in color
                argument: ``%s``, position: 9
                mutually_exclusive: show_negative_stats
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        out_type: (u'float' or u'int', nipype default value: float)
                write output with float or int
                argument: ``%s``, position: 2
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        transparency: (a boolean, nipype default value: True)
                make overlay colors semi-transparent
                argument: ``%s``, position: 1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        stat_thresh2: (a tuple of the form: (a float, a float))
                min and max values for second statistical overlay
                argument: ``%.2f %.2f``, position: 10
        out_file: (a file name)
                combined image volume
                argument: ``%s``, position: -1

Outputs::

        out_file: (an existing file name)
                combined image volume

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.PlotMotionParams:


.. index:: PlotMotionParams

PlotMotionParams
----------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1357>`__

Wraps the executable command ``fsl_tsplot``.

Use fsl_tsplot to plot the estimated motion parameters from a
realignment program.


Examples
~~~~~~~~

>>> import nipype.interfaces.fsl as fsl
>>> plotter = fsl.PlotMotionParams()
>>> plotter.inputs.in_file = 'functional.par'
>>> plotter.inputs.in_source = 'fsl'
>>> plotter.inputs.plot_type = 'rotations'
>>> res = plotter.run() #doctest: +SKIP


Notes
~~~~~

The 'in_source' attribute determines the order of columns that are expected
in the source file.  FSL prints motion parameters in the order rotations,
translations, while SPM prints them in the opposite order.  This interface
should be able to plot timecourses of motion parameters generated from
other sources as long as they fall under one of these two patterns.  For
more flexibilty, see the :class:`fsl.PlotTimeSeries` interface.

Inputs::

        [Mandatory]
        plot_type: (u'rotations' or u'translations' or u'displacement')
                which motion type to plot - rotations, translations, displacement
                argument: ``%s``
        in_file: (an existing file name or a list of items which are an
                  existing file name)
                file with motion parameters
                argument: ``%s``, position: 1
        in_source: (u'spm' or u'fsl')
                which program generated the motion parameter file - fsl, spm

        [Optional]
        plot_size: (a tuple of the form: (an integer (int or long), an
                  integer (int or long)))
                plot image height and width
                argument: ``%s``
        out_file: (a file name)
                image to write
                argument: ``-o %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_file: (an existing file name)
                image to write

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.PlotTimeSeries:


.. index:: PlotTimeSeries

PlotTimeSeries
--------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1260>`__

Wraps the executable command ``fsl_tsplot``.

Use fsl_tsplot to create images of time course plots.

Examples
~~~~~~~~

>>> import nipype.interfaces.fsl as fsl
>>> plotter = fsl.PlotTimeSeries()
>>> plotter.inputs.in_file = 'functional.par'
>>> plotter.inputs.title = 'Functional timeseries'
>>> plotter.inputs.labels = ['run1', 'run2']
>>> plotter.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name or a list of items which are an
                  existing file name)
                file or list of files with columns of timecourse information
                argument: ``%s``, position: 1

        [Optional]
        plot_size: (a tuple of the form: (an integer (int or long), an
                  integer (int or long)))
                plot image height and width
                argument: ``%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        y_min: (a float)
                minumum y value
                argument: ``--ymin=%.2f``
                mutually_exclusive: y_range
        title: (a unicode string)
                plot title
                argument: ``%s``
        labels: (a unicode string or a list of items which are a unicode
                  string)
                label or list of labels
                argument: ``%s``
        sci_notation: (a boolean)
                switch on scientific notation
                argument: ``--sci``
        plot_range: (a tuple of the form: (an integer (int or long), an
                  integer (int or long)))
                first and last columns from the in-file to plot
                argument: ``%s``
                mutually_exclusive: plot_start, plot_finish
        plot_start: (an integer (int or long))
                first column from in-file to plot
                argument: ``--start=%d``
                mutually_exclusive: plot_range
        legend_file: (an existing file name)
                legend file
                argument: ``--legend=%s``
        x_units: (an integer (int or long), nipype default value: 1)
                scaling units for x-axis (between 1 and length of in file)
                argument: ``-u %d``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        x_precision: (an integer (int or long))
                precision of x-axis labels
                argument: ``--precision=%d``
        y_max: (a float)
                maximum y value
                argument: ``--ymax=%.2f``
                mutually_exclusive: y_range
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        y_range: (a tuple of the form: (a float, a float))
                min and max y axis values
                argument: ``%s``
                mutually_exclusive: y_min, y_max
        plot_finish: (an integer (int or long))
                final column from in-file to plot
                argument: ``--finish=%d``
                mutually_exclusive: plot_range
        out_file: (a file name)
                image to write
                argument: ``-o %s``

Outputs::

        out_file: (an existing file name)
                image to write

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.PowerSpectrum:


.. index:: PowerSpectrum

PowerSpectrum
-------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1621>`__

Wraps the executable command ``fslpspec``.

Use FSL PowerSpectrum command for power spectrum estimation.

Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> pspec = fsl.PowerSpectrum()
>>> pspec.inputs.in_file = 'functional.nii'
>>> res = pspec.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input 4D file to estimate the power spectrum
                argument: ``%s``, position: 0

        [Optional]
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        out_file: (a file name)
                name of output 4D file for power spectrum
                argument: ``%s``, position: 1

Outputs::

        out_file: (an existing file name)
                path/name of the output 4D power spectrum file

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Reorient2Std:


.. index:: Reorient2Std

Reorient2Std
------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1713>`__

Wraps the executable command ``fslreorient2std``.

fslreorient2std is a tool for reorienting the image to match the
approximate orientation of the standard template images (MNI152).


Examples
~~~~~~~~

>>> reorient = Reorient2Std()
>>> reorient.inputs.in_file = "functional.nii"
>>> res = reorient.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                argument: ``%s``

        [Optional]
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        out_file: (a file name)
                argument: ``%s``

Outputs::

        out_file: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.RobustFOV:


.. index:: RobustFOV

RobustFOV
---------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L104>`__

Wraps the executable command ``robustfov``.

Automatically crops an image removing lower head and neck.

Interface is stable 5.0.0 to 5.0.9, but default brainsize changed from
150mm to 170mm.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input filename
                argument: ``-i %s``, position: 0

        [Optional]
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        out_roi: (a file name)
                ROI volume output name
                argument: ``-r %s``
        brainsize: (an integer (int or long))
                size of brain in z-dimension (default 170mm/150mm)
                argument: ``-b %d``
        out_transform: (a file name)
                Transformation matrix in_file to out_roi output name
                argument: ``-m %s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_transform: (an existing file name)
                Transformation matrix in_file to out_roi output name
        out_roi: (an existing file name)
                ROI volume output name

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.SigLoss:


.. index:: SigLoss

SigLoss
-------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1672>`__

Wraps the executable command ``sigloss``.

Estimates signal loss from a field map (in rad/s)

Examples
~~~~~~~~

>>> sigloss = SigLoss()
>>> sigloss.inputs.in_file = "phase.nii"
>>> sigloss.inputs.echo_time = 0.03
>>> res = sigloss.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                b0 fieldmap file
                argument: ``-i %s``

        [Optional]
        echo_time: (a float)
                echo time in seconds
                argument: ``--te=%f``
        out_file: (a file name)
                output signal loss estimate file
                argument: ``-s %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        slice_direction: (u'x' or u'y' or u'z')
                slicing direction
                argument: ``-d %s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        mask_file: (an existing file name)
                brain mask file
                argument: ``-m %s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_file: (an existing file name)
                signal loss estimate file

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Slice:


.. index:: Slice

Slice
-----

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L275>`__

Wraps the executable command ``fslslice``.

Use fslslice to split a 3D file into lots of 2D files (along z-axis).


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import Slice
>>> slice = Slice()
>>> slice.inputs.in_file = 'functional.nii'
>>> slice.inputs.out_base_name = 'sl'
>>> slice.cmdline
'fslslice functional.nii sl'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input filename
                argument: ``%s``, position: 0

        [Optional]
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        out_base_name: (a unicode string)
                outputs prefix
                argument: ``%s``, position: 1
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``

Outputs::

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

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Slicer:


.. index:: Slicer

Slicer
------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1147>`__

Wraps the executable command ``slicer``.

Use FSL's slicer command to output a png image from a volume.


Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> from nipype.testing import example_data
>>> slice = fsl.Slicer()
>>> slice.inputs.in_file = example_data('functional.nii')
>>> slice.inputs.all_axial = True
>>> slice.inputs.image_width = 750
>>> res = slice.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input volume
                argument: ``%s``, position: 1

        [Optional]
        intensity_range: (a tuple of the form: (a float, a float))
                min and max intensities to display
                argument: ``-i %.3f %.3f``, position: 5
        single_slice: (u'x' or u'y' or u'z')
                output picture of single slice in the x, y, or z plane
                argument: ``-%s``, position: 10
                mutually_exclusive: single_slice, middle_slices, all_axial,
                  sample_axial
                requires: slice_number
        colour_map: (an existing file name)
                use different colour map from that stored in nifti header
                argument: ``-l %s``, position: 4
        image_edges: (an existing file name)
                volume to display edge overlay for (useful for checking registration
                argument: ``%s``, position: 2
        show_orientation: (a boolean, nipype default value: True)
                label left-right orientation
                argument: ``%s``, position: 9
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        image_width: (an integer (int or long))
                max picture width
                argument: ``%d``, position: -2
        scaling: (a float)
                image scale
                argument: ``-s %f``, position: 0
        threshold_edges: (a float)
                use threshold for edges
                argument: ``-e %.3f``, position: 6
        middle_slices: (a boolean)
                output picture of mid-sagittal, axial, and coronal slices
                argument: ``-a``, position: 10
                mutually_exclusive: single_slice, middle_slices, all_axial,
                  sample_axial
        dither_edges: (a boolean)
                produce semi-transparent (dithered) edges
                argument: ``-t``, position: 7
        label_slices: (a boolean, nipype default value: True)
                display slice number
                argument: ``-L``, position: 3
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        nearest_neighbour: (a boolean)
                use nearest neighbor interpolation for output
                argument: ``-n``, position: 8
        sample_axial: (an integer (int or long))
                output every n axial slices into one picture
                argument: ``-S %d``, position: 10
                mutually_exclusive: single_slice, middle_slices, all_axial,
                  sample_axial
                requires: image_width
        all_axial: (a boolean)
                output all axial slices into one picture
                argument: ``-A``, position: 10
                mutually_exclusive: single_slice, middle_slices, all_axial,
                  sample_axial
                requires: image_width
        slice_number: (an integer (int or long))
                slice number to save in picture
                argument: ``-%d``, position: 11
        out_file: (a file name)
                picture to write
                argument: ``%s``, position: -1

Outputs::

        out_file: (an existing file name)
                picture to write

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Smooth:


.. index:: Smooth

Smooth
------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L216>`__

Wraps the executable command ``fslmaths``.

Use fslmaths to smooth the image

Examples
~~~~~~~~

Setting the kernel width using sigma:

>>> sm = Smooth()
>>> sm.inputs.output_type = 'NIFTI_GZ'
>>> sm.inputs.in_file = 'functional2.nii'
>>> sm.inputs.sigma = 8.0
>>> sm.cmdline # doctest: +ELLIPSIS
'fslmaths functional2.nii -kernel gauss 8.000 -fmean functional2_smooth.nii.gz'

Setting the kernel width using fwhm:

>>> sm = Smooth()
>>> sm.inputs.output_type = 'NIFTI_GZ'
>>> sm.inputs.in_file = 'functional2.nii'
>>> sm.inputs.fwhm = 8.0
>>> sm.cmdline # doctest: +ELLIPSIS
'fslmaths functional2.nii -kernel gauss 3.397 -fmean functional2_smooth.nii.gz'

One of sigma or fwhm must be set:

>>> from nipype.interfaces.fsl import Smooth
>>> sm = Smooth()
>>> sm.inputs.output_type = 'NIFTI_GZ'
>>> sm.inputs.in_file = 'functional2.nii'
>>> sm.cmdline #doctest: +ELLIPSIS
Traceback (most recent call last):
 ~~~
ValueError: Smooth requires a value for one of the inputs ...

Inputs::

        [Mandatory]
        fwhm: (a float)
                gaussian kernel fwhm, will be converted to sigma in mm (not voxels)
                argument: ``-kernel gauss %.03f -fmean``, position: 1
                mutually_exclusive: sigma
        sigma: (a float)
                gaussian kernel sigma in mm (not voxels)
                argument: ``-kernel gauss %.03f -fmean``, position: 1
                mutually_exclusive: fwhm
        in_file: (an existing file name)
                argument: ``%s``, position: 0

        [Optional]
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        smoothed_file: (a file name)
                argument: ``%s``, position: 2

Outputs::

        smoothed_file: (an existing file name)

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.Split:


.. index:: Split

Split
-----

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L528>`__

Wraps the executable command ``fslsplit``.

Uses FSL Fslsplit command to separate a volume into images in
time, x, y or z dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input filename
                argument: ``%s``, position: 0
        dimension: (u't' or u'x' or u'y' or u'z')
                dimension along which the file will be split
                argument: ``-%s``, position: 2

        [Optional]
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        out_base_name: (a unicode string)
                outputs prefix
                argument: ``%s``, position: 1
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

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

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.SwapDimensions:


.. index:: SwapDimensions

SwapDimensions
--------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L1571>`__

Wraps the executable command ``fslswapdim``.

Use fslswapdim to alter the orientation of an image.

This interface accepts a three-tuple corresponding to the new
orientation.  You may either provide dimension ids in the form of
(-)x, (-)y, or (-z), or nifti-syle dimension codes
(RL, LR, AP, PA, IS, SI).

Inputs::

        [Mandatory]
        new_dims: (a tuple of the form: (u'x' or u'-x' or u'y' or u'-y' or
                  u'z' or u'-z' or u'RL' or u'LR' or u'AP' or u'PA' or u'IS' or
                  u'SI', u'x' or u'-x' or u'y' or u'-y' or u'z' or u'-z' or u'RL' or
                  u'LR' or u'AP' or u'PA' or u'IS' or u'SI', u'x' or u'-x' or u'y'
                  or u'-y' or u'z' or u'-z' or u'RL' or u'LR' or u'AP' or u'PA' or
                  u'IS' or u'SI'))
                3-tuple of new dimension order
                argument: ``%s %s %s``
        in_file: (an existing file name)
                input image
                argument: ``%s``, position: 1

        [Optional]
        out_file: (a file name)
                image to write
                argument: ``%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        out_file: (an existing file name)
                image with new dimensions

References:
~~~~~~~~~~~
None

.. _nipype.interfaces.fsl.utils.WarpPoints:


.. index:: WarpPoints

WarpPoints
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2364>`__

Wraps the executable command ``img2imgcoord``.

Use FSL `img2imgcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
to transform point sets. Accepts plain text files and vtk files.

.. Note:: transformation of TrackVis trk files is not yet implemented


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import WarpPoints
>>> warppoints = WarpPoints()
>>> warppoints.inputs.in_coords = 'surf.txt'
>>> warppoints.inputs.src_file = 'epi.nii'
>>> warppoints.inputs.dest_file = 'T1.nii'
>>> warppoints.inputs.warp_file = 'warpfield.nii'
>>> warppoints.inputs.coord_mm = True
>>> warppoints.cmdline # doctest: +ELLIPSIS
'img2imgcoord -mm -dest T1.nii -src epi.nii -warp warpfield.nii surf.txt'
>>> res = warppoints.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_coords: (an existing file name)
                filename of file containing coordinates
                argument: ``%s``, position: -1
        dest_file: (an existing file name)
                filename of destination image
                argument: ``-dest %s``
        src_file: (an existing file name)
                filename of source image
                argument: ``-src %s``

        [Optional]
        xfm_file: (an existing file name)
                filename of affine transform (e.g. source2dest.mat)
                argument: ``-xfm %s``
                mutually_exclusive: warp_file
        coord_mm: (a boolean)
                all coordinates in mm
                argument: ``-mm``
                mutually_exclusive: coord_vox
        out_file: (a file name)
                output file name
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        coord_vox: (a boolean)
                all coordinates in voxels - default
                argument: ``-vox``
                mutually_exclusive: coord_mm
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        warp_file: (an existing file name)
                filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
                argument: ``-warp %s``
                mutually_exclusive: xfm_file

Outputs::

        out_file: (an existing file name)
                Name of output file, containing the warp as field or coefficients.

.. _nipype.interfaces.fsl.utils.WarpPointsFromStd:


.. index:: WarpPointsFromStd

WarpPointsFromStd
-----------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2599>`__

Wraps the executable command ``std2imgcoord``.

Use FSL `std2imgcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
to transform point sets to standard space coordinates. Accepts plain text coordinates
files.


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import WarpPointsFromStd
>>> warppoints = WarpPointsFromStd()
>>> warppoints.inputs.in_coords = 'surf.txt'
>>> warppoints.inputs.img_file = 'T1.nii'
>>> warppoints.inputs.std_file = 'mni.nii'
>>> warppoints.inputs.warp_file = 'warpfield.nii'
>>> warppoints.inputs.coord_mm = True
>>> warppoints.cmdline # doctest: +ELLIPSIS
'std2imgcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt'
>>> res = warppoints.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        img_file: (an existing file name)
                filename of a destination image
                argument: ``-img %s``
        in_coords: (an existing file name)
                filename of file containing coordinates
                argument: ``%s``, position: -2
        std_file: (an existing file name)
                filename of the image in standard space
                argument: ``-std %s``

        [Optional]
        xfm_file: (an existing file name)
                filename of affine transform (e.g. source2dest.mat)
                argument: ``-xfm %s``
                mutually_exclusive: warp_file
        coord_mm: (a boolean)
                all coordinates in mm
                argument: ``-mm``
                mutually_exclusive: coord_vox
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        coord_vox: (a boolean)
                all coordinates in voxels - default
                argument: ``-vox``
                mutually_exclusive: coord_mm
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        warp_file: (an existing file name)
                filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
                argument: ``-warp %s``
                mutually_exclusive: xfm_file

Outputs::

        out_file: (an existing file name)
                Name of output file, containing the warp as field or coefficients.

.. _nipype.interfaces.fsl.utils.WarpPointsToStd:


.. index:: WarpPointsToStd

WarpPointsToStd
---------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2530>`__

Wraps the executable command ``img2stdcoord``.

Use FSL `img2stdcoord <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/flirt/overview.html>`_
to transform point sets to standard space coordinates. Accepts plain text
files and vtk files.

.. Note:: transformation of TrackVis trk files is not yet implemented


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import WarpPointsToStd
>>> warppoints = WarpPointsToStd()
>>> warppoints.inputs.in_coords = 'surf.txt'
>>> warppoints.inputs.img_file = 'T1.nii'
>>> warppoints.inputs.std_file = 'mni.nii'
>>> warppoints.inputs.warp_file = 'warpfield.nii'
>>> warppoints.inputs.coord_mm = True
>>> warppoints.cmdline # doctest: +ELLIPSIS
'img2stdcoord -mm -img T1.nii -std mni.nii -warp warpfield.nii surf.txt'
>>> res = warppoints.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        img_file: (an existing file name)
                filename of input image
                argument: ``-img %s``
        in_coords: (an existing file name)
                filename of file containing coordinates
                argument: ``%s``, position: -1
        std_file: (an existing file name)
                filename of destination image
                argument: ``-std %s``

        [Optional]
        xfm_file: (an existing file name)
                filename of affine transform (e.g. source2dest.mat)
                argument: ``-xfm %s``
                mutually_exclusive: warp_file
        coord_mm: (a boolean)
                all coordinates in mm
                argument: ``-mm``
                mutually_exclusive: coord_vox
        out_file: (a file name)
                output file name
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        coord_vox: (a boolean)
                all coordinates in voxels - default
                argument: ``-vox``
                mutually_exclusive: coord_mm
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        warp_file: (an existing file name)
                filename of warpfield (e.g. intermediate2dest_warp.nii.gz)
                argument: ``-warp %s``
                mutually_exclusive: xfm_file
        premat_file: (an existing file name)
                filename of pre-warp affine transform (e.g.
                example_func2highres.mat)
                argument: ``-premat %s``

Outputs::

        out_file: (an existing file name)
                Name of output file, containing the warp as field or coefficients.

.. _nipype.interfaces.fsl.utils.WarpUtils:


.. index:: WarpUtils

WarpUtils
---------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/fsl/utils.py#L2105>`__

Wraps the executable command ``fnirtfileutils``.

Use FSL `fnirtfileutils <http://fsl.fmrib.ox.ac.uk/fsl/fsl-4.1.9/fnirt/warp_utils.html>`_
to convert field->coefficients, coefficients->field, coefficients->other_coefficients etc


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import WarpUtils
>>> warputils = WarpUtils()
>>> warputils.inputs.in_file = "warpfield.nii"
>>> warputils.inputs.reference = "T1.nii"
>>> warputils.inputs.out_format = 'spline'
>>> warputils.inputs.warp_resolution = (10,10,10)
>>> warputils.inputs.output_type = "NIFTI_GZ"
>>> warputils.cmdline # doctest: +ELLIPSIS
'fnirtfileutils --in=warpfield.nii --outformat=spline --ref=T1.nii --warpres=10.0000,10.0000,10.0000 --out=warpfield_coeffs.nii.gz'
>>> res = invwarp.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        write_jacobian: (a boolean, nipype default value: False)
                Switch on --jac flag with automatically generated filename
        in_file: (an existing file name)
                Name of file containing warp-coefficients/fields. This would
                typically be the output from the --cout switch of fnirt (but can
                also use fields, like the output from --fout).
                argument: ``--in=%s``
        reference: (an existing file name)
                Name of a file in target space. Note that the target space is now
                different from the target space that was used to create the --warp
                file. It would typically be the file that was specified with the
                --in argument when running fnirt.
                argument: ``--ref=%s``

        [Optional]
        out_format: (u'spline' or u'field')
                Specifies the output format. If set to field (default) the output
                will be a (4D) field-file. If set to spline the format will be a
                (4D) file of spline coefficients.
                argument: ``--outformat=%s``
        out_file: (a file name)
                Name of output file. The format of the output depends on what other
                parameters are set. The default format is a (4D) field-file. If the
                --outformat is set to spline the format will be a (4D) file of
                spline coefficients.
                argument: ``--out=%s``, position: -1
        with_affine: (a boolean)
                Specifies that the affine transform (i.e. that which was specified
                for the --aff parameter in fnirt) should be included as
                displacements in the --out file. That can be useful for interfacing
                with software that cannot decode FSL/fnirt coefficient-files (where
                the affine transform is stored separately from the displacements).
                argument: ``--withaff``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        warp_resolution: (a tuple of the form: (a float, a float, a float))
                Specifies the resolution/knot-spacing of the splines pertaining to
                the coefficients in the --out file. This parameter is only relevant
                if --outformat is set to spline. It should be noted that if the --in
                file has a higher resolution, the resulting coefficients will
                pertain to the closest (in a least-squares sense) file in the space
                of fields with the --warpres resolution. It should also be noted
                that the resolution will always be an integer multiple of the voxel
                size.
                argument: ``--warpres=%0.4f,%0.4f,%0.4f``
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        knot_space: (a tuple of the form: (an integer (int or long), an
                  integer (int or long), an integer (int or long)))
                Alternative (to --warpres) specification of the resolution of the
                output spline-field.
                argument: ``--knotspace=%d,%d,%d``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        out_jacobian: (a file name)
                Specifies that a (3D) file of Jacobian determinants corresponding to
                --in should be produced and written to filename.
                argument: ``--jac=%s``

Outputs::

        out_jacobian: (a file name)
                Name of output file, containing the map of the determinant of the
                Jacobian
        out_file: (a file name)
                Name of output file, containing the warp as field or coefficients.

References:
~~~~~~~~~~~
None
