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

interfaces.brainsuite.brainsuite
================================


.. _nipype.interfaces.brainsuite.brainsuite.Bfc:


.. index:: Bfc

Bfc
---

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L175>`__

Wraps command **bfc**

bias field corrector (BFC)
This program corrects gain variation in T1-weighted MRI.

http://brainsuite.org/processing/surfaceextraction/bfc/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> bfc = brainsuite.Bfc()
>>> bfc.inputs.inputMRIFile = example_data('structural.nii')
>>> bfc.inputs.inputMaskFile = example_data('mask.nii')
>>> results = bfc.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMRIFile: (a file name)
                input skull-stripped MRI volume
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        biasEstimateConvergenceThreshold: (a float)
                bias estimate convergence threshold (values > 0.1 disable)
                flag: --beps %f
        biasEstimateSpacing: (an integer (int or long))
                bias sample spacing (voxels)
                flag: -s %d
        biasFieldEstimatesOutputPrefix: (a string)
                save iterative biasfield estimates as<prefix>.n.field.nii.gz
                flag: --biasprefix %s
        biasRange: ('low' or 'medium' or 'high')
                Preset options for bias_model
                low: small bias model [0.95,1.05]
                medium: medium bias model [0.90,1.10]
                high: high bias model [0.80,1.20]
                flag: %s
        controlPointSpacing: (an integer (int or long))
                control point spacing (voxels)
                flag: -c %d
        convergenceThreshold: (a float)
                convergence threshold
                flag: --eps %f
        correctWholeVolume: (a boolean)
                apply correction field to entirevolume
                flag: --extrapolate
        correctedImagesOutputPrefix: (a string)
                save iterative correctedimages as<prefix>.n.bfc.nii.gz
                flag: --prefix %s
        correctionScheduleFile: (a file name)
                list of parameters
                flag: --schedule %s
        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
        histogramRadius: (an integer (int or long))
                histogram radius (voxels)
                flag: -r %d
        histogramType: ('ellipse' or 'block')
                Options for type of histogram
                ellipse:use ellipsoid for ROI histogram
                block:use block for ROI histogram
                flag: %s
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        inputMaskFile: (a file name)
                mask file
                flag: -m %s
        intermediate_file_type: ('analyze' or 'nifti' or 'gzippedAnalyze' or
                 'gzippedNifti')
                Options for the format inwhich intermediate files aregenerated
                flag: %s
        iterativeMode: (a boolean)
                iterative mode (overrides -r, -s, -c,-w settings)
                flag: --iterate
        maxBias: (a float, nipype default value: 1.5)
                maximum allowed biasvalue
                flag: -U %f
        minBias: (a float, nipype default value: 0.5)
                minimum allowed biasvalue
                flag: -L %f
        outputBiasField: (a file name)
                save bias field estimate
                flag: --bias %s
        outputMRIVolume: (a file name)
                output bias-corrected MRI volume.If unspecified, output file
                namewill be auto generated.
                flag: -o %s
        outputMaskedBiasField: (a file name)
                save bias field estimate (masked)
                flag: --maskedbias %s
        splineLambda: (a float)
                spline stiffness weighting parameter
                flag: -w %f
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                display timing information
                flag: --timer
        verbosityLevel: (an integer (int or long))
                verbosity level (0=silent)
                flag: -v %d

Outputs::

        correctionScheduleFile: (a file name)
                path/name of schedule file
        outputBiasField: (a file name)
                path/name of bias field output file
        outputMRIVolume: (a file name)
                path/name of output file
        outputMaskedBiasField: (a file name)
                path/name of masked bias field output

.. _nipype.interfaces.brainsuite.brainsuite.Bse:


.. index:: Bse

Bse
---

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L65>`__

Wraps command **bse**

brain surface extractor (BSE)
This program performs automated skull and scalp removal on T1-weighted MRI volumes.

http://brainsuite.org/processing/surfaceextraction/bse/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> bse = brainsuite.Bse()
>>> bse.inputs.inputMRIFile = example_data('structural.nii')
>>> results = bse.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMRIFile: (a file name)
                input MRI volume
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        diffusionConstant: (a float, nipype default value: 25)
                diffusion constant
                flag: -d %f
        diffusionIterations: (an integer (int or long), nipype default value:
                 3)
                diffusion iterations
                flag: -n %d
        dilateFinalMask: (a boolean, nipype default value: True)
                dilate final mask
                flag: -p
        edgeDetectionConstant: (a float, nipype default value: 0.64)
                edge detection constant
                flag: -s %f
        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
        noRotate: (a boolean)
                retain original orientation(default behavior will auto-rotate input
                NII filesto LPI orientation)
                flag: --norotate
        outputCortexFile: (a file name)
                cortex file
                flag: --cortex %s
        outputDetailedBrainMask: (a file name)
                save detailed brain mask
                flag: --hires %s
        outputDiffusionFilter: (a file name)
                diffusion filter output
                flag: --adf %s
        outputEdgeMap: (a file name)
                edge map output
                flag: --edge %s
        outputMRIVolume: (a file name)
                output brain-masked MRI volume. Ifunspecified, output file name will
                be autogenerated.
                flag: -o %s
        outputMaskFile: (a file name)
                save smooth brain mask
                flag: --mask %s
        radius: (a float, nipype default value: 1)
                radius of erosion/dilation filter
                flag: -r %f
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                show timing
                flag: --timer
        trim: (a boolean, nipype default value: True)
                trim brainstem
                flag: --trim
        verbosityLevel: (a float, nipype default value: 1)
                 verbosity level (0=silent)
                flag: -v %f

Outputs::

        outputCortexFile: (a file name)
                path/name of cortex file
        outputDetailedBrainMask: (a file name)
                path/name of detailed brain mask
        outputDiffusionFilter: (a file name)
                path/name of diffusion filter output
        outputEdgeMap: (a file name)
                path/name of edge map output
        outputMRIVolume: (a file name)
                path/name of brain-masked MRI volume
        outputMaskFile: (a file name)
                path/name of smooth brain mask

.. _nipype.interfaces.brainsuite.brainsuite.Cerebro:


.. index:: Cerebro

Cerebro
-------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L319>`__

Wraps command **cerebro**

Cerebrum/cerebellum labeling tool
This program performs automated labeling of cerebellum and cerebrum in T1 MRI.
Input MRI should be skull-stripped or a brain-only mask should be provided.


http://brainsuite.org/processing/surfaceextraction/cerebrum/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> cerebro = brainsuite.Cerebro()
>>> cerebro.inputs.inputMRIFile = example_data('structural.nii')
>>> cerebro.inputs.inputAtlasMRIFile = 'atlasMRIVolume.img'
>>> cerebro.inputs.inputAtlasLabelFile = 'atlasLabels.img'
>>> cerebro.inputs.inputBrainMaskFile = example_data('mask.nii')
>>> results = cerebro.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputAtlasLabelFile: (a file name)
                atlas labeling
                flag: --atlaslabels %s
        inputAtlasMRIFile: (a file name)
                atlas MRI volume
                flag: --atlas %s
        inputMRIFile: (a file name)
                input 3D MRI volume
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        costFunction: (an integer (int or long), nipype default value: 2)
                0,1,2
                flag: -c %d
        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
        inputBrainMaskFile: (a file name)
                brain mask file
                flag: -m %s
        keepTempFiles: (a boolean)
                don't remove temporary files
                flag: --keep
        linearConvergence: (a float)
                linear convergence
                flag: --linconv %f
        outputAffineTransformFile: (a file name)
                save affine transform to file.
                flag: --air %s
        outputCerebrumMaskFile: (a file name)
                output cerebrum mask volume. If unspecified, output file name will
                be auto generated.
                flag: -o %s
        outputLabelMaskFile: (a file name)
                output labeled hemisphere/cerebrum volume. If unspecified, output
                file name will be auto generated.
                flag: -l %s
        outputWarpTransformFile: (a file name)
                save warp transform to file.
                flag: --warp %s
        tempDirectory: (a string)
                specify directory to use for temporary files
                flag: --tempdir %s
        tempDirectoryBase: (a string)
                create a temporary directory within this directory
                flag: --tempdirbase %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        useCentroids: (a boolean)
                use centroids of data to initialize position
                flag: --centroids
        verbosity: (an integer (int or long))
                verbosity level (0=silent)
                flag: -v %d
        warpConvergence: (a float)
                warp convergence
                flag: --warpconv %f
        warpLabel: (an integer (int or long))
                warp order (2,3,4,5,6,7,8)
                flag: --warplevel %d

Outputs::

        outputAffineTransformFile: (a file name)
                path/name of affine transform file
        outputCerebrumMaskFile: (a file name)
                path/name of cerebrum mask file
        outputLabelMaskFile: (a file name)
                path/name of label mask file
        outputWarpTransformFile: (a file name)
                path/name of warp transform file

.. _nipype.interfaces.brainsuite.brainsuite.Cortex:


.. index:: Cortex

Cortex
------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L383>`__

Wraps command **cortex**

cortex extractor
This program produces a cortical mask using tissue fraction estimates
and a co-registered cerebellum/hemisphere mask.

http://brainsuite.org/processing/surfaceextraction/cortex/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> cortex = brainsuite.Cortex()
>>> cortex.inputs.inputHemisphereLabelFile = example_data('mask.nii')
>>> cortex.inputs.inputTissueFractionFile = example_data('tissues.nii.gz')
>>> results = cortex.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputHemisphereLabelFile: (a file name)
                hemisphere / lobe label volume
                flag: -h %s
        inputTissueFractionFile: (a file name)
                tissue fraction file (32-bit float)
                flag: -f %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        computeGCBoundary: (a boolean)
                compute GM/CSF boundary
                flag: -g
        computeWGBoundary: (a boolean, nipype default value: True)
                compute WM/GM boundary
                flag: -w
        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
        includeAllSubcorticalAreas: (a boolean, nipype default value: True)
                include all subcortical areas in WM mask
                flag: -a
        outputCerebrumMask: (a file name)
                output structure mask. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                timing function
                flag: --timer
        tissueFractionThreshold: (a float, nipype default value: 50.0)
                tissue fraction threshold (percentage)
                flag: -p %f
        verbosity: (an integer (int or long))
                verbosity level
                flag: -v %d

Outputs::

        outputCerebrumMask: (a file name)
                path/name of cerebrum mask

.. _nipype.interfaces.brainsuite.brainsuite.Dewisp:


.. index:: Dewisp

Dewisp
------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L543>`__

Wraps command **dewisp**

dewisp
removes wispy tendril structures from cortex model binary masks.
It does so based on graph theoretic analysis of connected components,
similar to TCA. Each branch of the structure graph is analyzed to determine
pinch points that indicate a likely error in segmentation that attaches noise
to the image. The pinch threshold determines how many voxels the cross-section
can be before it is considered part of the image.

http://brainsuite.org/processing/surfaceextraction/dewisp/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> dewisp = brainsuite.Dewisp()
>>> dewisp.inputs.inputMaskFile = example_data('mask.nii')
>>> results = dewisp.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMaskFile: (a file name)
                input file
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        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
        maximumIterations: (an integer (int or long))
                maximum number of iterations
                flag: -n %d
        outputMaskFile: (a file name)
                output file. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        sizeThreshold: (an integer (int or long))
                size threshold
                flag: -t %d
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                time processing
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity
                flag: -v %d

Outputs::

        outputMaskFile: (a file name)
                path/name of mask file

.. _nipype.interfaces.brainsuite.brainsuite.Dfs:


.. index:: Dfs

Dfs
---

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L618>`__

Wraps command **dfs**

Surface Generator
Generates mesh surfaces using an isosurface algorithm.

http://brainsuite.org/processing/surfaceextraction/inner-cortical-surface/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> dfs = brainsuite.Dfs()
>>> dfs.inputs.inputVolumeFile = example_data('structural.nii')
>>> results = dfs.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputVolumeFile: (a file name)
                input 3D volume
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        curvatureWeighting: (a float, nipype default value: 5.0)
                curvature weighting
                flag: -w %f
        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
        inputShadingVolume: (a file name)
                shade surface model with data from image volume
                flag: -c %s
        noNormalsFlag: (a boolean)
                do not compute vertex normals
                flag: --nonormals
        nonZeroTessellation: (a boolean)
                tessellate non-zero voxels
                flag: -nz
                mutually_exclusive: nonZeroTessellation, specialTessellation
        outputSurfaceFile: (a file name)
                output surface mesh file. If unspecified, output file name will be
                auto generated.
                flag: -o %s
        postSmoothFlag: (a boolean)
                smooth vertices after coloring
                flag: --postsmooth
        scalingPercentile: (a float)
                scaling percentile
                flag: -f %f
        smoothingConstant: (a float, nipype default value: 0.5)
                smoothing constant
                flag: -a %f
        smoothingIterations: (an integer (int or long), nipype default value:
                 10)
                number of smoothing iterations
                flag: -n %d
        specialTessellation: ('greater_than' or 'less_than' or 'equal_to')
                To avoid throwing a UserWarning, set tessellationThreshold first.
                Then set this attribute.
                Usage: tessellate voxels greater_than, less_than, or equal_to
                <tessellationThreshold>
                flag: %s, position: -1
                mutually_exclusive: nonZeroTessellation, specialTessellation
                requires: tessellationThreshold
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        tessellationThreshold: (a float)
                To be used with specialTessellation. Set this value first, then set
                specialTessellation value.
                Usage: tessellate voxels greater_than, less_than, or equal_to
                <tessellationThreshold>
                flag: %f
        timer: (a boolean)
                timing function
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity (0 = quiet)
                flag: -v %d
        zeroPadFlag: (a boolean)
                zero-pad volume (avoids clipping at edges)
                flag: -z

Outputs::

        outputSurfaceFile: (a file name)
                path/name of surface file

.. _nipype.interfaces.brainsuite.brainsuite.Hemisplit:


.. index:: Hemisplit

Hemisplit
---------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L830>`__

Wraps command **hemisplit**

Hemisphere splitter
Splits a surface object into two separate surfaces given an input label volume.
Each vertex is labeled left or right based on the labels being odd (left) or even (right).
The largest contour on the split surface is then found and used as the separation between left and right.

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> hemisplit = brainsuite.Hemisplit()
>>> hemisplit.inputs.inputSurfaceFile = 'input_surf.dfs'
>>> hemisplit.inputs.inputHemisphereLabelFile = 'label.nii'
>>> hemisplit.inputs.pialSurfaceFile = 'pial.dfs'
>>> results = hemisplit.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputHemisphereLabelFile: (a file name)
                input hemisphere label volume
                flag: -l %s
        inputSurfaceFile: (a file name)
                input surface
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        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
        outputLeftHemisphere: (a file name)
                output surface file, left hemisphere. If unspecified, output file
                name will be auto generated.
                flag: --left %s
        outputLeftPialHemisphere: (a file name)
                output pial surface file, left hemisphere. If unspecified, output
                file name will be auto generated.
                flag: -pl %s
        outputRightHemisphere: (a file name)
                output surface file, right hemisphere. If unspecified, output file
                name will be auto generated.
                flag: --right %s
        outputRightPialHemisphere: (a file name)
                output pial surface file, right hemisphere. If unspecified, output
                file name will be auto generated.
                flag: -pr %s
        pialSurfaceFile: (a file name)
                pial surface file -- must have same geometry as input surface
                flag: -p %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                timing function
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity (0 = silent)
                flag: -v %d

Outputs::

        outputLeftHemisphere: (a file name)
                path/name of left hemisphere
        outputLeftPialHemisphere: (a file name)
                path/name of left pial hemisphere
        outputRightHemisphere: (a file name)
                path/name of right hemisphere
        outputRightPialHemisphere: (a file name)
                path/name of right pial hemisphere

.. _nipype.interfaces.brainsuite.brainsuite.Pialmesh:


.. index:: Pialmesh

Pialmesh
--------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L702>`__

Wraps command **pialmesh**

pialmesh
computes a pial surface model using an inner WM/GM mesh and a tissue fraction map.

http://brainsuite.org/processing/surfaceextraction/pial/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> pialmesh = brainsuite.Pialmesh()
>>> pialmesh.inputs.inputSurfaceFile = 'input_mesh.dfs'
>>> pialmesh.inputs.inputTissueFractionFile = 'frac_file.nii.gz'
>>> pialmesh.inputs.inputMaskFile = example_data('mask.nii')
>>> results = pialmesh.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMaskFile: (a file name)
                restrict growth to mask file region
                flag: -m %s
        inputSurfaceFile: (a file name)
                input file
                flag: -i %s
        inputTissueFractionFile: (a file name)
                floating point (32) tissue fraction image
                flag: -f %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        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
        exportPrefix: (a string)
                prefix for exporting surfaces if interval is set
                flag: --prefix %s
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        laplacianSmoothing: (a float, nipype default value: 0.025)
                apply Laplacian smoothing
                flag: --smooth %f
        maxThickness: (a float, nipype default value: 20)
                maximum allowed tissue thickness
                flag: --max %f
        normalSmoother: (a float, nipype default value: 0.2)
                strength of normal smoother.
                flag: --nc %f
        numIterations: (an integer (int or long), nipype default value: 100)
                number of iterations
                flag: -n %d
        outputInterval: (an integer (int or long), nipype default value: 10)
                output interval
                flag: --interval %d
        outputSurfaceFile: (a file name)
                output file. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        recomputeNormals: (a boolean)
                recompute normals at each iteration
                flag: --norm
        searchRadius: (a float, nipype default value: 1)
                search radius
                flag: -r %f
        stepSize: (a float, nipype default value: 0.4)
                step size
                flag: -s %f
        tangentSmoother: (a float)
                strength of tangential smoother.
                flag: --tc %f
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                show timing
                flag: --timer
        tissueThreshold: (a float, nipype default value: 1.05)
                tissue threshold
                flag: -t %f
        verbosity: (an integer (int or long))
                verbosity
                flag: -v %d

Outputs::

        outputSurfaceFile: (a file name)
                path/name of surface file

.. _nipype.interfaces.brainsuite.brainsuite.Pvc:


.. index:: Pvc

Pvc
---

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L240>`__

Wraps command **pvc**

partial volume classifier (PVC) tool.
This program performs voxel-wise tissue classification T1-weighted MRI.
Image should be skull-stripped and bias-corrected before tissue classification.

http://brainsuite.org/processing/surfaceextraction/pvc/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> pvc = brainsuite.Pvc()
>>> pvc.inputs.inputMRIFile = example_data('structural.nii')
>>> pvc.inputs.inputMaskFile = example_data('mask.nii')
>>> results = pvc.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMRIFile: (a file name)
                MRI file
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        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
        inputMaskFile: (a file name)
                brain mask file
                flag: -m %s
        outputLabelFile: (a file name)
                output label file. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        outputTissueFractionFile: (a file name)
                output tissue fraction file
                flag: -f %s
        spatialPrior: (a float)
                spatial prior strength
                flag: -l %f
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        threeClassFlag: (a boolean)
                use a three-class (CSF=0,GM=1,WM=2) labeling
                flag: -3
        timer: (a boolean)
                time processing
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity level (0 = silent)
                flag: -v %d

Outputs::

        outputLabelFile: (a file name)
                path/name of label file
        outputTissueFractionFile: (a file name)
                path/name of tissue fraction file

.. _nipype.interfaces.brainsuite.brainsuite.Scrubmask:


.. index:: Scrubmask

Scrubmask
---------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L438>`__

Wraps command **scrubmask**

ScrubMask tool
scrubmask filters binary masks to trim loosely connected voxels that may
result from segmentation errors and produce bumps on tessellated surfaces.

http://brainsuite.org/processing/surfaceextraction/scrubmask/

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> scrubmask = brainsuite.Scrubmask()
>>> scrubmask.inputs.inputMaskFile = example_data('mask.nii')
>>> results = scrubmask.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMaskFile: (a file name)
                input structure mask file
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        backgroundFillThreshold: (an integer (int or long), nipype default
                 value: 2)
                background fill threshold
                flag: -b %d
        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
        foregroundTrimThreshold: (an integer (int or long), nipype default
                 value: 0)
                foreground trim threshold
                flag: -f %d
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        numberIterations: (an integer (int or long))
                number of iterations
                flag: -n %d
        outputMaskFile: (a file name)
                output structure mask file. If unspecified, output file name will be
                auto generated.
                flag: -o %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                timing function
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity (0=silent)
                flag: -v %d

Outputs::

        outputMaskFile: (a file name)
                path/name of mask file

.. _nipype.interfaces.brainsuite.brainsuite.Skullfinder:


.. index:: Skullfinder

Skullfinder
-----------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L771>`__

Wraps command **skullfinder**

Skull and scalp segmentation algorithm.

Examples
~~~~~~~~

>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> skullfinder = brainsuite.Skullfinder()
>>> skullfinder.inputs.inputMRIFile = example_data('structural.nii')
>>> skullfinder.inputs.inputMaskFile = example_data('mask.nii')
>>> results = skullfinder.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMRIFile: (a file name)
                input file
                flag: -i %s
        inputMaskFile: (a file name)
                A brain mask file, 8-bit image (0=non-brain, 255=brain)
                flag: -m %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        bgLabelValue: (an integer (int or long))
                background label value (0-255)
                flag: --bglabel %d
        brainLabelValue: (an integer (int or long))
                brain label value (0-255)
                flag: --brainlabel %d
        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
        lowerThreshold: (an integer (int or long))
                Lower threshold for segmentation
                flag: -l %d
        outputLabelFile: (a file name)
                output file. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        performFinalOpening: (a boolean)
                perform a final opening operation on the scalp mask
                flag: --finalOpening
        scalpLabelValue: (an integer (int or long))
                scalp label value (0-255)
                flag: --scalplabel %d
        skullLabelValue: (an integer (int or long))
                skull label value (0-255)
                flag: --skulllabel %d
        spaceLabelValue: (an integer (int or long))
                space label value (0-255)
                flag: --spacelabel %d
        surfaceFilePrefix: (a string)
                if specified, generate surface files for brain, skull, and scalp
                flag: -s %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        upperThreshold: (an integer (int or long))
                Upper threshold for segmentation
                flag: -u %d
        verbosity: (an integer (int or long))
                verbosity
                flag: -v %d

Outputs::

        outputLabelFile: (a file name)
                path/name of label file

.. _nipype.interfaces.brainsuite.brainsuite.Tca:


.. index:: Tca

Tca
---

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L494>`__

Wraps command **tca**

topological correction algorithm (TCA)
This program removes topological handles from a binary object.

http://brainsuite.org/processing/surfaceextraction/tca/

Examples
~~~~~~~~
>>> from nipype.interfaces import brainsuite
>>> from nipype.testing import example_data
>>> tca = brainsuite.Tca()
>>> tca.inputs.inputMaskFile = example_data('mask.nii')
>>> results = tca.run() #doctest: +SKIP

Inputs::

        [Mandatory]
        inputMaskFile: (a file name)
                input mask volume
                flag: -i %s

        [Optional]
        args: (a string)
                Additional parameters to the command
                flag: %s
        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
        foregroundDelta: (an integer (int or long), nipype default value: 20)
                foreground delta
                flag: --delta %d
        ignore_exception: (a boolean, nipype default value: False)
                Print an error message instead of throwing an exception in case the
                interface fails to run
        maxCorrectionSize: (an integer (int or long))
                minimum correction size
                flag: -n %d
        minCorrectionSize: (an integer (int or long), nipype default value:
                 2500)
                maximum correction size
                flag: -m %d
        outputMaskFile: (a file name)
                output mask volume. If unspecified, output file name will be auto
                generated.
                flag: -o %s
        terminal_output: ('stream' or 'allatonce' or 'file' or 'none')
                Control terminal output: `stream` - displays to terminal immediately
                (default), `allatonce` - waits till command is finished to display
                output, `file` - writes output to file, `none` - output is ignored
        timer: (a boolean)
                timing function
                flag: --timer
        verbosity: (an integer (int or long))
                verbosity (0 = quiet)
                flag: -v %d

Outputs::

        outputMaskFile: (a file name)
                path/name of mask file

.. module:: nipype.interfaces.brainsuite.brainsuite


.. _nipype.interfaces.brainsuite.brainsuite.getFileName:

:func:`getFileName`
-------------------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L874>`__






.. _nipype.interfaces.brainsuite.brainsuite.l_outputs:

:func:`l_outputs`
-----------------

`Link to code <file:///build/nipype-0.12.1+git4-gbc3a0b5/nipype/interfaces/brainsuite/brainsuite.py#L881>`__





