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

interfaces.fsl.maths
====================


.. _nipype.interfaces.fsl.maths.AR1Image:


.. index:: AR1Image

AR1Image
--------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate an AR1 coefficient image across a
given dimension. (Should use -odt float and probably demean first)

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to find AR(1) coefficientacross
                argument: ``-%sar1``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.ApplyMask:


.. index:: ApplyMask

ApplyMask
---------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to apply a binary mask to another image.

Inputs::

        [Mandatory]
        mask_file: (an existing file name)
                binary image defining mask space
                argument: ``-mas %s``, position: 4
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.BinaryMaths:


.. index:: BinaryMaths

BinaryMaths
-----------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to perform mathematical operations using a second image or
a numeric value.

Inputs::

        [Mandatory]
        operand_value: (a float)
                value to perform operation with
                argument: ``%.8f``, position: 5
                mutually_exclusive: operand_file
        operation: (u'add' or u'sub' or u'mul' or u'div' or u'rem' or u'max'
                  or u'min')
                operation to perform
                argument: ``-%s``, position: 4
        operand_file: (an existing file name)
                second image to perform operation with
                argument: ``%s``, position: 5
                mutually_exclusive: operand_value
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.ChangeDataType:


.. index:: ChangeDataType

ChangeDataType
--------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to change the datatype of an image.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                output data type
                argument: ``-odt %s``, position: -1

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.DilateImage:


.. index:: DilateImage

DilateImage
-----------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to perform a spatial dilation of an image.

Inputs::

        [Mandatory]
        operation: (u'mean' or u'modal' or u'max')
                filtering operation to perfoem in dilation
                argument: ``-dil%s``, position: 6
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        kernel_file: (an existing file name)
                use external file for kernel
                argument: ``%s``, position: 5
                mutually_exclusive: kernel_size
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        kernel_shape: (u'3D' or u'2D' or u'box' or u'boxv' or u'gauss' or
                  u'sphere' or u'file')
                kernel shape to use
                argument: ``-kernel %s``, position: 4
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        kernel_size: (a float)
                kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
                argument: ``%.4f``, position: 5
                mutually_exclusive: kernel_file

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.ErodeImage:


.. index:: ErodeImage

ErodeImage
----------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to perform a spatial erosion of an image.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        kernel_file: (an existing file name)
                use external file for kernel
                argument: ``%s``, position: 5
                mutually_exclusive: kernel_size
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        kernel_shape: (u'3D' or u'2D' or u'box' or u'boxv' or u'gauss' or
                  u'sphere' or u'file')
                kernel shape to use
                argument: ``-kernel %s``, position: 4
        minimum_filter: (a boolean, nipype default value: False)
                if true, minimum filter rather than erosion by zeroing-out
                argument: ``%s``, position: 6
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        kernel_size: (a float)
                kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
                argument: ``%.4f``, position: 5
                mutually_exclusive: kernel_file

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.IsotropicSmooth:


.. index:: IsotropicSmooth

IsotropicSmooth
---------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to spatially smooth an image with a gaussian kernel.

Inputs::

        [Mandatory]
        sigma: (a float)
                sigma of smoothing kernel [mm]
                argument: ``-s %.5f``, position: 4
                mutually_exclusive: fwhm
        fwhm: (a float)
                fwhm of smoothing kernel [mm]
                argument: ``-s %.5f``, position: 4
                mutually_exclusive: sigma
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MathsCommand:


.. index:: MathsCommand

MathsCommand
------------

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

Wraps the executable command ``fslmaths``.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MaxImage:


.. index:: MaxImage

MaxImage
--------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a max image across a given dimension.

Examples
~~~~~~~~
>>> from nipype.interfaces.fsl.maths import MaxImage
>>> maxer = MaxImage()
>>> maxer.inputs.in_file = "functional.nii"  # doctest: +SKIP
>>> maxer.dimension = "T"
>>> maxer.cmdline  # doctest: +SKIP
'fslmaths functional.nii -Tmax functional_max.nii'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to max across
                argument: ``-%smax``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MaxnImage:


.. index:: MaxnImage

MaxnImage
---------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate an image of index of max across
a given dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to index max across
                argument: ``-%smaxn``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MeanImage:


.. index:: MeanImage

MeanImage
---------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a mean image across a given dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to mean across
                argument: ``-%smean``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MedianImage:


.. index:: MedianImage

MedianImage
-----------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a median image across a given dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to median across
                argument: ``-%smedian``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MinImage:


.. index:: MinImage

MinImage
--------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a minimum image across a given dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to min across
                argument: ``-%smin``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.MultiImageMaths:


.. index:: MultiImageMaths

MultiImageMaths
---------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to perform a sequence of mathematical operations.

Examples
~~~~~~~~
>>> from nipype.interfaces.fsl import MultiImageMaths
>>> maths = MultiImageMaths()
>>> maths.inputs.in_file = "functional.nii"
>>> maths.inputs.op_string = "-add %s -mul -1 -div %s"
>>> maths.inputs.operand_files = ["functional2.nii", "functional3.nii"]
>>> maths.inputs.out_file = "functional4.nii"
>>> maths.cmdline
'fslmaths functional.nii -add functional2.nii -mul -1 -div functional3.nii functional4.nii'

Inputs::

        [Mandatory]
        op_string: (a string)
                python formatted string of operations to perform
                argument: ``%s``, position: 4
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2
        operand_files: (a list of items which are an existing file name)
                list of file names to plug into op string

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.PercentileImage:


.. index:: PercentileImage

PercentileImage
---------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a percentile image across a given dimension.

Examples
~~~~~~~~
>>> from nipype.interfaces.fsl.maths import MaxImage
>>> percer = PercentileImage()
>>> percer.inputs.in_file = "functional.nii"  # doctest: +SKIP
>>> percer.dimension = "T"
>>> percer.perc = 90
>>> percer.cmdline  # doctest: +SKIP
'fslmaths functional.nii -Tperc 90 functional_perc.nii'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        perc: (0 <= an integer <= 100)
                nth percentile (0-100) of FULL RANGE across dimension
                argument: ``%f``, position: 5
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to percentile across
                argument: ``-%sperc``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.SpatialFilter:


.. index:: SpatialFilter

SpatialFilter
-------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to spatially filter an image.

Inputs::

        [Mandatory]
        operation: (u'mean' or u'median' or u'meanu')
                operation to filter with
                argument: ``-f%s``, position: 6
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        kernel_file: (an existing file name)
                use external file for kernel
                argument: ``%s``, position: 5
                mutually_exclusive: kernel_size
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        kernel_shape: (u'3D' or u'2D' or u'box' or u'boxv' or u'gauss' or
                  u'sphere' or u'file')
                kernel shape to use
                argument: ``-kernel %s``, position: 4
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        kernel_size: (a float)
                kernel size - voxels for box/boxv, mm for sphere, mm sigma for gauss
                argument: ``%.4f``, position: 5
                mutually_exclusive: kernel_file

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.StdImage:


.. index:: StdImage

StdImage
--------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to generate a standard deviation in an image across a given
dimension.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        dimension: (u'T' or u'X' or u'Y' or u'Z', nipype default value: T)
                dimension to standard deviate across
                argument: ``-%sstd``, position: 4

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.TemporalFilter:


.. index:: TemporalFilter

TemporalFilter
--------------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to apply a low, high, or bandpass temporal filter to a
timeseries.

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        lowpass_sigma: (a float, nipype default value: -1)
                lowpass filter sigma (in volumes)
                argument: ``%.6f``, position: 5
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %s``, position: 1
        highpass_sigma: (a float, nipype default value: -1)
                highpass filter sigma (in volumes)
                argument: ``-bptf %.6f``, position: 4
        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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.Threshold:


.. index:: Threshold

Threshold
---------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to apply a threshold to an image in a variety of ways.

Inputs::

        [Mandatory]
        thresh: (a float)
                threshold value
                argument: ``%s``, position: 4
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        direction: (u'below' or u'above', nipype default value: below)
                zero-out either below or above thresh value
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        use_robust_range: (a boolean)
                interpret thresh as percentage (0-100) of robust range
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        use_nonzero_voxels: (a boolean)
                use nonzero voxels to calculate robust range
                requires: use_robust_range
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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

.. _nipype.interfaces.fsl.maths.UnaryMaths:


.. index:: UnaryMaths

UnaryMaths
----------

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

Wraps the executable command ``fslmaths``.

Use fslmaths to perorm a variety of mathematical operations on an image.

Inputs::

        [Mandatory]
        operation: (u'exp' or u'log' or u'sin' or u'cos' or u'tan' or u'asin'
                  or u'acos' or u'atan' or u'sqr' or u'sqrt' or u'recip' or u'abs'
                  or u'bin' or u'binv' or u'fillh' or u'fillh26' or u'index' or
                  u'edge' or u'nan' or u'nanm' or u'rand' or u'randn' or u'range')
                operation to perform
                argument: ``-%s``, position: 4
        in_file: (an existing file name)
                image to operate on
                argument: ``%s``, position: 2

        [Optional]
        nan2zeros: (a boolean)
                change NaNs to zeros before doing anything
                argument: ``-nan``, position: 3
        out_file: (a file name)
                image to write
                argument: ``%s``, position: -2
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        internal_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for calculations (default is float)
                argument: ``-dt %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
        output_datatype: (u'float' or u'char' or u'int' or u'short' or
                  u'double' or u'input')
                datatype to use for output (default uses input type)
                argument: ``-odt %s``, position: -1

Outputs::

        out_file: (an existing file name)
                image written after calculations

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