interfaces.fsl.epi

ApplyTOPUP

Link to code

Wraps the executable command applytopup.

Interface for FSL topup, a tool for estimating and correcting susceptibility induced distortions. General reference and use example.

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 
'applytopup --datain=topup_encoding.txt --imain=epi.nii,epi_rev.nii --inindex=1,2 --topup=topup --out=epi_corrected.nii.gz'
>>> res = applytopup.run() 

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

EPIDeWarp

Link to code

Wraps the executable command epidewarp.fsl.

Wraps the unwarping script epidewarp.fsl.

Warning

deprecated in FSL, please use 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 
'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() 

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

Eddy

Link to code

Wraps the executable command eddy_openmp.

Interface for FSL eddy, a tool for estimating and correcting eddy currents induced distortions. User guide and more info regarding 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 
'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 
'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() 

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

EddyCorrect

Link to code

Wraps the executable command eddy_correct.

Warning

Deprecated in FSL. Please use 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

EpiReg

Link to code

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 
'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() 

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

PrepareFieldmap

Link to code

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 
'fsl_prepare_fieldmap SIEMENS phase.nii magnitude.nii .../phase_fslprepared.nii.gz 2.460000'
>>> res = prepare.run() 

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

SigLoss

Link to code

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 
'sigloss --te=0.030000 -i phase.nii -s .../phase_sigloss.nii.gz'
>>> res = sigloss.run() 

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

TOPUP

Link to code

Wraps the executable command topup.

Interface for FSL topup, a tool for estimating and correcting susceptibility induced distortions. See FSL documentation for reference, usage examples, and exemplary config files.

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 
'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() 

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