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

interfaces.mrtrix.tracking
==========================


.. _nipype.interfaces.mrtrix.tracking.DiffusionTensorStreamlineTrack:


.. index:: DiffusionTensorStreamlineTrack

DiffusionTensorStreamlineTrack
------------------------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L424>`__

Wraps the executable command ``streamtrack``.

Specialized interface to StreamlineTrack. This interface is used for
streamline tracking from diffusion tensor data, and calls the MRtrix
function 'streamtrack' with the option 'DT_STREAM'

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> dtstrack = mrt.DiffusionTensorStreamlineTrack()
>>> dtstrack.inputs.in_file = 'data.Bfloat'
>>> dtstrack.inputs.seed_file = 'seed_mask.nii'
>>> dtstrack.run()                                  # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                the image containing the source data.The type of data required
                depends on the type of tracking as set in the preceeding argument.
                For DT methods, the base DWI are needed. For SD methods, the SH
                harmonic coefficients of the FOD are needed.
                argument: ``%s``, position: -2
        gradient_encoding_file: (an existing file name)
                Gradient encoding, supplied as a 4xN text file with each line is in
                the format [ X Y Z b ], where [ X Y Z ] describe the direction of
                the applied gradient, and b gives the b-value in units (1000
                s/mm^2). See FSL2MRTrix
                argument: ``-grad %s``, position: -2

        [Optional]
        do_not_precompute: (a boolean)
                Turns off precomputation of the legendre polynomial values. Warning:
                this will slow down the algorithm by a factor of approximately 4.
                argument: ``-noprecomputed``
        maximum_number_of_tracks: (an integer (int or long))
                Sets the maximum number of tracks to generate.The program will not
                generate more tracks than this number, even if the desired number of
                tracks hasn't yet been reached(default is 100 x number).
                argument: ``-maxnum %d``
        exclude_file: (an existing file name)
                exclusion file
                argument: ``-exclude %s``
                mutually_exclusive: exclude_file, exclude_spec
        cutoff_value: (a float)
                Set the FA or FOD amplitude cutoff for terminating tracks (default
                is 0.1).
                argument: ``-cutoff %s``
        seed_file: (an existing file name)
                seed file
                argument: ``-seed %s``
                mutually_exclusive: seed_file, seed_spec
        step_size: (a float)
                Set the step size of the algorithm in mm (default is 0.2).
                argument: ``-step %s``
        unidirectional: (a boolean)
                Track from the seed point in one direction only (default is to track
                in both directions).
                argument: ``-unidirectional``
        no_mask_interpolation: (a boolean)
                Turns off trilinear interpolation of mask images.
                argument: ``-nomaskinterp``
        include_file: (an existing file name)
                inclusion file
                argument: ``-include %s``
                mutually_exclusive: include_file, include_spec
        maximum_tract_length: (a float)
                Sets the maximum length of any track in millimeters (default is 200
                mm).
                argument: ``-length %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        stop: (a boolean)
                stop track as soon as it enters any of the include regions.
                argument: ``-stop``
        minimum_tract_length: (a float)
                Sets the minimum length of any track in millimeters (default is 10
                mm).
                argument: ``-minlength %s``
        inputmodel: (u'DT_STREAM' or u'SD_PROB' or u'SD_STREAM', nipype
                  default value: DT_STREAM)
                input model type
                argument: ``%s``, position: -3
        initial_direction: (a list of from 2 to 2 items which are an integer
                  (int or long))
                Specify the initial tracking direction as a vector
                argument: ``-initdirection %s``
        exclude_spec: (a list of from 4 to 4 items which are a float)
                exclusion specification in mm and radius (x y z r)
                argument: ``-exclude %s``, position: 2
                mutually_exclusive: exclude_file, exclude_spec
        desired_number_of_tracks: (an integer (int or long))
                Sets the desired number of tracks.The program will continue to
                generate tracks until this number of tracks have been selected and
                written to the output file(default is 100 for *_STREAM methods, 1000
                for *_PROB methods).
                argument: ``-number %d``
        seed_spec: (a list of from 4 to 4 items which are a float)
                seed specification in mm and radius (x y z r)
                argument: ``-seed %s``, position: 2
                mutually_exclusive: seed_file, seed_spec
        initial_cutoff_value: (a float)
                Sets the minimum FA or FOD amplitude for initiating tracks (default
                is twice the normal cutoff).
                argument: ``-initcutoff %s``
        minimum_radius_of_curvature: (a float)
                Set the minimum radius of curvature (default is 2 mm for DT_STREAM,
                0 for SD_STREAM, 1 mm for SD_PROB and DT_PROB)
                argument: ``-curvature %s``
        mask_spec: (a list of from 4 to 4 items which are a float)
                Mask specification in mm and radius (x y z r). Tracks will be
                terminated when they leave the ROI.
                argument: ``-mask %s``, position: 2
                mutually_exclusive: mask_file, mask_spec
        out_file: (a file name)
                output data file
                argument: ``%s``, position: -1
        include_spec: (a list of from 4 to 4 items which are a float)
                inclusion specification in mm and radius (x y z r)
                argument: ``-include %s``, position: 2
                mutually_exclusive: include_file, include_spec
        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)
                mask file. Only tracks within mask.
                argument: ``-mask %s``
                mutually_exclusive: mask_file, mask_spec

Outputs::

        tracked: (an existing file name)
                output file containing reconstructed tracts

.. _nipype.interfaces.mrtrix.tracking.FilterTracks:


.. index:: FilterTracks

FilterTracks
------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L91>`__

Wraps the executable command ``filter_tracks``.

Use regions-of-interest to select a subset of tracks
from a given MRtrix track file.

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> filt = mrt.FilterTracks()
>>> filt.inputs.in_file = 'tracks.tck'
>>> filt.run()                                 # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                input tracks to be filtered
                argument: ``%s``, position: -2

        [Optional]
        include_file: (an existing file name)
                inclusion file
                argument: ``-include %s``
                mutually_exclusive: include_file, include_spec
        minimum_tract_length: (a float)
                Sets the minimum length of any track in millimeters (default is 10
                mm).
                argument: ``-minlength %s``
        out_file: (a file name)
                Output filtered track filename
                argument: ``%s``, position: -1
        exclude_file: (an existing file name)
                exclusion file
                argument: ``-exclude %s``
                mutually_exclusive: exclude_file, exclude_spec
        include_spec: (a list of from 4 to 4 items which are a float)
                inclusion specification in mm and radius (x y z r)
                argument: ``-include %s``, position: 2
                mutually_exclusive: include_file, include_spec
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        quiet: (a boolean)
                Do not display information messages or progress status.
                argument: ``-quiet``, position: 1
        environ: (a dictionary with keys which are a newbytes or None or a
                  newstr or None and with values which are a newbytes or None or a
                  newstr or None, nipype default value: {})
                Environment variables
        debug: (a boolean)
                Display debugging messages.
                argument: ``-debug``, position: 1
        exclude_spec: (a list of from 4 to 4 items which are a float)
                exclusion specification in mm and radius (x y z r)
                argument: ``-exclude %s``, position: 2
                mutually_exclusive: exclude_file, exclude_spec
        no_mask_interpolation: (a boolean)
                Turns off trilinear interpolation of mask images.
                argument: ``-nomaskinterp``
        invert: (a boolean)
                invert the matching process, so that tracks that wouldotherwise have
                been included are now excluded and vice-versa.
                argument: ``-invert``

Outputs::

        out_file: (an existing file name)
                the output filtered tracks

.. _nipype.interfaces.mrtrix.tracking.ProbabilisticSphericallyDeconvolutedStreamlineTrack:


.. index:: ProbabilisticSphericallyDeconvolutedStreamlineTrack

ProbabilisticSphericallyDeconvolutedStreamlineTrack
---------------------------------------------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L457>`__

Wraps the executable command ``streamtrack``.

Performs probabilistic tracking using spherically deconvolved data

Specialized interface to StreamlineTrack. This interface is used for
probabilistic tracking from spherically deconvolved data, and calls
the MRtrix function 'streamtrack' with the option 'SD_PROB'

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> sdprobtrack = mrt.ProbabilisticSphericallyDeconvolutedStreamlineTrack()
>>> sdprobtrack.inputs.in_file = 'data.Bfloat'
>>> sdprobtrack.inputs.seed_file = 'seed_mask.nii'
>>> sdprobtrack.run()                                                       # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                the image containing the source data.The type of data required
                depends on the type of tracking as set in the preceeding argument.
                For DT methods, the base DWI are needed. For SD methods, the SH
                harmonic coefficients of the FOD are needed.
                argument: ``%s``, position: -2

        [Optional]
        do_not_precompute: (a boolean)
                Turns off precomputation of the legendre polynomial values. Warning:
                this will slow down the algorithm by a factor of approximately 4.
                argument: ``-noprecomputed``
        maximum_number_of_tracks: (an integer (int or long))
                Sets the maximum number of tracks to generate.The program will not
                generate more tracks than this number, even if the desired number of
                tracks hasn't yet been reached(default is 100 x number).
                argument: ``-maxnum %d``
        exclude_file: (an existing file name)
                exclusion file
                argument: ``-exclude %s``
                mutually_exclusive: exclude_file, exclude_spec
        cutoff_value: (a float)
                Set the FA or FOD amplitude cutoff for terminating tracks (default
                is 0.1).
                argument: ``-cutoff %s``
        seed_file: (an existing file name)
                seed file
                argument: ``-seed %s``
                mutually_exclusive: seed_file, seed_spec
        step_size: (a float)
                Set the step size of the algorithm in mm (default is 0.2).
                argument: ``-step %s``
        unidirectional: (a boolean)
                Track from the seed point in one direction only (default is to track
                in both directions).
                argument: ``-unidirectional``
        no_mask_interpolation: (a boolean)
                Turns off trilinear interpolation of mask images.
                argument: ``-nomaskinterp``
        include_file: (an existing file name)
                inclusion file
                argument: ``-include %s``
                mutually_exclusive: include_file, include_spec
        maximum_tract_length: (a float)
                Sets the maximum length of any track in millimeters (default is 200
                mm).
                argument: ``-length %s``
        maximum_number_of_trials: (an integer (int or long))
                Set the maximum number of sampling trials at each point (only used
                for probabilistic tracking).
                argument: ``-trials %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        stop: (a boolean)
                stop track as soon as it enters any of the include regions.
                argument: ``-stop``
        minimum_tract_length: (a float)
                Sets the minimum length of any track in millimeters (default is 10
                mm).
                argument: ``-minlength %s``
        inputmodel: (u'DT_STREAM' or u'SD_PROB' or u'SD_STREAM', nipype
                  default value: DT_STREAM)
                input model type
                argument: ``%s``, position: -3
        initial_direction: (a list of from 2 to 2 items which are an integer
                  (int or long))
                Specify the initial tracking direction as a vector
                argument: ``-initdirection %s``
        exclude_spec: (a list of from 4 to 4 items which are a float)
                exclusion specification in mm and radius (x y z r)
                argument: ``-exclude %s``, position: 2
                mutually_exclusive: exclude_file, exclude_spec
        desired_number_of_tracks: (an integer (int or long))
                Sets the desired number of tracks.The program will continue to
                generate tracks until this number of tracks have been selected and
                written to the output file(default is 100 for *_STREAM methods, 1000
                for *_PROB methods).
                argument: ``-number %d``
        seed_spec: (a list of from 4 to 4 items which are a float)
                seed specification in mm and radius (x y z r)
                argument: ``-seed %s``, position: 2
                mutually_exclusive: seed_file, seed_spec
        initial_cutoff_value: (a float)
                Sets the minimum FA or FOD amplitude for initiating tracks (default
                is twice the normal cutoff).
                argument: ``-initcutoff %s``
        minimum_radius_of_curvature: (a float)
                Set the minimum radius of curvature (default is 2 mm for DT_STREAM,
                0 for SD_STREAM, 1 mm for SD_PROB and DT_PROB)
                argument: ``-curvature %s``
        mask_spec: (a list of from 4 to 4 items which are a float)
                Mask specification in mm and radius (x y z r). Tracks will be
                terminated when they leave the ROI.
                argument: ``-mask %s``, position: 2
                mutually_exclusive: mask_file, mask_spec
        out_file: (a file name)
                output data file
                argument: ``%s``, position: -1
        include_spec: (a list of from 4 to 4 items which are a float)
                inclusion specification in mm and radius (x y z r)
                argument: ``-include %s``, position: 2
                mutually_exclusive: include_file, include_spec
        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)
                mask file. Only tracks within mask.
                argument: ``-mask %s``
                mutually_exclusive: mask_file, mask_spec

Outputs::

        tracked: (an existing file name)
                output file containing reconstructed tracts

.. _nipype.interfaces.mrtrix.tracking.SphericallyDeconvolutedStreamlineTrack:


.. index:: SphericallyDeconvolutedStreamlineTrack

SphericallyDeconvolutedStreamlineTrack
--------------------------------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L482>`__

Wraps the executable command ``streamtrack``.

Performs streamline tracking using spherically deconvolved data

Specialized interface to StreamlineTrack. This interface is used for
streamline tracking from spherically deconvolved data, and calls
the MRtrix function 'streamtrack' with the option 'SD_STREAM'

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> sdtrack = mrt.SphericallyDeconvolutedStreamlineTrack()
>>> sdtrack.inputs.in_file = 'data.Bfloat'
>>> sdtrack.inputs.seed_file = 'seed_mask.nii'
>>> sdtrack.run()                                          # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                the image containing the source data.The type of data required
                depends on the type of tracking as set in the preceeding argument.
                For DT methods, the base DWI are needed. For SD methods, the SH
                harmonic coefficients of the FOD are needed.
                argument: ``%s``, position: -2

        [Optional]
        do_not_precompute: (a boolean)
                Turns off precomputation of the legendre polynomial values. Warning:
                this will slow down the algorithm by a factor of approximately 4.
                argument: ``-noprecomputed``
        maximum_number_of_tracks: (an integer (int or long))
                Sets the maximum number of tracks to generate.The program will not
                generate more tracks than this number, even if the desired number of
                tracks hasn't yet been reached(default is 100 x number).
                argument: ``-maxnum %d``
        exclude_file: (an existing file name)
                exclusion file
                argument: ``-exclude %s``
                mutually_exclusive: exclude_file, exclude_spec
        cutoff_value: (a float)
                Set the FA or FOD amplitude cutoff for terminating tracks (default
                is 0.1).
                argument: ``-cutoff %s``
        seed_file: (an existing file name)
                seed file
                argument: ``-seed %s``
                mutually_exclusive: seed_file, seed_spec
        step_size: (a float)
                Set the step size of the algorithm in mm (default is 0.2).
                argument: ``-step %s``
        unidirectional: (a boolean)
                Track from the seed point in one direction only (default is to track
                in both directions).
                argument: ``-unidirectional``
        no_mask_interpolation: (a boolean)
                Turns off trilinear interpolation of mask images.
                argument: ``-nomaskinterp``
        include_file: (an existing file name)
                inclusion file
                argument: ``-include %s``
                mutually_exclusive: include_file, include_spec
        maximum_tract_length: (a float)
                Sets the maximum length of any track in millimeters (default is 200
                mm).
                argument: ``-length %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        stop: (a boolean)
                stop track as soon as it enters any of the include regions.
                argument: ``-stop``
        minimum_radius_of_curvature: (a float)
                Set the minimum radius of curvature (default is 2 mm for DT_STREAM,
                0 for SD_STREAM, 1 mm for SD_PROB and DT_PROB)
                argument: ``-curvature %s``
        inputmodel: (u'DT_STREAM' or u'SD_PROB' or u'SD_STREAM', nipype
                  default value: DT_STREAM)
                input model type
                argument: ``%s``, position: -3
        initial_direction: (a list of from 2 to 2 items which are an integer
                  (int or long))
                Specify the initial tracking direction as a vector
                argument: ``-initdirection %s``
        exclude_spec: (a list of from 4 to 4 items which are a float)
                exclusion specification in mm and radius (x y z r)
                argument: ``-exclude %s``, position: 2
                mutually_exclusive: exclude_file, exclude_spec
        desired_number_of_tracks: (an integer (int or long))
                Sets the desired number of tracks.The program will continue to
                generate tracks until this number of tracks have been selected and
                written to the output file(default is 100 for *_STREAM methods, 1000
                for *_PROB methods).
                argument: ``-number %d``
        seed_spec: (a list of from 4 to 4 items which are a float)
                seed specification in mm and radius (x y z r)
                argument: ``-seed %s``, position: 2
                mutually_exclusive: seed_file, seed_spec
        initial_cutoff_value: (a float)
                Sets the minimum FA or FOD amplitude for initiating tracks (default
                is twice the normal cutoff).
                argument: ``-initcutoff %s``
        minimum_tract_length: (a float)
                Sets the minimum length of any track in millimeters (default is 10
                mm).
                argument: ``-minlength %s``
        mask_spec: (a list of from 4 to 4 items which are a float)
                Mask specification in mm and radius (x y z r). Tracks will be
                terminated when they leave the ROI.
                argument: ``-mask %s``, position: 2
                mutually_exclusive: mask_file, mask_spec
        out_file: (a file name)
                output data file
                argument: ``%s``, position: -1
        include_spec: (a list of from 4 to 4 items which are a float)
                inclusion specification in mm and radius (x y z r)
                argument: ``-include %s``, position: 2
                mutually_exclusive: include_file, include_spec
        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)
                mask file. Only tracks within mask.
                argument: ``-mask %s``
                mutually_exclusive: mask_file, mask_spec

Outputs::

        tracked: (an existing file name)
                output file containing reconstructed tracts

.. _nipype.interfaces.mrtrix.tracking.StreamlineTrack:


.. index:: StreamlineTrack

StreamlineTrack
---------------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L388>`__

Wraps the executable command ``streamtrack``.

Performs tractography using one of the following models:
'dt_prob', 'dt_stream', 'sd_prob', 'sd_stream',
Where 'dt' stands for diffusion tensor, 'sd' stands for spherical
deconvolution, and 'prob' stands for probabilistic.

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> strack = mrt.StreamlineTrack()
>>> strack.inputs.inputmodel = 'SD_PROB'
>>> strack.inputs.in_file = 'data.Bfloat'
>>> strack.inputs.seed_file = 'seed_mask.nii'
>>> strack.inputs.mask_file = 'mask.nii'
>>> strack.cmdline
'streamtrack -mask mask.nii -seed seed_mask.nii SD_PROB data.Bfloat data_tracked.tck'
>>> strack.run()                                    # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                the image containing the source data.The type of data required
                depends on the type of tracking as set in the preceeding argument.
                For DT methods, the base DWI are needed. For SD methods, the SH
                harmonic coefficients of the FOD are needed.
                argument: ``%s``, position: -2

        [Optional]
        do_not_precompute: (a boolean)
                Turns off precomputation of the legendre polynomial values. Warning:
                this will slow down the algorithm by a factor of approximately 4.
                argument: ``-noprecomputed``
        maximum_number_of_tracks: (an integer (int or long))
                Sets the maximum number of tracks to generate.The program will not
                generate more tracks than this number, even if the desired number of
                tracks hasn't yet been reached(default is 100 x number).
                argument: ``-maxnum %d``
        exclude_file: (an existing file name)
                exclusion file
                argument: ``-exclude %s``
                mutually_exclusive: exclude_file, exclude_spec
        cutoff_value: (a float)
                Set the FA or FOD amplitude cutoff for terminating tracks (default
                is 0.1).
                argument: ``-cutoff %s``
        seed_file: (an existing file name)
                seed file
                argument: ``-seed %s``
                mutually_exclusive: seed_file, seed_spec
        step_size: (a float)
                Set the step size of the algorithm in mm (default is 0.2).
                argument: ``-step %s``
        unidirectional: (a boolean)
                Track from the seed point in one direction only (default is to track
                in both directions).
                argument: ``-unidirectional``
        no_mask_interpolation: (a boolean)
                Turns off trilinear interpolation of mask images.
                argument: ``-nomaskinterp``
        include_file: (an existing file name)
                inclusion file
                argument: ``-include %s``
                mutually_exclusive: include_file, include_spec
        maximum_tract_length: (a float)
                Sets the maximum length of any track in millimeters (default is 200
                mm).
                argument: ``-length %s``
        args: (a unicode string)
                Additional parameters to the command
                argument: ``%s``
        stop: (a boolean)
                stop track as soon as it enters any of the include regions.
                argument: ``-stop``
        minimum_radius_of_curvature: (a float)
                Set the minimum radius of curvature (default is 2 mm for DT_STREAM,
                0 for SD_STREAM, 1 mm for SD_PROB and DT_PROB)
                argument: ``-curvature %s``
        inputmodel: (u'DT_STREAM' or u'SD_PROB' or u'SD_STREAM', nipype
                  default value: DT_STREAM)
                input model type
                argument: ``%s``, position: -3
        initial_direction: (a list of from 2 to 2 items which are an integer
                  (int or long))
                Specify the initial tracking direction as a vector
                argument: ``-initdirection %s``
        exclude_spec: (a list of from 4 to 4 items which are a float)
                exclusion specification in mm and radius (x y z r)
                argument: ``-exclude %s``, position: 2
                mutually_exclusive: exclude_file, exclude_spec
        desired_number_of_tracks: (an integer (int or long))
                Sets the desired number of tracks.The program will continue to
                generate tracks until this number of tracks have been selected and
                written to the output file(default is 100 for *_STREAM methods, 1000
                for *_PROB methods).
                argument: ``-number %d``
        seed_spec: (a list of from 4 to 4 items which are a float)
                seed specification in mm and radius (x y z r)
                argument: ``-seed %s``, position: 2
                mutually_exclusive: seed_file, seed_spec
        initial_cutoff_value: (a float)
                Sets the minimum FA or FOD amplitude for initiating tracks (default
                is twice the normal cutoff).
                argument: ``-initcutoff %s``
        minimum_tract_length: (a float)
                Sets the minimum length of any track in millimeters (default is 10
                mm).
                argument: ``-minlength %s``
        mask_spec: (a list of from 4 to 4 items which are a float)
                Mask specification in mm and radius (x y z r). Tracks will be
                terminated when they leave the ROI.
                argument: ``-mask %s``, position: 2
                mutually_exclusive: mask_file, mask_spec
        out_file: (a file name)
                output data file
                argument: ``%s``, position: -1
        include_spec: (a list of from 4 to 4 items which are a float)
                inclusion specification in mm and radius (x y z r)
                argument: ``-include %s``, position: 2
                mutually_exclusive: include_file, include_spec
        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)
                mask file. Only tracks within mask.
                argument: ``-mask %s``
                mutually_exclusive: mask_file, mask_spec

Outputs::

        tracked: (an existing file name)
                output file containing reconstructed tracts

.. _nipype.interfaces.mrtrix.tracking.Tracks2Prob:


.. index:: Tracks2Prob

Tracks2Prob
-----------

`Link to code <file:///build/nipype-1.1.8/nipype/interfaces/mrtrix/tracking.py#L176>`__

Wraps the executable command ``tracks2prob``.

Convert a tract file into a map of the fraction of tracks to enter
each voxel - also known as a tract density image (TDI) - in MRtrix's
image format (.mif). This can be viewed using MRview or converted to
Nifti using MRconvert.

Example
~~~~~~~

>>> import nipype.interfaces.mrtrix as mrt
>>> tdi = mrt.Tracks2Prob()
>>> tdi.inputs.in_file = 'dwi_CSD_tracked.tck'
>>> tdi.inputs.colour = True
>>> tdi.run()                                       # doctest: +SKIP

Inputs::

        [Mandatory]
        in_file: (an existing file name)
                tract file
                argument: ``%s``, position: -2

        [Optional]
        out_filename: (a file name)
                output data file
                argument: ``%s``, position: -1
        template_file: (an existing file name)
                an image file to be used as a template for the output (the output
                image wil have the same transform and field of view)
                argument: ``-template %s``, position: 1
        resample: (a float)
                resample the tracks at regular intervals using Hermite
                interpolation. If omitted, the program will select an appropriate
                interpolation factor automatically.
                argument: ``-resample %d``, position: 3
        colour: (a boolean)
                add colour to the output image according to the direction of the
                tracks.
                argument: ``-colour``, position: 3
        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
        fraction: (a boolean)
                produce an image of the fraction of fibres through each voxel (as a
                proportion of the total number in the file), rather than the count.
                argument: ``-fraction``, position: 3
        voxel_dims: (a list of from 3 to 3 items which are a float)
                Three comma-separated numbers giving the size of each voxel in mm.
                argument: ``-vox %s``, position: 2
        output_datatype: (u'Bit' or u'Int8' or u'UInt8' or u'Int16' or
                  u'UInt16' or u'Int32' or u'UInt32' or u'float32' or u'float64')
                "i.e. Bfloat". Can be "char", "short", "int", "long", "float" or
                "double"
                argument: ``-datatype %s``, position: 2

Outputs::

        tract_image: (an existing file name)
                Output tract count or track density image
