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

interfaces.afni.preprocess
==========================


.. _nipype.interfaces.afni.preprocess.Allineate:


.. index:: Allineate

Allineate
---------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L999

Wraps command **3dAllineate**

Program to align one dataset (the 'source') to a base dataset

For complete details, see the `3dAllineate Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAllineate.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> allineate = afni.Allineate()
>>> allineate.inputs.infile = example_data('functional.nii')
>>> allineate.inputs.outfile= 'functional_allineate.nii'
>>> allineate.inputs.matrix= example_data('cmatrix.mat')
>>> res = allineate.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        infile: (an existing file name)
                input file to 3dAllineate
        outfile: (a file name)
                output file from 3dAllineate

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        matrix: (a file name)
                matrix to align input file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                cut file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Automask:


.. index:: Automask

Automask
--------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L614

Wraps command **3dAutomask**

Create a brain-only mask of the image using AFNI 3dAutomask command

For complete details, see the `3dAutomask Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dAutomask.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> automask = afni.Automask()
>>> automask.inputs.in_file = example_data('functional.nii')
>>> automask.inputs.dilate = 1
>>> res = automask.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dAutomask

        [Optional]
        apply_mask: (a file name)
                output file from 3dAutomask
        args: (a string)
                Additional parameters to the command
        clfrac: (a float)
                sets the clip level fraction (must be 0.1-0.9). A small value will tend to make the mask
                larger [default = 0.5].
        dilate: (an integer)
                dilate the mask outwards
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        erode: (an integer)
                erode the mask inwards
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                automask settings
        out_file: (a file name)
                output file from 3dAutomask (a brain mask)
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        suffix: (a string)
                out_file suffix

Outputs::

        args: (a string)
                Additional parameters to the command
        brain_file: (an existing file name)
                brain file (skull stripped)
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                mask file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.BrickStat:


.. index:: BrickStat

BrickStat
---------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1377

Wraps command **3dBrickStat**

Compute maximum and/or minimum voxel values of an input dataset

For complete details, see the `3dBrickStat Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dBrickStat.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> brickstat = afni.BrickStat()
>>> brickstat.inputs.in_file = example_data('functional.nii')
>>> brickstat.inputs.mask = example_data('skeleton_mask.nii.gz')
>>> brickstat.inputs.min = True
>>> res = brickstat.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dmaskave

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        mask: (a file name)
                -mask dset = use dset as mask to include/exclude voxels
        min: (a boolean)
                print the minimum value in dataset
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        min_val: (a float)
                output
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Calc:


.. index:: Calc

Calc
----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1541

Wraps command **3dcalc**

This program does voxel-by-voxel arithmetic on 3D datasets

For complete details, see the `3dcalc Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcalc.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> calc = afni.Calc()
>>> calc.inputs.infile_a = example_data('functional.nii')
>>> calc.inputs.Infile_b = example_data('functional2.nii.gz')
>>> calc.inputs.expr='a*b'
>>> calc.inputs.out_file =  'functional_calc.nii.gz'
>>> res = calc.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        expr: (a string)
                expr
        infile_a: (a file name)
                input file to 3dcalc

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        infile_b: (a file name)
                operand file to 3dcalc
        other: (a file name)
                other options
        out_file: (a file name)
                output file from 3dFourier
        single_idx: (an integer)
                volume index for infile_a
        start_idx: (an integer)
                start index for infile_a
                requires: stop_idx
        stop_idx: (an integer)
                stop index for infile_a
                requires: start_idx

Outputs::

        out_file: (an existing file name)
                 output file

.. _nipype.interfaces.afni.preprocess.Copy:


.. index:: Copy

Copy
----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L820

Wraps command **3dcopy**

Copies an image of one type to an image of the same
or different type using 3dcopy command

For complete details, see the `3dcopy Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dcopy.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> copy = afni.Copy()
>>> copy.inputs.in_file = example_data('functional.nii')
>>> copy.inputs.out_file = 'new_func.nii'
>>> res = copy.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dcopy

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (a file name)
                output file from 3dcopy
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (a file name)
                copied file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Despike:


.. index:: Despike

Despike
-------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L534

Wraps command **3dDespike**

Removes 'spikes' from the 3D+time input dataset

For complete details, see the `3dDespike Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDespike.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> despike = afni.Despike()
>>> despike.inputs.in_file = example_data('functional.nii')
>>> res = despike.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dDespike

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                additional args
        out_file: (a file name)
                output file from 3dDespike
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                despiked img
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Detrend:


.. index:: Detrend

Detrend
-------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L472

Wraps command **3dDetrend**

This program removes components from voxel time series using
linear least squares

For complete details, see the `3dDetrend Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dDetrend.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> detrend = afni.Detrend()
>>> detrend.inputs.in_file = example_data('functional.nii')
>>> detrend.inputs.options = '-polort 2'
>>> res = detrend.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dDetrend

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                selected statistical output
        out_file: (a file name)
                output file from 3dDetrend
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                statistical file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Fim:


.. index:: Fim

Fim
---

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1237

Wraps command **3dfim+**

Program to calculate the cross-correlation of
an ideal reference waveform with the measured FMRI
time series for each voxel

For complete details, see the `3dfim+ Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dfim+.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> fim = afni.Fim()
>>> fim.inputs.in_file = example_data('functional.nii')
>>> fim.inputs.ideal_file= example_data('seed.1D')
>>> fim.inputs.out_file = 'functional_corr.nii'
>>> fim.inputs.out = 'Correlation'
>>> fim.inputs.fim_thr = 0.0009
>>> res = fim.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        ideal_file: (a file name)
                output to the file
        in_file: (an existing file name)
                input file to 3dfim+

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        fim_thr: (a float)
                fim internal mask threshold value
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out: (a string)
                Flag to output the specified parameter
        out_file: (a file name)
                output file from 3dfim+
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                outfile
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Fourier:


.. index:: Fourier

Fourier
-------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L887

Wraps command **3dFourier**

Program to lowpass and/or highpass each voxel time series in a
dataset, via the FFT

For complete details, see the `3dFourier Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dfourier.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> fourier = afni.Fourier()
>>> fourier.inputs.in_file = example_data('functional.nii')
>>> fourier.inputs.other = '-retrend'
>>> fourier.inputs.highpass = 0.005
>>> fourier.inputs.lowpass = 0.1
>>> res = fourier.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        highpass: (a float)
                highpass
        in_file: (an existing file name)
                input file to 3dFourier
        lowpass: (a float)
                lowpass

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        other: (a string)
                other options
        out_file: (a file name)
                output file from 3dFourier
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                band-pass filtered file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Maskave:


.. index:: Maskave

Maskave
-------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1052

Wraps command **3dmaskave**

Computes average of all voxels in the input dataset
which satisfy the criterion in the options list

For complete details, see the `3dmaskave Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dmaskave.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> maskave = afni.Maskave()
>>> maskave.inputs.in_file = example_data('functional.nii')
>>> maskave.inputs.mask= example_data('seed_mask.nii')
>>> maskave.inputs.quiet= True
>>> maskave.inputs.out_file= 'maskave.1D'
>>> res = maskave.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dmaskave

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        mask: (a file name)
                matrix to align input file
        out_file: (a file name)
                output to the file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        quiet: (a boolean)
                matrix to align input file

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                outfile
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Merge:


.. index:: Merge

Merge
-----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L774

Wraps command **3dmerge**

Merge or edit volumes using AFNI 3dmerge command

For complete details, see the `3dmerge Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dmerge.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> merge = afni.Merge()
>>> merge.inputs.infile = example_data('functional.nii')
>>> merge.inputs.blurfwhm = 4.0
>>> merge.inputs.doall = True
>>> merge.inputs.outfile = 'e7.nii'
>>> res = merge.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        infile: (an existing file name)
                input file to 3dvolreg
        outfile: (a file name)
                output file from 3dvolreg

        [Optional]
        args: (a string)
                Additional parameters to the command
        blurfwhm: (an integer)
                FWHM blur value (mm)
        doall: (a boolean)
                apply options to all sub-bricks in dataset
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        other: (a string)
                other options
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                smoothed file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.ROIStats:


.. index:: ROIStats

ROIStats
--------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1454

Wraps command **3dROIstats**

Display statistics over masked regions

For complete details, see the `3dROIstats Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dROIstats.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> roistats = afni.ROIStats()
>>> roistats.inputs.in_file = example_data('functional.nii')
>>> roistats.inputs.mask = example_data('skeleton_mask.nii.gz')
>>> roistats.inputs.quiet=True
>>> res = roistats.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dROIstats

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        mask: (a file name)
                input mask
        mask_f2short: (a boolean)
                Tells the program to convert a float mask to short integers, by simple rounding.
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        quiet: (a boolean)
                execute quietly

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        stats: (a file name)
                output

.. _nipype.interfaces.afni.preprocess.Refit:


.. index:: Refit

Refit
-----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L209

Wraps command **3drefit**

Changes some of the information inside a 3D dataset's header

For complete details, see the `3drefit Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3drefit.html>

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> refit = afni.Refit()
>>> refit.inputs.in_file = example_data('structural.nii')
>>> refit.inputs.deoblique=True
>>> res = refit.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3drefit

        [Optional]
        args: (a string)
                Additional parameters to the command
        deoblique: (a boolean)
                replace current transformation matrix with cardinal matrix
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        xorigin: (a string)
                x distance for edge voxel offset
        yorigin: (a string)
                y distance for edge voxel offset
        zorigin: (a string)
                z distance for edge voxel offset

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                Same file as original infile with modified matrix
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Resample:


.. index:: Resample

Resample
--------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L349

Wraps command **3dresample**

Resample or reorient an image using AFNI 3dresample command

For complete details, see the `3dresample Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dresample.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> resample = afni.Resample()
>>> resample.inputs.in_file = example_data('functional.nii')
>>> resample.inputs.orientation= 'RPI'
>>> res = resample.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dresample

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        orientation: (a string)
                new orientation code
        out_file: (a file name)
                output file from 3dresample
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        suffix: (a string)
                out_file suffix

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                reoriented or resampled file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.SkullStrip:


.. index:: SkullStrip

SkullStrip
----------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1112

Wraps command **3dSkullStrip**

A program to extract the brain from surrounding
tissue from MRI T1-weighted images

For complete details, see the `3dSkullStrip Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dSkullStrip.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> skullstrip = afni.Skullstrip()
>>> skullstrip.inputs.in_file = example_data('functional.nii')
>>> skullstrip.inputs.options = '-o_ply'
>>> res = skullstrip.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dSkullStrip

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                options
        out_file: (a file name)
                output to the file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                outfile
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.TCat:


.. index:: TCat

TCat
----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1170

Wraps command **3dTcat**

Concatenate sub-bricks from input datasets into
one big 3D+time dataset

For complete details, see the `3dTcat Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcat.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> tcat = afni.TCat()
>>> tcat.inputs.in_file = example_data('functional.nii')
>>> tcat.inputs.out_file= 'functional_tcat.nii'
>>> tcat.inputs.rlt = '+'
>>> res = tcat.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dTcat

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (a file name)
                output to the file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        rlt: (a string)
                options

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                outfile
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.TCorrelate:


.. index:: TCorrelate

TCorrelate
----------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L1314

Wraps command **3dTcorrelate**

Computes the correlation coefficient between corresponding voxel
time series in two input 3D+time datasets 'xset' and 'yset'

For complete details, see the `3dTcorrelate Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTcorrelate.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> tcorrelate = afni.TCorrelate()
>>> tcorrelate.inputs.in_file = example_data('functional.nii')
>>> tcorrelate.inputs.xset= example_data('u_rc1s1_Template.nii')
>>> tcorrelate.inputs.yset = example_data('u_rc1s2_Template.nii')
>>> tcorrelate.inputs.out_file = 'functional_tcorrelate.nii.gz'
>>> tcorrelate.inputs.polort = -1
>>> tcorrelate.inputs.pearson = True
>>> res = tcarrelate.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        xset: (an existing file name)
                input xset
        yset: (an existing file name)
                input yset

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                other options
        out_file: (a file name)
                Save output into dataset with prefix
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        pearson: (a boolean)
                Correlation is the normal Pearson correlation coefficient
        polort: (an integer)
                Remove polynomical trend of order m

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                outfile
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.TShift:


.. index:: TShift

TShift
------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L138

Wraps command **3dTshift**

Shifts voxel time series from input
so that seperate slices are aligned to the same
temporal origin

For complete details, see the `3dTshift Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTshift.html>

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> tshift = afni.TShift()
>>> tshift.inputs.in_file = example_data('functional.nii')
>>> tshift.inputs.out_file = 'functional_tshift.nii'
>>> tshift.inputs.tpattern = 'alt+z'
>>> tshift.inputs.tzero = 0.0
>>> res = tshift.run()   # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dTShift

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore: (an integer)
                ignore the first set of points specified
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        interp: ('Fourier' or 'linear' or 'cubic' or 'quintic' or 'heptic')
                different interpolation methods (see 3dTShift for details) default = Fourier
        out_file: (a file name)
                output file from 3dTshift
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        rlt: (a boolean)
                Before shifting, remove the mean and linear trend
        rltplus: (a boolean)
                Before shifting, remove the mean and linear trend and later put back the mean
        suffix: (a string)
                out_file suffix
        tpattern: ('alt+z' or 'alt+z2' or 'alt-z' or 'alt-z2' or 'seq+z' or 'seq-z')
                use specified slice time pattern rather than one in header
        tr: (a string)
                manually set the TRYou can attach suffix "s" for seconds or "ms" for milliseconds.
        tslice: (an integer)
                align each slice to time offset of given slice
                mutually_exclusive: tzero
        tzero: (a float)
                align each slice to given time offset
                mutually_exclusive: tslice

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (a file name)
                post slice time shifted 4D image
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.TStat:


.. index:: TStat

TStat
-----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L414

Wraps command **3dTstat**

Compute voxel-wise statistics using AFNI 3dTstat command

For complete details, see the `3dTstat Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dTstat.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> tstat = afni.TStat()
>>> tstat.inputs.in_file = example_data('functional.nii')
>>> tstat.inputs.options= '-mean'
>>> res = tstat.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dTstat

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        options: (a string)
                selected statistical output
        out_file: (a file name)
                output file from 3dTstat
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                statistical file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.To3D:


.. index:: To3D

To3D
----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L59

Wraps command **to3d**

Create a 3D dataset from 2D image files using AFNI to3d command

For complete details, see the `to3d Documentation
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/to3d.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni
>>> To3D = afni.To3D()
>>> To3D.inputs.datatype = 'float'
>>> To3D.inputs.infolder = 'dicomdir'
>>> To3D.inputs.filetype = "anat"
>>> res = To3D.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        infolder: (an existing directory name)
                folder with DICOM images to convert
        outfile: (a file name)
                converted image file

        [Optional]
        args: (a string)
                Additional parameters to the command
        assumemosaic: (a boolean)
                assume that Siemens image is mosaic
        datatype: ('short' or 'float' or 'byte' or 'complex')
                set output file datatype
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        filetype: ('spgr' or 'fse' or 'epan' or 'anat' or 'ct' or 'spct' or 'pet' or 'mra' or
                 'bmap' or 'diff' or 'omri' or 'abuc' or 'fim' or 'fith' or 'fico' or 'fitt' or 'fift'
                 or 'fizt' or 'fict' or 'fibt' or 'fibn' or 'figt' or 'fipt' or 'fbuc')
                type of datafile being converted
        funcparams: (a string)
                parameters for functional data
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        skipoutliers: (a boolean)
                skip the outliers check

Outputs::

        out_file: (an existing file name)
                converted file

.. _nipype.interfaces.afni.preprocess.Volreg:


.. index:: Volreg

Volreg
------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L700

Wraps command **3dvolreg**

Register input volumes to a base volume using AFNI 3dvolreg command

For complete details, see the `3dvolreg Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dvolreg.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> volreg = afni.Volreg()
>>> volreg.inputs.in_file = example_data('functional.nii')
>>> volreg.inputs.other = '-Fourier -twopass'
>>> volreg.inputs.zpad = '4'
>>> res = volreg.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dvolreg

        [Optional]
        args: (a string)
                Additional parameters to the command
        basefile: (a file name)
                base file for registration
        copyorigin: (a boolean)
                copy base file origin coords to output
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        md1dfile: (a file name)
                max displacement output file
        oned_file: (a file name)
                1D movement parameters output file
        other: (a string)
                other options
        out_file: (a file name)
                output file from 3dvolreg
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        timeshift: (a boolean)
                time shift to mean slice time offset
        verbose: (a boolean)
                more detailed description of the process
        zpad: (a file name)
                Zeropad around the edges by 'n' voxels during rotations

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        md1d_file: (a file name)
                max displacement info file
        oned_file: (a file name)
                movement parameters info file
        out_file: (an existing file name)
                registered file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.Warp:


.. index:: Warp

Warp
----

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L283

Wraps command **3dWarp**

Use 3dWarp for spatially transforming a dataset

For complete details, see the `3dWarp Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dWarp.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> warp = afni.Warp()
>>> warp.inputs.in_file = example_data('structural.nii')
>>> warp.inputs.deoblique = True
>>> res = warp.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input file to 3dWarp

        [Optional]
        args: (a string)
                Additional parameters to the command
        deoblique: (a boolean)
                transform dataset from oblique to cardinal
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        gridset: (an existing file name)
                copy grid of specified dataset
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        interp: ('linear' or 'cubic' or 'NN' or 'quintic')
                spatial interpolation methods [default = linear]
        matparent: (an existing file name)
                apply transformation from 3dWarpDrive
        mni2tta: (a boolean)
                transform dataset from MNI152 to Talaraich
        out_file: (a file name)
                output file from 3dWarp
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
        suffix: (a string)
                out_file suffix
        tta2mni: (a boolean)
                transform dataset from Talairach to MNI152
        zpad: (an integer)
                pad input dataset with N planes of zero on all sides.

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                spatially transformed input image
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

.. _nipype.interfaces.afni.preprocess.ZCutUp:


.. index:: ZCutUp

ZCutUp
------

Code: http://github.com/nipy/nipype/blob/master/nipype/interfaces/afni/preprocess.py#L950

Wraps command **3dZcutup**

Cut z-slices from a volume using AFNI 3dZcutup command

For complete details, see the `3dZcutup Documentation.
<http://afni.nimh.nih.gov/pub/dist/doc/program_help/3dZcutup.html>`_

Examples
~~~~~~~~

>>> from nipype.interfaces import afni as afni
>>> from nipype.testing import  example_data
>>> zcutup = afni.Zcutup()
>>> zcutup.inputs.infile = example_data('functional.nii')
>>> zcutup.inputs.outfile= 'functional_zcutup.nii'
>>> zcutup.inputs.keep= '0 10'
>>> res = zcutup.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        infile: (an existing file name)
                input file to 3dZcutup
        outfile: (a file name)
                output file from 3dZcutup

        [Optional]
        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        keep: (a string)
                slice range to keep in output
        other: (a string)
                other options
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype

Outputs::

        args: (a string)
                Additional parameters to the command
        environ: (a dictionary with keys which are a value of type 'str' and with values which
                 are a value of type 'str', nipype default value: {})
                Environment variables
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the interface fails to
                run
        out_file: (an existing file name)
                cut file
        outputtype: ('NIFTI_GZ' or 'AFNI' or 'NIFTI')
                AFNI output filetype
