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

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


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


.. index:: ApplyTOPUP

ApplyTOPUP
----------

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

Wraps the executable 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_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]
        in_files: (a list of items which are an existing file name)
                name of file with images
                argument: ``--imain=%s``
        encoding_file: (an existing file name)
                name of text file with PE directions/times
                argument: ``--datain=%s``

        [Optional]
        out_corrected: (a file name)
                output (warped) image
                argument: ``--out=%s``
        datatype: (u'char' or u'short' or u'int' or u'float' or u'double')
                force output data type
                argument: ``-d=%s``
        in_index: (a list of items which are an integer (int or long))
                comma separated list of indices corresponding to --datain
                argument: ``--inindex=%s``
        in_topup_fieldcoef: (an existing file name)
                topup file containing the field coefficients
                argument: ``--topup=%s``
                requires: in_topup_movpar
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        interp: (u'trilinear' or u'spline')
                interpolation method
                argument: ``--interp=%s``
        method: (u'jac' or u'lsr')
                use jacobian modulation (jac) or least-squares resampling (lsr)
                argument: ``--method=%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
        in_topup_movpar: (an existing file name)
                topup movpar.txt file
                requires: in_topup_fieldcoef

Outputs::

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

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

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


.. index:: EPIDeWarp

EPIDeWarp
---------

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

Wraps the executable 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]
        mag_file: (an existing file name)
                Magnitude file
                argument: ``--mag %s``, position: 0
        dph_file: (an existing file name)
                Phase file assumed to be scaled from 0 to 4095
                argument: ``--dph %s``

        [Optional]
        exf_file: (an existing file name)
                example func volume (or use epi)
                argument: ``--exf %s``
        esp: (a float, nipype default value: 0.58)
                EPI echo spacing
                argument: ``--esp %s``
        nocleanup: (a boolean, nipype default value: True)
                no cleanup
                argument: ``--nocleanup``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        epi_file: (an existing file name)
                EPI volume to unwarp
                argument: ``--epi %s``
        tmpdir: (a string)
                tmpdir
                argument: ``--tmpdir %s``
        cleanup: (a boolean)
                cleanup
                argument: ``--cleanup``
        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
        exfdw: (a string)
                dewarped example func volume
                argument: ``--exfdw %s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        epidw: (a string)
                dewarped epi volume
                argument: ``--epidw %s``
        sigma: (an integer (int or long), nipype default value: 2)
                2D spatial gaussing smoothing stdev (default = 2mm)
                argument: ``--sigma %s``
        vsm: (a string)
                voxel shift map
                argument: ``--vsm %s``
        tediff: (a float, nipype default value: 2.46)
                difference in B0 field map TEs
                argument: ``--tediff %s``

Outputs::

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

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

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


.. index:: Eddy

Eddy
----

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

Wraps the executable command ``eddy_openmp``.

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.inputs.use_cuda = True
>>> eddy.cmdline # doctest: +ELLIPSIS
'eddy_cuda --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --niter=5 --nvoxhp=1000 --out=.../eddy_corrected'
>>> eddy.inputs.use_cuda = False
>>> eddy.cmdline # doctest: +ELLIPSIS
'eddy_openmp --ff=10.0 --acqp=epi_acqp.txt --bvals=bvals.scheme --bvecs=bvecs.scheme --imain=epi.nii --index=epi_index.txt --mask=epi_mask.nii --niter=5 --nvoxhp=1000 --out=.../eddy_corrected'
>>> res = eddy.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_acqp: (an existing file name)
                File containing acquisition parameters
                argument: ``--acqp=%s``
        in_index: (an existing file name)
                File containing indices for all volumes in --imain into --acqp and
                --topup
                argument: ``--index=%s``
        in_mask: (an existing file name)
                Mask to indicate brain
                argument: ``--mask=%s``
        in_file: (an existing file name)
                File containing all the images to estimate distortions for
                argument: ``--imain=%s``
        in_bval: (an existing file name)
                File containing the b-values for all volumes in --imain
                argument: ``--bvals=%s``
        in_bvec: (an existing file name)
                File containing the b-vectors for all volumes in --imain
                argument: ``--bvecs=%s``

        [Optional]
        out_base: (a unicode string, nipype default value: eddy_corrected)
                basename for output (warped) image
                argument: ``--out=%s``
        session: (an existing file name)
                File containing session indices for all volumes in --imain
                argument: ``--session=%s``
        repol: (a boolean)
                Detect and replace outlier slices
                argument: ``--repol``
        fwhm: (a float)
                FWHM for conditioning filter when estimating the parameters
                argument: ``--fwhm=%s``
        in_topup_movpar: (an existing file name)
                topup movpar.txt file
                requires: in_topup_fieldcoef
        field: (a unicode string)
                NonTOPUP fieldmap scaled in Hz - filename has to be provided without
                an extension. TOPUP is strongly recommended
                argument: ``--field=%s``
        fep: (a boolean)
                Fill empty planes in x- or y-directions
                argument: ``--fep``
        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
        method: (u'jac' or u'lsr')
                Final resampling method (jacobian/least squares)
                argument: ``--resamp=%s``
        fudge_factor: (a float, nipype default value: 10.0)
                Fudge factor for hyperparameter error variance
                argument: ``--ff=%s``
        is_shelled: (a boolean)
                Override internal check to ensure that date are acquired on a set of
                b-value shells
                argument: ``--data_is_shelled``
        niter: (an integer (int or long), nipype default value: 5)
                Number of iterations
                argument: ``--niter=%s``
        interp: (u'spline' or u'trilinear')
                Interpolation model for estimation step
                argument: ``--interp=%s``
        in_topup_fieldcoef: (an existing file name)
                topup file containing the field coefficients
                argument: ``--topup=%s``
                requires: in_topup_movpar
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        nvoxhp: (an integer (int or long), nipype default value: 1000)
                # of voxels used to estimate the hyperparameters
                argument: ``--nvoxhp=%s``
        dont_peas: (a boolean)
                Do NOT perform a post-eddy alignment of shells
                argument: ``--dont_peas``
        field_mat: (an existing file name)
                Matrix that specifies the relative locations of the field specified
                by --field and first volume in file --imain
                argument: ``--field_mat=%s``
        num_threads: (an integer (int or long), nipype default value: 1)
                Number of openmp threads to use
        dont_sep_offs_move: (a boolean)
                Do NOT attempt to separate field offset from subject movement
                argument: ``--dont_sep_offs_move``
        use_cuda: (a boolean)
                Run eddy using cuda gpu
        slm: (u'none' or u'linear' or u'quadratic')
                Second level EC model
                argument: ``--slm=%s``
        cnr_maps: (a boolean)
                Output CNR-Maps
                argument: ``--cnr_maps``
        flm: (u'linear' or u'quadratic' or u'cubic')
                First level EC model
                argument: ``--flm=%s``
        residuals: (a boolean)
                Output Residuals
                argument: ``--residuals``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

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 andmovement for each
                scan
        out_cnr_maps: (an existing file name)
                path/name of file with the cnr_maps
        out_residuals: (an existing file name)
                path/name of file with the residuals
        out_shell_alignment_parameters: (an existing file name)
                File containing rigid body movement parameters between the different
                shells as estimated by a post-hoc mutual information based
                registration
        out_movement_rms: (an existing file name)
                Summary of the "total movement" in each volume
        out_outlier_report: (an existing file name)
                Text-file with a plain language report on what outlier slices eddy
                has found
        out_restricted_movement_rms: (an existing file name)
                Summary of the "total movement" in each volume disregarding
                translation in the PE direction
        out_rotated_bvecs: (an existing file name)
                File containing rotated b-values for all volumes

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

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


.. index:: EddyCorrect

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

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

Wraps the executable 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]
        ref_num: (an integer (int or long), nipype default value: 0)
                reference number
                argument: ``%d``, position: 2
        in_file: (an existing file name)
                4D input file
                argument: ``%s``, position: 0

        [Optional]
        out_file: (a file name)
                4D output file
                argument: ``%s``, 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
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

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

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

.. _nipype.interfaces.fsl.epi.EddyQuad:


.. index:: EddyQuad

EddyQuad
--------

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

Wraps the executable command ``eddy_quad``.

Interface for FSL eddy_quad, a tool for generating single subject reports
and storing the quality assessment indices for each subject.
`User guide <https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/eddyqc/UsersGuide>`_

Examples
~~~~~~~~

>>> from nipype.interfaces.fsl import EddyQuad
>>> quad = EddyQuad()
>>> quad.inputs.base_name  = 'eddy_corrected'
>>> quad.inputs.idx_file   = 'epi_index.txt'
>>> quad.inputs.param_file = 'epi_acqp.txt'
>>> quad.inputs.mask_file  = 'epi_mask.nii'
>>> quad.inputs.bval_file  = 'bvals.scheme'
>>> quad.inputs.bvec_file  = 'bvecs.scheme'
>>> quad.inputs.output_dir = 'eddy_corrected.qc'
>>> quad.inputs.field      = 'fieldmap_phase_fslprepared.nii'
>>> quad.inputs.verbose    = True
>>> quad.cmdline
'eddy_quad eddy_corrected --bvals=bvals.scheme --bvecs=bvecs.scheme --field=fieldmap_phase_fslprepared.nii --eddyIdx=epi_index.txt --mask=epi_mask.nii --output-dir=eddy_corrected.qc --eddyParams=epi_acqp.txt --verbose'
>>> res = quad.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        mask_file: (an existing file name)
                Binary mask file
                argument: ``--mask=%s``
        bval_file: (an existing file name)
                b-values file
                argument: ``--bvals=%s``
        idx_file: (an existing file name)
                File containing indices for all volumes into acquisition parameters
                argument: ``--eddyIdx=%s``
        param_file: (an existing file name)
                File containing acquisition parameters
                argument: ``--eddyParams=%s``

        [Optional]
        bvec_file: (an existing file name)
                b-vectors file - only used when <base_name>.eddy_residuals file is
                present
                argument: ``--bvecs=%s``
        verbose: (a boolean)
                Display debug messages
                argument: ``--verbose``
        base_name: (a unicode string, nipype default value: eddy_corrected)
                Basename (including path) for EDDY output files, i.e., corrected
                images and QC files
                argument: ``%s``, position: 0
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        field: (an existing file name)
                TOPUP estimated field (in Hz)
                argument: ``--field=%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_dir: (a unicode string)
                Output directory - default = '<base_name>.qc'
                argument: ``--output-dir=%s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        slice_spec: (an existing file name)
                Text file specifying slice/group acquisition
                argument: ``--slspec=%s``

Outputs::

        avg_b0_pe_png: (a list of items which are an existing file name)
                Image showing mid-sagittal, -coronal and -axial slices of each
                averaged pe-direction b0 volume. Generated when using the -f option.
        avg_b_png: (a list of items which are an existing file name)
                Image showing mid-sagittal, -coronal and -axial slices of each
                averaged b-shell volume.
        vdm_png: (an existing file name)
                Image showing mid-sagittal, -coronal and -axial slices of the voxel
                displacement map. Generated when using the -f option.
        cnr_png: (a list of items which are an existing file name)
                Image showing mid-sagittal, -coronal and -axial slices of each
                b-shell CNR volume. Generated when CNR maps are available.
        residuals: (an existing file name)
                Text file containing the volume-wise mask-averaged squared
                residuals. Generated when residual maps are available.
        qc_pdf: (an existing file name)
                Single subject QC report.
        clean_volumes: (an existing file name)
                Text file containing a list of clean volumes, based on the eddy
                squared residuals. To generate a version of the pre-processed
                dataset without outlier volumes, use: `fslselectvols -i
                <eddy_corrected_data> -o eddy_corrected_data_clean
                --vols=vols_no_outliers.txt`
        qc_json: (an existing file name)
                Single subject database containing quality metrics and data info.

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

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


.. index:: EpiReg

EpiReg
------

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

Wraps the executable 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 --noclean --pedir=y --epi=epi.nii --t1=T1.nii --t1brain=T1_brain.nii --out=epi2struct'
>>> epireg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        t1_head: (an existing file name)
                wholehead T1 image
                argument: ``--t1=%s``, position: -3
        t1_brain: (an existing file name)
                brain extracted T1 image
                argument: ``--t1brain=%s``, position: -2
        epi: (an existing file name)
                EPI image
                argument: ``--epi=%s``, position: -4

        [Optional]
        fmap: (an existing file name)
                fieldmap image (in rad/s)
                argument: ``--fmap=%s``
        no_fmapreg: (a boolean)
                do not perform registration of fmap to T1 (use if fmap already
                registered)
                argument: ``--nofmapreg``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        fmapmag: (an existing file name)
                fieldmap magnitude image - wholehead
                argument: ``--fmapmag=%s``
        no_clean: (a boolean, nipype default value: True)
                do not clean up intermediate files
                argument: ``--noclean``
        out_base: (a string, nipype default value: epi2struct)
                output base name
                argument: ``--out=%s``, position: -1
        wmseg: (an existing file name)
                white matter segmentation of T1 image, has to be named like the
                t1brain and end on _wmseg
                argument: ``--wmseg=%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
        weight_image: (an existing file name)
                weighting image (in T1 space)
                argument: ``--weight=%s``
        pedir: (u'x' or u'y' or u'z' or u'-x' or u'-y' or u'-z')
                phase encoding direction, dir = x/y/z/-x/-y/-z
                argument: ``--pedir=%s``
        echospacing: (a float)
                Effective EPI echo spacing (sometimes called dwell time) - in
                seconds
                argument: ``--echospacing=%f``
        fmapmagbrain: (an existing file name)
                fieldmap magnitude image - brain extracted
                argument: ``--fmapmagbrain=%s``

Outputs::

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

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

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


.. index:: PrepareFieldmap

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

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

Wraps the executable 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)
                argument: ``%f``, position: -2
        in_phase: (an existing file name)
                Phase difference map, in SIEMENS format range from 0-4096 or 0-8192)
                argument: ``%s``, position: 2
        in_magnitude: (an existing file name)
                Magnitude difference map, brain extracted
                argument: ``%s``, position: 3

        [Optional]
        out_fieldmap: (a file name)
                output name for prepared fieldmap
                argument: ``%s``, position: 4
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        nocheck: (a boolean, nipype default value: False)
                do not perform sanity checks for image size/range/dimensions
                argument: ``--nocheck``, 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
        scanner: (a string, nipype default value: SIEMENS)
                must be SIEMENS
                argument: ``%s``, position: 1

Outputs::

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

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

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


.. index:: SigLoss

SigLoss
-------

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

Wraps the executable 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
                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.epi.TOPUP:


.. index:: TOPUP

TOPUP
-----

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

Wraps the executable 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 --jacout=jac --logout=b0_b0rev_topup.log --rbmout=xfm --dfout=warpfield'
>>> res = topup.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        readout_times: (a list of items which are a float)
                readout times (dwell times by # phase-encode steps minus 1)
                mutually_exclusive: encoding_file
                requires: encoding_direction
        encoding_direction: (a list of items which are u'y' or u'x' or u'z'
                  or u'x-' or u'y-' or u'z-')
                encoding direction for automatic generation of encoding_file
                argument: ``--datain=%s``
                mutually_exclusive: encoding_file
                requires: readout_times
        in_file: (an existing file name)
                name of 4D file with images
                argument: ``--imain=%s``
        encoding_file: (an existing file name)
                name of text file with PE directions/times
                argument: ``--datain=%s``
                mutually_exclusive: encoding_direction

        [Optional]
        minmet: (0 or 1)
                Minimisation method 0=Levenberg-Marquardt, 1=Scaled Conjugate
                Gradient
                argument: ``--minmet=%d``
        splineorder: (an integer (int or long))
                order of spline, 2->Qadratic spline, 3->Cubic spline
                argument: ``--splineorder=%d``
        out_base: (a file name)
                base-name of output files (spline coefficients (Hz) and movement
                parameters)
                argument: ``--out=%s``
        out_mat_prefix: (a unicode string, nipype default value: xfm)
                prefix for the realignment matrices
                argument: ``--rbmout=%s``
        subsamp: (an integer (int or long))
                sub-sampling scheme
                argument: ``--subsamp=%d``
        regmod: (u'bending_energy' or u'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.
                argument: ``--regmod=%s``
        out_logfile: (a file name)
                name of log-file
                argument: ``--logout=%s``
        scale: (0 or 1)
                If set (=1), the images are individually scaled to a common mean
                argument: ``--scale=%d``
        fwhm: (a float)
                FWHM (in mm) of gaussian smoothing kernel
                argument: ``--fwhm=%f``
        out_jac_prefix: (a unicode string, nipype default value: jac)
                prefix for the warpfield images
                argument: ``--jacout=%s``
        out_field: (a file name)
                name of image file with field (Hz)
                argument: ``--fout=%s``
        regrid: (1 or 0)
                If set (=1), the calculations are done in a different grid
                argument: ``--regrid=%d``
        config: (a string, nipype default value: b02b0.cnf)
                Name of config file specifying command line arguments
                argument: ``--config=%s``
        out_corrected: (a file name)
                name of 4D image file with unwarped images
                argument: ``--iout=%s``
        max_iter: (an integer (int or long))
                max # of non-linear iterations
                argument: ``--miter=%d``
        interp: (u'spline' or u'linear')
                Image interpolation model, linear or spline.
                argument: ``--interp=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        warp_res: (a float)
                (approximate) resolution (in mm) of warp basis for the different
                sub-sampling levels
                argument: ``--warpres=%f``
        estmov: (1 or 0)
                estimate movements if set
                argument: ``--estmov=%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.
                argument: ``--ssqlambda=%d``
        reg_lambda: (a float)
                Weight of regularisation, default depending on --ssqlambda and
                --regmod switches.
                argument: ``--lambda=%0.f``
        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
        numprec: (u'double' or u'float')
                Precision for representing Hessian, double or float.
                argument: ``--numprec=%s``
        out_warp_prefix: (a unicode string, nipype default value: warpfield)
                prefix for the warpfield images (in mm)
                argument: ``--dfout=%s``

Outputs::

        out_corrected: (a file name)
                name of 4D image file with unwarped images
        out_movpar: (an existing file name)
                movpar.txt output file
        out_mats: (a list of items which are an existing file name)
                realignment matrices
        out_fieldcoef: (an existing file name)
                file containing the field coefficients
        out_logfile: (a file name)
                name of log-file
        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_jacs: (a list of items which are an existing file name)
                Jacobian images
        out_warps: (a list of items which are an existing file name)
                warpfield images

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