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

interfaces.niftyreg.regutils
============================


.. _nipype.interfaces.niftyreg.regutils.RegAverage:


.. index:: RegAverage

RegAverage
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L437>`__

Wraps the executable command ``reg_average``.

Interface for executable reg_average from NiftyReg platform.

Compute average matrix or image from a list of matrices or image.
The tool can be use to resample images given input transformation
parametrisation as well as to demean transformations in Euclidean or
log-Euclidean space.

This interface is different than the others in the way that the options
will be written in a command file that is given as a parameter.

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegAverage()
>>> one_file = 'im1.nii'
>>> two_file = 'im2.nii'
>>> three_file = 'im3.nii'
>>> node.inputs.avg_files = [one_file, two_file, three_file]
>>> node.cmdline  # doctest: +ELLIPSIS
'reg_average --cmd_file .../reg_average_cmd'

Inputs::

        [Optional]
        demean3_ref_file: (a file name)
                Average images and demean average image that have linear and non-
                rigid transformations to a common space
                argument: ``-demean3 %s``, position: 1
                mutually_exclusive: avg_files, avg_lts_files, avg_ref_file,
                  demean1_ref_file, demean2_ref_file
                requires: warp_files
        warp_files: (a list of items which are a file name)
                transformation files and floating image pairs/triplets to the
                reference space
                argument: ``%s``, position: -1
                mutually_exclusive: avg_files, avg_lts_files
        out_file: (a file name)
                Output file name
                argument: ``%s``, position: 0
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        demean2_ref_file: (a file name)
                Average images and demean average image that have non-rigid
                transformations to a common space
                argument: ``-demean2 %s``, position: 1
                mutually_exclusive: avg_files, avg_lts_files, avg_ref_file,
                  demean1_ref_file, demean3_ref_file
                requires: warp_files
        demean1_ref_file: (a file name)
                Average images and demean average image that have affine
                transformations to a common space
                argument: ``-demean1 %s``, position: 1
                mutually_exclusive: avg_files, avg_lts_files, avg_ref_file,
                  demean2_ref_file, demean3_ref_file
                requires: warp_files
        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
        avg_files: (a list of items which are a file name)
                Averaging of images/affine transformations
                argument: ``-avg %s``, position: 1
                mutually_exclusive: avg_lts_files, avg_ref_file, demean1_ref_file,
                  demean2_ref_file, demean3_ref_file, warp_files
        avg_ref_file: (a file name)
                All input images are resampled into the space of <reference image>
                and averaged. A cubic spline interpolation scheme is used for
                resampling
                argument: ``-avg_tran %s``, position: 1
                mutually_exclusive: avg_files, avg_lts_files, demean1_ref_file,
                  demean2_ref_file, demean3_ref_file
                requires: warp_files
        avg_lts_files: (a list of items which are a file name)
                Robust average of affine transformations
                argument: ``-avg_lts %s``, position: 1
                mutually_exclusive: avg_files, avg_ref_file, demean1_ref_file,
                  demean2_ref_file, demean3_ref_file, warp_files

Outputs::

        out_file: (a file name)
                Output file name

.. _nipype.interfaces.niftyreg.regutils.RegJacobian:


.. index:: RegJacobian

RegJacobian
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L161>`__

Wraps the executable command ``reg_jacobian``.

Interface for executable reg_resample from NiftyReg platform.

Tool to generate Jacobian determinant maps from transformation
parametrisation generated by reg_f3d

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegJacobian()
>>> node.inputs.ref_file = 'im1.nii'
>>> node.inputs.trans_file = 'warpfield.nii'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_jacobian -omp 4 -ref im1.nii -trans warpfield.nii -jac warpfield_jac.nii.gz'

Inputs::

        [Mandatory]
        trans_file: (an existing file name)
                The input non-rigid transformation
                argument: ``-trans %s``

        [Optional]
        out_file: (a file name)
                The output jacobian determinant file name
                argument: ``%s``, position: -1
        ref_file: (an existing file name)
                Reference/target file (required if specifying CPP transformations.
                argument: ``-ref %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        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
        type: (u'jac' or u'jacL' or u'jacM', nipype default value: jac)
                Type of jacobian outcome
                argument: ``-%s``, position: -2

Outputs::

        out_file: (a file name)
                The output file

.. _nipype.interfaces.niftyreg.regutils.RegMeasure:


.. index:: RegMeasure

RegMeasure
----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L805>`__

Wraps the executable command ``reg_measure``.

Interface for executable reg_measure from NiftyReg platform.

Given two input images, compute the specified measure(s) of similarity

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegMeasure()
>>> node.inputs.ref_file = 'im1.nii'
>>> node.inputs.flo_file = 'im2.nii'
>>> node.inputs.measure_type = 'lncc'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_measure -flo im2.nii -lncc -omp 4 -out im2_lncc.txt -ref im1.nii'

Inputs::

        [Mandatory]
        ref_file: (an existing file name)
                The input reference/target image
                argument: ``-ref %s``
        flo_file: (an existing file name)
                The input floating/source image
                argument: ``-flo %s``
        measure_type: (u'ncc' or u'lncc' or u'nmi' or u'ssd')
                Measure of similarity to compute
                argument: ``-%s``

        [Optional]
        out_file: (a file name)
                The output text file containing the measure
                argument: ``-out %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        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

Outputs::

        out_file: (a file name)
                The output text file containing the measure

.. _nipype.interfaces.niftyreg.regutils.RegResample:


.. index:: RegResample

RegResample
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L88>`__

Wraps the executable command ``reg_resample``.

Interface for executable reg_resample from NiftyReg platform.

Tool to resample floating image in the space of a defined reference image
given a transformation parametrisation generated by reg_aladin, reg_f3d or
reg_transform

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegResample()
>>> node.inputs.ref_file = 'im1.nii'
>>> node.inputs.flo_file = 'im2.nii'
>>> node.inputs.trans_file = 'warpfield.nii'
>>> node.inputs.inter_val = 'LIN'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_resample -flo im2.nii -inter 1 -omp 4 -ref im1.nii -trans warpfield.nii -res im2_res.nii.gz'

Inputs::

        [Mandatory]
        ref_file: (an existing file name)
                The input reference/target image
                argument: ``-ref %s``
        flo_file: (an existing file name)
                The input floating/source image
                argument: ``-flo %s``

        [Optional]
        trans_file: (an existing file name)
                The input transformation file
                argument: ``-trans %s``
        psf_alg: (0 or 1)
                Minimise the matrix metric (0) or the determinant (1) when
                estimating the PSF [0]
                argument: ``-psf_alg %d``
        out_file: (a file name)
                The output filename of the transformed image
                argument: ``%s``, position: -1
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        tensor_flag: (a boolean)
                Resample Tensor Map
                argument: ``-tensor ``
        psf_flag: (a boolean)
                Perform the resampling in two steps to resample an image to a lower
                resolution
                argument: ``-psf``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        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
        verbosity_off_flag: (a boolean)
                Turn off verbose output
                argument: ``-voff``
        inter_val: (u'NN' or u'LIN' or u'CUB' or u'SINC')
                Interpolation type
                argument: ``-inter %d``
        type: (u'res' or u'blank', nipype default value: res)
                Type of output
                argument: ``-%s``, position: -2
        pad_val: (a float)
                Padding value
                argument: ``-pad %f``

Outputs::

        out_file: (a file name)
                The output filename of the transformed image

.. _nipype.interfaces.niftyreg.regutils.RegTools:


.. index:: RegTools

RegTools
--------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L306>`__

Wraps the executable command ``reg_tools``.

Interface for executable reg_tools from NiftyReg platform.

Tool delivering various actions related to registration such as
resampling the input image to a chosen resolution or remove the nan and
inf in the input image by a specified value.

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegTools()
>>> node.inputs.in_file = 'im1.nii'
>>> node.inputs.mul_val = 4
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_tools -in im1.nii -mul 4.0 -omp 4 -out im1_tools.nii.gz'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                The input image file path
                argument: ``-in %s``

        [Optional]
        mul_val: (a float or an existing file name)
                Multiply the input by image or value
                argument: ``-mul %s``
        thr_val: (a float)
                Binarise the input image with the given threshold
                argument: ``-thr %f``
        mask_file: (an existing file name)
                Values outside the mask are set to NaN
                argument: ``-nan %s``
        down_flag: (a boolean)
                Downsample the image by a factor of 2
                argument: ``-down``
        rms_val: (an existing file name)
                Compute the mean RMS between the images
                argument: ``-rms %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        bin_flag: (a boolean)
                Binarise the input image
                argument: ``-bin``
        add_val: (a float or an existing file name)
                Add to the input image or value
                argument: ``-add %s``
        smo_s_val: (a tuple of the form: (a float, a float, a float))
                Smooth the input image using a cubic spline kernel
                argument: ``-smoS %f %f %f``
        noscl_flag: (a boolean)
                Set scale, slope to 0 and 1
                argument: ``-noscl``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        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
        smo_g_val: (a tuple of the form: (a float, a float, a float))
                Smooth the input image using a Gaussian kernel
                argument: ``-smoG %f %f %f``
        div_val: (a float or an existing file name)
                Divide the input by image or value
                argument: ``-div %s``
        iso_flag: (a boolean)
                Make output image isotropic
                argument: ``-iso``
        chg_res_val: (a tuple of the form: (a float, a float, a float))
                Change the resolution of the input image
                argument: ``-chgres %f %f %f``
        inter_val: (u'NN' or u'LIN' or u'CUB' or u'SINC')
                Interpolation order to use to warp the floating image
                argument: ``-interp %d``
        sub_val: (a float or an existing file name)
                Add to the input image or value
                argument: ``-sub %s``
        out_file: (a file name)
                The output file name
                argument: ``-out %s``

Outputs::

        out_file: (an existing file name)
                The output file

.. _nipype.interfaces.niftyreg.regutils.RegTransform:


.. index:: RegTransform

RegTransform
------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/niftyreg/regutils.py#L683>`__

Wraps the executable command ``reg_transform``.

Interface for executable reg_transform from NiftyReg platform.

Tools to convert transformation parametrisation from one type to another
as well as to compose, inverse or half transformations.

`Source code <https://cmiclab.cs.ucl.ac.uk/mmodat/niftyreg>`_

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegTransform()
>>> node.inputs.def_input = 'warpfield.nii'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline  # doctest: +ELLIPSIS
'reg_transform -omp 4 -def warpfield.nii .../warpfield_trans.nii.gz'

Inputs::

        [Optional]
        upd_s_form_input: (an existing file name)
                Update s-form using the affine transformation
                argument: ``-updSform %s``, position: -3
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  inv_aff_input, inv_nrr_input, half_input, make_aff_input,
                  aff_2_rig_input, flirt_2_nr_input
                requires: upd_s_form_input2
        inv_nrr_input: (a tuple of the form: (an existing file name, an
                  existing file name))
                Invert a non-linear transformation
                argument: ``-invNrr %s %s``, position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, half_input, make_aff_input,
                  aff_2_rig_input, flirt_2_nr_input
        out_file: (a file name)
                transformation file to write
                argument: ``%s``, position: -1
        inv_aff_input: (an existing file name)
                Invert an affine transformation
                argument: ``-invAff %s``, position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_nrr_input, half_input, make_aff_input,
                  aff_2_rig_input, flirt_2_nr_input
        half_input: (an existing file name)
                Half way to the input transformation
                argument: ``-half %s``, position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, make_aff_input,
                  aff_2_rig_input, flirt_2_nr_input
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        make_aff_input: (a tuple of the form: (a float, a float, a float, a
                  float, a float, a float, a float, a float, a float, a float, a
                  float, a float))
                Make an affine transformation matrix
                argument: ``-makeAff %f %f %f %f %f %f %f %f %f %f %f %f``,
                position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  aff_2_rig_input, flirt_2_nr_input
        comp_input: (an existing file name)
                compose two transformations
                argument: ``-comp %s``, position: -3
                mutually_exclusive: def_input, disp_input, flow_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, aff_2_rig_input, flirt_2_nr_input
                requires: comp_input2
        upd_s_form_input2: (an existing file name)
                Update s-form using the affine transformation
                argument: ``%s``, position: -2
                requires: upd_s_form_input
        flirt_2_nr_input: (a tuple of the form: (an existing file name, an
                  existing file name, an existing file name))
                Convert a FLIRT affine transformation to niftyreg affine
                transformation
                argument: ``-flirtAff2NR %s %s %s``, position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, aff_2_rig_input
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        flow_input: (an existing file name)
                Compute flow field from spline SVF
                argument: ``-flow %s``, position: -2
                mutually_exclusive: def_input, disp_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, aff_2_rig_input, flirt_2_nr_input
        ref1_file: (an existing file name)
                The input reference/target image
                argument: ``-ref %s``, position: 0
        comp_input2: (an existing file name)
                compose two transformations
                argument: ``%s``, position: -2
        ref2_file: (an existing file name)
                The input second reference/target image
                argument: ``-ref2 %s``, position: 1
                requires: ref1_file
        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
        aff_2_rig_input: (an existing file name)
                Extract the rigid component from affine transformation
                argument: ``-aff2rig %s``, position: -2
                mutually_exclusive: def_input, disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, flirt_2_nr_input
        def_input: (an existing file name)
                Compute deformation field from transformation
                argument: ``-def %s``, position: -2
                mutually_exclusive: disp_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, aff_2_rig_input, flirt_2_nr_input
        disp_input: (an existing file name)
                Compute displacement field from transformation
                argument: ``-disp %s``, position: -2
                mutually_exclusive: def_input, flow_input, comp_input,
                  upd_s_form_input, inv_aff_input, inv_nrr_input, half_input,
                  make_aff_input, aff_2_rig_input, flirt_2_nr_input

Outputs::

        out_file: (a file name)
                Output File (transformation in any format)
