
\begin{DoxyItemize}
\item \hyperlink{vtkvolumerendering_vtkdirectionencoder}{vtk\-Direction\-Encoder}  
\item \hyperlink{vtkvolumerendering_vtkencodedgradientestimator}{vtk\-Encoded\-Gradient\-Estimator}  
\item \hyperlink{vtkvolumerendering_vtkencodedgradientshader}{vtk\-Encoded\-Gradient\-Shader}  
\item \hyperlink{vtkvolumerendering_vtkfinitedifferencegradientestimator}{vtk\-Finite\-Difference\-Gradient\-Estimator}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointraycastimage}{vtk\-Fixed\-Point\-Ray\-Cast\-Image}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegohelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegoshadehelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastcompositehelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastcompositeshadehelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycasthelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastmapper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkfixedpointvolumeraycastmiphelper}{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkgpuvolumeraycastmapper}{vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkhavsvolumemapper}{vtk\-H\-A\-V\-S\-Volume\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkopenglgpuvolumeraycastmapper}{vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkopenglhavsvolumemapper}{vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkopenglraycastimagedisplayhelper}{vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkopenglvolumetexturemapper2d}{vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D}  
\item \hyperlink{vtkvolumerendering_vtkopenglvolumetexturemapper3d}{vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D}  
\item \hyperlink{vtkvolumerendering_vtkprojectedtetrahedramapper}{vtk\-Projected\-Tetrahedra\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkraycastimagedisplayhelper}{vtk\-Ray\-Cast\-Image\-Display\-Helper}  
\item \hyperlink{vtkvolumerendering_vtkrecursivespheredirectionencoder}{vtk\-Recursive\-Sphere\-Direction\-Encoder}  
\item \hyperlink{vtkvolumerendering_vtksphericaldirectionencoder}{vtk\-Spherical\-Direction\-Encoder}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridbunykraycastfunction}{vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridhomogeneousrayintegrator}{vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridlinearrayintegrator}{vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridpartialpreintegration}{vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridpreintegration}{vtk\-Unstructured\-Grid\-Pre\-Integration}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumemapper}{vtk\-Unstructured\-Grid\-Volume\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumeraycastfunction}{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumeraycastiterator}{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumeraycastmapper}{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumerayintegrator}{vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator}  
\item \hyperlink{vtkvolumerendering_vtkunstructuredgridvolumezsweepmapper}{vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkvolumemapper}{vtk\-Volume\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkvolumeoutlinesource}{vtk\-Volume\-Outline\-Source}  
\item \hyperlink{vtkvolumerendering_vtkvolumepicker}{vtk\-Volume\-Picker}  
\item \hyperlink{vtkvolumerendering_vtkvolumepromapper}{vtk\-Volume\-Pro\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkvolumeraycastcompositefunction}{vtk\-Volume\-Ray\-Cast\-Composite\-Function}  
\item \hyperlink{vtkvolumerendering_vtkvolumeraycastfunction}{vtk\-Volume\-Ray\-Cast\-Function}  
\item \hyperlink{vtkvolumerendering_vtkvolumeraycastisosurfacefunction}{vtk\-Volume\-Ray\-Cast\-Isosurface\-Function}  
\item \hyperlink{vtkvolumerendering_vtkvolumeraycastmapper}{vtk\-Volume\-Ray\-Cast\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkvolumeraycastmipfunction}{vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function}  
\item \hyperlink{vtkvolumerendering_vtkvolumerenderingfactory}{vtk\-Volume\-Rendering\-Factory}  
\item \hyperlink{vtkvolumerendering_vtkvolumetexturemapper}{vtk\-Volume\-Texture\-Mapper}  
\item \hyperlink{vtkvolumerendering_vtkvolumetexturemapper2d}{vtk\-Volume\-Texture\-Mapper2\-D}  
\item \hyperlink{vtkvolumerendering_vtkvolumetexturemapper3d}{vtk\-Volume\-Texture\-Mapper3\-D}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkdirectionencoder}{}\section{vtk\-Direction\-Encoder}\label{vtkvolumerendering_vtkdirectionencoder}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Given a direction, encode it into an integer value. This value should be less than 65536, which is the maximum number of encoded directions supported by this superclass. A direction encoded is used to encode normals in a volume for use during volume rendering, and the amount of space that is allocated per normal is 2 bytes. This is an abstract superclass -\/ see the subclasses for specific implementation details.

To create an instance of class vtk\-Direction\-Encoder, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDirectionEncoder
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Direction\-Encoder has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Direction\-Encoder class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Get the name of this class  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Get the name of this class  
\item {\ttfamily vtk\-Direction\-Encoder = obj.\-New\-Instance ()} -\/ Get the name of this class  
\item {\ttfamily vtk\-Direction\-Encoder = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Get the name of this class  
\item {\ttfamily int = obj.\-Get\-Encoded\-Direction (float n\mbox{[}3\mbox{]})} -\/ Given a normal vector n, return the encoded direction  
\item {\ttfamily float = obj.\-Get\-Decoded\-Gradient (int value)} -\/ / Given an encoded value, return a pointer to the normal vector  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Encoded\-Directions (void )} -\/ Return the number of encoded directions  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkencodedgradientestimator}{}\section{vtk\-Encoded\-Gradient\-Estimator}\label{vtkvolumerendering_vtkencodedgradientestimator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Encoded\-Gradient\-Estimator is an abstract superclass for gradient estimation. It takes a scalar input of vtk\-Image\-Data, computes a gradient value for every point, and encodes this value into a three byte value (2 for direction, 1 for magnitude) using the vtk\-Direction\-Encoder. The direction encoder is defaulted to a vtk\-Recursive\-Sphere\-Direction\-Encoder, but can be overridden with the Set\-Direction\-Encoder method. The scale and the bias values for the gradient magnitude are used to convert it into a one byte value according to v = m$\ast$scale + bias where m is the magnitude and v is the resulting one byte value.

To create an instance of class vtk\-Encoded\-Gradient\-Estimator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEncodedGradientEstimator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Encoded\-Gradient\-Estimator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Encoded\-Gradient\-Estimator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Encoded\-Gradient\-Estimator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Encoded\-Gradient\-Estimator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data )} -\/ Set/\-Get the scalar input for which the normals will be calculated  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the scalar input for which the normals will be calculated  
\item {\ttfamily obj.\-Set\-Gradient\-Magnitude\-Scale (float )} -\/ Set/\-Get the scale and bias for the gradient magnitude  
\item {\ttfamily float = obj.\-Get\-Gradient\-Magnitude\-Scale ()} -\/ Set/\-Get the scale and bias for the gradient magnitude  
\item {\ttfamily obj.\-Set\-Gradient\-Magnitude\-Bias (float )} -\/ Set/\-Get the scale and bias for the gradient magnitude  
\item {\ttfamily float = obj.\-Get\-Gradient\-Magnitude\-Bias ()} -\/ Set/\-Get the scale and bias for the gradient magnitude  
\item {\ttfamily obj.\-Set\-Bounds\-Clip (int )} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily int = obj.\-Get\-Bounds\-Clip\-Min\-Value ()} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily int = obj.\-Get\-Bounds\-Clip\-Max\-Value ()} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily int = obj.\-Get\-Bounds\-Clip ()} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily obj.\-Bounds\-Clip\-On ()} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily obj.\-Bounds\-Clip\-Off ()} -\/ Turn on / off the bounding of the normal computation by the this-\/$>$Bounds bounding box  
\item {\ttfamily obj.\-Set\-Bounds (int , int , int , int , int , int )} -\/ Set / Get the bounds of the computation (used if this-\/$>$Computation\-Bounds is 1.) The bounds are specified xmin, xmax, ymin, ymax, zmin, zmax.  
\item {\ttfamily obj.\-Set\-Bounds (int a\mbox{[}6\mbox{]})} -\/ Set / Get the bounds of the computation (used if this-\/$>$Computation\-Bounds is 1.) The bounds are specified xmin, xmax, ymin, ymax, zmin, zmax.  
\item {\ttfamily int = obj. Get\-Bounds ()} -\/ Set / Get the bounds of the computation (used if this-\/$>$Computation\-Bounds is 1.) The bounds are specified xmin, xmax, ymin, ymax, zmin, zmax.  
\item {\ttfamily obj.\-Update (void )} -\/ Recompute the encoded normals and gradient magnitudes.  
\item {\ttfamily int = obj.\-Get\-Encoded\-Normal\-Index (int xyz\-\_\-index)} -\/ Get the encoded normal at an x,y,z location in the volume  
\item {\ttfamily int = obj.\-Get\-Encoded\-Normal\-Index (int x\-\_\-index, int y\-\_\-index, int z\-\_\-index)} -\/ Get the encoded normal at an x,y,z location in the volume  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int )} -\/ Get/\-Set the number of threads to create when encoding normals This defaults to the number of available processors on the machine  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Min\-Value ()} -\/ Get/\-Set the number of threads to create when encoding normals This defaults to the number of available processors on the machine  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Max\-Value ()} -\/ Get/\-Set the number of threads to create when encoding normals This defaults to the number of available processors on the machine  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Get/\-Set the number of threads to create when encoding normals This defaults to the number of available processors on the machine  
\item {\ttfamily obj.\-Set\-Direction\-Encoder (vtk\-Direction\-Encoder direnc)} -\/ Set / Get the direction encoder used to encode normal directions to fit within two bytes  
\item {\ttfamily vtk\-Direction\-Encoder = obj.\-Get\-Direction\-Encoder ()} -\/ Set / Get the direction encoder used to encode normal directions to fit within two bytes  
\item {\ttfamily obj.\-Set\-Compute\-Gradient\-Magnitudes (int )} -\/ If you don't want to compute gradient magnitudes (but you do want normals for shading) this can be used. Be careful -\/ if if you a non-\/constant gradient magnitude transfer function and you turn this on, it may crash  
\item {\ttfamily int = obj.\-Get\-Compute\-Gradient\-Magnitudes ()} -\/ If you don't want to compute gradient magnitudes (but you do want normals for shading) this can be used. Be careful -\/ if if you a non-\/constant gradient magnitude transfer function and you turn this on, it may crash  
\item {\ttfamily obj.\-Compute\-Gradient\-Magnitudes\-On ()} -\/ If you don't want to compute gradient magnitudes (but you do want normals for shading) this can be used. Be careful -\/ if if you a non-\/constant gradient magnitude transfer function and you turn this on, it may crash  
\item {\ttfamily obj.\-Compute\-Gradient\-Magnitudes\-Off ()} -\/ If you don't want to compute gradient magnitudes (but you do want normals for shading) this can be used. Be careful -\/ if if you a non-\/constant gradient magnitude transfer function and you turn this on, it may crash  
\item {\ttfamily obj.\-Set\-Cylinder\-Clip (int )} -\/ If the data in each slice is only contained within a circle circumscribed within the slice, and the slice is square, then don't compute anything outside the circle. This circle through the slices forms a cylinder.  
\item {\ttfamily int = obj.\-Get\-Cylinder\-Clip ()} -\/ If the data in each slice is only contained within a circle circumscribed within the slice, and the slice is square, then don't compute anything outside the circle. This circle through the slices forms a cylinder.  
\item {\ttfamily obj.\-Cylinder\-Clip\-On ()} -\/ If the data in each slice is only contained within a circle circumscribed within the slice, and the slice is square, then don't compute anything outside the circle. This circle through the slices forms a cylinder.  
\item {\ttfamily obj.\-Cylinder\-Clip\-Off ()} -\/ If the data in each slice is only contained within a circle circumscribed within the slice, and the slice is square, then don't compute anything outside the circle. This circle through the slices forms a cylinder.  
\item {\ttfamily float = obj.\-Get\-Last\-Update\-Time\-In\-Seconds ()} -\/ Get the time required for the last update in seconds or cpu seconds  
\item {\ttfamily float = obj.\-Get\-Last\-Update\-Time\-In\-C\-P\-U\-Seconds ()} -\/ Get the time required for the last update in seconds or cpu seconds  
\item {\ttfamily int = obj.\-Get\-Use\-Cylinder\-Clip ()}  
\item {\ttfamily obj.\-Set\-Zero\-Normal\-Threshold (float v)} -\/ Set / Get the Zero\-Normal\-Threshold -\/ this defines the minimum magnitude of a gradient that is considered sufficient to define a direction. Gradients with magnitudes at or less than this value are given a \char`\"{}zero normal\char`\"{} index. These are handled specially in the shader, and you can set the intensity of light for these zero normals in the gradient shader.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Threshold ()} -\/ Set / Get the Zero\-Normal\-Threshold -\/ this defines the minimum magnitude of a gradient that is considered sufficient to define a direction. Gradients with magnitudes at or less than this value are given a \char`\"{}zero normal\char`\"{} index. These are handled specially in the shader, and you can set the intensity of light for these zero normals in the gradient shader.  
\item {\ttfamily obj.\-Set\-Zero\-Pad (int )} -\/ Assume that the data value outside the volume is zero when computing normals.  
\item {\ttfamily int = obj.\-Get\-Zero\-Pad\-Min\-Value ()} -\/ Assume that the data value outside the volume is zero when computing normals.  
\item {\ttfamily int = obj.\-Get\-Zero\-Pad\-Max\-Value ()} -\/ Assume that the data value outside the volume is zero when computing normals.  
\item {\ttfamily int = obj.\-Get\-Zero\-Pad ()} -\/ Assume that the data value outside the volume is zero when computing normals.  
\item {\ttfamily obj.\-Zero\-Pad\-On ()} -\/ Assume that the data value outside the volume is zero when computing normals.  
\item {\ttfamily obj.\-Zero\-Pad\-Off ()} -\/ Assume that the data value outside the volume is zero when computing normals.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkencodedgradientshader}{}\section{vtk\-Encoded\-Gradient\-Shader}\label{vtkvolumerendering_vtkencodedgradientshader}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Encoded\-Gradient\-Shader computes shading tables for encoded normals that indicates the amount of diffuse and specular illumination that is received from all light sources at a surface location with that normal. For diffuse illumination this is accurate, but for specular illumination it is approximate for perspective projections since the center view direction is always used as the view direction. Since the shading table is dependent on the volume (for the transformation that must be applied to the normals to put them into world coordinates) there is a shading table per volume. This is necessary because multiple volumes can share a volume mapper.

To create an instance of class vtk\-Encoded\-Gradient\-Shader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEncodedGradientShader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Encoded\-Gradient\-Shader has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Encoded\-Gradient\-Shader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Encoded\-Gradient\-Shader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Encoded\-Gradient\-Shader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Zero\-Normal\-Diffuse\-Intensity (float )} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Diffuse\-Intensity\-Min\-Value ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Diffuse\-Intensity\-Max\-Value ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Diffuse\-Intensity ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily obj.\-Set\-Zero\-Normal\-Specular\-Intensity (float )} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Specular\-Intensity\-Min\-Value ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Specular\-Intensity\-Max\-Value ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily float = obj.\-Get\-Zero\-Normal\-Specular\-Intensity ()} -\/ Set / Get the intensity diffuse / specular light used for the zero normals.  
\item {\ttfamily obj.\-Update\-Shading\-Table (vtk\-Renderer ren, vtk\-Volume vol, vtk\-Encoded\-Gradient\-Estimator gradest)} -\/ Cause the shading table to be updated  
\item {\ttfamily obj.\-Set\-Active\-Component (int )} -\/ Set the active component for shading. This component's ambient / diffuse / specular / specular power values will be used to create the shading table. The default is 1.\-0  
\item {\ttfamily int = obj.\-Get\-Active\-Component\-Min\-Value ()} -\/ Set the active component for shading. This component's ambient / diffuse / specular / specular power values will be used to create the shading table. The default is 1.\-0  
\item {\ttfamily int = obj.\-Get\-Active\-Component\-Max\-Value ()} -\/ Set the active component for shading. This component's ambient / diffuse / specular / specular power values will be used to create the shading table. The default is 1.\-0  
\item {\ttfamily int = obj.\-Get\-Active\-Component ()} -\/ Set the active component for shading. This component's ambient / diffuse / specular / specular power values will be used to create the shading table. The default is 1.\-0  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfinitedifferencegradientestimator}{}\section{vtk\-Finite\-Difference\-Gradient\-Estimator}\label{vtkvolumerendering_vtkfinitedifferencegradientestimator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Finite\-Difference\-Gradient\-Estimator is a concrete subclass of vtk\-Encoded\-Gradient\-Estimator that uses a central differences technique to estimate the gradient. The gradient at some sample location (x,y,z) would be estimated by\-: \begin{DoxyVerb} nx = (f(x-dx,y,z) - f(x+dx,y,z)) / 2*dx;
 ny = (f(x,y-dy,z) - f(x,y+dy,z)) / 2*dy;
 nz = (f(x,y,z-dz) - f(x,y,z+dz)) / 2*dz;
\end{DoxyVerb}


This value is normalized to determine a unit direction vector and a magnitude. The normal is computed in voxel space, and dx = dy = dz = Sample\-Spacing\-In\-Voxels. A scaling factor is applied to convert this normal from voxel space to world coordinates.

To create an instance of class vtk\-Finite\-Difference\-Gradient\-Estimator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFiniteDifferenceGradientEstimator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Finite\-Difference\-Gradient\-Estimator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Finite\-Difference\-Gradient\-Estimator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Finite\-Difference\-Gradient\-Estimator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Finite\-Difference\-Gradient\-Estimator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Sample\-Spacing\-In\-Voxels (int )} -\/ Set/\-Get the spacing between samples for the finite differences method used to compute the normal. This spacing is in voxel units.  
\item {\ttfamily int = obj.\-Get\-Sample\-Spacing\-In\-Voxels ()} -\/ Set/\-Get the spacing between samples for the finite differences method used to compute the normal. This spacing is in voxel units.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointraycastimage}{}\section{vtk\-Fixed\-Point\-Ray\-Cast\-Image}\label{vtkvolumerendering_vtkfixedpointraycastimage}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a helper class for storing the ray cast image including the underlying data and the size of the image. This class is not intended to be used directly -\/ just as an internal class in the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper so that multiple mappers can share the same image. This class also stored the Z\-Buffer (if necessary due to intermixed geometry). Perhaps this class could be generalized in the future to be used for other ray cast methods other than the fixed point method.

To create an instance of class vtk\-Fixed\-Point\-Ray\-Cast\-Image, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointRayCastImage
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Ray\-Cast\-Image has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Ray\-Cast\-Image class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Ray\-Cast\-Image = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Ray\-Cast\-Image = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Image\-Viewport\-Size (int , int )} -\/ Set / Get the Image\-Viewport\-Size. This is the size of the whole viewport in pixels.  
\item {\ttfamily obj.\-Set\-Image\-Viewport\-Size (int a\mbox{[}2\mbox{]})} -\/ Set / Get the Image\-Viewport\-Size. This is the size of the whole viewport in pixels.  
\item {\ttfamily int = obj. Get\-Image\-Viewport\-Size ()} -\/ Set / Get the Image\-Viewport\-Size. This is the size of the whole viewport in pixels.  
\item {\ttfamily obj.\-Set\-Image\-Memory\-Size (int , int )} -\/ Set / Get the Image\-Memory\-Size. This is the size in pixels of the Image ivar. This will be a power of two in order to ensure that the texture can be rendered by graphics hardware that requires power of two textures.  
\item {\ttfamily obj.\-Set\-Image\-Memory\-Size (int a\mbox{[}2\mbox{]})} -\/ Set / Get the Image\-Memory\-Size. This is the size in pixels of the Image ivar. This will be a power of two in order to ensure that the texture can be rendered by graphics hardware that requires power of two textures.  
\item {\ttfamily int = obj. Get\-Image\-Memory\-Size ()} -\/ Set / Get the Image\-Memory\-Size. This is the size in pixels of the Image ivar. This will be a power of two in order to ensure that the texture can be rendered by graphics hardware that requires power of two textures.  
\item {\ttfamily obj.\-Set\-Image\-In\-Use\-Size (int , int )} -\/ Set / Get the size of the image we are actually using. As long as the memory size is big enough, but not too big, we won't bother deleting and re-\/allocated, we'll just continue to use the memory size we have. This size will always be equal to or less than the Image\-Memory\-Size.  
\item {\ttfamily obj.\-Set\-Image\-In\-Use\-Size (int a\mbox{[}2\mbox{]})} -\/ Set / Get the size of the image we are actually using. As long as the memory size is big enough, but not too big, we won't bother deleting and re-\/allocated, we'll just continue to use the memory size we have. This size will always be equal to or less than the Image\-Memory\-Size.  
\item {\ttfamily int = obj. Get\-Image\-In\-Use\-Size ()} -\/ Set / Get the size of the image we are actually using. As long as the memory size is big enough, but not too big, we won't bother deleting and re-\/allocated, we'll just continue to use the memory size we have. This size will always be equal to or less than the Image\-Memory\-Size.  
\item {\ttfamily obj.\-Set\-Image\-Origin (int , int )} -\/ Set / Get the origin of the image. This is the starting pixel within the whole viewport that our Image starts on. That is, we could be generating just a subregion of the whole viewport due to the fact that our volume occupies only a portion of the viewport. The Image pixels will start from this location.  
\item {\ttfamily obj.\-Set\-Image\-Origin (int a\mbox{[}2\mbox{]})} -\/ Set / Get the origin of the image. This is the starting pixel within the whole viewport that our Image starts on. That is, we could be generating just a subregion of the whole viewport due to the fact that our volume occupies only a portion of the viewport. The Image pixels will start from this location.  
\item {\ttfamily int = obj. Get\-Image\-Origin ()} -\/ Set / Get the origin of the image. This is the starting pixel within the whole viewport that our Image starts on. That is, we could be generating just a subregion of the whole viewport due to the fact that our volume occupies only a portion of the viewport. The Image pixels will start from this location.  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (float )} -\/ Set / Get the Image\-Sample\-Distance that will be used for rendering. This is a copy of the value stored in the mapper. It is stored here for sharing between all mappers that are participating in the creation of this image.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Set / Get the Image\-Sample\-Distance that will be used for rendering. This is a copy of the value stored in the mapper. It is stored here for sharing between all mappers that are participating in the creation of this image.  
\item {\ttfamily obj.\-Allocate\-Image ()} -\/ Call this method once the Image\-Memory\-Size has been set the allocate the image. If an image already exists, it will be deleted first.  
\item {\ttfamily obj.\-Clear\-Image ()} -\/ Clear the image to (0,0,0,0) for each pixel.  
\item {\ttfamily obj.\-Set\-Z\-Buffer\-Size (int , int )} -\/ Set / Get the size of the Z\-Buffer in pixels. The zbuffer will be captured for the region of the screen covered by the Image\-In\-Use\-Size image. However, due to subsampling, the size of the Image\-In\-Use\-Size image may be smaller than this Z\-Buffer image which will be captured at screen resolution.  
\item {\ttfamily obj.\-Set\-Z\-Buffer\-Size (int a\mbox{[}2\mbox{]})} -\/ Set / Get the size of the Z\-Buffer in pixels. The zbuffer will be captured for the region of the screen covered by the Image\-In\-Use\-Size image. However, due to subsampling, the size of the Image\-In\-Use\-Size image may be smaller than this Z\-Buffer image which will be captured at screen resolution.  
\item {\ttfamily int = obj. Get\-Z\-Buffer\-Size ()} -\/ Set / Get the size of the Z\-Buffer in pixels. The zbuffer will be captured for the region of the screen covered by the Image\-In\-Use\-Size image. However, due to subsampling, the size of the Image\-In\-Use\-Size image may be smaller than this Z\-Buffer image which will be captured at screen resolution.  
\item {\ttfamily obj.\-Set\-Z\-Buffer\-Origin (int , int )} -\/ Set / Get the origin of the Z\-Buffer. This is the distance from the lower left corner of the viewport where the Z\-Buffer started (multiply the Image\-Origin by the Image\-Sample\-Distance) This is the pixel location on the full resolution viewport where the Z\-Buffer capture will start. These values are used to convert the (x,y) pixel location within the Image\-In\-Use\-Size image into a Z\-Buffer location.  
\item {\ttfamily obj.\-Set\-Z\-Buffer\-Origin (int a\mbox{[}2\mbox{]})} -\/ Set / Get the origin of the Z\-Buffer. This is the distance from the lower left corner of the viewport where the Z\-Buffer started (multiply the Image\-Origin by the Image\-Sample\-Distance) This is the pixel location on the full resolution viewport where the Z\-Buffer capture will start. These values are used to convert the (x,y) pixel location within the Image\-In\-Use\-Size image into a Z\-Buffer location.  
\item {\ttfamily int = obj. Get\-Z\-Buffer\-Origin ()} -\/ Set / Get the origin of the Z\-Buffer. This is the distance from the lower left corner of the viewport where the Z\-Buffer started (multiply the Image\-Origin by the Image\-Sample\-Distance) This is the pixel location on the full resolution viewport where the Z\-Buffer capture will start. These values are used to convert the (x,y) pixel location within the Image\-In\-Use\-Size image into a Z\-Buffer location.  
\item {\ttfamily obj.\-Set\-Use\-Z\-Buffer (int )} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily int = obj.\-Get\-Use\-Z\-Buffer\-Min\-Value ()} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily int = obj.\-Get\-Use\-Z\-Buffer\-Max\-Value ()} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily int = obj.\-Get\-Use\-Z\-Buffer ()} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily obj.\-Use\-Z\-Buffer\-On ()} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily obj.\-Use\-Z\-Buffer\-Off ()} -\/ The Use\-Z\-Buffer flag indicates whether the Z\-Buffer is in use. The Z\-Buffer is captured and used when Intermix\-Intersecting\-Geometry is on in the mapper, and when there are props that have been rendered before the current volume.  
\item {\ttfamily float = obj.\-Get\-Z\-Buffer\-Value (int x, int y)} -\/ Get the Z\-Buffer value corresponding to location (x,y) where (x,y) are indexing into the Image\-In\-Use image. This must be converted to the zbuffer image coordinates. Nearest neighbor value is returned. If Use\-Z\-Buffer is off, then 1.\-0 is always returned.  
\item {\ttfamily obj.\-Allocate\-Z\-Buffer ()}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegohelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegohelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is one of the helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. It will generate composite images using an alpha blending operation. This class should not be used directly, it is a helper class for the mapper and has no user-\/level A\-P\-I.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastCompositeGOHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int thread\-I\-D, int thread\-Count, vtk\-Volume vol, vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper mapper)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegoshadehelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastcompositegoshadehelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is one of the helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. It will generate composite images using an alpha blending operation. This class should not be used directly, it is a helper class for the mapper and has no user-\/level A\-P\-I.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastCompositeGOShadeHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int thread\-I\-D, int thread\-Count, vtk\-Volume vol, vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper mapper)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastcompositehelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastcompositehelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is one of the helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. It will generate composite images using an alpha blending operation. This class should not be used directly, it is a helper class for the mapper and has no user-\/level A\-P\-I.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastCompositeHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int thread\-I\-D, int thread\-Count, vtk\-Volume vol, vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper mapper)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastcompositeshadehelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastcompositeshadehelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is one of the helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. It will generate composite images using an alpha blending operation. This class should not be used directly, it is a helper class for the mapper and has no user-\/level A\-P\-I.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastCompositeShadeHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int thread\-I\-D, int thread\-Count, vtk\-Volume vol, vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper mapper)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycasthelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycasthelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is the abstract superclass of all helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. This class should not be used directly.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int , int , vtk\-Volume , vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper )}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastmapper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a software ray caster for rendering volumes in vtk\-Image\-Data. It works with all input data types and up to four components. It performs composite or M\-I\-P rendering, and can be intermixed with geometric data. Space leaping is used to speed up the rendering process. In addition, calculation are performed in 15 bit fixed point precision. This mapper is threaded, and will interleave scan lines across processors.

This mapper is a good replacement for vtk\-Volume\-Ray\-Cast\-Mapper E\-X\-C\-E\-P\-T\-:
\begin{DoxyItemize}
\item it does not do isosurface ray casting
\item it does only interpolate before classify compositing
\item it does only maximum scalar value M\-I\-P
\end{DoxyItemize}

The vtk\-Volume\-Ray\-Cast\-Mapper C\-A\-N\-N\-O\-T be used in these instances when a vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper can be used\-:
\begin{DoxyItemize}
\item if the data is not unsigned char or unsigned short
\item if the data has more than one component
\end{DoxyItemize}

This mapper handles all data type from unsigned char through double. However, some of the internal calcultions are performed in float and therefore even the full float range may cause problems for this mapper (both in scalar data values and in spacing between samples).

Space leaping is performed by creating a sub-\/sampled volume. 4x4x4 cells in the original volume are represented by a min, max, and combined gradient and flag value. The min max volume has three unsigned shorts per 4x4x4 group of cells from the original volume -\/ one reprenting the minumum scalar index (the scalar value adjusted to fit in the 15 bit range), the maximum scalar index, and a third unsigned short which is both the maximum gradient opacity in the neighborhood (an unsigned char) and the flag that is filled in for the current lookup tables to indicate whether this region can be skipped.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Sample\-Distance (float )} -\/ Set/\-Get the distance between samples used for rendering when Auto\-Adjust\-Sample\-Distances is off, or when this mapper has more than 1 second allocated to it for rendering.  
\item {\ttfamily float = obj.\-Get\-Sample\-Distance ()} -\/ Set/\-Get the distance between samples used for rendering when Auto\-Adjust\-Sample\-Distances is off, or when this mapper has more than 1 second allocated to it for rendering.  
\item {\ttfamily obj.\-Set\-Interactive\-Sample\-Distance (float )} -\/ Set/\-Get the distance between samples when interactive rendering is happening. In this case, interactive is defined as this volume mapper having less than 1 second allocated for rendering. When Auto\-Adjust\-Sample\-Distance is On, and the allocated render time is less than 1 second, then this Interactive\-Sample\-Distance will be used instead of the Sample\-Distance above.  
\item {\ttfamily float = obj.\-Get\-Interactive\-Sample\-Distance ()} -\/ Set/\-Get the distance between samples when interactive rendering is happening. In this case, interactive is defined as this volume mapper having less than 1 second allocated for rendering. When Auto\-Adjust\-Sample\-Distance is On, and the allocated render time is less than 1 second, then this Interactive\-Sample\-Distance will be used instead of the Sample\-Distance above.  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (float )} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Min\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Max\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily obj.\-Set\-Minimum\-Image\-Sample\-Distance (float )} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily obj.\-Set\-Maximum\-Image\-Sample\-Distance (float )} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Sample\-Distances (int )} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Min\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Max\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-On ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-Off ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance and the Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use). If this is an interactive render (more than 1 frame per second) the Sample\-Distance will be increased, otherwise it will not be altered (a binary decision, as opposed to the Image\-Sample\-Distance which will vary continuously).  
\item {\ttfamily obj.\-Set\-Lock\-Sample\-Distance\-To\-Input\-Spacing (int )} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily int = obj.\-Get\-Lock\-Sample\-Distance\-To\-Input\-Spacing\-Min\-Value ()} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily int = obj.\-Get\-Lock\-Sample\-Distance\-To\-Input\-Spacing\-Max\-Value ()} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily int = obj.\-Get\-Lock\-Sample\-Distance\-To\-Input\-Spacing ()} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily obj.\-Lock\-Sample\-Distance\-To\-Input\-Spacing\-On ()} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily obj.\-Lock\-Sample\-Distance\-To\-Input\-Spacing\-Off ()} -\/ Automatically compute the sample distance from the data spacing. When the number of voxels is 8, the sample distance will be roughly 1/200 the average voxel size. The distance will grow proportionally to num\-Voxels$^\wedge$(1/3) until it reaches 1/2 average voxel size when number of voxels is 1\-E6. Note that Scalar\-Opacity\-Unit\-Distance is still taken into account and if different than 1, will effect the sample distance.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int num)} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily obj.\-Set\-Intermix\-Intersecting\-Geometry (int )} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Min\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Max\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-On ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-Off ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily float = obj.\-Compute\-Required\-Image\-Sample\-Distance (float desired\-Time, vtk\-Renderer ren)} -\/ What is the image sample distance required to achieve the desired time? A version of this method is provided that does not require the volume argument since if you are using an L\-O\-D\-Prop3\-D you may not know this information. If you use this version you must be certain that the ray cast mapper is only used for one volume (and not shared among multiple volumes)  
\item {\ttfamily float = obj.\-Compute\-Required\-Image\-Sample\-Distance (float desired\-Time, vtk\-Renderer ren, vtk\-Volume vol)} -\/ What is the image sample distance required to achieve the desired time? A version of this method is provided that does not require the volume argument since if you are using an L\-O\-D\-Prop3\-D you may not know this information. If you use this version you must be certain that the ray cast mapper is only used for one volume (and not shared among multiple volumes)  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper = obj.\-Get\-M\-I\-P\-Helper ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Helper = obj.\-Get\-Composite\-Helper ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Helper = obj.\-Get\-Composite\-G\-O\-Helper ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-G\-O\-Shade\-Helper = obj.\-Get\-Composite\-G\-O\-Shade\-Helper ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Composite\-Shade\-Helper = obj.\-Get\-Composite\-Shade\-Helper ()}  
\item {\ttfamily float = obj. Get\-Table\-Shift ()}  
\item {\ttfamily float = obj. Get\-Table\-Scale ()}  
\item {\ttfamily int = obj.\-Get\-Shading\-Required ()}  
\item {\ttfamily int = obj.\-Get\-Gradient\-Opacity\-Required ()}  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Current\-Scalars ()}  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Previous\-Scalars ()}  
\item {\ttfamily vtk\-Volume = obj.\-Get\-Volume ()}  
\item {\ttfamily obj.\-Compute\-Ray\-Info (int x, int y, int pos\mbox{[}3\mbox{]}, int dir\mbox{[}3\mbox{]}, int num\-Steps)}  
\item {\ttfamily obj.\-Initialize\-Ray\-Info (vtk\-Volume vol)}  
\item {\ttfamily int = obj.\-Should\-Use\-Nearest\-Neighbor\-Interpolation (vtk\-Volume vol)}  
\item {\ttfamily obj.\-Set\-Ray\-Cast\-Image (vtk\-Fixed\-Point\-Ray\-Cast\-Image )} -\/ Set / Get the underlying image object. One will be automatically created -\/ only need to set it when using from an A\-M\-R mapper which renders multiple times into the same image.  
\item {\ttfamily vtk\-Fixed\-Point\-Ray\-Cast\-Image = obj.\-Get\-Ray\-Cast\-Image ()} -\/ Set / Get the underlying image object. One will be automatically created -\/ only need to set it when using from an A\-M\-R mapper which renders multiple times into the same image.  
\item {\ttfamily int = obj.\-Per\-Image\-Initialization (vtk\-Renderer , vtk\-Volume , int , double , double , int )}  
\item {\ttfamily obj.\-Per\-Volume\-Initialization (vtk\-Renderer , vtk\-Volume )}  
\item {\ttfamily obj.\-Per\-Sub\-Volume\-Initialization (vtk\-Renderer , vtk\-Volume , int )}  
\item {\ttfamily obj.\-Render\-Sub\-Volume ()}  
\item {\ttfamily obj.\-Display\-Rendered\-Image (vtk\-Renderer , vtk\-Volume )}  
\item {\ttfamily obj.\-Abort\-Render ()}  
\item {\ttfamily obj.\-Create\-Canonical\-View (vtk\-Volume volume, vtk\-Image\-Data image, int blend\-\_\-mode, double view\-Direction\mbox{[}3\mbox{]}, double view\-Up\mbox{[}3\mbox{]})}  
\item {\ttfamily float = obj.\-Get\-Estimated\-Render\-Time (vtk\-Renderer ren, vtk\-Volume vol)} -\/ Get an estimate of the rendering time for a given volume / renderer. Only valid if this mapper has been used to render that volume for that renderer previously. Estimate is good when the viewing parameters have not changed much since that last render.  
\item {\ttfamily float = obj.\-Get\-Estimated\-Render\-Time (vtk\-Renderer ren)} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily obj.\-Set\-Final\-Color\-Window (float )} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily float = obj.\-Get\-Final\-Color\-Window ()} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily obj.\-Set\-Final\-Color\-Level (float )} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily float = obj.\-Get\-Final\-Color\-Level ()} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily int = obj.\-Get\-Flip\-M\-I\-P\-Comparison ()}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkfixedpointvolumeraycastmiphelper}{}\section{vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper}\label{vtkvolumerendering_vtkfixedpointvolumeraycastmiphelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is one of the helper classes for the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper. It will generate maximum intensity images. This class should not be used directly, it is a helper class for the mapper and has no user-\/level A\-P\-I.

To create an instance of class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFixedPointVolumeRayCastMIPHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-M\-I\-P\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Generate\-Image (int thread\-I\-D, int thread\-Count, vtk\-Volume vol, vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper mapper)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkgpuvolumeraycastmapper}{}\section{vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper}\label{vtkvolumerendering_vtkgpuvolumeraycastmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper is a volume mapper that performs ray casting on the G\-P\-U using fragment programs.

To create an instance of class vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGPUVolumeRayCastMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Sample\-Distances (int )} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Min\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Max\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-On ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-Off ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Set\-Sample\-Distance (float )} -\/ Set/\-Get the distance between samples used for rendering when Auto\-Adjust\-Sample\-Distances is off, or when this mapper has more than 1 second allocated to it for rendering. Initial value is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Sample\-Distance ()} -\/ Set/\-Get the distance between samples used for rendering when Auto\-Adjust\-Sample\-Distances is off, or when this mapper has more than 1 second allocated to it for rendering. Initial value is 1.\-0.  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (float )} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Min\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Max\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels. This value will be adjusted to meet a desired frame rate when Auto\-Adjust\-Sample\-Distances is on.  
\item {\ttfamily obj.\-Set\-Minimum\-Image\-Sample\-Distance (float )} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily obj.\-Set\-Maximum\-Image\-Sample\-Distance (float )} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted.  
\item {\ttfamily obj.\-Set\-Final\-Color\-Window (float )} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily float = obj.\-Get\-Final\-Color\-Window ()} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily obj.\-Set\-Final\-Color\-Level (float )} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily float = obj.\-Get\-Final\-Color\-Level ()} -\/ Set/\-Get the window / level applied to the final color. This allows brightness / contrast adjustments on the final image. window is the width of the window. level is the center of the window. Initial window value is 1.\-0 Initial level value is 0.\-5 window cannot be null but can be negative, this way values will be reversed. $|$window$|$ can be larger than 1.\-0 level can be any real value.  
\item {\ttfamily obj.\-Set\-Max\-Memory\-In\-Bytes (vtk\-Id\-Type )} -\/ Maximum size of the 3\-D texture in G\-P\-U memory. Will default to the size computed from the graphics card. Can be adjusted by the user.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Max\-Memory\-In\-Bytes ()} -\/ Maximum size of the 3\-D texture in G\-P\-U memory. Will default to the size computed from the graphics card. Can be adjusted by the user.  
\item {\ttfamily obj.\-Set\-Max\-Memory\-Fraction (float )} -\/ Maximum fraction of the Max\-Memory\-In\-Bytes that should be used to hold the texture. Valid values are 0.\-1 to 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Max\-Memory\-Fraction\-Min\-Value ()} -\/ Maximum fraction of the Max\-Memory\-In\-Bytes that should be used to hold the texture. Valid values are 0.\-1 to 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Max\-Memory\-Fraction\-Max\-Value ()} -\/ Maximum fraction of the Max\-Memory\-In\-Bytes that should be used to hold the texture. Valid values are 0.\-1 to 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Max\-Memory\-Fraction ()} -\/ Maximum fraction of the Max\-Memory\-In\-Bytes that should be used to hold the texture. Valid values are 0.\-1 to 1.\-0.  
\item {\ttfamily obj.\-Set\-Report\-Progress (bool )} -\/ Tells if the mapper will report intermediate progress. Initial value is true. As the progress works with a G\-L blocking call (gl\-Finish()), this can be useful for huge dataset but can slow down rendering of small dataset. It should be set to true for big dataset or complex shading and streaming but to false for small datasets.  
\item {\ttfamily bool = obj.\-Get\-Report\-Progress ()} -\/ Tells if the mapper will report intermediate progress. Initial value is true. As the progress works with a G\-L blocking call (gl\-Finish()), this can be useful for huge dataset but can slow down rendering of small dataset. It should be set to true for big dataset or complex shading and streaming but to false for small datasets.  
\item {\ttfamily int = obj.\-Is\-Render\-Supported (vtk\-Render\-Window , vtk\-Volume\-Property )}  
\item {\ttfamily obj.\-Create\-Canonical\-View (vtk\-Renderer ren, vtk\-Volume volume, vtk\-Image\-Data image, int blend\-\_\-mode, double view\-Direction\mbox{[}3\mbox{]}, double view\-Up\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Mask\-Input (vtk\-Image\-Data mask)}  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Mask\-Input ()}  
\item {\ttfamily obj.\-Set\-Mask\-Blend\-Factor (float )} -\/ Tells how much mask color transfer function is used compared to the standard color transfer function when the mask is true. 0.\-0 means only standard color transfer function. 1.\-0 means only mask color tranfer function. Initial value is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Mask\-Blend\-Factor\-Min\-Value ()} -\/ Tells how much mask color transfer function is used compared to the standard color transfer function when the mask is true. 0.\-0 means only standard color transfer function. 1.\-0 means only mask color tranfer function. Initial value is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Mask\-Blend\-Factor\-Max\-Value ()} -\/ Tells how much mask color transfer function is used compared to the standard color transfer function when the mask is true. 0.\-0 means only standard color transfer function. 1.\-0 means only mask color tranfer function. Initial value is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Mask\-Blend\-Factor ()} -\/ Tells how much mask color transfer function is used compared to the standard color transfer function when the mask is true. 0.\-0 means only standard color transfer function. 1.\-0 means only mask color tranfer function. Initial value is 1.\-0.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkhavsvolumemapper}{}\section{vtk\-H\-A\-V\-S\-Volume\-Mapper}\label{vtkvolumerendering_vtkhavsvolumemapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-H\-A\-V\-S\-Volume\-Mapper is a class that renders polygonal data (represented as an unstructured grid) using the Hardware-\/\-Assisted Visibility Sorting (H\-A\-V\-S) algorithm. First the unique triangles are sorted in object space, then they are sorted in image space using a fixed size A-\/buffer implemented on the G\-P\-U called the k-\/buffer. The H\-A\-V\-S algorithm excels at rendering large datasets quickly. The trade-\/off is that the algorithm may produce some rendering artifacts due to an insufficient k size (currently 2 or 6 is supported) or read/write race conditions.

A built in level-\/of-\/detail (L\-O\-D) approach samples the geometry using one of two heuristics (field or area). If L\-O\-D is enabled, the amount of geometry that is sampled and rendered changes dynamically to stay within the target frame rate. The field sampling method generally works best for datasets with cell sizes that don't vary much in size. On the contrary, the area sampling approach gives better approximations when the volume has a lot of variation in cell size.

The H\-A\-V\-S algorithm uses several advanced features on graphics hardware. The k-\/buffer sorting network is implemented using framebuffer objects (F\-B\-Os) with multiple render targets (M\-R\-Ts). Therefore, only cards that support these features can run the algorithm (at least an A\-T\-I 9500 or an N\-Vidia N\-V40 (6600)).

.S\-E\-C\-T\-I\-O\-N Notes

Several issues had to be addressed to get the H\-A\-V\-S algorithm working within the vtk framework. These additions forced the code to forsake speed for the sake of compliance and robustness.

The H\-A\-V\-S algorithm operates on the triangles that compose the mesh. Therefore, before rendering, the cells are decomposed into unique triangles and stored on the G\-P\-U for efficient rendering. The use of G\-P\-U data structures is only recommended if the entire geometry can fit in graphics memory. Otherwise this feature should be disabled.

Another new feature is the handling of mixed data types (eg., polygonal data with volume data). This is handled by reading the z-\/buffer from the current window and copying it into the framebuffer object for off-\/screen rendering. The depth test is then enabled so that the volume only appears over the opaque geometry. Finally, the results of the off-\/screen rendering are blended into the framebuffer as a transparent, view-\/aligned texture.

Instead of using a preintegrated 3\-D lookup table for storing the ray integral, this implementation uses partial pre-\/integration. This improves the performance of dynamic transfer function updates by avoiding a costly preprocess of the table.

A final change to the original algorithm is the handling of non-\/convexities in the mesh. Due to read/write hazards that may create undesired artifacts with non-\/convexities when using a inside/outside toggle in the fragment program, another approach was employed. To handle non-\/convexities, the fragment shader determines if a ray-\/gap is larger than the max cell size and kill the fragment if so. This approximation performs rather well in practice but may miss small non-\/convexities.

For more information on the H\-A\-V\-S algorithm see\-:

\char`\"{}\-Hardware-\/\-Assisted Visibility Sorting for Unstructured Volume
 Rendering\char`\"{} by S. P. Callahan, M. Ikits, J. L. D. Comba, and C. T. Silva, I\-E\-E\-E Transactions of Visualization and Computer Graphics; May/\-June 2005.

For more information on the Level-\/of-\/\-Detail algorithm, see\-:

\char`\"{}\-Interactive Rendering of Large Unstructured Grids Using Dynamic
 Level-\/of-\/\-Detail\char`\"{} by S. P. Callahan, J. L. D. Comba, P. Shirley, and C. T. Silva, Proceedings of I\-E\-E\-E Visualization '05, Oct. 2005.

.S\-E\-C\-T\-I\-O\-N Acknowledgments

This code was developed by Steven P. Callahan under the supervision of Prof. Claudio T. Silva. The code also contains contributions from Milan Ikits, Linh Ha, Huy T. Vo, Carlos E. Scheidegger, and Joao L. D. Comba.

The work was supported by grants, contracts, and gifts from the National Science Foundation, the Department of Energy, the Army Research Office, and I\-B\-M.

The port of H\-A\-V\-S to V\-T\-K and Para\-View has been primarily supported by Sandia National Labs.

To create an instance of class vtk\-H\-A\-V\-S\-Volume\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHAVSVolumeMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-H\-A\-V\-S\-Volume\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-H\-A\-V\-S\-Volume\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-H\-A\-V\-S\-Volume\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-H\-A\-V\-S\-Volume\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Partially\-Remove\-Non\-Convexities (bool )} -\/ regions by removing ray segments larger than the max cell size.  
\item {\ttfamily bool = obj.\-Get\-Partially\-Remove\-Non\-Convexities ()} -\/ regions by removing ray segments larger than the max cell size.  
\item {\ttfamily obj.\-Set\-Level\-Of\-Detail\-Target\-Time (float )} -\/ Set/get the desired level of detail target time measured in frames/sec.  
\item {\ttfamily float = obj.\-Get\-Level\-Of\-Detail\-Target\-Time ()} -\/ Set/get the desired level of detail target time measured in frames/sec.  
\item {\ttfamily obj.\-Set\-Level\-Of\-Detail (bool )} -\/ Turn on/off level-\/of-\/detail volume rendering  
\item {\ttfamily bool = obj.\-Get\-Level\-Of\-Detail ()} -\/ Turn on/off level-\/of-\/detail volume rendering  
\item {\ttfamily obj.\-Set\-Level\-Of\-Detail\-Method (int )} -\/ Set/get the current level-\/of-\/detail method  
\item {\ttfamily int = obj.\-Get\-Level\-Of\-Detail\-Method ()} -\/ Set/get the current level-\/of-\/detail method  
\item {\ttfamily obj.\-Set\-Level\-Of\-Detail\-Method\-Field ()} -\/ Set/get the current level-\/of-\/detail method  
\item {\ttfamily obj.\-Set\-Level\-Of\-Detail\-Method\-Area ()} -\/ Set the kbuffer size  
\item {\ttfamily obj.\-Set\-K\-Buffer\-Size (int )} -\/ Set the kbuffer size  
\item {\ttfamily int = obj.\-Get\-K\-Buffer\-Size ()} -\/ Set the kbuffer size  
\item {\ttfamily obj.\-Set\-K\-Buffer\-Size\-To2 ()} -\/ Set the kbuffer size  
\item {\ttfamily obj.\-Set\-K\-Buffer\-Size\-To6 ()} -\/ Check hardware support for the H\-A\-V\-S algorithm. Necessary features include off-\/screen rendering, 32-\/bit fp textures, multiple render targets, and framebuffer objects. Subclasses must override this method to indicate if supported by Hardware.  
\item {\ttfamily bool = obj.\-Supported\-By\-Hardware ()} -\/ Set/get whether or not the data structures should be stored on the G\-P\-U for better peformance.  
\item {\ttfamily obj.\-Set\-G\-P\-U\-Data\-Structures (bool )} -\/ Set/get whether or not the data structures should be stored on the G\-P\-U for better peformance.  
\item {\ttfamily bool = obj.\-Get\-G\-P\-U\-Data\-Structures ()} -\/ Set/get whether or not the data structures should be stored on the G\-P\-U for better peformance.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkopenglgpuvolumeraycastmapper}{}\section{vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper}\label{vtkvolumerendering_vtkopenglgpuvolumeraycastmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is the concrete implementation of a ray cast image display helper -\/ a helper class responsible for drawing the image to the screen.

To create an instance of class vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLGPUVolumeRayCastMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-G\-P\-U\-Volume\-Ray\-Cast\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Is\-Render\-Supported (vtk\-Render\-Window window, vtk\-Volume\-Property property)} -\/ Based on hardware and properties, we may or may not be able to render using 3\-D texture mapping. This indicates if 3\-D texture mapping is supported by the hardware, and if the other extensions necessary to support the specific properties are available.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkopenglhavsvolumemapper}{}\section{vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper}\label{vtkvolumerendering_vtkopenglhavsvolumemapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-H\-A\-V\-S\-Volume\-Mapper is a class that renders polygonal data (represented as an unstructured grid) using the Hardware-\/\-Assisted Visibility Sorting (H\-A\-V\-S) algorithm. First the unique triangles are sorted in object space, then they are sorted in image space using a fixed size A-\/buffer implemented on the G\-P\-U called the k-\/buffer. The H\-A\-V\-S algorithm excels at rendering large datasets quickly. The trade-\/off is that the algorithm may produce some rendering artifacts due to an insufficient k size (currently 2 or 6 is supported) or read/write race conditions.

A built in level-\/of-\/detail (L\-O\-D) approach samples the geometry using one of two heuristics (field or area). If L\-O\-D is enabled, the amount of geometry that is sampled and rendered changes dynamically to stay within the target frame rate. The field sampling method generally works best for datasets with cell sizes that don't vary much in size. On the contrary, the area sampling approach gives better approximations when the volume has a lot of variation in cell size.

The H\-A\-V\-S algorithm uses several advanced features on graphics hardware. The k-\/buffer sorting network is implemented using framebuffer objects (F\-B\-Os) with multiple render targets (M\-R\-Ts). Therefore, only cards that support these features can run the algorithm (at least an A\-T\-I 9500 or an N\-Vidia N\-V40 (6600)).

.S\-E\-C\-T\-I\-O\-N Notes

Several issues had to be addressed to get the H\-A\-V\-S algorithm working within the vtk framework. These additions forced the code to forsake speed for the sake of compliance and robustness.

The H\-A\-V\-S algorithm operates on the triangles that compose the mesh. Therefore, before rendering, the cells are decomposed into unique triangles and stored on the G\-P\-U for efficient rendering. The use of G\-P\-U data structures is only recommended if the entire geometry can fit in graphics memory. Otherwise this feature should be disabled.

Another new feature is the handling of mixed data types (eg., polygonal data with volume data). This is handled by reading the z-\/buffer from the current window and copying it into the framebuffer object for off-\/screen rendering. The depth test is then enabled so that the volume only appears over the opaque geometry. Finally, the results of the off-\/screen rendering are blended into the framebuffer as a transparent, view-\/aligned texture.

Instead of using a preintegrated 3\-D lookup table for storing the ray integral, this implementation uses partial pre-\/integration. This improves the performance of dynamic transfer function updates by avoiding a costly preprocess of the table.

A final change to the original algorithm is the handling of non-\/convexities in the mesh. Due to read/write hazards that may create undesired artifacts with non-\/convexities when using a inside/outside toggle in the fragment program, another approach was employed. To handle non-\/convexities, the fragment shader determines if a ray-\/gap is larger than the max cell size and kill the fragment if so. This approximation performs rather well in practice but may miss small non-\/convexities.

For more information on the H\-A\-V\-S algorithm see\-:

\char`\"{}\-Hardware-\/\-Assisted Visibility Sorting for Unstructured Volume
 Rendering\char`\"{} by S. P. Callahan, M. Ikits, J. L. D. Comba, and C. T. Silva, I\-E\-E\-E Transactions of Visualization and Computer Graphics; May/\-June 2005.

For more information on the Level-\/of-\/\-Detail algorithm, see\-:

\char`\"{}\-Interactive Rendering of Large Unstructured Grids Using Dynamic
 Level-\/of-\/\-Detail\char`\"{} by S. P. Callahan, J. L. D. Comba, P. Shirley, and C. T. Silva, Proceedings of I\-E\-E\-E Visualization '05, Oct. 2005.

.S\-E\-C\-T\-I\-O\-N Acknowledgments

This code was developed by Steven P. Callahan under the supervision of Prof. Claudio T. Silva. The code also contains contributions from Milan Ikits, Linh Ha, Huy T. Vo, Carlos E. Scheidegger, and Joao L. D. Comba.

The work was supported by grants, contracts, and gifts from the National Science Foundation, the Department of Energy, the Army Research Office, and I\-B\-M.

The port of H\-A\-V\-S to V\-T\-K and Para\-View has been primarily supported by Sandia National Labs.

To create an instance of class vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLHAVSVolumeMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-H\-A\-V\-S\-Volume\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Volume vol)} -\/ Render the volume  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily obj.\-Set\-G\-P\-U\-Data\-Structures (bool )} -\/ Set/get whether or not the data structures should be stored on the G\-P\-U for better peformance.  
\item {\ttfamily bool = obj.\-Supported\-By\-Hardware ()} -\/ Check hardware support for the H\-A\-V\-S algorithm. Necessary features include off-\/screen rendering, 32-\/bit fp textures, multiple render targets, and framebuffer objects. Subclasses must override this method to indicate if supported by Hardware.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkopenglraycastimagedisplayhelper}{}\section{vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper}\label{vtkvolumerendering_vtkopenglraycastimagedisplayhelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is the concrete implementation of a ray cast image display helper -\/ a helper class responsible for drawing the image to the screen.

To create an instance of class vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLRayCastImageDisplayHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Ray\-Cast\-Image\-Display\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, int image\-Memory\-Size\mbox{[}2\mbox{]}, int image\-Viewport\-Size\mbox{[}2\mbox{]}, int image\-In\-Use\-Size\mbox{[}2\mbox{]}, int image\-Origin\mbox{[}2\mbox{]}, float requested\-Depth, string image)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, int image\-Memory\-Size\mbox{[}2\mbox{]}, int image\-Viewport\-Size\mbox{[}2\mbox{]}, int image\-In\-Use\-Size\mbox{[}2\mbox{]}, int image\-Origin\mbox{[}2\mbox{]}, float requested\-Depth, short image)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, vtk\-Fixed\-Point\-Ray\-Cast\-Image image, float requested\-Depth)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkopenglvolumetexturemapper2d}{}\section{vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D}\label{vtkvolumerendering_vtkopenglvolumetexturemapper2d}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D renders a volume using 2\-D texture mapping.

To create an instance of class vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLVolumeTextureMapper2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Volume\-Texture\-Mapper2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkopenglvolumetexturemapper3d}{}\section{vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D}\label{vtkvolumerendering_vtkopenglvolumetexturemapper3d}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D renders a volume using 3\-D texture mapping. See vtk\-Volume\-Texture\-Mapper3\-D for full description.

To create an instance of class vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLVolumeTextureMapper3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Is\-Render\-Supported (vtk\-Volume\-Property )} -\/ Is hardware rendering supported? No if the input data is more than one independent component, or if the hardware does not support the required extensions  
\item {\ttfamily int = obj.\-Get\-Initialized ()}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this texture. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkprojectedtetrahedramapper}{}\section{vtk\-Projected\-Tetrahedra\-Mapper}\label{vtkvolumerendering_vtkprojectedtetrahedramapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Projected\-Tetrahedra\-Mapper is an implementation of the classic Projected Tetrahedra algorithm presented by Shirley and Tuchman in \char`\"{}\-A
 Polygonal Approximation to Direct Scalar Volume Rendering\char`\"{} in Computer Graphics, December 1990.

.S\-E\-C\-T\-I\-O\-N Bugs This mapper relies highly on the implementation of the Open\-G\-L pipeline. A typical hardware driver has lots of options and some settings can cause this mapper to produce artifacts.

To create an instance of class vtk\-Projected\-Tetrahedra\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProjectedTetrahedraMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Projected\-Tetrahedra\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Projected\-Tetrahedra\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Projected\-Tetrahedra\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Projected\-Tetrahedra\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Visibility\-Sort (vtk\-Visibility\-Sort sort)}  
\item {\ttfamily vtk\-Visibility\-Sort = obj.\-Get\-Visibility\-Sort ()}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkraycastimagedisplayhelper}{}\section{vtk\-Ray\-Cast\-Image\-Display\-Helper}\label{vtkvolumerendering_vtkraycastimagedisplayhelper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a helper class for drawing images created from ray casting on the screen. This is the abstract device-\/independent superclass.

To create an instance of class vtk\-Ray\-Cast\-Image\-Display\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRayCastImageDisplayHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Ray\-Cast\-Image\-Display\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Ray\-Cast\-Image\-Display\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Ray\-Cast\-Image\-Display\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Ray\-Cast\-Image\-Display\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, int image\-Memory\-Size\mbox{[}2\mbox{]}, int image\-Viewport\-Size\mbox{[}2\mbox{]}, int image\-In\-Use\-Size\mbox{[}2\mbox{]}, int image\-Origin\mbox{[}2\mbox{]}, float requested\-Depth, string image)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, int image\-Memory\-Size\mbox{[}2\mbox{]}, int image\-Viewport\-Size\mbox{[}2\mbox{]}, int image\-In\-Use\-Size\mbox{[}2\mbox{]}, int image\-Origin\mbox{[}2\mbox{]}, float requested\-Depth, short image)}  
\item {\ttfamily obj.\-Render\-Texture (vtk\-Volume vol, vtk\-Renderer ren, vtk\-Fixed\-Point\-Ray\-Cast\-Image image, float requested\-Depth)}  
\item {\ttfamily obj.\-Set\-Pre\-Multiplied\-Colors (int )}  
\item {\ttfamily int = obj.\-Get\-Pre\-Multiplied\-Colors\-Min\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Pre\-Multiplied\-Colors\-Max\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Pre\-Multiplied\-Colors ()}  
\item {\ttfamily obj.\-Pre\-Multiplied\-Colors\-On ()}  
\item {\ttfamily obj.\-Pre\-Multiplied\-Colors\-Off ()}  
\item {\ttfamily obj.\-Set\-Pixel\-Scale (float )} -\/ Set / Get the pixel scale to be applied to the image before display. Can be set to scale the incoming pixel values -\/ for example the fixed point mapper uses the unsigned short A\-P\-I but with 15 bit values so needs a scale of 2.\-0.  
\item {\ttfamily float = obj.\-Get\-Pixel\-Scale ()} -\/ Set / Get the pixel scale to be applied to the image before display. Can be set to scale the incoming pixel values -\/ for example the fixed point mapper uses the unsigned short A\-P\-I but with 15 bit values so needs a scale of 2.\-0.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkrecursivespheredirectionencoder}{}\section{vtk\-Recursive\-Sphere\-Direction\-Encoder}\label{vtkvolumerendering_vtkrecursivespheredirectionencoder}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Recursive\-Sphere\-Direction\-Encoder is a direction encoder which uses the vertices of a recursive subdivision of an octahedron (with the vertices pushed out onto the surface of an enclosing sphere) to encode directions into a two byte value.

To create an instance of class vtk\-Recursive\-Sphere\-Direction\-Encoder, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRecursiveSphereDirectionEncoder
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Recursive\-Sphere\-Direction\-Encoder has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Recursive\-Sphere\-Direction\-Encoder class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Recursive\-Sphere\-Direction\-Encoder = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Recursive\-Sphere\-Direction\-Encoder = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Encoded\-Direction (float n\mbox{[}3\mbox{]})} -\/ Given a normal vector n, return the encoded direction  
\item {\ttfamily float = obj.\-Get\-Decoded\-Gradient (int value)} -\/ / Given an encoded value, return a pointer to the normal vector  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Encoded\-Directions (void )} -\/ Return the number of encoded directions  
\item {\ttfamily obj.\-Set\-Recursion\-Depth (int )} -\/ Set / Get the recursion depth for the subdivision. This indicates how many time one triangle on the initial 8-\/sided sphere model is replaced by four triangles formed by connecting triangle edge midpoints. A recursion level of 0 yields 8 triangles with 6 unique vertices. The normals are the vectors from the sphere center through the vertices. The number of directions will be 11 since the four normals with 0 z values will be duplicated in the table -\/ once with +0 values and the other time with -\/0 values, and an addition index will be used to represent the (0,0,0) normal. If we instead choose a recursion level of 6 (the maximum that can fit within 2 bytes) the number of directions is 16643, with 16386 unique directions and a zero normal.  
\item {\ttfamily int = obj.\-Get\-Recursion\-Depth\-Min\-Value ()} -\/ Set / Get the recursion depth for the subdivision. This indicates how many time one triangle on the initial 8-\/sided sphere model is replaced by four triangles formed by connecting triangle edge midpoints. A recursion level of 0 yields 8 triangles with 6 unique vertices. The normals are the vectors from the sphere center through the vertices. The number of directions will be 11 since the four normals with 0 z values will be duplicated in the table -\/ once with +0 values and the other time with -\/0 values, and an addition index will be used to represent the (0,0,0) normal. If we instead choose a recursion level of 6 (the maximum that can fit within 2 bytes) the number of directions is 16643, with 16386 unique directions and a zero normal.  
\item {\ttfamily int = obj.\-Get\-Recursion\-Depth\-Max\-Value ()} -\/ Set / Get the recursion depth for the subdivision. This indicates how many time one triangle on the initial 8-\/sided sphere model is replaced by four triangles formed by connecting triangle edge midpoints. A recursion level of 0 yields 8 triangles with 6 unique vertices. The normals are the vectors from the sphere center through the vertices. The number of directions will be 11 since the four normals with 0 z values will be duplicated in the table -\/ once with +0 values and the other time with -\/0 values, and an addition index will be used to represent the (0,0,0) normal. If we instead choose a recursion level of 6 (the maximum that can fit within 2 bytes) the number of directions is 16643, with 16386 unique directions and a zero normal.  
\item {\ttfamily int = obj.\-Get\-Recursion\-Depth ()} -\/ Set / Get the recursion depth for the subdivision. This indicates how many time one triangle on the initial 8-\/sided sphere model is replaced by four triangles formed by connecting triangle edge midpoints. A recursion level of 0 yields 8 triangles with 6 unique vertices. The normals are the vectors from the sphere center through the vertices. The number of directions will be 11 since the four normals with 0 z values will be duplicated in the table -\/ once with +0 values and the other time with -\/0 values, and an addition index will be used to represent the (0,0,0) normal. If we instead choose a recursion level of 6 (the maximum that can fit within 2 bytes) the number of directions is 16643, with 16386 unique directions and a zero normal.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtksphericaldirectionencoder}{}\section{vtk\-Spherical\-Direction\-Encoder}\label{vtkvolumerendering_vtksphericaldirectionencoder}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spherical\-Direction\-Encoder is a direction encoder which uses spherical coordinates for mapping (nx, ny, nz) into an azimuth, elevation pair.

To create an instance of class vtk\-Spherical\-Direction\-Encoder, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphericalDirectionEncoder
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spherical\-Direction\-Encoder has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spherical\-Direction\-Encoder class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spherical\-Direction\-Encoder = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spherical\-Direction\-Encoder = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Encoded\-Direction (float n\mbox{[}3\mbox{]})} -\/ Given a normal vector n, return the encoded direction  
\item {\ttfamily float = obj.\-Get\-Decoded\-Gradient (int value)} -\/ / Given an encoded value, return a pointer to the normal vector  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Encoded\-Directions (void )} -\/ Get the decoded gradient table. There are this-\/$>$Get\-Number\-Of\-Encoded\-Directions() entries in the table, each containing a normal (direction) vector. This is a flat structure -\/ 3 times the number of directions floats in an array.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridbunykraycastfunction}{}\section{vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function}\label{vtkvolumerendering_vtkunstructuredgridbunykraycastfunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function is a concrete implementation of a ray cast function for unstructured grid data. This class was based on the paper \char`\"{}\-Simple, Fast, Robust Ray Casting of Irregular Grids\char`\"{} by Paul Bunyk, Arie Kaufmna, and Claudio Silva. This method is quite memory intensive (with extra explicit copies of the data) and therefore should not be used for very large data. This method assumes that the input data is composed entirely of tetras -\/ use vtk\-Data\-Set\-Triangle\-Filter before setting the input on the mapper.

The basic idea of this method is as follows\-:

1) Enumerate the triangles. At each triangle have space for some information that will be used during rendering. This includes which tetra the triangles belong to, the plane equation and the Barycentric coefficients.

2) Keep a reference to all four triangles for each tetra.

3) At the beginning of each render, do the precomputation. This includes creating an array of transformed points (in view coordinates) and computing the view dependent info per triangle (plane equations and barycentric coords in view space)

4) Find all front facing boundary triangles (a triangle is on the boundary if it belongs to only one tetra). For each triangle, find all pixels in the image that intersect the triangle, and add this to the sorted (by depth) intersection list at each pixel.

5) For each ray cast, traverse the intersection list. At each intersection, accumulate opacity and color contribution per tetra along the ray until you reach an exiting triangle (on the boundary).

To create an instance of class vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridBunykRayCastFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Bunyk\-Ray\-Cast\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridhomogeneousrayintegrator}{}\section{vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator}\label{vtkvolumerendering_vtkunstructuredgridhomogeneousrayintegrator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator performs homogeneous ray integration. This is a good method to use when volume rendering scalars that are defined on cells.

To create an instance of class vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridHomogeneousRayIntegrator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Homogeneous\-Ray\-Integrator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Volume volume, vtk\-Data\-Array scalars)}  
\item {\ttfamily obj.\-Integrate (vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections, float color\mbox{[}4\mbox{]})}  
\item {\ttfamily obj.\-Set\-Transfer\-Function\-Table\-Size (int )} -\/ For quick lookup, the transfer function is sampled into a table. This parameter sets how big of a table to use. By default, 1024 entries are used.  
\item {\ttfamily int = obj.\-Get\-Transfer\-Function\-Table\-Size ()} -\/ For quick lookup, the transfer function is sampled into a table. This parameter sets how big of a table to use. By default, 1024 entries are used.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridlinearrayintegrator}{}\section{vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator}\label{vtkvolumerendering_vtkunstructuredgridlinearrayintegrator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator performs piecewise linear ray integration. Considering that transfer functions in V\-T\-K are piecewise linear, this class should give the \char`\"{}correct\char`\"{} integration under most circumstances. However, the computations performed are fairly hefty and should, for the most part, only be used as a benchmark for other, faster methods.

To create an instance of class vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridLinearRayIntegrator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Volume volume, vtk\-Data\-Array scalars)}  
\item {\ttfamily obj.\-Integrate (vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections, float color\mbox{[}4\mbox{]})}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridpartialpreintegration}{}\section{vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration}\label{vtkvolumerendering_vtkunstructuredgridpartialpreintegration}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration performs piecewise linear ray integration. This will give the same results as vtk\-Unstructured\-Grid\-Linear\-Ray\-Integration (with potentially a error due to table lookup quantization), but should be notably faster. The algorithm used is given by Moreland and Angel, \char`\"{}\-A Fast High Accuracy Volume
 Renderer for Unstructured Data.\char`\"{}

This class is thread safe only after the first instance is created.

To create an instance of class vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridPartialPreIntegration
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Volume volume, vtk\-Data\-Array scalars)}  
\item {\ttfamily obj.\-Integrate (vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections, float color\mbox{[}4\mbox{]})}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridpreintegration}{}\section{vtk\-Unstructured\-Grid\-Pre\-Integration}\label{vtkvolumerendering_vtkunstructuredgridpreintegration}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Pre\-Integration performs ray integration by looking into a precomputed table. The result should be equivalent to that computed by vtk\-Unstructured\-Grid\-Linear\-Ray\-Integrator and vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration, but faster than either one. The pre-\/integration algorithm was first introduced by Roettger, Kraus, and Ertl in \char`\"{}\-Hardware-\/\-Accelerated Volume And Isosurface Rendering Based
 On Cell-\/\-Projection.\char`\"{}

Due to table size limitations, a table can only be indexed by independent scalars. Thus, dependent scalars are not supported.

To create an instance of class vtk\-Unstructured\-Grid\-Pre\-Integration, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridPreIntegration
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Pre\-Integration has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Pre\-Integration class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Pre\-Integration = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Pre\-Integration = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Volume volume, vtk\-Data\-Array scalars)}  
\item {\ttfamily obj.\-Integrate (vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections, float color\mbox{[}4\mbox{]})}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator = obj.\-Get\-Integrator ()} -\/ The class used to fill the pre integration table. By default, a vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration is built.  
\item {\ttfamily obj.\-Set\-Integrator (vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator )} -\/ The class used to fill the pre integration table. By default, a vtk\-Unstructured\-Grid\-Partial\-Pre\-Integration is built.  
\item {\ttfamily obj.\-Set\-Integration\-Table\-Scalar\-Resolution (int )} -\/ Set/\-Get the size of the integration table built.  
\item {\ttfamily int = obj.\-Get\-Integration\-Table\-Scalar\-Resolution ()} -\/ Set/\-Get the size of the integration table built.  
\item {\ttfamily obj.\-Set\-Integration\-Table\-Length\-Resolution (int )} -\/ Set/\-Get the size of the integration table built.  
\item {\ttfamily int = obj.\-Get\-Integration\-Table\-Length\-Resolution ()} -\/ Set/\-Get the size of the integration table built.  
\item {\ttfamily double = obj.\-Get\-Integration\-Table\-Scalar\-Shift (int component)} -\/ Get how an integration table is indexed.  
\item {\ttfamily double = obj.\-Get\-Integration\-Table\-Scalar\-Scale (int component)} -\/ Get how an integration table is indexed.  
\item {\ttfamily double = obj.\-Get\-Integration\-Table\-Length\-Scale ()} -\/ Get how an integration table is indexed.  
\item {\ttfamily int = obj.\-Get\-Incremental\-Pre\-Integration ()} -\/ Get/set whether to use incremental pre-\/integration (by default it's on). Incremental pre-\/integration is much faster but can introduce error due to numerical imprecision. Under most circumstances, the error is not noticable.  
\item {\ttfamily obj.\-Set\-Incremental\-Pre\-Integration (int )} -\/ Get/set whether to use incremental pre-\/integration (by default it's on). Incremental pre-\/integration is much faster but can introduce error due to numerical imprecision. Under most circumstances, the error is not noticable.  
\item {\ttfamily obj.\-Incremental\-Pre\-Integration\-On ()} -\/ Get/set whether to use incremental pre-\/integration (by default it's on). Incremental pre-\/integration is much faster but can introduce error due to numerical imprecision. Under most circumstances, the error is not noticable.  
\item {\ttfamily obj.\-Incremental\-Pre\-Integration\-Off ()} -\/ Get/set whether to use incremental pre-\/integration (by default it's on). Incremental pre-\/integration is much faster but can introduce error due to numerical imprecision. Under most circumstances, the error is not noticable.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumemapper}{}\section{vtk\-Unstructured\-Grid\-Volume\-Mapper}\label{vtkvolumerendering_vtkunstructuredgridvolumemapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Volume\-Mapper is the abstract definition of a volume mapper for unstructured data (vtk\-Unstructured\-Grid). Several basic types of volume mappers are supported as subclasses

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Unstructured\-Grid )} -\/ Set/\-Get the input data  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set )} -\/ Set/\-Get the input data  
\item {\ttfamily vtk\-Unstructured\-Grid = obj.\-Get\-Input ()} -\/ Set/\-Get the input data  
\item {\ttfamily obj.\-Set\-Blend\-Mode (int )}  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Composite ()}  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Maximum\-Intensity ()}  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode ()}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumeraycastfunction}{}\section{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function}\label{vtkvolumerendering_vtkunstructuredgridvolumeraycastfunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function is a superclass for ray casting functions that can be used within a vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper.

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeRayCastFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumeraycastiterator}{}\section{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator}\label{vtkvolumerendering_vtkunstructuredgridvolumeraycastiterator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator is a superclass for iterating over the intersections of a viewing ray with a group of unstructured cells. These iterators are created with a vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function.

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeRayCastIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (int x, int y)} -\/ Initializes the iteration to the start of the ray at the given screen coordinates.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Next\-Intersections (vtk\-Id\-List intersected\-Cells, vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array scalars, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections)} -\/ Get the intersections of the next several cells. The cell ids are stored in {\ttfamily intersected\-Cells} and the length of each ray segment within the cell is stored in {\ttfamily intersection\-Lengths}. The point scalars {\ttfamily scalars} are interpolated and stored in {\ttfamily near\-Intersections} and {\ttfamily far\-Intersections}. {\ttfamily intersected\-Cells}, {\ttfamily intersection\-Lengths}, or {\ttfamily scalars} may be {\ttfamily N\-U\-L\-L} to supress passing the associated information. The number of intersections actually encountered is returned. 0 is returned if and only if no more intersections are to be found.  
\item {\ttfamily obj.\-Set\-Bounds (double , double )} -\/ Set/get the bounds of the cast ray (in viewing coordinates). By default the range is \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}2\mbox{]})} -\/ Set/get the bounds of the cast ray (in viewing coordinates). By default the range is \mbox{[}0,1\mbox{]}.  
\item {\ttfamily double = obj. Get\-Bounds ()} -\/ Set/get the bounds of the cast ray (in viewing coordinates). By default the range is \mbox{[}0,1\mbox{]}.  
\item {\ttfamily obj.\-Set\-Max\-Number\-Of\-Intersections (vtk\-Id\-Type )}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Max\-Number\-Of\-Intersections ()}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumeraycastmapper}{}\section{vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper}\label{vtkvolumerendering_vtkunstructuredgridvolumeraycastmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a software ray caster for rendering volumes in vtk\-Unstructured\-Grid.

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeRayCastMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (float )} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Min\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Max\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily obj.\-Set\-Minimum\-Image\-Sample\-Distance (float )} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Maximum\-Image\-Sample\-Distance (float )} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Sample\-Distances (int )} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Min\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Max\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-On ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-Off ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int )} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily obj.\-Set\-Intermix\-Intersecting\-Geometry (int )} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Min\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Max\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-On ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-Off ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Set\-Ray\-Cast\-Function (vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function f)} -\/ Set/\-Get the helper class for casting rays.  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Function = obj.\-Get\-Ray\-Cast\-Function ()} -\/ Set/\-Get the helper class for casting rays.  
\item {\ttfamily obj.\-Set\-Ray\-Integrator (vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator ri)} -\/ Set/\-Get the helper class for integrating rays. If set to N\-U\-L\-L, a default integrator will be assigned.  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator = obj.\-Get\-Ray\-Integrator ()} -\/ Set/\-Get the helper class for integrating rays. If set to N\-U\-L\-L, a default integrator will be assigned.  
\item {\ttfamily obj.\-Cast\-Rays (int thread\-I\-D, int thread\-Count)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumerayintegrator}{}\section{vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator}\label{vtkvolumerendering_vtkunstructuredgridvolumerayintegrator}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator is a superclass for ray integration functions that can be used within a vtk\-Unstructured\-Grid\-Volume\-Ray\-Cast\-Mapper.

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeRayIntegrator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize (vtk\-Volume volume, vtk\-Data\-Array scalars)} -\/ Set up the integrator with the given properties and scalars.  
\item {\ttfamily obj.\-Integrate (vtk\-Double\-Array intersection\-Lengths, vtk\-Data\-Array near\-Intersections, vtk\-Data\-Array far\-Intersections, float color\mbox{[}4\mbox{]})} -\/ Given a set of intersections (defined by the three arrays), compute the peicewise integration of the array in front to back order. /c intersection\-Lengths holds the lengths of each peicewise segment. /c near\-Intersections and /c far\-Intersections hold the scalar values at the front and back of each segment. /c color should contain the R\-G\-B\-A value of the volume in front of the segments passed in, and the result will be placed back into /c color.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkunstructuredgridvolumezsweepmapper}{}\section{vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper}\label{vtkvolumerendering_vtkunstructuredgridvolumezsweepmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a volume mapper for unstructured grid implemented with the Z\-Sweep algorithm. This is a software projective method.

To create an instance of class vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUnstructuredGridVolumeZSweepMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Z\-Sweep\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (float )} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Min\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance\-Max\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily float = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily obj.\-Set\-Minimum\-Image\-Sample\-Distance (float )} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Minimum\-Image\-Sample\-Distance ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Maximum\-Image\-Sample\-Distance (float )} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily float = obj.\-Get\-Maximum\-Image\-Sample\-Distance ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Sample\-Distances (int )} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Min\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Max\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-On ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-Off ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Set\-Intermix\-Intersecting\-Geometry (int )} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Min\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Max\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-On ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-Off ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Max\-Pixel\-List\-Size ()} -\/ Maximum size allowed for a pixel list. Default is 32. During the rendering, if a list of pixel is full, incremental compositing is performed. Even if it is a user setting, it is an advanced parameter. You have to understand how the algorithm works to change this value.  
\item {\ttfamily obj.\-Set\-Max\-Pixel\-List\-Size (int size)} -\/ Change the maximum size allowed for a pixel list. It is an advanced parameter. \begin{DoxyPrecond}{Precondition}
positive\-\_\-size\-: size$>$1  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Ray\-Integrator (vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator ri)} -\/ Set/\-Get the helper class for integrating rays. If set to N\-U\-L\-L, a default integrator will be assigned.  
\item {\ttfamily vtk\-Unstructured\-Grid\-Volume\-Ray\-Integrator = obj.\-Get\-Ray\-Integrator ()} -\/ Set/\-Get the helper class for integrating rays. If set to N\-U\-L\-L, a default integrator will be assigned.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumemapper}{}\section{vtk\-Volume\-Mapper}\label{vtkvolumerendering_vtkvolumemapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Mapper is the abstract definition of a volume mapper for regular rectilinear data (vtk\-Image\-Data). Several basic types of volume mappers are supported.

To create an instance of class vtk\-Volume\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data )} -\/ Set/\-Get the input data  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set )} -\/ Set/\-Get the input data  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the input data  
\item {\ttfamily obj.\-Set\-Blend\-Mode (int )} -\/ Set/\-Get the blend mode. Currently this is only supported by the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper -\/ other mappers have different ways to set this (supplying a function to a vtk\-Volume\-Ray\-Cast\-Mapper) or don't have any options (vtk\-Volume\-Texture\-Mapper2\-D supports only compositing)  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Composite ()} -\/ Set/\-Get the blend mode. Currently this is only supported by the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper -\/ other mappers have different ways to set this (supplying a function to a vtk\-Volume\-Ray\-Cast\-Mapper) or don't have any options (vtk\-Volume\-Texture\-Mapper2\-D supports only compositing)  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Maximum\-Intensity ()} -\/ Set/\-Get the blend mode. Currently this is only supported by the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper -\/ other mappers have different ways to set this (supplying a function to a vtk\-Volume\-Ray\-Cast\-Mapper) or don't have any options (vtk\-Volume\-Texture\-Mapper2\-D supports only compositing)  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Minimum\-Intensity ()} -\/ Set/\-Get the blend mode. Currently this is only supported by the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper -\/ other mappers have different ways to set this (supplying a function to a vtk\-Volume\-Ray\-Cast\-Mapper) or don't have any options (vtk\-Volume\-Texture\-Mapper2\-D supports only compositing)  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode ()} -\/ Set/\-Get the blend mode. Currently this is only supported by the vtk\-Fixed\-Point\-Volume\-Ray\-Cast\-Mapper -\/ other mappers have different ways to set this (supplying a function to a vtk\-Volume\-Ray\-Cast\-Mapper) or don't have any options (vtk\-Volume\-Texture\-Mapper2\-D supports only compositing)  
\item {\ttfamily obj.\-Set\-Cropping (int )} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily int = obj.\-Get\-Cropping\-Min\-Value ()} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily int = obj.\-Get\-Cropping\-Max\-Value ()} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily int = obj.\-Get\-Cropping ()} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily obj.\-Cropping\-On ()} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily obj.\-Cropping\-Off ()} -\/ Turn On/\-Off orthogonal cropping. (Clipping planes are perpendicular to the coordinate axes.)  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Planes (double , double , double , double , double , double )} -\/ Set/\-Get the Cropping Region Planes ( xmin, xmax, ymin, ymax, zmin, zmax ) These planes are defined in volume coordinates -\/ spacing and origin are considered.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Planes (double a\mbox{[}6\mbox{]})} -\/ Set/\-Get the Cropping Region Planes ( xmin, xmax, ymin, ymax, zmin, zmax ) These planes are defined in volume coordinates -\/ spacing and origin are considered.  
\item {\ttfamily double = obj. Get\-Cropping\-Region\-Planes ()} -\/ Set/\-Get the Cropping Region Planes ( xmin, xmax, ymin, ymax, zmin, zmax ) These planes are defined in volume coordinates -\/ spacing and origin are considered.  
\item {\ttfamily double = obj. Get\-Voxel\-Cropping\-Region\-Planes ()} -\/ Get the cropping region planes in voxels. Only valid during the rendering process  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags (int )} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily int = obj.\-Get\-Cropping\-Region\-Flags\-Min\-Value ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily int = obj.\-Get\-Cropping\-Region\-Flags\-Max\-Value ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily int = obj.\-Get\-Cropping\-Region\-Flags ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags\-To\-Sub\-Volume ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags\-To\-Fence ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags\-To\-Inverted\-Fence ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags\-To\-Cross ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\item {\ttfamily obj.\-Set\-Cropping\-Region\-Flags\-To\-Inverted\-Cross ()} -\/ Set the flags for the cropping regions. The clipping planes divide the volume into 27 regions -\/ there is one bit for each region. The regions start from the one containing voxel (0,0,0), moving along the x axis fastest, the y axis next, and the z axis slowest. These are represented from the lowest bit to bit number 27 in the integer containing the flags. There are several convenience functions to set some common configurations -\/ subvolume (the default), fence (between any of the clip plane pairs), inverted fence, cross (between any two of the clip plane pairs) and inverted cross.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeoutlinesource}{}\section{vtk\-Volume\-Outline\-Source}\label{vtkvolumerendering_vtkvolumeoutlinesource}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Outline\-Source generates a wireframe outline that corresponds to the cropping region of a vtk\-Volume\-Mapper. It requires a vtk\-Volume\-Mapper as input. The Generate\-Faces option turns on the solid faces of the outline, and the Generate\-Scalars option generates color scalars. When Generate\-Scalars is on, it is possible to set an \char`\"{}\-Active\-Plane\-Id\char`\"{} value in the range \mbox{[}0..6\mbox{]} to highlight one of the six cropping planes. .S\-E\-C\-T\-I\-O\-N Thanks Thanks to David Gobbi for contributing this class to V\-T\-K.

To create an instance of class vtk\-Volume\-Outline\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeOutlineSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Outline\-Source has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Outline\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Outline\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Outline\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Volume\-Mapper (vtk\-Volume\-Mapper mapper)} -\/ Set the mapper that has the cropping region that the outline will be generated for. The mapper must have an input, because the bounds of the data must be computed in order to generate the outline.  
\item {\ttfamily vtk\-Volume\-Mapper = obj.\-Get\-Volume\-Mapper ()} -\/ Set the mapper that has the cropping region that the outline will be generated for. The mapper must have an input, because the bounds of the data must be computed in order to generate the outline.  
\item {\ttfamily obj.\-Set\-Generate\-Scalars (int )} -\/ Set whether to generate color scalars for the output. By default, the output has no scalars and the color must be set in the property of the actor.  
\item {\ttfamily obj.\-Generate\-Scalars\-On ()} -\/ Set whether to generate color scalars for the output. By default, the output has no scalars and the color must be set in the property of the actor.  
\item {\ttfamily obj.\-Generate\-Scalars\-Off ()} -\/ Set whether to generate color scalars for the output. By default, the output has no scalars and the color must be set in the property of the actor.  
\item {\ttfamily int = obj.\-Get\-Generate\-Scalars ()} -\/ Set whether to generate color scalars for the output. By default, the output has no scalars and the color must be set in the property of the actor.  
\item {\ttfamily obj.\-Set\-Generate\-Faces (int )} -\/ Set whether to generate polygonal faces for the output. By default, only lines are generated. The faces will form a closed, watertight surface.  
\item {\ttfamily obj.\-Generate\-Faces\-On ()} -\/ Set whether to generate polygonal faces for the output. By default, only lines are generated. The faces will form a closed, watertight surface.  
\item {\ttfamily obj.\-Generate\-Faces\-Off ()} -\/ Set whether to generate polygonal faces for the output. By default, only lines are generated. The faces will form a closed, watertight surface.  
\item {\ttfamily int = obj.\-Get\-Generate\-Faces ()} -\/ Set whether to generate polygonal faces for the output. By default, only lines are generated. The faces will form a closed, watertight surface.  
\item {\ttfamily obj.\-Set\-Color (double , double , double )} -\/ Set the color of the outline. This has no effect unless Generate\-Scalars is On. The default color is red.  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set the color of the outline. This has no effect unless Generate\-Scalars is On. The default color is red.  
\item {\ttfamily double = obj. Get\-Color ()} -\/ Set the color of the outline. This has no effect unless Generate\-Scalars is On. The default color is red.  
\item {\ttfamily obj.\-Set\-Active\-Plane\-Id (int )} -\/ Set the active plane, e.\-g. to display which plane is currently being modified by an interaction. Set this to -\/1 if there is no active plane. The default value is -\/1.  
\item {\ttfamily int = obj.\-Get\-Active\-Plane\-Id ()} -\/ Set the active plane, e.\-g. to display which plane is currently being modified by an interaction. Set this to -\/1 if there is no active plane. The default value is -\/1.  
\item {\ttfamily obj.\-Set\-Active\-Plane\-Color (double , double , double )} -\/ Set the color of the active cropping plane. This has no effect unless Generate\-Scalars is On and Active\-Plane\-Id is non-\/negative. The default color is yellow.  
\item {\ttfamily obj.\-Set\-Active\-Plane\-Color (double a\mbox{[}3\mbox{]})} -\/ Set the color of the active cropping plane. This has no effect unless Generate\-Scalars is On and Active\-Plane\-Id is non-\/negative. The default color is yellow.  
\item {\ttfamily double = obj. Get\-Active\-Plane\-Color ()} -\/ Set the color of the active cropping plane. This has no effect unless Generate\-Scalars is On and Active\-Plane\-Id is non-\/negative. The default color is yellow.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumepicker}{}\section{vtk\-Volume\-Picker}\label{vtkvolumerendering_vtkvolumepicker}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Picker is a subclass of vtk\-Cell\-Picker. It has one advantage over vtk\-Cell\-Picker for volumes\-: it will be able to correctly perform picking when Cropping\-Planes are present. This isn't possible for vtk\-Cell\-Picker since it doesn't link to the Volume\-Rendering classes and hence cannot access information about the Cropping\-Planes.

To create an instance of class vtk\-Volume\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumePicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pick\-Cropping\-Planes (int )} -\/ Set whether to pick the cropping planes of props that have them. If this is set, then the pick will be done on the cropping planes rather than on the data. The Get\-Cropping\-Plane\-Id() method will return the index of the cropping plane of the volume that was picked. This setting is only relevant to the picking of volumes.  
\item {\ttfamily obj.\-Pick\-Cropping\-Planes\-On ()} -\/ Set whether to pick the cropping planes of props that have them. If this is set, then the pick will be done on the cropping planes rather than on the data. The Get\-Cropping\-Plane\-Id() method will return the index of the cropping plane of the volume that was picked. This setting is only relevant to the picking of volumes.  
\item {\ttfamily obj.\-Pick\-Cropping\-Planes\-Off ()} -\/ Set whether to pick the cropping planes of props that have them. If this is set, then the pick will be done on the cropping planes rather than on the data. The Get\-Cropping\-Plane\-Id() method will return the index of the cropping plane of the volume that was picked. This setting is only relevant to the picking of volumes.  
\item {\ttfamily int = obj.\-Get\-Pick\-Cropping\-Planes ()} -\/ Set whether to pick the cropping planes of props that have them. If this is set, then the pick will be done on the cropping planes rather than on the data. The Get\-Cropping\-Plane\-Id() method will return the index of the cropping plane of the volume that was picked. This setting is only relevant to the picking of volumes.  
\item {\ttfamily int = obj.\-Get\-Cropping\-Plane\-Id ()} -\/ Get the index of the cropping plane that the pick ray passed through on its way to the prop. This will be set regardless of whether Pick\-Cropping\-Planes is on. The crop planes are ordered as follows\-: xmin, xmax, ymin, ymax, zmin, zmax. If the volume is not cropped, the value will bet set to -\/1.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumepromapper}{}\section{vtk\-Volume\-Pro\-Mapper}\label{vtkvolumerendering_vtkvolumepromapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Pro\-Mapper is the superclass for Volume\-P\-R\-O volume rendering mappers. Any functionality that is general across all Volume\-P\-R\-O implementations is placed here in this class. Subclasses of this class are for the specific board implementations. Subclasses of that are for underlying graphics languages. Users should not create subclasses directly -\/ a vtk\-Volume\-Pro\-Mapper will automatically create the object of the right type.

If you do not have the Volume\-P\-R\-O libraries when building this object, then the New method will create a default renderer that will not render. You can check the Number\-Of\-Boards ivar to see if it is a real rendering class. To build with the Volume\-P\-R\-O board see vtk\-Volume\-Pro\-V\-P1000\-Mapper.\-h for instructions.

For more information on the Volume\-P\-R\-O hardware, please see\-:

\href{http://www.terarecon.com/products/volumepro_prod.html}{\tt http\-://www.\-terarecon.\-com/products/volumepro\-\_\-prod.\-html}

If you encounter any problems with this class, please inform Kitware, Inc. at \href{mailto:kitware@kitware.com}{\tt kitware@kitware.\-com}.

To create an instance of class vtk\-Volume\-Pro\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeProMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Pro\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Pro\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Pro\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Pro\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer , vtk\-Volume )} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode (int )} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode\-Min\-Value ()} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode\-Max\-Value ()} -\/ Set the blend mode  
\item {\ttfamily int = obj.\-Get\-Blend\-Mode ()} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Composite ()} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Maximum\-Intensity ()} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Blend\-Mode\-To\-Minimum\-Intensity ()} -\/ Set the blend mode  
\item {\ttfamily string = obj.\-Get\-Blend\-Mode\-As\-String (void )} -\/ Set the blend mode  
\item {\ttfamily obj.\-Set\-Sub\-Volume (int , int , int , int , int , int )} -\/ Set the subvolume  
\item {\ttfamily obj.\-Set\-Sub\-Volume (int a\mbox{[}6\mbox{]})} -\/ Set the subvolume  
\item {\ttfamily int = obj. Get\-Sub\-Volume ()} -\/ Set the subvolume  
\item {\ttfamily obj.\-Set\-Cursor (int )} -\/ Turn the cursor on / off  
\item {\ttfamily int = obj.\-Get\-Cursor\-Min\-Value ()} -\/ Turn the cursor on / off  
\item {\ttfamily int = obj.\-Get\-Cursor\-Max\-Value ()} -\/ Turn the cursor on / off  
\item {\ttfamily int = obj.\-Get\-Cursor ()} -\/ Turn the cursor on / off  
\item {\ttfamily obj.\-Cursor\-On ()} -\/ Turn the cursor on / off  
\item {\ttfamily obj.\-Cursor\-Off ()} -\/ Turn the cursor on / off  
\item {\ttfamily obj.\-Set\-Cursor\-Type (int )} -\/ Set the type of the cursor  
\item {\ttfamily int = obj.\-Get\-Cursor\-Type\-Min\-Value ()} -\/ Set the type of the cursor  
\item {\ttfamily int = obj.\-Get\-Cursor\-Type\-Max\-Value ()} -\/ Set the type of the cursor  
\item {\ttfamily int = obj.\-Get\-Cursor\-Type ()} -\/ Set the type of the cursor  
\item {\ttfamily obj.\-Set\-Cursor\-Type\-To\-Cross\-Hair ()} -\/ Set the type of the cursor  
\item {\ttfamily obj.\-Set\-Cursor\-Type\-To\-Plane ()} -\/ Set the type of the cursor  
\item {\ttfamily string = obj.\-Get\-Cursor\-Type\-As\-String (void )} -\/ Set the type of the cursor  
\item {\ttfamily obj.\-Set\-Cursor\-Position (double , double , double )} -\/ Set/\-Get the cursor position  
\item {\ttfamily obj.\-Set\-Cursor\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cursor position  
\item {\ttfamily double = obj. Get\-Cursor\-Position ()} -\/ Set/\-Get the cursor position  
\item {\ttfamily obj.\-Set\-Cursor\-X\-Axis\-Color (double , double , double )} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Cursor\-X\-Axis\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cursor color  
\item {\ttfamily double = obj. Get\-Cursor\-X\-Axis\-Color ()} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Cursor\-Y\-Axis\-Color (double , double , double )} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Cursor\-Y\-Axis\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cursor color  
\item {\ttfamily double = obj. Get\-Cursor\-Y\-Axis\-Color ()} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Cursor\-Z\-Axis\-Color (double , double , double )} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Cursor\-Z\-Axis\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the cursor color  
\item {\ttfamily double = obj. Get\-Cursor\-Z\-Axis\-Color ()} -\/ Set/\-Get the cursor color  
\item {\ttfamily obj.\-Set\-Super\-Sampling (int )} -\/ Turn supersampling on/off  
\item {\ttfamily int = obj.\-Get\-Super\-Sampling\-Min\-Value ()} -\/ Turn supersampling on/off  
\item {\ttfamily int = obj.\-Get\-Super\-Sampling\-Max\-Value ()} -\/ Turn supersampling on/off  
\item {\ttfamily int = obj.\-Get\-Super\-Sampling ()} -\/ Turn supersampling on/off  
\item {\ttfamily obj.\-Super\-Sampling\-On ()} -\/ Turn supersampling on/off  
\item {\ttfamily obj.\-Super\-Sampling\-Off ()} -\/ Turn supersampling on/off  
\item {\ttfamily obj.\-Set\-Super\-Sampling\-Factor (double x, double y, double z)} -\/ Set the supersampling factors  
\item {\ttfamily obj.\-Set\-Super\-Sampling\-Factor (double f\mbox{[}3\mbox{]})} -\/ Set the supersampling factors  
\item {\ttfamily double = obj. Get\-Super\-Sampling\-Factor ()} -\/ Set the supersampling factors  
\item {\ttfamily obj.\-Set\-Cut\-Plane (int )} -\/ Turn on / off the cut plane  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane\-Min\-Value ()} -\/ Turn on / off the cut plane  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane\-Max\-Value ()} -\/ Turn on / off the cut plane  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane ()} -\/ Turn on / off the cut plane  
\item {\ttfamily obj.\-Cut\-Plane\-On ()} -\/ Turn on / off the cut plane  
\item {\ttfamily obj.\-Cut\-Plane\-Off ()} -\/ Turn on / off the cut plane  
\item {\ttfamily obj.\-Set\-Cut\-Plane\-Equation (double , double , double , double )} -\/ Set/\-Get the cut plane equation  
\item {\ttfamily obj.\-Set\-Cut\-Plane\-Equation (double a\mbox{[}4\mbox{]})} -\/ Set/\-Get the cut plane equation  
\item {\ttfamily double = obj. Get\-Cut\-Plane\-Equation ()} -\/ Set/\-Get the cut plane equation  
\item {\ttfamily obj.\-Set\-Cut\-Plane\-Thickness (double )} -\/ Set / Get the cut plane thickness  
\item {\ttfamily double = obj.\-Get\-Cut\-Plane\-Thickness\-Min\-Value ()} -\/ Set / Get the cut plane thickness  
\item {\ttfamily double = obj.\-Get\-Cut\-Plane\-Thickness\-Max\-Value ()} -\/ Set / Get the cut plane thickness  
\item {\ttfamily double = obj.\-Get\-Cut\-Plane\-Thickness ()} -\/ Set / Get the cut plane thickness  
\item {\ttfamily obj.\-Set\-Cut\-Plane\-Fall\-Off\-Distance (int )} -\/ Set / Get the cut plane falloff value for intensities  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane\-Fall\-Off\-Distance\-Min\-Value ()} -\/ Set / Get the cut plane falloff value for intensities  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane\-Fall\-Off\-Distance\-Max\-Value ()} -\/ Set / Get the cut plane falloff value for intensities  
\item {\ttfamily int = obj.\-Get\-Cut\-Plane\-Fall\-Off\-Distance ()} -\/ Set / Get the cut plane falloff value for intensities  
\item {\ttfamily obj.\-Set\-Gradient\-Opacity\-Modulation (int )} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Opacity\-Modulation\-Min\-Value ()} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Opacity\-Modulation\-Max\-Value ()} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Opacity\-Modulation ()} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily obj.\-Gradient\-Opacity\-Modulation\-On ()} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily obj.\-Gradient\-Opacity\-Modulation\-Off ()} -\/ Set/\-Get the gradient magnitude opacity modulation  
\item {\ttfamily obj.\-Set\-Gradient\-Diffuse\-Modulation (int )} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Diffuse\-Modulation\-Min\-Value ()} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Diffuse\-Modulation\-Max\-Value ()} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Diffuse\-Modulation ()} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily obj.\-Gradient\-Diffuse\-Modulation\-On ()} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily obj.\-Gradient\-Diffuse\-Modulation\-Off ()} -\/ Set/\-Get the gradient magnitude diffuse modulation  
\item {\ttfamily obj.\-Set\-Gradient\-Specular\-Modulation (int )} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Specular\-Modulation\-Min\-Value ()} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Specular\-Modulation\-Max\-Value ()} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily int = obj.\-Get\-Gradient\-Specular\-Modulation ()} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily obj.\-Gradient\-Specular\-Modulation\-On ()} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily obj.\-Gradient\-Specular\-Modulation\-Off ()} -\/ Set/\-Get the gradient magnitude specular modulation  
\item {\ttfamily int = obj.\-Get\-No\-Hardware ()} -\/ Conveniece methods for debugging  
\item {\ttfamily int = obj.\-Get\-Wrong\-V\-L\-I\-Version ()} -\/ Conveniece methods for debugging  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Boards ()} -\/ Access methods for some board info  
\item {\ttfamily int = obj.\-Get\-Major\-Board\-Version ()} -\/ Access methods for some board info  
\item {\ttfamily int = obj.\-Get\-Minor\-Board\-Version ()} -\/ Access methods for some board info  
\item {\ttfamily int = obj.\-Get\-Available\-Board\-Memory ()} -\/ Access methods for some board info  
\item {\ttfamily obj.\-Get\-Lock\-Sizes\-For\-Board\-Memory (int , int , int , int )} -\/ Access methods for some board info  
\item {\ttfamily obj.\-Set\-Intermix\-Intersecting\-Geometry (int )} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Min\-Value ()} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Max\-Value ()} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry ()} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-On ()} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-Off ()} -\/ Specify whether any geometry intersects the volume.  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Mipmap\-Levels (int )} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Mipmap\-Levels\-Min\-Value ()} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Mipmap\-Levels\-Max\-Value ()} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Mipmap\-Levels ()} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily obj.\-Auto\-Adjust\-Mipmap\-Levels\-On ()} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily obj.\-Auto\-Adjust\-Mipmap\-Levels\-Off ()} -\/ If set to 1, this mapper will select a mipmap level to use based on the Allocated\-Render\-Time of the volume and the amount of time used by the previous render.  
\item {\ttfamily obj.\-Set\-Minimum\-Mipmap\-Level (int )} -\/ Specify the minimum mipmap level to use -- the highest resolution. Defaults to 0. This is the mipmap level that is used when interaction stops.  
\item {\ttfamily int = obj.\-Get\-Minimum\-Mipmap\-Level\-Min\-Value ()} -\/ Specify the minimum mipmap level to use -- the highest resolution. Defaults to 0. This is the mipmap level that is used when interaction stops.  
\item {\ttfamily int = obj.\-Get\-Minimum\-Mipmap\-Level\-Max\-Value ()} -\/ Specify the minimum mipmap level to use -- the highest resolution. Defaults to 0. This is the mipmap level that is used when interaction stops.  
\item {\ttfamily int = obj.\-Get\-Minimum\-Mipmap\-Level ()} -\/ Specify the minimum mipmap level to use -- the highest resolution. Defaults to 0. This is the mipmap level that is used when interaction stops.  
\item {\ttfamily obj.\-Set\-Maximum\-Mipmap\-Level (int )} -\/ Specify the maximum mipmap level to use -- the lowest resolution. Defaults to 4. It will not help to set the level larger than this unless your volume is very large because for each successive mipmap level, the number of voxels along each axis is cut in half.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Mipmap\-Level\-Min\-Value ()} -\/ Specify the maximum mipmap level to use -- the lowest resolution. Defaults to 4. It will not help to set the level larger than this unless your volume is very large because for each successive mipmap level, the number of voxels along each axis is cut in half.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Mipmap\-Level\-Max\-Value ()} -\/ Specify the maximum mipmap level to use -- the lowest resolution. Defaults to 4. It will not help to set the level larger than this unless your volume is very large because for each successive mipmap level, the number of voxels along each axis is cut in half.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Mipmap\-Level ()} -\/ Specify the maximum mipmap level to use -- the lowest resolution. Defaults to 4. It will not help to set the level larger than this unless your volume is very large because for each successive mipmap level, the number of voxels along each axis is cut in half.  
\item {\ttfamily obj.\-Set\-Mipmap\-Level (int )} -\/ Choose a mipmap level. If Auto\-Adjust\-Mipmap\-Levels is off, then this specifies the mipmap level to use during interaction. If Auto\-Adjust\-Mipmap\-Levels is on, then this specifies the initial mipmap level to use.  
\item {\ttfamily int = obj.\-Get\-Mipmap\-Level\-Min\-Value ()} -\/ Choose a mipmap level. If Auto\-Adjust\-Mipmap\-Levels is off, then this specifies the mipmap level to use during interaction. If Auto\-Adjust\-Mipmap\-Levels is on, then this specifies the initial mipmap level to use.  
\item {\ttfamily int = obj.\-Get\-Mipmap\-Level\-Max\-Value ()} -\/ Choose a mipmap level. If Auto\-Adjust\-Mipmap\-Levels is off, then this specifies the mipmap level to use during interaction. If Auto\-Adjust\-Mipmap\-Levels is on, then this specifies the initial mipmap level to use.  
\item {\ttfamily int = obj.\-Get\-Mipmap\-Level ()} -\/ Choose a mipmap level. If Auto\-Adjust\-Mipmap\-Levels is off, then this specifies the mipmap level to use during interaction. If Auto\-Adjust\-Mipmap\-Levels is on, then this specifies the initial mipmap level to use.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeraycastcompositefunction}{}\section{vtk\-Volume\-Ray\-Cast\-Composite\-Function}\label{vtkvolumerendering_vtkvolumeraycastcompositefunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Ray\-Cast\-Composite\-Function is a ray function that can be used within a vtk\-Volume\-Ray\-Cast\-Mapper. This function performs compositing along the ray according to the properties stored in the vtk\-Volume\-Property for the volume.

To create an instance of class vtk\-Volume\-Ray\-Cast\-Composite\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRayCastCompositeFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Ray\-Cast\-Composite\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Ray\-Cast\-Composite\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Composite\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Composite\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Composite\-Method (int )} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily int = obj.\-Get\-Composite\-Method\-Min\-Value ()} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily int = obj.\-Get\-Composite\-Method\-Max\-Value ()} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily int = obj.\-Get\-Composite\-Method ()} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily obj.\-Set\-Composite\-Method\-To\-Interpolate\-First ()} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily obj.\-Set\-Composite\-Method\-To\-Classify\-First ()} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\item {\ttfamily string = obj.\-Get\-Composite\-Method\-As\-String (void )} -\/ Set the Composite\-Method to either Classify First or Interpolate First  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeraycastfunction}{}\section{vtk\-Volume\-Ray\-Cast\-Function}\label{vtkvolumerendering_vtkvolumeraycastfunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Ray\-Cast\-Function is a superclass for ray casting functions that can be used within a vtk\-Volume\-Ray\-Cast\-Mapper. This includes for example, vtk\-Volume\-Ray\-Cast\-Composite\-Function, vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function, and vtk\-Volume\-Ray\-Cast\-Isosurface\-Function.

To create an instance of class vtk\-Volume\-Ray\-Cast\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRayCastFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Ray\-Cast\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Ray\-Cast\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily float = obj.\-Get\-Zero\-Opacity\-Threshold (vtk\-Volume vol)} -\/ Get the value below which all scalar values are considered to have 0 opacity.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeraycastisosurfacefunction}{}\section{vtk\-Volume\-Ray\-Cast\-Isosurface\-Function}\label{vtkvolumerendering_vtkvolumeraycastisosurfacefunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Ray\-Cast\-Isosurface\-Function is a volume ray cast function that intersects a ray with an analytic isosurface in a scalar field. The color and shading parameters are defined in the vtk\-Volume\-Property of the vtk\-Volume, as well as the interpolation type to use when locating the surface (either a nearest neighbor approach or a tri-\/linear interpolation approach)

To create an instance of class vtk\-Volume\-Ray\-Cast\-Isosurface\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRayCastIsosurfaceFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Ray\-Cast\-Isosurface\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Ray\-Cast\-Isosurface\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Isosurface\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Isosurface\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily float = obj.\-Get\-Zero\-Opacity\-Threshold (vtk\-Volume vol)} -\/ Get the scalar value below which all scalar values have 0 opacity  
\item {\ttfamily obj.\-Set\-Iso\-Value (double )} -\/ Set/\-Get the value of Iso\-Value.  
\item {\ttfamily double = obj.\-Get\-Iso\-Value ()} -\/ Set/\-Get the value of Iso\-Value.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeraycastmapper}{}\section{vtk\-Volume\-Ray\-Cast\-Mapper}\label{vtkvolumerendering_vtkvolumeraycastmapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a software ray caster for rendering volumes in vtk\-Image\-Data.

To create an instance of class vtk\-Volume\-Ray\-Cast\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRayCastMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Ray\-Cast\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Ray\-Cast\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Sample\-Distance (double )} -\/ Set/\-Get the distance between samples. This variable is only used for sampling ray casting methods. Methods that compute a ray value by stepping cell-\/by-\/cell are not affected by this value.  
\item {\ttfamily double = obj.\-Get\-Sample\-Distance ()} -\/ Set/\-Get the distance between samples. This variable is only used for sampling ray casting methods. Methods that compute a ray value by stepping cell-\/by-\/cell are not affected by this value.  
\item {\ttfamily obj.\-Set\-Volume\-Ray\-Cast\-Function (vtk\-Volume\-Ray\-Cast\-Function )} -\/ Get / Set the volume ray cast function. This is used to process values found along the ray to compute a final pixel value.  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-Function = obj.\-Get\-Volume\-Ray\-Cast\-Function ()} -\/ Get / Set the volume ray cast function. This is used to process values found along the ray to compute a final pixel value.  
\item {\ttfamily obj.\-Set\-Gradient\-Estimator (vtk\-Encoded\-Gradient\-Estimator gradest)} -\/ Set / Get the gradient estimator used to estimate normals  
\item {\ttfamily vtk\-Encoded\-Gradient\-Estimator = obj.\-Get\-Gradient\-Estimator ()} -\/ Set / Get the gradient estimator used to estimate normals  
\item {\ttfamily vtk\-Encoded\-Gradient\-Shader = obj.\-Get\-Gradient\-Shader ()} -\/ Get the gradient shader.  
\item {\ttfamily obj.\-Set\-Image\-Sample\-Distance (double )} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily double = obj.\-Get\-Image\-Sample\-Distance\-Min\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily double = obj.\-Get\-Image\-Sample\-Distance\-Max\-Value ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily double = obj.\-Get\-Image\-Sample\-Distance ()} -\/ Sampling distance in the X\-Y image dimensions. Default value of 1 meaning 1 ray cast per pixel. If set to 0.\-5, 4 rays will be cast per pixel. If set to 2.\-0, 1 ray will be cast for every 4 (2 by 2) pixels.  
\item {\ttfamily obj.\-Set\-Minimum\-Image\-Sample\-Distance (double )} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Minimum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Minimum\-Image\-Sample\-Distance ()} -\/ This is the minimum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Maximum\-Image\-Sample\-Distance (double )} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Min\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Maximum\-Image\-Sample\-Distance\-Max\-Value ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily double = obj.\-Get\-Maximum\-Image\-Sample\-Distance ()} -\/ This is the maximum image sample distance allow when the image sample distance is being automatically adjusted  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Sample\-Distances (int )} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Min\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances\-Max\-Value ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Sample\-Distances ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-On ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Auto\-Adjust\-Sample\-Distances\-Off ()} -\/ If Auto\-Adjust\-Sample\-Distances is on, the the Image\-Sample\-Distance will be varied to achieve the allocated render time of this prop (controlled by the desired update rate and any culling in use).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int num)} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Set/\-Get the number of threads to use. This by default is equal to the number of available processors detected.  
\item {\ttfamily obj.\-Set\-Intermix\-Intersecting\-Geometry (int )} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Min\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry\-Max\-Value ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily int = obj.\-Get\-Intermix\-Intersecting\-Geometry ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-On ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\item {\ttfamily obj.\-Intermix\-Intersecting\-Geometry\-Off ()} -\/ If Intermix\-Intersecting\-Geometry is turned on, the zbuffer will be captured and used to limit the traversal of the rays.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumeraycastmipfunction}{}\section{vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function}\label{vtkvolumerendering_vtkvolumeraycastmipfunction}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function is a volume ray cast function that computes the maximum value encountered along the ray. This is either the maximum scalar value, or the maximum opacity, as defined by the Maximize\-Method. The color and opacity returned by this function is based on the color, scalar opacity, and gradient opacity transfer functions defined in the vtk\-Volume\-Property of the vtk\-Volume.

To create an instance of class vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRayCastMIPFunction
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Ray\-Cast\-M\-I\-P\-Function = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily float = obj.\-Get\-Zero\-Opacity\-Threshold (vtk\-Volume vol)} -\/ Get the scalar value below which all scalar values have zero opacity.  
\item {\ttfamily obj.\-Set\-Maximize\-Method (int )} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily int = obj.\-Get\-Maximize\-Method\-Min\-Value ()} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily int = obj.\-Get\-Maximize\-Method\-Max\-Value ()} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily int = obj.\-Get\-Maximize\-Method ()} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily obj.\-Set\-Maximize\-Method\-To\-Scalar\-Value ()} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily obj.\-Set\-Maximize\-Method\-To\-Opacity ()} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\item {\ttfamily string = obj.\-Get\-Maximize\-Method\-As\-String (void )} -\/ Set the Maximize\-Method to either Scalar\-Value or Opacity.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumerenderingfactory}{}\section{vtk\-Volume\-Rendering\-Factory}\label{vtkvolumerendering_vtkvolumerenderingfactory}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Volume\-Rendering\-Factory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeRenderingFactory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Rendering\-Factory has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Rendering\-Factory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Rendering\-Factory = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Rendering\-Factory = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumetexturemapper}{}\section{vtk\-Volume\-Texture\-Mapper}\label{vtkvolumerendering_vtkvolumetexturemapper}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Texture\-Mapper is the abstract definition of a volume mapper that uses a texture mapping approach.

To create an instance of class vtk\-Volume\-Texture\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeTextureMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Texture\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Texture\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Update ()} -\/ Update the volume rendering pipeline by updating the scalar input  
\item {\ttfamily obj.\-Set\-Gradient\-Estimator (vtk\-Encoded\-Gradient\-Estimator gradest)} -\/ Set / Get the gradient estimator used to estimate normals  
\item {\ttfamily vtk\-Encoded\-Gradient\-Estimator = obj.\-Get\-Gradient\-Estimator ()} -\/ Set / Get the gradient estimator used to estimate normals  
\item {\ttfamily vtk\-Encoded\-Gradient\-Shader = obj.\-Get\-Gradient\-Shader ()} -\/ Get the gradient shader.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumetexturemapper2d}{}\section{vtk\-Volume\-Texture\-Mapper2\-D}\label{vtkvolumerendering_vtkvolumetexturemapper2d}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Texture\-Mapper2\-D renders a volume using 2\-D texture mapping.

To create an instance of class vtk\-Volume\-Texture\-Mapper2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeTextureMapper2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Texture\-Mapper2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Texture\-Mapper2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Target\-Texture\-Size (int , int )} -\/ Target size in pixels of each size of the texture for downloading. Default is 512x512 -\/ so a 512x512 texture will be tiled with as many slices of the volume as possible, then all the quads will be rendered. This can be set to optimize for a particular architecture. This must be set with numbers that are a power of two.  
\item {\ttfamily obj.\-Set\-Target\-Texture\-Size (int a\mbox{[}2\mbox{]})} -\/ Target size in pixels of each size of the texture for downloading. Default is 512x512 -\/ so a 512x512 texture will be tiled with as many slices of the volume as possible, then all the quads will be rendered. This can be set to optimize for a particular architecture. This must be set with numbers that are a power of two.  
\item {\ttfamily int = obj. Get\-Target\-Texture\-Size ()} -\/ Target size in pixels of each size of the texture for downloading. Default is 512x512 -\/ so a 512x512 texture will be tiled with as many slices of the volume as possible, then all the quads will be rendered. This can be set to optimize for a particular architecture. This must be set with numbers that are a power of two.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Planes (int )} -\/ This is the maximum number of planes that will be created for texture mapping the volume. If the volume has more voxels than this along the viewing direction, then planes of the volume will be skipped to ensure that this maximum is not violated. A skip factor is used, and is incremented until the maximum condition is satisfied.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Planes ()} -\/ This is the maximum number of planes that will be created for texture mapping the volume. If the volume has more voxels than this along the viewing direction, then planes of the volume will be skipped to ensure that this maximum is not violated. A skip factor is used, and is incremented until the maximum condition is satisfied.  
\item {\ttfamily obj.\-Set\-Maximum\-Storage\-Size (int )} -\/ This is the maximum size of saved textures in bytes. If this size is large enough to hold the R\-G\-B\-A textures for all three directions (Xx\-Yx\-Zx3x4 is the approximate value -\/ it is actually a bit larger due to wasted space in the textures) then the textures will be saved.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Storage\-Size ()} -\/ This is the maximum size of saved textures in bytes. If this size is large enough to hold the R\-G\-B\-A textures for all three directions (Xx\-Yx\-Zx3x4 is the approximate value -\/ it is actually a bit larger due to wasted space in the textures) then the textures will be saved.  
\end{DoxyItemize}\hypertarget{vtkvolumerendering_vtkvolumetexturemapper3d}{}\section{vtk\-Volume\-Texture\-Mapper3\-D}\label{vtkvolumerendering_vtkvolumetexturemapper3d}
Section\-: \hyperlink{sec_vtkvolumerendering}{Visualization Toolkit Volume Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Texture\-Mapper3\-D renders a volume using 3\-D texture mapping. This class is actually an abstract superclass -\/ with all the actual work done by vtk\-Open\-G\-L\-Volume\-Texture\-Mapper3\-D.

This mappers currently supports\-:


\begin{DoxyItemize}
\item any data type as input
\item one component, or two or four non-\/independent components
\item composite blending
\item intermixed opaque geometry
\item multiple volumes can be rendered if they can be sorted into back-\/to-\/front order (use the vtk\-Frustum\-Coverage\-Culler)
\end{DoxyItemize}

This mapper does not support\-:
\begin{DoxyItemize}
\item more than one independent component
\item maximum intensity projection
\end{DoxyItemize}

Internally, this mapper will potentially change the resolution of the input data. The data will be resampled to be a power of two in each direction, and also no greater than 128$\ast$256$\ast$256 voxels (any aspect) for one or two component data, or 128$\ast$128$\ast$256 voxels (any aspect) for four component data. The limits are currently hardcoded after a check using the G\-L\-\_\-\-P\-R\-O\-X\-Y\-\_\-\-T\-E\-X\-T\-U\-R\-E3\-D because some graphics drivers were always responding \char`\"{}yes\char`\"{} to the proxy call despite not being able to allocate that much texture memory.

Currently, calculations are computed using 8 bits per R\-G\-B\-A channel. In the future this should be expanded to handle newer boards that can support 15 bit float compositing.

This mapper supports two main families of graphics hardware\-: nvidia and A\-T\-I. There are two different implementations of 3\-D texture mapping used -\/ one based on nvidia's G\-L\-\_\-\-N\-V\-\_\-texture\-\_\-shader2 and G\-L\-\_\-\-N\-V\-\_\-register\-\_\-combiners2 extension, and one based on A\-T\-I's G\-L\-\_\-\-A\-T\-I\-\_\-fragment\-\_\-shader (supported also by some nvidia boards) To use this class in an application that will run on various hardware configurations, you should have a back-\/up volume rendering method. You should create a vtk\-Volume\-Texture\-Mapper3\-D, assign its input, make sure you have a current Open\-G\-L context (you've rendered at least once), then call Is\-Render\-Supported with a vtk\-Volume\-Property as an argument. This method will return 0 if the input has more than one independent component, or if the graphics hardware does not support the set of required extensions for using at least one of the two implemented methods (nvidia or ati)

.S\-E\-C\-T\-I\-O\-N Thanks Thanks to Alexandre Gouaillard at the Megason Lab, Department of Systems Biology, Harvard Medical School \href{https://wiki.med.harvard.edu/SysBio/Megason/}{\tt https\-://wiki.\-med.\-harvard.\-edu/\-Sys\-Bio/\-Megason/} for the idea and initial patch to speed-\/up rendering with compressed textures.

To create an instance of class vtk\-Volume\-Texture\-Mapper3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeTextureMapper3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Texture\-Mapper3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Texture\-Mapper3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Texture\-Mapper3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Sample\-Distance (float )} -\/ The distance at which to space sampling planes. This may not be honored for interactive renders. An interactive render is defined as one that has less than 1 second of allocated render time.  
\item {\ttfamily float = obj.\-Get\-Sample\-Distance ()} -\/ The distance at which to space sampling planes. This may not be honored for interactive renders. An interactive render is defined as one that has less than 1 second of allocated render time.  
\item {\ttfamily int = obj. Get\-Volume\-Dimensions ()} -\/ These are the dimensions of the 3\-D texture  
\item {\ttfamily float = obj. Get\-Volume\-Spacing ()} -\/ This is the spacing of the 3\-D texture  
\item {\ttfamily int = obj.\-Is\-Render\-Supported (vtk\-Volume\-Property )} -\/ Based on hardware and properties, we may or may not be able to render using 3\-D texture mapping. This indicates if 3\-D texture mapping is supported by the hardware, and if the other extensions necessary to support the specific properties are available.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Polygons ()} -\/ Allow access to the number of polygons used for the rendering.  
\item {\ttfamily float = obj.\-Get\-Actual\-Sample\-Distance ()} -\/ Allow access to the actual sample distance used to render the image.  
\item {\ttfamily obj.\-Set\-Preferred\-Render\-Method (int )} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily int = obj.\-Get\-Preferred\-Render\-Method\-Min\-Value ()} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily int = obj.\-Get\-Preferred\-Render\-Method\-Max\-Value ()} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily obj.\-Set\-Preferred\-Method\-To\-Fragment\-Program ()} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily obj.\-Set\-Preferred\-Method\-To\-N\-Vidia ()} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily int = obj.\-Get\-Preferred\-Render\-Method ()} -\/ Set the preferred render method. If it is supported, this one will be used. Don't allow A\-T\-I\-\_\-\-M\-E\-T\-H\-O\-D -\/ it is not actually supported.  
\item {\ttfamily obj.\-Set\-Use\-Compressed\-Texture (bool )} -\/ Set/\-Get if the mapper use compressed textures (if supported by the hardware). Initial value is false. There are two reasons to use compressed textures\-: 1. rendering can be 4 times faster. 2. It saves some V\-R\-A\-M. There is one reason to not use compressed textures\-: quality may be lower than with uncompressed textures.  
\item {\ttfamily bool = obj.\-Get\-Use\-Compressed\-Texture ()} -\/ Set/\-Get if the mapper use compressed textures (if supported by the hardware). Initial value is false. There are two reasons to use compressed textures\-: 1. rendering can be 4 times faster. 2. It saves some V\-R\-A\-M. There is one reason to not use compressed textures\-: quality may be lower than with uncompressed textures.  
\end{DoxyItemize}