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

interfaces.fsl.dti
==================


.. _nipype.interfaces.fsl.dti.BEDPOSTX5:


.. index:: BEDPOSTX5

BEDPOSTX5
---------

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

Wraps the executable command ``bedpostx``.

BEDPOSTX stands for Bayesian Estimation of Diffusion Parameters Obtained
using Sampling Techniques. The X stands for modelling Crossing Fibres.
bedpostx runs Markov Chain Monte Carlo sampling to build up distributions
on diffusion parameters at each voxel. It creates all the files necessary
for running probabilistic tractography. For an overview of the modelling
carried out within bedpostx see this `technical report
<http://www.fmrib.ox.ac.uk/analysis/techrep/tr03tb1/tr03tb1/index.html>`_.


.. note:: Consider using
  :func:`nipype.workflows.fsl.dmri.create_bedpostx_pipeline` instead.


Example
~~~~~~~

>>> from nipype.interfaces import fsl
>>> bedp = fsl.BEDPOSTX5(bvecs='bvecs', bvals='bvals', dwi='diffusion.nii',
...                     mask='mask.nii', n_fibres=1)
>>> bedp.cmdline
'bedpostx bedpostx -b 0 --burnin_noard=0 --forcedir -n 1 -j 5000 -s 1 --updateproposalevery=40'

Inputs::

        [Mandatory]
        bvecs: (an existing file name)
                b vectors file
        n_fibres: (an integer >= 1, nipype default value: 2)
                Maximum number of fibres to fit in each voxel
                argument: ``-n %d``
        out_dir: (a directory name, nipype default value: bedpostx)
                output directory
                argument: ``%s``, position: 1
        bvals: (an existing file name)
                b values file
        mask: (an existing file name)
                bet binary mask file
        dwi: (an existing file name)
                diffusion weighted image data file

        [Optional]
        sample_every: (an integer >= 0, nipype default value: 1)
                Num of jumps for each sample (MCMC)
                argument: ``-s %d``
        grad_dev: (an existing file name)
                grad_dev file, if gradnonlin, -g is True
        no_spat: (a boolean)
                Initialise with tensor, not spatially
                argument: ``--nospat``
                mutually_exclusive: no_spat, non_linear, cnlinear
        n_jumps: (an integer (int or long), nipype default value: 5000)
                Num of jumps to be made by MCMC
                argument: ``-j %d``
        seed: (an integer (int or long))
                seed for pseudo random number generator
                argument: ``--seed=%d``
        burn_in: (an integer >= 0, nipype default value: 0)
                Total num of jumps at start of MCMC to be discarded
                argument: ``-b %d``
        all_ard: (a boolean)
                Turn ARD on on all fibres
                argument: ``--allard``
                mutually_exclusive: no_ard, all_ard
        use_gpu: (a boolean)
                Use the GPU version of bedpostx
        non_linear: (a boolean)
                Initialise with nonlinear fitting
                argument: ``--nonlinear``
                mutually_exclusive: no_spat, non_linear, cnlinear
        logdir: (a directory name)
                argument: ``--logdir=%s``
        fudge: (an integer (int or long))
                ARD fudge factor
                argument: ``-w %d``
        rician: (a boolean)
                use Rician noise modeling
                argument: ``--rician``
        no_ard: (a boolean)
                Turn ARD off on all fibres
                argument: ``--noard``
                mutually_exclusive: no_ard, all_ard
        f0_ard: (a boolean)
                Noise floor model: add to the model an unattenuated signal
                compartment f0
                argument: ``--f0 --ardf0``
                mutually_exclusive: f0_noard, f0_ard, all_ard
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        force_dir: (a boolean, nipype default value: True)
                use the actual directory name given (do not add + to make a new
                directory)
                argument: ``--forcedir``
        update_proposal_every: (an integer >= 1, nipype default value: 40)
                Num of jumps for each update to the proposal density std (MCMC)
                argument: ``--updateproposalevery=%d``
        cnlinear: (a boolean)
                Initialise with constrained nonlinear fitting
                argument: ``--cnonlinear``
                mutually_exclusive: no_spat, non_linear, cnlinear
        f0_noard: (a boolean)
                Noise floor model: add to the model an unattenuated signal
                compartment f0
                argument: ``--f0``
                mutually_exclusive: f0_noard, f0_ard
        gradnonlin: (a boolean)
                consider gradient nonlinearities, default off
                argument: ``-g``
        burn_in_no_ard: (an integer >= 0, nipype default value: 0)
                num of burnin jumps before the ard is imposed
                argument: ``--burnin_noard=%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
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        model: (1 or 2 or 3)
                use monoexponential (1, default, required for single-shell) or
                multiexponential (2, multi-shell) model
                argument: ``-model %d``

Outputs::

        merged_phsamples: (a list of items which are an existing file name)
                Samples from the distribution on phi
        mean_S0samples: (an existing file name)
                Mean of distribution on T2wbaseline signal intensity S0
        dyads: (a list of items which are an existing file name)
                Mean of PDD distribution in vector form.
        dyads_dispersion: (a list of items which are an existing file name)
                Dispersion
        merged_fsamples: (a list of items which are an existing file name)
                Samples from the distribution on anisotropic volume fraction
        mean_fsamples: (a list of items which are an existing file name)
                Mean of distribution on f anisotropy
        mean_phsamples: (a list of items which are an existing file name)
                Mean of distribution on phi
        merged_thsamples: (a list of items which are an existing file name)
                Samples from the distribution on theta
        mean_thsamples: (a list of items which are an existing file name)
                Mean of distribution on theta
        mean_dsamples: (an existing file name)
                Mean of distribution on diffusivity d

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

.. _nipype.interfaces.fsl.dti.DTIFit:


.. index:: DTIFit

DTIFit
------

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

Wraps the executable command ``dtifit``.

Use FSL  dtifit command for fitting a diffusion tensor model at each
voxel

Example
~~~~~~~

>>> from nipype.interfaces import fsl
>>> dti = fsl.DTIFit()
>>> dti.inputs.dwi = 'diffusion.nii'
>>> dti.inputs.bvecs = 'bvecs'
>>> dti.inputs.bvals = 'bvals'
>>> dti.inputs.base_name = 'TP'
>>> dti.inputs.mask = 'mask.nii'
>>> dti.cmdline
'dtifit -k diffusion.nii -o TP -m mask.nii -r bvecs -b bvals'

Inputs::

        [Mandatory]
        bvecs: (an existing file name)
                b vectors file
                argument: ``-r %s``, position: 3
        bvals: (an existing file name)
                b values file
                argument: ``-b %s``, position: 4
        mask: (an existing file name)
                bet binary mask file
                argument: ``-m %s``, position: 2
        dwi: (an existing file name)
                diffusion weighted image data file
                argument: ``-k %s``, position: 0

        [Optional]
        min_x: (an integer (int or long))
                min x
                argument: ``-x %d``
        min_y: (an integer (int or long))
                min y
                argument: ``-y %d``
        base_name: (a unicode string, nipype default value: dtifit_)
                base_name that all output files will start with
                argument: ``-o %s``, position: 1
        min_z: (an integer (int or long))
                min z
                argument: ``-z %d``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        gradnonlin: (an existing file name)
                gradient non linearities
                argument: ``--gradnonlin=%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
        max_x: (an integer (int or long))
                max x
                argument: ``-X %d``
        little_bit: (a boolean)
                only process small area of brain
                argument: ``--littlebit``
        sse: (a boolean)
                output sum of squared errors
                argument: ``--sse``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        max_z: (an integer (int or long))
                max z
                argument: ``-Z %d``
        cni: (an existing file name)
                input counfound regressors
                argument: ``--cni=%s``
        save_tensor: (a boolean)
                save the elements of the tensor
                argument: ``--save_tensor``
        max_y: (an integer (int or long))
                max y
                argument: ``-Y %d``

Outputs::

        MD: (an existing file name)
                path/name of file with the mean diffusivity
        tensor: (an existing file name)
                path/name of file with the 4D tensor volume
        V1: (an existing file name)
                path/name of file with the 1st eigenvector
        MO: (an existing file name)
                path/name of file with the mode of anisotropy
        S0: (an existing file name)
                path/name of file with the raw T2 signal with no diffusion weighting
        FA: (an existing file name)
                path/name of file with the fractional anisotropy
        V2: (an existing file name)
                path/name of file with the 2nd eigenvector
        V3: (an existing file name)
                path/name of file with the 3rd eigenvector
        L2: (an existing file name)
                path/name of file with the 2nd eigenvalue
        L3: (an existing file name)
                path/name of file with the 3rd eigenvalue
        L1: (an existing file name)
                path/name of file with the 1st eigenvalue
        sse: (an existing file name)
                path/name of file with the summed squared error

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

.. _nipype.interfaces.fsl.dti.DistanceMap:


.. index:: DistanceMap

DistanceMap
-----------

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

Wraps the executable command ``distancemap``.

Use FSL's distancemap to generate a map of the distance to the nearest
nonzero voxel.

Example
~~~~~~~

>>> import nipype.interfaces.fsl as fsl
>>> mapper = fsl.DistanceMap()
>>> mapper.inputs.in_file = "skeleton_mask.nii.gz"
>>> mapper.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                image to calculate distance values for
                argument: ``--in=%s``

        [Optional]
        invert_input: (a boolean)
                invert input image
                argument: ``--invert``
        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
        mask_file: (an existing file name)
                binary mask to contrain calculations
                argument: ``--mask=%s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        distance_map: (a file name)
                distance map to write
                argument: ``--out=%s``
        local_max_file: (a boolean or a file name)
                write an image of the local maxima
                argument: ``--localmax=%s``

Outputs::

        distance_map: (an existing file name)
                value is distance to nearest nonzero voxels
        local_max_file: (a file name)
                image of local maxima

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

.. _nipype.interfaces.fsl.dti.FindTheBiggest:


.. index:: FindTheBiggest

FindTheBiggest
--------------

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

Wraps the executable command ``find_the_biggest``.

Use FSL find_the_biggest for performing hard segmentation on
the outputs of connectivity-based thresholding in probtrack.
For complete details, see the `FDT
Documentation. <http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_biggest.html>`_

Example
~~~~~~~

>>> from nipype.interfaces import fsl
>>> ldir = ['seeds_to_M1.nii', 'seeds_to_M2.nii']
>>> fBig = fsl.FindTheBiggest(in_files=ldir, out_file='biggestSegmentation')
>>> fBig.cmdline
'find_the_biggest seeds_to_M1.nii seeds_to_M2.nii biggestSegmentation'

Inputs::

        [Mandatory]
        in_files: (a list of items which are an existing file name)
                a list of input volumes or a singleMatrixFile
                argument: ``%s``, position: 0

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

Outputs::

        out_file: (an existing file name)
                output file indexed in order of input files
                argument: ``%s``

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

.. _nipype.interfaces.fsl.dti.MakeDyadicVectors:


.. index:: MakeDyadicVectors

MakeDyadicVectors
-----------------

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

Wraps the executable command ``make_dyadic_vectors``.

Create vector volume representing mean principal diffusion direction
and its uncertainty (dispersion)

Inputs::

        [Mandatory]
        phi_vol: (an existing file name)
                argument: ``%s``, position: 1
        theta_vol: (an existing file name)
                argument: ``%s``, position: 0

        [Optional]
        perc: (a float)
                the {perc}% angle of the output cone of uncertainty (output will be
                in degrees)
                argument: ``%f``, position: 4
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        mask: (an existing file name)
                argument: ``%s``, position: 2
        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
        output: (a file name, nipype default value: dyads)
                argument: ``%s``, position: 3

Outputs::

        dispersion: (an existing file name)
        dyads: (an existing file name)

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

.. _nipype.interfaces.fsl.dti.ProbTrackX:


.. index:: ProbTrackX

ProbTrackX
----------

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

Wraps the executable command ``probtrackx``.

Use FSL  probtrackx for tractography on bedpostx results

Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> pbx = fsl.ProbTrackX(samples_base_name='merged', mask='mask.nii',     seed='MASK_average_thal_right.nii', mode='seedmask',     xfm='trans.mat', n_samples=3, n_steps=10, force_dir=True, opd=True,     os2t=True, target_masks = ['targets_MASK1.nii', 'targets_MASK2.nii'],     thsamples='merged_thsamples.nii', fsamples='merged_fsamples.nii',     phsamples='merged_phsamples.nii', out_dir='.')
>>> pbx.cmdline
'probtrackx --forcedir -m mask.nii --mode=seedmask --nsamples=3 --nsteps=10 --opd --os2t --dir=. --samples=merged --seed=MASK_average_thal_right.nii --targetmasks=targets.txt --xfm=trans.mat'

Inputs::

        [Mandatory]
        phsamples: (a list of items which are an existing file name)
        mask: (an existing file name)
                bet binary mask file in diffusion space
                argument: ``-m %s``
        seed: (an existing file name or a list of items which are an existing
                  file name or a list of items which are a list of from 3 to 3 items
                  which are an integer (int or long))
                seed volume(s), or voxel(s) or freesurfer label file
                argument: ``--seed=%s``
        thsamples: (a list of items which are an existing file name)
        fsamples: (a list of items which are an existing file name)

        [Optional]
        mod_euler: (a boolean)
                use modified euler streamlining
                argument: ``--modeuler``
        verbose: (0 or 1 or 2)
                Verbose level, [0-2]. Level 2 is required to output particle files.
                argument: ``--verbose=%d``
        out_dir: (an existing directory name)
                directory to put the final volumes in
                argument: ``--dir=%s``
        waypoints: (an existing file name)
                waypoint mask or ascii list of waypoint masks - only keep paths
                going through ALL the masks
                argument: ``--waypoints=%s``
        mask2: (an existing file name)
                second bet binary mask (in diffusion space) in twomask_symm mode
                argument: ``--mask2=%s``
        n_steps: (an integer (int or long))
                number of steps per sample - default=2000
                argument: ``--nsteps=%d``
        seed_ref: (an existing file name)
                reference vol to define seed space in simple mode - diffusion space
                assumed if absent
                argument: ``--seedref=%s``
        dist_thresh: (a float)
                discards samples shorter than this threshold (in mm - default=0)
                argument: ``--distthresh=%.3f``
        use_anisotropy: (a boolean)
                use anisotropy to constrain tracking
                argument: ``--usef``
        network: (a boolean)
                activate network mode - only keep paths going through at least one
                seed mask (required if multiple seed masks)
                argument: ``--network``
        sample_random_points: (a boolean)
                sample random points within seed voxels
                argument: ``--sampvox``
        os2t: (a boolean)
                Outputs seeds to targets
                argument: ``--os2t``
        avoid_mp: (an existing file name)
                reject pathways passing through locations given by this mask
                argument: ``--avoid=%s``
        target_masks: (a list of items which are a file name)
                list of target masks - required for seeds_to_targets classification
                argument: ``--targetmasks=%s``
        step_length: (a float)
                step_length in mm - default=0.5
                argument: ``--steplength=%.3f``
        n_samples: (an integer (int or long), nipype default value: 5000)
                number of samples - default=5000
                argument: ``--nsamples=%d``
        correct_path_distribution: (a boolean)
                correct path distribution for the length of the pathways
                argument: ``--pd``
        s2tastext: (a boolean)
                output seed-to-target counts as a text file (useful when seeding
                from a mesh)
                argument: ``--s2tastext``
        xfm: (an existing file name)
                transformation matrix taking seed space to DTI space (either FLIRT
                matrix or FNIRT warp_field) - default is identity
                argument: ``--xfm=%s``
        samples_base_name: (a unicode string, nipype default value: merged)
                the rootname/base_name for samples files
                argument: ``--samples=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        inv_xfm: (a file name)
                transformation matrix taking DTI space to seed space (compulsory
                when using a warp_field for seeds_to_dti)
                argument: ``--invxfm=%s``
        force_dir: (a boolean, nipype default value: True)
                use the actual directory name given - i.e. do not add + to make a
                new directory
                argument: ``--forcedir``
        mesh: (an existing file name)
                Freesurfer-type surface descriptor (in ascii format)
                argument: ``--mesh=%s``
        stop_mask: (an existing file name)
                stop tracking at locations given by this mask file
                argument: ``--stop=%s``
        fibst: (an integer (int or long))
                force a starting fibre for tracking - default=1, i.e. first fibre
                orientation. Only works if randfib==0
                argument: ``--fibst=%d``
        random_seed: (a boolean)
                random seed
                argument: ``--rseed``
        opd: (a boolean, nipype default value: True)
                outputs path distributions
                argument: ``--opd``
        rand_fib: (0 or 1 or 2 or 3)
                options: 0 - default, 1 - to randomly sample initial fibres (with f
                > fibthresh), 2 - to sample in proportion fibres (with f>fibthresh)
                to f, 3 - to sample ALL populations at random (even if f<fibthresh)
                argument: ``--randfib=%d``
        loop_check: (a boolean)
                perform loop_checks on paths - slower, but allows lower curvature
                threshold
                argument: ``--loopcheck``
        c_thresh: (a float)
                curvature threshold - default=0.2
                argument: ``--cthr=%.3f``
        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
        mode: (u'simple' or u'two_mask_symm' or u'seedmask')
                options: simple (single seed voxel), seedmask (mask of seed voxels),
                twomask_symm (two bet binary masks)
                argument: ``--mode=%s``
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type

Outputs::

        targets: (a list of items which are an existing file name)
                a list with all generated seeds_to_target files
        fdt_paths: (a list of items which are an existing file name)
                path/name of a 3D image file containing the output connectivity
                distribution to the seed mask
        particle_files: (a list of items which are an existing file name)
                Files describing all of the tract samples. Generated only if verbose
                is set to 2
        log: (an existing file name)
                path/name of a text record of the command that was run
        way_total: (an existing file name)
                path/name of a text file containing a single number corresponding to
                the total number of generated tracts that have not been rejected by
                inclusion/exclusion mask criteria

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

.. _nipype.interfaces.fsl.dti.ProbTrackX2:


.. index:: ProbTrackX2

ProbTrackX2
-----------

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

Wraps the executable command ``probtrackx2``.

Use FSL  probtrackx2 for tractography on bedpostx results

Examples
~~~~~~~~

>>> from nipype.interfaces import fsl
>>> pbx2 = fsl.ProbTrackX2()
>>> pbx2.inputs.seed = 'seed_source.nii.gz'
>>> pbx2.inputs.thsamples = 'merged_th1samples.nii.gz'
>>> pbx2.inputs.fsamples = 'merged_f1samples.nii.gz'
>>> pbx2.inputs.phsamples = 'merged_ph1samples.nii.gz'
>>> pbx2.inputs.mask = 'nodif_brain_mask.nii.gz'
>>> pbx2.inputs.out_dir = '.'
>>> pbx2.inputs.n_samples = 3
>>> pbx2.inputs.n_steps = 10
>>> pbx2.cmdline
'probtrackx2 --forcedir -m nodif_brain_mask.nii.gz --nsamples=3 --nsteps=10 --opd --dir=. --samples=merged --seed=seed_source.nii.gz'

Inputs::

        [Mandatory]
        phsamples: (a list of items which are an existing file name)
        mask: (an existing file name)
                bet binary mask file in diffusion space
                argument: ``-m %s``
        seed: (an existing file name or a list of items which are an existing
                  file name or a list of items which are a list of from 3 to 3 items
                  which are an integer (int or long))
                seed volume(s), or voxel(s) or freesurfer label file
                argument: ``--seed=%s``
        thsamples: (a list of items which are an existing file name)
        fsamples: (a list of items which are an existing file name)

        [Optional]
        mod_euler: (a boolean)
                use modified euler streamlining
                argument: ``--modeuler``
        verbose: (0 or 1 or 2)
                Verbose level, [0-2]. Level 2 is required to output particle files.
                argument: ``--verbose=%d``
        out_dir: (an existing directory name)
                directory to put the final volumes in
                argument: ``--dir=%s``
        simple: (a boolean)
                rack from a list of voxels (seed must be a ASCII list of
                coordinates)
                argument: ``--simple``
        waypoints: (an existing file name)
                waypoint mask or ascii list of waypoint masks - only keep paths
                going through ALL the masks
                argument: ``--waypoints=%s``
        fibst: (an integer (int or long))
                force a starting fibre for tracking - default=1, i.e. first fibre
                orientation. Only works if randfib==0
                argument: ``--fibst=%d``
        lrtarget3: (an existing file name)
                Column-space mask used for Nxn connectivity matrix
                argument: ``--lrtarget3=%s``
        n_steps: (an integer (int or long))
                number of steps per sample - default=2000
                argument: ``--nsteps=%d``
        seed_ref: (an existing file name)
                reference vol to define seed space in simple mode - diffusion space
                assumed if absent
                argument: ``--seedref=%s``
        colmask4: (an existing file name)
                Mask for columns of matrix4 (default=seed mask)
                argument: ``--colmask4=%s``
        use_anisotropy: (a boolean)
                use anisotropy to constrain tracking
                argument: ``--usef``
        network: (a boolean)
                activate network mode - only keep paths going through at least one
                seed mask (required if multiple seed masks)
                argument: ``--network``
        sample_random_points: (a boolean)
                sample random points within seed voxels
                argument: ``--sampvox``
        os2t: (a boolean)
                Outputs seeds to targets
                argument: ``--os2t``
        avoid_mp: (an existing file name)
                reject pathways passing through locations given by this mask
                argument: ``--avoid=%s``
        waycond: (u'OR' or u'AND')
                Waypoint condition. Either "AND" (default) or "OR"
                argument: ``--waycond=%s``
        step_length: (a float)
                step_length in mm - default=0.5
                argument: ``--steplength=%.3f``
        n_samples: (an integer (int or long), nipype default value: 5000)
                number of samples - default=5000
                argument: ``--nsamples=%d``
        correct_path_distribution: (a boolean)
                correct path distribution for the length of the pathways
                argument: ``--pd``
        s2tastext: (a boolean)
                output seed-to-target counts as a text file (useful when seeding
                from a mesh)
                argument: ``--s2tastext``
        dist_thresh: (a float)
                discards samples shorter than this threshold (in mm - default=0)
                argument: ``--distthresh=%.3f``
        target_masks: (a list of items which are a file name)
                list of target masks - required for seeds_to_targets classification
                argument: ``--targetmasks=%s``
        stop_mask: (an existing file name)
                stop tracking at locations given by this mask file
                argument: ``--stop=%s``
        xfm: (an existing file name)
                transformation matrix taking seed space to DTI space (either FLIRT
                matrix or FNIRT warp_field) - default is identity
                argument: ``--xfm=%s``
        omatrix4: (a boolean)
                Output matrix4 - DtiMaskToSeed (special Oxford Sparse Format)
                argument: ``--omatrix4``
        samples_base_name: (a unicode string, nipype default value: merged)
                the rootname/base_name for samples files
                argument: ``--samples=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        distthresh1: (a float)
                Discards samples (in matrix1) shorter than this threshold (in mm -
                default=0)
                argument: ``--distthresh1=%.3f``
        omatrix1: (a boolean)
                Output matrix1 - SeedToSeed Connectivity
                argument: ``--omatrix1``
        distthresh3: (a float)
                Discards samples (in matrix3) shorter than this threshold (in mm -
                default=0)
                argument: ``--distthresh3=%.3f``
        omatrix3: (a boolean)
                Output matrix3 (NxN connectivity matrix)
                argument: ``--omatrix3``
                requires: target3, lrtarget3
        force_dir: (a boolean, nipype default value: True)
                use the actual directory name given - i.e. do not add + to make a
                new directory
                argument: ``--forcedir``
        wayorder: (a boolean)
                Reject streamlines that do not hit waypoints in given order. Only
                valid if waycond=AND
                argument: ``--wayorder``
        omatrix2: (a boolean)
                Output matrix2 - SeedToLowResMask
                argument: ``--omatrix2``
                requires: target2
        target4: (an existing file name)
                Brain mask in DTI space
                argument: ``--target4=%s``
        target2: (an existing file name)
                Low resolution binary brain mask for storing connectivity
                distribution in matrix2 mode
                argument: ``--target2=%s``
        target3: (an existing file name)
                Mask used for NxN connectivity matrix (or Nxn if lrtarget3 is set)
                argument: ``--target3=%s``
        meshspace: (u'caret' or u'freesurfer' or u'first' or u'vox')
                Mesh reference space - either "caret" (default) or "freesurfer" or
                "first" or "vox"
                argument: ``--meshspace=%s``
        random_seed: (a boolean)
                random seed
                argument: ``--rseed``
        opd: (a boolean, nipype default value: True)
                outputs path distributions
                argument: ``--opd``
        inv_xfm: (a file name)
                transformation matrix taking DTI space to seed space (compulsory
                when using a warp_field for seeds_to_dti)
                argument: ``--invxfm=%s``
        rand_fib: (0 or 1 or 2 or 3)
                options: 0 - default, 1 - to randomly sample initial fibres (with f
                > fibthresh), 2 - to sample in proportion fibres (with f>fibthresh)
                to f, 3 - to sample ALL populations at random (even if f<fibthresh)
                argument: ``--randfib=%d``
        loop_check: (a boolean)
                perform loop_checks on paths - slower, but allows lower curvature
                threshold
                argument: ``--loopcheck``
        c_thresh: (a float)
                curvature threshold - default=0.2
                argument: ``--cthr=%.3f``
        onewaycondition: (a boolean)
                Apply waypoint conditions to each half tract separately
                argument: ``--onewaycondition``
        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
        fopd: (an existing file name)
                Other mask for binning tract distribution
                argument: ``--fopd=%s``

Outputs::

        matrix3_dot: (an existing file name)
                Output matrix3 - NxN connectivity matrix
        lookup_tractspace: (an existing file name)
                lookup_tractspace generated by --omatrix2 option
        log: (an existing file name)
                path/name of a text record of the command that was run
        fdt_paths: (a list of items which are an existing file name)
                path/name of a 3D image file containing the output connectivity
                distribution to the seed mask
        particle_files: (a list of items which are an existing file name)
                Files describing all of the tract samples. Generated only if verbose
                is set to 2
        matrix2_dot: (an existing file name)
                Output matrix2.dot - SeedToLowResMask
        network_matrix: (an existing file name)
                the network matrix generated by --omatrix1 option
        way_total: (an existing file name)
                path/name of a text file containing a single number corresponding to
                the total number of generated tracts that have not been rejected by
                inclusion/exclusion mask criteria
        matrix1_dot: (an existing file name)
                Output matrix1.dot - SeedToSeed Connectivity
        targets: (a list of items which are an existing file name)
                a list with all generated seeds_to_target files

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

.. _nipype.interfaces.fsl.dti.ProjThresh:


.. index:: ProjThresh

ProjThresh
----------

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

Wraps the executable command ``proj_thresh``.

Use FSL proj_thresh for thresholding some outputs of probtrack
For complete details, see the FDT Documentation
<http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_thresh.html>

Example
~~~~~~~

>>> from nipype.interfaces import fsl
>>> ldir = ['seeds_to_M1.nii', 'seeds_to_M2.nii']
>>> pThresh = fsl.ProjThresh(in_files=ldir, threshold=3)
>>> pThresh.cmdline
'proj_thresh seeds_to_M1.nii seeds_to_M2.nii 3'

Inputs::

        [Mandatory]
        threshold: (an integer (int or long))
                threshold indicating minimum number of seed voxels entering this
                mask region
                argument: ``%d``, position: 1
        in_files: (a list of items which are an existing file name)
                a list of input volumes
                argument: ``%s``, position: 0

        [Optional]
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        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

Outputs::

        out_files: (a list of items which are an existing file name)
                path/name of output volume after thresholding

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

.. _nipype.interfaces.fsl.dti.TractSkeleton:


.. index:: TractSkeleton

TractSkeleton
-------------

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

Wraps the executable command ``tbss_skeleton``.

Use FSL's tbss_skeleton to skeletonise an FA image or project arbitrary
values onto a skeleton.

There are two ways to use this interface.  To create a skeleton from an FA
image, just supply the ``in_file`` and set ``skeleton_file`` to True (or
specify a skeleton filename. To project values onto a skeleton, you must
set ``project_data`` to True, and then also supply values for
``threshold``, ``distance_map``, and ``data_file``. The
``search_mask_file`` and ``use_cingulum_mask`` inputs are also used in data
projection, but ``use_cingulum_mask`` is set to True by default.  This mask
controls where the projection algorithm searches within a circular space
around a tract, rather than in a single perpindicular direction.

Example
~~~~~~~

>>> import nipype.interfaces.fsl as fsl
>>> skeletor = fsl.TractSkeleton()
>>> skeletor.inputs.in_file = "all_FA.nii.gz"
>>> skeletor.inputs.skeleton_file = True
>>> skeletor.run() # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input image (typcially mean FA volume)
                argument: ``-i %s``

        [Optional]
        use_cingulum_mask: (a boolean, nipype default value: True)
                perform alternate search using built-in cingulum mask
                mutually_exclusive: search_mask_file
        skeleton_file: (a boolean or a file name)
                write out skeleton image
                argument: ``-o %s``
        data_file: (an existing file name)
                4D data to project onto skeleton (usually FA)
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        projected_data: (a file name)
                input data projected onto skeleton
        alt_skeleton: (an existing file name)
                alternate skeleton to use
                argument: ``-s %s``
        alt_data_file: (an existing file name)
                4D non-FA data to project onto skeleton
                argument: ``-a %s``
        threshold: (a float)
                skeleton threshold value
        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
        project_data: (a boolean)
                project data onto skeleton
                argument: ``-p %.3f %s %s %s %s``
                requires: threshold, distance_map, data_file
        search_mask_file: (an existing file name)
                mask in which to use alternate search rule
                mutually_exclusive: use_cingulum_mask
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        distance_map: (an existing file name)
                distance map image

Outputs::

        projected_data: (a file name)
                input data projected onto skeleton
        skeleton_file: (a file name)
                tract skeleton image

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

.. _nipype.interfaces.fsl.dti.VecReg:


.. index:: VecReg

VecReg
------

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

Wraps the executable command ``vecreg``.

Use FSL vecreg for registering vector data
For complete details, see the FDT Documentation
<http://www.fmrib.ox.ac.uk/fsl/fdt/fdt_vecreg.html>

Example
~~~~~~~

>>> from nipype.interfaces import fsl
>>> vreg = fsl.VecReg(in_file='diffusion.nii',                  affine_mat='trans.mat',                  ref_vol='mni.nii',                  out_file='diffusion_vreg.nii')
>>> vreg.cmdline
'vecreg -t trans.mat -i diffusion.nii -o diffusion_vreg.nii -r mni.nii'

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                filename for input vector or tensor field
                argument: ``-i %s``
        ref_vol: (an existing file name)
                filename for reference (target) volume
                argument: ``-r %s``

        [Optional]
        warp_field: (an existing file name)
                filename for 4D warp field for nonlinear registration
                argument: ``-w %s``
        out_file: (a file name)
                filename for output registered vector or tensor field
                argument: ``-o %s``
        rotation_warp: (an existing file name)
                filename for secondary warp field if set, this will be used for the
                rotation of the vector/tensor field
                argument: ``--rotwarp=%s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        mask: (an existing file name)
                brain mask in input space
                argument: ``-m %s``
        rotation_mat: (an existing file name)
                filename for secondary affine matrix if set, this will be used for
                the rotation of the vector/tensor field
                argument: ``--rotmat=%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
        affine_mat: (an existing file name)
                filename for affine transformation matrix
                argument: ``-t %s``
        ref_mask: (an existing file name)
                brain mask in output space (useful for speed up of nonlinear reg)
                argument: ``--refmask=%s``
        interpolation: (u'nearestneighbour' or u'trilinear' or u'sinc' or
                  u'spline')
                interpolation method : nearestneighbour, trilinear (default), sinc
                or spline
                argument: ``--interp=%s``

Outputs::

        out_file: (an existing file name)
                path/name of filename for the registered vector or tensor field

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

.. _nipype.interfaces.fsl.dti.XFibres5:


.. index:: XFibres5

XFibres5
--------

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

Wraps the executable command ``xfibres``.

Perform model parameters estimation for local (voxelwise) diffusion
parameters

Inputs::

        [Mandatory]
        bvecs: (an existing file name)
                b vectors file
                argument: ``--bvecs=%s``
        bvals: (an existing file name)
                b values file
                argument: ``--bvals=%s``
        mask: (an existing file name)
                brain binary mask file (i.e. from BET)
                argument: ``--mask=%s``
        dwi: (an existing file name)
                diffusion weighted image data file
                argument: ``--data=%s``
        n_fibres: (an integer >= 1, nipype default value: 2)
                Maximum number of fibres to fit in each voxel
                argument: ``--nfibres=%d``

        [Optional]
        sample_every: (an integer >= 0, nipype default value: 1)
                Num of jumps for each sample (MCMC)
                argument: ``--sampleevery=%d``
        no_spat: (a boolean)
                Initialise with tensor, not spatially
                argument: ``--nospat``
                mutually_exclusive: no_spat, non_linear, cnlinear
        n_jumps: (an integer (int or long), nipype default value: 5000)
                Num of jumps to be made by MCMC
                argument: ``--njumps=%d``
        seed: (an integer (int or long))
                seed for pseudo random number generator
                argument: ``--seed=%d``
        burn_in: (an integer >= 0, nipype default value: 0)
                Total num of jumps at start of MCMC to be discarded
                argument: ``--burnin=%d``
        all_ard: (a boolean)
                Turn ARD on on all fibres
                argument: ``--allard``
                mutually_exclusive: no_ard, all_ard
        non_linear: (a boolean)
                Initialise with nonlinear fitting
                argument: ``--nonlinear``
                mutually_exclusive: no_spat, non_linear, cnlinear
        logdir: (a directory name, nipype default value: .)
                argument: ``--logdir=%s``
        fudge: (an integer (int or long))
                ARD fudge factor
                argument: ``--fudge=%d``
        rician: (a boolean)
                use Rician noise modeling
                argument: ``--rician``
        no_ard: (a boolean)
                Turn ARD off on all fibres
                argument: ``--noard``
                mutually_exclusive: no_ard, all_ard
        f0_ard: (a boolean)
                Noise floor model: add to the model an unattenuated signal
                compartment f0
                argument: ``--f0 --ardf0``
                mutually_exclusive: f0_noard, f0_ard, all_ard
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        force_dir: (a boolean, nipype default value: True)
                use the actual directory name given (do not add + to make a new
                directory)
                argument: ``--forcedir``
        update_proposal_every: (an integer >= 1, nipype default value: 40)
                Num of jumps for each update to the proposal density std (MCMC)
                argument: ``--updateproposalevery=%d``
        cnlinear: (a boolean)
                Initialise with constrained nonlinear fitting
                argument: ``--cnonlinear``
                mutually_exclusive: no_spat, non_linear, cnlinear
        f0_noard: (a boolean)
                Noise floor model: add to the model an unattenuated signal
                compartment f0
                argument: ``--f0``
                mutually_exclusive: f0_noard, f0_ard
        gradnonlin: (an existing file name)
                gradient file corresponding to slice
                argument: ``--gradnonlin=%s``
        burn_in_no_ard: (an integer >= 0, nipype default value: 0)
                num of burnin jumps before the ard is imposed
                argument: ``--burnin_noard=%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
        output_type: (u'NIFTI_PAIR' or u'NIFTI_PAIR_GZ' or u'NIFTI_GZ' or
                  u'NIFTI')
                FSL output type
        model: (1 or 2 or 3)
                use monoexponential (1, default, required for single-shell) or
                multiexponential (2, multi-shell) model
                argument: ``--model=%d``

Outputs::

        mean_fsamples: (a list of items which are an existing file name)
                Mean of distribution on f anisotropy
        mean_S0samples: (an existing file name)
                Mean of distribution on T2wbaseline signal intensity S0
        mean_tausamples: (an existing file name)
                Mean of distribution on tau samples (only with rician noise)
        dyads: (a list of items which are an existing file name)
                Mean of PDD distribution in vector form.
        phsamples: (a list of items which are an existing file name)
                phi samples, per fiber
        fsamples: (a list of items which are an existing file name)
                Samples from the distribution on f anisotropy
        thsamples: (a list of items which are an existing file name)
                theta samples, per fiber
        mean_dsamples: (an existing file name)
                Mean of distribution on diffusivity d

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