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

interfaces.fsl.epi
==================


.. _nipype.interfaces.fsl.epi.ApplyTOPUP:


.. index:: ApplyTOPUP

ApplyTOPUP
----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L347>`__

Wraps command **applytopup**

Interface for FSL topup, a tool for estimating and correcting
susceptibility induced distortions.
`General reference
<http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ApplytopupUsersGuide>`_
and `use example
<http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ExampleTopupFollowedByApplytopup>`_.


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import ApplyTOPUP
>>> applytopup = ApplyTOPUP()
>>> applytopup.inputs.in_files = ["epi.nii", "epi_rev.nii"]
>>> applytopup.inputs.encoding_file = "topup_encoding.txt"
>>> applytopup.inputs.in_index = [1,2]
>>> applytopup.inputs.in_topup_fieldcoef = "topup_fieldcoef.nii.gz"
>>> applytopup.inputs.in_topup_movpar = "topup_movpar.txt"
>>> applytopup.inputs.output_type = "NIFTI_GZ"
>>> applytopup.cmdline #doctest: +ELLIPSIS
'applytopup --datain=topup_encoding.txt --imain=epi.nii,epi_rev.nii --inindex=1,2 --topup=topup --out=epi_corrected.nii.gz'
>>> res = applytopup.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        encoding_file: (an existing file name)
                name of text file with PE directions/times
                flag: --datain=%s
        in_files: (an existing file name)
                name of 4D file with images
                flag: --imain=%s
        in_index: (a list of items which are an integer)
                comma separated list of indicies into --datain of the input image
                (to be corrected)
                flag: --inindex=%s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        datatype: ('char' or 'short' or 'int' or 'float' or 'double')
                force output data type
                flag: -d=%s
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        in_topup_fieldcoef: (an existing file name)
                topup file containing the field coefficients
                flag: --topup=%s
                requires: in_topup_movpar
        in_topup_movpar: (an existing file name)
                topup movpar.txt file
                requires: in_topup_fieldcoef
        interp: ('trilinear' or 'spline')
                interpolation method
                flag: --interp=%s
        method: ('jac' or 'lsr')
                use jacobian modulation (jac) or least-squares resampling (lsr)
                flag: --method=%s
        out_corrected: (a file name)
                output (warped) image
                flag: --out=%s
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type

Outputs::

        out_corrected: (an existing file name)
                name of 4D image file with unwarped images

.. _nipype.interfaces.fsl.epi.EPIDeWarp:


.. index:: EPIDeWarp

EPIDeWarp
---------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L733>`__

Wraps command **epidewarp.fsl**

Wraps the unwarping script `epidewarp.fsl
<http://surfer.nmr.mgh.harvard.edu/fswiki/epidewarp.fsl>`_.

.. warning:: deprecated in FSL, please use
  :func:`nipype.workflows.dmri.preprocess.epi.sdc_fmb` instead.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import EPIDeWarp
>>> dewarp = EPIDeWarp()
>>> dewarp.inputs.epi_file = "functional.nii"
>>> dewarp.inputs.mag_file = "magnitude.nii"
>>> dewarp.inputs.dph_file = "phase.nii"
>>> dewarp.inputs.output_type = "NIFTI_GZ"
>>> dewarp.cmdline #doctest: +ELLIPSIS
'epidewarp.fsl --mag magnitude.nii --dph phase.nii --epi functional.nii --esp 0.58 --exfdw .../exfdw.nii.gz --nocleanup --sigma 2 --tediff 2.46 --tmpdir .../temp --vsm .../vsm.nii.gz'
>>> res = dewarp.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        dph_file: (an existing file name)
                Phase file assumed to be scaled from 0 to 4095
                flag: --dph %s
        mag_file: (an existing file name)
                Magnitude file
                flag: --mag %s, position: 0
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        cleanup: (a boolean)
                cleanup
                flag: --cleanup
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        epi_file: (an existing file name)
                EPI volume to unwarp
                flag: --epi %s
        epidw: (a string)
                dewarped epi volume
                flag: --epidw %s
        esp: (a float, nipype default value: 0.58)
                EPI echo spacing
                flag: --esp %s
        exf_file: (an existing file name)
                example func volume (or use epi)
                flag: --exf %s
        exfdw: (a string)
                dewarped example func volume
                flag: --exfdw %s
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        nocleanup: (a boolean, nipype default value: True)
                no cleanup
                flag: --nocleanup
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        sigma: (an integer, nipype default value: 2)
                2D spatial gaussing smoothing stdev (default = 2mm)
                flag: --sigma %s
        tediff: (a float, nipype default value: 2.46)
                difference in B0 field map TEs
                flag: --tediff %s
        tmpdir: (a string)
                tmpdir
                flag: --tmpdir %s
        vsm: (a string)
                voxel shift map
                flag: --vsm %s

Outputs::

        exf_mask: (a file name)
                Mask from example functional volume
        exfdw: (a file name)
                dewarped functional volume example
        unwarped_file: (a file name)
                unwarped epi file
        vsm_file: (a file name)
                voxel shift map

.. _nipype.interfaces.fsl.epi.Eddy:


.. index:: Eddy

Eddy
----

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L440>`__

Wraps command **eddy**

Interface for FSL eddy, a tool for estimating and correcting eddy
currents induced distortions. `User guide
<http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Eddy/UsersGuide>`_ and
`more info regarding acqp file
<http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddy/Faq#How_do_I_know_what_to_put_into_my_--acqp_file>`_.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import Eddy
>>> eddy = Eddy()
>>> eddy.inputs.in_file = 'epi.nii'
>>> eddy.inputs.in_mask  = 'epi_mask.nii'
>>> eddy.inputs.in_index = 'epi_index.txt'
>>> eddy.inputs.in_acqp  = 'epi_acqp.txt'
>>> eddy.inputs.in_bvec  = 'bvecs.scheme'
>>> eddy.inputs.in_bval  = 'bvals.scheme'
>>> eddy.cmdline #doctest: +ELLIPSIS
'eddy --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --out=.../eddy_corrected'
>>> res = eddy.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_acqp: (an existing file name)
                File containing acquisition parameters
                flag: --acqp=%s
        in_bval: (an existing file name)
                File containing the b-values for all volumes in --imain
                flag: --bvals=%s
        in_bvec: (an existing file name)
                File containing the b-vectors for all volumes in --imain
                flag: --bvecs=%s
        in_file: (an existing file name)
                File containing all the images to estimate distortions for
                flag: --imain=%s
        in_index: (an existing file name)
                File containing indices for all volumes in --imain into --acqp and
                --topup
                flag: --index=%s
        in_mask: (an existing file name)
                Mask to indicate brain
                flag: --mask=%s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        flm: ('linear' or 'quadratic' or 'cubic')
                First level EC model
                flag: --flm=%s
        fwhm: (a float)
                FWHM for conditioning filter when estimating the parameters
                flag: --fwhm=%s
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        in_topup_fieldcoef: (an existing file name)
                topup file containing the field coefficients
                flag: --topup=%s
                requires: in_topup_movpar
        in_topup_movpar: (an existing file name)
                topup movpar.txt file
                requires: in_topup_fieldcoef
        method: ('jac' or 'lsr')
                Final resampling method (jacobian/least squares)
                flag: --resamp=%s
        niter: (an integer)
                Number of iterations
                flag: --niter=%s
        num_threads: (an integer, nipype default value: 1)
                Number of openmp threads to use
        out_base: (a unicode string, nipype default value: eddy_corrected)
                basename for output (warped) image
                flag: --out=%s
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        repol: (a boolean)
                Detect and replace outlier slices
                flag: --repol
        session: (an existing file name)
                File containing session indices for all volumes in --imain
                flag: --session=%s

Outputs::

        out_corrected: (an existing file name)
                4D image file containing all the corrected volumes
        out_parameter: (an existing file name)
                text file with parameters definining the field and movement for each
                scan

.. _nipype.interfaces.fsl.epi.EddyCorrect:


.. index:: EddyCorrect

EddyCorrect
-----------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L831>`__

Wraps command **eddy_correct**

.. warning:: Deprecated in FSL. Please use
  :class:`nipype.interfaces.fsl.epi.Eddy` instead

Example
~~~~~~~

>>> from nipype.interfaces.fsl import EddyCorrect
>>> eddyc = EddyCorrect(in_file='diffusion.nii',
...                     out_file="diffusion_edc.nii", ref_num=0)
>>> eddyc.cmdline
'eddy_correct diffusion.nii diffusion_edc.nii 0'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                4D input file
                flag: %s, position: 0
        ref_num: (an integer, nipype default value: 0)
                reference number
                flag: %d, position: 2
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        out_file: (a file name)
                4D output file
                flag: %s, position: 1
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type

Outputs::

        eddy_corrected: (an existing file name)
                path/name of 4D eddy corrected output file

.. _nipype.interfaces.fsl.epi.EpiReg:


.. index:: EpiReg

EpiReg
------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L622>`__

Wraps command **epi_reg**

Runs FSL epi_reg script for simultaneous coregistration and fieldmap
unwarping.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import EpiReg
>>> epireg = EpiReg()
>>> epireg.inputs.epi='epi.nii'
>>> epireg.inputs.t1_head='T1.nii'
>>> epireg.inputs.t1_brain='T1_brain.nii'
>>> epireg.inputs.out_base='epi2struct'
>>> epireg.inputs.fmap='fieldmap_phase_fslprepared.nii'
>>> epireg.inputs.fmapmag='fieldmap_mag.nii'
>>> epireg.inputs.fmapmagbrain='fieldmap_mag_brain.nii'
>>> epireg.inputs.echospacing=0.00067
>>> epireg.inputs.pedir='y'
>>> epireg.cmdline #doctest: +ELLIPSIS
'epi_reg --echospacing=0.000670 --fmap=fieldmap_phase_fslprepared.nii --fmapmag=fieldmap_mag.nii --fmapmagbrain=fieldmap_mag_brain.nii --pedir=y --epi=epi.nii --t1=T1.nii --t1brain=T1_brain.nii --out=epi2struct'
>>> epireg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        epi: (an existing file name)
                EPI image
                flag: --epi=%s, position: -4
        t1_brain: (an existing file name)
                brain extracted T1 image
                flag: --t1brain=%s, position: -2
        t1_head: (an existing file name)
                wholehead T1 image
                flag: --t1=%s, position: -3
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        echospacing: (a float)
                Effective EPI echo spacing (sometimes called dwell time) - in
                seconds
                flag: --echospacing=%f
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        fmap: (an existing file name)
                fieldmap image (in rad/s)
                flag: --fmap=%s
        fmapmag: (an existing file name)
                fieldmap magnitude image - wholehead
                flag: --fmapmag=%s
        fmapmagbrain: (an existing file name)
                fieldmap magnitude image - brain extracted
                flag: --fmapmagbrain=%s
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        no_clean: (a boolean)
                do not clean up intermediate files
                flag: --noclean
        no_fmapreg: (a boolean)
                do not perform registration of fmap to T1 (use if fmap already
                registered)
                flag: --nofmapreg
        out_base: (a string)
                output base name
                flag: --out=%s, position: -1
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        pedir: ('x' or 'y' or 'z' or '-x' or '-y' or '-z')
                phase encoding direction, dir = x/y/z/-x/-y/-z
                flag: --pedir=%s
        weight_image: (an existing file name)
                weighting image (in T1 space)
                flag: --weight=%s
        wmseg: (an existing file name)
                white matter segmentation of T1 image, has to be named like the
                t1brain and end on _wmseg
                flag: --wmseg=%s

Outputs::

        epi2str_inv: (an existing file name)
                rigid structural-to-epi transform
        epi2str_mat: (an existing file name)
                rigid epi-to-structural transform
        fmap2epi_mat: (an existing file name)
                rigid fieldmap-to-epi transform
        fmap2str_mat: (an existing file name)
                rigid fieldmap-to-structural transform
        fmap_epi: (an existing file name)
                fieldmap in epi space
        fmap_str: (an existing file name)
                fieldmap in structural space
        fmapmag_str: (an existing file name)
                fieldmap magnitude image in structural space
        fullwarp: (an existing file name)
                warpfield to unwarp epi and transform into structural space
        out_1vol: (an existing file name)
                unwarped and coregistered single volume
        out_file: (an existing file name)
                unwarped and coregistered epi input
        shiftmap: (an existing file name)
                shiftmap in epi space
        wmedge: (an existing file name)
                white matter edges for visualization
        wmseg: (an existing file name)
                white matter segmentation used in flirt bbr

.. _nipype.interfaces.fsl.epi.PrepareFieldmap:


.. index:: PrepareFieldmap

PrepareFieldmap
---------------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L57>`__

Wraps command **fsl_prepare_fieldmap**

Interface for the fsl_prepare_fieldmap script (FSL 5.0)

Prepares a fieldmap suitable for FEAT from SIEMENS data - saves output in
rad/s format (e.g. ```fsl_prepare_fieldmap SIEMENS
images_3_gre_field_mapping images_4_gre_field_mapping fmap_rads 2.65```).


Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import PrepareFieldmap
>>> prepare = PrepareFieldmap()
>>> prepare.inputs.in_phase = "phase.nii"
>>> prepare.inputs.in_magnitude = "magnitude.nii"
>>> prepare.inputs.output_type = "NIFTI_GZ"
>>> prepare.cmdline #doctest: +ELLIPSIS
'fsl_prepare_fieldmap SIEMENS phase.nii magnitude.nii .../phase_fslprepared.nii.gz 2.460000'
>>> res = prepare.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        delta_TE: (a float, nipype default value: 2.46)
                echo time difference of the fieldmap sequence in ms. (usually 2.46ms
                in Siemens)
                flag: %f, position: -2
        in_magnitude: (an existing file name)
                Magnitude difference map, brain extracted
                flag: %s, position: 3
        in_phase: (an existing file name)
                Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
                flag: %s, position: 2
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        nocheck: (a boolean, nipype default value: False)
                do not perform sanity checks for image size/range/dimensions
                flag: --nocheck, position: -1
        out_fieldmap: (a file name)
                output name for prepared fieldmap
                flag: %s, position: 4
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        scanner: (a string, nipype default value: SIEMENS)
                must be SIEMENS
                flag: %s, position: 1

Outputs::

        out_fieldmap: (an existing file name)
                output name for prepared fieldmap

.. _nipype.interfaces.fsl.epi.SigLoss:


.. index:: SigLoss

SigLoss
-------

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L527>`__

Wraps command **sigloss**

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

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import SigLoss
>>> sigloss = SigLoss()
>>> sigloss.inputs.in_file = "phase.nii"
>>> sigloss.inputs.echo_time = 0.03
>>> sigloss.inputs.output_type = "NIFTI_GZ"
>>> sigloss.cmdline #doctest: +ELLIPSIS
'sigloss --te=0.030000 -i phase.nii -s .../phase_sigloss.nii.gz'
>>> res = sigloss.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                b0 fieldmap file
                flag: -i %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        echo_time: (a float)
                echo time in seconds
                flag: --te=%f
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        mask_file: (an existing file name)
                brain mask file
                flag: -m %s
        out_file: (a file name)
                output signal loss estimate file
                flag: -s %s
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        slice_direction: ('x' or 'y' or 'z')
                slicing direction
                flag: -d %s

Outputs::

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

.. _nipype.interfaces.fsl.epi.TOPUP:


.. index:: TOPUP

TOPUP
-----

`Link to code <http://github.com/nipy/nipype/tree/e63e055194d62d2bdc4665688261c03a42fd0025/nipype/interfaces/fsl/epi.py#L219>`__

Wraps command **topup**

Interface for FSL topup, a tool for estimating and correcting
susceptibility induced distortions. See FSL documentation for
`reference <http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/TOPUP>`_,
`usage examples
<http://fsl.fmrib.ox.ac.uk/fsl/fslwiki/topup/ExampleTopupFollowedByApplytopup>`_,
and `exemplary config files
<https://github.com/ahheckel/FSL-scripts/blob/master/rsc/fsl/fsl4/topup/b02b0.cnf`_.

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import TOPUP
>>> topup = TOPUP()
>>> topup.inputs.in_file = "b0_b0rev.nii"
>>> topup.inputs.encoding_file = "topup_encoding.txt"
>>> topup.inputs.output_type = "NIFTI_GZ"
>>> topup.cmdline #doctest: +ELLIPSIS
'topup --config=b02b0.cnf --datain=topup_encoding.txt --imain=b0_b0rev.nii --out=b0_b0rev_base --iout=b0_b0rev_corrected.nii.gz --fout=b0_b0rev_field.nii.gz --logout=b0_b0rev_topup.log'
>>> res = topup.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        encoding_direction: (a list of items which are 'y' or 'x' or 'z' or
                 'x-' or 'y-' or 'z-')
                encoding direction for automatic generation of encoding_file
                flag: --datain=%s
                mutually_exclusive: encoding_file
                requires: readout_times
        encoding_file: (an existing file name)
                name of text file with PE directions/times
                flag: --datain=%s
                mutually_exclusive: encoding_direction
        in_file: (an existing file name)
                name of 4D file with images
                flag: --imain=%s
        readout_times: (a float)
                readout times (dwell times by # phase-encode steps minus 1)
                mutually_exclusive: encoding_file
                requires: encoding_direction
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal
                immediately, `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        config: (a string, nipype default value: b02b0.cnf)
                Name of config file specifying command line arguments
                flag: --config=%s
        environ: (a dictionary with keys which are a value of type 'str' and
                 with values which are a value of type 'str', nipype default value:
                 {})
                Environment variables
        estmov: (1 or 0)
                estimate movements if set
                flag: --estmov=%d
        fwhm: (a float)
                FWHM (in mm) of gaussian smoothing kernel
                flag: --fwhm=%f
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        interp: ('spline' or 'linear')
                Image interpolation model, linear or spline.
                flag: --interp=%s
        max_iter: (an integer)
                max # of non-linear iterations
                flag: --miter=%d
        minmet: (0 or 1)
                Minimisation method 0=Levenberg-Marquardt, 1=Scaled Conjugate
                Gradient
                flag: --minmet=%d
        numprec: ('double' or 'float')
                Precision for representing Hessian, double or float.
                flag: --numprec=%s
        out_base: (a file name)
                base-name of output files (spline coefficients (Hz) and movement
                parameters)
                flag: --out=%s
        out_corrected: (a file name)
                name of 4D image file with unwarped images
                flag: --iout=%s
        out_field: (a file name)
                name of image file with field (Hz)
                flag: --fout=%s
        out_logfile: (a file name)
                name of log-file
                flag: --logout=%s
        output_type: ('NIFTI_PAIR' or 'NIFTI_PAIR_GZ' or 'NIFTI_GZ' or
                 'NIFTI')
                FSL output type
        reg_lambda: (a float)
                lambda weighting value of the regularisation term
                flag: --miter=%0.f
        regmod: ('bending_energy' or 'membrane_energy')
                Regularisation term implementation. Defaults to bending_energy. Note
                that the two functions have vastly different scales. The membrane
                energy is based on the first derivatives and the bending energy on
                the second derivatives. The second derivatives will typically be
                much smaller than the first derivatives, so input lambda will have
                to be larger for bending_energy to yield approximately the same
                level of regularisation.
                flag: --regmod=%s
        regrid: (1 or 0)
                If set (=1), the calculations are done in a different grid
                flag: --regrid=%d
        scale: (0 or 1)
                If set (=1), the images are individually scaled to a common mean
                flag: --scale=%d
        splineorder: (an integer)
                order of spline, 2->Qadratic spline, 3->Cubic spline
                flag: --splineorder=%d
        ssqlambda: (1 or 0)
                Weight lambda by the current value of the ssd. If used (=1), the
                effective weight of regularisation term becomes higher for the
                initial iterations, therefore initial steps are a little smoother
                than they would without weighting. This reduces the risk of finding
                a local minimum.
                flag: --ssqlambda=%d
        subsamp: (an integer)
                sub-sampling scheme
                flag: --subsamp=%d
        warp_res: (a float)
                (approximate) resolution (in mm) of warp basis for the different
                sub-sampling levels.
                flag: --warpres=%f

Outputs::

        out_corrected: (a file name)
                name of 4D image file with unwarped images
        out_enc_file: (a file name)
                encoding directions file output for applytopup
        out_field: (a file name)
                name of image file with field (Hz)
        out_fieldcoef: (an existing file name)
                file containing the field coefficients
        out_logfile: (a file name)
                name of log-file
        out_movpar: (an existing file name)
                movpar.txt output file
