
\begin{DoxyItemize}
\item \hyperlink{vtkhybrid_vtk3dsimporter}{vtk3\-D\-S\-Importer}  
\item \hyperlink{vtkhybrid_vtkannotatedcubeactor}{vtk\-Annotated\-Cube\-Actor}  
\item \hyperlink{vtkhybrid_vtkarcplotter}{vtk\-Arc\-Plotter}  
\item \hyperlink{vtkhybrid_vtkaxesactor}{vtk\-Axes\-Actor}  
\item \hyperlink{vtkhybrid_vtkaxisactor}{vtk\-Axis\-Actor}  
\item \hyperlink{vtkhybrid_vtkbarchartactor}{vtk\-Bar\-Chart\-Actor}  
\item \hyperlink{vtkhybrid_vtkcaptionactor2d}{vtk\-Caption\-Actor2\-D}  
\item \hyperlink{vtkhybrid_vtkcornerannotation}{vtk\-Corner\-Annotation}  
\item \hyperlink{vtkhybrid_vtkcubeaxesactor}{vtk\-Cube\-Axes\-Actor}  
\item \hyperlink{vtkhybrid_vtkcubeaxesactor2d}{vtk\-Cube\-Axes\-Actor2\-D}  
\item \hyperlink{vtkhybrid_vtkdepthsortpolydata}{vtk\-Depth\-Sort\-Poly\-Data}  
\item \hyperlink{vtkhybrid_vtkdspfilterdefinition}{vtk\-D\-S\-P\-Filter\-Definition}  
\item \hyperlink{vtkhybrid_vtkdspfiltergroup}{vtk\-D\-S\-P\-Filter\-Group}  
\item \hyperlink{vtkhybrid_vtkearthsource}{vtk\-Earth\-Source}  
\item \hyperlink{vtkhybrid_vtkexodusiireader}{vtk\-Exodus\-I\-I\-Reader}  
\item \hyperlink{vtkhybrid_vtkexodusmodel}{vtk\-Exodus\-Model}  
\item \hyperlink{vtkhybrid_vtkexodusreader}{vtk\-Exodus\-Reader}  
\item \hyperlink{vtkhybrid_vtkfacetreader}{vtk\-Facet\-Reader}  
\item \hyperlink{vtkhybrid_vtkgreedyterraindecimation}{vtk\-Greedy\-Terrain\-Decimation}  
\item \hyperlink{vtkhybrid_vtkgridtransform}{vtk\-Grid\-Transform}  
\item \hyperlink{vtkhybrid_vtkimagedatalic2d}{vtk\-Image\-Data\-L\-I\-C2\-D}  
\item \hyperlink{vtkhybrid_vtkimagedatalic2dextenttranslator}{vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator}  
\item \hyperlink{vtkhybrid_vtkimagetopolydatafilter}{vtk\-Image\-To\-Poly\-Data\-Filter}  
\item \hyperlink{vtkhybrid_vtkimplicitmodeller}{vtk\-Implicit\-Modeller}  
\item \hyperlink{vtkhybrid_vtkiterativeclosestpointtransform}{vtk\-Iterative\-Closest\-Point\-Transform}  
\item \hyperlink{vtkhybrid_vtklandmarktransform}{vtk\-Landmark\-Transform}  
\item \hyperlink{vtkhybrid_vtklegendboxactor}{vtk\-Legend\-Box\-Actor}  
\item \hyperlink{vtkhybrid_vtklegendscaleactor}{vtk\-Legend\-Scale\-Actor}  
\item \hyperlink{vtkhybrid_vtklsdynareader}{vtk\-L\-S\-Dyna\-Reader}  
\item \hyperlink{vtkhybrid_vtkpcaanalysisfilter}{vtk\-P\-C\-A\-Analysis\-Filter}  
\item \hyperlink{vtkhybrid_vtkpexodusiireader}{vtk\-P\-Exodus\-I\-I\-Reader}  
\item \hyperlink{vtkhybrid_vtkpexodusreader}{vtk\-P\-Exodus\-Reader}  
\item \hyperlink{vtkhybrid_vtkpiechartactor}{vtk\-Pie\-Chart\-Actor}  
\item \hyperlink{vtkhybrid_vtkpolydatasilhouette}{vtk\-Poly\-Data\-Silhouette}  
\item \hyperlink{vtkhybrid_vtkpolydatatoimagestencil}{vtk\-Poly\-Data\-To\-Image\-Stencil}  
\item \hyperlink{vtkhybrid_vtkprocrustesalignmentfilter}{vtk\-Procrustes\-Alignment\-Filter}  
\item \hyperlink{vtkhybrid_vtkprojectedterrainpath}{vtk\-Projected\-Terrain\-Path}  
\item \hyperlink{vtkhybrid_vtkrenderlargeimage}{vtk\-Render\-Large\-Image}  
\item \hyperlink{vtkhybrid_vtkribexporter}{vtk\-R\-I\-B\-Exporter}  
\item \hyperlink{vtkhybrid_vtkriblight}{vtk\-R\-I\-B\-Light}  
\item \hyperlink{vtkhybrid_vtkribproperty}{vtk\-R\-I\-B\-Property}  
\item \hyperlink{vtkhybrid_vtkspiderplotactor}{vtk\-Spider\-Plot\-Actor}  
\item \hyperlink{vtkhybrid_vtkstructuredextent}{vtk\-Structured\-Extent}  
\item \hyperlink{vtkhybrid_vtktemporaldatasetcache}{vtk\-Temporal\-Data\-Set\-Cache}  
\item \hyperlink{vtkhybrid_vtktemporalinterpolator}{vtk\-Temporal\-Interpolator}  
\item \hyperlink{vtkhybrid_vtktemporalshiftscale}{vtk\-Temporal\-Shift\-Scale}  
\item \hyperlink{vtkhybrid_vtktemporalsnaptotimestep}{vtk\-Temporal\-Snap\-To\-Time\-Step}  
\item \hyperlink{vtkhybrid_vtkthinplatesplinetransform}{vtk\-Thin\-Plate\-Spline\-Transform}  
\item \hyperlink{vtkhybrid_vtktransformtogrid}{vtk\-Transform\-To\-Grid}  
\item \hyperlink{vtkhybrid_vtkvectortext}{vtk\-Vector\-Text}  
\item \hyperlink{vtkhybrid_vtkvideosource}{vtk\-Video\-Source}  
\item \hyperlink{vtkhybrid_vtkvrmlimporter}{vtk\-V\-R\-M\-L\-Importer}  
\item \hyperlink{vtkhybrid_vtkweightedtransformfilter}{vtk\-Weighted\-Transform\-Filter}  
\item \hyperlink{vtkhybrid_vtkx3dexporter}{vtk\-X3\-D\-Exporter}  
\item \hyperlink{vtkhybrid_vtkxyplotactor}{vtk\-X\-Y\-Plot\-Actor}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtk3dsimporter}{}\section{vtk3\-D\-S\-Importer}\label{vtkhybrid_vtk3dsimporter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk3\-D\-S\-Importer imports 3\-D Studio files into vtk.

To create an instance of class vtk3\-D\-S\-Importer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtk3DSImporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk3\-D\-S\-Importer 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 vtk3\-D\-S\-Importer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk3\-D\-S\-Importer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk3\-D\-S\-Importer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the name of the file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the name of the file to read.  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Set/\-Get the computation of normals. If on, imported geometry will be run through vtk\-Poly\-Data\-Normals.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Set/\-Get the computation of normals. If on, imported geometry will be run through vtk\-Poly\-Data\-Normals.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Set/\-Get the computation of normals. If on, imported geometry will be run through vtk\-Poly\-Data\-Normals.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Set/\-Get the computation of normals. If on, imported geometry will be run through vtk\-Poly\-Data\-Normals.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkannotatedcubeactor}{}\section{vtk\-Annotated\-Cube\-Actor}\label{vtkhybrid_vtkannotatedcubeactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Annotated\-Cube\-Actor is a hybrid 3\-D actor used to represent an anatomical orientation marker in a scene. The class consists of a 3\-D unit cube centered on the origin with each face labelled in correspondance to a particular coordinate direction. For example, with Cartesian directions, the user defined text labels could be\-: +\-X, -\/\-X, +\-Y, -\/\-Y, +\-Z, -\/\-Z, while for anatomical directions\-: A, P, L, R, S, I. Text is automatically centered on each cube face and is not restriceted to single characters. In addition to or in replace of a solid text label representation, the outline edges of the labels can be displayed. The individual properties of the cube, face labels and text outlines can be manipulated as can their visibility.

To create an instance of class vtk\-Annotated\-Cube\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAnnotatedCubeActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Annotated\-Cube\-Actor 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\-Annotated\-Cube\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Annotated\-Cube\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Annotated\-Cube\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ For some exporters and other other operations we must be able to collect all the actors or volumes. These methods are used in that process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an axes actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax). (The method Get\-Bounds(double bounds\mbox{[}6\mbox{]}) is available from the superclass.)  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax). (The method Get\-Bounds(double bounds\mbox{[}6\mbox{]}) is available from the superclass.)  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the actors mtime plus consider its properties and texture if set.  
\item {\ttfamily obj.\-Set\-Face\-Text\-Scale (double )} -\/ Set/\-Get the scale factor for the face text  
\item {\ttfamily double = obj.\-Get\-Face\-Text\-Scale ()} -\/ Set/\-Get the scale factor for the face text  
\item {\ttfamily vtk\-Property = obj.\-Get\-X\-Plus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-X\-Minus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Y\-Plus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Y\-Minus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Z\-Plus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Z\-Minus\-Face\-Property ()} -\/ Get the individual face text properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Cube\-Property ()} -\/ Get the cube properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Text\-Edges\-Property ()} -\/ Get the text edges properties.  
\item {\ttfamily obj.\-Set\-X\-Plus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-X\-Plus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-X\-Minus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-X\-Minus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-Y\-Plus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-Y\-Plus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-Y\-Minus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-Y\-Minus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-Z\-Plus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-Z\-Plus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-Z\-Minus\-Face\-Text (string )} -\/ Set/get the face text.  
\item {\ttfamily string = obj.\-Get\-Z\-Minus\-Face\-Text ()} -\/ Set/get the face text.  
\item {\ttfamily obj.\-Set\-Text\-Edges\-Visibility (int )} -\/ Enable/disable drawing the vector text edges.  
\item {\ttfamily int = obj.\-Get\-Text\-Edges\-Visibility ()} -\/ Enable/disable drawing the vector text edges.  
\item {\ttfamily obj.\-Set\-Cube\-Visibility (int )} -\/ Enable/disable drawing the cube.  
\item {\ttfamily int = obj.\-Get\-Cube\-Visibility ()} -\/ Enable/disable drawing the cube.  
\item {\ttfamily obj.\-Set\-Face\-Text\-Visibility (int )} -\/ Enable/disable drawing the vector text.  
\item {\ttfamily int = obj.\-Get\-Face\-Text\-Visibility ()} -\/ Enable/disable drawing the vector text.  
\item {\ttfamily obj.\-Set\-X\-Face\-Text\-Rotation (double )} -\/ Augment individual face text orientations.  
\item {\ttfamily double = obj.\-Get\-X\-Face\-Text\-Rotation ()} -\/ Augment individual face text orientations.  
\item {\ttfamily obj.\-Set\-Y\-Face\-Text\-Rotation (double )} -\/ Augment individual face text orientations.  
\item {\ttfamily double = obj.\-Get\-Y\-Face\-Text\-Rotation ()} -\/ Augment individual face text orientations.  
\item {\ttfamily obj.\-Set\-Z\-Face\-Text\-Rotation (double )} -\/ Augment individual face text orientations.  
\item {\ttfamily double = obj.\-Get\-Z\-Face\-Text\-Rotation ()} -\/ Augment individual face text orientations.  
\item {\ttfamily vtk\-Assembly = obj.\-Get\-Assembly ()}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkarcplotter}{}\section{vtk\-Arc\-Plotter}\label{vtkhybrid_vtkarcplotter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Arc\-Plotter performs plotting of attribute data along polylines defined with an input vtk\-Poly\-Data data object. Any type of attribute data can be plotted including scalars, vectors, tensors, normals, texture coordinates, and field data. Either one or multiple data components can be plotted.

To use this class you must specify an input data set that contains one or more polylines, and some attribute data including which component of the attribute data. (By default, this class processes the first component of scalar data.) You will also need to set an offset radius (the distance of the polyline to the median line of the plot), a width for the plot (the distance that the minimum and maximum plot values are mapped into), an possibly an offset (used to offset attribute data with multiple components).

Normally the filter automatically computes normals for generating the offset arc plot. However, you can specify a default normal and use that instead.

To create an instance of class vtk\-Arc\-Plotter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkArcPlotter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Arc\-Plotter 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\-Arc\-Plotter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Arc\-Plotter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Arc\-Plotter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Specify a camera used to orient the plot along the arc. If no camera is specified, then the orientation of the plot is arbitrary.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Specify a camera used to orient the plot along the arc. If no camera is specified, then the orientation of the plot is arbitrary.  
\item {\ttfamily obj.\-Set\-Plot\-Mode (int )} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily int = obj.\-Get\-Plot\-Mode ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-Scalars ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-Vectors ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-Normals ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-T\-Coords ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-Tensors ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Mode\-To\-Plot\-Field\-Data ()} -\/ Specify which data to plot\-: scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Plot\-Component to control which component to plot.  
\item {\ttfamily obj.\-Set\-Plot\-Component (int )} -\/ Set/\-Get the component number to plot if the data has more than one component. If the value of the plot component is == (-\/1), then all the components will be plotted.  
\item {\ttfamily int = obj.\-Get\-Plot\-Component ()} -\/ Set/\-Get the component number to plot if the data has more than one component. If the value of the plot component is == (-\/1), then all the components will be plotted.  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set the radius of the \char`\"{}median\char`\"{} value of the first plotted component.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set the radius of the \char`\"{}median\char`\"{} value of the first plotted component.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set the radius of the \char`\"{}median\char`\"{} value of the first plotted component.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set the radius of the \char`\"{}median\char`\"{} value of the first plotted component.  
\item {\ttfamily obj.\-Set\-Height (double )} -\/ Set the height of the plot. (The radius combined with the height define the location of the plot relative to the generating polyline.)  
\item {\ttfamily double = obj.\-Get\-Height\-Min\-Value ()} -\/ Set the height of the plot. (The radius combined with the height define the location of the plot relative to the generating polyline.)  
\item {\ttfamily double = obj.\-Get\-Height\-Max\-Value ()} -\/ Set the height of the plot. (The radius combined with the height define the location of the plot relative to the generating polyline.)  
\item {\ttfamily double = obj.\-Get\-Height ()} -\/ Set the height of the plot. (The radius combined with the height define the location of the plot relative to the generating polyline.)  
\item {\ttfamily obj.\-Set\-Offset (double )} -\/ Specify an offset that translates each subsequent plot (if there is more than one component plotted) from the defining arc (i.\-e., polyline).  
\item {\ttfamily double = obj.\-Get\-Offset\-Min\-Value ()} -\/ Specify an offset that translates each subsequent plot (if there is more than one component plotted) from the defining arc (i.\-e., polyline).  
\item {\ttfamily double = obj.\-Get\-Offset\-Max\-Value ()} -\/ Specify an offset that translates each subsequent plot (if there is more than one component plotted) from the defining arc (i.\-e., polyline).  
\item {\ttfamily double = obj.\-Get\-Offset ()} -\/ Specify an offset that translates each subsequent plot (if there is more than one component plotted) from the defining arc (i.\-e., polyline).  
\item {\ttfamily obj.\-Set\-Use\-Default\-Normal (int )} -\/ Set a boolean to control whether to use default normals. By default, normals are automatically computed from the generating polyline and camera.  
\item {\ttfamily int = obj.\-Get\-Use\-Default\-Normal ()} -\/ Set a boolean to control whether to use default normals. By default, normals are automatically computed from the generating polyline and camera.  
\item {\ttfamily obj.\-Use\-Default\-Normal\-On ()} -\/ Set a boolean to control whether to use default normals. By default, normals are automatically computed from the generating polyline and camera.  
\item {\ttfamily obj.\-Use\-Default\-Normal\-Off ()} -\/ Set a boolean to control whether to use default normals. By default, normals are automatically computed from the generating polyline and camera.  
\item {\ttfamily obj.\-Set\-Default\-Normal (float , float , float )} -\/ Set the default normal to use if you do not wish automatic normal calculation. The arc plot will be generated using this normal.  
\item {\ttfamily obj.\-Set\-Default\-Normal (float a\mbox{[}3\mbox{]})} -\/ Set the default normal to use if you do not wish automatic normal calculation. The arc plot will be generated using this normal.  
\item {\ttfamily float = obj. Get\-Default\-Normal ()} -\/ Set the default normal to use if you do not wish automatic normal calculation. The arc plot will be generated using this normal.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Array (int )} -\/ Set/\-Get the field data array to plot. This instance variable is only applicable if field data is plotted.  
\item {\ttfamily int = obj.\-Get\-Field\-Data\-Array\-Min\-Value ()} -\/ Set/\-Get the field data array to plot. This instance variable is only applicable if field data is plotted.  
\item {\ttfamily int = obj.\-Get\-Field\-Data\-Array\-Max\-Value ()} -\/ Set/\-Get the field data array to plot. This instance variable is only applicable if field data is plotted.  
\item {\ttfamily int = obj.\-Get\-Field\-Data\-Array ()} -\/ Set/\-Get the field data array to plot. This instance variable is only applicable if field data is plotted.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ New Get\-M\-Time because of camera dependency.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkaxesactor}{}\section{vtk\-Axes\-Actor}\label{vtkhybrid_vtkaxesactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Axes\-Actor is a hybrid 2\-D/3\-D actor used to represent 3\-D axes in a scene. The user can define the geometry to use for the shaft or the tip, and the user can set the text for the three axes. The text will appear to follow the camera since it is implemented by means of vtk\-Caption\-Actor2\-D. All of the functionality of the underlying vtk\-Caption\-Actor2\-D objects are accessable so that, for instance, the font attributes of the axes text can be manipulated through vtk\-Text\-Property. Since this class inherits from vtk\-Prop3\-D, one can apply a user transform to the underlying geometry and the positioning of the labels. For example, a rotation transform could be used to generate a left-\/handed axes representation.

To create an instance of class vtk\-Axes\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAxesActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Axes\-Actor 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\-Axes\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Axes\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Axes\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ For some exporters and other other operations we must be able to collect all the actors or volumes. These methods are used in that process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an axes actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax). (The method Get\-Bounds(double bounds\mbox{[}6\mbox{]}) is available from the superclass.)  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax). (The method Get\-Bounds(double bounds\mbox{[}6\mbox{]}) is available from the superclass.)  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the actors mtime plus consider its properties and texture if set.  
\item {\ttfamily long = obj.\-Get\-Redraw\-M\-Time ()} -\/ Return the mtime of anything that would cause the rendered image to appear differently. Usually this involves checking the mtime of the prop plus anything else it depends on such as properties, textures etc.  
\item {\ttfamily obj.\-Set\-Total\-Length (double v\mbox{[}3\mbox{]})} -\/ Set the total length of the axes in 3 dimensions.  
\item {\ttfamily obj.\-Set\-Total\-Length (double x, double y, double z)} -\/ Set the total length of the axes in 3 dimensions.  
\item {\ttfamily double = obj. Get\-Total\-Length ()} -\/ Set the total length of the axes in 3 dimensions.  
\item {\ttfamily obj.\-Set\-Normalized\-Shaft\-Length (double v\mbox{[}3\mbox{]})} -\/ Set the normalized (0-\/1) length of the shaft.  
\item {\ttfamily obj.\-Set\-Normalized\-Shaft\-Length (double x, double y, double z)} -\/ Set the normalized (0-\/1) length of the shaft.  
\item {\ttfamily double = obj. Get\-Normalized\-Shaft\-Length ()} -\/ Set the normalized (0-\/1) length of the shaft.  
\item {\ttfamily obj.\-Set\-Normalized\-Tip\-Length (double v\mbox{[}3\mbox{]})} -\/ Set the normalized (0-\/1) length of the tip. Normally, this would be 1 -\/ the normalized length of the shaft.  
\item {\ttfamily obj.\-Set\-Normalized\-Tip\-Length (double x, double y, double z)} -\/ Set the normalized (0-\/1) length of the tip. Normally, this would be 1 -\/ the normalized length of the shaft.  
\item {\ttfamily double = obj. Get\-Normalized\-Tip\-Length ()} -\/ Set the normalized (0-\/1) length of the tip. Normally, this would be 1 -\/ the normalized length of the shaft.  
\item {\ttfamily obj.\-Set\-Normalized\-Label\-Position (double v\mbox{[}3\mbox{]})} -\/ Set the normalized (0-\/1) position of the label along the length of the shaft. A value $>$ 1 is permissible.  
\item {\ttfamily obj.\-Set\-Normalized\-Label\-Position (double x, double y, double z)} -\/ Set the normalized (0-\/1) position of the label along the length of the shaft. A value $>$ 1 is permissible.  
\item {\ttfamily double = obj. Get\-Normalized\-Label\-Position ()} -\/ Set the normalized (0-\/1) position of the label along the length of the shaft. A value $>$ 1 is permissible.  
\item {\ttfamily obj.\-Set\-Cone\-Resolution (int )} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cone\-Resolution\-Min\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cone\-Resolution\-Max\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cone\-Resolution ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Sphere\-Resolution (int )} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Sphere\-Resolution\-Min\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Sphere\-Resolution\-Max\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Sphere\-Resolution ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Cylinder\-Resolution (int )} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cylinder\-Resolution\-Min\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cylinder\-Resolution\-Max\-Value ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily int = obj.\-Get\-Cylinder\-Resolution ()} -\/ Set/get the resolution of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Cone\-Radius (double )} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cone\-Radius\-Min\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cone\-Radius\-Max\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cone\-Radius ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Sphere\-Radius (double )} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Sphere\-Radius\-Min\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Sphere\-Radius\-Max\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Sphere\-Radius ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Cylinder\-Radius (double )} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cylinder\-Radius\-Min\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cylinder\-Radius\-Max\-Value ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily double = obj.\-Get\-Cylinder\-Radius ()} -\/ Set/get the radius of the pieces of the axes actor.  
\item {\ttfamily obj.\-Set\-Shaft\-Type (int type)} -\/ Set the type of the shaft to a cylinder, line, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Shaft\-Type\-To\-Cylinder ()} -\/ Set the type of the shaft to a cylinder, line, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Shaft\-Type\-To\-Line ()} -\/ Set the type of the shaft to a cylinder, line, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Shaft\-Type\-To\-User\-Defined ()} -\/ Set the type of the shaft to a cylinder, line, or user defined geometry.  
\item {\ttfamily int = obj.\-Get\-Shaft\-Type ()} -\/ Set the type of the shaft to a cylinder, line, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Tip\-Type (int type)} -\/ Set the type of the tip to a cone, sphere, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Tip\-Type\-To\-Cone ()} -\/ Set the type of the tip to a cone, sphere, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Tip\-Type\-To\-Sphere ()} -\/ Set the type of the tip to a cone, sphere, or user defined geometry.  
\item {\ttfamily obj.\-Set\-Tip\-Type\-To\-User\-Defined ()} -\/ Set the type of the tip to a cone, sphere, or user defined geometry.  
\item {\ttfamily int = obj.\-Get\-Tip\-Type ()} -\/ Set the type of the tip to a cone, sphere, or user defined geometry.  
\item {\ttfamily obj.\-Set\-User\-Defined\-Tip (vtk\-Poly\-Data )} -\/ Set the user defined tip polydata.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-User\-Defined\-Tip ()} -\/ Set the user defined tip polydata.  
\item {\ttfamily obj.\-Set\-User\-Defined\-Shaft (vtk\-Poly\-Data )} -\/ Set the user defined shaft polydata.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-User\-Defined\-Shaft ()} -\/ Set the user defined shaft polydata.  
\item {\ttfamily vtk\-Property = obj.\-Get\-X\-Axis\-Tip\-Property ()} -\/ Get the tip properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Y\-Axis\-Tip\-Property ()} -\/ Get the tip properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Z\-Axis\-Tip\-Property ()} -\/ Get the tip properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-X\-Axis\-Shaft\-Property ()} -\/ Get the shaft properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Y\-Axis\-Shaft\-Property ()} -\/ Get the shaft properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Z\-Axis\-Shaft\-Property ()} -\/ Get the shaft properties.  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Get\-X\-Axis\-Caption\-Actor2\-D ()} -\/ Retrieve handles to the X, Y and Z axis (so that you can set their text properties for example)  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Get\-Y\-Axis\-Caption\-Actor2\-D ()} -\/ Retrieve handles to the X, Y and Z axis (so that you can set their text properties for example)  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Get\-Z\-Axis\-Caption\-Actor2\-D ()} -\/ Set/get the label text.  
\item {\ttfamily obj.\-Set\-X\-Axis\-Label\-Text (string )} -\/ Set/get the label text.  
\item {\ttfamily string = obj.\-Get\-X\-Axis\-Label\-Text ()} -\/ Set/get the label text.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Label\-Text (string )} -\/ Set/get the label text.  
\item {\ttfamily string = obj.\-Get\-Y\-Axis\-Label\-Text ()} -\/ Set/get the label text.  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Label\-Text (string )} -\/ Set/get the label text.  
\item {\ttfamily string = obj.\-Get\-Z\-Axis\-Label\-Text ()} -\/ Set/get the label text.  
\item {\ttfamily obj.\-Set\-Axis\-Labels (int )} -\/ Enable/disable drawing the axis labels.  
\item {\ttfamily int = obj.\-Get\-Axis\-Labels ()} -\/ Enable/disable drawing the axis labels.  
\item {\ttfamily obj.\-Axis\-Labels\-On ()} -\/ Enable/disable drawing the axis labels.  
\item {\ttfamily obj.\-Axis\-Labels\-Off ()} -\/ Enable/disable drawing the axis labels.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkaxisactor}{}\section{vtk\-Axis\-Actor}\label{vtkhybrid_vtkaxisactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Axis\-Actor creates an axis with tick marks, labels, and/or a title, depending on the particular instance variable settings. It is assumed that the axes is part of a bounding box and is orthoganal to one of the coordinate axes. To use this class, you typically specify two points defining the start and end points of the line (xyz definition using vtk\-Coordinate class), the axis type (X, Y or Z), the axis location in relation to the bounding box, the bounding box, the number of labels, and the data range (min,max). You can also control what parts of the axis are visible including the line, the tick marks, the labels, and the title. It is also possible to control gridlines, and specifiy on which 'side' the tickmarks are drawn (again with respect to the underlying assumed bounding box). You can also specify the label format (a printf style format).

This class decides how to locate the labels, and how to create reasonable tick marks and labels.

Labels follow the camera so as to be legible from any viewpoint.

The instance variables Point1 and Point2 are instances of vtk\-Coordinate. All calculations and references are in World Coordinates.

.S\-E\-C\-T\-I\-O\-N Notes This class was adapted from a 2\-D version created by Hank Childs called vtk\-Hank\-Axis\-Actor2\-D.

To create an instance of class vtk\-Axis\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAxisActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Axis\-Actor 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\-Axis\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Axis\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Axis\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point1\-Coordinate ()} -\/ Specify the position of the first point defining the axis.  
\item {\ttfamily obj.\-Set\-Point1 (double x\mbox{[}3\mbox{]})} -\/ Specify the position of the first point defining the axis.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y, double z)} -\/ Specify the position of the first point defining the axis.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point2\-Coordinate ()} -\/ Specify the position of the second point defining the axis.  
\item {\ttfamily obj.\-Set\-Point2 (double x\mbox{[}3\mbox{]})} -\/ Specify the position of the second point defining the axis.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y, double z)} -\/ Specify the position of the second point defining the axis.  
\item {\ttfamily obj.\-Set\-Range (double , double )} -\/ Specify the (min,max) axis range. This will be used in the generation of labels, if labels are visible.  
\item {\ttfamily obj.\-Set\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify the (min,max) axis range. This will be used in the generation of labels, if labels are visible.  
\item {\ttfamily double = obj. Get\-Range ()} -\/ Specify the (min,max) axis range. This will be used in the generation of labels, if labels are visible.  
\item {\ttfamily obj.\-Set\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Set or get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily double = obj.\-Get\-Bounds (void )} -\/ Set or get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Set or get the bounds for this Actor as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on the axis.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on the axis.  
\item {\ttfamily obj.\-Set\-Minor\-Ticks\-Visible (int )} -\/ Set/\-Get the flag that controls whether the minor ticks are visible.  
\item {\ttfamily int = obj.\-Get\-Minor\-Ticks\-Visible ()} -\/ Set/\-Get the flag that controls whether the minor ticks are visible.  
\item {\ttfamily obj.\-Minor\-Ticks\-Visible\-On ()} -\/ Set/\-Get the flag that controls whether the minor ticks are visible.  
\item {\ttfamily obj.\-Minor\-Ticks\-Visible\-Off ()} -\/ Set/\-Get the flag that controls whether the minor ticks are visible.  
\item {\ttfamily obj.\-Set\-Title (string t)} -\/ Set/\-Get the title of the axis actor,  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the axis actor,  
\item {\ttfamily obj.\-Set\-Major\-Tick\-Size (double )} -\/ Set/\-Get the size of the major tick marks  
\item {\ttfamily double = obj.\-Get\-Major\-Tick\-Size ()} -\/ Set/\-Get the size of the major tick marks  
\item {\ttfamily obj.\-Set\-Minor\-Tick\-Size (double )} -\/ Set/\-Get the size of the major tick marks  
\item {\ttfamily double = obj.\-Get\-Minor\-Tick\-Size ()} -\/ Set/\-Get the size of the major tick marks  
\item {\ttfamily obj.\-Set\-Tick\-Location (int )} -\/ Set/\-Get the location of the ticks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location\-Min\-Value ()} -\/ Set/\-Get the location of the ticks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location\-Max\-Value ()} -\/ Set/\-Get the location of the ticks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location ()} -\/ Set/\-Get the location of the ticks.  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Inside (void )}  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Outside (void )}  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Both (void )}  
\item {\ttfamily obj.\-Set\-Axis\-Visibility (int )} -\/ Set/\-Get visibility of the axis line.  
\item {\ttfamily int = obj.\-Get\-Axis\-Visibility ()} -\/ Set/\-Get visibility of the axis line.  
\item {\ttfamily obj.\-Axis\-Visibility\-On ()} -\/ Set/\-Get visibility of the axis line.  
\item {\ttfamily obj.\-Axis\-Visibility\-Off ()} -\/ Set/\-Get visibility of the axis line.  
\item {\ttfamily obj.\-Set\-Tick\-Visibility (int )} -\/ Set/\-Get visibility of the axis tick marks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Visibility ()} -\/ Set/\-Get visibility of the axis tick marks.  
\item {\ttfamily obj.\-Tick\-Visibility\-On ()} -\/ Set/\-Get visibility of the axis tick marks.  
\item {\ttfamily obj.\-Tick\-Visibility\-Off ()} -\/ Set/\-Get visibility of the axis tick marks.  
\item {\ttfamily obj.\-Set\-Label\-Visibility (int )} -\/ Set/\-Get visibility of the axis labels.  
\item {\ttfamily int = obj.\-Get\-Label\-Visibility ()} -\/ Set/\-Get visibility of the axis labels.  
\item {\ttfamily obj.\-Label\-Visibility\-On ()} -\/ Set/\-Get visibility of the axis labels.  
\item {\ttfamily obj.\-Label\-Visibility\-Off ()} -\/ Set/\-Get visibility of the axis labels.  
\item {\ttfamily obj.\-Set\-Title\-Visibility (int )} -\/ Set/\-Get visibility of the axis title.  
\item {\ttfamily int = obj.\-Get\-Title\-Visibility ()} -\/ Set/\-Get visibility of the axis title.  
\item {\ttfamily obj.\-Title\-Visibility\-On ()} -\/ Set/\-Get visibility of the axis title.  
\item {\ttfamily obj.\-Title\-Visibility\-Off ()} -\/ Set/\-Get visibility of the axis title.  
\item {\ttfamily obj.\-Set\-Draw\-Gridlines (int )} -\/ Set/\-Get whether gridlines should be drawn.  
\item {\ttfamily int = obj.\-Get\-Draw\-Gridlines ()} -\/ Set/\-Get whether gridlines should be drawn.  
\item {\ttfamily obj.\-Draw\-Gridlines\-On ()} -\/ Set/\-Get whether gridlines should be drawn.  
\item {\ttfamily obj.\-Draw\-Gridlines\-Off ()} -\/ Set/\-Get whether gridlines should be drawn.  
\item {\ttfamily obj.\-Set\-Gridline\-X\-Length (double )} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily double = obj.\-Get\-Gridline\-X\-Length ()} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily obj.\-Set\-Gridline\-Y\-Length (double )} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily double = obj.\-Get\-Gridline\-Y\-Length ()} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily obj.\-Set\-Gridline\-Z\-Length (double )} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily double = obj.\-Get\-Gridline\-Z\-Length ()} -\/ Set/\-Get the length to use when drawing gridlines.  
\item {\ttfamily obj.\-Set\-Axis\-Type (int )} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily int = obj.\-Get\-Axis\-Type\-Min\-Value ()} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily int = obj.\-Get\-Axis\-Type\-Max\-Value ()} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily int = obj.\-Get\-Axis\-Type ()} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily obj.\-Set\-Axis\-Type\-To\-X (void )} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily obj.\-Set\-Axis\-Type\-To\-Y (void )} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily obj.\-Set\-Axis\-Type\-To\-Z (void )} -\/ Set/\-Get the type of this axis.  
\item {\ttfamily obj.\-Set\-Axis\-Position (int )} -\/ Set/\-Get the position of this axis (in relation to an an assumed bounding box). For an x-\/type axis, M\-I\-N\-M\-I\-N corresponds to the x-\/edge in the bounding box where Y values are minimum and Z values are minimum. For a y-\/type axis, M\-A\-X\-M\-I\-N corresponds to the y-\/edge where X values are maximum and Z values are minimum.


\item {\ttfamily int = obj.\-Get\-Axis\-Position\-Min\-Value ()} -\/ Set/\-Get the position of this axis (in relation to an an assumed bounding box). For an x-\/type axis, M\-I\-N\-M\-I\-N corresponds to the x-\/edge in the bounding box where Y values are minimum and Z values are minimum. For a y-\/type axis, M\-A\-X\-M\-I\-N corresponds to the y-\/edge where X values are maximum and Z values are minimum.


\item {\ttfamily int = obj.\-Get\-Axis\-Position\-Max\-Value ()} -\/ Set/\-Get the position of this axis (in relation to an an assumed bounding box). For an x-\/type axis, M\-I\-N\-M\-I\-N corresponds to the x-\/edge in the bounding box where Y values are minimum and Z values are minimum. For a y-\/type axis, M\-A\-X\-M\-I\-N corresponds to the y-\/edge where X values are maximum and Z values are minimum.


\item {\ttfamily int = obj.\-Get\-Axis\-Position ()} -\/ Set/\-Get the position of this axis (in relation to an an assumed bounding box). For an x-\/type axis, M\-I\-N\-M\-I\-N corresponds to the x-\/edge in the bounding box where Y values are minimum and Z values are minimum. For a y-\/type axis, M\-A\-X\-M\-I\-N corresponds to the y-\/edge where X values are maximum and Z values are minimum.


\item {\ttfamily obj.\-Set\-Axis\-Position\-To\-Min\-Min (void )}  
\item {\ttfamily obj.\-Set\-Axis\-Position\-To\-Min\-Max (void )}  
\item {\ttfamily obj.\-Set\-Axis\-Position\-To\-Max\-Max (void )}  
\item {\ttfamily obj.\-Set\-Axis\-Position\-To\-Max\-Min (void )}  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Set/\-Get the camera for this axis. The camera is used by the labels to 'follow' the camera and be legible from any viewpoint.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera for this axis. The camera is used by the labels to 'follow' the camera and be legible from any viewpoint.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Draw the axis.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Geometry (vtk\-Viewport )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an axis actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Set\-Label\-Scale (double )}  
\item {\ttfamily obj.\-Set\-Title\-Scale (double )}  
\item {\ttfamily obj.\-Set\-Minor\-Start (double )} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily double = obj.\-Get\-Minor\-Start ()} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily obj.\-Set\-Major\-Start (double )} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily double = obj.\-Get\-Major\-Start ()} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily obj.\-Set\-Delta\-Minor (double )} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily double = obj.\-Get\-Delta\-Minor ()} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily obj.\-Set\-Delta\-Major (double )} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily double = obj.\-Get\-Delta\-Major ()} -\/ Set/\-Get the starting position for minor and major tick points, and the delta values that determine their spacing.  
\item {\ttfamily obj.\-Build\-Axis (vtk\-Viewport viewport, bool )}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkbarchartactor}{}\section{vtk\-Bar\-Chart\-Actor}\label{vtkhybrid_vtkbarchartactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Bar\-Chart\-Actor generates a bar chart from an array of numbers defined in field data (a vtk\-Data\-Object). To use this class, you must specify an input data object. You'll probably also want to specify the position of the plot be setting the Position and Position2 instance variables, which define a rectangle in which the plot lies. There are also many other instance variables that control the look of the plot includes its title and legend.

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated with these components.

To create an instance of class vtk\-Bar\-Chart\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBarChartActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bar\-Chart\-Actor 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\-Bar\-Chart\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Bar\-Chart\-Actor = obj.\-New\-Instance ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Bar\-Chart\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the input to the bar chart actor.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get the input data object to this actor.  
\item {\ttfamily obj.\-Set\-Title\-Visibility (int )} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily int = obj.\-Get\-Title\-Visibility ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-On ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-Off ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the bar chart.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the bar chart.  
\item {\ttfamily obj.\-Set\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property. The property controls the appearance of the plot title.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property. The property controls the appearance of the plot title.  
\item {\ttfamily obj.\-Set\-Label\-Visibility (int )} -\/ Enable/\-Disable the display of bar labels.  
\item {\ttfamily int = obj.\-Get\-Label\-Visibility ()} -\/ Enable/\-Disable the display of bar labels.  
\item {\ttfamily obj.\-Label\-Visibility\-On ()} -\/ Enable/\-Disable the display of bar labels.  
\item {\ttfamily obj.\-Label\-Visibility\-Off ()} -\/ Enable/\-Disable the display of bar labels.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property. This controls the appearance of all bar bar labels.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property. This controls the appearance of all bar bar labels.  
\item {\ttfamily obj.\-Set\-Bar\-Color (int i, double r, double g, double b)} -\/ Specify colors for each bar. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Bar\-Color (int i, double color\mbox{[}3\mbox{]})} -\/ Specify colors for each bar. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Bar\-Label (int i, string )} -\/ Specify the names of each bar. If not specified, then an integer number is automatically generated.  
\item {\ttfamily string = obj.\-Get\-Bar\-Label (int i)} -\/ Specify the names of each bar. If not specified, then an integer number is automatically generated.  
\item {\ttfamily obj.\-Set\-Y\-Title (string )} -\/ Specify the title of the y-\/axis.  
\item {\ttfamily string = obj.\-Get\-Y\-Title ()} -\/ Specify the title of the y-\/axis.  
\item {\ttfamily obj.\-Set\-Legend\-Visibility (int )} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily int = obj.\-Get\-Legend\-Visibility ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-On ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-Off ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-Get\-Legend\-Actor ()} -\/ Retrieve handles to the legend box. This is useful if you would like to manually control the legend appearance.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Draw the bar plot.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the bar plot.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkcaptionactor2d}{}\section{vtk\-Caption\-Actor2\-D}\label{vtkhybrid_vtkcaptionactor2d}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Caption\-Actor2\-D is a hybrid 2\-D/3\-D actor that is used to associate text with a point (the Attachment\-Point) in the scene. The caption can be drawn with a rectangular border and a leader connecting the caption to the attachment point. Optionally, the leader can be glyphed at its endpoint to create arrow heads or other indicators.

To use the caption actor, you normally specify the Position and Position2 coordinates (these are inherited from the vtk\-Actor2\-D superclass). (Note that Position2 can be set using vtk\-Actor2\-D's Set\-Width() and Set\-Height() methods.) Position and Position2 define the size of the caption, and a third point, the Attachment\-Point, defines a point that the caption is associated with. You must also define the caption text, whether you want a border around the caption, and whether you want a leader from the caption to the attachment point. The font attributes of the text can be set through the vtk\-Text\-Property associated to this actor. You also indicate whether you want the leader to be 2\-D or 3\-D. (2\-D leaders are always drawn over the underlying geometry. 3\-D leaders may be occluded by the geometry.) The leader may also be terminated by an optional glyph (e.\-g., arrow).

The trickiest part about using this class is setting Position, Position2, and Attachment\-Point correctly. These instance variables are vtk\-Coordinates, and can be set up in various ways. In default usage, the Attachment\-Point is defined in the world coordinate system, Position is the lower-\/left corner of the caption and relative to Attachment\-Point (defined in display coordaintes, i.\-e., pixels), and Position2 is relative to Position and is the upper-\/right corner (also in display coordinates). However, the user has full control over the coordinates, and can do things like place the caption in a fixed position in the renderer, with the leader moving with the Attachment\-Point.

To create an instance of class vtk\-Caption\-Actor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCaptionActor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Caption\-Actor2\-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\-Caption\-Actor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Caption (string )} -\/ Define the text to be placed in the caption. The text can be multiple lines (separated by \char`\"{}\textbackslash{}n\char`\"{}).  
\item {\ttfamily string = obj.\-Get\-Caption ()} -\/ Define the text to be placed in the caption. The text can be multiple lines (separated by \char`\"{}\textbackslash{}n\char`\"{}).  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Attachment\-Point\-Coordinate ()} -\/ Set/\-Get the attachment point for the caption. By default, the attachment point is defined in world coordinates, but this can be changed using vtk\-Coordinate methods.  
\item {\ttfamily obj.\-Set\-Attachment\-Point (double, double, double)} -\/ Set/\-Get the attachment point for the caption. By default, the attachment point is defined in world coordinates, but this can be changed using vtk\-Coordinate methods.  
\item {\ttfamily obj.\-Set\-Attachment\-Point (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the attachment point for the caption. By default, the attachment point is defined in world coordinates, but this can be changed using vtk\-Coordinate methods.  
\item {\ttfamily double = obj.\-Get\-Attachment\-Point ()} -\/ Set/\-Get the attachment point for the caption. By default, the attachment point is defined in world coordinates, but this can be changed using vtk\-Coordinate methods.  
\item {\ttfamily obj.\-Set\-Border (int )} -\/ Enable/disable the placement of a border around the text.  
\item {\ttfamily int = obj.\-Get\-Border ()} -\/ Enable/disable the placement of a border around the text.  
\item {\ttfamily obj.\-Border\-On ()} -\/ Enable/disable the placement of a border around the text.  
\item {\ttfamily obj.\-Border\-Off ()} -\/ Enable/disable the placement of a border around the text.  
\item {\ttfamily obj.\-Set\-Leader (int )} -\/ Enable/disable drawing a \char`\"{}line\char`\"{} from the caption to the attachment point.  
\item {\ttfamily int = obj.\-Get\-Leader ()} -\/ Enable/disable drawing a \char`\"{}line\char`\"{} from the caption to the attachment point.  
\item {\ttfamily obj.\-Leader\-On ()} -\/ Enable/disable drawing a \char`\"{}line\char`\"{} from the caption to the attachment point.  
\item {\ttfamily obj.\-Leader\-Off ()} -\/ Enable/disable drawing a \char`\"{}line\char`\"{} from the caption to the attachment point.  
\item {\ttfamily obj.\-Set\-Three\-Dimensional\-Leader (int )} -\/ Indicate whether the leader is 2\-D (no hidden line) or 3\-D (z-\/buffered).  
\item {\ttfamily int = obj.\-Get\-Three\-Dimensional\-Leader ()} -\/ Indicate whether the leader is 2\-D (no hidden line) or 3\-D (z-\/buffered).  
\item {\ttfamily obj.\-Three\-Dimensional\-Leader\-On ()} -\/ Indicate whether the leader is 2\-D (no hidden line) or 3\-D (z-\/buffered).  
\item {\ttfamily obj.\-Three\-Dimensional\-Leader\-Off ()} -\/ Indicate whether the leader is 2\-D (no hidden line) or 3\-D (z-\/buffered).  
\item {\ttfamily obj.\-Set\-Leader\-Glyph (vtk\-Poly\-Data )} -\/ Specify a glyph to be used as the leader \char`\"{}head\char`\"{}. This could be something like an arrow or sphere. If not specified, no glyph is drawn. Note that the glyph is assumed to be aligned along the x-\/axis and is rotated about the origin.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Leader\-Glyph ()} -\/ Specify a glyph to be used as the leader \char`\"{}head\char`\"{}. This could be something like an arrow or sphere. If not specified, no glyph is drawn. Note that the glyph is assumed to be aligned along the x-\/axis and is rotated about the origin.  
\item {\ttfamily obj.\-Set\-Leader\-Glyph\-Size (double )} -\/ Specify the relative size of the leader head. This is expressed as a fraction of the size (diagonal length) of the renderer. The leader head is automatically scaled so that window resize, zooming or other camera motion results in proportional changes in size to the leader glyph.  
\item {\ttfamily double = obj.\-Get\-Leader\-Glyph\-Size\-Min\-Value ()} -\/ Specify the relative size of the leader head. This is expressed as a fraction of the size (diagonal length) of the renderer. The leader head is automatically scaled so that window resize, zooming or other camera motion results in proportional changes in size to the leader glyph.  
\item {\ttfamily double = obj.\-Get\-Leader\-Glyph\-Size\-Max\-Value ()} -\/ Specify the relative size of the leader head. This is expressed as a fraction of the size (diagonal length) of the renderer. The leader head is automatically scaled so that window resize, zooming or other camera motion results in proportional changes in size to the leader glyph.  
\item {\ttfamily double = obj.\-Get\-Leader\-Glyph\-Size ()} -\/ Specify the relative size of the leader head. This is expressed as a fraction of the size (diagonal length) of the renderer. The leader head is automatically scaled so that window resize, zooming or other camera motion results in proportional changes in size to the leader glyph.  
\item {\ttfamily obj.\-Set\-Maximum\-Leader\-Glyph\-Size (int )} -\/ Specify the maximum size of the leader head (if any) in pixels. This is used in conjunction with Leader\-Glyph\-Size to cap the maximum size of the Leader\-Glyph.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Leader\-Glyph\-Size\-Min\-Value ()} -\/ Specify the maximum size of the leader head (if any) in pixels. This is used in conjunction with Leader\-Glyph\-Size to cap the maximum size of the Leader\-Glyph.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Leader\-Glyph\-Size\-Max\-Value ()} -\/ Specify the maximum size of the leader head (if any) in pixels. This is used in conjunction with Leader\-Glyph\-Size to cap the maximum size of the Leader\-Glyph.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Leader\-Glyph\-Size ()} -\/ Specify the maximum size of the leader head (if any) in pixels. This is used in conjunction with Leader\-Glyph\-Size to cap the maximum size of the Leader\-Glyph.  
\item {\ttfamily obj.\-Set\-Padding (int )} -\/ Set/\-Get the padding between the caption and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding\-Min\-Value ()} -\/ Set/\-Get the padding between the caption and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding\-Max\-Value ()} -\/ Set/\-Get the padding between the caption and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding ()} -\/ Set/\-Get the padding between the caption and the border. The value is specified in pixels.  
\item {\ttfamily vtk\-Text\-Actor = obj.\-Get\-Text\-Actor ()} -\/ Get the text actor used by the caption. This is useful if you want to control justification and other characteristics of the text actor.  
\item {\ttfamily obj.\-Set\-Caption\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Caption\-Text\-Property ()} -\/ Set/\-Get the text property.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this scaled text actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Set\-Attach\-Edge\-Only (int )} -\/ Enable/disable whether to attach the arrow only to the edge, N\-O\-T the vertices of the caption border.  
\item {\ttfamily int = obj.\-Get\-Attach\-Edge\-Only ()} -\/ Enable/disable whether to attach the arrow only to the edge, N\-O\-T the vertices of the caption border.  
\item {\ttfamily obj.\-Attach\-Edge\-Only\-On ()} -\/ Enable/disable whether to attach the arrow only to the edge, N\-O\-T the vertices of the caption border.  
\item {\ttfamily obj.\-Attach\-Edge\-Only\-Off ()} -\/ Enable/disable whether to attach the arrow only to the edge, N\-O\-T the vertices of the caption border.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkcornerannotation}{}\section{vtk\-Corner\-Annotation}\label{vtkhybrid_vtkcornerannotation}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is an annotation object that manages four text actors / mappers to provide annotation in the four corners of a viewport

To create an instance of class vtk\-Corner\-Annotation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCornerAnnotation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Corner\-Annotation 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\-Corner\-Annotation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Corner\-Annotation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Corner\-Annotation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Draw the scalar bar and annotation text to the screen.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Draw the scalar bar and annotation text to the screen.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Draw the scalar bar and annotation text to the screen.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Set\-Maximum\-Line\-Height (double )} -\/ Set/\-Get the maximum height of a line of text as a percentage of the vertical area allocated to this scaled text actor. Defaults to 1.\-0  
\item {\ttfamily double = obj.\-Get\-Maximum\-Line\-Height ()} -\/ Set/\-Get the maximum height of a line of text as a percentage of the vertical area allocated to this scaled text actor. Defaults to 1.\-0  
\item {\ttfamily obj.\-Set\-Minimum\-Font\-Size (int )} -\/ Set/\-Get the minimum/maximum size font that will be shown. If the font drops below the minimum size it will not be rendered.  
\item {\ttfamily int = obj.\-Get\-Minimum\-Font\-Size ()} -\/ Set/\-Get the minimum/maximum size font that will be shown. If the font drops below the minimum size it will not be rendered.  
\item {\ttfamily obj.\-Set\-Maximum\-Font\-Size (int )} -\/ Set/\-Get the minimum/maximum size font that will be shown. If the font drops below the minimum size it will not be rendered.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Font\-Size ()} -\/ Set/\-Get the minimum/maximum size font that will be shown. If the font drops below the minimum size it will not be rendered.  
\item {\ttfamily obj.\-Set\-Linear\-Font\-Scale\-Factor (double )} -\/ Set/\-Get font scaling factors The font size, f, is calculated as the largest possible value such that the annotations for the given viewport do not overlap. This font size is scaled non-\/linearly with the viewport size, to maintain an acceptable readable size at larger viewport sizes, without being too big. f' = linear\-Scale $\ast$ pow(f,nonlinear\-Scale)  
\item {\ttfamily double = obj.\-Get\-Linear\-Font\-Scale\-Factor ()} -\/ Set/\-Get font scaling factors The font size, f, is calculated as the largest possible value such that the annotations for the given viewport do not overlap. This font size is scaled non-\/linearly with the viewport size, to maintain an acceptable readable size at larger viewport sizes, without being too big. f' = linear\-Scale $\ast$ pow(f,nonlinear\-Scale)  
\item {\ttfamily obj.\-Set\-Nonlinear\-Font\-Scale\-Factor (double )} -\/ Set/\-Get font scaling factors The font size, f, is calculated as the largest possible value such that the annotations for the given viewport do not overlap. This font size is scaled non-\/linearly with the viewport size, to maintain an acceptable readable size at larger viewport sizes, without being too big. f' = linear\-Scale $\ast$ pow(f,nonlinear\-Scale)  
\item {\ttfamily double = obj.\-Get\-Nonlinear\-Font\-Scale\-Factor ()} -\/ Set/\-Get font scaling factors The font size, f, is calculated as the largest possible value such that the annotations for the given viewport do not overlap. This font size is scaled non-\/linearly with the viewport size, to maintain an acceptable readable size at larger viewport sizes, without being too big. f' = linear\-Scale $\ast$ pow(f,nonlinear\-Scale)  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Set\-Text (int i, string text)} -\/ Set/\-Get the text to be displayed for each corner  
\item {\ttfamily string = obj.\-Get\-Text (int i)} -\/ Set/\-Get the text to be displayed for each corner  
\item {\ttfamily obj.\-Clear\-All\-Texts ()} -\/ Set/\-Get the text to be displayed for each corner  
\item {\ttfamily obj.\-Copy\-All\-Texts\-From (vtk\-Corner\-Annotation ca)} -\/ Set/\-Get the text to be displayed for each corner  
\item {\ttfamily obj.\-Set\-Image\-Actor (vtk\-Image\-Actor )} -\/ Set an image actor to look at for slice information  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Get\-Image\-Actor ()} -\/ Set an image actor to look at for slice information  
\item {\ttfamily obj.\-Set\-Window\-Level (vtk\-Image\-Map\-To\-Window\-Level\-Colors )} -\/ Set an instance of vtk\-Image\-Map\-To\-Window\-Level\-Colors to use for looking at window level changes  
\item {\ttfamily vtk\-Image\-Map\-To\-Window\-Level\-Colors = obj.\-Get\-Window\-Level ()} -\/ Set an instance of vtk\-Image\-Map\-To\-Window\-Level\-Colors to use for looking at window level changes  
\item {\ttfamily obj.\-Set\-Level\-Shift (double )} -\/ Set the value to shift the level by.  
\item {\ttfamily double = obj.\-Get\-Level\-Shift ()} -\/ Set the value to shift the level by.  
\item {\ttfamily obj.\-Set\-Level\-Scale (double )} -\/ Set the value to scale the level by.  
\item {\ttfamily double = obj.\-Get\-Level\-Scale ()} -\/ Set the value to scale the level by.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property of all corners.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the text property of all corners.  
\item {\ttfamily obj.\-Show\-Slice\-And\-Image\-On ()} -\/ Even if there is an image actor, should `slice' and `image' be displayed?  
\item {\ttfamily obj.\-Show\-Slice\-And\-Image\-Off ()} -\/ Even if there is an image actor, should `slice' and `image' be displayed?  
\item {\ttfamily obj.\-Set\-Show\-Slice\-And\-Image (int )} -\/ Even if there is an image actor, should `slice' and `image' be displayed?  
\item {\ttfamily int = obj.\-Get\-Show\-Slice\-And\-Image ()} -\/ Even if there is an image actor, should `slice' and `image' be displayed?  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkcubeaxesactor}{}\section{vtk\-Cube\-Axes\-Actor}\label{vtkhybrid_vtkcubeaxesactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cube\-Axes\-Actor is a composite actor that draws axes of the bounding box of an input dataset. The axes include labels and titles for the x-\/y-\/z axes. The algorithm selects which axes to draw based on the user-\/defined 'fly' mode. (S\-T\-A\-T\-I\-C is default). 'S\-T\-A\-T\-I\-C' constructs axes from all edges of the bounding box. 'C\-L\-O\-S\-E\-S\-T\-\_\-\-T\-R\-I\-A\-D' consists of the three axes x-\/y-\/z forming a triad that lies closest to the specified camera. 'F\-U\-R\-T\-H\-E\-S\-T\-\_\-\-T\-R\-I\-A\-D' consists of the three axes x-\/y-\/z forming a triad that lies furthest from the specified camera. 'O\-U\-T\-E\-R\-\_\-\-E\-D\-G\-E\-S' is constructed from edges that are on the \char`\"{}exterior\char`\"{} of the bounding box, exterior as determined from examining outer edges of the bounding box in projection (display) space.

To use this object you must define a bounding box and the camera used to render the vtk\-Cube\-Axes\-Actor. You can optionally turn on/off labels, ticks, gridlines, and set tick location, number of labels, and text to use for axis-\/titles. A 'corner offset' can also be set. This allows the axes to be set partially away from the actual bounding box to perhaps prevent overlap of labels between the various axes.

The Bounds instance variable (an array of six doubles) is used to determine the bounding box.

To create an instance of class vtk\-Cube\-Axes\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCubeAxesActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cube\-Axes\-Actor 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\-Cube\-Axes\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cube\-Axes\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cube\-Axes\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the axes as per the vtk\-Prop superclass' A\-P\-I.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Geometry (vtk\-Viewport )} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Bounds (double , double , double , double , double , double )} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Set/\-Get the camera to perform scaling and translation of the vtk\-Cube\-Axes\-Actor.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera to perform scaling and translation of the vtk\-Cube\-Axes\-Actor.  
\item {\ttfamily obj.\-Set\-Fly\-Mode (int )} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode\-Min\-Value ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode\-Max\-Value ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Outer\-Edges ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Closest\-Triad ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Furthest\-Triad ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Static\-Triad ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Static\-Edges ()} -\/ Specify a mode to control how the axes are drawn\-: either static, closest triad, furthest triad or outer edges in relation to the camera position.  
\item {\ttfamily obj.\-Set\-X\-Title (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-X\-Title ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-X\-Units (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-X\-Units ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-Y\-Title (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Y\-Title ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-Y\-Units (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Y\-Units ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-Z\-Title (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Z\-Title ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-Z\-Units (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Z\-Units ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X-\/\-Axis\char`\"{}, \char`\"{}\-Y-\/\-Axis\char`\"{} and \char`\"{}\-Z-\/\-Axis\char`\"{}.  
\item {\ttfamily obj.\-Set\-X\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily string = obj.\-Get\-X\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily obj.\-Set\-Y\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily string = obj.\-Get\-Y\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily obj.\-Set\-Z\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily string = obj.\-Get\-Z\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily obj.\-Set\-Inertia (int )} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia\-Min\-Value ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia\-Max\-Value ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily obj.\-Set\-Corner\-Offset (double )} -\/ Specify an offset value to \char`\"{}pull back\char`\"{} the axes from the corner at which they are joined to avoid overlap of axes labels. The \char`\"{}\-Corner\-Offset\char`\"{} is the fraction of the axis length to pull back.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset ()} -\/ Specify an offset value to \char`\"{}pull back\char`\"{} the axes from the corner at which they are joined to avoid overlap of axes labels. The \char`\"{}\-Corner\-Offset\char`\"{} is the fraction of the axis length to pull back.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Set\-X\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-X\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-X\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-X\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-Y\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Y\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Y\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-Z\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Z\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Z\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Set\-X\-Axis\-Label\-Visibility (int )} -\/ Turn on and off the visibility of labels for each axis.  
\item {\ttfamily int = obj.\-Get\-X\-Axis\-Label\-Visibility ()} -\/ Turn on and off the visibility of labels for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Label\-Visibility\-On ()} -\/ Turn on and off the visibility of labels for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Label\-Visibility\-Off ()} -\/ Turn on and off the visibility of labels for each axis.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Label\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Y\-Axis\-Label\-Visibility ()}  
\item {\ttfamily obj.\-Y\-Axis\-Label\-Visibility\-On ()}  
\item {\ttfamily obj.\-Y\-Axis\-Label\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Label\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Z\-Axis\-Label\-Visibility ()}  
\item {\ttfamily obj.\-Z\-Axis\-Label\-Visibility\-On ()}  
\item {\ttfamily obj.\-Z\-Axis\-Label\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-X\-Axis\-Tick\-Visibility (int )} -\/ Turn on and off the visibility of ticks for each axis.  
\item {\ttfamily int = obj.\-Get\-X\-Axis\-Tick\-Visibility ()} -\/ Turn on and off the visibility of ticks for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Tick\-Visibility\-On ()} -\/ Turn on and off the visibility of ticks for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Tick\-Visibility\-Off ()} -\/ Turn on and off the visibility of ticks for each axis.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Tick\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Y\-Axis\-Tick\-Visibility ()}  
\item {\ttfamily obj.\-Y\-Axis\-Tick\-Visibility\-On ()}  
\item {\ttfamily obj.\-Y\-Axis\-Tick\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Tick\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Z\-Axis\-Tick\-Visibility ()}  
\item {\ttfamily obj.\-Z\-Axis\-Tick\-Visibility\-On ()}  
\item {\ttfamily obj.\-Z\-Axis\-Tick\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-X\-Axis\-Minor\-Tick\-Visibility (int )} -\/ Turn on and off the visibility of minor ticks for each axis.  
\item {\ttfamily int = obj.\-Get\-X\-Axis\-Minor\-Tick\-Visibility ()} -\/ Turn on and off the visibility of minor ticks for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Minor\-Tick\-Visibility\-On ()} -\/ Turn on and off the visibility of minor ticks for each axis.  
\item {\ttfamily obj.\-X\-Axis\-Minor\-Tick\-Visibility\-Off ()} -\/ Turn on and off the visibility of minor ticks for each axis.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Minor\-Tick\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Y\-Axis\-Minor\-Tick\-Visibility ()}  
\item {\ttfamily obj.\-Y\-Axis\-Minor\-Tick\-Visibility\-On ()}  
\item {\ttfamily obj.\-Y\-Axis\-Minor\-Tick\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Minor\-Tick\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Z\-Axis\-Minor\-Tick\-Visibility ()}  
\item {\ttfamily obj.\-Z\-Axis\-Minor\-Tick\-Visibility\-On ()}  
\item {\ttfamily obj.\-Z\-Axis\-Minor\-Tick\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-Draw\-X\-Gridlines (int )}  
\item {\ttfamily int = obj.\-Get\-Draw\-X\-Gridlines ()}  
\item {\ttfamily obj.\-Draw\-X\-Gridlines\-On ()}  
\item {\ttfamily obj.\-Draw\-X\-Gridlines\-Off ()}  
\item {\ttfamily obj.\-Set\-Draw\-Y\-Gridlines (int )}  
\item {\ttfamily int = obj.\-Get\-Draw\-Y\-Gridlines ()}  
\item {\ttfamily obj.\-Draw\-Y\-Gridlines\-On ()}  
\item {\ttfamily obj.\-Draw\-Y\-Gridlines\-Off ()}  
\item {\ttfamily obj.\-Set\-Draw\-Z\-Gridlines (int )}  
\item {\ttfamily int = obj.\-Get\-Draw\-Z\-Gridlines ()}  
\item {\ttfamily obj.\-Draw\-Z\-Gridlines\-On ()}  
\item {\ttfamily obj.\-Draw\-Z\-Gridlines\-Off ()}  
\item {\ttfamily obj.\-Set\-Tick\-Location (int )} -\/ Set/\-Get the location of ticks marks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location\-Min\-Value ()} -\/ Set/\-Get the location of ticks marks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location\-Max\-Value ()} -\/ Set/\-Get the location of ticks marks.  
\item {\ttfamily int = obj.\-Get\-Tick\-Location ()} -\/ Set/\-Get the location of ticks marks.  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Inside (void )}  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Outside (void )}  
\item {\ttfamily obj.\-Set\-Tick\-Location\-To\-Both (void )}  
\item {\ttfamily obj.\-Set\-Label\-Scaling (bool , int , int , int )}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Cube\-Axes\-Actor actor)} -\/ Shallow copy of a Kat\-Cube\-Axes\-Actor.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkcubeaxesactor2d}{}\section{vtk\-Cube\-Axes\-Actor2\-D}\label{vtkhybrid_vtkcubeaxesactor2d}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cube\-Axes\-Actor2\-D is a composite actor that draws three axes of the bounding box of an input dataset. The axes include labels and titles for the x-\/y-\/z axes. The algorithm selects the axes that are on the \char`\"{}exterior\char`\"{} of the bounding box, exterior as determined from examining outer edges of the bounding box in projection (display) space. Alternatively, the edges closest to the viewer (i.\-e., camera position) can be drawn.

To use this object you must define a bounding box and the camera used to render the vtk\-Cube\-Axes\-Actor2\-D. The camera is used to control the scaling and position of the vtk\-Cube\-Axes\-Actor2\-D so that it fits in the viewport and always remains visible.)

The font property of the axes titles and labels can be modified through the Axis\-Title\-Text\-Property and Axis\-Label\-Text\-Property attributes. You may also use the Get\-X\-Axis\-Actor2\-D, Get\-Y\-Axis\-Actor2\-D or Get\-Z\-Axis\-Actor2\-D methods to access each individual axis actor to modify their font properties.

The bounding box to use is defined in one of three ways. First, if the Input ivar is defined, then the input dataset's bounds is used. If the Input is not defined, and the Prop (superclass of all actors) is defined, then the Prop's bounds is used. If neither the Input or Prop is defined, then the Bounds instance variable (an array of six doubles) is used.

To create an instance of class vtk\-Cube\-Axes\-Actor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCubeAxesActor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cube\-Axes\-Actor2\-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\-Cube\-Axes\-Actor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cube\-Axes\-Actor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cube\-Axes\-Actor2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Draw the axes as per the vtk\-Prop superclass' A\-P\-I.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the axes as per the vtk\-Prop superclass' A\-P\-I.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set )} -\/ Use the bounding box of this input dataset to draw the cube axes. If this is not specified, then the class will attempt to determine the bounds from the defined Prop or Bounds.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Use the bounding box of this input dataset to draw the cube axes. If this is not specified, then the class will attempt to determine the bounds from the defined Prop or Bounds.  
\item {\ttfamily obj.\-Set\-View\-Prop (vtk\-Prop prop)} -\/ Use the bounding box of this prop to draw the cube axes. The View\-Prop is used to determine the bounds only if the Input is not defined.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-View\-Prop ()} -\/ Use the bounding box of this prop to draw the cube axes. The View\-Prop is used to determine the bounds only if the Input is not defined.  
\item {\ttfamily obj.\-Set\-Bounds (double , double , double , double , double , double )} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Explicitly specify the region in space around which to draw the bounds. The bounds is used only when no Input or Prop is specified. The bounds are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Ranges (double , double , double , double , double , double )} -\/ Explicitly specify the range of values used on the bounds. The ranges are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-Ranges (double a\mbox{[}6\mbox{]})} -\/ Explicitly specify the range of values used on the bounds. The ranges are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily double = obj.\-Get\-Ranges ()} -\/ Explicitly specify the range of values used on the bounds. The ranges are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Get\-Ranges (double ranges\mbox{[}6\mbox{]})} -\/ Explicitly specify the range of values used on the bounds. The ranges are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making sure that the min's are less than the max's.  
\item {\ttfamily obj.\-Set\-X\-Origin (double )} -\/ Explicitly specify an origin for the axes. These usually intersect at one of the corners of the bounding box, however users have the option to override this if necessary  
\item {\ttfamily obj.\-Set\-Y\-Origin (double )} -\/ Explicitly specify an origin for the axes. These usually intersect at one of the corners of the bounding box, however users have the option to override this if necessary  
\item {\ttfamily obj.\-Set\-Z\-Origin (double )} -\/ Explicitly specify an origin for the axes. These usually intersect at one of the corners of the bounding box, however users have the option to override this if necessary  
\item {\ttfamily obj.\-Set\-Use\-Ranges (int )} -\/ Set/\-Get a flag that controls whether the axes use the data ranges or the ranges set by Set\-Ranges. By default the axes use the data ranges.  
\item {\ttfamily int = obj.\-Get\-Use\-Ranges ()} -\/ Set/\-Get a flag that controls whether the axes use the data ranges or the ranges set by Set\-Ranges. By default the axes use the data ranges.  
\item {\ttfamily obj.\-Use\-Ranges\-On ()} -\/ Set/\-Get a flag that controls whether the axes use the data ranges or the ranges set by Set\-Ranges. By default the axes use the data ranges.  
\item {\ttfamily obj.\-Use\-Ranges\-Off ()} -\/ Set/\-Get a flag that controls whether the axes use the data ranges or the ranges set by Set\-Ranges. By default the axes use the data ranges.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Set/\-Get the camera to perform scaling and translation of the vtk\-Cube\-Axes\-Actor2\-D.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera to perform scaling and translation of the vtk\-Cube\-Axes\-Actor2\-D.  
\item {\ttfamily obj.\-Set\-Fly\-Mode (int )} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode\-Min\-Value ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode\-Max\-Value ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily int = obj.\-Get\-Fly\-Mode ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Outer\-Edges ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-Closest\-Triad ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily obj.\-Set\-Fly\-Mode\-To\-None ()} -\/ Specify a mode to control how the axes are drawn\-: either outer edges or closest triad to the camera position, or you may also disable flying of the axes.  
\item {\ttfamily obj.\-Set\-Scaling (int )} -\/ Set/\-Get a flag that controls whether the axes are scaled to fit in the viewport. If off, the axes size remains constant (i.\-e., stay the size of the bounding box). By default scaling is on so the axes are scaled to fit inside the viewport.  
\item {\ttfamily int = obj.\-Get\-Scaling ()} -\/ Set/\-Get a flag that controls whether the axes are scaled to fit in the viewport. If off, the axes size remains constant (i.\-e., stay the size of the bounding box). By default scaling is on so the axes are scaled to fit inside the viewport.  
\item {\ttfamily obj.\-Scaling\-On ()} -\/ Set/\-Get a flag that controls whether the axes are scaled to fit in the viewport. If off, the axes size remains constant (i.\-e., stay the size of the bounding box). By default scaling is on so the axes are scaled to fit inside the viewport.  
\item {\ttfamily obj.\-Scaling\-Off ()} -\/ Set/\-Get a flag that controls whether the axes are scaled to fit in the viewport. If off, the axes size remains constant (i.\-e., stay the size of the bounding box). By default scaling is on so the axes are scaled to fit inside the viewport.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show along the x, y, and z axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Min\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x, y, and z axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Max\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x, y, and z axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels ()} -\/ Set/\-Get the number of annotation labels to show along the x, y, and z axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data.  
\item {\ttfamily obj.\-Set\-X\-Label (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-X\-Label ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily obj.\-Set\-Y\-Label (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Y\-Label ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily obj.\-Set\-Z\-Label (string )} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Z\-Label ()} -\/ Set/\-Get the labels for the x, y, and z axes. By default, use \char`\"{}\-X\char`\"{}, \char`\"{}\-Y\char`\"{} and \char`\"{}\-Z\char`\"{}.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-X\-Axis\-Actor2\-D ()} -\/ Retrieve handles to the X, Y and Z axis (so that you can set their text properties for example)  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Y\-Axis\-Actor2\-D ()} -\/ Retrieve handles to the X, Y and Z axis (so that you can set their text properties for example)  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Z\-Axis\-Actor2\-D ()} -\/ Set/\-Get the title text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y/\-Z\-Axis\-Actor2\-D() methods.  
\item {\ttfamily obj.\-Set\-Axis\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y/\-Z\-Axis\-Actor2\-D() methods.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Axis\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y/\-Z\-Axis\-Actor2\-D() methods.  
\item {\ttfamily obj.\-Set\-Axis\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y/\-Z\-Axis\-Actor2\-D() methods.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Axis\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y/\-Z\-Axis\-Actor2\-D() methods.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on each of the x-\/y-\/z axes.  
\item {\ttfamily obj.\-Set\-Font\-Factor (double )} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label and title the axes.  
\item {\ttfamily double = obj.\-Get\-Font\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label and title the axes.  
\item {\ttfamily double = obj.\-Get\-Font\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label and title the axes.  
\item {\ttfamily double = obj.\-Get\-Font\-Factor ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label and title the axes.  
\item {\ttfamily obj.\-Set\-Inertia (int )} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia\-Min\-Value ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia\-Max\-Value ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily int = obj.\-Get\-Inertia ()} -\/ Set/\-Get the inertial factor that controls how often (i.\-e, how many renders) the axes can switch position (jump from one axes to another).  
\item {\ttfamily obj.\-Set\-Show\-Actual\-Bounds (int )} -\/ Set/\-Get the variable that controls whether the actual bounds of the dataset are always shown. Setting this variable to 1 means that clipping is disabled and that the actual value of the bounds is displayed even with corner offsets Setting this variable to 0 means these axis will clip themselves and show variable bounds (legacy mode)  
\item {\ttfamily int = obj.\-Get\-Show\-Actual\-Bounds\-Min\-Value ()} -\/ Set/\-Get the variable that controls whether the actual bounds of the dataset are always shown. Setting this variable to 1 means that clipping is disabled and that the actual value of the bounds is displayed even with corner offsets Setting this variable to 0 means these axis will clip themselves and show variable bounds (legacy mode)  
\item {\ttfamily int = obj.\-Get\-Show\-Actual\-Bounds\-Max\-Value ()} -\/ Set/\-Get the variable that controls whether the actual bounds of the dataset are always shown. Setting this variable to 1 means that clipping is disabled and that the actual value of the bounds is displayed even with corner offsets Setting this variable to 0 means these axis will clip themselves and show variable bounds (legacy mode)  
\item {\ttfamily int = obj.\-Get\-Show\-Actual\-Bounds ()} -\/ Set/\-Get the variable that controls whether the actual bounds of the dataset are always shown. Setting this variable to 1 means that clipping is disabled and that the actual value of the bounds is displayed even with corner offsets Setting this variable to 0 means these axis will clip themselves and show variable bounds (legacy mode)  
\item {\ttfamily obj.\-Set\-Corner\-Offset (double )} -\/ Specify an offset value to \char`\"{}pull back\char`\"{} the axes from the corner at which they are joined to avoid overlap of axes labels. The \char`\"{}\-Corner\-Offset\char`\"{} is the fraction of the axis length to pull back.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset ()} -\/ Specify an offset value to \char`\"{}pull back\char`\"{} the axes from the corner at which they are joined to avoid overlap of axes labels. The \char`\"{}\-Corner\-Offset\char`\"{} is the fraction of the axis length to pull back.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Set\-X\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-X\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-X\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-X\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Set\-Y\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-Y\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Y\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Y\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Set\-Z\-Axis\-Visibility (int )} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily int = obj.\-Get\-Z\-Axis\-Visibility ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Z\-Axis\-Visibility\-On ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Z\-Axis\-Visibility\-Off ()} -\/ Turn on and off the visibility of each axis.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Cube\-Axes\-Actor2\-D actor)} -\/ Shallow copy of a Cube\-Axes\-Actor2\-D.  
\item {\ttfamily obj.\-Set\-Prop (vtk\-Prop prop)} -\/  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkdepthsortpolydata}{}\section{vtk\-Depth\-Sort\-Poly\-Data}\label{vtkhybrid_vtkdepthsortpolydata}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Depth\-Sort\-Poly\-Data rearranges the order of cells so that certain rendering operations (e.\-g., transparency or Painter's algorithms) generate correct results. To use this filter you must specify the direction vector along which to sort the cells. You can do this by specifying a camera and/or prop to define a view direction; or explicitly set a view direction.

To create an instance of class vtk\-Depth\-Sort\-Poly\-Data, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDepthSortPolyData
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Depth\-Sort\-Poly\-Data 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\-Depth\-Sort\-Poly\-Data class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Depth\-Sort\-Poly\-Data = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Depth\-Sort\-Poly\-Data = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Direction (int )} -\/ Specify the sort method for the polygonal primitives. By default, the poly data is sorted from back to front.  
\item {\ttfamily int = obj.\-Get\-Direction ()} -\/ Specify the sort method for the polygonal primitives. By default, the poly data is sorted from back to front.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Front\-To\-Back ()} -\/ Specify the sort method for the polygonal primitives. By default, the poly data is sorted from back to front.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Back\-To\-Front ()} -\/ Specify the sort method for the polygonal primitives. By default, the poly data is sorted from back to front.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Specified\-Vector ()} -\/ Specify the point to use when sorting. The fastest is to just take the first cell point. Other options are to take the bounding box center or the parametric center of the cell. By default, the first cell point is used.  
\item {\ttfamily obj.\-Set\-Depth\-Sort\-Mode (int )} -\/ Specify the point to use when sorting. The fastest is to just take the first cell point. Other options are to take the bounding box center or the parametric center of the cell. By default, the first cell point is used.  
\item {\ttfamily int = obj.\-Get\-Depth\-Sort\-Mode ()} -\/ Specify the point to use when sorting. The fastest is to just take the first cell point. Other options are to take the bounding box center or the parametric center of the cell. By default, the first cell point is used.  
\item {\ttfamily obj.\-Set\-Depth\-Sort\-Mode\-To\-First\-Point ()} -\/ Specify the point to use when sorting. The fastest is to just take the first cell point. Other options are to take the bounding box center or the parametric center of the cell. By default, the first cell point is used.  
\item {\ttfamily obj.\-Set\-Depth\-Sort\-Mode\-To\-Bounds\-Center ()} -\/ Specify the point to use when sorting. The fastest is to just take the first cell point. Other options are to take the bounding box center or the parametric center of the cell. By default, the first cell point is used.  
\item {\ttfamily obj.\-Set\-Depth\-Sort\-Mode\-To\-Parametric\-Center ()} -\/ Specify a camera that is used to define a view direction along which the cells are sorted. This ivar only has effect if the direction is set to front-\/to-\/back or back-\/to-\/front, and a camera is specified.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Specify a camera that is used to define a view direction along which the cells are sorted. This ivar only has effect if the direction is set to front-\/to-\/back or back-\/to-\/front, and a camera is specified.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Specify a camera that is used to define a view direction along which the cells are sorted. This ivar only has effect if the direction is set to front-\/to-\/back or back-\/to-\/front, and a camera is specified.  
\item {\ttfamily obj.\-Set\-Prop3\-D (vtk\-Prop3\-D )} -\/ Specify a transformation matrix (via the vtk\-Prop3\-D\-::\-Get\-Matrix() method) that is used to include the effects of transformation. This ivar only has effect if the direction is set to front-\/to-\/back or back-\/to-\/front, and a camera is specified. Specifying the vtk\-Prop3\-D is optional.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Prop3\-D ()} -\/ Specify a transformation matrix (via the vtk\-Prop3\-D\-::\-Get\-Matrix() method) that is used to include the effects of transformation. This ivar only has effect if the direction is set to front-\/to-\/back or back-\/to-\/front, and a camera is specified. Specifying the vtk\-Prop3\-D is optional.  
\item {\ttfamily obj.\-Set\-Vector (double , double , double )} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector.  
\item {\ttfamily obj.\-Set\-Vector (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector.  
\item {\ttfamily double = obj. Get\-Vector ()} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector, with this point specifying the origin.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector, with this point specifying the origin.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The sort occurs in the direction of the vector, with this point specifying the origin.  
\item {\ttfamily obj.\-Set\-Sort\-Scalars (int )} -\/ Set/\-Get a flag that controls the generation of scalar values corresponding to the sort order. If enabled, the output of this filter will include scalar values that range from 0 to (ncells-\/1), where 0 is closest to the sort direction.  
\item {\ttfamily int = obj.\-Get\-Sort\-Scalars ()} -\/ Set/\-Get a flag that controls the generation of scalar values corresponding to the sort order. If enabled, the output of this filter will include scalar values that range from 0 to (ncells-\/1), where 0 is closest to the sort direction.  
\item {\ttfamily obj.\-Sort\-Scalars\-On ()} -\/ Set/\-Get a flag that controls the generation of scalar values corresponding to the sort order. If enabled, the output of this filter will include scalar values that range from 0 to (ncells-\/1), where 0 is closest to the sort direction.  
\item {\ttfamily obj.\-Sort\-Scalars\-Off ()} -\/ Set/\-Get a flag that controls the generation of scalar values corresponding to the sort order. If enabled, the output of this filter will include scalar values that range from 0 to (ncells-\/1), where 0 is closest to the sort direction.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return M\-Time also considering the dependent objects\-: the camera and/or the prop3\-D.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkdspfilterdefinition}{}\section{vtk\-D\-S\-P\-Filter\-Definition}\label{vtkhybrid_vtkdspfilterdefinition}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-D\-S\-P\-Filter\-Definition is used by vtk\-Exodus\-Reader, vtk\-Exodus\-I\-I\-Reader and vtk\-P\-Exodus\-Reader to do temporal smoothing of data

To create an instance of class vtk\-D\-S\-P\-Filter\-Definition, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDSPFilterDefinition
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-D\-S\-P\-Filter\-Definition 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\-D\-S\-P\-Filter\-Definition class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-D\-S\-P\-Filter\-Definition = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-D\-S\-P\-Filter\-Definition = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Copy (vtk\-D\-S\-P\-Filter\-Definition other)}  
\item {\ttfamily obj.\-Clear ()}  
\item {\ttfamily bool = obj.\-Is\-This\-Input\-Variable\-Instance\-Needed (int a\-\_\-timestep, int a\-\_\-output\-Timestep)}  
\item {\ttfamily obj.\-Push\-Back\-Numerator\-Weight (double a\-\_\-value)}  
\item {\ttfamily obj.\-Push\-Back\-Denominator\-Weight (double a\-\_\-value)}  
\item {\ttfamily obj.\-Push\-Back\-Forward\-Numerator\-Weight (double a\-\_\-value)}  
\item {\ttfamily obj.\-Set\-Input\-Variable\-Name (string a\-\_\-value)}  
\item {\ttfamily obj.\-Set\-Output\-Variable\-Name (string a\-\_\-value)}  
\item {\ttfamily string = obj.\-Get\-Input\-Variable\-Name ()}  
\item {\ttfamily string = obj.\-Get\-Output\-Variable\-Name ()}  
\item {\ttfamily int = obj.\-Get\-Num\-Numerator\-Weights ()}  
\item {\ttfamily int = obj.\-Get\-Num\-Denominator\-Weights ()}  
\item {\ttfamily int = obj.\-Get\-Num\-Forward\-Numerator\-Weights ()}  
\item {\ttfamily double = obj.\-Get\-Numerator\-Weight (int a\-\_\-which)}  
\item {\ttfamily double = obj.\-Get\-Denominator\-Weight (int a\-\_\-which)}  
\item {\ttfamily double = obj.\-Get\-Forward\-Numerator\-Weight (int a\-\_\-which)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkdspfiltergroup}{}\section{vtk\-D\-S\-P\-Filter\-Group}\label{vtkhybrid_vtkdspfiltergroup}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-D\-S\-P\-Filter\-Group is used by vtk\-Exodus\-Reader, vtk\-Exodus\-I\-I\-Reader and vtk\-P\-Exodus\-Reader to do temporal smoothing of data

To create an instance of class vtk\-D\-S\-P\-Filter\-Group, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDSPFilterGroup
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-D\-S\-P\-Filter\-Group 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\-D\-S\-P\-Filter\-Group class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-D\-S\-P\-Filter\-Group = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-D\-S\-P\-Filter\-Group = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Filter (vtk\-D\-S\-P\-Filter\-Definition filter)}  
\item {\ttfamily obj.\-Remove\-Filter (string a\-\_\-output\-Variable\-Name)}  
\item {\ttfamily bool = obj.\-Is\-This\-Input\-Variable\-Instance\-Needed (string a\-\_\-name, int a\-\_\-timestep, int a\-\_\-output\-Timestep)}  
\item {\ttfamily bool = obj.\-Is\-This\-Input\-Variable\-Instance\-Cached (string a\-\_\-name, int a\-\_\-timestep)}  
\item {\ttfamily obj.\-Add\-Input\-Variable\-Instance (string a\-\_\-name, int a\-\_\-timestep, vtk\-Float\-Array a\-\_\-data)}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-Cached\-Input (int a\-\_\-which\-Filter, int a\-\_\-which\-Timestep)}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-Cached\-Output (int a\-\_\-which\-Filter, int a\-\_\-which\-Timestep)}  
\item {\ttfamily string = obj.\-Get\-Input\-Variable\-Name (int a\-\_\-which\-Filter)}  
\item {\ttfamily int = obj.\-Get\-Num\-Filters ()}  
\item {\ttfamily obj.\-Copy (vtk\-D\-S\-P\-Filter\-Group other)}  
\item {\ttfamily vtk\-D\-S\-P\-Filter\-Definition = obj.\-Get\-Filter (int a\-\_\-which\-Filter)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkearthsource}{}\section{vtk\-Earth\-Source}\label{vtkhybrid_vtkearthsource}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Earth\-Source creates a spherical rendering of the geographical shapes of the major continents of the earth. The On\-Ratio determines how much of the data is actually used. The radius defines the radius of the sphere at which the continents are placed. Obtains data from an imbedded array of coordinates.

To create an instance of class vtk\-Earth\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEarthSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Earth\-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\-Earth\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Earth\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Earth\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set radius of earth.  
\item {\ttfamily double = obj.\-Get\-Radius\-Min\-Value ()} -\/ Set radius of earth.  
\item {\ttfamily double = obj.\-Get\-Radius\-Max\-Value ()} -\/ Set radius of earth.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set radius of earth.  
\item {\ttfamily obj.\-Set\-On\-Ratio (int )} -\/ Turn on every nth entity. This controls how much detail the model will have. The maximum ratio is sixteen. (The smaller On\-Ratio, the more detail there is.)  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Min\-Value ()} -\/ Turn on every nth entity. This controls how much detail the model will have. The maximum ratio is sixteen. (The smaller On\-Ratio, the more detail there is.)  
\item {\ttfamily int = obj.\-Get\-On\-Ratio\-Max\-Value ()} -\/ Turn on every nth entity. This controls how much detail the model will have. The maximum ratio is sixteen. (The smaller On\-Ratio, the more detail there is.)  
\item {\ttfamily int = obj.\-Get\-On\-Ratio ()} -\/ Turn on every nth entity. This controls how much detail the model will have. The maximum ratio is sixteen. (The smaller On\-Ratio, the more detail there is.)  
\item {\ttfamily obj.\-Set\-Outline (int )} -\/ Turn on/off drawing continents as filled polygons or as wireframe outlines. Warning\-: some graphics systems will have trouble with the very large, concave filled polygons. Recommend you use Outlien\-On (i.\-e., disable filled polygons) for now.  
\item {\ttfamily int = obj.\-Get\-Outline ()} -\/ Turn on/off drawing continents as filled polygons or as wireframe outlines. Warning\-: some graphics systems will have trouble with the very large, concave filled polygons. Recommend you use Outlien\-On (i.\-e., disable filled polygons) for now.  
\item {\ttfamily obj.\-Outline\-On ()} -\/ Turn on/off drawing continents as filled polygons or as wireframe outlines. Warning\-: some graphics systems will have trouble with the very large, concave filled polygons. Recommend you use Outlien\-On (i.\-e., disable filled polygons) for now.  
\item {\ttfamily obj.\-Outline\-Off ()} -\/ Turn on/off drawing continents as filled polygons or as wireframe outlines. Warning\-: some graphics systems will have trouble with the very large, concave filled polygons. Recommend you use Outlien\-On (i.\-e., disable filled polygons) for now.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkexodusiireader}{}\section{vtk\-Exodus\-I\-I\-Reader}\label{vtkhybrid_vtkexodusiireader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Exodus\-I\-I\-Reader is a unstructured grid source object that reads Exodus\-I\-I files. Most of the meta data associated with the file is loaded when Update\-Information is called. This includes information like Title, number of blocks, number and names of arrays. This data can be retrieved from methods in this reader. Separate arrays that are meant to be a single vector, are combined internally for convenience. To be combined, the array names have to be identical except for a trailing X,Y and Z (or x,y,z). By default cell and point arrays are not loaded. However, the user can flag arrays to load with the methods \char`\"{}\-Set\-Point\-Array\-Status\char`\"{} and \char`\"{}\-Set\-Cell\-Array\-Status\char`\"{}. The reader D\-O\-E\-S N\-O\-T respond to piece requests

To create an instance of class vtk\-Exodus\-I\-I\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExodusIIReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Exodus\-I\-I\-Reader 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\-Exodus\-I\-I\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Exodus\-I\-I\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Exodus\-I\-I\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Determine if the file can be readed with this reader.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the object's M\-Time. This is overridden to include the timestamp of its internal class.  
\item {\ttfamily long = obj.\-Get\-Metadata\-M\-Time ()} -\/ Return the M\-Time of the internal data structure. This is really only intended for use by vtk\-P\-Exodus\-I\-I\-Reader in order to determine if the filename is newer than the metadata.  
\item {\ttfamily obj.\-Set\-File\-Name (string fname)} -\/ Specify file name of the Exodus file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of the Exodus file.  
\item {\ttfamily obj.\-Set\-X\-M\-L\-File\-Name (string fname)} -\/ Specify file name of the xml file.  
\item {\ttfamily string = obj.\-Get\-X\-M\-L\-File\-Name ()} -\/ Specify file name of the xml file.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Which Time\-Step to read.  
\item {\ttfamily obj.\-Set\-Mode\-Shape (int val)} -\/ Returns the available range of valid integer time steps.  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Returns the available range of valid integer time steps.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Returns the available range of valid integer time steps.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Returns the available range of valid integer time steps.  
\item {\ttfamily obj.\-Set\-Generate\-Object\-Id\-Cell\-Array (int g)} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name(). For cells representing elements from an Exodus element block, this is set to the element block I\-D. For cells representing edges from an Exodus edge block, this is the edge block I\-D. Similarly, ths is the face block I\-D for cells representing faces from an Exodus face block. The same holds for cells representing entries of node, edge, face, side, and element sets.  
\item {\ttfamily int = obj.\-Get\-Generate\-Object\-Id\-Cell\-Array ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name(). For cells representing elements from an Exodus element block, this is set to the element block I\-D. For cells representing edges from an Exodus edge block, this is the edge block I\-D. Similarly, ths is the face block I\-D for cells representing faces from an Exodus face block. The same holds for cells representing entries of node, edge, face, side, and element sets.  
\item {\ttfamily obj.\-Generate\-Object\-Id\-Cell\-Array\-On ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name(). For cells representing elements from an Exodus element block, this is set to the element block I\-D. For cells representing edges from an Exodus edge block, this is the edge block I\-D. Similarly, ths is the face block I\-D for cells representing faces from an Exodus face block. The same holds for cells representing entries of node, edge, face, side, and element sets.  
\item {\ttfamily obj.\-Generate\-Object\-Id\-Cell\-Array\-Off ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name(). For cells representing elements from an Exodus element block, this is set to the element block I\-D. For cells representing edges from an Exodus edge block, this is the edge block I\-D. Similarly, ths is the face block I\-D for cells representing faces from an Exodus face block. The same holds for cells representing entries of node, edge, face, side, and element sets.  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Element\-Id\-Array (int g)}  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Element\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Node\-Id\-Array (int g)}  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Node\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-Implicit\-Element\-Id\-Array (int g)}  
\item {\ttfamily int = obj.\-Get\-Generate\-Implicit\-Element\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Implicit\-Element\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Implicit\-Element\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-Implicit\-Node\-Id\-Array (int g)}  
\item {\ttfamily int = obj.\-Get\-Generate\-Implicit\-Node\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-Implicit\-Node\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-Implicit\-Node\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-Generate\-File\-Id\-Array (int f)}  
\item {\ttfamily int = obj.\-Get\-Generate\-File\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-File\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-File\-Id\-Array\-Off ()}  
\item {\ttfamily obj.\-Set\-File\-Id (int f)}  
\item {\ttfamily int = obj.\-Get\-File\-Id ()}  
\item {\ttfamily obj.\-Set\-Apply\-Displacements (int d)} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily int = obj.\-Get\-Apply\-Displacements ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Apply\-Displacements\-On ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Apply\-Displacements\-Off ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Set\-Displacement\-Magnitude (float s)} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily float = obj.\-Get\-Displacement\-Magnitude ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Set\-Has\-Mode\-Shapes (int ms)} -\/ Set/\-Get whether the Exodus sequence number corresponds to time steps or mode shapes. By default, Has\-Mode\-Shapes is false unless two time values in the Exodus file are identical, in which case it is true.  
\item {\ttfamily int = obj.\-Get\-Has\-Mode\-Shapes ()} -\/ Set/\-Get whether the Exodus sequence number corresponds to time steps or mode shapes. By default, Has\-Mode\-Shapes is false unless two time values in the Exodus file are identical, in which case it is true.  
\item {\ttfamily obj.\-Has\-Mode\-Shapes\-On ()} -\/ Set/\-Get whether the Exodus sequence number corresponds to time steps or mode shapes. By default, Has\-Mode\-Shapes is false unless two time values in the Exodus file are identical, in which case it is true.  
\item {\ttfamily obj.\-Has\-Mode\-Shapes\-Off ()} -\/ Set/\-Get whether the Exodus sequence number corresponds to time steps or mode shapes. By default, Has\-Mode\-Shapes is false unless two time values in the Exodus file are identical, in which case it is true.  
\item {\ttfamily obj.\-Set\-Mode\-Shape\-Time (double phase)} -\/ Set/\-Get the time used to animate mode shapes. This is a number between 0 and 1 that is used to scale the {\itshape Displacement\-Magnitude} in a sinusoidal pattern. Specifically, the displacement vector for each vertex is scaled by $ \mathrm{DisplacementMagnitude} cos( 2\pi \mathrm{ModeShapeTime} ) $ before it is added to the vertex coordinates.  
\item {\ttfamily double = obj.\-Get\-Mode\-Shape\-Time ()} -\/ Set/\-Get the time used to animate mode shapes. This is a number between 0 and 1 that is used to scale the {\itshape Displacement\-Magnitude} in a sinusoidal pattern. Specifically, the displacement vector for each vertex is scaled by $ \mathrm{DisplacementMagnitude} cos( 2\pi \mathrm{ModeShapeTime} ) $ before it is added to the vertex coordinates.  
\item {\ttfamily obj.\-Set\-Animate\-Mode\-Shapes (int flag)} -\/ If this flag is on (the default) and Has\-Mode\-Shapes is also on, then this reader will report a continuous time range \mbox{[}0,1\mbox{]} and animate the displacements in a periodic sinusoid. If this flag is off and Has\-Mode\-Shapes is on, this reader ignores time. This flag has no effect if Has\-Mode\-Shapes is off.  
\item {\ttfamily int = obj.\-Get\-Animate\-Mode\-Shapes ()} -\/ If this flag is on (the default) and Has\-Mode\-Shapes is also on, then this reader will report a continuous time range \mbox{[}0,1\mbox{]} and animate the displacements in a periodic sinusoid. If this flag is off and Has\-Mode\-Shapes is on, this reader ignores time. This flag has no effect if Has\-Mode\-Shapes is off.  
\item {\ttfamily obj.\-Animate\-Mode\-Shapes\-On ()} -\/ If this flag is on (the default) and Has\-Mode\-Shapes is also on, then this reader will report a continuous time range \mbox{[}0,1\mbox{]} and animate the displacements in a periodic sinusoid. If this flag is off and Has\-Mode\-Shapes is on, this reader ignores time. This flag has no effect if Has\-Mode\-Shapes is off.  
\item {\ttfamily obj.\-Animate\-Mode\-Shapes\-Off ()} -\/ If this flag is on (the default) and Has\-Mode\-Shapes is also on, then this reader will report a continuous time range \mbox{[}0,1\mbox{]} and animate the displacements in a periodic sinusoid. If this flag is off and Has\-Mode\-Shapes is on, this reader ignores time. This flag has no effect if Has\-Mode\-Shapes is off.  
\item {\ttfamily obj.\-Set\-Edge\-Field\-Decorations (int d)} -\/ F\-I\-X\-M\-E  
\item {\ttfamily int = obj.\-Get\-Edge\-Field\-Decorations ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Edge\-Field\-Decorations\-None ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Edge\-Field\-Decorations\-Glyphs ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Edge\-Field\-Decorations\-Corner\-Averaged ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Set\-Face\-Field\-Decorations (int d)} -\/ F\-I\-X\-M\-E  
\item {\ttfamily int = obj.\-Get\-Face\-Field\-Decorations ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Face\-Field\-Decorations\-None ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Face\-Field\-Decorations\-Glyphs ()} -\/ F\-I\-X\-M\-E  
\item {\ttfamily obj.\-Face\-Field\-Decorations\-Corner\-Averaged ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes\-In\-File ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edges\-In\-File ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Faces\-In\-File ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Elements\-In\-File ()}  
\item {\ttfamily int = obj.\-Get\-Object\-Type\-From\-Name (string name)}  
\item {\ttfamily string = obj.\-Get\-Object\-Type\-Name (int )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Objects (int object\-Type)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Entries\-In\-Object (int object\-Type, int object\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Id (int object\-Type, int object\-Index)}  
\item {\ttfamily string = obj.\-Get\-Object\-Name (int object\-Type, int object\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Index (int object\-Type, string object\-Name)}  
\item {\ttfamily int = obj.\-Get\-Object\-Index (int object\-Type, int id)}  
\item {\ttfamily int = obj.\-Get\-Object\-Status (int object\-Type, int object\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Status (int object\-Type, string object\-Name)}  
\item {\ttfamily obj.\-Set\-Object\-Status (int object\-Type, int object\-Index, int status)}  
\item {\ttfamily obj.\-Set\-Object\-Status (int object\-Type, string object\-Name, int status)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Object\-Arrays (int object\-Type)}  
\item {\ttfamily string = obj.\-Get\-Object\-Array\-Name (int object\-Type, int array\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Array\-Index (int object\-Type, string array\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Object\-Array\-Components (int object\-Type, int array\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Array\-Status (int object\-Type, int array\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Array\-Status (int object\-Type, string array\-Name)}  
\item {\ttfamily obj.\-Set\-Object\-Array\-Status (int object\-Type, int array\-Index, int status)}  
\item {\ttfamily obj.\-Set\-Object\-Array\-Status (int object\-Type, string array\-Name, int status)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Object\-Attributes (int object\-Type, int object\-Index)}  
\item {\ttfamily string = obj.\-Get\-Object\-Attribute\-Name (int object\-Type, int object\-Index, int attrib\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Attribute\-Index (int object\-Type, int object\-Index, string attrib\-Name)}  
\item {\ttfamily int = obj.\-Get\-Object\-Attribute\-Status (int object\-Type, int object\-Index, int attrib\-Index)}  
\item {\ttfamily int = obj.\-Get\-Object\-Attribute\-Status (int object\-Type, int object\-Index, string attrib\-Name)}  
\item {\ttfamily obj.\-Set\-Object\-Attribute\-Status (int object\-Type, int object\-Index, int attrib\-Index, int status)}  
\item {\ttfamily obj.\-Set\-Object\-Attribute\-Status (int object\-Type, int object\-Index, string attrib\-Name, int status)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Nodes ()}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Edges ()}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Faces ()}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Elements ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Part\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Part\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-I\-D (string name)}  
\item {\ttfamily string = obj.\-Get\-Part\-Block\-Info (int array\-Idx)}  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Material\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Material\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-I\-D (string name)}  
\item {\ttfamily obj.\-Set\-Material\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Material\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Assembly\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Assembly\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-I\-D (string name)}  
\item {\ttfamily obj.\-Set\-Assembly\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Assembly\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Hierarchy\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Hierarchy\-Array\-Name (int array\-Idx)}  
\item {\ttfamily obj.\-Set\-Hierarchy\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Hierarchy\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Hierarchy\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Hierarchy\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Display\-Type ()}  
\item {\ttfamily obj.\-Set\-Display\-Type (int type)}  
\item {\ttfamily obj.\-Exodus\-Model\-Metadata\-On ()}  
\item {\ttfamily obj.\-Exodus\-Model\-Metadata\-Off ()}  
\item {\ttfamily obj.\-Set\-Exodus\-Model\-Metadata (int )}  
\item {\ttfamily int = obj.\-Get\-Exodus\-Model\-Metadata ()}  
\item {\ttfamily vtk\-Exodus\-Model = obj.\-Get\-Exodus\-Model ()} -\/ Returns the object which encapsulates the model metadata.  
\item {\ttfamily obj.\-Set\-Pack\-Exodus\-Model\-Onto\-Output (int )}  
\item {\ttfamily int = obj.\-Get\-Pack\-Exodus\-Model\-Onto\-Output ()}  
\item {\ttfamily obj.\-Pack\-Exodus\-Model\-Onto\-Output\-On ()}  
\item {\ttfamily obj.\-Pack\-Exodus\-Model\-Onto\-Output\-Off ()}  
\item {\ttfamily int = obj.\-Is\-Valid\-Variable (string type, string name)}  
\item {\ttfamily int = obj.\-Get\-Variable\-I\-D (string type, string name)}  
\item {\ttfamily obj.\-Set\-All\-Array\-Status (int otype, int status)}  
\item {\ttfamily int = obj.\-Get\-Time\-Series\-Data (int I\-D, string v\-Name, string v\-Type, vtk\-Float\-Array result)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Block\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Block\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Edge\-Block\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Edge\-Block\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Face\-Block\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Face\-Block\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Face\-Block\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Face\-Block\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Block\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Element\-Block\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Element\-Block\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Element\-Block\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Global\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Global\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Global\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Global\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Point\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Point\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Point\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Edge\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Edge\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Face\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Face\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Face\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Face\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Element\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Element\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Element\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Map\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Node\-Map\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Node\-Map\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Node\-Map\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Map\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Map\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Edge\-Map\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Edge\-Map\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Face\-Map\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Face\-Map\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Face\-Map\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Face\-Map\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Map\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Element\-Map\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Element\-Map\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Element\-Map\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Set\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Node\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Node\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Node\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Side\-Set\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Side\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Side\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Side\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Set\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Edge\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Edge\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Face\-Set\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Face\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Face\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Face\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Set\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Element\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Element\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Element\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Set\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Node\-Set\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Node\-Set\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Node\-Set\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Side\-Set\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Side\-Set\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Side\-Set\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Side\-Set\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Edge\-Set\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Edge\-Set\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Edge\-Set\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Edge\-Set\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Face\-Set\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Face\-Set\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Face\-Set\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Face\-Set\-Result\-Array\-Status (string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Element\-Set\-Result\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Element\-Set\-Result\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Element\-Set\-Result\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Element\-Set\-Result\-Array\-Status (string name, int flag)} -\/ Set the fast-\/path keys. All three must be set for the fast-\/path option to work. Possible argument values\-: \char`\"{}\-P\-O\-I\-N\-T\char`\"{},\char`\"{}\-C\-E\-L\-L\char`\"{},\char`\"{}\-E\-D\-G\-E\char`\"{},\char`\"{}\-F\-A\-C\-E\char`\"{}  
\item {\ttfamily obj.\-Set\-Fast\-Path\-Object\-Type (string type)} -\/ Set the fast-\/path keys. All three must be set for the fast-\/path option to work. Possible argument values\-: \char`\"{}\-P\-O\-I\-N\-T\char`\"{},\char`\"{}\-C\-E\-L\-L\char`\"{},\char`\"{}\-E\-D\-G\-E\char`\"{},\char`\"{}\-F\-A\-C\-E\char`\"{}  
\item {\ttfamily obj.\-Set\-Fast\-Path\-Id\-Type (string type)} -\/ Possible argument values\-: \char`\"{}\-I\-N\-D\-E\-X\char`\"{},\char`\"{}\-G\-L\-O\-B\-A\-L\char`\"{} \char`\"{}\-G\-L\-O\-B\-A\-L\char`\"{} means the id refers to a global id \char`\"{}\-I\-N\-D\-E\-X\char`\"{} means the id refers to an index into the V\-T\-K array  
\item {\ttfamily obj.\-Set\-Fast\-Path\-Object\-Id (vtk\-Id\-Type id)} -\/ Possible argument values\-: \char`\"{}\-I\-N\-D\-E\-X\char`\"{},\char`\"{}\-G\-L\-O\-B\-A\-L\char`\"{} \char`\"{}\-G\-L\-O\-B\-A\-L\char`\"{} means the id refers to a global id \char`\"{}\-I\-N\-D\-E\-X\char`\"{} means the id refers to an index into the V\-T\-K array  
\item {\ttfamily obj.\-Reset ()} -\/ Reset the user-\/specified parameters and flush internal arrays so that the reader state is just as it was after the reader was instantiated.

It doesn't make sense to let users reset only the internal state; both the settings and the state are changed by this call.  
\item {\ttfamily obj.\-Reset\-Settings ()} -\/ Reset the user-\/specified parameters to their default values. The only settings not affected are the filename and/or pattern because these have no default.

Resetting the settings but not the state allows users to keep the active cache but return to initial array selections, etc.  
\item {\ttfamily obj.\-Reset\-Cache ()} -\/ Clears out the cache entries.  
\item {\ttfamily obj.\-Update\-Time\-Information ()} -\/ Re-\/reads time information from the exodus file and updates Time\-Step\-Range accordingly.  
\item {\ttfamily obj.\-Dump ()}  
\item {\ttfamily vtk\-Graph = obj.\-Get\-S\-I\-L ()} -\/ S\-I\-L describes organization of/relationships between classifications eg. blocks/materials/hierarchies.  
\item {\ttfamily int = obj.\-Get\-S\-I\-L\-Update\-Stamp ()} -\/ Every time the S\-I\-L is updated a this will return a different value.  
\item {\ttfamily bool = obj.\-Get\-Produced\-Fast\-Path\-Output ()} -\/ H\-A\-C\-K\-: Used by vtk\-P\-Exodus\-I\-I\-Reader to tell is the reader produced a valid fast path output.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkexodusmodel}{}\section{vtk\-Exodus\-Model}\label{vtkhybrid_vtkexodusmodel}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A vtk\-Unstructured\-Grid output by vtk\-Exodus\-Reader or vtk\-P\-Exodus\-Reader is missing a great deal of initialization and static model data that is in an Exodus I\-I file. (Global variables, properties, node sets, side sets, and so on.) This data can be stored in a vtk\-Model\-Metadata object, which can be initialized using this vtk\-Exodus\-Model class.

This class can be initialized with a file handle for an open Exodus file, and the vtk\-Unstructured\-Grid derived from that file. The methods used would be Set\-Global\-Information, Set\-Local\-Information, Add\-U\-Grid\-Element\-Variable and Add\-U\-Grid\-Node\-Variable. The vtk\-Exodus\-Reader does this.

It can also be initialized (using Unpack\-Exodus\-Model) from a vtk\-Unstructured\-Grid that has had metadata packed into it's field arrays with Pack\-Exodus\-Model. The vtk\-Exodus\-I\-I\-Writer does this.

If you plan to write out the Exodus file (with vtk\-Exodus\-I\-I\-Writer), you should direct the Exodus reader to create a vtk\-Exodus\-Model object. This will be used by the Exodus writer to create a correct Exodus I\-I file on output. In addition, the vtk\-Distributed\-Data\-Filter is cognizant of the Exodus\-Model object and will unpack, extract, merge, and pack these objects associated with the grids it is partitioning.

.S\-E\-C\-T\-I\-O\-N See also vtk\-Exodus\-Reader vtk\-P\-Exodus\-Reader vtk\-Exodus\-I\-I\-Writer vtk\-Model\-Metadata vtk\-Distributed\-Data\-Filter

To create an instance of class vtk\-Exodus\-Model, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExodusModel
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Exodus\-Model 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\-Exodus\-Model class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Exodus\-Model = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Exodus\-Model = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Set\-Global\-Information (int fid, int compute\-\_\-word\-\_\-size)}  
\item {\ttfamily int = obj.\-Add\-U\-Grid\-Element\-Variable (string ugrid\-Var\-Name, string orig\-Name, int num\-Components)}  
\item {\ttfamily int = obj.\-Remove\-U\-Grid\-Element\-Variable (string ugrid\-Var\-Name)}  
\item {\ttfamily int = obj.\-Add\-U\-Grid\-Node\-Variable (string ugrid\-Var\-Name, string orig\-Name, int num\-Components)}  
\item {\ttfamily int = obj.\-Remove\-U\-Grid\-Node\-Variable (string ugrid\-Var\-Name)}  
\item {\ttfamily int = obj.\-Set\-Local\-Information (vtk\-Unstructured\-Grid ugrid, int fid, int time\-Step, int new\-Geometry, int compute\-\_\-word\-\_\-size)}  
\item {\ttfamily vtk\-Model\-Metadata = obj.\-Get\-Model\-Metadata ()}  
\item {\ttfamily obj.\-Set\-Model\-Metadata (vtk\-Model\-Metadata em\-Data)}  
\item {\ttfamily int = obj.\-Unpack\-Exodus\-Model (vtk\-Unstructured\-Grid grid, int delete\-It)}  
\item {\ttfamily int = obj.\-Merge\-Exodus\-Model (vtk\-Exodus\-Model em)}  
\item {\ttfamily vtk\-Exodus\-Model = obj.\-Extract\-Exodus\-Model (vtk\-Id\-Type\-Array global\-Cell\-Id\-List, vtk\-Unstructured\-Grid grid)}  
\item {\ttfamily obj.\-Pack\-Exodus\-Model (vtk\-Unstructured\-Grid grid)}  
\item {\ttfamily obj.\-Reset ()}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkexodusreader}{}\section{vtk\-Exodus\-Reader}\label{vtkhybrid_vtkexodusreader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Exodus\-Reader is a unstructured grid source object that reads Exodus\-I\-I files. Most of the meta data associated with the file is loaded when Update\-Information is called. This includes information like Title, number of blocks, number and names of arrays. This data can be retrieved from methods in this reader. Separate arrays that are meant to be a single vector, are combined internally for convenience. To be combined, the array names have to be identical except for a trailing X,Y and Z (or x,y,z). By default cell and point arrays are not loaded. However, the user can flag arrays to load with the methods \char`\"{}\-Set\-Point\-Array\-Status\char`\"{} and \char`\"{}\-Set\-Cell\-Array\-Status\char`\"{}. The reader D\-O\-E\-S N\-O\-T respond to piece requests

To create an instance of class vtk\-Exodus\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExodusReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Exodus\-Reader 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\-Exodus\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Exodus\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Exodus\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Determine if the file can be readed with this reader.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of the Exodus file.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of the Exodus file.  
\item {\ttfamily obj.\-Set\-X\-M\-L\-File\-Name (string )} -\/ Specify file name of the xml file.  
\item {\ttfamily string = obj.\-Get\-X\-M\-L\-File\-Name ()} -\/ Specify file name of the xml file.  
\item {\ttfamily obj.\-Set\-Time\-Step (int )} -\/ Which Time\-Step to read.  
\item {\ttfamily int = obj.\-Get\-Time\-Step ()} -\/ Which Time\-Step to read.  
\item {\ttfamily obj.\-Set\-Generate\-Block\-Id\-Cell\-Array (int )} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name()  
\item {\ttfamily int = obj.\-Get\-Generate\-Block\-Id\-Cell\-Array ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Generate\-Block\-Id\-Cell\-Array\-On ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Generate\-Block\-Id\-Cell\-Array\-Off ()} -\/ Extra cell data array that can be generated. By default, this array is O\-N. The value of the array is the integer id found in the exodus file. The name of the array is returned by Get\-Block\-Id\-Array\-Name()  
\item {\ttfamily string = obj.\-Get\-Block\-Id\-Array\-Name ()} -\/ Extra cell data array that can be generated. By default, this array is off. The value of the array is the integer global id of the cell. The name of the array is returned by Get\-Global\-Element\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Element\-Id\-Array (int )} -\/ Extra cell data array that can be generated. By default, this array is off. The value of the array is the integer global id of the cell. The name of the array is returned by Get\-Global\-Element\-Id\-Array\-Name()  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Element\-Id\-Array ()} -\/ Extra cell data array that can be generated. By default, this array is off. The value of the array is the integer global id of the cell. The name of the array is returned by Get\-Global\-Element\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-On ()} -\/ Extra cell data array that can be generated. By default, this array is off. The value of the array is the integer global id of the cell. The name of the array is returned by Get\-Global\-Element\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Generate\-Global\-Element\-Id\-Array\-Off ()} -\/ Extra cell data array that can be generated. By default, this array is off. The value of the array is the integer global id of the cell. The name of the array is returned by Get\-Global\-Element\-Id\-Array\-Name()  
\item {\ttfamily obj.\-Set\-Generate\-Global\-Node\-Id\-Array (int )} -\/ Extra point data array that can be generated. By default, this array is O\-N. The value of the array is the integer id of the node. The id is relative to the entire data set. The name of the array is returned by Global\-Node\-Id\-Array\-Name().  
\item {\ttfamily int = obj.\-Get\-Generate\-Global\-Node\-Id\-Array ()} -\/ Extra point data array that can be generated. By default, this array is O\-N. The value of the array is the integer id of the node. The id is relative to the entire data set. The name of the array is returned by Global\-Node\-Id\-Array\-Name().  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-On ()} -\/ Extra point data array that can be generated. By default, this array is O\-N. The value of the array is the integer id of the node. The id is relative to the entire data set. The name of the array is returned by Global\-Node\-Id\-Array\-Name().  
\item {\ttfamily obj.\-Generate\-Global\-Node\-Id\-Array\-Off ()} -\/ Extra point data array that can be generated. By default, this array is O\-N. The value of the array is the integer id of the node. The id is relative to the entire data set. The name of the array is returned by Global\-Node\-Id\-Array\-Name().  
\item {\ttfamily obj.\-Set\-Apply\-Displacements (int )} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily int = obj.\-Get\-Apply\-Displacements ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Apply\-Displacements\-On ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Apply\-Displacements\-Off ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily obj.\-Set\-Displacement\-Magnitude (float )} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily float = obj.\-Get\-Displacement\-Magnitude ()} -\/ Geometric locations can include displacements. By default, this is O\-N. The nodal positions are 'displaced' by the standard exodus displacment vector. If displacements are turned 'off', the user can explicitly add them by applying a warp filter.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Elements ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Sets ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Side\-Sets ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Blocks ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes ()} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Elements\-In\-Block (int block\-\_\-idx)} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Block\-Id (int block\-\_\-idx)} -\/ Access to meta data generated by Update\-Information.  
\item {\ttfamily int = obj.\-Get\-Total\-Number\-Of\-Nodes ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-I\-D (string name)}  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Number\-Of\-Components (int index)}  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-I\-D (string name)}  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Number\-Of\-Components (int index)}  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Total\-Number\-Of\-Elements ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Block\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Block\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Block\-Array\-I\-D (string name)}  
\item {\ttfamily obj.\-Set\-Block\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Block\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Block\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Block\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Node\-Set\-Arrays ()} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily int = obj.\-Get\-Node\-Set\-Array\-Status (int index)} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily int = obj.\-Get\-Node\-Set\-Array\-Status (string name)} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily obj.\-Set\-Node\-Set\-Array\-Status (int index, int flag)} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily obj.\-Set\-Node\-Set\-Array\-Status (string name, int flag)} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily string = obj.\-Get\-Node\-Set\-Array\-Name (int index)} -\/ By default Node/\-Side sets are not loaded, These methods allow the user to select which Node/\-Side sets they want to load. Number\-Of\-Node\-Sets and Number\-Of\-Side\-Sets (set by vtk macros) are stored in vtk\-Exodus\-Reader but other Node/\-Side set metadata are stored in vtk\-Exodus\-Meta\-Data Note\-: Get\-Number\-Of\-Node\-Set\-Arrays and Get\-Number\-Of\-Side\-Set\-Arrays are just syntatic sugar for paraview server xml  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Side\-Set\-Arrays ()}  
\item {\ttfamily int = obj.\-Get\-Side\-Set\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Side\-Set\-Array\-Status (string name)}  
\item {\ttfamily obj.\-Set\-Side\-Set\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Side\-Set\-Array\-Status (string name, int flag)}  
\item {\ttfamily string = obj.\-Get\-Side\-Set\-Array\-Name (int index)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Part\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Part\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-I\-D (string name)}  
\item {\ttfamily string = obj.\-Get\-Part\-Block\-Info (int array\-Idx)}  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Material\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Material\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-I\-D (string name)}  
\item {\ttfamily obj.\-Set\-Material\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Material\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Material\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Assembly\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Assembly\-Array\-Name (int array\-Idx)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-I\-D (string name)}  
\item {\ttfamily obj.\-Set\-Assembly\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Assembly\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Assembly\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Hierarchy\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Hierarchy\-Array\-Name (int array\-Idx)}  
\item {\ttfamily obj.\-Set\-Hierarchy\-Array\-Status (int index, int flag)}  
\item {\ttfamily obj.\-Set\-Hierarchy\-Array\-Status (string , int flag)}  
\item {\ttfamily int = obj.\-Get\-Hierarchy\-Array\-Status (int index)}  
\item {\ttfamily int = obj.\-Get\-Hierarchy\-Array\-Status (string )}  
\item {\ttfamily int = obj.\-Get\-Has\-Mode\-Shapes ()} -\/ Some simulations overload the Exodus time steps to represent mode shapes. In this case, it does not make sense to iterate over the \char`\"{}time steps\char`\"{}, because they are not meant to be played in order. Rather, each represents the vibration at a different \char`\"{}mode.\char`\"{} Setting this to 1 changes the semantics of the reader to not report the time steps to downstream filters. By default, this is off, which is the case for most Exodus files.  
\item {\ttfamily obj.\-Set\-Has\-Mode\-Shapes (int )} -\/ Some simulations overload the Exodus time steps to represent mode shapes. In this case, it does not make sense to iterate over the \char`\"{}time steps\char`\"{}, because they are not meant to be played in order. Rather, each represents the vibration at a different \char`\"{}mode.\char`\"{} Setting this to 1 changes the semantics of the reader to not report the time steps to downstream filters. By default, this is off, which is the case for most Exodus files.  
\item {\ttfamily obj.\-Has\-Mode\-Shapes\-On ()} -\/ Some simulations overload the Exodus time steps to represent mode shapes. In this case, it does not make sense to iterate over the \char`\"{}time steps\char`\"{}, because they are not meant to be played in order. Rather, each represents the vibration at a different \char`\"{}mode.\char`\"{} Setting this to 1 changes the semantics of the reader to not report the time steps to downstream filters. By default, this is off, which is the case for most Exodus files.  
\item {\ttfamily obj.\-Has\-Mode\-Shapes\-Off ()} -\/ Some simulations overload the Exodus time steps to represent mode shapes. In this case, it does not make sense to iterate over the \char`\"{}time steps\char`\"{}, because they are not meant to be played in order. Rather, each represents the vibration at a different \char`\"{}mode.\char`\"{} Setting this to 1 changes the semantics of the reader to not report the time steps to downstream filters. By default, this is off, which is the case for most Exodus files.  
\item {\ttfamily int = obj.\-Get\-Display\-Type ()}  
\item {\ttfamily obj.\-Set\-Display\-Type (int type)}  
\item {\ttfamily obj.\-Exodus\-Model\-Metadata\-On ()}  
\item {\ttfamily obj.\-Exodus\-Model\-Metadata\-Off ()}  
\item {\ttfamily obj.\-Set\-Exodus\-Model\-Metadata (int )}  
\item {\ttfamily int = obj.\-Get\-Exodus\-Model\-Metadata ()}  
\item {\ttfamily vtk\-Exodus\-Model = obj.\-Get\-Exodus\-Model ()}  
\item {\ttfamily obj.\-Set\-Pack\-Exodus\-Model\-Onto\-Output (int )}  
\item {\ttfamily int = obj.\-Get\-Pack\-Exodus\-Model\-Onto\-Output ()}  
\item {\ttfamily obj.\-Pack\-Exodus\-Model\-Onto\-Output\-On ()}  
\item {\ttfamily obj.\-Pack\-Exodus\-Model\-Onto\-Output\-Off ()}  
\item {\ttfamily int = obj.\-Is\-Valid\-Variable (string type, string name)}  
\item {\ttfamily int = obj.\-Get\-Variable\-I\-D (string type, string name)}  
\item {\ttfamily obj.\-Set\-All\-Assembly\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Block\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Cell\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Hierarchy\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Material\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Part\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-All\-Point\-Array\-Status (int status)}  
\item {\ttfamily obj.\-Set\-Array\-Status (string type, string name, int flag)}  
\item {\ttfamily int = obj.\-Get\-Array\-Status (string type, string name)}  
\item {\ttfamily int = obj.\-Get\-Time\-Series\-Data (int I\-D, string v\-Name, string v\-Type, vtk\-Float\-Array result)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variable\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Variable\-Array\-Name (int a\-\_\-which)}  
\item {\ttfamily obj.\-Enable\-D\-S\-P\-Filtering ()}  
\item {\ttfamily obj.\-Add\-Filter (vtk\-D\-S\-P\-Filter\-Definition a\-\_\-filter)}  
\item {\ttfamily obj.\-Start\-Adding\-Filter ()}  
\item {\ttfamily obj.\-Add\-Filter\-Input\-Var (string name)}  
\item {\ttfamily obj.\-Add\-Filter\-Output\-Var (string name)}  
\item {\ttfamily obj.\-Add\-Filter\-Numerator\-Weight (double weight)}  
\item {\ttfamily obj.\-Add\-Filter\-Forward\-Numerator\-Weight (double weight)}  
\item {\ttfamily obj.\-Add\-Filter\-Denominator\-Weight (double weight)}  
\item {\ttfamily obj.\-Finish\-Adding\-Filter ()}  
\item {\ttfamily obj.\-Remove\-Filter (string a\-\_\-output\-Variable\-Name)}  
\item {\ttfamily obj.\-Get\-D\-S\-P\-Output\-Arrays (int exoid, vtk\-Unstructured\-Grid output)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkfacetreader}{}\section{vtk\-Facet\-Reader}\label{vtkhybrid_vtkfacetreader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Facet\-Reader creates a poly data dataset. It reads A\-S\-C\-I\-I files stored in Facet format

The facet format looks like this\-: F\-A\-C\-E\-T F\-I\-L\-E ... nparts Part 1 name 0 npoints 0 0 p1x p1y p1z p2x p2y p2z ... 1 Part 1 name ncells npointspercell p1c1 p2c1 p3c1 ... pnc1 materialnum partnum p1c2 p2c2 p3c2 ... pnc2 materialnum partnum ...

To create an instance of class vtk\-Facet\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFacetReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Facet\-Reader 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\-Facet\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Facet\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Facet\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify file name of Facet datafile to read  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify file name of Facet datafile to read  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkgreedyterraindecimation}{}\section{vtk\-Greedy\-Terrain\-Decimation}\label{vtkhybrid_vtkgreedyterraindecimation}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Greedy\-Terrain\-Decimation approximates a height field with a triangle mesh (triangulated irregular network -\/ T\-I\-N) using a greedy insertion algorithm similar to that described by Garland and Heckbert in their paper \char`\"{}\-Fast Polygonal Approximations of Terrain and Height Fields\char`\"{} (Technical Report C\-M\-U-\/\-C\-S-\/95-\/181). The input to the filter is a height field (represented by a image whose scalar values are height) and the output of the filter is polygonal data consisting of triangles. The number of triangles in the output is reduced in number as compared to a naive tessellation of the input height field. This filter copies point data from the input to the output for those points present in the output.

An brief description of the algorithm is as follows. The algorithm uses a top-\/down decimation approach that initially represents the height field with two triangles (whose vertices are at the four corners of the image). These two triangles form a Delaunay triangulation. In an iterative fashion, the point in the image with the greatest error (as compared to the original height field) is injected into the triangulation. (Note that the single point with the greatest error per triangle is identified and placed into a priority queue. As the triangulation is modified, the errors from the deleted triangles are removed from the queue, error values from the new triangles are added.) The point whose error is at the top of the queue is added to the triangulaion modifying it using the standard incremental Delaunay point insertion (see vtk\-Delaunay2\-D) algorithm. Points are repeatedly inserted until the appropriate (user-\/specified) error criterion is met.

To use this filter, set the input and specify the error measure to be used. The error measure options are 1) the absolute number of triangles to be produced; 2) a fractional reduction of the mesh (num\-Tris/max\-Tris) where max\-Tris is the largest possible number of triangles 2$\ast$(dims\mbox{[}0\mbox{]}-\/1)$\ast$(dims\mbox{[}1\mbox{]}-\/1); 3) an absolute measure on error (maximum difference in height field to reduced T\-I\-N); and 4) relative error (the absolute error is normalized by the diagonal of the bounding box of the height field).

To create an instance of class vtk\-Greedy\-Terrain\-Decimation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGreedyTerrainDecimation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Greedy\-Terrain\-Decimation 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\-Greedy\-Terrain\-Decimation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Greedy\-Terrain\-Decimation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Greedy\-Terrain\-Decimation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Error\-Measure (int )} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily int = obj.\-Get\-Error\-Measure\-Min\-Value ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily int = obj.\-Get\-Error\-Measure\-Max\-Value ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily int = obj.\-Get\-Error\-Measure ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily obj.\-Set\-Error\-Measure\-To\-Number\-Of\-Triangles ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily obj.\-Set\-Error\-Measure\-To\-Specified\-Reduction ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily obj.\-Set\-Error\-Measure\-To\-Absolute\-Error ()} -\/ Specify how to terminate the algorithm\-: either as an absolute number of triangles, a relative number of triangles (normalized by the full resolution mesh), an absolute error (in the height field), or relative error (normalized by the length of the diagonal of the image).  
\item {\ttfamily obj.\-Set\-Error\-Measure\-To\-Relative\-Error ()} -\/ Specify the number of triangles to produce on output. (It is a good idea to make sure this is less than a tessellated mesh at full resolution.) You need to set this value only when the error measure is set to Number\-Of\-Triangles.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Triangles (vtk\-Id\-Type )} -\/ Specify the number of triangles to produce on output. (It is a good idea to make sure this is less than a tessellated mesh at full resolution.) You need to set this value only when the error measure is set to Number\-Of\-Triangles.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Triangles\-Min\-Value ()} -\/ Specify the number of triangles to produce on output. (It is a good idea to make sure this is less than a tessellated mesh at full resolution.) You need to set this value only when the error measure is set to Number\-Of\-Triangles.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Triangles\-Max\-Value ()} -\/ Specify the number of triangles to produce on output. (It is a good idea to make sure this is less than a tessellated mesh at full resolution.) You need to set this value only when the error measure is set to Number\-Of\-Triangles.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Triangles ()} -\/ Specify the number of triangles to produce on output. (It is a good idea to make sure this is less than a tessellated mesh at full resolution.) You need to set this value only when the error measure is set to Number\-Of\-Triangles.  
\item {\ttfamily obj.\-Set\-Reduction (double )} -\/ Specify the reduction of the mesh (represented as a fraction). Note that a value of 0.\-10 means a 10\% reduction. You need to set this value only when the error measure is set to Specified\-Reduction.  
\item {\ttfamily double = obj.\-Get\-Reduction\-Min\-Value ()} -\/ Specify the reduction of the mesh (represented as a fraction). Note that a value of 0.\-10 means a 10\% reduction. You need to set this value only when the error measure is set to Specified\-Reduction.  
\item {\ttfamily double = obj.\-Get\-Reduction\-Max\-Value ()} -\/ Specify the reduction of the mesh (represented as a fraction). Note that a value of 0.\-10 means a 10\% reduction. You need to set this value only when the error measure is set to Specified\-Reduction.  
\item {\ttfamily double = obj.\-Get\-Reduction ()} -\/ Specify the reduction of the mesh (represented as a fraction). Note that a value of 0.\-10 means a 10\% reduction. You need to set this value only when the error measure is set to Specified\-Reduction.  
\item {\ttfamily obj.\-Set\-Absolute\-Error (double )} -\/ Specify the absolute error of the mesh; that is, the error in height between the decimated mesh and the original height field. You need to set this value only when the error measure is set to Absolute\-Error.  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error\-Min\-Value ()} -\/ Specify the absolute error of the mesh; that is, the error in height between the decimated mesh and the original height field. You need to set this value only when the error measure is set to Absolute\-Error.  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error\-Max\-Value ()} -\/ Specify the absolute error of the mesh; that is, the error in height between the decimated mesh and the original height field. You need to set this value only when the error measure is set to Absolute\-Error.  
\item {\ttfamily double = obj.\-Get\-Absolute\-Error ()} -\/ Specify the absolute error of the mesh; that is, the error in height between the decimated mesh and the original height field. You need to set this value only when the error measure is set to Absolute\-Error.  
\item {\ttfamily obj.\-Set\-Relative\-Error (double )} -\/ Specify the relative error of the mesh; that is, the error in height between the decimated mesh and the original height field normalized by the diagonal of the image. You need to set this value only when the error measure is set to Relative\-Error.  
\item {\ttfamily double = obj.\-Get\-Relative\-Error\-Min\-Value ()} -\/ Specify the relative error of the mesh; that is, the error in height between the decimated mesh and the original height field normalized by the diagonal of the image. You need to set this value only when the error measure is set to Relative\-Error.  
\item {\ttfamily double = obj.\-Get\-Relative\-Error\-Max\-Value ()} -\/ Specify the relative error of the mesh; that is, the error in height between the decimated mesh and the original height field normalized by the diagonal of the image. You need to set this value only when the error measure is set to Relative\-Error.  
\item {\ttfamily double = obj.\-Get\-Relative\-Error ()} -\/ Specify the relative error of the mesh; that is, the error in height between the decimated mesh and the original height field normalized by the diagonal of the image. You need to set this value only when the error measure is set to Relative\-Error.  
\item {\ttfamily obj.\-Set\-Boundary\-Vertex\-Deletion (int )} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily int = obj.\-Get\-Boundary\-Vertex\-Deletion ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Boundary\-Vertex\-Deletion\-On ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Boundary\-Vertex\-Deletion\-Off ()} -\/ Turn on/off the deletion of vertices on the boundary of a mesh. This may limit the maximum reduction that may be achieved.  
\item {\ttfamily obj.\-Set\-Compute\-Normals (int )} -\/ Compute normals based on the input image. Off by default.  
\item {\ttfamily int = obj.\-Get\-Compute\-Normals ()} -\/ Compute normals based on the input image. Off by default.  
\item {\ttfamily obj.\-Compute\-Normals\-On ()} -\/ Compute normals based on the input image. Off by default.  
\item {\ttfamily obj.\-Compute\-Normals\-Off ()} -\/ Compute normals based on the input image. Off by default.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkgridtransform}{}\section{vtk\-Grid\-Transform}\label{vtkhybrid_vtkgridtransform}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Grid\-Transform describes a nonlinear warp transformation as a set of displacement vectors sampled along a uniform 3\-D grid.

To create an instance of class vtk\-Grid\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGridTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Grid\-Transform 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\-Grid\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Grid\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Grid\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Displacement\-Grid (vtk\-Image\-Data )} -\/ Set/\-Get the grid transform (the grid transform must have three components for displacement in x, y, and z respectively). The vtk\-Grid\-Transform class will never modify the data.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Displacement\-Grid ()} -\/ Set/\-Get the grid transform (the grid transform must have three components for displacement in x, y, and z respectively). The vtk\-Grid\-Transform class will never modify the data.  
\item {\ttfamily obj.\-Set\-Displacement\-Scale (double )} -\/ Set scale factor to be applied to the displacements. This is used primarily for grids which contain integer data types. Default\-: 1  
\item {\ttfamily double = obj.\-Get\-Displacement\-Scale ()} -\/ Set scale factor to be applied to the displacements. This is used primarily for grids which contain integer data types. Default\-: 1  
\item {\ttfamily obj.\-Set\-Displacement\-Shift (double )} -\/ Set a shift to be applied to the displacements. The shift is applied after the scale, i.\-e. x = scale$\ast$y + shift. Default\-: 0  
\item {\ttfamily double = obj.\-Get\-Displacement\-Shift ()} -\/ Set a shift to be applied to the displacements. The shift is applied after the scale, i.\-e. x = scale$\ast$y + shift. Default\-: 0  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode (int mode)} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Mode ()} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Nearest\-Neighbor ()} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Linear ()} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily obj.\-Set\-Interpolation\-Mode\-To\-Cubic ()} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily string = obj.\-Get\-Interpolation\-Mode\-As\-String ()} -\/ Set interpolation mode for sampling the grid. Higher-\/order interpolation allows you to use a sparser grid. Default\-: Linear.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkimagedatalic2d}{}\section{vtk\-Image\-Data\-L\-I\-C2\-D}\label{vtkhybrid_vtkimagedatalic2d}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
G\-P\-U implementation of a Line Integral Convolution, a technique for imaging vector fields.

The input on port 0 is an vtk\-Image\-Data with extents of a 2\-D image. It needs a vector field on point data. Port 1 is a special port for customized noise input. It is an optional port. If not present, noise is generated by the filter. Even if none-\/power-\/of-\/two texture are supported, giving a power-\/of-\/two image may result in faster execution on the G\-P\-U. If noise input is not specified, then the filter using vtk\-Image\-Noise\-Source to generate a 128x128 noise texture. This filter only works on point vectors. One can use a vtk\-Cell\-Data\-To\-Point\-Data filter to convert cell vectors to point vectors.

.S\-E\-C\-T\-I\-O\-N Required Open\-G\-L Extensins G\-L\-\_\-\-A\-R\-B\-\_\-texture\-\_\-non\-\_\-power\-\_\-of\-\_\-two G\-L\-\_\-\-V\-E\-R\-S\-I\-O\-N\-\_\-2\-\_\-0 G\-L\-\_\-\-A\-R\-B\-\_\-texture\-\_\-float G\-L\-\_\-\-A\-R\-B\-\_\-draw\-\_\-buffers G\-L\-\_\-\-E\-X\-T\-\_\-framebuffer\-\_\-object G\-L\-\_\-\-A\-R\-B\-\_\-pixel\-\_\-buffer\-\_\-object

To create an instance of class vtk\-Image\-Data\-L\-I\-C2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDataLIC2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Data\-L\-I\-C2\-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\-Image\-Data\-L\-I\-C2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Data\-L\-I\-C2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Data\-L\-I\-C2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Set\-Context (vtk\-Render\-Window context)} -\/ Get/\-Set the context. Context must be a vtk\-Open\-G\-L\-Render\-Window. This does not increase the reference count of the context to avoid reference loops. Set\-Context() may raise an error is the Open\-G\-L context does not support the required Open\-G\-L extensions. Return 0 upon failure and 1 upon success.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Context ()} -\/ Get/\-Set the context. Context must be a vtk\-Open\-G\-L\-Render\-Window. This does not increase the reference count of the context to avoid reference loops. Set\-Context() may raise an error is the Open\-G\-L context does not support the required Open\-G\-L extensions. Return 0 upon failure and 1 upon success.  
\item {\ttfamily obj.\-Set\-Steps (int )} -\/ Number of steps. Initial value is 20. class invariant\-: Steps$>$0. In term of visual quality, the greater the better.  
\item {\ttfamily int = obj.\-Get\-Steps ()} -\/ Number of steps. Initial value is 20. class invariant\-: Steps$>$0. In term of visual quality, the greater the better.  
\item {\ttfamily obj.\-Set\-Step\-Size (double )} -\/ Step size. Specify the step size as a unit of the cell length of the input vector field. Cell lenghth is the length of the diagonal of a cell. Initial value is 1.\-0. class invariant\-: Step\-Size$>$0.\-0. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is double but G\-P\-U only supports float. This value will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-Step\-Size\-Min\-Value ()} -\/ Step size. Specify the step size as a unit of the cell length of the input vector field. Cell lenghth is the length of the diagonal of a cell. Initial value is 1.\-0. class invariant\-: Step\-Size$>$0.\-0. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is double but G\-P\-U only supports float. This value will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-Step\-Size\-Max\-Value ()} -\/ Step size. Specify the step size as a unit of the cell length of the input vector field. Cell lenghth is the length of the diagonal of a cell. Initial value is 1.\-0. class invariant\-: Step\-Size$>$0.\-0. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is double but G\-P\-U only supports float. This value will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-Step\-Size ()} -\/ Step size. Specify the step size as a unit of the cell length of the input vector field. Cell lenghth is the length of the diagonal of a cell. Initial value is 1.\-0. class invariant\-: Step\-Size$>$0.\-0. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is double but G\-P\-U only supports float. This value will be converted to float in the execution of the algorithm.  
\item {\ttfamily obj.\-Set\-Magnification (int )} -\/ The the magnification factor. Default is 1  
\item {\ttfamily int = obj.\-Get\-Magnification\-Min\-Value ()} -\/ The the magnification factor. Default is 1  
\item {\ttfamily int = obj.\-Get\-Magnification\-Max\-Value ()} -\/ The the magnification factor. Default is 1  
\item {\ttfamily int = obj.\-Get\-Magnification ()} -\/ The the magnification factor. Default is 1  
\item {\ttfamily int = obj.\-Get\-Open\-G\-L\-Extensions\-Supported ()} -\/ Check if the required Open\-G\-L extensions / G\-P\-U are supported.  
\item {\ttfamily int = obj.\-Get\-F\-B\-O\-Success ()} -\/ Check if L\-I\-C runs properly.  
\item {\ttfamily int = obj.\-Get\-L\-I\-C\-Success ()}  
\item {\ttfamily obj.\-Translate\-Input\-Extent (int in\-Ext, int in\-Whole\-Extent, int out\-Ext)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkimagedatalic2dextenttranslator}{}\section{vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator}\label{vtkhybrid_vtkimagedatalic2dextenttranslator}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageDataLIC2DExtentTranslator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator 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\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Data\-L\-I\-C2\-D\-Extent\-Translator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Algorithm (vtk\-Image\-Data\-L\-I\-C2\-D )} -\/ Set the vtk\-Image\-Data\-L\-I\-C2\-D algorithm for which this extent translator is being used.  
\item {\ttfamily vtk\-Image\-Data\-L\-I\-C2\-D = obj.\-Get\-Algorithm ()} -\/ Set the vtk\-Image\-Data\-L\-I\-C2\-D algorithm for which this extent translator is being used.  
\item {\ttfamily obj.\-Set\-Input\-Extent\-Translator (vtk\-Extent\-Translator )}  
\item {\ttfamily vtk\-Extent\-Translator = obj.\-Get\-Input\-Extent\-Translator ()}  
\item {\ttfamily obj.\-Set\-Input\-Whole\-Extent (int , int , int , int , int , int )}  
\item {\ttfamily obj.\-Set\-Input\-Whole\-Extent (int a\mbox{[}6\mbox{]})}  
\item {\ttfamily int = obj. Get\-Input\-Whole\-Extent ()}  
\item {\ttfamily int = obj.\-Piece\-To\-Extent\-Thread\-Safe (int piece, int num\-Pieces, int ghost\-Level, int whole\-Extent, int result\-Extent, int split\-Mode, int by\-Points)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkimagetopolydatafilter}{}\section{vtk\-Image\-To\-Poly\-Data\-Filter}\label{vtkhybrid_vtkimagetopolydatafilter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-To\-Poly\-Data\-Filter converts raster data (i.\-e., an image) into polygonal data (i.\-e., quads or n-\/sided polygons), with each polygon assigned a constant color. This is useful for writers that generate vector formats (i.\-e., C\-G\-M or Post\-Script). To use this filter, you specify how to quantize the color (or whether to use an image with a lookup table), and what style the output should be. The output is always polygons, but the choice is n x m quads (where n and m define the input image dimensions) \char`\"{}\-Pixelize\char`\"{} option; arbitrary polygons \char`\"{}\-Polygonalize\char`\"{} option; or variable number of quads of constant color generated along scan lines \char`\"{}\-Run\-Length\char`\"{} option.

The algorithm quantizes color in order to create coherent regions that the polygons can represent with good compression. By default, the input image is quantized to 256 colors using a 3-\/3-\/2 bits for red-\/green-\/blue. However, you can also supply a single component image and a lookup table, with the single component assumed to be an index into the table. (Note\-: a quantized image can be generated with the filter vtk\-Image\-Quantize\-R\-G\-B\-To\-Index.) The number of colors on output is equal to the number of colors in the input lookup table (or 256 if the built in linear ramp is used).

The output of the filter is polygons with a single color per polygon cell. If the output style is set to \char`\"{}\-Polygonalize\char`\"{}, the polygons may have an large number of points (bounded by something like 2$\ast$(n+m)); and the polygon may not be convex which may cause rendering problems on some systems (use vtk\-Triangle\-Filter). Otherwise, each polygon will have four vertices. The output also contains scalar data defining R\-G\-B color in unsigned char form.

To create an instance of class vtk\-Image\-To\-Poly\-Data\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageToPolyDataFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-To\-Poly\-Data\-Filter 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\-Image\-To\-Poly\-Data\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-To\-Poly\-Data\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-To\-Poly\-Data\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Output\-Style (int )} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily int = obj.\-Get\-Output\-Style\-Min\-Value ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily int = obj.\-Get\-Output\-Style\-Max\-Value ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily int = obj.\-Get\-Output\-Style ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily obj.\-Set\-Output\-Style\-To\-Pixelize ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily obj.\-Set\-Output\-Style\-To\-Polygonalize ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily obj.\-Set\-Output\-Style\-To\-Run\-Length ()} -\/ Specify how to create the output. Pixelize means converting the image to quad polygons with a constant color per quad. Polygonalize means merging colors together into polygonal regions, and then smoothing the regions (if smoothing is turned on). Run\-Length means creating quad polygons that may encompass several pixels on a scan line. The default behavior is Polygonalize.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Specify how to quantize color.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode\-Min\-Value ()} -\/ Specify how to quantize color.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode\-Max\-Value ()} -\/ Specify how to quantize color.  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Specify how to quantize color.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-L\-U\-T ()} -\/ Specify how to quantize color.  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Linear256 ()} -\/ Specify how to quantize color.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors )} -\/ Set/\-Get the vtk\-Lookup\-Table to use. The lookup table is used when the color mode is set to L\-U\-T and a single component scalar is input.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Set/\-Get the vtk\-Lookup\-Table to use. The lookup table is used when the color mode is set to L\-U\-T and a single component scalar is input.  
\item {\ttfamily obj.\-Set\-Smoothing (int )} -\/ If the output style is set to polygonalize, then you can control whether to smooth boundaries.  
\item {\ttfamily int = obj.\-Get\-Smoothing ()} -\/ If the output style is set to polygonalize, then you can control whether to smooth boundaries.  
\item {\ttfamily obj.\-Smoothing\-On ()} -\/ If the output style is set to polygonalize, then you can control whether to smooth boundaries.  
\item {\ttfamily obj.\-Smoothing\-Off ()} -\/ If the output style is set to polygonalize, then you can control whether to smooth boundaries.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Smoothing\-Iterations (int )} -\/ Specify the number of smoothing iterations to smooth polygons. (Only in effect if output style is Polygonalize and smoothing is on.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Smoothing\-Iterations\-Min\-Value ()} -\/ Specify the number of smoothing iterations to smooth polygons. (Only in effect if output style is Polygonalize and smoothing is on.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Smoothing\-Iterations\-Max\-Value ()} -\/ Specify the number of smoothing iterations to smooth polygons. (Only in effect if output style is Polygonalize and smoothing is on.)  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Smoothing\-Iterations ()} -\/ Specify the number of smoothing iterations to smooth polygons. (Only in effect if output style is Polygonalize and smoothing is on.)  
\item {\ttfamily obj.\-Set\-Decimation (int )} -\/ Turn on/off whether the final polygons should be decimated. whether to smooth boundaries.  
\item {\ttfamily int = obj.\-Get\-Decimation ()} -\/ Turn on/off whether the final polygons should be decimated. whether to smooth boundaries.  
\item {\ttfamily obj.\-Decimation\-On ()} -\/ Turn on/off whether the final polygons should be decimated. whether to smooth boundaries.  
\item {\ttfamily obj.\-Decimation\-Off ()} -\/ Turn on/off whether the final polygons should be decimated. whether to smooth boundaries.  
\item {\ttfamily obj.\-Set\-Decimation\-Error (double )} -\/ Specify the error to use for decimation (if decimation is on). The error is an absolute number--the image spacing and dimensions are used to create points so the error should be consistent with the image size.  
\item {\ttfamily double = obj.\-Get\-Decimation\-Error\-Min\-Value ()} -\/ Specify the error to use for decimation (if decimation is on). The error is an absolute number--the image spacing and dimensions are used to create points so the error should be consistent with the image size.  
\item {\ttfamily double = obj.\-Get\-Decimation\-Error\-Max\-Value ()} -\/ Specify the error to use for decimation (if decimation is on). The error is an absolute number--the image spacing and dimensions are used to create points so the error should be consistent with the image size.  
\item {\ttfamily double = obj.\-Get\-Decimation\-Error ()} -\/ Specify the error to use for decimation (if decimation is on). The error is an absolute number--the image spacing and dimensions are used to create points so the error should be consistent with the image size.  
\item {\ttfamily obj.\-Set\-Error (int )} -\/ Specify the error value between two colors where the colors are considered the same. Only use this if the color mode uses the default 256 table.  
\item {\ttfamily int = obj.\-Get\-Error\-Min\-Value ()} -\/ Specify the error value between two colors where the colors are considered the same. Only use this if the color mode uses the default 256 table.  
\item {\ttfamily int = obj.\-Get\-Error\-Max\-Value ()} -\/ Specify the error value between two colors where the colors are considered the same. Only use this if the color mode uses the default 256 table.  
\item {\ttfamily int = obj.\-Get\-Error ()} -\/ Specify the error value between two colors where the colors are considered the same. Only use this if the color mode uses the default 256 table.  
\item {\ttfamily obj.\-Set\-Sub\-Image\-Size (int )} -\/ Specify the size (n by n pixels) of the largest region to polygonalize. When the Output\-Style is set to V\-T\-K\-\_\-\-S\-T\-Y\-L\-E\-\_\-\-P\-O\-L\-Y\-G\-O\-N\-A\-L\-I\-Z\-E, large amounts of memory are used. In order to process large images, the image is broken into pieces that are at most Size pixels in width and height.  
\item {\ttfamily int = obj.\-Get\-Sub\-Image\-Size\-Min\-Value ()} -\/ Specify the size (n by n pixels) of the largest region to polygonalize. When the Output\-Style is set to V\-T\-K\-\_\-\-S\-T\-Y\-L\-E\-\_\-\-P\-O\-L\-Y\-G\-O\-N\-A\-L\-I\-Z\-E, large amounts of memory are used. In order to process large images, the image is broken into pieces that are at most Size pixels in width and height.  
\item {\ttfamily int = obj.\-Get\-Sub\-Image\-Size\-Max\-Value ()} -\/ Specify the size (n by n pixels) of the largest region to polygonalize. When the Output\-Style is set to V\-T\-K\-\_\-\-S\-T\-Y\-L\-E\-\_\-\-P\-O\-L\-Y\-G\-O\-N\-A\-L\-I\-Z\-E, large amounts of memory are used. In order to process large images, the image is broken into pieces that are at most Size pixels in width and height.  
\item {\ttfamily int = obj.\-Get\-Sub\-Image\-Size ()} -\/ Specify the size (n by n pixels) of the largest region to polygonalize. When the Output\-Style is set to V\-T\-K\-\_\-\-S\-T\-Y\-L\-E\-\_\-\-P\-O\-L\-Y\-G\-O\-N\-A\-L\-I\-Z\-E, large amounts of memory are used. In order to process large images, the image is broken into pieces that are at most Size pixels in width and height.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkimplicitmodeller}{}\section{vtk\-Implicit\-Modeller}\label{vtkhybrid_vtkimplicitmodeller}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Implicit\-Modeller is a filter that computes the distance from the input geometry to the points of an output structured point set. This distance function can then be \char`\"{}contoured\char`\"{} to generate new, offset surfaces from the original geometry. An important feature of this object is \char`\"{}capping\char`\"{}. If capping is turned on, after the implicit model is created, the values on the boundary of the structured points dataset are set to the cap value. This is used to force closure of the resulting contoured surface. Note, however, that large cap values can generate weird surface normals in those cells adjacent to the boundary of the dataset. Using smaller cap value will reduce this effect. 

Another important ivar is Maximum\-Distance. This controls how far into the volume the distance function is computed from the input geometry. Small values give significant increases in performance. However, there can strange sampling effects at the extreme range of the Maximum\-Distance. 

In order to properly execute and sample the input data, a rectangular region in space must be defined (this is the ivar Model\-Bounds). If not explicitly defined, the model bounds will be computed. Note that to avoid boundary effects, it is possible to adjust the model bounds (i.\-e., using the Adjust\-Bounds and Adjust\-Distance ivars) to strictly contain the sampled data. 

This filter has one other unusual capability\-: it is possible to append data in a sequence of operations to generate a single output. This is useful when you have multiple datasets and want to create a conglomeration of all the data. However, the user must be careful to either specify the Model\-Bounds or specify the first item such that its bounds completely contain all other items. This is because the rectangular region of the output can not be changed after the 1st Append. 

The Process\-Mode ivar controls the method used within the Append function (where the actual work is done regardless if the Append function is explicitly called) to compute the implicit model. If set to work in voxel mode, each voxel is visited once. If set to cell mode, each cell is visited once. Tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode. Also, if explicitly using the Append feature many times, the cell mode will probably be better because each voxel will be visited each Append. Append the data before input if possible when using the voxel mode. Do not switch between voxel and cell mode between execution of Start\-Append and End\-Append. 

Further performance improvement is now possible using the Per\-Voxel process mode on multi-\/processor machines (the mode is now multithreaded). Each thread processes a different \char`\"{}slab\char`\"{} of the output. Also, if the input is vtk\-Poly\-Data, it is appropriately clipped for each thread; that is, each thread only considers the input which could affect its slab of the output. 

This filter can now produce output of any type supported by vtk\-Image\-Data. However to support this change, additional sqrts must be executed during the Append step. Previously, the output was initialized to the squared Cap\-Value in Start\-Append, the output was updated with squared distance values during the Append, and then the sqrt of the distances was computed in End\-Append. To support different scalar types in the output (largely to reduce memory requirements as an vtk\-Image\-Shift\-Scale and/or vtk\-Image\-Cast could have achieved the same result), we can't \char`\"{}afford\char`\"{} to save squared value in the output, because then we could only represent up to the sqrt of the scalar max for an integer type in the output; 1 (instead of 255) for an unsigned char; 11 for a char (instead of 127). Thus this change may result in a minor performance degradation. Non-\/float output types can be scaled to the Cap\-Value by turning Scale\-To\-Maximum\-Distance On.

To create an instance of class vtk\-Implicit\-Modeller, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitModeller
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Modeller 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\-Implicit\-Modeller class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Modeller = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Modeller = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Compute\-Model\-Bounds (vtk\-Data\-Set input\-N\-U\-L\-L)} -\/ Compute Model\-Bounds from input geometry. If input is not specified, the input of the filter will be used.  
\item {\ttfamily int = obj. Get\-Sample\-Dimensions ()} -\/ Set/\-Get the i-\/j-\/k dimensions on which to sample distance function.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int i, int j, int k)} -\/ Set/\-Get the i-\/j-\/k dimensions on which to sample distance function.  
\item {\ttfamily obj.\-Set\-Sample\-Dimensions (int dim\mbox{[}3\mbox{]})} -\/ Set/\-Get the i-\/j-\/k dimensions on which to sample distance function.  
\item {\ttfamily obj.\-Set\-Maximum\-Distance (double )} -\/ Set / get the distance away from surface of input geometry to sample. Smaller values make large increases in performance.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Min\-Value ()} -\/ Set / get the distance away from surface of input geometry to sample. Smaller values make large increases in performance.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance\-Max\-Value ()} -\/ Set / get the distance away from surface of input geometry to sample. Smaller values make large increases in performance.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Distance ()} -\/ Set / get the distance away from surface of input geometry to sample. Smaller values make large increases in performance.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double , double , double , double , double , double )} -\/ Set / get the region in space in which to perform the sampling. If not specified, it will be computed automatically.  
\item {\ttfamily obj.\-Set\-Model\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Set / get the region in space in which to perform the sampling. If not specified, it will be computed automatically.  
\item {\ttfamily double = obj. Get\-Model\-Bounds ()} -\/ Set / get the region in space in which to perform the sampling. If not specified, it will be computed automatically.  
\item {\ttfamily obj.\-Set\-Adjust\-Bounds (int )} -\/ Control how the model bounds are computed. If the ivar Adjust\-Bounds is set, then the bounds specified (or computed automatically) is modified by the fraction given by Adjust\-Distance. This means that the model bounds is expanded in each of the x-\/y-\/z directions.  
\item {\ttfamily int = obj.\-Get\-Adjust\-Bounds ()} -\/ Control how the model bounds are computed. If the ivar Adjust\-Bounds is set, then the bounds specified (or computed automatically) is modified by the fraction given by Adjust\-Distance. This means that the model bounds is expanded in each of the x-\/y-\/z directions.  
\item {\ttfamily obj.\-Adjust\-Bounds\-On ()} -\/ Control how the model bounds are computed. If the ivar Adjust\-Bounds is set, then the bounds specified (or computed automatically) is modified by the fraction given by Adjust\-Distance. This means that the model bounds is expanded in each of the x-\/y-\/z directions.  
\item {\ttfamily obj.\-Adjust\-Bounds\-Off ()} -\/ Control how the model bounds are computed. If the ivar Adjust\-Bounds is set, then the bounds specified (or computed automatically) is modified by the fraction given by Adjust\-Distance. This means that the model bounds is expanded in each of the x-\/y-\/z directions.  
\item {\ttfamily obj.\-Set\-Adjust\-Distance (double )} -\/ Specify the amount to grow the model bounds (if the ivar Adjust\-Bounds is set). The value is a fraction of the maximum length of the sides of the box specified by the model bounds.  
\item {\ttfamily double = obj.\-Get\-Adjust\-Distance\-Min\-Value ()} -\/ Specify the amount to grow the model bounds (if the ivar Adjust\-Bounds is set). The value is a fraction of the maximum length of the sides of the box specified by the model bounds.  
\item {\ttfamily double = obj.\-Get\-Adjust\-Distance\-Max\-Value ()} -\/ Specify the amount to grow the model bounds (if the ivar Adjust\-Bounds is set). The value is a fraction of the maximum length of the sides of the box specified by the model bounds.  
\item {\ttfamily double = obj.\-Get\-Adjust\-Distance ()} -\/ Specify the amount to grow the model bounds (if the ivar Adjust\-Bounds is set). The value is a fraction of the maximum length of the sides of the box specified by the model bounds.  
\item {\ttfamily obj.\-Set\-Capping (int )} -\/ The outer boundary of the structured point set can be assigned a particular value. This can be used to close or \char`\"{}cap\char`\"{} all surfaces.  
\item {\ttfamily int = obj.\-Get\-Capping ()} -\/ The outer boundary of the structured point set can be assigned a particular value. This can be used to close or \char`\"{}cap\char`\"{} all surfaces.  
\item {\ttfamily obj.\-Capping\-On ()} -\/ The outer boundary of the structured point set can be assigned a particular value. This can be used to close or \char`\"{}cap\char`\"{} all surfaces.  
\item {\ttfamily obj.\-Capping\-Off ()} -\/ The outer boundary of the structured point set can be assigned a particular value. This can be used to close or \char`\"{}cap\char`\"{} all surfaces.  
\item {\ttfamily obj.\-Set\-Cap\-Value (double value)} -\/ Specify the capping value to use. The Cap\-Value is also used as an initial distance value at each point in the dataset.  
\item {\ttfamily double = obj.\-Get\-Cap\-Value ()} -\/ Specify the capping value to use. The Cap\-Value is also used as an initial distance value at each point in the dataset.  
\item {\ttfamily obj.\-Set\-Scale\-To\-Maximum\-Distance (int )} -\/ If a non-\/floating output type is specified, the output distances can be scaled to use the entire positive scalar range of the output type specified (up to the Cap\-Value which is equal to the max for the type unless modified by the user). For example, if Scale\-To\-Maximum\-Distance is On and the Output\-Scalar\-Type is Unsigned\-Char the distances saved in the output would be linearly scaled between 0 (for distances \char`\"{}very close\char`\"{} to the surface) and 255 (at the specifed maximum distance)... assuming the Cap\-Value is not changed from 255.  
\item {\ttfamily int = obj.\-Get\-Scale\-To\-Maximum\-Distance ()} -\/ If a non-\/floating output type is specified, the output distances can be scaled to use the entire positive scalar range of the output type specified (up to the Cap\-Value which is equal to the max for the type unless modified by the user). For example, if Scale\-To\-Maximum\-Distance is On and the Output\-Scalar\-Type is Unsigned\-Char the distances saved in the output would be linearly scaled between 0 (for distances \char`\"{}very close\char`\"{} to the surface) and 255 (at the specifed maximum distance)... assuming the Cap\-Value is not changed from 255.  
\item {\ttfamily obj.\-Scale\-To\-Maximum\-Distance\-On ()} -\/ If a non-\/floating output type is specified, the output distances can be scaled to use the entire positive scalar range of the output type specified (up to the Cap\-Value which is equal to the max for the type unless modified by the user). For example, if Scale\-To\-Maximum\-Distance is On and the Output\-Scalar\-Type is Unsigned\-Char the distances saved in the output would be linearly scaled between 0 (for distances \char`\"{}very close\char`\"{} to the surface) and 255 (at the specifed maximum distance)... assuming the Cap\-Value is not changed from 255.  
\item {\ttfamily obj.\-Scale\-To\-Maximum\-Distance\-Off ()} -\/ If a non-\/floating output type is specified, the output distances can be scaled to use the entire positive scalar range of the output type specified (up to the Cap\-Value which is equal to the max for the type unless modified by the user). For example, if Scale\-To\-Maximum\-Distance is On and the Output\-Scalar\-Type is Unsigned\-Char the distances saved in the output would be linearly scaled between 0 (for distances \char`\"{}very close\char`\"{} to the surface) and 255 (at the specifed maximum distance)... assuming the Cap\-Value is not changed from 255.  
\item {\ttfamily obj.\-Set\-Process\-Mode (int )} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily int = obj.\-Get\-Process\-Mode\-Min\-Value ()} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily int = obj.\-Get\-Process\-Mode\-Max\-Value ()} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily int = obj.\-Get\-Process\-Mode ()} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily obj.\-Set\-Process\-Mode\-To\-Per\-Voxel ()} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily obj.\-Set\-Process\-Mode\-To\-Per\-Cell ()} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily string = obj.\-Get\-Process\-Mode\-As\-String (void )} -\/ Specify whether to visit each cell once per append or each voxel once per append. Some tests have shown once per voxel to be faster when there are a lot of cells (at least a thousand?); relative performance improvement increases with addition cells. Primitives should not be stripped for best performance of the voxel mode.  
\item {\ttfamily obj.\-Set\-Locator\-Max\-Level (int )} -\/ Specify the level of the locator to use when using the per voxel process mode.  
\item {\ttfamily int = obj.\-Get\-Locator\-Max\-Level ()} -\/ Specify the level of the locator to use when using the per voxel process mode.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Threads (int )} -\/ Set / Get the number of threads used during Per-\/\-Voxel processing mode  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Min\-Value ()} -\/ Set / Get the number of threads used during Per-\/\-Voxel processing mode  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads\-Max\-Value ()} -\/ Set / Get the number of threads used during Per-\/\-Voxel processing mode  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Threads ()} -\/ Set / Get the number of threads used during Per-\/\-Voxel processing mode  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type (int type)} -\/ Set the desired output scalar type.  
\item {\ttfamily int = obj.\-Get\-Output\-Scalar\-Type ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Float ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Double ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Int ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Int ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Long ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Long ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Short ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Set\-Output\-Scalar\-Type\-To\-Char ()} -\/ Set the desired output scalar type.  
\item {\ttfamily obj.\-Start\-Append ()} -\/ Initialize the filter for appending data. You must invoke the Start\-Append() method before doing successive Appends(). It's also a good idea to manually specify the model bounds; otherwise the input bounds for the data will be used.  
\item {\ttfamily obj.\-Append (vtk\-Data\-Set input)} -\/ Append a data set to the existing output. To use this function, you'll have to invoke the Start\-Append() method before doing successive appends. It's also a good idea to specify the model bounds; otherwise the input model bounds is used. When you've finished appending, use the End\-Append() method.  
\item {\ttfamily obj.\-End\-Append ()} -\/ Method completes the append process.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkiterativeclosestpointtransform}{}\section{vtk\-Iterative\-Closest\-Point\-Transform}\label{vtkhybrid_vtkiterativeclosestpointtransform}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Match two surfaces using the iterative closest point (I\-C\-P) algorithm. The core of the algorithm is to match each vertex in one surface with the closest surface point on the other, then apply the transformation that modify one surface to best match the other (in a least square sense). This has to be iterated to get proper convergence of the surfaces. .S\-E\-C\-T\-I\-O\-N Note Use vtk\-Transform\-Poly\-Data\-Filter to apply the resulting I\-C\-P transform to your data. You might also set it to your actor's user transform. .S\-E\-C\-T\-I\-O\-N Note This class makes use of vtk\-Landmark\-Transform internally to compute the best fit. Use the Get\-Landmark\-Transform member to get a pointer to that transform and set its parameters. You might, for example, constrain the number of degrees of freedom of the solution (i.\-e. rigid body, similarity, etc.) by checking the vtk\-Landmark\-Transform documentation for its Set\-Mode member.

To create an instance of class vtk\-Iterative\-Closest\-Point\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIterativeClosestPointTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Iterative\-Closest\-Point\-Transform 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\-Iterative\-Closest\-Point\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Iterative\-Closest\-Point\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Iterative\-Closest\-Point\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source (vtk\-Data\-Set source)} -\/ Specify the source and target data sets.  
\item {\ttfamily obj.\-Set\-Target (vtk\-Data\-Set target)} -\/ Specify the source and target data sets.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Source ()} -\/ Specify the source and target data sets.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Target ()} -\/ Specify the source and target data sets.  
\item {\ttfamily obj.\-Set\-Locator (vtk\-Cell\-Locator locator)} -\/ Set/\-Get a spatial locator for speeding up the search process. An instance of vtk\-Cell\-Locator is used by default.  
\item {\ttfamily vtk\-Cell\-Locator = obj.\-Get\-Locator ()} -\/ Set/\-Get a spatial locator for speeding up the search process. An instance of vtk\-Cell\-Locator is used by default.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Iterations (int )} -\/ Set/\-Get the maximum number of iterations. Default is 50.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Iterations ()} -\/ Set/\-Get the maximum number of iterations. Default is 50.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Iterations ()} -\/ Get the number of iterations since the last update  
\item {\ttfamily obj.\-Set\-Check\-Mean\-Distance (int )} -\/ Force the algorithm to check the mean distance between two iterations. Default is Off.  
\item {\ttfamily int = obj.\-Get\-Check\-Mean\-Distance ()} -\/ Force the algorithm to check the mean distance between two iterations. Default is Off.  
\item {\ttfamily obj.\-Check\-Mean\-Distance\-On ()} -\/ Force the algorithm to check the mean distance between two iterations. Default is Off.  
\item {\ttfamily obj.\-Check\-Mean\-Distance\-Off ()} -\/ Force the algorithm to check the mean distance between two iterations. Default is Off.  
\item {\ttfamily obj.\-Set\-Mean\-Distance\-Mode (int )} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily int = obj.\-Get\-Mean\-Distance\-Mode\-Min\-Value ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily int = obj.\-Get\-Mean\-Distance\-Mode\-Max\-Value ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily int = obj.\-Get\-Mean\-Distance\-Mode ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily obj.\-Set\-Mean\-Distance\-Mode\-To\-R\-M\-S ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily obj.\-Set\-Mean\-Distance\-Mode\-To\-Absolute\-Value ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily string = obj.\-Get\-Mean\-Distance\-Mode\-As\-String ()} -\/ Specify the mean distance mode. This mode expresses how the mean distance is computed. The R\-M\-S mode is the square root of the average of the sum of squares of the closest point distances. The Absolute Value mode is the mean of the sum of absolute values of the closest point distances. The default is V\-T\-K\-\_\-\-I\-C\-P\-\_\-\-M\-O\-D\-E\-\_\-\-R\-M\-S  
\item {\ttfamily obj.\-Set\-Maximum\-Mean\-Distance (double )} -\/ Set/\-Get the maximum mean distance between two iteration. If the mean distance is lower than this, the convergence stops. The default is 0.\-01.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Mean\-Distance ()} -\/ Set/\-Get the maximum mean distance between two iteration. If the mean distance is lower than this, the convergence stops. The default is 0.\-01.  
\item {\ttfamily double = obj.\-Get\-Mean\-Distance ()} -\/ Get the mean distance between the last two iterations.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Landmarks (int )} -\/ Set/\-Get the maximum number of landmarks sampled in your dataset. If your dataset is dense, then you will typically not need all the points to compute the I\-C\-P transform. The default is 200.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Landmarks ()} -\/ Set/\-Get the maximum number of landmarks sampled in your dataset. If your dataset is dense, then you will typically not need all the points to compute the I\-C\-P transform. The default is 200.  
\item {\ttfamily obj.\-Set\-Start\-By\-Matching\-Centroids (int )} -\/ Starts the process by translating source centroid to target centroid. The default is Off.  
\item {\ttfamily int = obj.\-Get\-Start\-By\-Matching\-Centroids ()} -\/ Starts the process by translating source centroid to target centroid. The default is Off.  
\item {\ttfamily obj.\-Start\-By\-Matching\-Centroids\-On ()} -\/ Starts the process by translating source centroid to target centroid. The default is Off.  
\item {\ttfamily obj.\-Start\-By\-Matching\-Centroids\-Off ()} -\/ Starts the process by translating source centroid to target centroid. The default is Off.  
\item {\ttfamily vtk\-Landmark\-Transform = obj.\-Get\-Landmark\-Transform ()} -\/ Get the internal landmark transform. Use it to constrain the number of degrees of freedom of the solution (i.\-e. rigid body, similarity, etc.).  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. This is done by switching the source and target.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtklandmarktransform}{}\section{vtk\-Landmark\-Transform}\label{vtkhybrid_vtklandmarktransform}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A vtk\-Landmark\-Transform is defined by two sets of landmarks, the transform computed gives the best fit mapping one onto the other, in a least squares sense. The indices are taken to correspond, so point 1 in the first set will get mapped close to point 1 in the second set, etc. Call Set\-Source\-Landmarks and Set\-Target\-Landmarks to specify the two sets of landmarks, ensure they have the same number of points.

To create an instance of class vtk\-Landmark\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLandmarkTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Landmark\-Transform 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\-Landmark\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Landmark\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Landmark\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Source\-Landmarks (vtk\-Points points)} -\/ Specify the source and target landmark sets. The two sets must have the same number of points. If you add or change points in these objects, you must call Modified() on them or the transformation might not update.  
\item {\ttfamily obj.\-Set\-Target\-Landmarks (vtk\-Points points)} -\/ Specify the source and target landmark sets. The two sets must have the same number of points. If you add or change points in these objects, you must call Modified() on them or the transformation might not update.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Source\-Landmarks ()} -\/ Specify the source and target landmark sets. The two sets must have the same number of points. If you add or change points in these objects, you must call Modified() on them or the transformation might not update.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Target\-Landmarks ()} -\/ Specify the source and target landmark sets. The two sets must have the same number of points. If you add or change points in these objects, you must call Modified() on them or the transformation might not update.  
\item {\ttfamily obj.\-Set\-Mode (int )} -\/ Set the number of degrees of freedom to constrain the solution to. Rigidbody (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-R\-I\-G\-I\-D\-B\-O\-D\-Y)\-: rotation and translation only. Similarity (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-S\-I\-M\-I\-L\-A\-R\-I\-T\-Y)\-: rotation, translation and isotropic scaling. Affine (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-A\-F\-F\-I\-N\-E)\-: collinearity is preserved. Ratios of distances along a line are preserved. The default is similarity.  
\item {\ttfamily obj.\-Set\-Mode\-To\-Rigid\-Body ()} -\/ Set the number of degrees of freedom to constrain the solution to. Rigidbody (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-R\-I\-G\-I\-D\-B\-O\-D\-Y)\-: rotation and translation only. Similarity (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-S\-I\-M\-I\-L\-A\-R\-I\-T\-Y)\-: rotation, translation and isotropic scaling. Affine (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-A\-F\-F\-I\-N\-E)\-: collinearity is preserved. Ratios of distances along a line are preserved. The default is similarity.  
\item {\ttfamily obj.\-Set\-Mode\-To\-Similarity ()} -\/ Set the number of degrees of freedom to constrain the solution to. Rigidbody (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-R\-I\-G\-I\-D\-B\-O\-D\-Y)\-: rotation and translation only. Similarity (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-S\-I\-M\-I\-L\-A\-R\-I\-T\-Y)\-: rotation, translation and isotropic scaling. Affine (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-A\-F\-F\-I\-N\-E)\-: collinearity is preserved. Ratios of distances along a line are preserved. The default is similarity.  
\item {\ttfamily obj.\-Set\-Mode\-To\-Affine ()} -\/ Set the number of degrees of freedom to constrain the solution to. Rigidbody (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-R\-I\-G\-I\-D\-B\-O\-D\-Y)\-: rotation and translation only. Similarity (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-S\-I\-M\-I\-L\-A\-R\-I\-T\-Y)\-: rotation, translation and isotropic scaling. Affine (V\-T\-K\-\_\-\-L\-A\-N\-D\-M\-A\-R\-K\-\_\-\-A\-F\-F\-I\-N\-E)\-: collinearity is preserved. Ratios of distances along a line are preserved. The default is similarity.  
\item {\ttfamily int = obj.\-Get\-Mode ()} -\/ Get the current transformation mode.  
\item {\ttfamily string = obj.\-Get\-Mode\-As\-String ()} -\/ Get the current transformation mode.  
\item {\ttfamily obj.\-Inverse ()} -\/ Invert the transformation. This is done by switching the source and target landmarks.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtklegendboxactor}{}\section{vtk\-Legend\-Box\-Actor}\label{vtkhybrid_vtklegendboxactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Legend\-Box\-Actor is used to associate a symbol with a text string. The user specifies a vtk\-Poly\-Data to use as the symbol, and a string associated with the symbol. The actor can then be placed in the scene in the same way that any other vtk\-Actor2\-D can be used.

To use this class, you must define the position of the legend box by using the superclasses' vtk\-Actor2\-D\-::\-Position coordinate and Position2 coordinate. Then define the set of symbols and text strings that make up the menu box. The font attributes of the entries can be set through the vtk\-Text\-Property associated to this actor. The class will scale the symbols and text to fit in the legend box defined by (Position,Position2). Optional features like turning on a border line and setting the spacing between the border and the symbols/text can also be set.

To create an instance of class vtk\-Legend\-Box\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLegendBoxActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Legend\-Box\-Actor 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\-Legend\-Box\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Entries (int num)} -\/ Specify the number of entries in the legend box.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Entries ()} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry (int i, vtk\-Poly\-Data symbol, string string, double color\mbox{[}3\mbox{]})} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry\-Symbol (int i, vtk\-Poly\-Data symbol)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry\-String (int i, string string)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry\-Color (int i, double color\mbox{[}3\mbox{]})} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry\-Color (int i, double r, double g, double b)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Entry\-Symbol (int i)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily string = obj.\-Get\-Entry\-String (int i)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily double = obj.\-Get\-Entry\-Color (int i)} -\/ Add an entry to the legend box. You must supply a vtk\-Poly\-Data to be used as a symbol (it can be N\-U\-L\-L) and a text string (which also can be N\-U\-L\-L). The vtk\-Poly\-Data is assumed to be defined in the x-\/y plane, and the text is assumed to be a single line in height. Note that when this method is invoked previous entries are deleted. Also supply a text string and optionally a color. (If a color is not specified, then the entry color is the same as this actor's color.) (Note\-: use the set methods when you use Set\-Number\-Of\-Entries().)  
\item {\ttfamily obj.\-Set\-Entry\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Entry\-Text\-Property ()} -\/ Set/\-Get the text property.  
\item {\ttfamily obj.\-Set\-Border (int )} -\/ Set/\-Get the flag that controls whether a border will be drawn around the legend box.  
\item {\ttfamily int = obj.\-Get\-Border ()} -\/ Set/\-Get the flag that controls whether a border will be drawn around the legend box.  
\item {\ttfamily obj.\-Border\-On ()} -\/ Set/\-Get the flag that controls whether a border will be drawn around the legend box.  
\item {\ttfamily obj.\-Border\-Off ()} -\/ Set/\-Get the flag that controls whether a border will be drawn around the legend box.  
\item {\ttfamily obj.\-Set\-Lock\-Border (int )} -\/ Set/\-Get the flag that controls whether the border and legend placement is locked into the rectangle defined by (Position,Position2). If off, then the legend box will adjust its size so that the border fits nicely around the text and symbols. (The ivar is off by default.) Note\-: the legend box is guaranteed to lie within the original border definition.  
\item {\ttfamily int = obj.\-Get\-Lock\-Border ()} -\/ Set/\-Get the flag that controls whether the border and legend placement is locked into the rectangle defined by (Position,Position2). If off, then the legend box will adjust its size so that the border fits nicely around the text and symbols. (The ivar is off by default.) Note\-: the legend box is guaranteed to lie within the original border definition.  
\item {\ttfamily obj.\-Lock\-Border\-On ()} -\/ Set/\-Get the flag that controls whether the border and legend placement is locked into the rectangle defined by (Position,Position2). If off, then the legend box will adjust its size so that the border fits nicely around the text and symbols. (The ivar is off by default.) Note\-: the legend box is guaranteed to lie within the original border definition.  
\item {\ttfamily obj.\-Lock\-Border\-Off ()} -\/ Set/\-Get the flag that controls whether the border and legend placement is locked into the rectangle defined by (Position,Position2). If off, then the legend box will adjust its size so that the border fits nicely around the text and symbols. (The ivar is off by default.) Note\-: the legend box is guaranteed to lie within the original border definition.  
\item {\ttfamily obj.\-Set\-Box (int )} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily int = obj.\-Get\-Box ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily obj.\-Box\-On ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily obj.\-Box\-Off ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Box\-Property ()} -\/ Get the box vtk\-Property2\-D.  
\item {\ttfamily obj.\-Set\-Padding (int )} -\/ Set/\-Get the padding between the legend entries and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding\-Min\-Value ()} -\/ Set/\-Get the padding between the legend entries and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding\-Max\-Value ()} -\/ Set/\-Get the padding between the legend entries and the border. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Padding ()} -\/ Set/\-Get the padding between the legend entries and the border. The value is specified in pixels.  
\item {\ttfamily obj.\-Set\-Scalar\-Visibility (int )} -\/ Turn on/off flag to control whether the symbol's scalar data is used to color the symbol. If off, the color of the vtk\-Legend\-Box\-Actor is used.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Visibility ()} -\/ Turn on/off flag to control whether the symbol's scalar data is used to color the symbol. If off, the color of the vtk\-Legend\-Box\-Actor is used.  
\item {\ttfamily obj.\-Scalar\-Visibility\-On ()} -\/ Turn on/off flag to control whether the symbol's scalar data is used to color the symbol. If off, the color of the vtk\-Legend\-Box\-Actor is used.  
\item {\ttfamily obj.\-Scalar\-Visibility\-Off ()} -\/ Turn on/off flag to control whether the symbol's scalar data is used to color the symbol. If off, the color of the vtk\-Legend\-Box\-Actor is used.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this scaled text actor. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtklegendscaleactor}{}\section{vtk\-Legend\-Scale\-Actor}\label{vtkhybrid_vtklegendscaleactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to annotate the render window. Its basic goal is to provide an indication of the scale of the scene. Four axes surrounding the render window indicate (in a variety of ways) the scale of what the camera is viewing. An option also exists for displaying a scale legend.

The axes can be programmed either to display distance scales or x-\/y coordinate values. By default, the scales display a distance. However, if you know that the view is down the z-\/axis, the scales can be programmed to display x-\/y coordinate values.

To create an instance of class vtk\-Legend\-Scale\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLegendScaleActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Legend\-Scale\-Actor 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\-Legend\-Scale\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Legend\-Scale\-Actor = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Legend\-Scale\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Set\-Label\-Mode (int )} -\/ Specify the mode for labeling the scale axes. By default, the axes are labeled with the distance between points (centered at a distance of 0.\-0). Alternatively if you know that the view is down the z-\/axis; the axes can be labeled with x-\/y coordinate values.  
\item {\ttfamily int = obj.\-Get\-Label\-Mode\-Min\-Value ()} -\/ Specify the mode for labeling the scale axes. By default, the axes are labeled with the distance between points (centered at a distance of 0.\-0). Alternatively if you know that the view is down the z-\/axis; the axes can be labeled with x-\/y coordinate values.  
\item {\ttfamily int = obj.\-Get\-Label\-Mode\-Max\-Value ()} -\/ Specify the mode for labeling the scale axes. By default, the axes are labeled with the distance between points (centered at a distance of 0.\-0). Alternatively if you know that the view is down the z-\/axis; the axes can be labeled with x-\/y coordinate values.  
\item {\ttfamily int = obj.\-Get\-Label\-Mode ()} -\/ Specify the mode for labeling the scale axes. By default, the axes are labeled with the distance between points (centered at a distance of 0.\-0). Alternatively if you know that the view is down the z-\/axis; the axes can be labeled with x-\/y coordinate values.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Distance ()} -\/ Specify the mode for labeling the scale axes. By default, the axes are labeled with the distance between points (centered at a distance of 0.\-0). Alternatively if you know that the view is down the z-\/axis; the axes can be labeled with x-\/y coordinate values.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-X\-Y\-Coordinates ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Set\-Right\-Axis\-Visibility (int )} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily int = obj.\-Get\-Right\-Axis\-Visibility ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Right\-Axis\-Visibility\-On ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Right\-Axis\-Visibility\-Off ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Set\-Top\-Axis\-Visibility (int )} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily int = obj.\-Get\-Top\-Axis\-Visibility ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Top\-Axis\-Visibility\-On ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Top\-Axis\-Visibility\-Off ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Set\-Left\-Axis\-Visibility (int )} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily int = obj.\-Get\-Left\-Axis\-Visibility ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Left\-Axis\-Visibility\-On ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Left\-Axis\-Visibility\-Off ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Set\-Bottom\-Axis\-Visibility (int )} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily int = obj.\-Get\-Bottom\-Axis\-Visibility ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Bottom\-Axis\-Visibility\-On ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Bottom\-Axis\-Visibility\-Off ()} -\/ Set/\-Get the flags that control which of the four axes to display (top, bottom, left and right). By default, all the axes are displayed.  
\item {\ttfamily obj.\-Set\-Legend\-Visibility (int )} -\/ Indicate whether the legend scale should be displayed or not. The default is On.  
\item {\ttfamily int = obj.\-Get\-Legend\-Visibility ()} -\/ Indicate whether the legend scale should be displayed or not. The default is On.  
\item {\ttfamily obj.\-Legend\-Visibility\-On ()} -\/ Indicate whether the legend scale should be displayed or not. The default is On.  
\item {\ttfamily obj.\-Legend\-Visibility\-Off ()} -\/ Indicate whether the legend scale should be displayed or not. The default is On.  
\item {\ttfamily obj.\-All\-Axes\-On ()} -\/ Convenience method that turns all the axes either on or off.  
\item {\ttfamily obj.\-All\-Axes\-Off ()} -\/ Convenience method that turns all the axes either on or off.  
\item {\ttfamily obj.\-All\-Annotations\-On ()} -\/ Convenience method that turns all the axes and the legend scale.  
\item {\ttfamily obj.\-All\-Annotations\-Off ()} -\/ Convenience method that turns all the axes and the legend scale.  
\item {\ttfamily obj.\-Set\-Right\-Border\-Offset (int )} -\/ Set/\-Get the offset of the right axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Right\-Border\-Offset\-Min\-Value ()} -\/ Set/\-Get the offset of the right axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Right\-Border\-Offset\-Max\-Value ()} -\/ Set/\-Get the offset of the right axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Right\-Border\-Offset ()} -\/ Set/\-Get the offset of the right axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily obj.\-Set\-Top\-Border\-Offset (int )} -\/ Set/\-Get the offset of the top axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Top\-Border\-Offset\-Min\-Value ()} -\/ Set/\-Get the offset of the top axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Top\-Border\-Offset\-Max\-Value ()} -\/ Set/\-Get the offset of the top axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Top\-Border\-Offset ()} -\/ Set/\-Get the offset of the top axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily obj.\-Set\-Left\-Border\-Offset (int )} -\/ Set/\-Get the offset of the left axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Left\-Border\-Offset\-Min\-Value ()} -\/ Set/\-Get the offset of the left axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Left\-Border\-Offset\-Max\-Value ()} -\/ Set/\-Get the offset of the left axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily int = obj.\-Get\-Left\-Border\-Offset ()} -\/ Set/\-Get the offset of the left axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 50.  
\item {\ttfamily obj.\-Set\-Bottom\-Border\-Offset (int )} -\/ Set/\-Get the offset of the bottom axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Bottom\-Border\-Offset\-Min\-Value ()} -\/ Set/\-Get the offset of the bottom axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Bottom\-Border\-Offset\-Max\-Value ()} -\/ Set/\-Get the offset of the bottom axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily int = obj.\-Get\-Bottom\-Border\-Offset ()} -\/ Set/\-Get the offset of the bottom axis from the border. This number is expressed in pixels, and represents the approximate distance of the axes from the sides of the renderer. The default is 30.  
\item {\ttfamily obj.\-Set\-Corner\-Offset\-Factor (double )} -\/ Get/\-Set the corner offset. This is the offset factor used to offset the axes at the corners. Default value is 2.\-0.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset\-Factor\-Min\-Value ()} -\/ Get/\-Set the corner offset. This is the offset factor used to offset the axes at the corners. Default value is 2.\-0.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset\-Factor\-Max\-Value ()} -\/ Get/\-Set the corner offset. This is the offset factor used to offset the axes at the corners. Default value is 2.\-0.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset\-Factor ()} -\/ Get/\-Set the corner offset. This is the offset factor used to offset the axes at the corners. Default value is 2.\-0.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Legend\-Title\-Property ()} -\/ Set/\-Get the labels text properties for the legend title and labels.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Legend\-Label\-Property ()} -\/ Set/\-Get the labels text properties for the legend title and labels.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Right\-Axis ()} -\/ These are methods to retrieve the vtk\-Axis\-Actors used to represent the four axes that form this representation. Users may retrieve and then modify these axes to control their appearance.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Top\-Axis ()} -\/ These are methods to retrieve the vtk\-Axis\-Actors used to represent the four axes that form this representation. Users may retrieve and then modify these axes to control their appearance.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Left\-Axis ()} -\/ These are methods to retrieve the vtk\-Axis\-Actors used to represent the four axes that form this representation. Users may retrieve and then modify these axes to control their appearance.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Bottom\-Axis ()} -\/ These are methods to retrieve the vtk\-Axis\-Actors used to represent the four axes that form this representation. Users may retrieve and then modify these axes to control their appearance.  
\item {\ttfamily obj.\-Build\-Representation (vtk\-Viewport viewport)}  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtklsdynareader}{}\section{vtk\-L\-S\-Dyna\-Reader}\label{vtkhybrid_vtklsdynareader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter reads L\-S-\/\-Dyna databases.

The Set/\-Get\-File\-Name() routines are actually wrappers around the Set/\-Get\-Database\-Directory() members; the actual filename you choose is irrelevant -- only the directory name is used. This is done in order to accommodate Para\-View.

Note that this reader produces 7 output meshes. These meshes are required as several attributes are defined on subsets of the mesh. Below is a list of meshes in the order they are output and an explanation of which attributes are unique to each mesh\-:
\begin{DoxyItemize}
\item solid (3\-D) elements\-: number of integration points are different than 2\-D
\item thick shell elements\-: number of integration points are different than planar 2\-D
\item shell (2\-D) elements\-: number of integration points are different than 3\-D
\item rigid surfaces\-: can't have deflection, only velocity, accel, etc.
\item road surfaces\-: have only a \char`\"{}segment I\-D\char`\"{} (serves as material I\-D) and a velocity.
\item beam elements\-: have Frenet (T\-N\-B) frame and cross-\/section attributes (shape and size)
\item spherical particle hydrodynamics (S\-P\-H) elements\-: have a radius of influence, internal energy, etc. Because each mesh has its own cell attributes, the vtk\-L\-S\-Dyna\-Reader has a rather large A\-P\-I. Instead of a single set of routines to query and set cell array names and status, one exists for each possible output mesh. Also, Get\-Number\-Of\-Cells() will return the sum of all the cells in all 7 meshes. If you want the number of cells in a specific mesh, there are separate routines for each mesh type.
\end{DoxyItemize}

.S\-E\-C\-T\-I\-O\-N \char`\"{}\-Developer Notes\char`\"{}

To create an instance of class vtk\-L\-S\-Dyna\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLSDynaReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-L\-S\-Dyna\-Reader 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\-L\-S\-Dyna\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-L\-S\-Dyna\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-L\-S\-Dyna\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Debug\-Dump ()} -\/ A routine to call Dump() from within a lame debugger that won't properly pass a C++ iostream object like cout.  
\item {\ttfamily int = obj.\-Can\-Read\-File (string fname)} -\/ Determine if the file can be readed with this reader.  
\item {\ttfamily obj.\-Set\-Database\-Directory (string )} -\/ Get/\-Set the directory containing the L\-S-\/\-Dyna database and determine whether it is valid.  
\item {\ttfamily string = obj.\-Get\-Database\-Directory ()} -\/ Get/\-Set the directory containing the L\-S-\/\-Dyna database and determine whether it is valid.  
\item {\ttfamily int = obj.\-Is\-Database\-Valid ()} -\/ Get/\-Set the directory containing the L\-S-\/\-Dyna database and determine whether it is valid.  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Get/\-Set the filename. The Set/\-Get\-File\-Name() routines are actually wrappers around the Set/\-Get\-Database\-Directory() members; the actual filename you choose is irrelevant -- only the directory name is used. This is done in order to accommodate Para\-View.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Get/\-Set the filename. The Set/\-Get\-File\-Name() routines are actually wrappers around the Set/\-Get\-Database\-Directory() members; the actual filename you choose is irrelevant -- only the directory name is used. This is done in order to accommodate Para\-View.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ The title of the database is a 40 or 80 character text description stored at the front of a d3plot file. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily int = obj.\-Get\-Dimensionality ()} -\/ Retrieve the dimension of points in the database. This should return 2 or 3. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Nodes ()} -\/ Retrieve the number of points in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().

Note that Get\-Number\-Of\-Cells() returns the sum of Get\-Number\-Of\-Continuum\-Cells() and Get\-Number\-Of\-Particle\-Cells().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Continuum\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().

Note that Get\-Number\-Of\-Continuum\-Cells() returns the sum of Get\-Number\-Of\-Solid\-Cells(), Get\-Number\-Of\-Thick\-Shell\-Cells(), Get\-Number\-Of\-Shell\-Cells(), Get\-Number\-Of\-Rigid\-Body\-Cells(), Get\-Number\-Of\-Road\-Surface\-Cells(), and Get\-Number\-Of\-Beam\-Cells().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Solid\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Thick\-Shell\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Shell\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Rigid\-Body\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Road\-Surface\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Beam\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Particle\-Cells ()} -\/ Retrieve the number of cells of a given type in the database. Do not call this function before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Time\-Steps ()} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily obj.\-Set\-Time\-Step (vtk\-Id\-Type )} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Time\-Step ()} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily double = obj.\-Get\-Time\-Value (vtk\-Id\-Type )} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily int = obj. Get\-Time\-Step\-Range ()} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int , int )} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily obj.\-Set\-Time\-Step\-Range (int a\mbox{[}2\mbox{]})} -\/ Retrieve information about the time extents of the L\-S-\/\-Dyna database. Do not call these functions before setting the database directory and calling Update\-Information().  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Point\-Arrays ()} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Point\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Point\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Point\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Point\-Array (int arr)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Point\-Array (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the nodal variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cell\-Arrays (int cell\-Type)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily string = obj.\-Get\-Cell\-Array\-Name (int cell\-Type, int arr)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (int cell\-Type, int arr, int status)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily obj.\-Set\-Cell\-Array\-Status (int cell\-Type, string arr\-Name, int status)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (int cell\-Type, int arr)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily int = obj.\-Get\-Cell\-Array\-Status (int cell\-Type, string arr\-Name)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Cell\-Array (int cell\-Type, int arr)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Cell\-Array (int cell\-Type, string arr\-Name)} -\/ Routines that allow the status of a cell variable to be adjusted or queried independent of the output mesh. The {\itshape cell\-Type} parameter should be one of\-: L\-S\-\_\-\-P\-O\-I\-N\-T, L\-S\-\_\-\-B\-E\-A\-M, L\-S\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-T\-H\-I\-C\-K\-\_\-\-S\-H\-E\-L\-L, L\-S\-\_\-\-S\-O\-L\-I\-D, L\-S\-\_\-\-R\-I\-G\-I\-D\-\_\-\-B\-O\-D\-Y, or L\-S\-\_\-\-R\-O\-A\-D\-\_\-\-S\-U\-R\-F\-A\-C\-E  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Solid\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Solid\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Solid\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Solid\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Solid\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Solid\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Solid\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Solid\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Thick\-Shell\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Thick\-Shell\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Thick\-Shell\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Thick\-Shell\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Thick\-Shell\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Thick\-Shell\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Thick\-Shell\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Thick\-Shell\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Shell\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Shell\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Shell\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Shell\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Shell\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Shell\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Shell\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Shell\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Rigid\-Body\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Rigid\-Body\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Rigid\-Body\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Rigid\-Body\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Rigid\-Body\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Rigid\-Body\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Rigid\-Body\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Rigid\-Body\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Road\-Surface\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Road\-Surface\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Road\-Surface\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Road\-Surface\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Road\-Surface\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Road\-Surface\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Road\-Surface\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Road\-Surface\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Beam\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Beam\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Beam\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Beam\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Beam\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Beam\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Beam\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Beam\-Array (string arr\-Name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Particle\-Arrays ()} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily string = obj.\-Get\-Particle\-Array\-Name (int )} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Particle\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily obj.\-Set\-Particle\-Array\-Status (string arr\-Name, int status)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Particle\-Array\-Status (int arr)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Particle\-Array\-Status (string arr\-Name)} -\/ These methods allow you to load only selected subsets of the cell variables defined over the mesh.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Particle\-Array (int a)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components\-In\-Particle\-Array (string arr\-Name)}  
\item {\ttfamily obj.\-Set\-Deformed\-Mesh (int )} -\/ Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true but its value is ignored if the nodal \char`\"{}\-Deflection\char`\"{} array is not set to be loaded.  
\item {\ttfamily int = obj.\-Get\-Deformed\-Mesh ()} -\/ Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true but its value is ignored if the nodal \char`\"{}\-Deflection\char`\"{} array is not set to be loaded.  
\item {\ttfamily obj.\-Deformed\-Mesh\-On ()} -\/ Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true but its value is ignored if the nodal \char`\"{}\-Deflection\char`\"{} array is not set to be loaded.  
\item {\ttfamily obj.\-Deformed\-Mesh\-Off ()} -\/ Should deflected coordinates be used, or should the mesh remain undeflected? By default, this is true but its value is ignored if the nodal \char`\"{}\-Deflection\char`\"{} array is not set to be loaded.  
\item {\ttfamily obj.\-Set\-Remove\-Deleted\-Cells (int )} -\/ Should dead cells be removed from the mesh? Cells are marked dead by setting the corresponding entry in the {\bfseries cell} array \char`\"{}\-Death\char`\"{} to 0. Cells that are not dead have the corresponding entry in the cell array \char`\"{}\-Death\char`\"{} set to their material I\-D. By default, this is true but its value is ignored if the cell \char`\"{}\-Death\char`\"{} array is not set to be loaded. It is also ignored if the database's element deletion option is set to denote {\bfseries points} (not cells) as deleted; in that case, \char`\"{}\-Death\char`\"{} will appear to be a point array.  
\item {\ttfamily int = obj.\-Get\-Remove\-Deleted\-Cells ()} -\/ Should dead cells be removed from the mesh? Cells are marked dead by setting the corresponding entry in the {\bfseries cell} array \char`\"{}\-Death\char`\"{} to 0. Cells that are not dead have the corresponding entry in the cell array \char`\"{}\-Death\char`\"{} set to their material I\-D. By default, this is true but its value is ignored if the cell \char`\"{}\-Death\char`\"{} array is not set to be loaded. It is also ignored if the database's element deletion option is set to denote {\bfseries points} (not cells) as deleted; in that case, \char`\"{}\-Death\char`\"{} will appear to be a point array.  
\item {\ttfamily obj.\-Remove\-Deleted\-Cells\-On ()} -\/ Should dead cells be removed from the mesh? Cells are marked dead by setting the corresponding entry in the {\bfseries cell} array \char`\"{}\-Death\char`\"{} to 0. Cells that are not dead have the corresponding entry in the cell array \char`\"{}\-Death\char`\"{} set to their material I\-D. By default, this is true but its value is ignored if the cell \char`\"{}\-Death\char`\"{} array is not set to be loaded. It is also ignored if the database's element deletion option is set to denote {\bfseries points} (not cells) as deleted; in that case, \char`\"{}\-Death\char`\"{} will appear to be a point array.  
\item {\ttfamily obj.\-Remove\-Deleted\-Cells\-Off ()} -\/ Should dead cells be removed from the mesh? Cells are marked dead by setting the corresponding entry in the {\bfseries cell} array \char`\"{}\-Death\char`\"{} to 0. Cells that are not dead have the corresponding entry in the cell array \char`\"{}\-Death\char`\"{} set to their material I\-D. By default, this is true but its value is ignored if the cell \char`\"{}\-Death\char`\"{} array is not set to be loaded. It is also ignored if the database's element deletion option is set to denote {\bfseries points} (not cells) as deleted; in that case, \char`\"{}\-Death\char`\"{} will appear to be a point array.  
\item {\ttfamily obj.\-Set\-Split\-By\-Material\-Id (int )} -\/ Split each part into submeshes based on material I\-D. By default, this is false and all cells of a given type (solid, thick shell, shell, ...) are in a single mesh.  
\item {\ttfamily int = obj.\-Get\-Split\-By\-Material\-Id ()} -\/ Split each part into submeshes based on material I\-D. By default, this is false and all cells of a given type (solid, thick shell, shell, ...) are in a single mesh.  
\item {\ttfamily obj.\-Split\-By\-Material\-Id\-On ()} -\/ Split each part into submeshes based on material I\-D. By default, this is false and all cells of a given type (solid, thick shell, shell, ...) are in a single mesh.  
\item {\ttfamily obj.\-Split\-By\-Material\-Id\-Off ()} -\/ Split each part into submeshes based on material I\-D. By default, this is false and all cells of a given type (solid, thick shell, shell, ...) are in a single mesh.  
\item {\ttfamily obj.\-Set\-Input\-Deck (string )} -\/ The name of the input deck corresponding to the current database. This is used to determine the part names associated with each material I\-D. This file may be in two formats\-: a valid L\-S\-Dyna input deck or a short X\-M\-L summary. If the file begins with \char`\"{}$<$?xml\char`\"{} then the summary format is used. Otherwise, the keyword format is used and a summary file will be created if write permissions exist in the directory containing the keyword file. The newly created summary will have \char`\"{}.\-k\char`\"{} or \char`\"{}.\-key\char`\"{} stripped from the end of the keyword filename and \char`\"{}.\-lsdyna\char`\"{} appended.  
\item {\ttfamily string = obj.\-Get\-Input\-Deck ()} -\/ The name of the input deck corresponding to the current database. This is used to determine the part names associated with each material I\-D. This file may be in two formats\-: a valid L\-S\-Dyna input deck or a short X\-M\-L summary. If the file begins with \char`\"{}$<$?xml\char`\"{} then the summary format is used. Otherwise, the keyword format is used and a summary file will be created if write permissions exist in the directory containing the keyword file. The newly created summary will have \char`\"{}.\-k\char`\"{} or \char`\"{}.\-key\char`\"{} stripped from the end of the keyword filename and \char`\"{}.\-lsdyna\char`\"{} appended.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Part\-Arrays ()} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\item {\ttfamily string = obj.\-Get\-Part\-Array\-Name (int )} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (int arr, int status)} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\item {\ttfamily obj.\-Set\-Part\-Array\-Status (string part\-Name, int status)} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (int arr)} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\item {\ttfamily int = obj.\-Get\-Part\-Array\-Status (string part\-Name)} -\/ These methods allow you to load only selected parts of the input. If Input\-Deck points to a valid keyword file (or summary), then part names will be taken from that file. Otherwise, when arbitrary material numbering is used, parts will be named \char`\"{}\-Part\-X\-X\-X (\-Matl\-Y\-Y\-Y)\char`\"{} where X\-X\-X is an increasing sequential number and Y\-Y\-Y is the respective material I\-D. If no input deck is specified and arbitrary arbitrary material numbering is not used, parts will be named \char`\"{}\-Part\-X\-X\-X\char`\"{} where X\-X\-X is a sequential material I\-D.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpcaanalysisfilter}{}\section{vtk\-P\-C\-A\-Analysis\-Filter}\label{vtkhybrid_vtkpcaanalysisfilter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-C\-A\-Analysis\-Filter is a filter that takes as input a set of aligned pointsets (any object derived from vtk\-Point\-Set) and performs a principal component analysis of the coordinates. This can be used to visualise the major or minor modes of variation seen in a set of similar biological objects with corresponding landmarks. vtk\-P\-C\-A\-Analysis\-Filter is designed to work with the output from the vtk\-Procrustes\-Analysis\-Filter

Call Set\-Number\-Of\-Inputs(n) before calling Set\-Input(0) ... Set\-Input(n-\/1). Retrieve the outputs using Get\-Output(0) ... Get\-Output(n-\/1).

vtk\-P\-C\-A\-Analysis\-Filter is an implementation of (for example)\-:

T. Cootes et al. \-: Active Shape Models -\/ their training and application. Computer Vision and Image Understanding, 61(1)\-:38-\/59, 1995.

The material can also be found in Tim Cootes' ever-\/changing online report published at his website\-: \href{http://www.isbe.man.ac.uk/~bim/}{\tt http\-://www.\-isbe.\-man.\-ac.\-uk/$\sim$bim/}

To create an instance of class vtk\-P\-C\-A\-Analysis\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPCAAnalysisFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-C\-A\-Analysis\-Filter 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\-P\-C\-A\-Analysis\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-C\-A\-Analysis\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-C\-A\-Analysis\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Float\-Array = obj.\-Get\-Evals ()} -\/ Get the vector of eigenvalues sorted in descending order  
\item {\ttfamily obj.\-Set\-Number\-Of\-Inputs (int n)} -\/ Specify how many pointsets are going to be given as input.  
\item {\ttfamily obj.\-Set\-Input (int idx, vtk\-Point\-Set p)} -\/ Specify the input pointset with index idx. Call Set\-Number\-Of\-Inputs before calling this function.  
\item {\ttfamily obj.\-Set\-Input (int idx, vtk\-Data\-Object input)} -\/ Specify the input pointset with index idx. Call Set\-Number\-Of\-Inputs before calling this function.  
\item {\ttfamily vtk\-Point\-Set = obj.\-Get\-Input (int idx)} -\/ Retrieve the input with index idx (usually only used for pipeline tracing).  
\item {\ttfamily obj.\-Get\-Parameterised\-Shape (vtk\-Float\-Array b, vtk\-Point\-Set shape)} -\/ Fills the shape with\-:

mean + b\mbox{[}0\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}0\mbox{]}) $\ast$ eigenvector\mbox{[}0\mbox{]}
\begin{DoxyItemize}
\item b\mbox{[}1\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}1\mbox{]}) $\ast$ eigenvector\mbox{[}1\mbox{]} ...
\item b\mbox{[}sizeb-\/1\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}bsize-\/1\mbox{]}) $\ast$ eigenvector\mbox{[}bsize-\/1\mbox{]}
\end{DoxyItemize}

here b are the parameters expressed in standard deviations bsize is the number of parameters in the b vector This function assumes that shape is allready allocated with the right size, it just moves the points.  
\item {\ttfamily obj.\-Get\-Shape\-Parameters (vtk\-Point\-Set shape, vtk\-Float\-Array b, int bsize)} -\/ Return the bsize parameters b that best model the given shape (in standard deviations). That is that the given shape will be approximated by\-:

shape $\sim$ mean + b\mbox{[}0\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}0\mbox{]}) $\ast$ eigenvector\mbox{[}0\mbox{]}
\begin{DoxyItemize}
\item b\mbox{[}1\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}1\mbox{]}) $\ast$ eigenvector\mbox{[}1\mbox{]} ...
\item b\mbox{[}bsize-\/1\mbox{]} $\ast$ sqrt(eigenvalue\mbox{[}bsize-\/1\mbox{]}) $\ast$ eigenvector\mbox{[}bsize-\/1\mbox{]}  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Modes\-Required\-For (double proportion)} -\/ Retrieve how many modes are necessary to model the given proportion of the variation. proportion should be between 0 and 1  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpexodusiireader}{}\section{vtk\-P\-Exodus\-I\-I\-Reader}\label{vtkhybrid_vtkpexodusiireader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-Exodus\-I\-I\-Reader is a unstructured grid source object that reads Exodus\-I\-I files. Most of the meta data associated with the file is loaded when Update\-Information is called. This includes information like Title, number of blocks, number and names of arrays. This data can be retrieved from methods in this reader. Separate arrays that are meant to be a single vector, are combined internally for convenience. To be combined, the array names have to be identical except for a trailing X,Y and Z (or x,y,z). By default all cell and point arrays are loaded. However, the user can flag arrays not to load with the methods \char`\"{}\-Set\-Point\-Data\-Array\-Load\-Flag\char`\"{} and \char`\"{}\-Set\-Cell\-Data\-Array\-Load\-Flag\char`\"{}. The reader responds to piece requests by loading only a range of the possible blocks. Unused points are filtered out internally.

To create an instance of class vtk\-P\-Exodus\-I\-I\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPExodusIIReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-Exodus\-I\-I\-Reader 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\-P\-Exodus\-I\-I\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-Exodus\-I\-I\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-Exodus\-I\-I\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Controller (vtk\-Multi\-Process\-Controller c)} -\/ Set/get the communication object used to relay a list of files from the rank 0 process to all others. This is the only interprocess communication required by vtk\-P\-Exodus\-I\-I\-Reader.  
\item {\ttfamily vtk\-Multi\-Process\-Controller = obj.\-Get\-Controller ()} -\/ Set/get the communication object used to relay a list of files from the rank 0 process to all others. This is the only interprocess communication required by vtk\-P\-Exodus\-I\-I\-Reader.  
\item {\ttfamily obj.\-Set\-File\-Pattern (string )} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily string = obj.\-Get\-File\-Pattern ()} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily obj.\-Set\-File\-Range (int , int )} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily obj.\-Set\-File\-Range (int r)} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily int = obj. Get\-File\-Range ()} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily obj.\-Set\-File\-Name (string name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-File\-Names ()} -\/ Return the number of files to be read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Files ()} -\/ Return the number of files to be read.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Elements ()}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Total\-Number\-Of\-Nodes ()}  
\item {\ttfamily obj.\-Update\-Time\-Information ()} -\/ Calls Update\-Time\-Information() on all serial readers so they'll re-\/read their time info from the file. The last time step that they all have in common is stored in Last\-Common\-Time\-Step, which is used in Request\-Information() to override the output time-\/specific information keys with the range of times that A\-L\-L readers can actually read.  
\item {\ttfamily obj.\-Broadcast (vtk\-Multi\-Process\-Controller ctrl)} -\/ Sends metadata (that read from the input file, not settings modified through this A\-P\-I) from the rank 0 node to all other processes in a job.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpexodusreader}{}\section{vtk\-P\-Exodus\-Reader}\label{vtkhybrid_vtkpexodusreader}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-P\-Exodus\-Reader is a unstructured grid source object that reads P\-Exodus\-Reader\-I\-I files. Most of the meta data associated with the file is loaded when Update\-Information is called. This includes information like Title, number of blocks, number and names of arrays. This data can be retrieved from methods in this reader. Separate arrays that are meant to be a single vector, are combined internally for convenience. To be combined, the array names have to be identical except for a trailing X,Y and Z (or x,y,z). By default all cell and point arrays are loaded. However, the user can flag arrays not to load with the methods \char`\"{}\-Set\-Point\-Data\-Array\-Load\-Flag\char`\"{} and \char`\"{}\-Set\-Cell\-Data\-Array\-Load\-Flag\char`\"{}. The reader responds to piece requests by loading only a range of the possible blocks. Unused points are filtered out internally.

To create an instance of class vtk\-P\-Exodus\-Reader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPExodusReader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-Exodus\-Reader 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\-P\-Exodus\-Reader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-Exodus\-Reader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-Exodus\-Reader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Pattern (string )} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily string = obj.\-Get\-File\-Pattern ()} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ These methods tell the reader that the data is ditributed across multiple files. This is for distributed execution. It this case, pieces are mapped to files. The pattern should have one d to format the file number. File\-Number\-Range is used to generate file numbers. I was thinking of having an arbitrary list of file numbers. This may happen in the future. (That is why there is no Get\-File\-Number\-Range method.  
\item {\ttfamily obj.\-Set\-File\-Range (int , int )} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily obj.\-Set\-File\-Range (int r)} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily int = obj. Get\-File\-Range ()} -\/ Set the range of files that are being loaded. The range for single file should add to 0.  
\item {\ttfamily obj.\-Set\-File\-Name (string name)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-File\-Names ()} -\/ Return the number of files to be read.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Files ()} -\/ Return the number of files to be read.  
\item {\ttfamily obj.\-Set\-Generate\-File\-Id\-Array (int flag)}  
\item {\ttfamily int = obj.\-Get\-Generate\-File\-Id\-Array ()}  
\item {\ttfamily obj.\-Generate\-File\-Id\-Array\-On ()}  
\item {\ttfamily obj.\-Generate\-File\-Id\-Array\-Off ()}  
\item {\ttfamily int = obj.\-Get\-Total\-Number\-Of\-Elements ()}  
\item {\ttfamily int = obj.\-Get\-Total\-Number\-Of\-Nodes ()}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Variable\-Arrays ()}  
\item {\ttfamily string = obj.\-Get\-Variable\-Array\-Name (int a\-\_\-which)}  
\item {\ttfamily obj.\-Enable\-D\-S\-P\-Filtering ()}  
\item {\ttfamily obj.\-Add\-Filter (vtk\-D\-S\-P\-Filter\-Definition a\-\_\-filter)}  
\item {\ttfamily obj.\-Start\-Adding\-Filter ()}  
\item {\ttfamily obj.\-Add\-Filter\-Input\-Var (string name)}  
\item {\ttfamily obj.\-Add\-Filter\-Output\-Var (string name)}  
\item {\ttfamily obj.\-Add\-Filter\-Numerator\-Weight (double weight)}  
\item {\ttfamily obj.\-Add\-Filter\-Forward\-Numerator\-Weight (double weight)}  
\item {\ttfamily obj.\-Add\-Filter\-Denominator\-Weight (double weight)}  
\item {\ttfamily obj.\-Finish\-Adding\-Filter ()}  
\item {\ttfamily obj.\-Remove\-Filter (string a\-\_\-output\-Variable\-Name)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpiechartactor}{}\section{vtk\-Pie\-Chart\-Actor}\label{vtkhybrid_vtkpiechartactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Pie\-Chart\-Actor generates a pie chart from an array of numbers defined in field data (a vtk\-Data\-Object). To use this class, you must specify an input data object. You'll probably also want to specify the position of the plot be setting the Position and Position2 instance variables, which define a rectangle in which the plot lies. There are also many other instance variables that control the look of the plot includes its title, and legend.

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated with these components.

To create an instance of class vtk\-Pie\-Chart\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPieChartActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Pie\-Chart\-Actor 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\-Pie\-Chart\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Pie\-Chart\-Actor = obj.\-New\-Instance ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Pie\-Chart\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the input to the pie chart actor.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get the input data object to this actor.  
\item {\ttfamily obj.\-Set\-Title\-Visibility (int )} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily int = obj.\-Get\-Title\-Visibility ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-On ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-Off ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the pie chart.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the pie chart.  
\item {\ttfamily obj.\-Set\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property. The property controls the appearance of the plot title.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property. The property controls the appearance of the plot title.  
\item {\ttfamily obj.\-Set\-Label\-Visibility (int )} -\/ Enable/\-Disable the display of pie piece labels.  
\item {\ttfamily int = obj.\-Get\-Label\-Visibility ()} -\/ Enable/\-Disable the display of pie piece labels.  
\item {\ttfamily obj.\-Label\-Visibility\-On ()} -\/ Enable/\-Disable the display of pie piece labels.  
\item {\ttfamily obj.\-Label\-Visibility\-Off ()} -\/ Enable/\-Disable the display of pie piece labels.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property. This controls the appearance of all pie piece labels.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property. This controls the appearance of all pie piece labels.  
\item {\ttfamily obj.\-Set\-Piece\-Color (int i, double r, double g, double b)} -\/ Specify colors for each piece of pie. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Piece\-Color (int i, double color\mbox{[}3\mbox{]})} -\/ Specify colors for each piece of pie. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Piece\-Label (int i, string )} -\/ Specify the names for each piece of pie. not specified, then an integer number is automatically generated.  
\item {\ttfamily string = obj.\-Get\-Piece\-Label (int i)} -\/ Specify the names for each piece of pie. not specified, then an integer number is automatically generated.  
\item {\ttfamily obj.\-Set\-Legend\-Visibility (int )} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily int = obj.\-Get\-Legend\-Visibility ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-On ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-Off ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-Get\-Legend\-Actor ()} -\/ Retrieve handles to the legend box. This is useful if you would like to manually control the legend appearance.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Draw the pie plot.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the pie plot.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpolydatasilhouette}{}\section{vtk\-Poly\-Data\-Silhouette}\label{vtkhybrid_vtkpolydatasilhouette}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Silhouette extracts a subset of a polygonal mesh edges to generate an outline (silhouette) of the corresponding 3\-D object. In addition, this filter can also extracts sharp edges (aka feature angles). In order to use this filter you must specify the a point of view (origin) or a direction (vector). given this direction or origin, a silhouette is generated wherever the surface's normal is orthogonal to the view direction.

To create an instance of class vtk\-Poly\-Data\-Silhouette, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataSilhouette
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Silhouette 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\-Poly\-Data\-Silhouette class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Silhouette = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Silhouette = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enable\-Feature\-Angle (int )} -\/ Enables or Disables generation of silhouette edges along sharp edges  
\item {\ttfamily int = obj.\-Get\-Enable\-Feature\-Angle ()} -\/ Enables or Disables generation of silhouette edges along sharp edges  
\item {\ttfamily obj.\-Set\-Feature\-Angle (double )} -\/ Sets/\-Gets minimal angle for sharp edges detection. Default is 60  
\item {\ttfamily double = obj.\-Get\-Feature\-Angle ()} -\/ Sets/\-Gets minimal angle for sharp edges detection. Default is 60  
\item {\ttfamily obj.\-Set\-Border\-Edges (int )} -\/ Enables or Disables generation of border edges. Note\-: borders exist only in case of non closed surface  
\item {\ttfamily int = obj.\-Get\-Border\-Edges ()} -\/ Enables or Disables generation of border edges. Note\-: borders exist only in case of non closed surface  
\item {\ttfamily obj.\-Border\-Edges\-On ()} -\/ Enables or Disables generation of border edges. Note\-: borders exist only in case of non closed surface  
\item {\ttfamily obj.\-Border\-Edges\-Off ()} -\/ Enables or Disables generation of border edges. Note\-: borders exist only in case of non closed surface  
\item {\ttfamily obj.\-Set\-Piece\-Invariant (int )} -\/ Enables or Disables piece invariance. This is usefull when dealing with multi-\/block data sets. Note\-: requires one level of ghost cells  
\item {\ttfamily int = obj.\-Get\-Piece\-Invariant ()} -\/ Enables or Disables piece invariance. This is usefull when dealing with multi-\/block data sets. Note\-: requires one level of ghost cells  
\item {\ttfamily obj.\-Piece\-Invariant\-On ()} -\/ Enables or Disables piece invariance. This is usefull when dealing with multi-\/block data sets. Note\-: requires one level of ghost cells  
\item {\ttfamily obj.\-Piece\-Invariant\-Off ()} -\/ Enables or Disables piece invariance. This is usefull when dealing with multi-\/block data sets. Note\-: requires one level of ghost cells  
\item {\ttfamily obj.\-Set\-Direction (int )} -\/ Specify how view direction is computed. By default, the camera origin (eye) is used.  
\item {\ttfamily int = obj.\-Get\-Direction ()} -\/ Specify how view direction is computed. By default, the camera origin (eye) is used.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Specified\-Vector ()} -\/ Specify how view direction is computed. By default, the camera origin (eye) is used.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Specified\-Origin ()} -\/ Specify how view direction is computed. By default, the camera origin (eye) is used.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Camera\-Vector ()} -\/ Specify how view direction is computed. By default, the camera origin (eye) is used.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Camera\-Origin ()} -\/ Specify a camera that is used to define the view direction. This ivar only has effect if the direction is set to V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-O\-R\-I\-G\-I\-N or V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-V\-E\-C\-T\-O\-R, and a camera is specified.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Specify a camera that is used to define the view direction. This ivar only has effect if the direction is set to V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-O\-R\-I\-G\-I\-N or V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-V\-E\-C\-T\-O\-R, and a camera is specified.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Specify a camera that is used to define the view direction. This ivar only has effect if the direction is set to V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-O\-R\-I\-G\-I\-N or V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-V\-E\-C\-T\-O\-R, and a camera is specified.  
\item {\ttfamily obj.\-Set\-Prop3\-D (vtk\-Prop3\-D )} -\/ Specify a transformation matrix (via the vtk\-Prop3\-D\-::\-Get\-Matrix() method) that is used to include the effects of transformation. This ivar only has effect if the direction is set to V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-O\-R\-I\-G\-I\-N or V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-V\-E\-C\-T\-O\-R, and a camera is specified. Specifying the vtk\-Prop3\-D is optional.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Prop3\-D ()} -\/ Specify a transformation matrix (via the vtk\-Prop3\-D\-::\-Get\-Matrix() method) that is used to include the effects of transformation. This ivar only has effect if the direction is set to V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-O\-R\-I\-G\-I\-N or V\-T\-K\-\_\-\-D\-I\-R\-E\-C\-T\-I\-O\-N\-\_\-\-C\-A\-M\-E\-R\-A\-\_\-\-V\-E\-C\-T\-O\-R, and a camera is specified. Specifying the vtk\-Prop3\-D is optional.  
\item {\ttfamily obj.\-Set\-Vector (double , double , double )} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The edge detection occurs in the direction of the vector.  
\item {\ttfamily obj.\-Set\-Vector (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The edge detection occurs in the direction of the vector.  
\item {\ttfamily double = obj. Get\-Vector ()} -\/ Set/\-Get the sort direction. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Vector(). The edge detection occurs in the direction of the vector.  
\item {\ttfamily obj.\-Set\-Origin (double , double , double )} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Origin(). The edge detection occurs in the direction of the origin to each edge's center.  
\item {\ttfamily obj.\-Set\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Origin(). The edge detection occurs in the direction of the origin to each edge's center.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set/\-Get the sort origin. This ivar only has effect if the sort direction is set to Set\-Direction\-To\-Specified\-Origin(). The edge detection occurs in the direction of the origin to each edge's center.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return M\-Time also considering the dependent objects\-: the camera and/or the prop3\-D.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkpolydatatoimagestencil}{}\section{vtk\-Poly\-Data\-To\-Image\-Stencil}\label{vtkhybrid_vtkpolydatatoimagestencil}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Poly\-Data\-To\-Image\-Stencil class will convert a surface mesh into an image stencil that can be used to mask an image with vtk\-Image\-Stencil, or used to calculate statistics within the enclosed region with vtk\-Image\-Accumulate.

To create an instance of class vtk\-Poly\-Data\-To\-Image\-Stencil, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataToImageStencil
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-To\-Image\-Stencil 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\-Poly\-Data\-To\-Image\-Stencil class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-To\-Image\-Stencil = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-To\-Image\-Stencil = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Poly\-Data )} -\/ Specify the implicit function to convert into a stencil.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input ()} -\/ Specify the implicit function to convert into a stencil.  
\item {\ttfamily obj.\-Set\-Information\-Input (vtk\-Image\-Data )} -\/ Set a vtk\-Image\-Data that has the Spacing, Origin, and Whole\-Extent that will be used for the stencil. This input should be set to the image that you wish to apply the stencil to. If you use this method, then any values set with the Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Whole\-Extent methods will be ignored.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Information\-Input ()} -\/ Set a vtk\-Image\-Data that has the Spacing, Origin, and Whole\-Extent that will be used for the stencil. This input should be set to the image that you wish to apply the stencil to. If you use this method, then any values set with the Set\-Output\-Spacing, Set\-Output\-Origin, and Set\-Output\-Whole\-Extent methods will be ignored.  
\item {\ttfamily obj.\-Set\-Output\-Origin (double , double , double )} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily obj.\-Set\-Output\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily double = obj. Get\-Output\-Origin ()} -\/ Set the Origin to be used for the stencil. It should be set to the Origin of the image you intend to apply the stencil to. The default value is (0,0,0).  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double , double , double )} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily obj.\-Set\-Output\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily double = obj. Get\-Output\-Spacing ()} -\/ Set the Spacing to be used for the stencil. It should be set to the Spacing of the image you intend to apply the stencil to. The default value is (1,1,1)  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int , int , int , int , int , int )} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily int = obj. Get\-Output\-Whole\-Extent ()} -\/ Set the whole extent for the stencil (anything outside this extent will be considered to be \char`\"{}outside\char`\"{} the stencil). If this is not set, then the stencil will always use the requested Update\-Extent as the stencil extent.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ The tolerance to apply in when determining whether a voxel is inside the stencil, given as a fraction of a voxel. Only used in X and Y, not in Z.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance to apply in when determining whether a voxel is inside the stencil, given as a fraction of a voxel. Only used in X and Y, not in Z.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance to apply in when determining whether a voxel is inside the stencil, given as a fraction of a voxel. Only used in X and Y, not in Z.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ The tolerance to apply in when determining whether a voxel is inside the stencil, given as a fraction of a voxel. Only used in X and Y, not in Z.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkprocrustesalignmentfilter}{}\section{vtk\-Procrustes\-Alignment\-Filter}\label{vtkhybrid_vtkprocrustesalignmentfilter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Procrustes\-Alignment\-Filter is a filter that takes a set of pointsets (any object derived from vtk\-Point\-Set) and aligns them in a least-\/squares sense to their mutual mean. The algorithm is iterated until convergence, as the mean must be recomputed after each alignment.

Call Set\-Number\-Of\-Inputs(n) before calling Set\-Input(0) ... Set\-Input(n-\/1).

Retrieve the outputs using Get\-Output(0) ... Get\-Output(n-\/1).

The default (in vtk\-Landmark\-Transform) is for a similarity alignment. For a rigid-\/body alignment (to build a 'size-\/and-\/shape' model) use\-:

Get\-Landmark\-Transform()-\/$>$Set\-Mode\-To\-Rigid\-Body().

Affine alignments are not normally used but are left in for completeness\-:

Get\-Landmark\-Transform()-\/$>$Set\-Mode\-To\-Affine().

vtk\-Procrustes\-Alignment\-Filter is an implementation of\-:

J.\-C. Gower (1975) Generalized Procrustes Analysis. Psychometrika, 40\-:33-\/51.

To create an instance of class vtk\-Procrustes\-Alignment\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProcrustesAlignmentFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Procrustes\-Alignment\-Filter 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\-Procrustes\-Alignment\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Procrustes\-Alignment\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Procrustes\-Alignment\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Landmark\-Transform = obj.\-Get\-Landmark\-Transform ()} -\/ Get the internal landmark transform. Use it to constrain the number of degrees of freedom of the alignment (i.\-e. rigid body, similarity, etc.). The default is a similarity alignment.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Mean\-Points ()} -\/ Get the estimated mean point cloud  
\item {\ttfamily obj.\-Set\-Number\-Of\-Inputs (int n)} -\/ Specify how many pointsets are going to be given as input.  
\item {\ttfamily obj.\-Set\-Input (int idx, vtk\-Point\-Set p)} -\/ Specify the input pointset with index idx. Call Set\-Number\-Of\-Inputs before calling this function.  
\item {\ttfamily obj.\-Set\-Input (int idx, vtk\-Data\-Object input)} -\/ Specify the input pointset with index idx. Call Set\-Number\-Of\-Inputs before calling this function.  
\item {\ttfamily obj.\-Set\-Start\-From\-Centroid (bool )} -\/ When on, the initial alignment is to the centroid of the cohort curves. When off, the alignment is to the centroid of the first input. Default is off for backward compatibility.  
\item {\ttfamily bool = obj.\-Get\-Start\-From\-Centroid ()} -\/ When on, the initial alignment is to the centroid of the cohort curves. When off, the alignment is to the centroid of the first input. Default is off for backward compatibility.  
\item {\ttfamily obj.\-Start\-From\-Centroid\-On ()} -\/ When on, the initial alignment is to the centroid of the cohort curves. When off, the alignment is to the centroid of the first input. Default is off for backward compatibility.  
\item {\ttfamily obj.\-Start\-From\-Centroid\-Off ()} -\/ When on, the initial alignment is to the centroid of the cohort curves. When off, the alignment is to the centroid of the first input. Default is off for backward compatibility.  
\item {\ttfamily vtk\-Point\-Set = obj.\-Get\-Input (int idx)} -\/ Retrieve the input point set with index idx (usually only for pipeline tracing).  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkprojectedterrainpath}{}\section{vtk\-Projected\-Terrain\-Path}\label{vtkhybrid_vtkprojectedterrainpath}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Projected\-Terrain\-Path projects an input polyline onto a terrain. (The terrain is defined by a 2\-D height image and is the second input to the filter.) The polyline projection is controlled via several modes as follows. 1) Simple mode projects the polyline points onto the terrain, taking into account the height offset instance variable. 2) Non-\/occluded mode insures that no parts of the polyline are occluded by the terrain (e.\-g. a line passes through a mountain). This may require recursive subdivision of the polyline. 3) Hug mode insures that the polyine points remain within a constant distance from the surface. This may also require recursive subdivision of the polyline. Note that both non-\/occluded mode and hug mode also take into account the height offset, so it is possible to create paths that hug terrain a certain distance above it. To use this filter, define two inputs\-: 1) a polyline, and 2) an image whose scalar values represent a height field. Then specify the mode, and the height offset to use.

An description of the algorithm is as follows. The filter begins by projecting the polyline points to the image (offset by the specified height offset). If the mode is non-\/occluded or hug, then the maximum error along each line segment is computed and placed into a priority queue. Each line segment is then split at the point of maximum error, and the two new line segments are evaluated for maximum error. This process continues until the line is not occluded by the terrain (non-\/occluded mode) or satisfies the error on variation from the surface (hug mode). (Note this process is repeated for each polyline in the input. Also, the maximum error is computed in two parts\-: a maximum positive error and maximum negative error. If the polyline is above the terrain--i.\-e., the height offset is positive--in non-\/occluded or hug mode all negative errors are eliminated. If the polyline is below the terrain--i.\-e., the height offset is negative--in non-\/occluded or hug mode all positive errors are eliminated.)

To create an instance of class vtk\-Projected\-Terrain\-Path, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProjectedTerrainPath
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Projected\-Terrain\-Path 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\-Terrain\-Path class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Projected\-Terrain\-Path = obj.\-New\-Instance ()} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily vtk\-Projected\-Terrain\-Path = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methids for printing and determining type information.  
\item {\ttfamily obj.\-Set\-Source (vtk\-Image\-Data source)} -\/ Specify the second input (the terrain) onto which the polyline(s) should be projected.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Source ()} -\/ Specify the second input (the terrain) onto which the polyline(s) should be projected.  
\item {\ttfamily obj.\-Set\-Projection\-Mode (int )} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily int = obj.\-Get\-Projection\-Mode\-Min\-Value ()} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily int = obj.\-Get\-Projection\-Mode\-Max\-Value ()} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily int = obj.\-Get\-Projection\-Mode ()} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily obj.\-Set\-Projection\-Mode\-To\-Simple ()} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily obj.\-Set\-Projection\-Mode\-To\-Non\-Occluded ()} -\/ Determine how to control the projection process. Simple projection just projects the original polyline points. Non-\/occluded projection insures that the polyline does not intersect the terrain surface. Hug projection is similar to non-\/occulded projection except that produces a path that is nearly parallel to the terrain (within the user specified height tolerance).  
\item {\ttfamily obj.\-Set\-Projection\-Mode\-To\-Hug ()} -\/ This is the height above (or below) the terrain that the projected path should be. Positive values indicate distances above the terrain; negative values indicate distances below the terrain.  
\item {\ttfamily obj.\-Set\-Height\-Offset (double )} -\/ This is the height above (or below) the terrain that the projected path should be. Positive values indicate distances above the terrain; negative values indicate distances below the terrain.  
\item {\ttfamily double = obj.\-Get\-Height\-Offset ()} -\/ This is the height above (or below) the terrain that the projected path should be. Positive values indicate distances above the terrain; negative values indicate distances below the terrain.  
\item {\ttfamily obj.\-Set\-Height\-Tolerance (double )} -\/ This is the allowable variation in the altitude of the path with respect to the variation in the terrain. It only comes into play if the hug projection mode is enabled.  
\item {\ttfamily double = obj.\-Get\-Height\-Tolerance\-Min\-Value ()} -\/ This is the allowable variation in the altitude of the path with respect to the variation in the terrain. It only comes into play if the hug projection mode is enabled.  
\item {\ttfamily double = obj.\-Get\-Height\-Tolerance\-Max\-Value ()} -\/ This is the allowable variation in the altitude of the path with respect to the variation in the terrain. It only comes into play if the hug projection mode is enabled.  
\item {\ttfamily double = obj.\-Get\-Height\-Tolerance ()} -\/ This is the allowable variation in the altitude of the path with respect to the variation in the terrain. It only comes into play if the hug projection mode is enabled.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Lines (vtk\-Id\-Type )} -\/ This instance variable can be used to limit the total number of line segments created during subdivision. Note that the number of input line segments will be the minimum number that cab be output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Lines\-Min\-Value ()} -\/ This instance variable can be used to limit the total number of line segments created during subdivision. Note that the number of input line segments will be the minimum number that cab be output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Lines\-Max\-Value ()} -\/ This instance variable can be used to limit the total number of line segments created during subdivision. Note that the number of input line segments will be the minimum number that cab be output.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Maximum\-Number\-Of\-Lines ()} -\/ This instance variable can be used to limit the total number of line segments created during subdivision. Note that the number of input line segments will be the minimum number that cab be output.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkrenderlargeimage}{}\section{vtk\-Render\-Large\-Image}\label{vtkhybrid_vtkrenderlargeimage}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Large\-Image provides methods needed to read a region from a file.

To create an instance of class vtk\-Render\-Large\-Image, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderLargeImage
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Large\-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\-Render\-Large\-Image class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Large\-Image = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Large\-Image = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Magnification (int )} -\/ The magnification of the current render window  
\item {\ttfamily int = obj.\-Get\-Magnification ()} -\/ The magnification of the current render window  
\item {\ttfamily obj.\-Set\-Input (vtk\-Renderer )} -\/ Indicates what renderer to get the pixel data from.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Input ()} -\/ Returns which renderer is being used as the source for the pixel data.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkribexporter}{}\section{vtk\-R\-I\-B\-Exporter}\label{vtkhybrid_vtkribexporter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-R\-I\-B\-Exporter is a concrete subclass of vtk\-Exporter that writes a Renderman .R\-I\-B files. The input specifies a vtk\-Render\-Window. All visible actors and lights will be included in the rib file. The following file naming conventions apply\-: rib file -\/ File\-Prefix.\-rib image file created by Render\-Man -\/ File\-Prefix.\-tif texture files -\/ Texture\-Prefix\-\_\-0x\-A\-D\-D\-R\-\_\-\-M\-T\-I\-M\-E.\-tif This object does N\-O\-T generate an image file. The user must run either Render\-Man or a Render\-Man emulator like Blue Moon Ray Tracer (B\-M\-R\-T). vtk properties are convert to Renderman shaders as follows\-: Normal property, no texture map -\/ plastic.\-sl Normal property with texture map -\/ txtplastic.\-sl These two shaders must be compiled by the rendering package being used. vtk\-R\-I\-B\-Exporter also supports custom shaders. The shaders are written using the Renderman Shading Language. See \char`\"{}\-The Renderman
 Companion\char`\"{}, I\-S\-B\-N 0-\/201-\/50868, 1989 for details on writing shaders. vtk\-R\-I\-B\-Property specifies the declarations and parameter settings for custom shaders. Tcl Example\-: generate a rib file for the current rendering. vtk\-R\-I\-B\-Exporter my\-R\-I\-B my\-R\-I\-B Set\-Input \$ren\-Win my\-R\-I\-B Set\-F\-Ile\-Prefix mine my\-R\-I\-B Write This will create a file mine.\-rib. After running this file through a Renderman renderer a file mine.\-tif will contain the rendered image.

To create an instance of class vtk\-R\-I\-B\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRIBExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-R\-I\-B\-Exporter 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\-R\-I\-B\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-R\-I\-B\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-R\-I\-B\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Size (int , int )}  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})}  
\item {\ttfamily int = obj. Get\-Size ()}  
\item {\ttfamily obj.\-Set\-Pixel\-Samples (int , int )}  
\item {\ttfamily obj.\-Set\-Pixel\-Samples (int a\mbox{[}2\mbox{]})}  
\item {\ttfamily int = obj. Get\-Pixel\-Samples ()}  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify the prefix of the files to write out. The resulting file names will have .R\-I\-B appended to them.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify the prefix of the files to write out. The resulting file names will have .R\-I\-B appended to them.  
\item {\ttfamily obj.\-Set\-Texture\-Prefix (string )} -\/ Specify the prefix of any generated texture files.  
\item {\ttfamily string = obj.\-Get\-Texture\-Prefix ()} -\/ Specify the prefix of any generated texture files.  
\item {\ttfamily obj.\-Set\-Background (int )} -\/ Set/\-Get the background flag. Default is 0 (off). If set, the rib file will contain an image shader that will use the renderer window's background color. Normally, Render\-Man does generate backgrounds. Backgrounds are composited into the scene with the tiffcomp program that comes with Pixar's Render\-Man Toolkit. In fact, Pixar's Renderman will accept an image shader but only sets the alpha of the background. Images created this way will still have a black background but contain an alpha of 1 at all pixels and C\-A\-N\-N\-O\-T be subsequently composited with other images using tiffcomp. However, other Render\-Man compliant renderers like Blue Moon Ray Tracing (B\-M\-R\-T) do allow image shaders and properly set the background color. If this sounds too confusing, use the following rules\-: If you are using Pixar's Renderman, leave the Background off. Otherwise, try setting Back\-Ground\-On and see if you get the desired results.  
\item {\ttfamily int = obj.\-Get\-Background ()} -\/ Set/\-Get the background flag. Default is 0 (off). If set, the rib file will contain an image shader that will use the renderer window's background color. Normally, Render\-Man does generate backgrounds. Backgrounds are composited into the scene with the tiffcomp program that comes with Pixar's Render\-Man Toolkit. In fact, Pixar's Renderman will accept an image shader but only sets the alpha of the background. Images created this way will still have a black background but contain an alpha of 1 at all pixels and C\-A\-N\-N\-O\-T be subsequently composited with other images using tiffcomp. However, other Render\-Man compliant renderers like Blue Moon Ray Tracing (B\-M\-R\-T) do allow image shaders and properly set the background color. If this sounds too confusing, use the following rules\-: If you are using Pixar's Renderman, leave the Background off. Otherwise, try setting Back\-Ground\-On and see if you get the desired results.  
\item {\ttfamily obj.\-Background\-On ()} -\/ Set/\-Get the background flag. Default is 0 (off). If set, the rib file will contain an image shader that will use the renderer window's background color. Normally, Render\-Man does generate backgrounds. Backgrounds are composited into the scene with the tiffcomp program that comes with Pixar's Render\-Man Toolkit. In fact, Pixar's Renderman will accept an image shader but only sets the alpha of the background. Images created this way will still have a black background but contain an alpha of 1 at all pixels and C\-A\-N\-N\-O\-T be subsequently composited with other images using tiffcomp. However, other Render\-Man compliant renderers like Blue Moon Ray Tracing (B\-M\-R\-T) do allow image shaders and properly set the background color. If this sounds too confusing, use the following rules\-: If you are using Pixar's Renderman, leave the Background off. Otherwise, try setting Back\-Ground\-On and see if you get the desired results.  
\item {\ttfamily obj.\-Background\-Off ()} -\/ Set/\-Get the background flag. Default is 0 (off). If set, the rib file will contain an image shader that will use the renderer window's background color. Normally, Render\-Man does generate backgrounds. Backgrounds are composited into the scene with the tiffcomp program that comes with Pixar's Render\-Man Toolkit. In fact, Pixar's Renderman will accept an image shader but only sets the alpha of the background. Images created this way will still have a black background but contain an alpha of 1 at all pixels and C\-A\-N\-N\-O\-T be subsequently composited with other images using tiffcomp. However, other Render\-Man compliant renderers like Blue Moon Ray Tracing (B\-M\-R\-T) do allow image shaders and properly set the background color. If this sounds too confusing, use the following rules\-: If you are using Pixar's Renderman, leave the Background off. Otherwise, try setting Back\-Ground\-On and see if you get the desired results.  
\item {\ttfamily obj.\-Set\-Export\-Arrays (int )} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\item {\ttfamily int = obj.\-Get\-Export\-Arrays\-Min\-Value ()} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\item {\ttfamily int = obj.\-Get\-Export\-Arrays\-Max\-Value ()} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\item {\ttfamily obj.\-Export\-Arrays\-On ()} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\item {\ttfamily obj.\-Export\-Arrays\-Off ()} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\item {\ttfamily int = obj.\-Get\-Export\-Arrays ()} -\/ Set or get the Export\-Arrays. If Export\-Arrays is set, then all point data, field data, and cell data arrays will get exported together with polygons.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkriblight}{}\section{vtk\-R\-I\-B\-Light}\label{vtkhybrid_vtkriblight}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-R\-I\-B\-Light is a subclass of vtk\-Light that allows the user to specify light source shaders and shadow casting lights for use with Render\-Man.

To create an instance of class vtk\-R\-I\-B\-Light, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRIBLight
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-R\-I\-B\-Light 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\-R\-I\-B\-Light class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-R\-I\-B\-Light = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-R\-I\-B\-Light = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Shadows\-On ()}  
\item {\ttfamily obj.\-Shadows\-Off ()}  
\item {\ttfamily obj.\-Set\-Shadows (int )}  
\item {\ttfamily int = obj.\-Get\-Shadows ()}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, int index)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkribproperty}{}\section{vtk\-R\-I\-B\-Property}\label{vtkhybrid_vtkribproperty}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-R\-I\-B\-Property is a subclass of vtk\-Property that allows the user to specify named shaders for use with Render\-Man. Both a surface shader and displacement shader can be specified. Parameters for the shaders can be declared and set.

To create an instance of class vtk\-R\-I\-B\-Property, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRIBProperty
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-R\-I\-B\-Property 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\-R\-I\-B\-Property class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-R\-I\-B\-Property = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-R\-I\-B\-Property = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Surface\-Shader (string )} -\/ Specify the name of a surface shader.  
\item {\ttfamily string = obj.\-Get\-Surface\-Shader ()} -\/ Specify the name of a surface shader.  
\item {\ttfamily obj.\-Set\-Displacement\-Shader (string )} -\/ Specify the name of a displacement shader.  
\item {\ttfamily string = obj.\-Get\-Displacement\-Shader ()} -\/ Specify the name of a displacement shader.  
\item {\ttfamily obj.\-Set\-Variable (string variable, string declaration)} -\/ Specify declarations for variables..  
\item {\ttfamily obj.\-Add\-Variable (string variable, string declaration)} -\/ Specify declarations for variables..  
\item {\ttfamily string = obj.\-Get\-Declarations ()} -\/ Get variable declarations  
\item {\ttfamily obj.\-Set\-Parameter (string parameter, string value)} -\/ Specify parameter values for variables.  
\item {\ttfamily obj.\-Add\-Parameter (string parameter, string value)} -\/ Specify parameter values for variables.  
\item {\ttfamily string = obj.\-Get\-Parameters ()} -\/ Get parameters.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkspiderplotactor}{}\section{vtk\-Spider\-Plot\-Actor}\label{vtkhybrid_vtkspiderplotactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spider\-Plot\-Actor generates a spider plot from an input field (i.\-e., vtk\-Data\-Object). A spider plot represents N-\/dimensional data by using a set of N axes that originate from the center of a circle, and form the spokes of a wheel (like a spider web). Each N-\/dimensional point is plotted as a polyline that forms a closed polygon; the vertices of the polygon are plotted against the radial axes.

To use this class, you must specify an input data object. You'll probably also want to specify the position of the plot be setting the Position and Position2 instance variables, which define a rectangle in which the plot lies. Another important parameter is the Independent\-Variables ivar, which tells the instance how to interpret the field data (independent variables as the rows or columns of the field). There are also many other instance variables that control the look of the plot includes its title and legend.

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated with these components.

To create an instance of class vtk\-Spider\-Plot\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSpiderPlotActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spider\-Plot\-Actor 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\-Spider\-Plot\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Spider\-Plot\-Actor = obj.\-New\-Instance ()} -\/ Standard methods for type information and printing.  
\item {\ttfamily vtk\-Spider\-Plot\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the input to the spider plot actor.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Get the input data object to this actor.  
\item {\ttfamily obj.\-Set\-Independent\-Variables (int )} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily int = obj.\-Get\-Independent\-Variables\-Min\-Value ()} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily int = obj.\-Get\-Independent\-Variables\-Max\-Value ()} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily int = obj.\-Get\-Independent\-Variables ()} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily obj.\-Set\-Independent\-Variables\-To\-Columns ()} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily obj.\-Set\-Independent\-Variables\-To\-Rows ()} -\/ Specify whether to use the rows or columns as independent variables. If columns, then each row represents a separate point. If rows, then each column represents a separate point.  
\item {\ttfamily obj.\-Set\-Title\-Visibility (int )} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily int = obj.\-Get\-Title\-Visibility ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-On ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Title\-Visibility\-Off ()} -\/ Enable/\-Disable the display of a plot title.  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the spider plot.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the spider plot.  
\item {\ttfamily obj.\-Set\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property.  
\item {\ttfamily obj.\-Set\-Label\-Visibility (int )}  
\item {\ttfamily int = obj.\-Get\-Label\-Visibility ()}  
\item {\ttfamily obj.\-Label\-Visibility\-On ()}  
\item {\ttfamily obj.\-Label\-Visibility\-Off ()}  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Rings (int )} -\/ Specify the number of circumferential rings. If set to zero, then none will be shown; othewise the specified number will be shown.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Rings\-Min\-Value ()} -\/ Specify the number of circumferential rings. If set to zero, then none will be shown; othewise the specified number will be shown.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Rings\-Max\-Value ()} -\/ Specify the number of circumferential rings. If set to zero, then none will be shown; othewise the specified number will be shown.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Rings ()} -\/ Specify the number of circumferential rings. If set to zero, then none will be shown; othewise the specified number will be shown.  
\item {\ttfamily obj.\-Set\-Axis\-Label (int i, string )} -\/ Specify the names of the radial spokes (i.\-e., the radial axes). If not specified, then an integer number is automatically generated.  
\item {\ttfamily string = obj.\-Get\-Axis\-Label (int i)} -\/ Specify the names of the radial spokes (i.\-e., the radial axes). If not specified, then an integer number is automatically generated.  
\item {\ttfamily obj.\-Set\-Axis\-Range (int i, double min, double max)} -\/ Specify the range of data on each radial axis. If not specified, then the range is computed automatically.  
\item {\ttfamily obj.\-Set\-Axis\-Range (int i, double range\mbox{[}2\mbox{]})} -\/ Specify the range of data on each radial axis. If not specified, then the range is computed automatically.  
\item {\ttfamily obj.\-Get\-Axis\-Range (int i, double range\mbox{[}2\mbox{]})} -\/ Specify the range of data on each radial axis. If not specified, then the range is computed automatically.  
\item {\ttfamily obj.\-Set\-Plot\-Color (int i, double r, double g, double b)} -\/ Specify colors for each plot. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Plot\-Color (int i, double color\mbox{[}3\mbox{]})} -\/ Specify colors for each plot. If not specified, they are automatically generated.  
\item {\ttfamily obj.\-Set\-Legend\-Visibility (int )} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily int = obj.\-Get\-Legend\-Visibility ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-On ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Visibility\-Off ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-Get\-Legend\-Actor ()} -\/ Retrieve handles to the legend box. This is useful if you would like to manually control the legend appearance.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Draw the spider plot.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the spider plot.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkstructuredextent}{}\section{vtk\-Structured\-Extent}\label{vtkhybrid_vtkstructuredextent}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Structured\-Extent is an helper class that helps in arithmetic with structured extents. It defines a bunch of static methods (most of which are inlined) to aid in dealing with extents.

To create an instance of class vtk\-Structured\-Extent, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStructuredExtent
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Structured\-Extent 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\-Structured\-Extent class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Structured\-Extent = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Structured\-Extent = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtktemporaldatasetcache}{}\section{vtk\-Temporal\-Data\-Set\-Cache}\label{vtkhybrid_vtktemporaldatasetcache}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Temporal\-Data\-Set\-Cache cache time step requests of a temporal dataset, when cached data is requested it is returned using a shallow copy. .S\-E\-C\-T\-I\-O\-N Thanks Ken Martin (Kitware) and John Bidiscombe of C\-S\-C\-S -\/ Swiss National Supercomputing Centre for creating and contributing this class. For related material, please refer to \-: John Biddiscombe, Berk Geveci, Ken Martin, Kenneth Moreland, David Thompson, \char`\"{}\-Time Dependent Processing in a Parallel Pipeline Architecture\char`\"{}, I\-E\-E\-E Visualization 2007.

To create an instance of class vtk\-Temporal\-Data\-Set\-Cache, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalDataSetCache
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Data\-Set\-Cache 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\-Temporal\-Data\-Set\-Cache class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Temporal\-Data\-Set\-Cache = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Temporal\-Data\-Set\-Cache = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Cache\-Size (int size)} -\/ This is the maximum number of time steps that can be retained in memory. it defaults to 10.  
\item {\ttfamily int = obj.\-Get\-Cache\-Size ()} -\/ This is the maximum number of time steps that can be retained in memory. it defaults to 10.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtktemporalinterpolator}{}\section{vtk\-Temporal\-Interpolator}\label{vtkhybrid_vtktemporalinterpolator}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Temporal\-Interpolator interpolates between two time steps to produce new data for an arbitrary T. vtk\-Temporal\-Interpolator has three modes of operation. The default mode is to produce a continuous range of time values as output, which enables a filter downstream to request any value of T within the range. The second mode of operation is enabled by setting Discrete\-Time\-Step\-Interval to a non zero value. When this mode is activated, the filter will report a finite number of Time steps separated by delta\-T between the original range of values. This mode is useful when a dataset of N time steps has one (or more) missing datasets for certain T values and you simply wish to smooth over the missing steps but otherwise use the original data. The third mode of operation is enabled by setting Resample\-Factor to a non zero positive integer value. When this mode is activated, the filter will report a finite number of Time steps which contain the original steps, plus N new values between each original step 1/\-Resample\-Factor time units apart. Note that if the input time steps are irregular, then using Resample\-Factor will produce an irregular sequence of regular steps between each of the original irregular steps (clear enough, yes?).

Higher order interpolation schemes will require changes to the A\-P\-I as most calls assume only two timesteps are used.

To create an instance of class vtk\-Temporal\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Interpolator 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\-Temporal\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Temporal\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Temporal\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Discrete\-Time\-Step\-Interval (double )} -\/ If you require a discrete number of outputs steps, to be generated from an input source -\/ for example, you required N steps separated by T, then set Discrete\-Time\-Step\-Interval to T and you will get T\-I\-M\-E\-\_\-\-R\-A\-N\-G\-E/\-Discrete\-Time\-Step\-Interval steps This is a useful option to use if you have a dataset with one missing time step and wish to 'fill-\/in' the missing data with an interpolated value from the steps either side  
\item {\ttfamily double = obj.\-Get\-Discrete\-Time\-Step\-Interval ()} -\/ If you require a discrete number of outputs steps, to be generated from an input source -\/ for example, you required N steps separated by T, then set Discrete\-Time\-Step\-Interval to T and you will get T\-I\-M\-E\-\_\-\-R\-A\-N\-G\-E/\-Discrete\-Time\-Step\-Interval steps This is a useful option to use if you have a dataset with one missing time step and wish to 'fill-\/in' the missing data with an interpolated value from the steps either side  
\item {\ttfamily obj.\-Set\-Resample\-Factor (int )} -\/ When Resample\-Factor is a non zero positive integer, each pair of input time steps will be interpolated between with the number of steps specified. For example an input of 1,2,3,4,5 and a resample factor of 10, will produce steps 0f 1.\-0, 1.\-1, 1.\-2.....1.\-9, 2.\-0 etc N\-B. Irregular input steps will produce irregular output steps. Resample factor wuill only be used if Discrete\-Time\-Step\-Interval is zero otherwise the Discrete\-Time\-Step\-Interval takes precedence  
\item {\ttfamily int = obj.\-Get\-Resample\-Factor ()} -\/ When Resample\-Factor is a non zero positive integer, each pair of input time steps will be interpolated between with the number of steps specified. For example an input of 1,2,3,4,5 and a resample factor of 10, will produce steps 0f 1.\-0, 1.\-1, 1.\-2.....1.\-9, 2.\-0 etc N\-B. Irregular input steps will produce irregular output steps. Resample factor wuill only be used if Discrete\-Time\-Step\-Interval is zero otherwise the Discrete\-Time\-Step\-Interval takes precedence  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtktemporalshiftscale}{}\section{vtk\-Temporal\-Shift\-Scale}\label{vtkhybrid_vtktemporalshiftscale}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Temporal\-Shift\-Scale modify the time range or time steps of the data without changing the data itself. The data is not resampled by this filter, only the information accompanying the data is modified.

To create an instance of class vtk\-Temporal\-Shift\-Scale, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalShiftScale
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Shift\-Scale 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\-Temporal\-Shift\-Scale class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Temporal\-Shift\-Scale = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Temporal\-Shift\-Scale = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pre\-Shift (double )} -\/ Apply a translation to the data before scaling. To convert T\{5,100\} to T\{0,1\} use Preshift=-\/5, Scale=1/95, Post\-Shift=0 To convert T\{5,105\} to T\{5,10\} use Preshift=-\/5, Scale=5/100, Post\-Shift=5  
\item {\ttfamily double = obj.\-Get\-Pre\-Shift ()} -\/ Apply a translation to the data before scaling. To convert T\{5,100\} to T\{0,1\} use Preshift=-\/5, Scale=1/95, Post\-Shift=0 To convert T\{5,105\} to T\{5,10\} use Preshift=-\/5, Scale=5/100, Post\-Shift=5  
\item {\ttfamily obj.\-Set\-Post\-Shift (double )} -\/ Apply a translation to the time  
\item {\ttfamily double = obj.\-Get\-Post\-Shift ()} -\/ Apply a translation to the time  
\item {\ttfamily obj.\-Set\-Scale (double )} -\/ Apply a scale to the time.  
\item {\ttfamily double = obj.\-Get\-Scale ()} -\/ Apply a scale to the time.  
\item {\ttfamily obj.\-Set\-Periodic (int )} -\/ If Periodic is true, requests for time will be wrapped around so that the source appears to be a periodic time source. If data exists for times \{0,N-\/1\}, setting periodic to true will cause time 0 to be produced when time N, 2\-N, 2\-N etc is requested. This effectively gives the source the ability to generate time data indefinitely in a loop. When combined with Shift/\-Scale, the time becomes periodic in the shifted and scaled time frame of reference. Note\-: Since the input time may not start at zero, the wrapping of time from the end of one period to the start of the next, will subtract the initial time -\/ a source with T\{5..6\} repeated periodicaly will have output time \{5..6..7..8\} etc.  
\item {\ttfamily int = obj.\-Get\-Periodic ()} -\/ If Periodic is true, requests for time will be wrapped around so that the source appears to be a periodic time source. If data exists for times \{0,N-\/1\}, setting periodic to true will cause time 0 to be produced when time N, 2\-N, 2\-N etc is requested. This effectively gives the source the ability to generate time data indefinitely in a loop. When combined with Shift/\-Scale, the time becomes periodic in the shifted and scaled time frame of reference. Note\-: Since the input time may not start at zero, the wrapping of time from the end of one period to the start of the next, will subtract the initial time -\/ a source with T\{5..6\} repeated periodicaly will have output time \{5..6..7..8\} etc.  
\item {\ttfamily obj.\-Periodic\-On ()} -\/ If Periodic is true, requests for time will be wrapped around so that the source appears to be a periodic time source. If data exists for times \{0,N-\/1\}, setting periodic to true will cause time 0 to be produced when time N, 2\-N, 2\-N etc is requested. This effectively gives the source the ability to generate time data indefinitely in a loop. When combined with Shift/\-Scale, the time becomes periodic in the shifted and scaled time frame of reference. Note\-: Since the input time may not start at zero, the wrapping of time from the end of one period to the start of the next, will subtract the initial time -\/ a source with T\{5..6\} repeated periodicaly will have output time \{5..6..7..8\} etc.  
\item {\ttfamily obj.\-Periodic\-Off ()} -\/ If Periodic is true, requests for time will be wrapped around so that the source appears to be a periodic time source. If data exists for times \{0,N-\/1\}, setting periodic to true will cause time 0 to be produced when time N, 2\-N, 2\-N etc is requested. This effectively gives the source the ability to generate time data indefinitely in a loop. When combined with Shift/\-Scale, the time becomes periodic in the shifted and scaled time frame of reference. Note\-: Since the input time may not start at zero, the wrapping of time from the end of one period to the start of the next, will subtract the initial time -\/ a source with T\{5..6\} repeated periodicaly will have output time \{5..6..7..8\} etc.  
\item {\ttfamily obj.\-Set\-Periodic\-End\-Correction (int )} -\/ if Periodic time is enabled, this flag determines if the last time step is the same as the first. If Periodic\-End\-Correction is true, then it is assumed that the input data goes from 0-\/1 (or whatever scaled/shifted actual time) and time 1 is the same as time 0 so that steps will be 0,1,2,3...N,1,2,3...N,1,2,3 where step N is the same as 0 and step 0 is not repeated. When this flag is false the data is assumed to be literal and output is of the form 0,1,2,3...N,0,1,2,3... By default this flag is O\-N  
\item {\ttfamily int = obj.\-Get\-Periodic\-End\-Correction ()} -\/ if Periodic time is enabled, this flag determines if the last time step is the same as the first. If Periodic\-End\-Correction is true, then it is assumed that the input data goes from 0-\/1 (or whatever scaled/shifted actual time) and time 1 is the same as time 0 so that steps will be 0,1,2,3...N,1,2,3...N,1,2,3 where step N is the same as 0 and step 0 is not repeated. When this flag is false the data is assumed to be literal and output is of the form 0,1,2,3...N,0,1,2,3... By default this flag is O\-N  
\item {\ttfamily obj.\-Periodic\-End\-Correction\-On ()} -\/ if Periodic time is enabled, this flag determines if the last time step is the same as the first. If Periodic\-End\-Correction is true, then it is assumed that the input data goes from 0-\/1 (or whatever scaled/shifted actual time) and time 1 is the same as time 0 so that steps will be 0,1,2,3...N,1,2,3...N,1,2,3 where step N is the same as 0 and step 0 is not repeated. When this flag is false the data is assumed to be literal and output is of the form 0,1,2,3...N,0,1,2,3... By default this flag is O\-N  
\item {\ttfamily obj.\-Periodic\-End\-Correction\-Off ()} -\/ if Periodic time is enabled, this flag determines if the last time step is the same as the first. If Periodic\-End\-Correction is true, then it is assumed that the input data goes from 0-\/1 (or whatever scaled/shifted actual time) and time 1 is the same as time 0 so that steps will be 0,1,2,3...N,1,2,3...N,1,2,3 where step N is the same as 0 and step 0 is not repeated. When this flag is false the data is assumed to be literal and output is of the form 0,1,2,3...N,0,1,2,3... By default this flag is O\-N  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Periods (double )} -\/ if Periodic time is enabled, this controls how many time periods time is reported for. A filter cannot output an infinite number of time steps and therefore a finite number of periods is generated when reporting time.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Number\-Of\-Periods ()} -\/ if Periodic time is enabled, this controls how many time periods time is reported for. A filter cannot output an infinite number of time steps and therefore a finite number of periods is generated when reporting time.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtktemporalsnaptotimestep}{}\section{vtk\-Temporal\-Snap\-To\-Time\-Step}\label{vtkhybrid_vtktemporalsnaptotimestep}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Temporal\-Snap\-To\-Time\-Step modify the time range or time steps of the data without changing the data itself. The data is not resampled by this filter, only the information accompanying the data is modified.

To create an instance of class vtk\-Temporal\-Snap\-To\-Time\-Step, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTemporalSnapToTimeStep
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Temporal\-Snap\-To\-Time\-Step 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\-Temporal\-Snap\-To\-Time\-Step class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Temporal\-Snap\-To\-Time\-Step = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Temporal\-Snap\-To\-Time\-Step = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Snap\-Mode (int )}  
\item {\ttfamily int = obj.\-Get\-Snap\-Mode ()}  
\item {\ttfamily obj.\-Set\-Snap\-Mode\-To\-Nearest ()}  
\item {\ttfamily obj.\-Set\-Snap\-Mode\-To\-Next\-Below\-Or\-Equal ()}  
\item {\ttfamily obj.\-Set\-Snap\-Mode\-To\-Next\-Above\-Or\-Equal ()}  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkthinplatesplinetransform}{}\section{vtk\-Thin\-Plate\-Spline\-Transform}\label{vtkhybrid_vtkthinplatesplinetransform}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Thin\-Plate\-Spline\-Transform describes a nonlinear warp transform defined by a set of source and target landmarks. Any point on the mesh close to a source landmark will be moved to a place close to the corresponding target landmark. The points in between are interpolated smoothly using Bookstein's Thin Plate Spline algorithm.

To obtain a correct T\-P\-S warp, use the R2\-Log\-R kernel if your data is 2\-D, and the R kernel if your data is 3\-D. Or you can specify your own R\-B\-F. (Hence this class is more general than a pure T\-P\-S transform.)

To create an instance of class vtk\-Thin\-Plate\-Spline\-Transform, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkThinPlateSplineTransform
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Thin\-Plate\-Spline\-Transform 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\-Thin\-Plate\-Spline\-Transform class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Thin\-Plate\-Spline\-Transform = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Thin\-Plate\-Spline\-Transform = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Sigma ()} -\/ Specify the 'stiffness' of the spline. The default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Sigma (double )} -\/ Specify the 'stiffness' of the spline. The default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Basis (int basis)} -\/ Specify the radial basis function to use. The default is R2\-Log\-R which is appropriate for 2\-D. Use $|$\-R$|$ (Set\-Basis\-To\-R) if your data is 3\-D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-\/plate spline.  
\item {\ttfamily int = obj.\-Get\-Basis ()} -\/ Specify the radial basis function to use. The default is R2\-Log\-R which is appropriate for 2\-D. Use $|$\-R$|$ (Set\-Basis\-To\-R) if your data is 3\-D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-\/plate spline.  
\item {\ttfamily obj.\-Set\-Basis\-To\-R ()} -\/ Specify the radial basis function to use. The default is R2\-Log\-R which is appropriate for 2\-D. Use $|$\-R$|$ (Set\-Basis\-To\-R) if your data is 3\-D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-\/plate spline.  
\item {\ttfamily obj.\-Set\-Basis\-To\-R2\-Log\-R ()} -\/ Specify the radial basis function to use. The default is R2\-Log\-R which is appropriate for 2\-D. Use $|$\-R$|$ (Set\-Basis\-To\-R) if your data is 3\-D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-\/plate spline.  
\item {\ttfamily string = obj.\-Get\-Basis\-As\-String ()} -\/ Specify the radial basis function to use. The default is R2\-Log\-R which is appropriate for 2\-D. Use $|$\-R$|$ (Set\-Basis\-To\-R) if your data is 3\-D. Alternatively specify your own basis function, however this will mean that the transform will no longer be a true thin-\/plate spline.  
\item {\ttfamily obj.\-Set\-Source\-Landmarks (vtk\-Points source)} -\/ Set the source landmarks for the warp. If you add or change the vtk\-Points object, you must call Modified() on it or the transformation might not update.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Source\-Landmarks ()} -\/ Set the source landmarks for the warp. If you add or change the vtk\-Points object, you must call Modified() on it or the transformation might not update.  
\item {\ttfamily obj.\-Set\-Target\-Landmarks (vtk\-Points target)} -\/ Set the target landmarks for the warp. If you add or change the vtk\-Points object, you must call Modified() on it or the transformation might not update.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Target\-Landmarks ()} -\/ Set the target landmarks for the warp. If you add or change the vtk\-Points object, you must call Modified() on it or the transformation might not update.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the M\-Time.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Make\-Transform ()} -\/ Make another transform of the same type.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtktransformtogrid}{}\section{vtk\-Transform\-To\-Grid}\label{vtkhybrid_vtktransformtogrid}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Transform\-To\-Grid takes any transform as input and produces a grid for use by a vtk\-Grid\-Transform. This can be used, for example, to invert a grid transform, concatenate two grid transforms, or to convert a thin plate spline transform into a grid transform.

To create an instance of class vtk\-Transform\-To\-Grid, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformToGrid
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-To\-Grid 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\-Transform\-To\-Grid class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-To\-Grid = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-To\-Grid = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Abstract\-Transform )} -\/ Set/\-Get the transform which will be converted into a grid.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Input ()} -\/ Set/\-Get the transform which will be converted into a grid.  
\item {\ttfamily obj.\-Set\-Grid\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the extent of the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the extent of the grid.  
\item {\ttfamily int = obj. Get\-Grid\-Extent ()} -\/ Get/\-Set the extent of the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Origin (double , double , double )} -\/ Get/\-Set the origin of the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Origin (double a\mbox{[}3\mbox{]})} -\/ Get/\-Set the origin of the grid.  
\item {\ttfamily double = obj. Get\-Grid\-Origin ()} -\/ Get/\-Set the origin of the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Spacing (double , double , double )} -\/ Get/\-Set the spacing between samples in the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Get/\-Set the spacing between samples in the grid.  
\item {\ttfamily double = obj. Get\-Grid\-Spacing ()} -\/ Get/\-Set the spacing between samples in the grid.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type (int )} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily int = obj.\-Get\-Grid\-Scalar\-Type ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type\-To\-Float ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type\-To\-Short ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type\-To\-Unsigned\-Short ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type\-To\-Unsigned\-Char ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily obj.\-Set\-Grid\-Scalar\-Type\-To\-Char ()} -\/ Get/\-Set the scalar type of the grid. The default is double.  
\item {\ttfamily double = obj.\-Get\-Displacement\-Scale ()} -\/ Get the scale and shift to convert integer grid elements into real values\-: dx = scale$\ast$di + shift. If the grid is of double type, then scale = 1 and shift = 0.  
\item {\ttfamily double = obj.\-Get\-Displacement\-Shift ()} -\/ Get the scale and shift to convert integer grid elements into real values\-: dx = scale$\ast$di + shift. If the grid is of double type, then scale = 1 and shift = 0.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkvectortext}{}\section{vtk\-Vector\-Text}\label{vtkhybrid_vtkvectortext}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Vector\-Text, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVectorText
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Vector\-Text 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\-Vector\-Text class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Vector\-Text = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Vector\-Text = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Text (string )} -\/ Set/\-Get the text to be drawn.  
\item {\ttfamily string = obj.\-Get\-Text ()} -\/ Set/\-Get the text to be drawn.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkvideosource}{}\section{vtk\-Video\-Source}\label{vtkhybrid_vtkvideosource}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Video\-Source is a superclass for video input interfaces for V\-T\-K. The goal is to provide an interface which is very similar to the interface of a V\-C\-R, where the 'tape' is an internal frame buffer capable of holding a preset number of video frames. Specialized versions of this class record input from various video input sources. This base class records input from a noise source.

To create an instance of class vtk\-Video\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVideoSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Video\-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\-Video\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Video\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Video\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Record ()} -\/ Record incoming video at the specified Frame\-Rate. The recording continues indefinitely until Stop() is called.  
\item {\ttfamily obj.\-Play ()} -\/ Play through the 'tape' sequentially at the specified frame rate. If you have just finished Recoding, you should call Rewind() first.  
\item {\ttfamily obj.\-Stop ()} -\/ Stop recording or playing.  
\item {\ttfamily obj.\-Rewind ()} -\/ Rewind to the frame with the earliest timestamp. Record operations will start on the following frame, therefore if you want to re-\/record over this frame you must call Seek(-\/1) before calling Grab() or Record().  
\item {\ttfamily obj.\-Fast\-Forward ()} -\/ Fast\-Forward to the last frame that was recorded (i.\-e. to the frame that has the most recent timestamp).  
\item {\ttfamily obj.\-Seek (int n)} -\/ Seek forwards or backwards by the specified number of frames (positive is forward, negative is backward).  
\item {\ttfamily obj.\-Grab ()} -\/ Grab a single video frame.  
\item {\ttfamily int = obj.\-Get\-Recording ()} -\/ Are we in record mode? (record mode and play mode are mutually exclusive).  
\item {\ttfamily int = obj.\-Get\-Playing ()} -\/ Are we in play mode? (record mode and play mode are mutually exclusive).  
\item {\ttfamily obj.\-Set\-Frame\-Size (int x, int y, int z)} -\/ Set the full-\/frame size. This must be an allowed size for the device, the device may either refuse a request for an illegal frame size or automatically choose a new frame size. The default is usually 320x240x1, but can be device specific. The 'depth' should always be 1 (unless you have a device that can handle 3\-D acquisition).  
\item {\ttfamily obj.\-Set\-Frame\-Size (int dim\mbox{[}3\mbox{]})} -\/ Set the full-\/frame size. This must be an allowed size for the device, the device may either refuse a request for an illegal frame size or automatically choose a new frame size. The default is usually 320x240x1, but can be device specific. The 'depth' should always be 1 (unless you have a device that can handle 3\-D acquisition).  
\item {\ttfamily int = obj. Get\-Frame\-Size ()} -\/ Set the full-\/frame size. This must be an allowed size for the device, the device may either refuse a request for an illegal frame size or automatically choose a new frame size. The default is usually 320x240x1, but can be device specific. The 'depth' should always be 1 (unless you have a device that can handle 3\-D acquisition).  
\item {\ttfamily obj.\-Set\-Frame\-Rate (float rate)} -\/ Request a particular frame rate (default 30 frames per second).  
\item {\ttfamily float = obj.\-Get\-Frame\-Rate ()} -\/ Request a particular frame rate (default 30 frames per second).  
\item {\ttfamily obj.\-Set\-Output\-Format (int format)} -\/ Set the output format. This must be appropriate for device, usually only V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E, V\-T\-K\-\_\-\-R\-G\-B, and V\-T\-K\-\_\-\-R\-G\-B\-A are supported.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-Luminance ()} -\/ Set the output format. This must be appropriate for device, usually only V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E, V\-T\-K\-\_\-\-R\-G\-B, and V\-T\-K\-\_\-\-R\-G\-B\-A are supported.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-R\-G\-B ()} -\/ Set the output format. This must be appropriate for device, usually only V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E, V\-T\-K\-\_\-\-R\-G\-B, and V\-T\-K\-\_\-\-R\-G\-B\-A are supported.  
\item {\ttfamily obj.\-Set\-Output\-Format\-To\-R\-G\-B\-A ()} -\/ Set the output format. This must be appropriate for device, usually only V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E, V\-T\-K\-\_\-\-R\-G\-B, and V\-T\-K\-\_\-\-R\-G\-B\-A are supported.  
\item {\ttfamily int = obj.\-Get\-Output\-Format ()} -\/ Set the output format. This must be appropriate for device, usually only V\-T\-K\-\_\-\-L\-U\-M\-I\-N\-A\-N\-C\-E, V\-T\-K\-\_\-\-R\-G\-B, and V\-T\-K\-\_\-\-R\-G\-B\-A are supported.  
\item {\ttfamily obj.\-Set\-Frame\-Buffer\-Size (int Frame\-Buffer\-Size)} -\/ Set size of the frame buffer, i.\-e. the number of frames that the 'tape' can store.  
\item {\ttfamily int = obj.\-Get\-Frame\-Buffer\-Size ()} -\/ Set size of the frame buffer, i.\-e. the number of frames that the 'tape' can store.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Output\-Frames (int )} -\/ Set the number of frames to copy to the output on each execute. The frames will be concatenated along the Z dimension, with the most recent frame first. Default\-: 1  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Output\-Frames ()} -\/ Set the number of frames to copy to the output on each execute. The frames will be concatenated along the Z dimension, with the most recent frame first. Default\-: 1  
\item {\ttfamily obj.\-Auto\-Advance\-On ()} -\/ Set whether to automatically advance the buffer before each grab. Default\-: on  
\item {\ttfamily obj.\-Auto\-Advance\-Off ()} -\/ Set whether to automatically advance the buffer before each grab. Default\-: on  
\item {\ttfamily obj.\-Set\-Auto\-Advance (int )} -\/ Set whether to automatically advance the buffer before each grab. Default\-: on  
\item {\ttfamily int = obj.\-Get\-Auto\-Advance ()} -\/ Set whether to automatically advance the buffer before each grab. Default\-: on  
\item {\ttfamily obj.\-Set\-Clip\-Region (int r\mbox{[}6\mbox{]})} -\/ Set the clip rectangle for the frames. The video will be clipped before it is copied into the framebuffer. Changing the Clip\-Region will destroy the current contents of the framebuffer. The default Clip\-Region is (0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X).  
\item {\ttfamily obj.\-Set\-Clip\-Region (int x0, int x1, int y0, int y1, int z0, int z1)} -\/ Set the clip rectangle for the frames. The video will be clipped before it is copied into the framebuffer. Changing the Clip\-Region will destroy the current contents of the framebuffer. The default Clip\-Region is (0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X).  
\item {\ttfamily int = obj. Get\-Clip\-Region ()} -\/ Set the clip rectangle for the frames. The video will be clipped before it is copied into the framebuffer. Changing the Clip\-Region will destroy the current contents of the framebuffer. The default Clip\-Region is (0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X,0,V\-T\-K\-\_\-\-I\-N\-T\-\_\-\-M\-A\-X).  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int , int , int , int , int , int )} -\/ Get/\-Set the Whole\-Extent of the output. This can be used to either clip or pad the video frame. This clipping/padding is done when the frame is copied to the output, and does not change the contents of the framebuffer. This is useful e.\-g. for expanding the output size to a power of two for texture mapping. The default is (0,-\/1,0,-\/1,0,-\/1) which causes the entire frame to be copied to the output.  
\item {\ttfamily obj.\-Set\-Output\-Whole\-Extent (int a\mbox{[}6\mbox{]})} -\/ Get/\-Set the Whole\-Extent of the output. This can be used to either clip or pad the video frame. This clipping/padding is done when the frame is copied to the output, and does not change the contents of the framebuffer. This is useful e.\-g. for expanding the output size to a power of two for texture mapping. The default is (0,-\/1,0,-\/1,0,-\/1) which causes the entire frame to be copied to the output.  
\item {\ttfamily int = obj. Get\-Output\-Whole\-Extent ()} -\/ Get/\-Set the Whole\-Extent of the output. This can be used to either clip or pad the video frame. This clipping/padding is done when the frame is copied to the output, and does not change the contents of the framebuffer. This is useful e.\-g. for expanding the output size to a power of two for texture mapping. The default is (0,-\/1,0,-\/1,0,-\/1) which causes the entire frame to be copied to the output.  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double , double , double )} -\/ Set/\-Get the pixel spacing. Default\-: (1.\-0,1.\-0,1.\-0)  
\item {\ttfamily obj.\-Set\-Data\-Spacing (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the pixel spacing. Default\-: (1.\-0,1.\-0,1.\-0)  
\item {\ttfamily double = obj. Get\-Data\-Spacing ()} -\/ Set/\-Get the pixel spacing. Default\-: (1.\-0,1.\-0,1.\-0)  
\item {\ttfamily obj.\-Set\-Data\-Origin (double , double , double )} -\/ Set/\-Get the coordinates of the lower, left corner of the frame. Default\-: (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily obj.\-Set\-Data\-Origin (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the coordinates of the lower, left corner of the frame. Default\-: (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily double = obj. Get\-Data\-Origin ()} -\/ Set/\-Get the coordinates of the lower, left corner of the frame. Default\-: (0.\-0,0.\-0,0.\-0)  
\item {\ttfamily obj.\-Set\-Opacity (float )} -\/ For R\-G\-B\-A output only (4 scalar components), set the opacity. This will not modify the existing contents of the framebuffer, only subsequently grabbed frames.  
\item {\ttfamily float = obj.\-Get\-Opacity ()} -\/ For R\-G\-B\-A output only (4 scalar components), set the opacity. This will not modify the existing contents of the framebuffer, only subsequently grabbed frames.  
\item {\ttfamily int = obj.\-Get\-Frame\-Count ()} -\/ This value is incremented each time a frame is grabbed. reset it to zero (or any other value) at any time.  
\item {\ttfamily obj.\-Set\-Frame\-Count (int )} -\/ This value is incremented each time a frame is grabbed. reset it to zero (or any other value) at any time.  
\item {\ttfamily int = obj.\-Get\-Frame\-Index ()} -\/ Get the frame index relative to the 'beginning of the tape'. This value wraps back to zero if it increases past the Frame\-Buffer\-Size.  
\item {\ttfamily double = obj.\-Get\-Frame\-Time\-Stamp (int frame)} -\/ Get a time stamp in seconds (resolution of milliseconds) for a video frame. Time began on Jan 1, 1970. You can specify a number (negative or positive) to specify the position of the video frame relative to the current frame.  
\item {\ttfamily double = obj.\-Get\-Frame\-Time\-Stamp ()} -\/ Get a time stamp in seconds (resolution of milliseconds) for the Output. Time began on Jan 1, 1970. This timestamp is only valid after the Output has been Updated.  
\item {\ttfamily obj.\-Initialize ()} -\/ Initialize the hardware. This is called automatically on the first Update or Grab.  
\item {\ttfamily int = obj.\-Get\-Initialized ()} -\/ Initialize the hardware. This is called automatically on the first Update or Grab.  
\item {\ttfamily obj.\-Release\-System\-Resources ()} -\/ Release the video driver. This method must be called before application exit, or else the application might hang during exit.  
\item {\ttfamily obj.\-Internal\-Grab ()} -\/ The internal function which actually does the grab. You will definitely want to override this if you develop a vtk\-Video\-Source subclass.  
\item {\ttfamily obj.\-Set\-Start\-Time\-Stamp (double t)} -\/ And internal variable which marks the beginning of a Record session. These methods are for internal use only.  
\item {\ttfamily double = obj.\-Get\-Start\-Time\-Stamp ()} -\/ And internal variable which marks the beginning of a Record session. These methods are for internal use only.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkvrmlimporter}{}\section{vtk\-V\-R\-M\-L\-Importer}\label{vtkhybrid_vtkvrmlimporter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-V\-R\-M\-L\-Importer imports V\-R\-M\-L 2.\-0 files into vtk.

To create an instance of class vtk\-V\-R\-M\-L\-Importer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVRMLImporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-V\-R\-M\-L\-Importer 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\-V\-R\-M\-L\-Importer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-V\-R\-M\-L\-Importer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-V\-R\-M\-L\-Importer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Object = obj.\-Get\-V\-R\-M\-L\-D\-E\-F\-Object (string name)} -\/ In the V\-R\-M\-L spec you can D\-E\-F and U\-S\-E nodes (name them), This routine will return the associated V\-T\-K object which was created as a result of the D\-E\-F mechanism Send in the name from the V\-R\-M\-L file, get the V\-T\-K object. You will have to check and correctly cast the object since this only returns vtk\-Objects.  
\item {\ttfamily obj.\-enter\-Node (string )} -\/ Needed by the yacc/lex grammar used  
\item {\ttfamily obj.\-exit\-Node ()} -\/ Needed by the yacc/lex grammar used  
\item {\ttfamily obj.\-enter\-Field (string )} -\/ Needed by the yacc/lex grammar used  
\item {\ttfamily obj.\-exit\-Field ()} -\/ Needed by the yacc/lex grammar used  
\item {\ttfamily obj.\-use\-Node (string )} -\/ Needed by the yacc/lex grammar used  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the name of the file to read.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the name of the file to read.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkweightedtransformfilter}{}\section{vtk\-Weighted\-Transform\-Filter}\label{vtkhybrid_vtkweightedtransformfilter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Weighted\-Transform\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWeightedTransformFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Weighted\-Transform\-Filter 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\-Weighted\-Transform\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Weighted\-Transform\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Weighted\-Transform\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the filter's transforms.  
\item {\ttfamily obj.\-Set\-Weight\-Array (string )} -\/ Weight\-Array is the string name of the Data\-Array in the input's Field\-Data that holds the weighting coefficients for each point. The filter will first look for the array in the input's Point\-Data Field\-Data. If the array isn't there, the filter looks in the input's Field\-Data. The Weight\-Array can have tuples of any length, but must have a tuple for every point in the input data set. This array transforms points, normals, and vectors.  
\item {\ttfamily string = obj.\-Get\-Weight\-Array ()} -\/ Weight\-Array is the string name of the Data\-Array in the input's Field\-Data that holds the weighting coefficients for each point. The filter will first look for the array in the input's Point\-Data Field\-Data. If the array isn't there, the filter looks in the input's Field\-Data. The Weight\-Array can have tuples of any length, but must have a tuple for every point in the input data set. This array transforms points, normals, and vectors.  
\item {\ttfamily obj.\-Set\-Transform\-Index\-Array (string )} -\/ Transform\-Index\-Array is the string name of the Data\-Array in the input's Field\-Data that holds the indices for the transforms for each point. These indices are used to select which transforms each weight of the Data\-Array refers. If the Transform\-Index\-Array is not specified, the weights of each point are assumed to map directly to a transform. This Data\-Array must be of type Unsigned\-Short, which effectively limits the number of transforms to 65536 if a transform index array is used.

The filter will first look for the array in the input's Point\-Data Field\-Data. If the array isn't there, the filter looks in the input's Field\-Data. The Transform\-Index\-Array can have tuples of any length, but must have a tuple for every point in the input data set. This array transforms points, normals, and vectors.  
\item {\ttfamily string = obj.\-Get\-Transform\-Index\-Array ()} -\/ Transform\-Index\-Array is the string name of the Data\-Array in the input's Field\-Data that holds the indices for the transforms for each point. These indices are used to select which transforms each weight of the Data\-Array refers. If the Transform\-Index\-Array is not specified, the weights of each point are assumed to map directly to a transform. This Data\-Array must be of type Unsigned\-Short, which effectively limits the number of transforms to 65536 if a transform index array is used.

The filter will first look for the array in the input's Point\-Data Field\-Data. If the array isn't there, the filter looks in the input's Field\-Data. The Transform\-Index\-Array can have tuples of any length, but must have a tuple for every point in the input data set. This array transforms points, normals, and vectors.  
\item {\ttfamily obj.\-Set\-Cell\-Data\-Weight\-Array (string )} -\/ The Cell\-Data\-Weight\-Array is analogous to the Weight\-Array, except for Cell\-Data. The array is searched for first in the Cell\-Data Field\-Data, then in the input's Field\-Data. The data array must have a tuple for each cell. This array is used to transform only normals and vectors.  
\item {\ttfamily string = obj.\-Get\-Cell\-Data\-Weight\-Array ()} -\/ The Cell\-Data\-Weight\-Array is analogous to the Weight\-Array, except for Cell\-Data. The array is searched for first in the Cell\-Data Field\-Data, then in the input's Field\-Data. The data array must have a tuple for each cell. This array is used to transform only normals and vectors.  
\item {\ttfamily obj.\-Set\-Cell\-Data\-Transform\-Index\-Array (string )}  
\item {\ttfamily string = obj.\-Get\-Cell\-Data\-Transform\-Index\-Array ()}  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Abstract\-Transform transform, int num)} -\/ Set or Get one of the filter's transforms. The transform number must be less than the number of transforms allocated for the object. Setting a transform slot to N\-U\-L\-L is equivalent to assigning an overriding weight of zero to that filter slot.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform (int num)} -\/ Set or Get one of the filter's transforms. The transform number must be less than the number of transforms allocated for the object. Setting a transform slot to N\-U\-L\-L is equivalent to assigning an overriding weight of zero to that filter slot.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Transforms (int num)} -\/ Set the number of transforms for the filter. References to non-\/existent filter numbers in the data array is equivalent to a weight of zero (i.\-e., no contribution of that filter or weight). The maximum number of transforms is limited to 65536 if transform index arrays are used.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Transforms ()} -\/ Set the number of transforms for the filter. References to non-\/existent filter numbers in the data array is equivalent to a weight of zero (i.\-e., no contribution of that filter or weight). The maximum number of transforms is limited to 65536 if transform index arrays are used.  
\item {\ttfamily obj.\-Add\-Input\-Values\-On ()} -\/ If Add\-Input\-Values is true, the output values of this filter will be offset from the input values. The effect is exactly equivalent to having an identity transform of weight 1 added into each output point.  
\item {\ttfamily obj.\-Add\-Input\-Values\-Off ()} -\/ If Add\-Input\-Values is true, the output values of this filter will be offset from the input values. The effect is exactly equivalent to having an identity transform of weight 1 added into each output point.  
\item {\ttfamily obj.\-Set\-Add\-Input\-Values (int )} -\/ If Add\-Input\-Values is true, the output values of this filter will be offset from the input values. The effect is exactly equivalent to having an identity transform of weight 1 added into each output point.  
\item {\ttfamily int = obj.\-Get\-Add\-Input\-Values ()} -\/ If Add\-Input\-Values is true, the output values of this filter will be offset from the input values. The effect is exactly equivalent to having an identity transform of weight 1 added into each output point.  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkx3dexporter}{}\section{vtk\-X3\-D\-Exporter}\label{vtkhybrid_vtkx3dexporter}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X3\-D\-Exporter is a render window exporter which writes out the renderered scene into an X3\-D file. X3\-D is an X\-M\-L-\/based format for representation 3\-D scenes (similar to V\-R\-M\-L). Check out \href{http://www.web3d.org/x3d/}{\tt http\-://www.\-web3d.\-org/x3d/} for more details. .S\-E\-C\-T\-I\-O\-N Thanks X3\-D\-Exporter is contributed by Christophe Mouton at E\-D\-F.

To create an instance of class vtk\-X3\-D\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkX3DExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X3\-D\-Exporter 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\-X3\-D\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X3\-D\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X3\-D\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/\-Get the output file name.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the output file name.  
\item {\ttfamily obj.\-Set\-Speed (double )} -\/ Specify the Speed of navigation. Default is 4.  
\item {\ttfamily double = obj.\-Get\-Speed ()} -\/ Specify the Speed of navigation. Default is 4.  
\item {\ttfamily obj.\-Set\-Binary (int )} -\/ Turn on binary mode  
\item {\ttfamily int = obj.\-Get\-Binary\-Min\-Value ()} -\/ Turn on binary mode  
\item {\ttfamily int = obj.\-Get\-Binary\-Max\-Value ()} -\/ Turn on binary mode  
\item {\ttfamily obj.\-Binary\-On ()} -\/ Turn on binary mode  
\item {\ttfamily obj.\-Binary\-Off ()} -\/ Turn on binary mode  
\item {\ttfamily int = obj.\-Get\-Binary ()} -\/ Turn on binary mode  
\item {\ttfamily obj.\-Set\-Fastest (int )} -\/ In binary mode use fastest instead of best compression  
\item {\ttfamily int = obj.\-Get\-Fastest\-Min\-Value ()} -\/ In binary mode use fastest instead of best compression  
\item {\ttfamily int = obj.\-Get\-Fastest\-Max\-Value ()} -\/ In binary mode use fastest instead of best compression  
\item {\ttfamily obj.\-Fastest\-On ()} -\/ In binary mode use fastest instead of best compression  
\item {\ttfamily obj.\-Fastest\-Off ()} -\/ In binary mode use fastest instead of best compression  
\item {\ttfamily int = obj.\-Get\-Fastest ()} -\/ In binary mode use fastest instead of best compression  
\end{DoxyItemize}\hypertarget{vtkhybrid_vtkxyplotactor}{}\section{vtk\-X\-Y\-Plot\-Actor}\label{vtkhybrid_vtkxyplotactor}
Section\-: \hyperlink{sec_vtkhybrid}{Visualization Toolkit Hybrid Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-Y\-Plot\-Actor creates an x-\/y plot of data from one or more input data sets or field data. The class plots dataset scalar values (y-\/axis) against the points (x-\/axis). The x-\/axis values are generated by taking the point ids, computing a cumulative arc length, or a normalized arc length. More than one input data set can be specified to generate multiple plots. Alternatively, if field data is supplied as input, the class plots one component against another. (The user must specify which component to use as the x-\/axis and which for the y-\/axis.)

To use this class to plot dataset(s), you must specify one or more input datasets containing scalar and point data. You'll probably also want to invoke a method to control how the point coordinates are converted into x values (by default point ids are used).

To use this class to plot field data, you must specify one or more input data objects with its associated field data. You'll also want to specify which component to use as the x-\/axis and which to use as the y-\/axis. Note that when plotting field data, the x and y values are used directly (i.\-e., there are no options to normalize the components).

Once you've set up the plot, you'll want to position it. The Position\-Coordinate defines the lower-\/left location of the x-\/y plot (specified in normalized viewport coordinates) and the Position2\-Coordinate define the upper-\/right corner. (Note\-: the Position2\-Coordinate is relative to Position\-Coordinate, so you can move the vtk\-X\-Y\-Plot\-Actor around the viewport by setting just the Position\-Coordinate.) The combination of the two position coordinates specifies a rectangle in which the plot will lie.

Optional features include the ability to specify axes labels, label format and plot title. You can also manually specify the x and y plot ranges (by default they are computed automatically). The Border instance variable is used to create space between the boundary of the plot window (specified by Position\-Coordinate and Position2\-Coordinate) and the plot itself.

The font property of the plot title can be modified through the Title\-Text\-Property attribute. The font property of the axes titles and labels can be modified through the Axis\-Title\-Text\-Property and Axis\-Label\-Text\-Property attributes. You may also use the Get\-X\-Axis\-Actor2\-D or Get\-Y\-Axis\-Actor2\-D methods to access each individual axis actor to modify their font properties. In the same way, the Get\-Legend\-Box\-Actor method can be used to access the legend box actor to modify its font properties.

There are several advanced features as well. You can assign per curve properties (such as color and a plot symbol). (Note that each input dataset and/or data object creates a single curve.) Another option is to add a plot legend that graphically indicates the correspondance between the curve, curve symbols, and the data source. You can also exchange the x and y axes if you prefer you plot orientation that way.

To create an instance of class vtk\-X\-Y\-Plot\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXYPlotActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-Y\-Plot\-Actor 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\-X\-Y\-Plot\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-Y\-Plot\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-Y\-Plot\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Set in, string array\-Name, int component)} -\/ Add a dataset to the list of data to append. The array name specifies which point array to plot. The array must be a vtk\-Data\-Array subclass, i.\-e. a numeric array. If the array name is N\-U\-L\-L, then the default scalars are used. The array can have multiple components, but only the first component is ploted.  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Set in)} -\/ Remove a dataset from the list of data to append.  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Data\-Set in, string array\-Name, int component)} -\/ Remove a dataset from the list of data to append.  
\item {\ttfamily obj.\-Remove\-Input (vtk\-Data\-Set in)} -\/ This removes all of the data set inputs, but does not change the data object inputs.  
\item {\ttfamily obj.\-Remove\-All\-Inputs ()} -\/ This removes all of the data set inputs, but does not change the data object inputs.  
\item {\ttfamily vtk\-Data\-Set\-Collection = obj.\-Get\-Input\-List ()} -\/ If plotting points by value, which component to use to determine the value. This sets a value per each input dataset (i.\-e., the ith dataset).  
\item {\ttfamily obj.\-Set\-Point\-Component (int i, int comp)} -\/ If plotting points by value, which component to use to determine the value. This sets a value per each input dataset (i.\-e., the ith dataset).  
\item {\ttfamily int = obj.\-Get\-Point\-Component (int i)} -\/ If plotting points by value, which component to use to determine the value. This sets a value per each input dataset (i.\-e., the ith dataset).  
\item {\ttfamily obj.\-Set\-X\-Values (int )} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily int = obj.\-Get\-X\-Values\-Min\-Value ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily int = obj.\-Get\-X\-Values\-Max\-Value ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily int = obj.\-Get\-X\-Values ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily obj.\-Set\-X\-Values\-To\-Index ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily obj.\-Set\-X\-Values\-To\-Arc\-Length ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily obj.\-Set\-X\-Values\-To\-Normalized\-Arc\-Length ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily obj.\-Set\-X\-Values\-To\-Value ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily string = obj.\-Get\-X\-Values\-As\-String ()} -\/ Specify how the independent (x) variable is computed from the points. The independent variable can be the scalar/point index (i.\-e., point id), the accumulated arc length along the points, the normalized arc length, or by component value. If plotting datasets (e.\-g., points), the value that is used is specified by the Point\-Component ivar. (Note\-: these methods also control how field data is plotted. Field data is usually plotted by value or index, if plotting length 1-\/dimensional length measures are used.)  
\item {\ttfamily obj.\-Add\-Data\-Object\-Input (vtk\-Data\-Object in)} -\/ Add a dataset to the list of data to append.  
\item {\ttfamily obj.\-Remove\-Data\-Object\-Input (vtk\-Data\-Object in)} -\/ Remove a dataset from the list of data to append.  
\item {\ttfamily vtk\-Data\-Object\-Collection = obj.\-Get\-Data\-Object\-Input\-List ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily obj.\-Set\-Data\-Object\-Plot\-Mode (int )} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-Plot\-Mode\-Min\-Value ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-Plot\-Mode\-Max\-Value ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-Plot\-Mode ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily obj.\-Set\-Data\-Object\-Plot\-Mode\-To\-Rows ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily obj.\-Set\-Data\-Object\-Plot\-Mode\-To\-Columns ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily string = obj.\-Get\-Data\-Object\-Plot\-Mode\-As\-String ()} -\/ Indicate whether to plot rows or columns. If plotting rows, then the dependent variables is taken from a specified row, versus rows (y).  
\item {\ttfamily obj.\-Set\-Data\-Object\-X\-Component (int i, int comp)} -\/ Specify which component of the input data object to use as the independent variable for the ith input data object. (This ivar is ignored if plotting the index.) Note that the value is interpreted differently depending on Data\-Object\-Plot\-Mode. If the mode is Rows, then the value of Data\-Object\-X\-Component is the row number; otherwise it's the column number.  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-X\-Component (int i)} -\/ Specify which component of the input data object to use as the independent variable for the ith input data object. (This ivar is ignored if plotting the index.) Note that the value is interpreted differently depending on Data\-Object\-Plot\-Mode. If the mode is Rows, then the value of Data\-Object\-X\-Component is the row number; otherwise it's the column number.  
\item {\ttfamily obj.\-Set\-Data\-Object\-Y\-Component (int i, int comp)} -\/ Specify which component of the input data object to use as the dependent variable for the ith input data object. (This ivar is ignored if plotting the index.) Note that the value is interpreted differently depending on Data\-Object\-Plot\-Mode. If the mode is Rows, then the value of Data\-Object\-Y\-Component is the row number; otherwise it's the column number.  
\item {\ttfamily int = obj.\-Get\-Data\-Object\-Y\-Component (int i)} -\/ Specify which component of the input data object to use as the dependent variable for the ith input data object. (This ivar is ignored if plotting the index.) Note that the value is interpreted differently depending on Data\-Object\-Plot\-Mode. If the mode is Rows, then the value of Data\-Object\-Y\-Component is the row number; otherwise it's the column number.  
\item {\ttfamily obj.\-Set\-Plot\-Color (int i, double r, double g, double b)}  
\item {\ttfamily obj.\-Set\-Plot\-Color (int i, double color\mbox{[}3\mbox{]})}  
\item {\ttfamily double = obj.\-Get\-Plot\-Color (int i)}  
\item {\ttfamily obj.\-Set\-Plot\-Symbol (int i, vtk\-Poly\-Data input)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Plot\-Symbol (int i)}  
\item {\ttfamily obj.\-Set\-Plot\-Label (int i, string label)}  
\item {\ttfamily string = obj.\-Get\-Plot\-Label (int i)}  
\item {\ttfamily int = obj.\-Get\-Plot\-Curve\-Points ()}  
\item {\ttfamily obj.\-Set\-Plot\-Curve\-Points (int )}  
\item {\ttfamily obj.\-Plot\-Curve\-Points\-On ()}  
\item {\ttfamily obj.\-Plot\-Curve\-Points\-Off ()}  
\item {\ttfamily int = obj.\-Get\-Plot\-Curve\-Lines ()}  
\item {\ttfamily obj.\-Set\-Plot\-Curve\-Lines (int )}  
\item {\ttfamily obj.\-Plot\-Curve\-Lines\-On ()}  
\item {\ttfamily obj.\-Plot\-Curve\-Lines\-Off ()}  
\item {\ttfamily obj.\-Set\-Plot\-Lines (int i, int )}  
\item {\ttfamily int = obj.\-Get\-Plot\-Lines (int i)}  
\item {\ttfamily obj.\-Set\-Plot\-Points (int i, int )}  
\item {\ttfamily int = obj.\-Get\-Plot\-Points (int i)}  
\item {\ttfamily obj.\-Set\-Exchange\-Axes (int )} -\/ Enable/\-Disable exchange of the x-\/y axes (i.\-e., what was x becomes y, and vice-\/versa). Exchanging axes affects the labeling as well.  
\item {\ttfamily int = obj.\-Get\-Exchange\-Axes ()} -\/ Enable/\-Disable exchange of the x-\/y axes (i.\-e., what was x becomes y, and vice-\/versa). Exchanging axes affects the labeling as well.  
\item {\ttfamily obj.\-Exchange\-Axes\-On ()} -\/ Enable/\-Disable exchange of the x-\/y axes (i.\-e., what was x becomes y, and vice-\/versa). Exchanging axes affects the labeling as well.  
\item {\ttfamily obj.\-Exchange\-Axes\-Off ()} -\/ Enable/\-Disable exchange of the x-\/y axes (i.\-e., what was x becomes y, and vice-\/versa). Exchanging axes affects the labeling as well.  
\item {\ttfamily obj.\-Set\-Reverse\-X\-Axis (int )} -\/ Normally the x-\/axis is plotted from minimum to maximum. Setting this instance variable causes the x-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the x-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily int = obj.\-Get\-Reverse\-X\-Axis ()} -\/ Normally the x-\/axis is plotted from minimum to maximum. Setting this instance variable causes the x-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the x-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily obj.\-Reverse\-X\-Axis\-On ()} -\/ Normally the x-\/axis is plotted from minimum to maximum. Setting this instance variable causes the x-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the x-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily obj.\-Reverse\-X\-Axis\-Off ()} -\/ Normally the x-\/axis is plotted from minimum to maximum. Setting this instance variable causes the x-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the x-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily obj.\-Set\-Reverse\-Y\-Axis (int )} -\/ Normally the y-\/axis is plotted from minimum to maximum. Setting this instance variable causes the y-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the y-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily int = obj.\-Get\-Reverse\-Y\-Axis ()} -\/ Normally the y-\/axis is plotted from minimum to maximum. Setting this instance variable causes the y-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the y-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily obj.\-Reverse\-Y\-Axis\-On ()} -\/ Normally the y-\/axis is plotted from minimum to maximum. Setting this instance variable causes the y-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the y-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily obj.\-Reverse\-Y\-Axis\-Off ()} -\/ Normally the y-\/axis is plotted from minimum to maximum. Setting this instance variable causes the y-\/axis to be plotted from maximum to minimum. Note that boolean always applies to the y-\/axis even if Exchange\-Axes is set.  
\item {\ttfamily vtk\-Legend\-Box\-Actor = obj.\-Get\-Legend\-Actor ()} -\/ Retrieve handles to the legend box and glyph source. This is useful if you would like to change the default behavior of the legend box or glyph source. For example, the default glyph can be changed from a line to a vertex plus line, etc.)  
\item {\ttfamily vtk\-Glyph\-Source2\-D = obj.\-Get\-Glyph\-Source ()} -\/ Retrieve handles to the legend box and glyph source. This is useful if you would like to change the default behavior of the legend box or glyph source. For example, the default glyph can be changed from a line to a vertex plus line, etc.)  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily obj.\-Set\-X\-Title (string )} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily string = obj.\-Get\-X\-Title ()} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily obj.\-Set\-Y\-Title (string )} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily string = obj.\-Get\-Y\-Title ()} -\/ Set/\-Get the title of the x-\/y plot, and the title along the x and y axes.  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-X\-Axis\-Actor2\-D ()} -\/ Retrieve handles to the X and Y axis (so that you can set their text properties for example)  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Y\-Axis\-Actor2\-D ()} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily obj.\-Set\-X\-Range (double , double )} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily obj.\-Set\-X\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily double = obj. Get\-X\-Range ()} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily obj.\-Set\-Y\-Range (double , double )} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily obj.\-Set\-Y\-Range (double a\mbox{[}2\mbox{]})} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily double = obj. Get\-Y\-Range ()} -\/ Set the plot range (range of independent and dependent variables) to plot. Data outside of the range will be clipped. If the plot range of either the x or y variables is set to (v1,v2), where v1 == v2, then the range will be computed automatically. Note that the x-\/range values should be consistent with the way the independent variable is created (via I\-N\-D\-E\-X, D\-I\-S\-T\-A\-N\-C\-E, or A\-R\-C\-\_\-\-L\-E\-N\-G\-T\-H).  
\item {\ttfamily obj.\-Set\-Plot\-Range (double xmin, double ymin, double xmax, double ymax)} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily obj.\-Set\-Number\-Of\-X\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-X\-Labels\-Min\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-X\-Labels\-Max\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-X\-Labels ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Y\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Y\-Labels\-Min\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Y\-Labels\-Max\-Value ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Y\-Labels ()} -\/ Set/\-Get the number of annotation labels to show along the x and y axes. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data. The convenience method Set\-Number\-Of\-Lables() sets the number of x and y labels to the same value.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Labels (int num)} -\/ Set/\-Get the flag that controls whether the labels and ticks are adjusted for \char`\"{}nice\char`\"{} numerical values to make it easier to read the labels. The adjustment is based in the Range instance variable. Call Get\-Adjusted\-Range and Get\-Adjusted\-Number\-Of\-Labels to get the adjusted range and number of labels.  
\item {\ttfamily obj.\-Set\-Adjust\-X\-Labels (int adjust)} -\/ Set/\-Get the flag that controls whether the labels and ticks are adjusted for \char`\"{}nice\char`\"{} numerical values to make it easier to read the labels. The adjustment is based in the Range instance variable. Call Get\-Adjusted\-Range and Get\-Adjusted\-Number\-Of\-Labels to get the adjusted range and number of labels.  
\item {\ttfamily int = obj.\-Get\-Adjust\-X\-Labels ()} -\/ Set/\-Get the flag that controls whether the labels and ticks are adjusted for \char`\"{}nice\char`\"{} numerical values to make it easier to read the labels. The adjustment is based in the Range instance variable. Call Get\-Adjusted\-Range and Get\-Adjusted\-Number\-Of\-Labels to get the adjusted range and number of labels.  
\item {\ttfamily obj.\-Set\-Adjust\-Y\-Labels (int adjust)} -\/ Set/\-Get the flag that controls whether the labels and ticks are adjusted for \char`\"{}nice\char`\"{} numerical values to make it easier to read the labels. The adjustment is based in the Range instance variable. Call Get\-Adjusted\-Range and Get\-Adjusted\-Number\-Of\-Labels to get the adjusted range and number of labels.  
\item {\ttfamily int = obj.\-Get\-Adjust\-Y\-Labels ()} -\/ Set/\-Get the flag that controls whether the labels and ticks are adjusted for \char`\"{}nice\char`\"{} numerical values to make it easier to read the labels. The adjustment is based in the Range instance variable. Call Get\-Adjusted\-Range and Get\-Adjusted\-Number\-Of\-Labels to get the adjusted range and number of labels.  
\item {\ttfamily obj.\-Set\-X\-Title\-Position (double position)} -\/ Set/\-Get the position of the title of X or Y axis.  
\item {\ttfamily double = obj.\-Get\-X\-Title\-Position ()} -\/ Set/\-Get the position of the title of X or Y axis.  
\item {\ttfamily obj.\-Set\-Y\-Title\-Position (double position)} -\/ Set/\-Get the position of the title of X or Y axis.  
\item {\ttfamily double = obj.\-Get\-Y\-Title\-Position ()} -\/ Set/\-Get the position of the title of X or Y axis.  
\item {\ttfamily obj.\-Set\-Number\-Of\-X\-Minor\-Ticks (int num)} -\/ Set/\-Get the number of minor ticks in X or Y.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-X\-Minor\-Ticks ()} -\/ Set/\-Get the number of minor ticks in X or Y.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Y\-Minor\-Ticks (int num)} -\/ Set/\-Get the number of minor ticks in X or Y.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Y\-Minor\-Ticks ()} -\/ Set/\-Get the number of minor ticks in X or Y.  
\item {\ttfamily obj.\-Set\-Legend (int )} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily int = obj.\-Get\-Legend ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-On ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Legend\-Off ()} -\/ Enable/\-Disable the creation of a legend. If on, the legend labels will be created automatically unless the per plot legend symbol has been set.  
\item {\ttfamily obj.\-Set\-Title\-Position (double , double )} -\/ Set/\-Get the position of the title. This has no effect if Adjust\-Title\-Position is true.  
\item {\ttfamily obj.\-Set\-Title\-Position (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get the position of the title. This has no effect if Adjust\-Title\-Position is true.  
\item {\ttfamily double = obj. Get\-Title\-Position ()} -\/ Set/\-Get the position of the title. This has no effect if Adjust\-Title\-Position is true.  
\item {\ttfamily obj.\-Set\-Adjust\-Title\-Position (int )} -\/ If true, the xyplot actor will adjust the position of the title automatically to be upper-\/middle. Default is true.  
\item {\ttfamily int = obj.\-Get\-Adjust\-Title\-Position ()} -\/ If true, the xyplot actor will adjust the position of the title automatically to be upper-\/middle. Default is true.  
\item {\ttfamily obj.\-Adjust\-Title\-Position\-On ()} -\/ If true, the xyplot actor will adjust the position of the title automatically to be upper-\/middle. Default is true.  
\item {\ttfamily obj.\-Adjust\-Title\-Position\-Off ()} -\/ If true, the xyplot actor will adjust the position of the title automatically to be upper-\/middle. Default is true.  
\item {\ttfamily obj.\-Set\-Adjust\-Title\-Position\-Mode (int )} -\/ If Adjust\-Title\-Position is truem, the xyplot actor will adjust the position of the title automatically depending on the given mode, the mode is a combination of the Alignment flags. by default\-: vtk\-X\-Y\-Plot\-Actor\-::\-Align\-H\-Center $|$ vtk\-X\-Y\-Plot\-Actor\-::\-Top $|$ vtk\-X\-Y\-Plot\-Actor\-::\-Align\-Axis\-V\-Center  
\item {\ttfamily int = obj.\-Get\-Adjust\-Title\-Position\-Mode ()} -\/ If Adjust\-Title\-Position is truem, the xyplot actor will adjust the position of the title automatically depending on the given mode, the mode is a combination of the Alignment flags. by default\-: vtk\-X\-Y\-Plot\-Actor\-::\-Align\-H\-Center $|$ vtk\-X\-Y\-Plot\-Actor\-::\-Top $|$ vtk\-X\-Y\-Plot\-Actor\-::\-Align\-Axis\-V\-Center  
\item {\ttfamily obj.\-Set\-Legend\-Position (double , double )} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily obj.\-Set\-Legend\-Position (double a\mbox{[}2\mbox{]})} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily double = obj. Get\-Legend\-Position ()} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily obj.\-Set\-Legend\-Position2 (double , double )} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily obj.\-Set\-Legend\-Position2 (double a\mbox{[}2\mbox{]})} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily double = obj. Get\-Legend\-Position2 ()} -\/ Use these methods to control the position of the legend. The variables Legend\-Position and Legend\-Position2 define the lower-\/left and upper-\/right position of the legend. The coordinates are expressed as normalized values with respect to the rectangle defined by Position\-Coordinate and Position2\-Coordinate. Note that Legend\-Position2 is relative to Legend\-Position.  
\item {\ttfamily obj.\-Set\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property.  
\item {\ttfamily obj.\-Set\-Axis\-Title\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the title text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y\-Axis\-Actor2\-D() methods.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Axis\-Title\-Text\-Property ()} -\/ Set/\-Get the title text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y\-Axis\-Actor2\-D() methods.  
\item {\ttfamily obj.\-Set\-Axis\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y\-Axis\-Actor2\-D() methods.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Axis\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property of all axes. Note that each axis can be controlled individually through the Get\-X/\-Y\-Axis\-Actor2\-D() methods.  
\item {\ttfamily obj.\-Set\-Logx (int )} -\/ Enable/\-Disable plotting of Log of x-\/values.  
\item {\ttfamily int = obj.\-Get\-Logx ()} -\/ Enable/\-Disable plotting of Log of x-\/values.  
\item {\ttfamily obj.\-Logx\-On ()} -\/ Enable/\-Disable plotting of Log of x-\/values.  
\item {\ttfamily obj.\-Logx\-Off ()} -\/ Enable/\-Disable plotting of Log of x-\/values.  
\item {\ttfamily obj.\-Set\-Label\-Format (string \-\_\-arg)} -\/ Set/\-Get the format with which to print the labels . This sets both X and Y label formats. Get\-Label\-Format() returns X label format.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the X label.  
\item {\ttfamily obj.\-Set\-X\-Label\-Format (string \-\_\-arg)} -\/ Set/\-Get the format with which to print the X label.  
\item {\ttfamily string = obj.\-Get\-X\-Label\-Format ()} -\/ Set/\-Get the format with which to print the X label.  
\item {\ttfamily obj.\-Set\-Y\-Label\-Format (string \-\_\-arg)} -\/ Set/\-Get the format with which to print the Y label.  
\item {\ttfamily string = obj.\-Get\-Y\-Label\-Format ()} -\/ Set/\-Get the format with which to print the Y label.  
\item {\ttfamily obj.\-Set\-Border (int )} -\/ Set/\-Get the spacing between the plot window and the plot. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Border\-Min\-Value ()} -\/ Set/\-Get the spacing between the plot window and the plot. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Border\-Max\-Value ()} -\/ Set/\-Get the spacing between the plot window and the plot. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Border ()} -\/ Set/\-Get the spacing between the plot window and the plot. The value is specified in pixels.  
\item {\ttfamily int = obj.\-Get\-Plot\-Points ()} -\/ Set/\-Get whether the points are rendered. The point size can be set in the property object. This is a global flag which affects the plot only if per curve symbols are not defined.  
\item {\ttfamily obj.\-Set\-Plot\-Points (int )} -\/ Set/\-Get whether the points are rendered. The point size can be set in the property object. This is a global flag which affects the plot only if per curve symbols are not defined.  
\item {\ttfamily obj.\-Plot\-Points\-On ()} -\/ Set/\-Get whether the points are rendered. The point size can be set in the property object. This is a global flag which affects the plot only if per curve symbols are not defined.  
\item {\ttfamily obj.\-Plot\-Points\-Off ()} -\/ Set/\-Get whether the points are rendered. The point size can be set in the property object. This is a global flag which affects the plot only if per curve symbols are not defined.  
\item {\ttfamily int = obj.\-Get\-Plot\-Lines ()} -\/ Set/\-Get whether the lines are rendered. The line width can be set in the property object.  
\item {\ttfamily obj.\-Set\-Plot\-Lines (int )} -\/ Set/\-Get whether the lines are rendered. The line width can be set in the property object.  
\item {\ttfamily obj.\-Plot\-Lines\-On ()} -\/ Set/\-Get whether the lines are rendered. The line width can be set in the property object.  
\item {\ttfamily obj.\-Plot\-Lines\-Off ()} -\/ Set/\-Get whether the lines are rendered. The line width can be set in the property object.  
\item {\ttfamily obj.\-Set\-Glyph\-Size (double )} -\/ Set/\-Get the factor that controls how big glyphs are in the plot. The number is expressed as a fraction of the length of the diagonal of the plot bounding box.  
\item {\ttfamily double = obj.\-Get\-Glyph\-Size\-Min\-Value ()} -\/ Set/\-Get the factor that controls how big glyphs are in the plot. The number is expressed as a fraction of the length of the diagonal of the plot bounding box.  
\item {\ttfamily double = obj.\-Get\-Glyph\-Size\-Max\-Value ()} -\/ Set/\-Get the factor that controls how big glyphs are in the plot. The number is expressed as a fraction of the length of the diagonal of the plot bounding box.  
\item {\ttfamily double = obj.\-Get\-Glyph\-Size ()} -\/ Set/\-Get the factor that controls how big glyphs are in the plot. The number is expressed as a fraction of the length of the diagonal of the plot bounding box.  
\item {\ttfamily obj.\-Viewport\-To\-Plot\-Coordinate (vtk\-Viewport viewport)} -\/ An alternate form of Viewport\-To\-Plot\-Coordinate() above. This method inputs the viewport coordinate pair (defined by the ivar Viewport\-Coordinate)and then stores them in the ivar Plot\-Coordinate.  
\item {\ttfamily obj.\-Set\-Plot\-Coordinate (double , double )} -\/ An alternate form of Viewport\-To\-Plot\-Coordinate() above. This method inputs the viewport coordinate pair (defined by the ivar Viewport\-Coordinate)and then stores them in the ivar Plot\-Coordinate.  
\item {\ttfamily obj.\-Set\-Plot\-Coordinate (double a\mbox{[}2\mbox{]})} -\/ An alternate form of Viewport\-To\-Plot\-Coordinate() above. This method inputs the viewport coordinate pair (defined by the ivar Viewport\-Coordinate)and then stores them in the ivar Plot\-Coordinate.  
\item {\ttfamily double = obj. Get\-Plot\-Coordinate ()} -\/ An alternate form of Viewport\-To\-Plot\-Coordinate() above. This method inputs the viewport coordinate pair (defined by the ivar Viewport\-Coordinate)and then stores them in the ivar Plot\-Coordinate.  
\item {\ttfamily obj.\-Plot\-To\-Viewport\-Coordinate (vtk\-Viewport viewport)} -\/ An alternate form of Plot\-To\-Viewport\-Coordinate() above. This method inputs the plot coordinate pair (defined in the ivar Plot\-Coordinate) and then stores them in the ivar Viewport\-Coordinate. (This method can be wrapped.)  
\item {\ttfamily obj.\-Set\-Viewport\-Coordinate (double , double )} -\/ An alternate form of Plot\-To\-Viewport\-Coordinate() above. This method inputs the plot coordinate pair (defined in the ivar Plot\-Coordinate) and then stores them in the ivar Viewport\-Coordinate. (This method can be wrapped.)  
\item {\ttfamily obj.\-Set\-Viewport\-Coordinate (double a\mbox{[}2\mbox{]})} -\/ An alternate form of Plot\-To\-Viewport\-Coordinate() above. This method inputs the plot coordinate pair (defined in the ivar Plot\-Coordinate) and then stores them in the ivar Viewport\-Coordinate. (This method can be wrapped.)  
\item {\ttfamily double = obj. Get\-Viewport\-Coordinate ()} -\/ An alternate form of Plot\-To\-Viewport\-Coordinate() above. This method inputs the plot coordinate pair (defined in the ivar Plot\-Coordinate) and then stores them in the ivar Viewport\-Coordinate. (This method can be wrapped.)  
\item {\ttfamily int = obj.\-Is\-In\-Plot (vtk\-Viewport viewport, double u, double v)} -\/ Is the specified viewport position within the plot area (as opposed to the region used by the plot plus the labels)?  
\item {\ttfamily obj.\-Set\-Chart\-Box (int )} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the chart box.  
\item {\ttfamily int = obj.\-Get\-Chart\-Box ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the chart box.  
\item {\ttfamily obj.\-Chart\-Box\-On ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the chart box.  
\item {\ttfamily obj.\-Chart\-Box\-Off ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the chart box.  
\item {\ttfamily obj.\-Set\-Chart\-Border (int )} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily int = obj.\-Get\-Chart\-Border ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily obj.\-Chart\-Border\-On ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily obj.\-Chart\-Border\-Off ()} -\/ Set/\-Get the flag that controls whether a box will be drawn/filled corresponding to the legend box.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Chart\-Box\-Property ()} -\/ Get the box vtk\-Property2\-D.  
\item {\ttfamily obj.\-Set\-Show\-Reference\-X\-Line (int )} -\/ Set/\-Get if the X reference line is visible. hidden by default  
\item {\ttfamily int = obj.\-Get\-Show\-Reference\-X\-Line ()} -\/ Set/\-Get if the X reference line is visible. hidden by default  
\item {\ttfamily obj.\-Show\-Reference\-X\-Line\-On ()} -\/ Set/\-Get if the X reference line is visible. hidden by default  
\item {\ttfamily obj.\-Show\-Reference\-X\-Line\-Off ()} -\/ Set/\-Get if the X reference line is visible. hidden by default  
\item {\ttfamily obj.\-Set\-Reference\-X\-Value (double )}  
\item {\ttfamily double = obj.\-Get\-Reference\-X\-Value ()}  
\item {\ttfamily obj.\-Set\-Show\-Reference\-Y\-Line (int )} -\/ Set/\-Get if the Y reference line is visible. hidden by default  
\item {\ttfamily int = obj.\-Get\-Show\-Reference\-Y\-Line ()} -\/ Set/\-Get if the Y reference line is visible. hidden by default  
\item {\ttfamily obj.\-Show\-Reference\-Y\-Line\-On ()} -\/ Set/\-Get if the Y reference line is visible. hidden by default  
\item {\ttfamily obj.\-Show\-Reference\-Y\-Line\-Off ()} -\/ Set/\-Get if the Y reference line is visible. hidden by default  
\item {\ttfamily obj.\-Set\-Reference\-Y\-Value (double )}  
\item {\ttfamily double = obj.\-Get\-Reference\-Y\-Value ()}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Take into account the modified time of internal helper classes.  
\end{DoxyItemize}