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

interfaces.niftyreg.reg
=======================


.. _nipype.interfaces.niftyreg.reg.RegAladin:


.. index:: RegAladin

RegAladin
---------

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

Wraps the executable command ``reg_aladin``.

Interface for executable reg_aladin from NiftyReg platform.

Block Matching algorithm for symmetric global registration.
Based on Modat et al., "Global image registration using
asymmetric block-matching approach"
J. Med. Img. 1(2) 024003, 2014, doi: 10.1117/1.JMI.1.2.024003

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

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegAladin()
>>> node.inputs.ref_file = 'im1.nii'
>>> node.inputs.flo_file = 'im2.nii'
>>> node.inputs.rmask_file = 'mask.nii'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_aladin -aff im2_aff.txt -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.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``

        [Optional]
        maxit_val: (an integer >= 0)
                Maximum number of iterations
                argument: ``-maxit %d``
        flo_low_val: (a float)
                Lower threshold value on floating image
                argument: ``-floLowThr %f``
        ref_up_val: (a float)
                Upper threshold value on reference image
                argument: ``-refUpThr %f``
        v_val: (an integer >= 0)
                Percent of blocks that are active
                argument: ``-pv %d``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        in_aff_file: (an existing file name)
                The input affine transformation
                argument: ``-inaff %s``
        cog_flag: (a boolean)
                Use the masks centre of mass to initialise the transformation
                argument: ``-cog``
        flo_up_val: (a float)
                Upper threshold value on floating image
                argument: ``-floUpThr %f``
        gpuid_val: (an integer (int or long))
                Device to use id
                argument: ``-gpuid %i``
        ref_low_val: (a float)
                Lower threshold value on reference image
                argument: ``-refLowThr %f``
        i_val: (an integer >= 0)
                Percent of inlier blocks
                argument: ``-pi %d``
        nosym_flag: (a boolean)
                Turn off symmetric registration
                argument: ``-noSym``
        aff_file: (a file name)
                The output affine matrix file
                argument: ``-aff %s``
        platform_val: (an integer (int or long))
                Platform index
                argument: ``-platf %i``
        fmask_file: (an existing file name)
                The input floating mask
                argument: ``-fmask %s``
        smoo_f_val: (a float)
                Amount of smoothing to apply to floating image
                argument: ``-smooF %f``
        rig_only_flag: (a boolean)
                Do only a rigid registration
                argument: ``-rigOnly``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        aff_direct_flag: (a boolean)
                Directly optimise the affine parameters
                argument: ``-affDirect``
        verbosity_off_flag: (a boolean)
                Turn off verbose output
                argument: ``-voff``
        nac_flag: (a boolean)
                Use nifti header to initialise transformation
                argument: ``-nac``
        ln_val: (an integer >= 0)
                Number of resolution levels to create
                argument: ``-ln %d``
        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
        res_file: (a file name)
                The affine transformed floating image
                argument: ``-res %s``
        rmask_file: (an existing file name)
                The input reference mask
                argument: ``-rmask %s``
        lp_val: (an integer >= 0)
                Number of resolution levels to perform
                argument: ``-lp %d``
        smoo_r_val: (a float)
                Amount of smoothing to apply to reference image
                argument: ``-smooR %f``

Outputs::

        avg_output: (a string)
                Output string in the format for reg_average
        aff_file: (a file name)
                The output affine file
        res_file: (a file name)
                The output transformed image

.. _nipype.interfaces.niftyreg.reg.RegF3D:


.. index:: RegF3D

RegF3D
------

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

Wraps the executable command ``reg_f3d``.

Interface for executable reg_f3d from NiftyReg platform.

Fast Free-Form Deformation (F3D) algorithm for non-rigid registration.
Initially based on Modat et al., "Fast Free-Form Deformation using
graphics processing units", CMPB, 2010

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

Examples
~~~~~~~~
>>> from nipype.interfaces import niftyreg
>>> node = niftyreg.RegF3D()
>>> node.inputs.ref_file = 'im1.nii'
>>> node.inputs.flo_file = 'im2.nii'
>>> node.inputs.rmask_file = 'mask.nii'
>>> node.inputs.omp_core_val = 4
>>> node.cmdline
'reg_f3d -cpp im2_cpp.nii.gz -flo im2.nii -omp 4 -ref im1.nii -res im2_res.nii.gz -rmask mask.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``

        [Optional]
        fupth2_thr_val: (a tuple of the form: (an integer >= 0, a float))
                Upper threshold for floating image at the specified time point
                argument: ``-fUpTh %d %f``
        maxit_val: (an integer >= 0)
                Maximum number of iterations per level
                argument: ``-maxit %d``
        flwth_thr_val: (a float)
                Lower threshold for floating image
                argument: ``--fLwTh %f``
        pad_val: (a float)
                Padding value
                argument: ``-pad %f``
        flwth2_thr_val: (a tuple of the form: (an integer >= 0, a float))
                Lower threshold for floating image at the specified time point
                argument: ``-fLwTh %d %f``
        omp_core_val: (an integer (int or long), nipype default value: 1)
                Number of openmp thread to use
                argument: ``-omp %i``
        rbn_val: (an integer >= 0)
                Number of bins in the histogram for reference image
                argument: ``--rbn %d``
        vel_flag: (a boolean)
                Use velocity field integration
                argument: ``-vel``
        rupth_thr_val: (a float)
                Upper threshold for reference image
                argument: ``--rUpTh %f``
        fbn2_val: (a tuple of the form: (an integer >= 0, an integer >= 0))
                Number of bins in the histogram for reference image for given time
                point
                argument: ``-fbn %d %d``
        be_val: (a float)
                Bending energy value
                argument: ``-be %f``
        le_val: (a float)
                Linear elasticity penalty term
                argument: ``-le %f``
        rbn2_val: (a tuple of the form: (an integer >= 0, an integer >= 0))
                Number of bins in the histogram for reference image for given time
                point
                argument: ``-rbn %d %d``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        sy_val: (a float)
                Final grid spacing along the y axes
                argument: ``-sy %f``
        incpp_file: (an existing file name)
                The input cpp transformation file
                argument: ``-incpp %s``
        kld_flag: (a boolean)
                Use KL divergence as the similarity measure
                argument: ``--kld``
        rlwth_thr_val: (a float)
                Lower threshold for reference image
                argument: ``--rLwTh %f``
        lncc_val: (a float)
                SD of the Gaussian for computing LNCC
                argument: ``--lncc %f``
        nmi_flag: (a boolean)
                use NMI even when other options are specified
                argument: ``--nmi``
        aff_file: (an existing file name)
                The input affine transformation file
                argument: ``-aff %s``
        jl_val: (a float)
                Log of jacobian of deformation penalty value
                argument: ``-jl %f``
        noy_flag: (a boolean)
                Don't optimise in y direction
                argument: ``-noy``
        noz_flag: (a boolean)
                Don't optimise in z direction
                argument: ``-noz``
        fmask_file: (an existing file name)
                Floating image mask
                argument: ``-fmask %s``
        pert_val: (an integer >= 0)
                Add perturbation steps after each optimization step
                argument: ``-pert %d``
        kld2_flag: (an integer >= 0)
                Use KL divergence as the similarity measure for a given time point
                argument: ``-kld %d``
        lncc2_val: (a tuple of the form: (an integer >= 0, a float))
                SD of the Gaussian for computing LNCC for a given time point
                argument: ``-lncc %d %f``
        ssd2_flag: (an integer >= 0)
                Use SSD as the similarity measure for a given time point
                argument: ``-ssd %d``
        nox_flag: (a boolean)
                Don't optimise in x direction
                argument: ``-nox``
        rlwth2_thr_val: (a tuple of the form: (an integer >= 0, a float))
                Lower threshold for reference image at the specified time point
                argument: ``-rLwTh %d %f``
        no_app_jl_flag: (a boolean)
                Do not approximate the log of jacobian penalty at control points
                only
                argument: ``-noAppJL``
        nopy_flag: (a boolean)
                Do not use the multiresolution approach
                argument: ``-nopy``
        sx_val: (a float)
                Final grid spacing along the x axes
                argument: ``-sx %f``
        ref_smooth_val: (a float)
                Smoothing kernel width for reference image
                argument: ``-smooR %f``
        fupth_thr_val: (a float)
                Upper threshold for floating image
                argument: ``--fUpTh %f``
        rupth2_thr_val: (a tuple of the form: (an integer >= 0, a float))
                Upper threshold for reference image at the specified time point
                argument: ``-rUpTh %d %f``
        ssd_flag: (a boolean)
                Use SSD as the similarity measure
                argument: ``--ssd``
        smooth_grad_val: (a float)
                Kernel width for smoothing the metric gradient
                argument: ``-smoothGrad %f``
        noconj_flag: (a boolean)
                Use simple GD optimization
                argument: ``-noConj``
        cpp_file: (a file name)
                The output CPP file
                argument: ``-cpp %s``
        rmask_file: (an existing file name)
                Reference image mask
                argument: ``-rmask %s``
        ln_val: (an integer >= 0)
                Number of resolution levels to create
                argument: ``-ln %d``
        amc_flag: (a boolean)
                Use additive NMI
                argument: ``-amc``
        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
        fbn_val: (an integer >= 0)
                Number of bins in the histogram for reference image
                argument: ``--fbn %d``
        res_file: (a file name)
                The output resampled image
                argument: ``-res %s``
        flo_smooth_val: (a float)
                Smoothing kernel width for floating image
                argument: ``-smooF %f``
        verbosity_off_flag: (a boolean)
                Turn off verbose output
                argument: ``-voff``
        sz_val: (a float)
                Final grid spacing along the z axes
                argument: ``-sz %f``
        lp_val: (an integer >= 0)
                Number of resolution levels to perform
                argument: ``-lp %d``

Outputs::

        invcpp_file: (a file name)
                The output inverse CPP file
        cpp_file: (a file name)
                The output CPP file
        invres_file: (a file name)
                The output inverse res file
        avg_output: (a string)
                Output string in the format for reg_average
        res_file: (a file name)
                The output resampled image
