
\begin{DoxyItemize}
\item \hyperlink{vtkrendering_vtkabstractmapper3d}{vtk\-Abstract\-Mapper3\-D}  
\item \hyperlink{vtkrendering_vtkabstractpicker}{vtk\-Abstract\-Picker}  
\item \hyperlink{vtkrendering_vtkabstractproppicker}{vtk\-Abstract\-Prop\-Picker}  
\item \hyperlink{vtkrendering_vtkabstractvolumemapper}{vtk\-Abstract\-Volume\-Mapper}  
\item \hyperlink{vtkrendering_vtkactor}{vtk\-Actor}  
\item \hyperlink{vtkrendering_vtkactorcollection}{vtk\-Actor\-Collection}  
\item \hyperlink{vtkrendering_vtkareapicker}{vtk\-Area\-Picker}  
\item \hyperlink{vtkrendering_vtkassembly}{vtk\-Assembly}  
\item \hyperlink{vtkrendering_vtkaxisactor2d}{vtk\-Axis\-Actor2\-D}  
\item \hyperlink{vtkrendering_vtkcamera}{vtk\-Camera}  
\item \hyperlink{vtkrendering_vtkcameraactor}{vtk\-Camera\-Actor}  
\item \hyperlink{vtkrendering_vtkcamerainterpolator}{vtk\-Camera\-Interpolator}  
\item \hyperlink{vtkrendering_vtkcamerapass}{vtk\-Camera\-Pass}  
\item \hyperlink{vtkrendering_vtkcellcenterdepthsort}{vtk\-Cell\-Center\-Depth\-Sort}  
\item \hyperlink{vtkrendering_vtkcellpicker}{vtk\-Cell\-Picker}  
\item \hyperlink{vtkrendering_vtkchooserpainter}{vtk\-Chooser\-Painter}  
\item \hyperlink{vtkrendering_vtkclearzpass}{vtk\-Clear\-Z\-Pass}  
\item \hyperlink{vtkrendering_vtkcoincidenttopologyresolutionpainter}{vtk\-Coincident\-Topology\-Resolution\-Painter}  
\item \hyperlink{vtkrendering_vtkcolormaterialhelper}{vtk\-Color\-Material\-Helper}  
\item \hyperlink{vtkrendering_vtkcompositepainter}{vtk\-Composite\-Painter}  
\item \hyperlink{vtkrendering_vtkcompositepolydatamapper}{vtk\-Composite\-Poly\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtkcompositepolydatamapper2}{vtk\-Composite\-Poly\-Data\-Mapper2}  
\item \hyperlink{vtkrendering_vtkculler}{vtk\-Culler}  
\item \hyperlink{vtkrendering_vtkcullercollection}{vtk\-Culler\-Collection}  
\item \hyperlink{vtkrendering_vtkdatasetmapper}{vtk\-Data\-Set\-Mapper}  
\item \hyperlink{vtkrendering_vtkdatatransferhelper}{vtk\-Data\-Transfer\-Helper}  
\item \hyperlink{vtkrendering_vtkdefaultpainter}{vtk\-Default\-Painter}  
\item \hyperlink{vtkrendering_vtkdefaultpass}{vtk\-Default\-Pass}  
\item \hyperlink{vtkrendering_vtkdepthpeelingpass}{vtk\-Depth\-Peeling\-Pass}  
\item \hyperlink{vtkrendering_vtkdistancetocamera}{vtk\-Distance\-To\-Camera}  
\item \hyperlink{vtkrendering_vtkdummygpuinfolist}{vtk\-Dummy\-G\-P\-U\-Info\-List}  
\item \hyperlink{vtkrendering_vtkdynamic2dlabelmapper}{vtk\-Dynamic2\-D\-Label\-Mapper}  
\item \hyperlink{vtkrendering_vtkexporter}{vtk\-Exporter}  
\item \hyperlink{vtkrendering_vtkfollower}{vtk\-Follower}  
\item \hyperlink{vtkrendering_vtkframebufferobject}{vtk\-Frame\-Buffer\-Object}  
\item \hyperlink{vtkrendering_vtkfreetypelabelrenderstrategy}{vtk\-Free\-Type\-Label\-Render\-Strategy}  
\item \hyperlink{vtkrendering_vtkfrustumcoverageculler}{vtk\-Frustum\-Coverage\-Culler}  
\item \hyperlink{vtkrendering_vtkgaussianblurpass}{vtk\-Gaussian\-Blur\-Pass}  
\item \hyperlink{vtkrendering_vtkgenericrenderwindowinteractor}{vtk\-Generic\-Render\-Window\-Interactor}  
\item \hyperlink{vtkrendering_vtkgenericvertexattributemapping}{vtk\-Generic\-Vertex\-Attribute\-Mapping}  
\item \hyperlink{vtkrendering_vtkgl2psexporter}{vtk\-G\-L2\-P\-S\-Exporter}  
\item \hyperlink{vtkrendering_vtkglslshader}{vtk\-G\-L\-S\-L\-Shader}  
\item \hyperlink{vtkrendering_vtkglslshaderdeviceadapter}{vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter}  
\item \hyperlink{vtkrendering_vtkglslshaderdeviceadapter2}{vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2}  
\item \hyperlink{vtkrendering_vtkglslshaderprogram}{vtk\-G\-L\-S\-L\-Shader\-Program}  
\item \hyperlink{vtkrendering_vtkgpuinfo}{vtk\-G\-P\-U\-Info}  
\item \hyperlink{vtkrendering_vtkgpuinfolist}{vtk\-G\-P\-U\-Info\-List}  
\item \hyperlink{vtkrendering_vtkgraphicsfactory}{vtk\-Graphics\-Factory}  
\item \hyperlink{vtkrendering_vtkgraphmapper}{vtk\-Graph\-Mapper}  
\item \hyperlink{vtkrendering_vtkgraphtoglyphs}{vtk\-Graph\-To\-Glyphs}  
\item \hyperlink{vtkrendering_vtkhardwareselectionpolydatapainter}{vtk\-Hardware\-Selection\-Poly\-Data\-Painter}  
\item \hyperlink{vtkrendering_vtkhardwareselector}{vtk\-Hardware\-Selector}  
\item \hyperlink{vtkrendering_vtkhierarchicalpolydatamapper}{vtk\-Hierarchical\-Poly\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtkidentcoloredpainter}{vtk\-Ident\-Colored\-Painter}  
\item \hyperlink{vtkrendering_vtkimageactor}{vtk\-Image\-Actor}  
\item \hyperlink{vtkrendering_vtkimagemapper}{vtk\-Image\-Mapper}  
\item \hyperlink{vtkrendering_vtkimageprocessingpass}{vtk\-Image\-Processing\-Pass}  
\item \hyperlink{vtkrendering_vtkimageviewer}{vtk\-Image\-Viewer}  
\item \hyperlink{vtkrendering_vtkimageviewer2}{vtk\-Image\-Viewer2}  
\item \hyperlink{vtkrendering_vtkimagingfactory}{vtk\-Imaging\-Factory}  
\item \hyperlink{vtkrendering_vtkimporter}{vtk\-Importer}  
\item \hyperlink{vtkrendering_vtkinteractoreventrecorder}{vtk\-Interactor\-Event\-Recorder}  
\item \hyperlink{vtkrendering_vtkinteractorobserver}{vtk\-Interactor\-Observer}  
\item \hyperlink{vtkrendering_vtkinteractorstyle}{vtk\-Interactor\-Style}  
\item \hyperlink{vtkrendering_vtkinteractorstyleflight}{vtk\-Interactor\-Style\-Flight}  
\item \hyperlink{vtkrendering_vtkinteractorstyleimage}{vtk\-Interactor\-Style\-Image}  
\item \hyperlink{vtkrendering_vtkinteractorstylejoystickactor}{vtk\-Interactor\-Style\-Joystick\-Actor}  
\item \hyperlink{vtkrendering_vtkinteractorstylejoystickcamera}{vtk\-Interactor\-Style\-Joystick\-Camera}  
\item \hyperlink{vtkrendering_vtkinteractorstylerubberband2d}{vtk\-Interactor\-Style\-Rubber\-Band2\-D}  
\item \hyperlink{vtkrendering_vtkinteractorstylerubberband3d}{vtk\-Interactor\-Style\-Rubber\-Band3\-D}  
\item \hyperlink{vtkrendering_vtkinteractorstylerubberbandpick}{vtk\-Interactor\-Style\-Rubber\-Band\-Pick}  
\item \hyperlink{vtkrendering_vtkinteractorstylerubberbandzoom}{vtk\-Interactor\-Style\-Rubber\-Band\-Zoom}  
\item \hyperlink{vtkrendering_vtkinteractorstyleswitch}{vtk\-Interactor\-Style\-Switch}  
\item \hyperlink{vtkrendering_vtkinteractorstyleterrain}{vtk\-Interactor\-Style\-Terrain}  
\item \hyperlink{vtkrendering_vtkinteractorstyletrackball}{vtk\-Interactor\-Style\-Trackball}  
\item \hyperlink{vtkrendering_vtkinteractorstyletrackballactor}{vtk\-Interactor\-Style\-Trackball\-Actor}  
\item \hyperlink{vtkrendering_vtkinteractorstyletrackballcamera}{vtk\-Interactor\-Style\-Trackball\-Camera}  
\item \hyperlink{vtkrendering_vtkinteractorstyleunicam}{vtk\-Interactor\-Style\-Unicam}  
\item \hyperlink{vtkrendering_vtkinteractorstyleuser}{vtk\-Interactor\-Style\-User}  
\item \hyperlink{vtkrendering_vtkivexporter}{vtk\-I\-V\-Exporter}  
\item \hyperlink{vtkrendering_vtklabeleddatamapper}{vtk\-Labeled\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtklabeledtreemapdatamapper}{vtk\-Labeled\-Tree\-Map\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtklabelhierarchy}{vtk\-Label\-Hierarchy}  
\item \hyperlink{vtkrendering_vtklabelhierarchyalgorithm}{vtk\-Label\-Hierarchy\-Algorithm}  
\item \hyperlink{vtkrendering_vtklabelhierarchycompositeiterator}{vtk\-Label\-Hierarchy\-Composite\-Iterator}  
\item \hyperlink{vtkrendering_vtklabelhierarchyiterator}{vtk\-Label\-Hierarchy\-Iterator}  
\item \hyperlink{vtkrendering_vtklabelplacementmapper}{vtk\-Label\-Placement\-Mapper}  
\item \hyperlink{vtkrendering_vtklabelplacer}{vtk\-Label\-Placer}  
\item \hyperlink{vtkrendering_vtklabelrenderstrategy}{vtk\-Label\-Render\-Strategy}  
\item \hyperlink{vtkrendering_vtklabelsizecalculator}{vtk\-Label\-Size\-Calculator}  
\item \hyperlink{vtkrendering_vtkleaderactor2d}{vtk\-Leader\-Actor2\-D}  
\item \hyperlink{vtkrendering_vtklight}{vtk\-Light}  
\item \hyperlink{vtkrendering_vtklightactor}{vtk\-Light\-Actor}  
\item \hyperlink{vtkrendering_vtklightcollection}{vtk\-Light\-Collection}  
\item \hyperlink{vtkrendering_vtklightkit}{vtk\-Light\-Kit}  
\item \hyperlink{vtkrendering_vtklightspass}{vtk\-Lights\-Pass}  
\item \hyperlink{vtkrendering_vtklineintegralconvolution2d}{vtk\-Line\-Integral\-Convolution2\-D}  
\item \hyperlink{vtkrendering_vtklinespainter}{vtk\-Lines\-Painter}  
\item \hyperlink{vtkrendering_vtklodactor}{vtk\-L\-O\-D\-Actor}  
\item \hyperlink{vtkrendering_vtklodprop3d}{vtk\-L\-O\-D\-Prop3\-D}  
\item \hyperlink{vtkrendering_vtkmaparrayvalues}{vtk\-Map\-Array\-Values}  
\item \hyperlink{vtkrendering_vtkmapper}{vtk\-Mapper}  
\item \hyperlink{vtkrendering_vtkmappercollection}{vtk\-Mapper\-Collection}  
\item \hyperlink{vtkrendering_vtkobjexporter}{vtk\-O\-B\-J\-Exporter}  
\item \hyperlink{vtkrendering_vtkobservermediator}{vtk\-Observer\-Mediator}  
\item \hyperlink{vtkrendering_vtkooglexporter}{vtk\-O\-O\-G\-L\-Exporter}  
\item \hyperlink{vtkrendering_vtkopaquepass}{vtk\-Opaque\-Pass}  
\item \hyperlink{vtkrendering_vtkopenglactor}{vtk\-Open\-G\-L\-Actor}  
\item \hyperlink{vtkrendering_vtkopenglcamera}{vtk\-Open\-G\-L\-Camera}  
\item \hyperlink{vtkrendering_vtkopenglclipplanespainter}{vtk\-Open\-G\-L\-Clip\-Planes\-Painter}  
\item \hyperlink{vtkrendering_vtkopenglcoincidenttopologyresolutionpainter}{vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter}  
\item \hyperlink{vtkrendering_vtkopengldisplaylistpainter}{vtk\-Open\-G\-L\-Display\-List\-Painter}  
\item \hyperlink{vtkrendering_vtkopenglextensionmanager}{vtk\-Open\-G\-L\-Extension\-Manager}  
\item \hyperlink{vtkrendering_vtkopenglfreetypetextmapper}{vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper}  
\item \hyperlink{vtkrendering_vtkopenglhardwaresupport}{vtk\-Open\-G\-L\-Hardware\-Support}  
\item \hyperlink{vtkrendering_vtkopenglimageactor}{vtk\-Open\-G\-L\-Image\-Actor}  
\item \hyperlink{vtkrendering_vtkopenglimagemapper}{vtk\-Open\-G\-L\-Image\-Mapper}  
\item \hyperlink{vtkrendering_vtkopengllight}{vtk\-Open\-G\-L\-Light}  
\item \hyperlink{vtkrendering_vtkopengllightingpainter}{vtk\-Open\-G\-L\-Lighting\-Painter}  
\item \hyperlink{vtkrendering_vtkopenglpainterdeviceadapter}{vtk\-Open\-G\-L\-Painter\-Device\-Adapter}  
\item \hyperlink{vtkrendering_vtkopenglpolydatamapper}{vtk\-Open\-G\-L\-Poly\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtkopenglpolydatamapper2d}{vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D}  
\item \hyperlink{vtkrendering_vtkopenglproperty}{vtk\-Open\-G\-L\-Property}  
\item \hyperlink{vtkrendering_vtkopenglrenderer}{vtk\-Open\-G\-L\-Renderer}  
\item \hyperlink{vtkrendering_vtkopenglrenderwindow}{vtk\-Open\-G\-L\-Render\-Window}  
\item \hyperlink{vtkrendering_vtkopenglrepresentationpainter}{vtk\-Open\-G\-L\-Representation\-Painter}  
\item \hyperlink{vtkrendering_vtkopenglscalarstocolorspainter}{vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter}  
\item \hyperlink{vtkrendering_vtkopengltexture}{vtk\-Open\-G\-L\-Texture}  
\item \hyperlink{vtkrendering_vtkoverlaypass}{vtk\-Overlay\-Pass}  
\item \hyperlink{vtkrendering_vtkpainter}{vtk\-Painter}  
\item \hyperlink{vtkrendering_vtkpainterdeviceadapter}{vtk\-Painter\-Device\-Adapter}  
\item \hyperlink{vtkrendering_vtkpainterpolydatamapper}{vtk\-Painter\-Poly\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtkparallelcoordinatesactor}{vtk\-Parallel\-Coordinates\-Actor}  
\item \hyperlink{vtkrendering_vtkparallelcoordinatesinteractorstyle}{vtk\-Parallel\-Coordinates\-Interactor\-Style}  
\item \hyperlink{vtkrendering_vtkpicker}{vtk\-Picker}  
\item \hyperlink{vtkrendering_vtkpixelbufferobject}{vtk\-Pixel\-Buffer\-Object}  
\item \hyperlink{vtkrendering_vtkpointpicker}{vtk\-Point\-Picker}  
\item \hyperlink{vtkrendering_vtkpointsettolabelhierarchy}{vtk\-Point\-Set\-To\-Label\-Hierarchy}  
\item \hyperlink{vtkrendering_vtkpointspainter}{vtk\-Points\-Painter}  
\item \hyperlink{vtkrendering_vtkpolydatamapper}{vtk\-Poly\-Data\-Mapper}  
\item \hyperlink{vtkrendering_vtkpolydatamapper2d}{vtk\-Poly\-Data\-Mapper2\-D}  
\item \hyperlink{vtkrendering_vtkpolydatapainter}{vtk\-Poly\-Data\-Painter}  
\item \hyperlink{vtkrendering_vtkpolygonspainter}{vtk\-Polygons\-Painter}  
\item \hyperlink{vtkrendering_vtkpovexporter}{vtk\-P\-O\-V\-Exporter}  
\item \hyperlink{vtkrendering_vtkprimitivepainter}{vtk\-Primitive\-Painter}  
\item \hyperlink{vtkrendering_vtkprop3d}{vtk\-Prop3\-D}  
\item \hyperlink{vtkrendering_vtkprop3dcollection}{vtk\-Prop3\-D\-Collection}  
\item \hyperlink{vtkrendering_vtkproperty}{vtk\-Property}  
\item \hyperlink{vtkrendering_vtkproppicker}{vtk\-Prop\-Picker}  
\item \hyperlink{vtkrendering_vtkqimagetoimagesource}{vtk\-Q\-Image\-To\-Image\-Source}  
\item \hyperlink{vtkrendering_vtkqtinitialization}{vtk\-Qt\-Initialization}  
\item \hyperlink{vtkrendering_vtkqtlabelrenderstrategy}{vtk\-Qt\-Label\-Render\-Strategy}  
\item \hyperlink{vtkrendering_vtkqttreeringlabelmapper}{vtk\-Qt\-Tree\-Ring\-Label\-Mapper}  
\item \hyperlink{vtkrendering_vtkquadriclodactor}{vtk\-Quadric\-L\-O\-D\-Actor}  
\item \hyperlink{vtkrendering_vtkquaternioninterpolator}{vtk\-Quaternion\-Interpolator}  
\item \hyperlink{vtkrendering_vtkrenderedareapicker}{vtk\-Rendered\-Area\-Picker}  
\item \hyperlink{vtkrendering_vtkrenderer}{vtk\-Renderer}  
\item \hyperlink{vtkrendering_vtkrenderercollection}{vtk\-Renderer\-Collection}  
\item \hyperlink{vtkrendering_vtkrendererdelegate}{vtk\-Renderer\-Delegate}  
\item \hyperlink{vtkrendering_vtkrenderersource}{vtk\-Renderer\-Source}  
\item \hyperlink{vtkrendering_vtkrenderpass}{vtk\-Render\-Pass}  
\item \hyperlink{vtkrendering_vtkrenderpasscollection}{vtk\-Render\-Pass\-Collection}  
\item \hyperlink{vtkrendering_vtkrenderwindow}{vtk\-Render\-Window}  
\item \hyperlink{vtkrendering_vtkrenderwindowcollection}{vtk\-Render\-Window\-Collection}  
\item \hyperlink{vtkrendering_vtkrenderwindowinteractor}{vtk\-Render\-Window\-Interactor}  
\item \hyperlink{vtkrendering_vtkrepresentationpainter}{vtk\-Representation\-Painter}  
\item \hyperlink{vtkrendering_vtkscalarbaractor}{vtk\-Scalar\-Bar\-Actor}  
\item \hyperlink{vtkrendering_vtkscalarstocolorspainter}{vtk\-Scalars\-To\-Colors\-Painter}  
\item \hyperlink{vtkrendering_vtkscaledtextactor}{vtk\-Scaled\-Text\-Actor}  
\item \hyperlink{vtkrendering_vtkscenepicker}{vtk\-Scene\-Picker}  
\item \hyperlink{vtkrendering_vtkselectvisiblepoints}{vtk\-Select\-Visible\-Points}  
\item \hyperlink{vtkrendering_vtksequencepass}{vtk\-Sequence\-Pass}  
\item \hyperlink{vtkrendering_vtkshader}{vtk\-Shader}  
\item \hyperlink{vtkrendering_vtkshaderprogram}{vtk\-Shader\-Program}  
\item \hyperlink{vtkrendering_vtkshadowmappass}{vtk\-Shadow\-Map\-Pass}  
\item \hyperlink{vtkrendering_vtksobelgradientmagnitudepass}{vtk\-Sobel\-Gradient\-Magnitude\-Pass}  
\item \hyperlink{vtkrendering_vtkstandardpolydatapainter}{vtk\-Standard\-Poly\-Data\-Painter}  
\item \hyperlink{vtkrendering_vtksurfacelicdefaultpainter}{vtk\-Surface\-L\-I\-C\-Default\-Painter}  
\item \hyperlink{vtkrendering_vtksurfacelicpainter}{vtk\-Surface\-L\-I\-C\-Painter}  
\item \hyperlink{vtkrendering_vtktdxinteractorstyle}{vtk\-T\-Dx\-Interactor\-Style}  
\item \hyperlink{vtkrendering_vtktdxinteractorstylecamera}{vtk\-T\-Dx\-Interactor\-Style\-Camera}  
\item \hyperlink{vtkrendering_vtktdxinteractorstylesettings}{vtk\-T\-Dx\-Interactor\-Style\-Settings}  
\item \hyperlink{vtkrendering_vtktesting}{vtk\-Testing}  
\item \hyperlink{vtkrendering_vtktextactor}{vtk\-Text\-Actor}  
\item \hyperlink{vtkrendering_vtktextactor3d}{vtk\-Text\-Actor3\-D}  
\item \hyperlink{vtkrendering_vtktextmapper}{vtk\-Text\-Mapper}  
\item \hyperlink{vtkrendering_vtktextproperty}{vtk\-Text\-Property}  
\item \hyperlink{vtkrendering_vtktexture}{vtk\-Texture}  
\item \hyperlink{vtkrendering_vtktexturedactor2d}{vtk\-Textured\-Actor2\-D}  
\item \hyperlink{vtkrendering_vtktextureobject}{vtk\-Texture\-Object}  
\item \hyperlink{vtkrendering_vtktransforminterpolator}{vtk\-Transform\-Interpolator}  
\item \hyperlink{vtkrendering_vtktranslucentpass}{vtk\-Translucent\-Pass}  
\item \hyperlink{vtkrendering_vtktupleinterpolator}{vtk\-Tuple\-Interpolator}  
\item \hyperlink{vtkrendering_vtkuniformvariables}{vtk\-Uniform\-Variables}  
\item \hyperlink{vtkrendering_vtkviewtheme}{vtk\-View\-Theme}  
\item \hyperlink{vtkrendering_vtkvisibilitysort}{vtk\-Visibility\-Sort}  
\item \hyperlink{vtkrendering_vtkvisiblecellselector}{vtk\-Visible\-Cell\-Selector}  
\item \hyperlink{vtkrendering_vtkvolume}{vtk\-Volume}  
\item \hyperlink{vtkrendering_vtkvolumecollection}{vtk\-Volume\-Collection}  
\item \hyperlink{vtkrendering_vtkvolumeproperty}{vtk\-Volume\-Property}  
\item \hyperlink{vtkrendering_vtkvolumetricpass}{vtk\-Volumetric\-Pass}  
\item \hyperlink{vtkrendering_vtkvrmlexporter}{vtk\-V\-R\-M\-L\-Exporter}  
\item \hyperlink{vtkrendering_vtkwindowtoimagefilter}{vtk\-Window\-To\-Image\-Filter}  
\item \hyperlink{vtkrendering_vtkworldpointpicker}{vtk\-World\-Point\-Picker}  
\item \hyperlink{vtkrendering_vtkxgpuinfolist}{vtk\-X\-G\-P\-U\-Info\-List}  
\item \hyperlink{vtkrendering_vtkxopenglrenderwindow}{vtk\-X\-Open\-G\-L\-Render\-Window}  
\item \hyperlink{vtkrendering_vtkxrenderwindowinteractor}{vtk\-X\-Render\-Window\-Interactor}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkabstractmapper3d}{}\section{vtk\-Abstract\-Mapper3\-D}\label{vtkrendering_vtkabstractmapper3d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Mapper3\-D is an abstract class to specify interface between 3\-D data and graphics primitives or software rendering techniques. Subclasses of vtk\-Abstract\-Mapper3\-D can be used for rendering geometry or rendering volumetric data.

This class also defines an A\-P\-I to support hardware clipping planes (at most six planes can be defined). It also provides geometric data about the input data it maps, such as the bounding box and center.

To create an instance of class vtk\-Abstract\-Mapper3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractMapper3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Mapper3\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Mapper3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Mapper3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Mapper3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax). Update this-\/$>$Bounds as a side effect.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds for this mapper as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Return the Center of this mapper's data.  
\item {\ttfamily obj.\-Get\-Center (double center\mbox{[}3\mbox{]})} -\/ Return the diagonal length of this mappers bounding box.  
\item {\ttfamily double = obj.\-Get\-Length ()} -\/ Return the diagonal length of this mappers bounding box.  
\item {\ttfamily int = obj.\-Is\-A\-Ray\-Cast\-Mapper ()} -\/ Is this a \char`\"{}render into image\char`\"{} mapper? A subclass would return 1 if the mapper produces an image by rendering into a software image buffer.  
\item {\ttfamily int = obj.\-Is\-A\-Render\-Into\-Image\-Mapper ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkabstractpicker}{}\section{vtk\-Abstract\-Picker}\label{vtkrendering_vtkabstractpicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Picker is an abstract superclass that defines a minimal A\-P\-I for its concrete subclasses. The minimum functionality of a picker is to return the x-\/y-\/z global coordinate position of a pick (the pick itself is defined in display coordinates).

The A\-P\-I to this class is to invoke the Pick() method with a selection point (in display coordinates -\/ pixels) and a renderer. Then get the resulting pick position in global coordinates with the Get\-Pick\-Position() method.

vtk\-Picker fires events during the picking process. These events are Start\-Pick\-Event, Pick\-Event, and End\-Pick\-Event which are invoked prior to picking, when something is picked, and after all picking candidates have been tested. Note that during the pick process the Pick\-Event of vtk\-Prop (and its subclasses such as vtk\-Actor) is fired prior to the Pick\-Event of vtk\-Picker.

To create an instance of class vtk\-Abstract\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Get the renderer in which pick event occurred.  
\item {\ttfamily double = obj. Get\-Selection\-Point ()} -\/ Get the selection point in screen (pixel) coordinates. The third value is related to z-\/buffer depth. (Normally should be =0.)  
\item {\ttfamily double = obj. Get\-Pick\-Position ()} -\/ Return position in global coordinates of pick point.  
\item {\ttfamily int = obj.\-Pick (double selection\-X, double selection\-Y, double selection\-Z, vtk\-Renderer renderer)} -\/ Perform pick operation with selection point provided. Normally the first two values for the selection point are x-\/y pixel coordinate, and the third value is =0. Return non-\/zero if something was successfully picked.  
\item {\ttfamily int = obj.\-Pick (double selection\-Pt\mbox{[}3\mbox{]}, vtk\-Renderer ren)} -\/ provided. Normally the first two values for the selection point are x-\/y pixel coordinate, and the third value is =0. Return non-\/zero if something was successfully picked.  
\item {\ttfamily obj.\-Set\-Pick\-From\-List (int )} -\/ Use these methods to control whether to limit the picking to this list (rather than renderer's actors). Make sure that the pick list contains actors that referred to by the picker's renderer.  
\item {\ttfamily int = obj.\-Get\-Pick\-From\-List ()} -\/ Use these methods to control whether to limit the picking to this list (rather than renderer's actors). Make sure that the pick list contains actors that referred to by the picker's renderer.  
\item {\ttfamily obj.\-Pick\-From\-List\-On ()} -\/ Use these methods to control whether to limit the picking to this list (rather than renderer's actors). Make sure that the pick list contains actors that referred to by the picker's renderer.  
\item {\ttfamily obj.\-Pick\-From\-List\-Off ()} -\/ Use these methods to control whether to limit the picking to this list (rather than renderer's actors). Make sure that the pick list contains actors that referred to by the picker's renderer.  
\item {\ttfamily obj.\-Initialize\-Pick\-List ()} -\/ Initialize list of actors in pick list.  
\item {\ttfamily obj.\-Add\-Pick\-List (vtk\-Prop )} -\/ Add an actor to the pick list.  
\item {\ttfamily obj.\-Delete\-Pick\-List (vtk\-Prop )} -\/ Delete an actor from the pick list.  
\item {\ttfamily vtk\-Prop\-Collection = obj.\-Get\-Pick\-List ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkabstractproppicker}{}\section{vtk\-Abstract\-Prop\-Picker}\label{vtkrendering_vtkabstractproppicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Prop\-Picker is an abstract superclass for pickers that can pick an instance of vtk\-Prop. Some pickers, like vtk\-World\-Point\-Picker (not a subclass of this class), cannot identify the prop that is picked. Subclasses of vtk\-Abstract\-Prop\-Picker return a prop in the form of a vtk\-Assembly\-Path when a pick is invoked. Note that an vtk\-Assembly\-Path contain a list of vtk\-Assembly\-Nodes, each of which in turn contains a reference to a vtk\-Prop and a 4x4 transformation matrix. The path fully describes the entire pick path, so you can pick assemblies or portions of assemblies, or just grab the tail end of the vtk\-Assembly\-Path (which is the picked prop).

To create an instance of class vtk\-Abstract\-Prop\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractPropPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Prop\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Prop\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Prop\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Prop\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Path (vtk\-Assembly\-Path )} -\/ Return the vtk\-Assembly\-Path that has been picked. The assembly path lists all the vtk\-Props that form an assembly. If no assembly is present, then the assembly path will have one node (which is the picked prop). The set method is used internally to set the path. (Note\-: the structure of an assembly path is a collection of vtk\-Assembly\-Node, each node pointing to a vtk\-Prop and (possibly) a transformation matrix.)  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Get\-Path ()} -\/ Return the vtk\-Assembly\-Path that has been picked. The assembly path lists all the vtk\-Props that form an assembly. If no assembly is present, then the assembly path will have one node (which is the picked prop). The set method is used internally to set the path. (Note\-: the structure of an assembly path is a collection of vtk\-Assembly\-Node, each node pointing to a vtk\-Prop and (possibly) a transformation matrix.)  
\item {\ttfamily vtk\-Prop = obj.\-Get\-View\-Prop ()} -\/ Return the vtk\-Prop that has been picked. If N\-U\-L\-L, nothing was picked. If anything at all was picked, this method will return something.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Prop3\-D ()} -\/ Return the vtk\-Prop that has been picked. If N\-U\-L\-L, no vtk\-Prop3\-D was picked.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Actor ()} -\/ Return the vtk\-Actor that has been picked. If N\-U\-L\-L, no actor was picked.  
\item {\ttfamily vtk\-Actor2\-D = obj.\-Get\-Actor2\-D ()} -\/ Return the vtk\-Actor2\-D that has been picked. If N\-U\-L\-L, no actor2\-D was picked.  
\item {\ttfamily vtk\-Volume = obj.\-Get\-Volume ()} -\/ Return the vtk\-Volume that has been picked. If N\-U\-L\-L, no volume was picked.  
\item {\ttfamily vtk\-Assembly = obj.\-Get\-Assembly ()} -\/ Return the vtk\-Assembly that has been picked. If N\-U\-L\-L, no assembly was picked. (Note\-: the returned assembly is the first node in the assembly path. If the path is one node long, then the assembly and the prop are the same, assuming that the first node is a vtk\-Assembly.)  
\item {\ttfamily vtk\-Prop\-Assembly = obj.\-Get\-Prop\-Assembly ()} -\/ Return the vtk\-Prop\-Assembly that has been picked. If N\-U\-L\-L, no prop assembly was picked. (Note\-: the returned prop assembly is the first node in the assembly path. If the path is one node long, then the prop assembly and the prop are the same, assuming that the first node is a vtk\-Prop\-Assembly.)  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Prop ()} -\/  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkabstractvolumemapper}{}\section{vtk\-Abstract\-Volume\-Mapper}\label{vtkrendering_vtkabstractvolumemapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Abstract\-Volume\-Mapper is the abstract definition of a volume mapper. Specific subclasses deal with different specific types of data input

To create an instance of class vtk\-Abstract\-Volume\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractVolumeMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Volume\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Abstract\-Volume\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Abstract\-Volume\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Abstract\-Volume\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set )} -\/ Set/\-Get the input data  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Data\-Set\-Input ()} -\/ Set/\-Get the input data  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Data\-Object\-Input ()} -\/ Set/\-Get the input data  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Default ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Data ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Field\-Data ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Field\-Data ()} -\/ Control how the mapper works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the mapper will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the mapper to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Scalar\-Array.  
\item {\ttfamily obj.\-Select\-Scalar\-Array (int array\-Num)} -\/ When Scalar\-Mode is set to Use\-Point\-Field\-Data or Use\-Cell\-Field\-Data, you can specify which scalar array to use during rendering. The transfer function in the vtk\-Volume\-Property (attached to the calling vtk\-Volume) will decide how to convert vectors to colors.  
\item {\ttfamily obj.\-Select\-Scalar\-Array (string array\-Name)} -\/ When Scalar\-Mode is set to Use\-Point\-Field\-Data or Use\-Cell\-Field\-Data, you can specify which scalar array to use during rendering. The transfer function in the vtk\-Volume\-Property (attached to the calling vtk\-Volume) will decide how to convert vectors to colors.  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ Get the array name or number and component to use for rendering.  
\item {\ttfamily int = obj.\-Get\-Array\-Id ()} -\/ Get the array name or number and component to use for rendering.  
\item {\ttfamily int = obj.\-Get\-Array\-Access\-Mode ()} -\/ Return the method for obtaining scalar data.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Mode\-As\-String ()} -\/ Return the method for obtaining scalar data.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkactor}{}\section{vtk\-Actor}\label{vtkrendering_vtkactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Actor is used to represent an entity in a rendering scene. It inherits functions related to the actors position, and orientation from vtk\-Prop. The actor also has scaling and maintains a reference to the defining geometry (i.\-e., the mapper), rendering properties, and possibly a texture map. vtk\-Actor combines these instance variables into one 4x4 transformation matrix as follows\-: \mbox{[}x y z 1\mbox{]} = \mbox{[}x y z 1\mbox{]} Translate(-\/origin) Scale(scale) Rot(y) Rot(x) Rot (z) Trans(origin) Trans(position)

To create an instance of class vtk\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-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.\-Render (vtk\-Renderer , vtk\-Mapper )} -\/ Shallow copy of an actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an 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.\-Set\-Property (vtk\-Property lut)} -\/ Set/\-Get the property object that controls this actors surface properties. This should be an instance of a vtk\-Property object. Every actor must have a property associated with it. If one isn't specified, then one will be generated automatically. Multiple actors can share one property object.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Set/\-Get the property object that controls this actors surface properties. This should be an instance of a vtk\-Property object. Every actor must have a property associated with it. If one isn't specified, then one will be generated automatically. Multiple actors can share one property object.  
\item {\ttfamily vtk\-Property = obj.\-Make\-Property ()} -\/ Create a new property suitable for use with this type of Actor. For example, a vtk\-Mesa\-Actor should create a vtk\-Mesa\-Property in this function. The default is to just call vtk\-Property\-::\-New.  
\item {\ttfamily obj.\-Set\-Backface\-Property (vtk\-Property lut)} -\/ Set/\-Get the property object that controls this actors backface surface properties. This should be an instance of a vtk\-Property object. If one isn't specified, then the front face properties will be used. Multiple actors can share one property object.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Backface\-Property ()} -\/ Set/\-Get the property object that controls this actors backface surface properties. This should be an instance of a vtk\-Property object. If one isn't specified, then the front face properties will be used. Multiple actors can share one property object.  
\item {\ttfamily obj.\-Set\-Texture (vtk\-Texture )} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. An actor does not need to have an associated texture map and multiple actors can share one texture.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture ()} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. An actor does not need to have an associated texture map and multiple actors can share one texture.  
\item {\ttfamily obj.\-Set\-Mapper (vtk\-Mapper )} -\/ This is the method that is used to connect an actor to the end of a visualization pipeline, i.\-e. the mapper. This should be a subclass of vtk\-Mapper. Typically vtk\-Poly\-Data\-Mapper and vtk\-Data\-Set\-Mapper will be used.  
\item {\ttfamily vtk\-Mapper = obj.\-Get\-Mapper ()} -\/ Returns the Mapper that this actor is getting its data from.  
\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 obj.\-Apply\-Properties ()} -\/ Get the actors mtime plus consider its properties and texture if set.  
\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.\-Init\-Part\-Traversal ()} -\/ The following methods are for compatibility. The methods will be deprecated in the near future. Use vtk\-Prop\-::\-Get\-Next\-Path() (and related functionality) to get the parts in an assembly (or more correctly, the paths in the assembly).  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Next\-Part ()} -\/ The following methods are for compatibility. The methods will be deprecated in the near future. Use vtk\-Prop\-::\-Get\-Next\-Path() (and related functionality) to get the parts in an assembly (or more correctly, the paths in the assembly).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Parts ()} -\/ The following methods are for compatibility. The methods will be deprecated in the near future. Use vtk\-Prop\-::\-Get\-Next\-Path() (and related functionality) to get the parts in an assembly (or more correctly, the paths in the assembly).  
\item {\ttfamily bool = obj.\-Get\-Supports\-Selection ()} -\/ W\-A\-R\-N\-I\-N\-G\-: I\-N\-T\-E\-R\-N\-A\-L M\-E\-T\-H\-O\-D -\/ N\-O\-T I\-N\-T\-E\-N\-D\-E\-D F\-O\-R G\-E\-N\-E\-R\-A\-L U\-S\-E D\-O N\-O\-T U\-S\-E T\-H\-I\-S M\-E\-T\-H\-O\-D O\-U\-T\-S\-I\-D\-E O\-F T\-H\-E R\-E\-N\-D\-E\-R\-I\-N\-G P\-R\-O\-C\-E\-S\-S Used by vtk\-Hardware\-Selector to determine if the prop supports hardware selection.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkactorcollection}{}\section{vtk\-Actor\-Collection}\label{vtkrendering_vtkactorcollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Actor\-Collection represents and provides methods to manipulate a list of actors (i.\-e., vtk\-Actor and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Actor\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkActorCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Actor\-Collection 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\-Actor\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Actor\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Actor\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Actor a)} -\/ Add an actor to the list.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Next\-Actor ()} -\/ Get the next actor in the list.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Last\-Actor ()} -\/ Get the last actor in the list.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Next\-Item ()} -\/ Access routines that are provided for compatibility with previous version of V\-T\-K. Please use the Get\-Next\-Actor(), Get\-Last\-Actor() variants where possible.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Last\-Item ()} -\/ Access routines that are provided for compatibility with previous version of V\-T\-K. Please use the Get\-Next\-Actor(), Get\-Last\-Actor() variants where possible.  
\item {\ttfamily obj.\-Apply\-Properties (vtk\-Property p)} -\/ Apply properties to all actors in this collection.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkareapicker}{}\section{vtk\-Area\-Picker}\label{vtkrendering_vtkareapicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Area\-Picker picks all vtk\-Prop3\-Ds that lie behind the screen space rectangle from x0,y0 and x1,y1. The selection is based upon the bounding box of the prop and is thus not exact.

Like vtk\-Picker, a pick results in a list of Prop3\-Ds because many props may lie within the pick frustum. You can also get an Assembly\-Path, which in this case is defined to be the path to the one particular prop in the Prop3\-D list that lies nearest to the near plane.

This picker also returns the selection frustum, defined as either a vtk\-Planes, or a set of eight corner vertices in world space. The vtk\-Planes version is an Implicit\-Function, which is suitable for use with the vtk\-Extract\-Geometry. The six frustum planes are in order\-: left, right, bottom, top, near, far

Because this picker picks everything within a volume, the world pick point result is ill-\/defined. Therefore if you ask this class for the world pick position, you will get the centroid of the pick frustum. This may be outside of all props in the prop list.

To create an instance of class vtk\-Area\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAreaPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Area\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Area\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Area\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Area\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Pick\-Coords (double x0, double y0, double x1, double y1)} -\/ Set the default screen rectangle to pick in.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer )} -\/ Set the default renderer to pick on.  
\item {\ttfamily int = obj.\-Pick ()} -\/ Perform an Area\-Pick within the default screen rectangle and renderer.  
\item {\ttfamily int = obj.\-Area\-Pick (double x0, double y0, double x1, double y1, vtk\-Renderer renderer\-N\-U\-L\-L)} -\/ Perform pick operation in volume behind the given screen coordinates. Props intersecting the selection frustum will be accesible via Get\-Prop3\-D. Get\-Planes returns a vtk\-Implicit\-Funciton suitable for vtk\-Extract\-Geometry.  
\item {\ttfamily int = obj.\-Pick (double x0, double y0, double , vtk\-Renderer renderer\-N\-U\-L\-L)} -\/ Perform pick operation in volume behind the given screen coordinate. This makes a thin frustum around the selected pixel. Note\-: this ignores Z in order to pick everying in a volume from z=0 to z=1.  
\item {\ttfamily vtk\-Abstract\-Mapper3\-D = obj.\-Get\-Mapper ()} -\/ Return mapper that was picked (if any).  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Data\-Set ()} -\/ Get a pointer to the dataset that was picked (if any). If nothing was picked then N\-U\-L\-L is returned.  
\item {\ttfamily vtk\-Prop3\-D\-Collection = obj.\-Get\-Prop3\-Ds ()} -\/ Return a collection of all the prop 3\-D's that were intersected by the pick ray. This collection is not sorted.  
\item {\ttfamily vtk\-Planes = obj.\-Get\-Frustum ()} -\/ Return the six planes that define the selection frustum. The implicit function defined by the planes evaluates to negative inside and positive outside.  
\item {\ttfamily vtk\-Points = obj.\-Get\-Clip\-Points ()} -\/ Return eight points that define the selection frustum.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkassembly}{}\section{vtk\-Assembly}\label{vtkrendering_vtkassembly}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Assembly is an object that groups vtk\-Prop3\-Ds, its subclasses, and other assemblies into a tree-\/like hierarchy. The vtk\-Prop3\-Ds and assemblies can then be transformed together by transforming just the root assembly of the hierarchy.

A vtk\-Assembly object can be used in place of an vtk\-Prop3\-D since it is a subclass of vtk\-Prop3\-D. The difference is that vtk\-Assembly maintains a list of vtk\-Prop3\-D instances (its \char`\"{}parts\char`\"{}) that form the assembly. Then, any operation that transforms (i.\-e., scales, rotates, translates) the parent assembly will transform all its parts. Note that this process is recursive\-: you can create groups consisting of assemblies and/or vtk\-Prop3\-Ds to arbitrary depth.

To add an assembly to the renderer's list of props, you only need to add the root of the assembly. During rendering, the parts of the assembly are rendered during a hierarchical traversal process.

To create an instance of class vtk\-Assembly, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAssembly
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Assembly 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\-Assembly class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Assembly = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Assembly = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Part (vtk\-Prop3\-D )} -\/ Add a part to the list of parts.  
\item {\ttfamily obj.\-Remove\-Part (vtk\-Prop3\-D )} -\/ Remove a part from the list of parts,  
\item {\ttfamily vtk\-Prop3\-D\-Collection = obj.\-Get\-Parts ()} -\/ Return the parts (direct descendants) of this assembly.  
\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 obj.\-Get\-Volumes (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 ren)} -\/ Render this assembly and all its parts. The rendering process is recursive. Note that a mapper need not be defined. If not defined, then no geometry will be drawn for this assembly. This allows you to create \char`\"{}logical\char`\"{} assemblies; that is, assemblies that only serve to group and transform its parts.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport ren)} -\/ Render this assembly and all its parts. The rendering process is recursive. Note that a mapper need not be defined. If not defined, then no geometry will be drawn for this assembly. This allows you to create \char`\"{}logical\char`\"{} assemblies; that is, assemblies that only serve to group and transform its parts.  
\item {\ttfamily int = obj.\-Render\-Volumetric\-Geometry (vtk\-Viewport ren)} -\/ Render this assembly and all its parts. The rendering process is recursive. Note that a mapper need not be defined. If not defined, then no geometry will be drawn for this assembly. This allows you to create \char`\"{}logical\char`\"{} assemblies; that is, assemblies that only serve to group and transform its parts.  
\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.  
\item {\ttfamily obj.\-Init\-Path\-Traversal ()} -\/ Methods to traverse the parts of an assembly. Each part (starting from the root) will appear properly transformed and with the correct properties (depending upon the Apply\-Property and Apply\-Transform ivars). Note that the part appears as an instance of vtk\-Prop. These methods should be contrasted to those that traverse the list of parts using Get\-Parts(). Get\-Parts() returns a list of children of this assembly, not necessarily with the correct transformation or properties. To use the methods below -\/ first invoke Init\-Path\-Traversal() followed by repeated calls to Get\-Next\-Path(). Get\-Next\-Path() returns a N\-U\-L\-L pointer when the list is exhausted.  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Get\-Next\-Path ()} -\/ Methods to traverse the parts of an assembly. Each part (starting from the root) will appear properly transformed and with the correct properties (depending upon the Apply\-Property and Apply\-Transform ivars). Note that the part appears as an instance of vtk\-Prop. These methods should be contrasted to those that traverse the list of parts using Get\-Parts(). Get\-Parts() returns a list of children of this assembly, not necessarily with the correct transformation or properties. To use the methods below -\/ first invoke Init\-Path\-Traversal() followed by repeated calls to Get\-Next\-Path(). Get\-Next\-Path() returns a N\-U\-L\-L pointer when the list is exhausted.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Paths ()} -\/ Methods to traverse the parts of an assembly. Each part (starting from the root) will appear properly transformed and with the correct properties (depending upon the Apply\-Property and Apply\-Transform ivars). Note that the part appears as an instance of vtk\-Prop. These methods should be contrasted to those that traverse the list of parts using Get\-Parts(). Get\-Parts() returns a list of children of this assembly, not necessarily with the correct transformation or properties. To use the methods below -\/ first invoke Init\-Path\-Traversal() followed by repeated calls to Get\-Next\-Path(). Get\-Next\-Path() returns a N\-U\-L\-L pointer when the list is exhausted.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds for the assembly as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds for the assembly as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override default Get\-M\-Time method to also consider all of the assembly's parts.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an assembly. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkaxisactor2d}{}\section{vtk\-Axis\-Actor2\-D}\label{vtkrendering_vtkaxisactor2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Axis\-Actor2\-D creates an axis with tick marks, labels, and/or a title, depending on the particular instance variable settings. vtk\-Axis\-Actor2\-D is a 2\-D actor; that is, it is drawn on the overlay plane and is not occluded by 3\-D geometry. To use this class, you typically specify two points defining the start and end points of the line (x-\/y definition using vtk\-Coordinate class), 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. You can also specify the label format (a printf style format).

This class decides what font size to use and how to locate the labels. It also decides how to create reasonable tick marks and labels. The number of labels and the range of values may not match the number specified, but should be close.

Labels are drawn on the \char`\"{}right\char`\"{} side of the axis. The \char`\"{}right\char`\"{} side is the side of the axis on the right as you move from Position to Position2. The way the labels and title line up with the axis and tick marks depends on whether the line is considered horizontal or vertical.

The vtk\-Actor2\-D instance variables Position and Position2 are instances of vtk\-Coordinate. Note that the Position2 is an absolute position in that class (it was by default relative to Position in vtk\-Actor2\-D).

What this means is that you can specify the axis in a variety of coordinate systems. Also, the axis does not have to be either horizontal or vertical. The tick marks are created so that they are perpendicular to the axis.

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated to this actor.

To create an instance of class vtk\-Axis\-Actor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAxisActor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Axis\-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\-Axis\-Actor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Axis\-Actor2\-D = 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. Note\-: backward compatibility only, use vtk\-Actor2\-D's Position instead.  
\item {\ttfamily obj.\-Set\-Point1 (double x\mbox{[}2\mbox{]})} -\/ Specify the position of the first point defining the axis. Note\-: backward compatibility only, use vtk\-Actor2\-D's Position instead.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y)} -\/ Specify the position of the first point defining the axis. Note\-: backward compatibility only, use vtk\-Actor2\-D's Position instead.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point2\-Coordinate ()} -\/ Specify the position of the second point defining the axis. Note that the order from Point1 to Point2 controls which side the tick marks are drawn on (ticks are drawn on the right, if visible). Note\-: backward compatibility only, use vtk\-Actor2\-D's Position2 instead.  
\item {\ttfamily obj.\-Set\-Point2 (double x\mbox{[}2\mbox{]})} -\/ Specify the position of the second point defining the axis. Note that the order from Point1 to Point2 controls which side the tick marks are drawn on (ticks are drawn on the right, if visible). Note\-: backward compatibility only, use vtk\-Actor2\-D's Position2 instead.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y)} -\/ Specify the position of the second point defining the axis. Note that the order from Point1 to Point2 controls which side the tick marks are drawn on (ticks are drawn on the right, if visible). Note\-: backward compatibility only, use vtk\-Actor2\-D's Position2 instead.  
\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\-Number\-Of\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Min\-Value ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Max\-Value ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on the scalar bar.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on the scalar bar.  
\item {\ttfamily obj.\-Set\-Adjust\-Labels (int )} -\/ 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\-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.\-Adjust\-Labels\-On ()} -\/ 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.\-Adjust\-Labels\-Off ()} -\/ 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.\-Get\-Adjusted\-Range (double \-\_\-arg\mbox{[}2\mbox{]})} -\/ 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\-Adjusted\-Number\-Of\-Labels ()} -\/ Set/\-Get the title of the scalar bar actor,  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the scalar bar actor,  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the scalar bar actor,  
\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\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property.  
\item {\ttfamily obj.\-Set\-Tick\-Length (int )} -\/ Set/\-Get the length of the tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Tick\-Length\-Min\-Value ()} -\/ Set/\-Get the length of the tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Tick\-Length\-Max\-Value ()} -\/ Set/\-Get the length of the tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Tick\-Length ()} -\/ Set/\-Get the length of the tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Minor\-Ticks (int )} -\/ Number of minor ticks to be displayed between each tick. Default is 0.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Minor\-Ticks\-Min\-Value ()} -\/ Number of minor ticks to be displayed between each tick. Default is 0.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Minor\-Ticks\-Max\-Value ()} -\/ Number of minor ticks to be displayed between each tick. Default is 0.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Minor\-Ticks ()} -\/ Number of minor ticks to be displayed between each tick. Default is 0.  
\item {\ttfamily obj.\-Set\-Minor\-Tick\-Length (int )} -\/ Set/\-Get the length of the minor tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Minor\-Tick\-Length\-Min\-Value ()} -\/ Set/\-Get the length of the minor tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Minor\-Tick\-Length\-Max\-Value ()} -\/ Set/\-Get the length of the minor tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily int = obj.\-Get\-Minor\-Tick\-Length ()} -\/ Set/\-Get the length of the minor tick marks (expressed in pixels or display coordinates).  
\item {\ttfamily obj.\-Set\-Tick\-Offset (int )} -\/ Set/\-Get the offset of the labels (expressed in pixels or display coordinates). The offset is the distance of labels from tick marks or other objects.  
\item {\ttfamily int = obj.\-Get\-Tick\-Offset\-Min\-Value ()} -\/ Set/\-Get the offset of the labels (expressed in pixels or display coordinates). The offset is the distance of labels from tick marks or other objects.  
\item {\ttfamily int = obj.\-Get\-Tick\-Offset\-Max\-Value ()} -\/ Set/\-Get the offset of the labels (expressed in pixels or display coordinates). The offset is the distance of labels from tick marks or other objects.  
\item {\ttfamily int = obj.\-Get\-Tick\-Offset ()} -\/ Set/\-Get the offset of the labels (expressed in pixels or display coordinates). The offset is the distance of labels from tick marks or other objects.  
\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\-Title\-Position (double )} -\/ Set/\-Get position of the axis title. 0 is at the start of the axis whereas 1 is at the end.  
\item {\ttfamily double = obj.\-Get\-Title\-Position ()} -\/ Set/\-Get position of the axis title. 0 is at the start of the axis whereas 1 is at the end.  
\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. This ivar used in conjunction with the Label\-Factor can be used to control font sizes.  
\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. This ivar used in conjunction with the Label\-Factor can be used to control font sizes.  
\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. This ivar used in conjunction with the Label\-Factor can be used to control font sizes.  
\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. This ivar used in conjunction with the Label\-Factor can be used to control font sizes.  
\item {\ttfamily obj.\-Set\-Label\-Factor (double )} -\/ Set/\-Get the factor that controls the relative size of the axis labels to the axis title.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the axis labels to the axis title.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the relative size of the axis labels to the axis title.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor ()} -\/ Set/\-Get the factor that controls the relative size of the axis labels to the axis title.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Draw the axis.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Draw the axis.  
\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.  
\item {\ttfamily obj.\-Set\-Size\-Font\-Relative\-To\-Axis (int )} -\/ Specify whether to size the fonts relative to the viewport or relative to length of the axis. By default, fonts are resized relative to the axis.  
\item {\ttfamily int = obj.\-Get\-Size\-Font\-Relative\-To\-Axis ()} -\/ Specify whether to size the fonts relative to the viewport or relative to length of the axis. By default, fonts are resized relative to the axis.  
\item {\ttfamily obj.\-Size\-Font\-Relative\-To\-Axis\-On ()} -\/ Specify whether to size the fonts relative to the viewport or relative to length of the axis. By default, fonts are resized relative to the axis.  
\item {\ttfamily obj.\-Size\-Font\-Relative\-To\-Axis\-Off ()} -\/ Specify whether to size the fonts relative to the viewport or relative to length of the axis. By default, fonts are resized relative to the axis.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an axis actor. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcamera}{}\section{vtk\-Camera}\label{vtkrendering_vtkcamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Camera is a virtual camera for 3\-D rendering. It provides methods to position and orient the view point and focal point. Convenience methods for moving about the focal point also are provided. More complex methods allow the manipulation of the computer graphics model including view up vector, clipping planes, and camera perspective.

To create an instance of class vtk\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera 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\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Position (double x, double y, double z)} -\/ Set/\-Get the position of the camera in world coordinates. The default position is (0,0,1).  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the camera in world coordinates. The default position is (0,0,1).  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get the position of the camera in world coordinates. The default position is (0,0,1).  
\item {\ttfamily obj.\-Set\-Focal\-Point (double x, double y, double z)} -\/ Set/\-Get the focal of the camera in world coordinates. The default focal point is the origin.  
\item {\ttfamily obj.\-Set\-Focal\-Point (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the focal of the camera in world coordinates. The default focal point is the origin.  
\item {\ttfamily double = obj. Get\-Focal\-Point ()} -\/ Set/\-Get the focal of the camera in world coordinates. The default focal point is the origin.  
\item {\ttfamily obj.\-Set\-View\-Up (double vx, double vy, double vz)} -\/ Set/\-Get the view up direction for the camera. The default is (0,1,0).  
\item {\ttfamily obj.\-Set\-View\-Up (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the view up direction for the camera. The default is (0,1,0).  
\item {\ttfamily double = obj. Get\-View\-Up ()} -\/ Set/\-Get the view up direction for the camera. The default is (0,1,0).  
\item {\ttfamily obj.\-Orthogonalize\-View\-Up ()} -\/ Recompute the View\-Up vector to force it to be perpendicular to camera-\/$>$focalpoint vector. Unless you are going to use Yaw or Azimuth on the camera, there is no need to do this.  
\item {\ttfamily obj.\-Set\-Distance (double )} -\/ Move the focal point so that it is the specified distance from the camera position. This distance must be positive.  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ Return the distance from the camera position to the focal point. This distance is positive.  
\item {\ttfamily double = obj. Get\-Direction\-Of\-Projection ()} -\/ Get the vector in the direction from the camera position to the focal point. This is usually the opposite of the View\-Plane\-Normal, the vector perpendicular to the screen, unless the view is oblique.  
\item {\ttfamily obj.\-Dolly (double value)} -\/ Divide the camera's distance from the focal point by the given dolly value. Use a value greater than one to dolly-\/in toward the focal point, and use a value less than one to dolly-\/out away from the focal point.  
\item {\ttfamily obj.\-Set\-Roll (double angle)} -\/ Set the roll angle of the camera about the direction of projection.  
\item {\ttfamily double = obj.\-Get\-Roll ()} -\/ Set the roll angle of the camera about the direction of projection.  
\item {\ttfamily obj.\-Roll (double angle)} -\/ Rotate the camera about the direction of projection. This will spin the camera about its axis.  
\item {\ttfamily obj.\-Azimuth (double angle)} -\/ Rotate the camera about the view up vector centered at the focal point. Note that the view up vector is whatever was set via Set\-View\-Up, and is not necessarily perpendicular to the direction of projection. The result is a horizontal rotation of the camera.  
\item {\ttfamily obj.\-Yaw (double angle)} -\/ Rotate the focal point about the view up vector, using the camera's position as the center of rotation. Note that the view up vector is whatever was set via Set\-View\-Up, and is not necessarily perpendicular to the direction of projection. The result is a horizontal rotation of the scene.  
\item {\ttfamily obj.\-Elevation (double angle)} -\/ Rotate the camera about the cross product of the negative of the direction of projection and the view up vector, using the focal point as the center of rotation. The result is a vertical rotation of the scene.  
\item {\ttfamily obj.\-Pitch (double angle)} -\/ Rotate the focal point about the cross product of the view up vector and the direction of projection, using the camera's position as the center of rotation. The result is a vertical rotation of the camera.  
\item {\ttfamily obj.\-Set\-Parallel\-Projection (int flag)} -\/ Set/\-Get the value of the Parallel\-Projection instance variable. This determines if the camera should do a perspective or parallel projection.  
\item {\ttfamily int = obj.\-Get\-Parallel\-Projection ()} -\/ Set/\-Get the value of the Parallel\-Projection instance variable. This determines if the camera should do a perspective or parallel projection.  
\item {\ttfamily obj.\-Parallel\-Projection\-On ()} -\/ Set/\-Get the value of the Parallel\-Projection instance variable. This determines if the camera should do a perspective or parallel projection.  
\item {\ttfamily obj.\-Parallel\-Projection\-Off ()} -\/ Set/\-Get the value of the Parallel\-Projection instance variable. This determines if the camera should do a perspective or parallel projection.  
\item {\ttfamily obj.\-Set\-Use\-Horizontal\-View\-Angle (int flag)} -\/ Set/\-Get the value of the Use\-Horizontal\-View\-Angle instance variable. If set, the camera's view angle represents a horizontal view angle, rather than the default vertical view angle. This is useful if the application uses a display device which whose specs indicate a particular horizontal view angle, or if the application varies the window height but wants to keep the perspective transform unchanges.  
\item {\ttfamily int = obj.\-Get\-Use\-Horizontal\-View\-Angle ()} -\/ Set/\-Get the value of the Use\-Horizontal\-View\-Angle instance variable. If set, the camera's view angle represents a horizontal view angle, rather than the default vertical view angle. This is useful if the application uses a display device which whose specs indicate a particular horizontal view angle, or if the application varies the window height but wants to keep the perspective transform unchanges.  
\item {\ttfamily obj.\-Use\-Horizontal\-View\-Angle\-On ()} -\/ Set/\-Get the value of the Use\-Horizontal\-View\-Angle instance variable. If set, the camera's view angle represents a horizontal view angle, rather than the default vertical view angle. This is useful if the application uses a display device which whose specs indicate a particular horizontal view angle, or if the application varies the window height but wants to keep the perspective transform unchanges.  
\item {\ttfamily obj.\-Use\-Horizontal\-View\-Angle\-Off ()} -\/ Set/\-Get the value of the Use\-Horizontal\-View\-Angle instance variable. If set, the camera's view angle represents a horizontal view angle, rather than the default vertical view angle. This is useful if the application uses a display device which whose specs indicate a particular horizontal view angle, or if the application varies the window height but wants to keep the perspective transform unchanges.  
\item {\ttfamily obj.\-Set\-View\-Angle (double angle)} -\/ Set/\-Get the camera view angle, which is the angular height of the camera view measured in degrees. The default angle is 30 degrees. This method has no effect in parallel projection mode. The formula for setting the angle up for perfect perspective viewing is\-: angle = 2$\ast$atan((h/2)/d) where h is the height of the Render\-Window (measured by holding a ruler up to your screen) and d is the distance from your eyes to the screen.  
\item {\ttfamily double = obj.\-Get\-View\-Angle ()} -\/ Set/\-Get the camera view angle, which is the angular height of the camera view measured in degrees. The default angle is 30 degrees. This method has no effect in parallel projection mode. The formula for setting the angle up for perfect perspective viewing is\-: angle = 2$\ast$atan((h/2)/d) where h is the height of the Render\-Window (measured by holding a ruler up to your screen) and d is the distance from your eyes to the screen.  
\item {\ttfamily obj.\-Set\-Parallel\-Scale (double scale)} -\/ Set/\-Get the scaling used for a parallel projection, i.\-e. the height of the viewport in world-\/coordinate distances. The default is 1. Note that the \char`\"{}scale\char`\"{} parameter works as an \char`\"{}inverse scale\char`\"{} --- larger numbers produce smaller images. This method has no effect in perspective projection mode.  
\item {\ttfamily double = obj.\-Get\-Parallel\-Scale ()} -\/ Set/\-Get the scaling used for a parallel projection, i.\-e. the height of the viewport in world-\/coordinate distances. The default is 1. Note that the \char`\"{}scale\char`\"{} parameter works as an \char`\"{}inverse scale\char`\"{} --- larger numbers produce smaller images. This method has no effect in perspective projection mode.  
\item {\ttfamily obj.\-Zoom (double factor)} -\/ In perspective mode, decrease the view angle by the specified factor. In parallel mode, decrease the parallel scale by the specified factor. A value greater than 1 is a zoom-\/in, a value less than 1 is a zoom-\/out.  
\item {\ttfamily obj.\-Set\-Clipping\-Range (double d\-Near, double d\-Far)} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. How the clipping planes are set can have a large impact on how well z-\/buffering works. In particular the front clipping plane can make a very big difference. Setting it to 0.\-01 when it really could be 1.\-0 can have a big impact on your z-\/buffer resolution farther away. The default clipping range is (0.\-1,1000).  
\item {\ttfamily obj.\-Set\-Clipping\-Range (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. How the clipping planes are set can have a large impact on how well z-\/buffering works. In particular the front clipping plane can make a very big difference. Setting it to 0.\-01 when it really could be 1.\-0 can have a big impact on your z-\/buffer resolution farther away. The default clipping range is (0.\-1,1000).  
\item {\ttfamily double = obj. Get\-Clipping\-Range ()} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. How the clipping planes are set can have a large impact on how well z-\/buffering works. In particular the front clipping plane can make a very big difference. Setting it to 0.\-01 when it really could be 1.\-0 can have a big impact on your z-\/buffer resolution farther away. The default clipping range is (0.\-1,1000).  
\item {\ttfamily obj.\-Set\-Thickness (double )} -\/ Set the distance between clipping planes. This method adjusts the far clipping plane to be set a distance 'thickness' beyond the near clipping plane.  
\item {\ttfamily double = obj.\-Get\-Thickness ()} -\/ Set the distance between clipping planes. This method adjusts the far clipping plane to be set a distance 'thickness' beyond the near clipping plane.  
\item {\ttfamily obj.\-Set\-Window\-Center (double x, double y)} -\/ Set/\-Get the center of the window in viewport coordinates. The viewport coordinate range is (\mbox{[}-\/1,+1\mbox{]},\mbox{[}-\/1,+1\mbox{]}). This method is for if you have one window which consists of several viewports, or if you have several screens which you want to act together as one large screen.  
\item {\ttfamily double = obj. Get\-Window\-Center ()} -\/ Set/\-Get the center of the window in viewport coordinates. The viewport coordinate range is (\mbox{[}-\/1,+1\mbox{]},\mbox{[}-\/1,+1\mbox{]}). This method is for if you have one window which consists of several viewports, or if you have several screens which you want to act together as one large screen.  
\item {\ttfamily obj.\-Set\-Oblique\-Angles (double alpha, double beta)} -\/ Get/\-Set the oblique viewing angles. The first angle, alpha, is the angle (measured from the horizontal) that rays along the direction of projection will follow once projected onto the 2\-D screen. The second angle, beta, is the angle between the view plane and the direction of projection. This creates a shear transform x' = x + dz$\ast$cos(alpha)/tan(beta), y' = dz$\ast$sin(alpha)/tan(beta) where dz is the distance of the point from the focal plane. The angles are (45,90) by default. Oblique projections commonly use (30,63.\-435).  
\item {\ttfamily obj.\-Apply\-Transform (vtk\-Transform t)} -\/ Apply a transform to the camera. The camera position, focal-\/point, and view-\/up are re-\/calculated using the transform's matrix to multiply the old points by the new transform.  
\item {\ttfamily double = obj. Get\-View\-Plane\-Normal ()} -\/ Get the View\-Plane\-Normal. This vector will point opposite to the direction of projection, unless you have created an sheared output view using Set\-View\-Shear/\-Set\-Oblique\-Angles.  
\item {\ttfamily obj.\-Set\-View\-Shear (double dxdz, double dydz, double center)} -\/ Set/get the shear transform of the viewing frustum. Parameters are dx/dz, dy/dz, and center. center is a factor that describes where to shear around. The distance dshear from the camera where no shear occurs is given by (dshear = center $\ast$ Focal\-Distance).  
\item {\ttfamily obj.\-Set\-View\-Shear (double d\mbox{[}3\mbox{]})} -\/ Set/get the shear transform of the viewing frustum. Parameters are dx/dz, dy/dz, and center. center is a factor that describes where to shear around. The distance dshear from the camera where no shear occurs is given by (dshear = center $\ast$ Focal\-Distance).  
\item {\ttfamily double = obj. Get\-View\-Shear ()} -\/ Set/get the shear transform of the viewing frustum. Parameters are dx/dz, dy/dz, and center. center is a factor that describes where to shear around. The distance dshear from the camera where no shear occurs is given by (dshear = center $\ast$ Focal\-Distance).  
\item {\ttfamily obj.\-Set\-Eye\-Angle (double )} -\/ Set/\-Get the separation between eyes (in degrees). This is used when generating stereo images.  
\item {\ttfamily double = obj.\-Get\-Eye\-Angle ()} -\/ Set/\-Get the separation between eyes (in degrees). This is used when generating stereo images.  
\item {\ttfamily obj.\-Set\-Focal\-Disk (double )} -\/ Set the size of the cameras lens in world coordinates. This is only used when the renderer is doing focal depth rendering. When that is being done the size of the focal disk will effect how significant the depth effects will be.  
\item {\ttfamily double = obj.\-Get\-Focal\-Disk ()} -\/ Set the size of the cameras lens in world coordinates. This is only used when the renderer is doing focal depth rendering. When that is being done the size of the focal disk will effect how significant the depth effects will be.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-View\-Transform\-Matrix ()} -\/ Return the matrix of the view transform. The View\-Transform depends on only three ivars\-: the Position, the Focal\-Point, and the View\-Up vector. All the other methods are there simply for the sake of the users' convenience.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-View\-Transform\-Object ()} -\/ Return the projection transform matrix, which converts from camera coordinates to viewport coordinates. The 'aspect' is the width/height for the viewport, and the nearz and farz are the Z-\/buffer values that map to the near and far clipping planes. The viewport coordinates of a point located inside the frustum are in the range (\mbox{[}-\/1,+1\mbox{]},\mbox{[}-\/1,+1\mbox{]},\mbox{[}nearz,farz\mbox{]}). W\-A\-R\-N\-I\-N\-G\-: the name of the method is wrong, it should be Get\-Projection\-Transform\-Matrix() (it is used also in parallel projection)  \begin{DoxyPrecond}{Precondition}
source\-\_\-exists!=0 

not\-\_\-this\-: source!=this  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Deep\-Copy (vtk\-Camera source)} -\/ Copy the properties of `source' into `this'. Copy the contents of the matrices. \begin{DoxyPrecond}{Precondition}
source\-\_\-exists!=0 

not\-\_\-this\-: source!=this  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkcameraactor}{}\section{vtk\-Camera\-Actor}\label{vtkrendering_vtkcameraactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Camera\-Actor is an actor used to represent a camera by its wireframe frustum.

To create an instance of class vtk\-Camera\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCameraActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera\-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\-Camera\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Camera\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Camera\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera camera)} -\/ The camera to represent. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ The camera to represent. Initial value is N\-U\-L\-L.  
\item {\ttfamily obj.\-Set\-Width\-By\-Height\-Ratio (double )} -\/ Ratio between the width and the height of the frustum. Initial value is 1.\-0 (square)  
\item {\ttfamily double = obj.\-Get\-Width\-By\-Height\-Ratio ()} -\/ Ratio between the width and the height of the frustum. Initial value is 1.\-0 (square)  
\item {\ttfamily int = obj.\-Render\-Opaque\-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? No.  
\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 long = obj.\-Get\-M\-Time ()} -\/ Get the actors mtime plus consider its properties and texture if set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Get property of the internal actor.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property p)} -\/ Set property of the internal actor.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcamerainterpolator}{}\section{vtk\-Camera\-Interpolator}\label{vtkrendering_vtkcamerainterpolator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to interpolate a series of cameras to update a specified camera. Either linear interpolation or spline interpolation may be used. The instance variables currently interpolated include position, focal point, view up, view angle, parallel scale, and clipping range.

To use this class, specify the type of interpolation to use, and add a series of cameras at various times \char`\"{}t\char`\"{} to the list of cameras from which to interpolate. Then to interpolate in between cameras, simply invoke the function Interpolate\-Camera(t,camera) where \char`\"{}camera\char`\"{} is the camera to be updated with interpolated values. Note that \char`\"{}t\char`\"{} should be in the range (min,max) times specified with the Add\-Camera() method. If outside this range, the interpolation is clamped. This class copies the camera information (as compared to referencing the cameras) so you do not need to keep separate instances of the camera around for each camera added to the list of cameras to interpolate.

To create an instance of class vtk\-Camera\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCameraInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera\-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\-Camera\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Camera\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Camera\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cameras ()} -\/ Return the number of cameras in the list of cameras.  
\item {\ttfamily double = obj.\-Get\-Minimum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned are undefined if the list of cameras is empty.  
\item {\ttfamily double = obj.\-Get\-Maximum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned are undefined if the list of cameras is empty.  
\item {\ttfamily obj.\-Initialize ()} -\/ Clear the list of cameras.  
\item {\ttfamily obj.\-Add\-Camera (double t, vtk\-Camera camera)} -\/ Add another camera to the list of cameras defining the camera function. Note that using the same time t value more than once replaces the previous camera value at t. At least one camera must be added to define a function.  
\item {\ttfamily obj.\-Remove\-Camera (double t)} -\/ Delete the camera at a particular parameter t. If there is no camera defined at location t, then the method does nothing.  
\item {\ttfamily obj.\-Interpolate\-Camera (double t, vtk\-Camera camera)} -\/ Interpolate the list of cameras and determine a new camera (i.\-e., fill in the camera provided). If t is outside the range of (min,max) values, then t is clamped to lie within this range.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type (int )} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Min\-Value ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Max\-Value ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Linear ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Spline ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the instance variable interpolators (i.\-e., position, focal point, clipping range, orientation, etc.) interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Manual ()} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-Position\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Position\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-Focal\-Point\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the focal point portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Focal\-Point\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the focal point portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-View\-Up\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the view up portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-View\-Up\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the view up portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-View\-Angle\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the view angle portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-View\-Angle\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the view angle portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-Parallel\-Scale\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the parallel scale portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Parallel\-Scale\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the parallel scale portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily obj.\-Set\-Clipping\-Range\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the clipping range portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Clipping\-Range\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the clipping range portion of the camera. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances directly.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time() because we depend on the interpolators which may be modified outside of this class.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcamerapass}{}\section{vtk\-Camera\-Pass}\label{vtkrendering_vtkcamerapass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Render the camera.

It setups the projection and modelview matrices and can clear the background It calls its delegate once. After its delegate returns, it restore the modelview matrix stack.

Its delegate is usually set to a vtk\-Sequence\-Pass with a vtk\-Ligths\-Pass and a list of passes for the geometry.

To create an instance of class vtk\-Camera\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCameraPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera\-Pass 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\-Camera\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Camera\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Camera\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Delegate\-Pass ()} -\/ Delegate for rendering the geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Sequence\-Pass with a vtk\-Ligths\-Pass and a list of passes for the geometry. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Delegate\-Pass (vtk\-Render\-Pass delegate\-Pass)} -\/ Delegate for rendering the geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Sequence\-Pass with a vtk\-Ligths\-Pass and a list of passes for the geometry. Initial value is a N\-U\-L\-L pointer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcellcenterdepthsort}{}\section{vtk\-Cell\-Center\-Depth\-Sort}\label{vtkrendering_vtkcellcenterdepthsort}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cell\-Center\-Depth\-Sort is a simple and fast implementation of depth sort, but it only provides approximate results. The sorting algorithm finds the centroids of all the cells. It then performs the dot product of the centroids against a vector pointing in the direction of the camera transformed into object space. It then performs an ordinary sort on the result.

To create an instance of class vtk\-Cell\-Center\-Depth\-Sort, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCellCenterDepthSort
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cell\-Center\-Depth\-Sort 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\-Cell\-Center\-Depth\-Sort class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cell\-Center\-Depth\-Sort = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cell\-Center\-Depth\-Sort = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Init\-Traversal ()}  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-Get\-Next\-Cells ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcellpicker}{}\section{vtk\-Cell\-Picker}\label{vtkrendering_vtkcellpicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Cell\-Picker will shoot a ray into a 3\-D scene and return information about the first object that the ray hits. It works for all Prop3\-Ds. For vtk\-Volume objects, it shoots a ray into the volume and returns the point where the ray intersects an isosurface of a chosen opacity. For vtk\-Image\-Actor objects, it intersects the ray with the displayed slice. For vtk\-Actor objects, it intersects the actor's polygons. If the object's mapper has Clipping\-Planes, then it takes the clipping into account, and will return the Id of the clipping plane that was intersected. For all prop types, it returns point and cell information, plus the normal of the surface that was intersected at the pick position. For volumes and images, it also returns (i,j,k) coordinates for the point and the cell that were picked.

To create an instance of class vtk\-Cell\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCellPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Cell\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Cell\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Cell\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Cell\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Pick (double selection\-X, double selection\-Y, double selection\-Z, vtk\-Renderer renderer)} -\/ Perform pick operation with selection point provided. Normally the first two values are the (x,y) pixel coordinates for the pick, and the third value is z=0. The return value will be non-\/zero if something was successfully picked.  
\item {\ttfamily obj.\-Add\-Locator (vtk\-Abstract\-Cell\-Locator locator)} -\/ Add a locator for one of the data sets that will be included in the scene. You must set up the locator with exactly the same data set that was input to the mapper of one or more of the actors in the scene. As well, you must either build the locator before doing the pick, or you must turn on Lazy\-Evaluation in the locator to make it build itself on the first pick. Note that if you try to add the same locator to the picker twice, the second addition will be ignored.  
\item {\ttfamily obj.\-Remove\-Locator (vtk\-Abstract\-Cell\-Locator locator)} -\/ Remove a locator that was previously added. If you try to remove a nonexistent locator, then nothing will happen and no errors will be raised.  
\item {\ttfamily obj.\-Remove\-All\-Locators ()} -\/ Remove all locators associated with this picker.  
\item {\ttfamily obj.\-Set\-Volume\-Opacity\-Isovalue (double )} -\/ Set the opacity isovalue to use for defining volume surfaces. The pick will occur at the location along the pick ray where the opacity of the volume is equal to this isovalue. If you want to do the pick based on an actual data isovalue rather than the opacity, then pass the data value through the scalar opacity function before using this method.  
\item {\ttfamily double = obj.\-Get\-Volume\-Opacity\-Isovalue ()} -\/ Set the opacity isovalue to use for defining volume surfaces. The pick will occur at the location along the pick ray where the opacity of the volume is equal to this isovalue. If you want to do the pick based on an actual data isovalue rather than the opacity, then pass the data value through the scalar opacity function before using this method.  
\item {\ttfamily obj.\-Set\-Use\-Volume\-Gradient\-Opacity (int )} -\/ Use the product of the scalar and gradient opacity functions when computing the opacity isovalue, instead of just using the scalar opacity. This parameter is only relevant to volume picking and is off by default.  
\item {\ttfamily obj.\-Use\-Volume\-Gradient\-Opacity\-On ()} -\/ Use the product of the scalar and gradient opacity functions when computing the opacity isovalue, instead of just using the scalar opacity. This parameter is only relevant to volume picking and is off by default.  
\item {\ttfamily obj.\-Use\-Volume\-Gradient\-Opacity\-Off ()} -\/ Use the product of the scalar and gradient opacity functions when computing the opacity isovalue, instead of just using the scalar opacity. This parameter is only relevant to volume picking and is off by default.  
\item {\ttfamily int = obj.\-Get\-Use\-Volume\-Gradient\-Opacity ()} -\/ Use the product of the scalar and gradient opacity functions when computing the opacity isovalue, instead of just using the scalar opacity. This parameter is only relevant to volume picking and is off by default.  
\item {\ttfamily obj.\-Set\-Pick\-Clipping\-Planes (int )} -\/ The Pick\-Clipping\-Planes setting controls how clipping planes are handled by the pick. If it is On, then the clipping planes become pickable objects, even though they are usually invisible. This means that if the pick ray intersects a clipping plane before it hits anything else, the pick will stop at that clipping plane. The Get\-Prop3\-D() and Get\-Mapper() methods will return the Prop3\-D and Mapper that the clipping plane belongs to. The Get\-Clipping\-Plane\-Id() method will return the index of the clipping plane so that you can retrieve it from the mapper, or -\/1 if no clipping plane was picked. The picking of vtk\-Image\-Actors is not influenced by this setting, since they have no clipping planes.  
\item {\ttfamily obj.\-Pick\-Clipping\-Planes\-On ()} -\/ The Pick\-Clipping\-Planes setting controls how clipping planes are handled by the pick. If it is On, then the clipping planes become pickable objects, even though they are usually invisible. This means that if the pick ray intersects a clipping plane before it hits anything else, the pick will stop at that clipping plane. The Get\-Prop3\-D() and Get\-Mapper() methods will return the Prop3\-D and Mapper that the clipping plane belongs to. The Get\-Clipping\-Plane\-Id() method will return the index of the clipping plane so that you can retrieve it from the mapper, or -\/1 if no clipping plane was picked. The picking of vtk\-Image\-Actors is not influenced by this setting, since they have no clipping planes.  
\item {\ttfamily obj.\-Pick\-Clipping\-Planes\-Off ()} -\/ The Pick\-Clipping\-Planes setting controls how clipping planes are handled by the pick. If it is On, then the clipping planes become pickable objects, even though they are usually invisible. This means that if the pick ray intersects a clipping plane before it hits anything else, the pick will stop at that clipping plane. The Get\-Prop3\-D() and Get\-Mapper() methods will return the Prop3\-D and Mapper that the clipping plane belongs to. The Get\-Clipping\-Plane\-Id() method will return the index of the clipping plane so that you can retrieve it from the mapper, or -\/1 if no clipping plane was picked. The picking of vtk\-Image\-Actors is not influenced by this setting, since they have no clipping planes.  
\item {\ttfamily int = obj.\-Get\-Pick\-Clipping\-Planes ()} -\/ The Pick\-Clipping\-Planes setting controls how clipping planes are handled by the pick. If it is On, then the clipping planes become pickable objects, even though they are usually invisible. This means that if the pick ray intersects a clipping plane before it hits anything else, the pick will stop at that clipping plane. The Get\-Prop3\-D() and Get\-Mapper() methods will return the Prop3\-D and Mapper that the clipping plane belongs to. The Get\-Clipping\-Plane\-Id() method will return the index of the clipping plane so that you can retrieve it from the mapper, or -\/1 if no clipping plane was picked. The picking of vtk\-Image\-Actors is not influenced by this setting, since they have no clipping planes.  
\item {\ttfamily int = obj.\-Get\-Clipping\-Plane\-Id ()} -\/ Get the index of the clipping plane that was intersected during the pick. This will be set regardless of whether Pick\-Clipping\-Planes is On, all that is required is that the pick intersected a clipping plane of the Prop3\-D that was picked. The result will be -\/1 if the Prop3\-D that was picked has no clipping planes, or if the ray didn't intersect the planes.  
\item {\ttfamily double = obj. Get\-Pick\-Normal ()} -\/ Return the normal of the picked surface at the Pick\-Position. If no surface was picked, then a vector pointing back at the camera is returned.  
\item {\ttfamily double = obj. Get\-Mapper\-Normal ()} -\/ Return the normal of the surface at the Pick\-Position in mapper coordinates. The result is undefined if no prop was picked.  
\item {\ttfamily int = obj. Get\-Point\-I\-J\-K ()} -\/ Get the structured coordinates of the point at the Pick\-Position. Only valid for image actors and volumes with vtk\-Image\-Data.  
\item {\ttfamily int = obj. Get\-Cell\-I\-J\-K ()} -\/ Get the structured coordinates of the cell at the Pick\-Position. Only valid for image actors and volumes with vtk\-Image\-Data. Combine this with the P\-Coords to get the position within the cell.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Id ()} -\/ Get the id of the picked point. If Point\-Id = -\/1, nothing was picked. This point will be a member of any cell that is picked.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Id ()} -\/ Get the id of the picked cell. If Cell\-Id = -\/1, nothing was picked.  
\item {\ttfamily int = obj.\-Get\-Sub\-Id ()} -\/ Get the sub\-Id of the picked cell. This is useful, for example, if the data is made of triangle strips. If Sub\-Id = -\/1, nothing was picked.  
\item {\ttfamily double = obj. Get\-P\-Coords ()} -\/ Get the parametric coordinates of the picked cell. Only valid if a prop was picked. The P\-Coords can be used to compute the weights that are needed to interpolate data values within the cell.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture ()} -\/ Get the texture that was picked. This will always be set if the picked prop has a texture, and will always be null otherwise.  
\item {\ttfamily obj.\-Set\-Pick\-Texture\-Data (int )} -\/ If this is \char`\"{}\-On\char`\"{} and if the picked prop has a texture, then the data returned by Get\-Data\-Set() will be the texture's data instead of the mapper's data. The Get\-Point\-Id(), Get\-Cell\-Id(), Get\-P\-Coords() etc. will all return information for use with the texture's data. If the picked prop does not have any texture, then Get\-Data\-Set() will return the mapper's data instead and Get\-Point\-Id() etc. will return information related to the mapper's data. The default value of Pick\-Texture\-Data is \char`\"{}\-Off\char`\"{}.  
\item {\ttfamily obj.\-Pick\-Texture\-Data\-On ()} -\/ If this is \char`\"{}\-On\char`\"{} and if the picked prop has a texture, then the data returned by Get\-Data\-Set() will be the texture's data instead of the mapper's data. The Get\-Point\-Id(), Get\-Cell\-Id(), Get\-P\-Coords() etc. will all return information for use with the texture's data. If the picked prop does not have any texture, then Get\-Data\-Set() will return the mapper's data instead and Get\-Point\-Id() etc. will return information related to the mapper's data. The default value of Pick\-Texture\-Data is \char`\"{}\-Off\char`\"{}.  
\item {\ttfamily obj.\-Pick\-Texture\-Data\-Off ()} -\/ If this is \char`\"{}\-On\char`\"{} and if the picked prop has a texture, then the data returned by Get\-Data\-Set() will be the texture's data instead of the mapper's data. The Get\-Point\-Id(), Get\-Cell\-Id(), Get\-P\-Coords() etc. will all return information for use with the texture's data. If the picked prop does not have any texture, then Get\-Data\-Set() will return the mapper's data instead and Get\-Point\-Id() etc. will return information related to the mapper's data. The default value of Pick\-Texture\-Data is \char`\"{}\-Off\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Pick\-Texture\-Data ()} -\/ If this is \char`\"{}\-On\char`\"{} and if the picked prop has a texture, then the data returned by Get\-Data\-Set() will be the texture's data instead of the mapper's data. The Get\-Point\-Id(), Get\-Cell\-Id(), Get\-P\-Coords() etc. will all return information for use with the texture's data. If the picked prop does not have any texture, then Get\-Data\-Set() will return the mapper's data instead and Get\-Point\-Id() etc. will return information related to the mapper's data. The default value of Pick\-Texture\-Data is \char`\"{}\-Off\char`\"{}.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkchooserpainter}{}\section{vtk\-Chooser\-Painter}\label{vtkrendering_vtkchooserpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter does not actually do any painting. Instead, it picks other painters based on the current state of itself and its poly data. It then delegates the work to these other painters.

To create an instance of class vtk\-Chooser\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkChooserPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Chooser\-Painter 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\-Chooser\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Chooser\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Chooser\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Vert\-Painter (vtk\-Poly\-Data\-Painter )}  
\item {\ttfamily obj.\-Set\-Line\-Painter (vtk\-Poly\-Data\-Painter )}  
\item {\ttfamily obj.\-Set\-Poly\-Painter (vtk\-Poly\-Data\-Painter )}  
\item {\ttfamily obj.\-Set\-Strip\-Painter (vtk\-Poly\-Data\-Painter )}  
\item {\ttfamily obj.\-Set\-Use\-Lines\-Painter\-For\-Wireframes (int )} -\/ When set, the lines painter is used for drawing wireframes (off by default, except on Mac, where it's on by default).  
\item {\ttfamily int = obj.\-Get\-Use\-Lines\-Painter\-For\-Wireframes ()} -\/ When set, the lines painter is used for drawing wireframes (off by default, except on Mac, where it's on by default).  
\item {\ttfamily obj.\-Use\-Lines\-Painter\-For\-Wireframes\-On ()} -\/ When set, the lines painter is used for drawing wireframes (off by default, except on Mac, where it's on by default).  
\item {\ttfamily obj.\-Use\-Lines\-Painter\-For\-Wireframes\-Off ()} -\/ When set, the lines painter is used for drawing wireframes (off by default, except on Mac, where it's on by default).  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkclearzpass}{}\section{vtk\-Clear\-Z\-Pass}\label{vtkrendering_vtkclearzpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Clear the depth buffer with a given value.

To create an instance of class vtk\-Clear\-Z\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClearZPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Clear\-Z\-Pass 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\-Clear\-Z\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Clear\-Z\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Clear\-Z\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Depth (double )} -\/ Set/\-Get the depth value. Initial value is 1.\-0 (farest).  
\item {\ttfamily double = obj.\-Get\-Depth\-Min\-Value ()} -\/ Set/\-Get the depth value. Initial value is 1.\-0 (farest).  
\item {\ttfamily double = obj.\-Get\-Depth\-Max\-Value ()} -\/ Set/\-Get the depth value. Initial value is 1.\-0 (farest).  
\item {\ttfamily double = obj.\-Get\-Depth ()} -\/ Set/\-Get the depth value. Initial value is 1.\-0 (farest).  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcoincidenttopologyresolutionpainter}{}\section{vtk\-Coincident\-Topology\-Resolution\-Painter}\label{vtkrendering_vtkcoincidenttopologyresolutionpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Provides the ability to shift the z-\/buffer to resolve coincident topology. For example, if you'd like to draw a mesh with some edges a different color, and the edges lie on the mesh, this feature can be useful to get nice looking lines.

To create an instance of class vtk\-Coincident\-Topology\-Resolution\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCoincidentTopologyResolutionPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Coincident\-Topology\-Resolution\-Painter 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\-Coincident\-Topology\-Resolution\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Coincident\-Topology\-Resolution\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Coincident\-Topology\-Resolution\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcolormaterialhelper}{}\section{vtk\-Color\-Material\-Helper}\label{vtkrendering_vtkcolormaterialhelper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Color\-Material\-Helper is a helper to assist in simulating the Color\-Material behaviour of the default Open\-G\-L pipeline. Look at vtk\-Color\-Material\-Helper\-\_\-s for available G\-L\-S\-L functions.

To create an instance of class vtk\-Color\-Material\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkColorMaterialHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Color\-Material\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Color\-Material\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Color\-Material\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Color\-Material\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Prepare\-For\-Rendering ()} -\/ Prepares the shader i.\-e. reads color material paramters state from Open\-G\-L. This must be called before the shader is bound.  
\item {\ttfamily obj.\-Render ()} -\/ Uploads any uniforms needed. This must be called only after the shader has been bound, but before rendering the geometry.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcompositepainter}{}\section{vtk\-Composite\-Painter}\label{vtkrendering_vtkcompositepainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Composite\-Painter iterates over the leaves in a composite datasets. This painter can also handle the case when the dataset is not a composite dataset.

To create an instance of class vtk\-Composite\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCompositePainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Composite\-Painter 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\-Composite\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Composite\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Composite\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()} -\/ Get the output data object from this painter. The default implementation simply forwards the input data object as the output.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcompositepolydatamapper}{}\section{vtk\-Composite\-Poly\-Data\-Mapper}\label{vtkrendering_vtkcompositepolydatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class uses a set of vtk\-Poly\-Data\-Mappers to render input data which may be hierarchical. The input to this mapper may be either vtk\-Poly\-Data or a vtk\-Composite\-Data\-Set built from polydata. If something other than vtk\-Poly\-Data is encountered, an error message will be produced.

To create an instance of class vtk\-Composite\-Poly\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCompositePolyDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Composite\-Poly\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Composite\-Poly\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Composite\-Poly\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Composite\-Poly\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor a)} -\/ Standard method for rendering a mapper. This method will be called by the actor.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release the underlying resources associated with this mapper  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcompositepolydatamapper2}{}\section{vtk\-Composite\-Poly\-Data\-Mapper2}\label{vtkrendering_vtkcompositepolydatamapper2}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Composite\-Poly\-Data\-Mapper2 is similar to vtk\-Composite\-Poly\-Data\-Mapper except that instead of creating individual mapper for each block in the composite dataset, it iterates over the blocks internally.

To create an instance of class vtk\-Composite\-Poly\-Data\-Mapper2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCompositePolyDataMapper2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Composite\-Poly\-Data\-Mapper2 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\-Composite\-Poly\-Data\-Mapper2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Composite\-Poly\-Data\-Mapper2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Composite\-Poly\-Data\-Mapper2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Piece (vtk\-Renderer ren, vtk\-Actor act)} -\/ Implemented by sub classes. Actual rendering is done here.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor act)} -\/ This calls Render\-Piece (in a for loop is streaming is necessary). Basically a reimplementation for vtk\-Poly\-Data\-Mapper\-::\-Render() since we don't want it to give up when vtk\-Composite\-Data\-Set is encountered.  
\item {\ttfamily obj.\-Set\-Color\-Blocks (int )} -\/ When set, each block is colored with a different color. Note that scalar coloring will be ignored.  
\item {\ttfamily int = obj.\-Get\-Color\-Blocks ()} -\/ When set, each block is colored with a different color. Note that scalar coloring will be ignored.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkculler}{}\section{vtk\-Culler}\label{vtkrendering_vtkculler}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
A culler has a cull method called by the vtk\-Renderer. The cull method is called before any rendering is performed, and it allows the culler to do some processing on the props and to modify their Allocated\-Render\-Time and re-\/order them in the prop list.

To create an instance of class vtk\-Culler, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCuller
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Culler 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\-Culler class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Culler = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Culler = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkcullercollection}{}\section{vtk\-Culler\-Collection}\label{vtkrendering_vtkcullercollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Culler\-Collection represents and provides methods to manipulate a list of Cullers (i.\-e., vtk\-Culler and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Culler\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCullerCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Culler\-Collection 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\-Culler\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Culler\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Culler\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Culler a)} -\/ Get the next Culler in the list.  
\item {\ttfamily vtk\-Culler = obj.\-Get\-Next\-Item ()} -\/ Get the last Culler in the list.  
\item {\ttfamily vtk\-Culler = obj.\-Get\-Last\-Item ()} -\/ Get the last Culler in the list.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdatasetmapper}{}\section{vtk\-Data\-Set\-Mapper}\label{vtkrendering_vtkdatasetmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Set\-Mapper is a mapper to map data sets (i.\-e., vtk\-Data\-Set and all derived classes) to graphics primitives. The mapping procedure is as follows\-: all 0\-D, 1\-D, and 2\-D cells are converted into points, lines, and polygons/triangle strips and then mapped to the graphics system. The 2\-D faces of 3\-D cells are mapped only if they are used by only one cell, i.\-e., on the boundary of the data set.

To create an instance of class vtk\-Data\-Set\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataSetMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Set\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Set\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Set\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Set\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor act)}  
\item {\ttfamily vtk\-Poly\-Data\-Mapper = obj.\-Get\-Poly\-Data\-Mapper ()} -\/ Get the internal poly data mapper used to map data set to graphics system.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the mtime also considering the lookup table.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set input)} -\/ Set the Input of this mapper.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Set the Input of this mapper.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdatatransferhelper}{}\section{vtk\-Data\-Transfer\-Helper}\label{vtkrendering_vtkdatatransferhelper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Data\-Transfer\-Helper is a helper class that aids in transferring data between the C\-P\-U memory and the G\-P\-U memory. The data in G\-P\-U memory is stored as textures which that in C\-P\-U memory is stored as vtk\-Data\-Array. vtk\-Data\-Transfer\-Helper provides A\-P\-I to transfer only a sub-\/extent of C\-P\-U structured data to/from the G\-P\-U.

To create an instance of class vtk\-Data\-Transfer\-Helper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDataTransferHelper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Data\-Transfer\-Helper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Data\-Transfer\-Helper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Data\-Transfer\-Helper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Data\-Transfer\-Helper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily 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.  
\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.  
\item {\ttfamily obj.\-Set\-C\-P\-U\-Extent (int , int , int , int , int , int )} -\/ Set the C\-P\-U data extent. The extent matches the vtk\-Data\-Array size. If the vtk\-Data\-Array comes from an vtk\-Image\-Data and it is part of the point data, it is usually the vtk\-Image\-Data extent. It can be on cell data too, but in this case it does not match the vtk\-Image\-Data extent. If the vtk\-Data\-Array comes from a vtk\-Data\-Set, just set it to a one-\/dimenstional extent equal to the number of tuples. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily obj.\-Set\-C\-P\-U\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the C\-P\-U data extent. The extent matches the vtk\-Data\-Array size. If the vtk\-Data\-Array comes from an vtk\-Image\-Data and it is part of the point data, it is usually the vtk\-Image\-Data extent. It can be on cell data too, but in this case it does not match the vtk\-Image\-Data extent. If the vtk\-Data\-Array comes from a vtk\-Data\-Set, just set it to a one-\/dimenstional extent equal to the number of tuples. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily int = obj. Get\-C\-P\-U\-Extent ()} -\/ Set the C\-P\-U data extent. The extent matches the vtk\-Data\-Array size. If the vtk\-Data\-Array comes from an vtk\-Image\-Data and it is part of the point data, it is usually the vtk\-Image\-Data extent. It can be on cell data too, but in this case it does not match the vtk\-Image\-Data extent. If the vtk\-Data\-Array comes from a vtk\-Data\-Set, just set it to a one-\/dimenstional extent equal to the number of tuples. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily obj.\-Set\-G\-P\-U\-Extent (int , int , int , int , int , int )} -\/ Set the G\-P\-U data extent. This is the sub-\/extent to copy from or to the G\-P\-U. This extent matches the size of the data to transfer. G\-P\-U\-Extent and Texture\-Extent don't have to match (G\-P\-U\-Extent can be 1\-D whereas Texture\-Extent is 2\-D) but the number of elements have to match. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily obj.\-Set\-G\-P\-U\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the G\-P\-U data extent. This is the sub-\/extent to copy from or to the G\-P\-U. This extent matches the size of the data to transfer. G\-P\-U\-Extent and Texture\-Extent don't have to match (G\-P\-U\-Extent can be 1\-D whereas Texture\-Extent is 2\-D) but the number of elements have to match. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily int = obj. Get\-G\-P\-U\-Extent ()} -\/ Set the G\-P\-U data extent. This is the sub-\/extent to copy from or to the G\-P\-U. This extent matches the size of the data to transfer. G\-P\-U\-Extent and Texture\-Extent don't have to match (G\-P\-U\-Extent can be 1\-D whereas Texture\-Extent is 2\-D) but the number of elements have to match. Initial value is (0,0,0,0,0,0), a valid one tuple array.  
\item {\ttfamily obj.\-Set\-Texture\-Extent (int , int , int , int , int , int )} -\/ Set the texture data extent. This is the extent of the texture image that will receive the data. This extent matches the size of the data to transfer. If it is set to an invalid extent, G\-P\-U\-Extent is used. See more comment on G\-P\-U\-Extent. Initial value is an invalid extent.  
\item {\ttfamily obj.\-Set\-Texture\-Extent (int a\mbox{[}6\mbox{]})} -\/ Set the texture data extent. This is the extent of the texture image that will receive the data. This extent matches the size of the data to transfer. If it is set to an invalid extent, G\-P\-U\-Extent is used. See more comment on G\-P\-U\-Extent. Initial value is an invalid extent.  
\item {\ttfamily int = obj. Get\-Texture\-Extent ()} -\/ Set the texture data extent. This is the extent of the texture image that will receive the data. This extent matches the size of the data to transfer. If it is set to an invalid extent, G\-P\-U\-Extent is used. See more comment on G\-P\-U\-Extent. Initial value is an invalid extent.  
\item {\ttfamily bool = obj.\-Get\-Extent\-Is\-Valid (int extent)} -\/ Tells if the given extent (6 int) is valid. True if min extent$<$=max extent. \begin{DoxyPrecond}{Precondition}
extent\-\_\-exists\-: extent!=0  
\end{DoxyPrecond}

\item {\ttfamily bool = obj.\-Get\-C\-P\-U\-Extent\-Is\-Valid ()} -\/ Tells if C\-P\-U\-Extent is valid. True if min extent$<$=max extent.  
\item {\ttfamily bool = obj.\-Get\-G\-P\-U\-Extent\-Is\-Valid ()} -\/ Tells if G\-P\-U\-Extent is valid. True if min extent$<$=max extent.  
\item {\ttfamily bool = obj.\-Get\-Texture\-Extent\-Is\-Valid ()} -\/ Tells if Texture\-Extent is valid. True if min extent$<$=max extent.  
\item {\ttfamily obj.\-Set\-Min\-Texture\-Dimension (int )} -\/ Define the minimal dimension of the texture regardless of the dimensions of the Texture\-Extent. Initial value is 1. A texture extent can have a given dimension 0\-D (one value), 1\-D, 2\-D or 3\-D. By default 0\-D and 1\-D are translated into a 1\-D texture, 2\-D is translated into a 2\-D texture, 3\-D is translated into a 3\-D texture. To make life easier when writting G\-L\-S\-L code and use only one type of sampler (ex\-: sampler2d), the default behavior can be changed by forcing a type of texture with this ivar. 1\-: default behavior. Initial value. 2\-: force 0\-D and 1\-D to be in a 2\-D texture 3\-: force 0\-D, 1\-D and 2\-D texture to be in a 3\-D texture.  
\item {\ttfamily int = obj.\-Get\-Min\-Texture\-Dimension ()} -\/ Define the minimal dimension of the texture regardless of the dimensions of the Texture\-Extent. Initial value is 1. A texture extent can have a given dimension 0\-D (one value), 1\-D, 2\-D or 3\-D. By default 0\-D and 1\-D are translated into a 1\-D texture, 2\-D is translated into a 2\-D texture, 3\-D is translated into a 3\-D texture. To make life easier when writting G\-L\-S\-L code and use only one type of sampler (ex\-: sampler2d), the default behavior can be changed by forcing a type of texture with this ivar. 1\-: default behavior. Initial value. 2\-: force 0\-D and 1\-D to be in a 2\-D texture 3\-: force 0\-D, 1\-D and 2\-D texture to be in a 3\-D texture.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Array ()} -\/ Get/\-Set the C\-P\-U data buffer. Initial value is 0.  
\item {\ttfamily obj.\-Set\-Array (vtk\-Data\-Array array)} -\/ Get/\-Set the C\-P\-U data buffer. Initial value is 0.  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Get\-Texture ()} -\/ Get/\-Set the G\-P\-U data buffer. Initial value is 0.  
\item {\ttfamily obj.\-Set\-Texture (vtk\-Texture\-Object texture)} -\/ Get/\-Set the G\-P\-U data buffer. Initial value is 0.  
\item {\ttfamily bool = obj.\-Upload (int components, int component\-List\-N\-U\-L\-L)} -\/ Old comment. Upload Extent from C\-P\-U data buffer to G\-P\-U. The Whole\-Extent must match the Array size. New comment. Upload G\-P\-U\-Extent from C\-P\-U vtk\-Data\-Array to G\-P\-U texture. It is possible to send a subset of the components or to specify and order of components or both. If components=0, component\-List is ignored and all components are passed, a texture cannot have more than 4 components. \begin{DoxyPrecond}{Precondition}
array\-\_\-exists\-: array!=0 

array\-\_\-not\-\_\-empty\-: array-\/$>$Get\-Number\-Of\-Tuples()$>$0 

valid\-\_\-cpu\-\_\-extent\-: this-\/$>$Get\-C\-P\-U\-Extent\-Is\-Valid() 

valid\-\_\-cpu\-\_\-extent\-\_\-size\-: (C\-P\-U\-Extent\mbox{[}1\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}0\mbox{]}+1)$\ast$(C\-P\-U\-Extent\mbox{[}3\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}2\mbox{]}+1)$\ast$(C\-P\-U\-Extent\mbox{[}5\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}4\mbox{]}+1)==array-\/$>$Get\-Number\-Of\-Tuples() 

valid\-\_\-gpu\-\_\-extent\-: this-\/$>$Get\-G\-P\-U\-Extent\-Is\-Valid() 

gpu\-\_\-extent\-\_\-in\-\_\-cpu\-\_\-extent\-: C\-P\-U\-Extent\mbox{[}0\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}0\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}1\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}1\mbox{]} \&\& C\-P\-U\-Extent\mbox{[}2\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}2\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}3\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}3\mbox{]} \&\& C\-P\-U\-Extent\mbox{[}4\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}4\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}5\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}5\mbox{]} 

gpu\-\_\-texture\-\_\-size\-: !this-\/$>$Get\-Texture\-Extent\-Is\-Valid() $|$$|$ (G\-P\-U\-Extent\mbox{[}1\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}0\mbox{]}+1)$\ast$(G\-P\-U\-Extent\mbox{[}3\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}2\mbox{]}+1)$\ast$(G\-P\-U\-Extent\mbox{[}5\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}4\mbox{]}+1)==(Texture\-Extent\mbox{[}1\mbox{]}-\/\-Texture\-Extent\mbox{[}0\mbox{]}+1)$\ast$(Texture\-Extent\mbox{[}3\mbox{]}-\/\-Texture\-Extent\mbox{[}2\mbox{]}+1)$\ast$(Texture\-Extent\mbox{[}5\mbox{]}-\/\-Texture\-Extent\mbox{[}4\mbox{]}+1) 

texture\-\_\-can\-\_\-exist\-\_\-or\-\_\-not\-: texture==0 $|$$|$ texture!=0 

valid\-\_\-components\-: (components==0 \&\& component\-List==0 \&\& array-\/$>$Get\-Number\-Of\-Components()$<$=4) $|$$|$ (components$>$=1 \&\& components$<$=array-\/$>$Get\-Number\-Of\-Components() \&\& components$<$=4 \&\& component\-List!=0)  
\end{DoxyPrecond}

\item {\ttfamily bool = obj.\-Download ()} -\/ old comment\-: Downlad Extent from G\-P\-U data buffer to C\-P\-U. G\-P\-U data size must exactly match Extent. C\-P\-U data buffer will be resized to match Whole\-Extent in which only the Extent will be filled with the G\-P\-U data. new comment\-: Download G\-P\-U\-Extent from G\-P\-U texture to C\-P\-U vtk\-Data\-Array. If Array is not provided, it will be created with the size of C\-P\-U\-Extent. But only the tuples covered by G\-P\-U\-Extent will be download. In this case, if G\-P\-U\-Extent does not cover all G\-P\-U\-Extent, some of the vtk\-Data\-Array will be uninitialized. Reminder\-: A=$>$B $<$=$>$ !\-A$|$$|$\-B \begin{DoxyPrecond}{Precondition}
texture\-\_\-exists\-: texture!=0 

array\-\_\-not\-\_\-empty\-: array==0 $|$$|$ array-\/$>$Get\-Number\-Of\-Tuples()$>$0 

valid\-\_\-cpu\-\_\-extent\-: this-\/$>$Get\-C\-P\-U\-Extent\-Is\-Valid() 

valid\-\_\-cpu\-\_\-extent\-\_\-size\-: array==0 $|$$|$ (C\-P\-U\-Extent\mbox{[}1\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}0\mbox{]}+1)$\ast$(C\-P\-U\-Extent\mbox{[}3\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}2\mbox{]}+1)$\ast$(C\-P\-U\-Extent\mbox{[}5\mbox{]}-\/\-C\-P\-U\-Extent\mbox{[}4\mbox{]}+1)==array-\/$>$Get\-Number\-Of\-Tuples() 

valid\-\_\-gpu\-\_\-extent\-: this-\/$>$Get\-G\-P\-U\-Extent\-Is\-Valid() 

gpu\-\_\-extent\-\_\-in\-\_\-cpu\-\_\-extent\-: C\-P\-U\-Extent\mbox{[}0\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}0\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}1\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}1\mbox{]} \&\& C\-P\-U\-Extent\mbox{[}2\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}2\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}3\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}3\mbox{]} \&\& C\-P\-U\-Extent\mbox{[}4\mbox{]}$<$=G\-P\-U\-Extent\mbox{[}4\mbox{]} \&\& G\-P\-U\-Extent\mbox{[}5\mbox{]}$<$=C\-P\-U\-Extent\mbox{[}5\mbox{]} 

gpu\-\_\-texture\-\_\-size\-: !this-\/$>$Get\-Texture\-Extent\-Is\-Valid() $|$$|$ (G\-P\-U\-Extent\mbox{[}1\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}0\mbox{]}+1)$\ast$(G\-P\-U\-Extent\mbox{[}3\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}2\mbox{]}+1)$\ast$(G\-P\-U\-Extent\mbox{[}5\mbox{]}-\/\-G\-P\-U\-Extent\mbox{[}4\mbox{]}+1)==(Texture\-Extent\mbox{[}1\mbox{]}-\/\-Texture\-Extent\mbox{[}0\mbox{]}+1)$\ast$(Texture\-Extent\mbox{[}3\mbox{]}-\/\-Texture\-Extent\mbox{[}2\mbox{]}+1)$\ast$(Texture\-Extent\mbox{[}5\mbox{]}-\/\-Texture\-Extent\mbox{[}4\mbox{]}+1) 

valid\-\_\-components\-: array==0 $|$$|$ array-\/$>$Get\-Number\-Of\-Components()$<$=4 

components\-\_\-match\-: array==0 $|$$|$ (texture-\/$>$Get\-Components()==array-\/$>$Get\-Number\-Of\-Components())  
\end{DoxyPrecond}

\item {\ttfamily bool = obj.\-Download\-Async1 ()} -\/ Splits the download in two operations Asynchronously download from texture memory to P\-B\-O (Download\-Async1()). Copy from pbo to user array (Download\-Async2()).  
\item {\ttfamily bool = obj.\-Download\-Async2 ()} -\/ Splits the download in two operations Asynchronously download from texture memory to P\-B\-O (Download\-Async1()). Copy from pbo to user array (Download\-Async2()).  
\item {\ttfamily bool = obj.\-Get\-Shader\-Supports\-Texture\-Int ()}  
\item {\ttfamily obj.\-Set\-Shader\-Supports\-Texture\-Int (bool value)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdefaultpainter}{}\section{vtk\-Default\-Painter}\label{vtkrendering_vtkdefaultpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter does not do any actual rendering. Sets up a default pipeline of painters to mimick the behaiour of old vtk\-Poly\-Data\-Mapper. The chain is as follows\-: input--$>$ vtk\-Scalars\-To\-Colors\-Painter --$>$ vtk\-Clip\-Planes\-Painter --$>$ vtk\-Display\-List\-Painter --$>$ vtk\-Composite\-Painter --$>$ vtk\-Coincident\-Topology\-Resolution\-Painter --$>$ vtk\-Lighting\-Painter --$>$ vtk\-Representation\-Painter --$>$ $<$Delegate of vtk\-Default\-Painter$>$. Typically, the delegate of the default painter be one that is capable of r rendering graphics primitives or a vtk\-Chooser\-Painter which can select appropriate painters to do the rendering.

To create an instance of class vtk\-Default\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDefaultPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Default\-Painter 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\-Default\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Default\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Default\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Scalars\-To\-Colors\-Painter (vtk\-Scalars\-To\-Colors\-Painter )} -\/ Get/\-Set the painter that maps scalars to colors.  
\item {\ttfamily vtk\-Scalars\-To\-Colors\-Painter = obj.\-Get\-Scalars\-To\-Colors\-Painter ()} -\/ Get/\-Set the painter that maps scalars to colors.  
\item {\ttfamily obj.\-Set\-Clip\-Planes\-Painter (vtk\-Clip\-Planes\-Painter )} -\/ Get/\-Set the painter that handles clipping.  
\item {\ttfamily vtk\-Clip\-Planes\-Painter = obj.\-Get\-Clip\-Planes\-Painter ()} -\/ Get/\-Set the painter that handles clipping.  
\item {\ttfamily obj.\-Set\-Display\-List\-Painter (vtk\-Display\-List\-Painter )} -\/ Get/\-Set the painter that builds display lists.  
\item {\ttfamily vtk\-Display\-List\-Painter = obj.\-Get\-Display\-List\-Painter ()} -\/ Get/\-Set the painter that builds display lists.  
\item {\ttfamily obj.\-Set\-Composite\-Painter (vtk\-Composite\-Painter )} -\/ Get/\-Set the painter used to handle composite datasets.  
\item {\ttfamily vtk\-Composite\-Painter = obj.\-Get\-Composite\-Painter ()} -\/ Get/\-Set the painter used to handle composite datasets.  
\item {\ttfamily obj.\-Set\-Coincident\-Topology\-Resolution\-Painter (vtk\-Coincident\-Topology\-Resolution\-Painter )} -\/ Painter used to resolve coincident topology.  
\item {\ttfamily vtk\-Coincident\-Topology\-Resolution\-Painter = obj.\-Get\-Coincident\-Topology\-Resolution\-Painter ()} -\/ Painter used to resolve coincident topology.  
\item {\ttfamily obj.\-Set\-Lighting\-Painter (vtk\-Lighting\-Painter )} -\/ Get/\-Set the painter that controls lighting.  
\item {\ttfamily vtk\-Lighting\-Painter = obj.\-Get\-Lighting\-Painter ()} -\/ Get/\-Set the painter that controls lighting.  
\item {\ttfamily obj.\-Set\-Representation\-Painter (vtk\-Representation\-Painter )} -\/ Painter used to convert polydata to Wireframe/\-Points representation.  
\item {\ttfamily vtk\-Representation\-Painter = obj.\-Get\-Representation\-Painter ()} -\/ Painter used to convert polydata to Wireframe/\-Points representation.  
\item {\ttfamily obj.\-Set\-Delegate\-Painter (vtk\-Painter )} -\/ Set/\-Get the painter to which this painter should propagare its draw calls. These methods are overridden so that the delegate is set to the end of the Painter Chain.  
\item {\ttfamily vtk\-Painter = obj.\-Get\-Delegate\-Painter ()} -\/ Overridden to setup the chain of painter depending on the actor representation. The chain is rebuilt if this-\/$>$M\-Time has changed since last Build\-Painter\-Chain(); Building of the chain does not depend on input polydata, hence it does not check if the input has changed at all.  
\item {\ttfamily obj.\-Render (vtk\-Renderer renderer, vtk\-Actor actor, long typeflags, bool force\-Compile\-Only)} -\/ Overridden to setup the chain of painter depending on the actor representation. The chain is rebuilt if this-\/$>$M\-Time has changed since last Build\-Painter\-Chain(); Building of the chain does not depend on input polydata, hence it does not check if the input has changed at all.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this painter. The parameter window could be used to determine which graphic resources to release. The call is propagated to the delegate painter, if any.  
\item {\ttfamily obj.\-Update\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Expand or shrink the estimated bounds based on the geometric transformations applied in the painter. The bounds are left unchanged if the painter does not change the geometry.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdefaultpass}{}\section{vtk\-Default\-Pass}\label{vtkrendering_vtkdefaultpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Default\-Pass implements the basic standard render passes of V\-T\-K. Subclasses can easily be implemented by reusing some parts of the basic implementation.

It implements classic Render operations as well as versions with property key checking.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color.

To create an instance of class vtk\-Default\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDefaultPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Default\-Pass 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\-Default\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Default\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Default\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdepthpeelingpass}{}\section{vtk\-Depth\-Peeling\-Pass}\label{vtkrendering_vtkdepthpeelingpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Render the translucent polygonal geometry of a scene without sorting polygons in the view direction.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color. An opaque pass may have been performed right after the initialization.

The depth peeling algorithm works by rendering the translucent polygonal geometry multiple times (once for each peel). The actually rendering of the translucent polygonal geometry is peformed by its delegate Translucent\-Pass. This delegate is therefore used multiple times.

Its delegate is usually set to a vtk\-Translucent\-Pass.

To create an instance of class vtk\-Depth\-Peeling\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDepthPeelingPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Depth\-Peeling\-Pass 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\-Peeling\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Depth\-Peeling\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Depth\-Peeling\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Translucent\-Pass ()} -\/ Delegate for rendering the translucent polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Translucent\-Pass (vtk\-Render\-Pass translucent\-Pass)} -\/ Delegate for rendering the translucent polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Occlusion\-Ratio (double )} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio\-Min\-Value ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio\-Max\-Value ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Peels (int )} -\/ In case of depth peeling, define the maximum number of peeling layers. Initial value is 4. A special value of 0 means no maximum limit. It has to be a positive value.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Peels ()} -\/ In case of depth peeling, define the maximum number of peeling layers. Initial value is 4. A special value of 0 means no maximum limit. It has to be a positive value.  
\item {\ttfamily bool = obj.\-Get\-Last\-Rendering\-Used\-Depth\-Peeling ()} -\/ Tells if the last time this pass was executed, the depth peeling algorithm was actually used. Initial value is false.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdistancetocamera}{}\section{vtk\-Distance\-To\-Camera}\label{vtkrendering_vtkdistancetocamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter adds a double array containing the distance from each point to the camera. If Scaling is on, it will use the values in the input array to process in order to scale the size of the points. Screen\-Size sets the size in screen pixels that you would want a rendered rectangle at that point to be, if it was scaled by the output array.

To create an instance of class vtk\-Distance\-To\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDistanceToCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Distance\-To\-Camera 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\-Distance\-To\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Distance\-To\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Distance\-To\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ The renderer which will ultimately render these points.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ The renderer which will ultimately render these points.  
\item {\ttfamily obj.\-Set\-Screen\-Size (double )} -\/ The desired screen size obtained by scaling glyphs by the distance array. It assumes the glyph at each point will be unit size.  
\item {\ttfamily double = obj.\-Get\-Screen\-Size ()} -\/ The desired screen size obtained by scaling glyphs by the distance array. It assumes the glyph at each point will be unit size.  
\item {\ttfamily obj.\-Set\-Scaling (bool )} -\/ Whether to scale the distance by the input array to process.  
\item {\ttfamily bool = obj.\-Get\-Scaling ()} -\/ Whether to scale the distance by the input array to process.  
\item {\ttfamily obj.\-Scaling\-On ()} -\/ Whether to scale the distance by the input array to process.  
\item {\ttfamily obj.\-Scaling\-Off ()} -\/ Whether to scale the distance by the input array to process.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ The modified time of this filter.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkdummygpuinfolist}{}\section{vtk\-Dummy\-G\-P\-U\-Info\-List}\label{vtkrendering_vtkdummygpuinfolist}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Dummy\-G\-P\-U\-Info\-List implements Probe() by just setting the count of G\-P\-Us to be zero. Useful when an O\-S specific implementation is not available.

To create an instance of class vtk\-Dummy\-G\-P\-U\-Info\-List, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDummyGPUInfoList
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dummy\-G\-P\-U\-Info\-List 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\-Dummy\-G\-P\-U\-Info\-List class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Dummy\-G\-P\-U\-Info\-List = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Dummy\-G\-P\-U\-Info\-List = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Probe ()} -\/ Build the list of vtk\-Info\-G\-P\-U if not done yet. \begin{DoxyPostcond}{Postcondition}
probed\-: Is\-Probed()  
\end{DoxyPostcond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkdynamic2dlabelmapper}{}\section{vtk\-Dynamic2\-D\-Label\-Mapper}\label{vtkrendering_vtkdynamic2dlabelmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Dynamic2\-D\-Label\-Mapper is a mapper that renders text at dataset points such that the labels do not overlap. Various items can be labeled including point ids, scalars, vectors, normals, texture coordinates, tensors, and field data components. This mapper assumes that the points are located on the x-\/y plane and that the camera remains perpendicular to that plane with a y-\/up axis (this can be constrained using vtk\-Image\-Interactor). On the first render, the mapper computes the visiblility of all labels at all scales, and queries this information on successive renders. This causes the first render to be much slower. The visibility algorithm is a greedy approach based on the point id, so the label for a point will be drawn unless the label for a point with lower id overlaps it.

To create an instance of class vtk\-Dynamic2\-D\-Label\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDynamic2DLabelMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dynamic2\-D\-Label\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Dynamic2\-D\-Label\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Instantiate object with \%\%-\/\#6.\-3g label format. By default, point ids are labeled.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Instantiate object with \%\%-\/\#6.\-3g label format. By default, point ids are labeled.  
\item {\ttfamily vtk\-Dynamic2\-D\-Label\-Mapper = obj.\-New\-Instance ()} -\/ Instantiate object with \%\%-\/\#6.\-3g label format. By default, point ids are labeled.  
\item {\ttfamily vtk\-Dynamic2\-D\-Label\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Instantiate object with \%\%-\/\#6.\-3g label format. By default, point ids are labeled.  
\item {\ttfamily obj.\-Set\-Priority\-Array\-Name (string name)} -\/ Set the points array name to use to give priority to labels. Defaults to \char`\"{}priority\char`\"{}.  
\item {\ttfamily obj.\-Set\-Reverse\-Priority (bool )} -\/ Whether to reverse the priority order (i.\-e. low values have high priority). Default is off.  
\item {\ttfamily bool = obj.\-Get\-Reverse\-Priority ()} -\/ Whether to reverse the priority order (i.\-e. low values have high priority). Default is off.  
\item {\ttfamily obj.\-Reverse\-Priority\-On ()} -\/ Whether to reverse the priority order (i.\-e. low values have high priority). Default is off.  
\item {\ttfamily obj.\-Reverse\-Priority\-Off ()} -\/ Whether to reverse the priority order (i.\-e. low values have high priority). Default is off.  
\item {\ttfamily obj.\-Set\-Label\-Height\-Padding (float )} -\/ Set the label height padding as a percentage. The percentage is a percentage of your label height. Default is 50\%.  
\item {\ttfamily float = obj.\-Get\-Label\-Height\-Padding ()} -\/ Set the label height padding as a percentage. The percentage is a percentage of your label height. Default is 50\%.  
\item {\ttfamily obj.\-Set\-Label\-Width\-Padding (float )} -\/ Set the label width padding as a percentage. The percentage is a percentage of your label $^\wedge$height$^\wedge$ (yes, not a typo). Default is 50\%.  
\item {\ttfamily float = obj.\-Get\-Label\-Width\-Padding ()} -\/ Set the label width padding as a percentage. The percentage is a percentage of your label $^\wedge$height$^\wedge$ (yes, not a typo). Default is 50\%.  
\item {\ttfamily obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw non-\/overlapping labels to the screen.  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw non-\/overlapping labels to the screen.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkexporter}{}\section{vtk\-Exporter}\label{vtkrendering_vtkexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Exporter is an abstract class that exports a scene to a file. It is very similar to vtk\-Writer except that a writer only writes out the geometric and topological data for an object, where an exporter can write out material properties, lighting, camera parameters etc. The concrete subclasses of this class may not write out all of this information. For example vtk\-O\-B\-J\-Exporter writes out Wavefront obj files which do not include support for camera parameters.

vtk\-Exporter provides the convenience methods Start\-Write() and End\-Write(). These methods are executed before and after execution of the Write() method. You can also specify arguments to these methods. This class defines Set\-Input and Get\-Input methods which take or return a vtk\-Render\-Window.

To create an instance of class vtk\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Write ()} -\/ Write data to output. Method executes subclasses Write\-Data() method, as well as Start\-Write() and End\-Write() methods.  
\item {\ttfamily obj.\-Update ()} -\/ Convenient alias for Write() method.  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window )} -\/ Set/\-Get the rendering window that contains the scene to be written.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Set/\-Get the rendering window that contains the scene to be written.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Render\-Window ren\-Win)} -\/ These methods are provided for backward compatibility. Will disappear soon.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Input ()} -\/ These methods are provided for backward compatibility. Will disappear soon.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Returns the M\-Time also considering the Render\-Window.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkfollower}{}\section{vtk\-Follower}\label{vtkrendering_vtkfollower}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Follower is a subclass of vtk\-Actor that always follows its specified camera. More specifically it will not change its position or scale, but it will continually update its orientation so that it is right side up and facing the camera. This is typically used for text labels in a scene. All of the adjustments that can be made to an actor also will take effect with a follower. So, if you change the orientation of the follower by 90 degrees, then it will follow the camera, but be off by 90 degrees.

To create an instance of class vtk\-Follower, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFollower
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Follower 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\-Follower class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Follower = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Follower = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Set/\-Get the camera to follow. If this is not set, then the follower won't know who to follow.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera to follow. If this is not set, then the follower won't know who to follow.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ This causes the actor to be rendered. It in turn will render the actor's property, texture map and then mapper. If a property hasn't been assigned, then the actor will create one automatically.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ This causes the actor to be rendered. It in turn will render the actor's property, texture map and then mapper. If a property hasn't been assigned, then the actor will create one automatically.  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren)} -\/ This causes the actor to be rendered. It in turn will render the actor's property, texture map and then mapper. If a property hasn't been assigned, then the actor will create one automatically.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Does this prop have some translucent polygonal geometry?  
\item {\ttfamily obj.\-Get\-Matrix (vtk\-Matrix4x4 m)} -\/ Copy the follower's composite 4x4 matrix into the matrix provided.  
\item {\ttfamily obj.\-Get\-Matrix (double m\mbox{[}16\mbox{]})} -\/ Copy the follower's composite 4x4 matrix into the matrix provided.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Matrix ()} -\/ Shallow copy of a follower. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of a follower. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkframebufferobject}{}\section{vtk\-Frame\-Buffer\-Object}\label{vtkrendering_vtkframebufferobject}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Encapsulates an Open\-G\-L Frame Buffer Object. For use by vtk\-Open\-G\-L\-F\-B\-O\-Render\-Window, not to be used directly.

To create an instance of class vtk\-Frame\-Buffer\-Object, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFrameBufferObject
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Frame\-Buffer\-Object 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\-Frame\-Buffer\-Object class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Frame\-Buffer\-Object = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Frame\-Buffer\-Object = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily 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.  
\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.  
\item {\ttfamily bool = obj.\-Start (int width, int height, bool shader\-Supports\-Texture\-Int)} -\/ User must take care that width/height match the dimensions of the user defined texture attachments. This method makes the \char`\"{}active buffers\char`\"{} the buffers that will get drawn into by subsequent drawing calls. Note that this does not clear the render buffers i.\-e. no gl\-Clear() calls are made by either of these methods. It's up to the caller to clear the buffers if needed.  
\item {\ttfamily bool = obj.\-Start\-Non\-Ortho (int width, int height, bool shader\-Supports\-Texture\-Int)} -\/ User must take care that width/height match the dimensions of the user defined texture attachments. This method makes the \char`\"{}active buffers\char`\"{} the buffers that will get drawn into by subsequent drawing calls. Note that this does not clear the render buffers i.\-e. no gl\-Clear() calls are made by either of these methods. It's up to the caller to clear the buffers if needed.  
\item {\ttfamily obj.\-Render\-Quad (int min\-X, int max\-X, int min\-Y, int max\-Y)} -\/ Renders a quad at the given location with pixel coordinates. This method is provided as a convenience, since we often render quads in a F\-B\-O. \begin{DoxyPrecond}{Precondition}
positive\-\_\-min\-X\-: min\-X$>$=0 

increasing\-\_\-x\-: min\-X$<$=max\-X 

valid\-\_\-max\-X\-: max\-X$<$Last\-Size\mbox{[}0\mbox{]} 

positive\-\_\-min\-Y\-: min\-Y$>$=0 

increasing\-\_\-y\-: min\-Y$<$=max\-Y 

valid\-\_\-max\-Y\-: max\-Y$<$Last\-Size\mbox{[}1\mbox{]}  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Bind ()} -\/ Save the current framebuffer and make the frame buffer active. Multiple calls to Bind has no effect.  
\item {\ttfamily obj.\-Un\-Bind ()} -\/ Restore the framebuffer saved with the call to Bind(). Multiple calls to Un\-Bind has no effect.  
\item {\ttfamily obj.\-Set\-Active\-Buffer (int index)} -\/ Choose the buffer to render into. This is available only if the G\-L\-\_\-\-A\-R\-B\-\_\-draw\-\_\-buffers extension is supported by the card.  
\item {\ttfamily obj.\-Set\-Active\-Buffers (int numbuffers, int indices\mbox{[}\mbox{]})} -\/ Choose the buffer to render into. This is available only if the G\-L\-\_\-\-A\-R\-B\-\_\-draw\-\_\-buffers extension is supported by the card.  
\item {\ttfamily obj.\-Set\-Color\-Buffer (int index, vtk\-Texture\-Object texture, int zslice)}  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Get\-Color\-Buffer (int index)}  
\item {\ttfamily obj.\-Remove\-Color\-Buffer (int index)}  
\item {\ttfamily obj.\-Remove\-All\-Color\-Buffers ()}  
\item {\ttfamily obj.\-Set\-Depth\-Buffer (vtk\-Texture\-Object depth\-Texture)} -\/ Set the texture to use as depth buffer.  
\item {\ttfamily obj.\-Remove\-Depth\-Buffer ()} -\/ Set the texture to use as depth buffer.  
\item {\ttfamily obj.\-Set\-Depth\-Buffer\-Needed (bool )} -\/ If true, the frame buffer object will be initialized with a depth buffer. Initial value is true.  
\item {\ttfamily bool = obj.\-Get\-Depth\-Buffer\-Needed ()} -\/ If true, the frame buffer object will be initialized with a depth buffer. Initial value is true.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Render\-Targets (int )} -\/ Set/\-Get the number of render targets to render into at once.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Render\-Targets ()} -\/ Set/\-Get the number of render targets to render into at once.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Active\-Targets ()} -\/ Returns the maximum number of targets that can be rendered to at one time. This limits the active targets set by Set\-Active\-Targets(). The return value is valid only if Get\-Context is non-\/null.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Render\-Targets ()} -\/ Returns the maximum number of render targets available. This limits the available attachement points for Set\-Color\-Attachment(). The return value is valid only if Get\-Context is non-\/null.  
\item {\ttfamily int = obj. Get\-Last\-Size ()} -\/ Dimensions in pixels of the framebuffer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkfreetypelabelrenderstrategy}{}\section{vtk\-Free\-Type\-Label\-Render\-Strategy}\label{vtkrendering_vtkfreetypelabelrenderstrategy}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Uses the Free\-Type to render labels and compute label sizes. This strategy may be used with vtk\-Label\-Placement\-Mapper.

To create an instance of class vtk\-Free\-Type\-Label\-Render\-Strategy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFreeTypeLabelRenderStrategy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Free\-Type\-Label\-Render\-Strategy 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\-Free\-Type\-Label\-Render\-Strategy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Free\-Type\-Label\-Render\-Strategy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Free\-Type\-Label\-Render\-Strategy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Supports\-Rotation ()} -\/ The free type render strategy currently does not support bounded size labels.  
\item {\ttfamily bool = obj.\-Supports\-Bounded\-Size ()} -\/ Release any graphics resources that are being consumed by this strategy. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window window)} -\/ Release any graphics resources that are being consumed by this strategy. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkfrustumcoverageculler}{}\section{vtk\-Frustum\-Coverage\-Culler}\label{vtkrendering_vtkfrustumcoverageculler}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Frustum\-Coverage\-Culler will cull props based on the coverage in the view frustum. The coverage is computed by enclosing the prop in a bounding sphere, projecting that to the viewing coordinate system, then taking a slice through the view frustum at the center of the sphere. This results in a circle on the plane slice through the view frustum. This circle is enclosed in a squared, and the fraction of the plane slice that this square covers is the coverage. This is a number between 0 and 1. If the number is less than the Minumum\-Coverage, the allocated render time for that prop is set to zero. If it is greater than the Maximum\-Coverage, the allocated render time is set to 1.\-0. In between, a linear ramp is used to convert coverage into allocated render time.

To create an instance of class vtk\-Frustum\-Coverage\-Culler, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFrustumCoverageCuller
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Frustum\-Coverage\-Culler 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\-Frustum\-Coverage\-Culler class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Frustum\-Coverage\-Culler = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Frustum\-Coverage\-Culler = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Minimum\-Coverage (double )} -\/ Set/\-Get the minimum coverage -\/ props with less coverage than this are given no time to render (they are culled)  
\item {\ttfamily double = obj.\-Get\-Minimum\-Coverage ()} -\/ Set/\-Get the minimum coverage -\/ props with less coverage than this are given no time to render (they are culled)  
\item {\ttfamily obj.\-Set\-Maximum\-Coverage (double )} -\/ Set/\-Get the maximum coverage -\/ props with more coverage than this are given an allocated render time of 1.\-0 (the maximum)  
\item {\ttfamily double = obj.\-Get\-Maximum\-Coverage ()} -\/ Set/\-Get the maximum coverage -\/ props with more coverage than this are given an allocated render time of 1.\-0 (the maximum)  
\item {\ttfamily obj.\-Set\-Sorting\-Style (int )} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily int = obj.\-Get\-Sorting\-Style\-Min\-Value ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily int = obj.\-Get\-Sorting\-Style\-Max\-Value ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily int = obj.\-Get\-Sorting\-Style ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily obj.\-Set\-Sorting\-Style\-To\-None ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily obj.\-Set\-Sorting\-Style\-To\-Back\-To\-Front ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily obj.\-Set\-Sorting\-Style\-To\-Front\-To\-Back ()} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\item {\ttfamily string = obj.\-Get\-Sorting\-Style\-As\-String (void )} -\/ Set the sorting style -\/ none, front-\/to-\/back or back-\/to-\/front The default is none  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgaussianblurpass}{}\section{vtk\-Gaussian\-Blur\-Pass}\label{vtkrendering_vtkgaussianblurpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Blur the image renderered by its delegate. Blurring uses a Gaussian low-\/pass filter with a 5x5 kernel.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color. An opaque pass may have been performed right after the initialization.

The delegate is used once.

Its delegate is usually set to a vtk\-Camera\-Pass or to a post-\/processing pass.

This pass requires a Open\-G\-L context that supports texture objects (T\-O), framebuffer objects (F\-B\-O) and G\-L\-S\-L. If not, it will emit an error message and will render its delegate and return.

.S\-E\-C\-T\-I\-O\-N Implementation As the filter is separable, it first blurs the image horizontally and then vertically. This reduces the number of texture sampling to 5 per pass. In addition, as texture sampling can already blend texel values in linear mode, by adjusting the texture coordinate accordingly, only 3 texture sampling are actually necessary. Reference\-: Open\-G\-L Bloom Toturial by Philip Rideout, section Exploit Hardware Filtering \href{http://prideout.net/bloom/index.php#Sneaky}{\tt http\-://prideout.\-net/bloom/index.\-php\#\-Sneaky}

To create an instance of class vtk\-Gaussian\-Blur\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGaussianBlurPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Gaussian\-Blur\-Pass 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\-Gaussian\-Blur\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Gaussian\-Blur\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Gaussian\-Blur\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkgenericrenderwindowinteractor}{}\section{vtk\-Generic\-Render\-Window\-Interactor}\label{vtkrendering_vtkgenericrenderwindowinteractor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Generic\-Render\-Window\-Interactor provides a way to translate native mouse and keyboard events into vtk Events. By calling the methods on this class, vtk events will be invoked. This will allow scripting languages to use vtk\-Interactor\-Styles and 3\-D widgets.

To create an instance of class vtk\-Generic\-Render\-Window\-Interactor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericRenderWindowInteractor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-Render\-Window\-Interactor 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\-Generic\-Render\-Window\-Interactor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-Render\-Window\-Interactor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-Render\-Window\-Interactor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Mouse\-Move\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Right\-Button\-Press\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Right\-Button\-Release\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Left\-Button\-Press\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Left\-Button\-Release\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Middle\-Button\-Press\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Middle\-Button\-Release\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Mouse\-Wheel\-Forward\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Mouse\-Wheel\-Backward\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Expose\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Configure\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Enter\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Leave\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Timer\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Key\-Press\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Key\-Release\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Char\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Exit\-Event ()} -\/ Fire various events. Set\-Event\-Information should be called just prior to calling any of these methods. These methods will Invoke the corresponding vtk event.  
\item {\ttfamily obj.\-Set\-Timer\-Event\-Resets\-Timer (int )} -\/ Flag that indicates whether the Timer\-Event method should call Reset\-Timer to simulate repeating timers with an endless stream of one shot timers. By default this flag is on and all repeating timers are implemented as a stream of sequential one shot timers. If the observer of Create\-Timer\-Event actually creates a \char`\"{}natively repeating\char`\"{} timer, setting this flag to off will prevent (perhaps many many) unnecessary calls to Reset\-Timer. Having the flag on by default means that \char`\"{}natively one
 shot\char`\"{} timers can be either one shot or repeating timers with no additional work. Also, \char`\"{}natively repeating\char`\"{} timers still work with the default setting, but with potentially many create and destroy calls.  
\item {\ttfamily int = obj.\-Get\-Timer\-Event\-Resets\-Timer ()} -\/ Flag that indicates whether the Timer\-Event method should call Reset\-Timer to simulate repeating timers with an endless stream of one shot timers. By default this flag is on and all repeating timers are implemented as a stream of sequential one shot timers. If the observer of Create\-Timer\-Event actually creates a \char`\"{}natively repeating\char`\"{} timer, setting this flag to off will prevent (perhaps many many) unnecessary calls to Reset\-Timer. Having the flag on by default means that \char`\"{}natively one
 shot\char`\"{} timers can be either one shot or repeating timers with no additional work. Also, \char`\"{}natively repeating\char`\"{} timers still work with the default setting, but with potentially many create and destroy calls.  
\item {\ttfamily obj.\-Timer\-Event\-Resets\-Timer\-On ()} -\/ Flag that indicates whether the Timer\-Event method should call Reset\-Timer to simulate repeating timers with an endless stream of one shot timers. By default this flag is on and all repeating timers are implemented as a stream of sequential one shot timers. If the observer of Create\-Timer\-Event actually creates a \char`\"{}natively repeating\char`\"{} timer, setting this flag to off will prevent (perhaps many many) unnecessary calls to Reset\-Timer. Having the flag on by default means that \char`\"{}natively one
 shot\char`\"{} timers can be either one shot or repeating timers with no additional work. Also, \char`\"{}natively repeating\char`\"{} timers still work with the default setting, but with potentially many create and destroy calls.  
\item {\ttfamily obj.\-Timer\-Event\-Resets\-Timer\-Off ()} -\/ Flag that indicates whether the Timer\-Event method should call Reset\-Timer to simulate repeating timers with an endless stream of one shot timers. By default this flag is on and all repeating timers are implemented as a stream of sequential one shot timers. If the observer of Create\-Timer\-Event actually creates a \char`\"{}natively repeating\char`\"{} timer, setting this flag to off will prevent (perhaps many many) unnecessary calls to Reset\-Timer. Having the flag on by default means that \char`\"{}natively one
 shot\char`\"{} timers can be either one shot or repeating timers with no additional work. Also, \char`\"{}natively repeating\char`\"{} timers still work with the default setting, but with potentially many create and destroy calls.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgenericvertexattributemapping}{}\section{vtk\-Generic\-Vertex\-Attribute\-Mapping}\label{vtkrendering_vtkgenericvertexattributemapping}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Generic\-Vertex\-Attribute\-Mapping stores mapping between data arrays and generic vertex attributes. It is used by vtk\-Painter\-Poly\-Data\-Mapper to pass the mappings to the painter which rendering the attributes. .S\-E\-C\-T\-I\-O\-N Thanks Support for generic vertex attributes in V\-T\-K was contributed in collaboration with Stephane Ploix at E\-D\-F.

To create an instance of class vtk\-Generic\-Vertex\-Attribute\-Mapping, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGenericVertexAttributeMapping
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Generic\-Vertex\-Attribute\-Mapping 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\-Generic\-Vertex\-Attribute\-Mapping class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Generic\-Vertex\-Attribute\-Mapping = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Generic\-Vertex\-Attribute\-Mapping = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Mapping (string attribute\-Name, string array\-Name, int field\-Association, int component)} -\/ Select a data array from the point/cell data and map it to a generic vertex attribute. Note that indices change when a mapping is added/removed.  
\item {\ttfamily obj.\-Add\-Mapping (int unit, string array\-Name, int field\-Association, int component)} -\/ Select a data array and use it as multitexture texture coordinates. Note the texture unit parameter should correspond to the texture unit set on the texture.  
\item {\ttfamily bool = obj.\-Remove\-Mapping (string attribute\-Name)} -\/ Remove a vertex attribute mapping.  
\item {\ttfamily obj.\-Remove\-All\-Mappings ()} -\/ Remove all mappings.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Mappings ()} -\/ Get number of mapppings.  
\item {\ttfamily string = obj.\-Get\-Attribute\-Name (int index)} -\/ Get the attribute name at the given index.  
\item {\ttfamily string = obj.\-Get\-Array\-Name (int index)} -\/ Get the array name at the given index.  
\item {\ttfamily int = obj.\-Get\-Field\-Association (int index)} -\/ Get the field association at the given index.  
\item {\ttfamily int = obj.\-Get\-Component (int index)} -\/ Get the component no. at the given index.  
\item {\ttfamily int = obj.\-Get\-Texture\-Unit (int index)} -\/ Get the component no. at the given index.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgl2psexporter}{}\section{vtk\-G\-L2\-P\-S\-Exporter}\label{vtkrendering_vtkgl2psexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-L2\-P\-S\-Exporter is a concrete subclass of vtk\-Exporter that writes high quality vector Post\-Script (P\-S/\-E\-P\-S), P\-D\-F or S\-V\-G files by using G\-L2\-P\-S. G\-L2\-P\-S can be obtained at\-: \href{http://www.geuz.org/gl2ps/}{\tt http\-://www.\-geuz.\-org/gl2ps/}. This can be very useful when one requires publication quality pictures. This class works best with simple 3\-D scenes and most 2\-D plots. Please note that G\-L2\-P\-S has its limitations since Post\-Script is not an ideal language to represent complex 3\-D scenes. However, this class does allow one to write mixed vector/raster files by using the Write3\-D\-Props\-As\-Raster\-Image ivar. Please do read the caveats section of this documentation.

By default vtk\-G\-L2\-P\-S\-Exporter generates Encapsulated Post\-Script (E\-P\-S) output along with the text in portrait orientation with the background color of the window being drawn. The generated output is also compressed using zlib. The various other options are set to sensible defaults.

The output file format (File\-Format) can be either Post\-Script (P\-S), Encapsulated Post\-Script (E\-P\-S), P\-D\-F, S\-V\-G or Te\-X. The file extension is generated automatically depending on the File\-Format. The default is E\-P\-S. When Te\-X output is chosen, only the text strings in the plot are generated and put into a picture environment. One can turn on and off the text when generating P\-S/\-E\-P\-S/\-P\-D\-F/\-S\-V\-G files by using the Text boolean variable. By default the text is drawn. The background color of the renderwindow is drawn by default. To make the background white instead use the Draw\-Background\-Off function. Landscape figures can be generated by using the Landscape\-On function. Portrait orientation is used by default. Several of the G\-L2\-P\-S options can be set. The names of the ivars for these options are similar to the ones that G\-L2\-P\-S provides. Compress, Simple\-Line\-Offset, Silent, Best\-Root, P\-S3\-Shading and Occlusion\-Cull are similar to the options provided by G\-L2\-P\-S. Please read the function documentation or the G\-L2\-P\-S documentation for more details. The ivar Write3\-D\-Props\-As\-Raster\-Image allows one to generate mixed vector/raster images. All the 3\-D props in the scene will be written as a raster image and all 2\-D actors will be written as vector graphic primitives. This makes it possible to handle transparency and complex 3\-D scenes. This ivar is set to Off by default. When drawing lines and points the Open\-G\-L point size and line width are multiplied by a factor in order to generate Post\-Script lines and points of the right size. The Get/\-Set\-Global\-Point\-Size\-Factor and Get/\-Set\-Global\-Line\-Width\-Factor let one customize this ratio. The default value is such that the Post\-Script output looks close to what is seen on screen.

To use this class you need to turn on V\-T\-K\-\_\-\-U\-S\-E\-\_\-\-G\-L2\-P\-S when configuring V\-T\-K.

To create an instance of class vtk\-G\-L2\-P\-S\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGL2PSExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-L2\-P\-S\-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\-G\-L2\-P\-S\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-L2\-P\-S\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-L2\-P\-S\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify the prefix of the files to write out. The resulting filenames will have .ps or .eps or .tex appended to them depending on the other options chosen.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify the prefix of the files to write out. The resulting filenames will have .ps or .eps or .tex appended to them depending on the other options chosen.  
\item {\ttfamily obj.\-Set\-File\-Format (int )} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily int = obj.\-Get\-File\-Format\-Min\-Value ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily int = obj.\-Get\-File\-Format\-Max\-Value ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily int = obj.\-Get\-File\-Format ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-File\-Format\-To\-P\-S ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-File\-Format\-To\-E\-P\-S ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-File\-Format\-To\-P\-D\-F ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-File\-Format\-To\-Te\-X ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-File\-Format\-To\-S\-V\-G ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily string = obj.\-Get\-File\-Format\-As\-String ()} -\/ Specify the format of file to write out. This can be one of\-: P\-S\-\_\-\-F\-I\-L\-E, E\-P\-S\-\_\-\-F\-I\-L\-E, P\-D\-F\-\_\-\-F\-I\-L\-E, T\-E\-X\-\_\-\-F\-I\-L\-E. Defaults to E\-P\-S\-\_\-\-F\-I\-L\-E. Depending on the option chosen it generates the appropriate file (with correct extension) when the Write function is called.  
\item {\ttfamily obj.\-Set\-Sort (int )} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily int = obj.\-Get\-Sort\-Min\-Value ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily int = obj.\-Get\-Sort\-Max\-Value ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily int = obj.\-Get\-Sort ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily obj.\-Set\-Sort\-To\-Off ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily obj.\-Set\-Sort\-To\-Simple ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily obj.\-Set\-Sort\-To\-B\-S\-P ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily string = obj.\-Get\-Sort\-As\-String ()} -\/ Set the the type of sorting algorithm to order primitives from back to front. Successive algorithms are more memory intensive. Simple is the default but B\-S\-P is perhaps the best.  
\item {\ttfamily obj.\-Set\-Compress (int )} -\/ Turn on/off compression when generating Post\-Script or P\-D\-F output. By default compression is on.  
\item {\ttfamily int = obj.\-Get\-Compress ()} -\/ Turn on/off compression when generating Post\-Script or P\-D\-F output. By default compression is on.  
\item {\ttfamily obj.\-Compress\-On ()} -\/ Turn on/off compression when generating Post\-Script or P\-D\-F output. By default compression is on.  
\item {\ttfamily obj.\-Compress\-Off ()} -\/ Turn on/off compression when generating Post\-Script or P\-D\-F output. By default compression is on.  
\item {\ttfamily obj.\-Set\-Draw\-Background (int )} -\/ Turn on/off drawing the background frame. If off the background is treated as white. By default the background is drawn.  
\item {\ttfamily int = obj.\-Get\-Draw\-Background ()} -\/ Turn on/off drawing the background frame. If off the background is treated as white. By default the background is drawn.  
\item {\ttfamily obj.\-Draw\-Background\-On ()} -\/ Turn on/off drawing the background frame. If off the background is treated as white. By default the background is drawn.  
\item {\ttfamily obj.\-Draw\-Background\-Off ()} -\/ Turn on/off drawing the background frame. If off the background is treated as white. By default the background is drawn.  
\item {\ttfamily obj.\-Set\-Simple\-Line\-Offset (int )} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-S\-I\-M\-P\-L\-E\-\_\-\-L\-I\-N\-E\-\_\-\-O\-F\-F\-S\-E\-T option. When enabled a small offset is added in the z-\/buffer to all the lines in the plot. This results in an anti-\/aliasing like solution. Defaults to on.  
\item {\ttfamily int = obj.\-Get\-Simple\-Line\-Offset ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-S\-I\-M\-P\-L\-E\-\_\-\-L\-I\-N\-E\-\_\-\-O\-F\-F\-S\-E\-T option. When enabled a small offset is added in the z-\/buffer to all the lines in the plot. This results in an anti-\/aliasing like solution. Defaults to on.  
\item {\ttfamily obj.\-Simple\-Line\-Offset\-On ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-S\-I\-M\-P\-L\-E\-\_\-\-L\-I\-N\-E\-\_\-\-O\-F\-F\-S\-E\-T option. When enabled a small offset is added in the z-\/buffer to all the lines in the plot. This results in an anti-\/aliasing like solution. Defaults to on.  
\item {\ttfamily obj.\-Simple\-Line\-Offset\-Off ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-S\-I\-M\-P\-L\-E\-\_\-\-L\-I\-N\-E\-\_\-\-O\-F\-F\-S\-E\-T option. When enabled a small offset is added in the z-\/buffer to all the lines in the plot. This results in an anti-\/aliasing like solution. Defaults to on.  
\item {\ttfamily obj.\-Set\-Silent (int )} -\/ Turn on/off G\-L2\-P\-S messages sent to stderr (G\-L2\-P\-S\-\_\-\-S\-I\-L\-E\-N\-T). When enabled G\-L2\-P\-S messages are suppressed. Defaults to off.  
\item {\ttfamily int = obj.\-Get\-Silent ()} -\/ Turn on/off G\-L2\-P\-S messages sent to stderr (G\-L2\-P\-S\-\_\-\-S\-I\-L\-E\-N\-T). When enabled G\-L2\-P\-S messages are suppressed. Defaults to off.  
\item {\ttfamily obj.\-Silent\-On ()} -\/ Turn on/off G\-L2\-P\-S messages sent to stderr (G\-L2\-P\-S\-\_\-\-S\-I\-L\-E\-N\-T). When enabled G\-L2\-P\-S messages are suppressed. Defaults to off.  
\item {\ttfamily obj.\-Silent\-Off ()} -\/ Turn on/off G\-L2\-P\-S messages sent to stderr (G\-L2\-P\-S\-\_\-\-S\-I\-L\-E\-N\-T). When enabled G\-L2\-P\-S messages are suppressed. Defaults to off.  
\item {\ttfamily obj.\-Set\-Best\-Root (int )} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-B\-E\-S\-T\-\_\-\-R\-O\-O\-T option. When enabled the construction of the B\-S\-P tree is optimized by choosing the root primitives leading to the minimum number of splits. Defaults to on.  
\item {\ttfamily int = obj.\-Get\-Best\-Root ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-B\-E\-S\-T\-\_\-\-R\-O\-O\-T option. When enabled the construction of the B\-S\-P tree is optimized by choosing the root primitives leading to the minimum number of splits. Defaults to on.  
\item {\ttfamily obj.\-Best\-Root\-On ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-B\-E\-S\-T\-\_\-\-R\-O\-O\-T option. When enabled the construction of the B\-S\-P tree is optimized by choosing the root primitives leading to the minimum number of splits. Defaults to on.  
\item {\ttfamily obj.\-Best\-Root\-Off ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-B\-E\-S\-T\-\_\-\-R\-O\-O\-T option. When enabled the construction of the B\-S\-P tree is optimized by choosing the root primitives leading to the minimum number of splits. Defaults to on.  
\item {\ttfamily obj.\-Set\-Text (int )} -\/ Turn on/off drawing the text. If on (default) the text is drawn. If the File\-Format is set to Te\-X output then a La\-Te\-X picture is generated with the text strings. If off text output is suppressed.  
\item {\ttfamily int = obj.\-Get\-Text ()} -\/ Turn on/off drawing the text. If on (default) the text is drawn. If the File\-Format is set to Te\-X output then a La\-Te\-X picture is generated with the text strings. If off text output is suppressed.  
\item {\ttfamily obj.\-Text\-On ()} -\/ Turn on/off drawing the text. If on (default) the text is drawn. If the File\-Format is set to Te\-X output then a La\-Te\-X picture is generated with the text strings. If off text output is suppressed.  
\item {\ttfamily obj.\-Text\-Off ()} -\/ Turn on/off drawing the text. If on (default) the text is drawn. If the File\-Format is set to Te\-X output then a La\-Te\-X picture is generated with the text strings. If off text output is suppressed.  
\item {\ttfamily obj.\-Set\-Landscape (int )} -\/ Turn on/off landscape orientation. If off (default) the orientation is set to portrait.  
\item {\ttfamily int = obj.\-Get\-Landscape ()} -\/ Turn on/off landscape orientation. If off (default) the orientation is set to portrait.  
\item {\ttfamily obj.\-Landscape\-On ()} -\/ Turn on/off landscape orientation. If off (default) the orientation is set to portrait.  
\item {\ttfamily obj.\-Landscape\-Off ()} -\/ Turn on/off landscape orientation. If off (default) the orientation is set to portrait.  
\item {\ttfamily obj.\-Set\-P\-S3\-Shading (int )} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-P\-S3\-\_\-\-S\-H\-A\-D\-I\-N\-G option. When enabled the shfill Post\-Script level 3 operator is used. Read the G\-L2\-P\-S documentation for more details. Defaults to on.  
\item {\ttfamily int = obj.\-Get\-P\-S3\-Shading ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-P\-S3\-\_\-\-S\-H\-A\-D\-I\-N\-G option. When enabled the shfill Post\-Script level 3 operator is used. Read the G\-L2\-P\-S documentation for more details. Defaults to on.  
\item {\ttfamily obj.\-P\-S3\-Shading\-On ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-P\-S3\-\_\-\-S\-H\-A\-D\-I\-N\-G option. When enabled the shfill Post\-Script level 3 operator is used. Read the G\-L2\-P\-S documentation for more details. Defaults to on.  
\item {\ttfamily obj.\-P\-S3\-Shading\-Off ()} -\/ Turn on/off the G\-L2\-P\-S\-\_\-\-P\-S3\-\_\-\-S\-H\-A\-D\-I\-N\-G option. When enabled the shfill Post\-Script level 3 operator is used. Read the G\-L2\-P\-S documentation for more details. Defaults to on.  
\item {\ttfamily obj.\-Set\-Occlusion\-Cull (int )} -\/ Turn on/off culling of occluded polygons (G\-L2\-P\-S\-\_\-\-O\-C\-C\-L\-U\-S\-I\-O\-N\-\_\-\-C\-U\-L\-L). When enabled hidden polygons are removed. This reduces file size considerably. Defaults to on.  
\item {\ttfamily int = obj.\-Get\-Occlusion\-Cull ()} -\/ Turn on/off culling of occluded polygons (G\-L2\-P\-S\-\_\-\-O\-C\-C\-L\-U\-S\-I\-O\-N\-\_\-\-C\-U\-L\-L). When enabled hidden polygons are removed. This reduces file size considerably. Defaults to on.  
\item {\ttfamily obj.\-Occlusion\-Cull\-On ()} -\/ Turn on/off culling of occluded polygons (G\-L2\-P\-S\-\_\-\-O\-C\-C\-L\-U\-S\-I\-O\-N\-\_\-\-C\-U\-L\-L). When enabled hidden polygons are removed. This reduces file size considerably. Defaults to on.  
\item {\ttfamily obj.\-Occlusion\-Cull\-Off ()} -\/ Turn on/off culling of occluded polygons (G\-L2\-P\-S\-\_\-\-O\-C\-C\-L\-U\-S\-I\-O\-N\-\_\-\-C\-U\-L\-L). When enabled hidden polygons are removed. This reduces file size considerably. Defaults to on.  
\item {\ttfamily obj.\-Set\-Write3\-D\-Props\-As\-Raster\-Image (int )} -\/ Turn on/off writing 3\-D props as raster images. 2\-D props are rendered using vector graphics primitives. If you have hi-\/res actors and are using transparency you probably need to turn this on. Defaults to Off.  
\item {\ttfamily int = obj.\-Get\-Write3\-D\-Props\-As\-Raster\-Image ()} -\/ Turn on/off writing 3\-D props as raster images. 2\-D props are rendered using vector graphics primitives. If you have hi-\/res actors and are using transparency you probably need to turn this on. Defaults to Off.  
\item {\ttfamily obj.\-Write3\-D\-Props\-As\-Raster\-Image\-On ()} -\/ Turn on/off writing 3\-D props as raster images. 2\-D props are rendered using vector graphics primitives. If you have hi-\/res actors and are using transparency you probably need to turn this on. Defaults to Off.  
\item {\ttfamily obj.\-Write3\-D\-Props\-As\-Raster\-Image\-Off ()} -\/ Turn on/off writing 3\-D props as raster images. 2\-D props are rendered using vector graphics primitives. If you have hi-\/res actors and are using transparency you probably need to turn this on. Defaults to Off.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkglslshader}{}\section{vtk\-G\-L\-S\-L\-Shader}\label{vtkrendering_vtkglslshader}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-L\-S\-L\-Shader is a concrete class that creates and compiles hardware shaders written in the Open\-G\-L Shadering Language (G\-L\-S\-L, Open\-G\-L2.\-0). While step linking a vertex and a fragment shader is performed by vtk\-G\-L\-S\-L\-Shader\-Program, all shader parameters are initialized in this class.

.Section vtk\-Open\-G\-L\-Extension\-Manager All Open\-G\-L calls are made through vtk\-Open\-G\-L\-Extension\-Manager.

.Section Supported Basic Shader Types\-:

Scalar Types uniform float uniform int uniform int -- boolean scalar not yet tested

Vector Types\-: uniform vec\{2$|$3$|$4\} uniform ivec\{2$|$3$|$4\} uniform bvec\{2$|$3$|$4\} -- boolean vector not yet tested

Matrix Types\-: uniform mat\{2$|$3$|$4\}

Texture Samplers\-: sample1\-D -- Not yet implemented in this cless. sample2\-D -- Not yet implemented in this class. sample3\-D -- Not yet implemented in this class. sampler1\-D\-Shadow -- Not yet implemented in this class. sampler1\-D\-Shadow -- Not yet implemented in this class.

User-\/\-Defined structures\-: uniform struct N\-O\-T\-E\-: these must be defined and declared outside of the 'main' shader function.

.S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-G\-L\-S\-L\-Shader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGLSLShader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-L\-S\-L\-Shader has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-L\-S\-L\-Shader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Compile ()} -\/ Called to compile the shader code. The subclasses must only compile the code in this method. Returns if the compile was successful. Subclasses should compile the code only if it was not already compiled.  
\item {\ttfamily int = obj.\-Get\-Handle ()} -\/ The Shader needs the id of the Shader\-Program to obtain uniform variable locations. This is set by vtk\-G\-L\-S\-L\-Shader\-Program.  
\item {\ttfamily obj.\-Set\-Program (int )} -\/ The Shader needs the id of the Shader\-Program to obtain uniform variable locations. This is set by vtk\-G\-L\-S\-L\-Shader\-Program.  
\item {\ttfamily int = obj.\-Get\-Program ()} -\/ The Shader needs the id of the Shader\-Program to obtain uniform variable locations. This is set by vtk\-G\-L\-S\-L\-Shader\-Program.  
\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{vtkrendering_vtkglslshaderdeviceadapter}{}\section{vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter}\label{vtkrendering_vtkglslshaderdeviceadapter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shader\-Device\-Adapter subclass for G\-L\-S\-L. .S\-E\-C\-T\-I\-O\-N Thanks Support for generic vertex attributes in V\-T\-K was contributed in collaboration with Stephane Ploix at E\-D\-F.

To create an instance of class vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGLSLShaderDeviceAdapter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Prepare\-For\-Render ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkglslshaderdeviceadapter2}{}\section{vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2}\label{vtkrendering_vtkglslshaderdeviceadapter2}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shader\-Device\-Adapter subclass for vtk\-Shader\-Program2.

To create an instance of class vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGLSLShaderDeviceAdapter2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Device\-Adapter2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Prepare\-For\-Render ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkglslshaderprogram}{}\section{vtk\-G\-L\-S\-L\-Shader\-Program}\label{vtkrendering_vtkglslshaderprogram}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-L\-S\-L\-Shader\-Program is a concerete implementation of vtk\-Shader\-Program. It's main function is to 'Link' a vertex and a fragment shader together and install them into the rendering pipeline by calling Open\-G\-L2.\-0.

Initialization of shader parameters is delegated to instances of vtk\-Shader (vtk\-G\-L\-S\-L\-Shader in this case). .S\-E\-C\-T\-I\-O\-N Thanks Shader support in V\-T\-K includes key contributions by Gary Templet at Sandia National Labs.

To create an instance of class vtk\-G\-L\-S\-L\-Shader\-Program, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGLSLShaderProgram
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-L\-S\-L\-Shader\-Program has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-L\-S\-L\-Shader\-Program class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Program = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-L\-S\-L\-Shader\-Program = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Actor actor, vtk\-Renderer renderer)}  
\item {\ttfamily obj.\-Post\-Render (vtk\-Actor , vtk\-Renderer )} -\/ Called to unload the shaders after the actor has been rendered.  
\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 int = obj.\-Get\-Program ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgpuinfo}{}\section{vtk\-G\-P\-U\-Info}\label{vtkrendering_vtkgpuinfo}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-P\-U\-Info stores information about G\-P\-U Video R\-A\-M. An host can have several G\-P\-Us. The values are set by vtk\-G\-P\-U\-Info\-List.

To create an instance of class vtk\-G\-P\-U\-Info, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGPUInfo
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-P\-U\-Info has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-P\-U\-Info class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-P\-U\-Info = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-P\-U\-Info = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Dedicated\-Video\-Memory (vtk\-Id\-Type )} -\/ Set/\-Get dedicated video memory in bytes. Initial value is 0. Usually the fastest one. If it is not null, it should be take into account first and Dedicated\-System\-Memory or Shared\-System\-Memory should be ignored.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Dedicated\-Video\-Memory ()} -\/ Set/\-Get dedicated video memory in bytes. Initial value is 0. Usually the fastest one. If it is not null, it should be take into account first and Dedicated\-System\-Memory or Shared\-System\-Memory should be ignored.  
\item {\ttfamily obj.\-Set\-Dedicated\-System\-Memory (vtk\-Id\-Type )} -\/ Set/\-Get dedicated system memory in bytes. Initial value is 0. This is slow memory. If it is not null, this value should be taken into account only if there is no Dedicated\-Video\-Memory and Shared\-System\-Memory should be ignored.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Dedicated\-System\-Memory ()} -\/ Set/\-Get dedicated system memory in bytes. Initial value is 0. This is slow memory. If it is not null, this value should be taken into account only if there is no Dedicated\-Video\-Memory and Shared\-System\-Memory should be ignored.  
\item {\ttfamily obj.\-Set\-Shared\-System\-Memory (vtk\-Id\-Type )} -\/ Set/\-Get shared system memory in bytes. Initial value is 0. Slowest memory. This value should be taken into account only if there is neither Dedicated\-Video\-Memory nor Dedicated\-System\-Memory.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Shared\-System\-Memory ()} -\/ Set/\-Get shared system memory in bytes. Initial value is 0. Slowest memory. This value should be taken into account only if there is neither Dedicated\-Video\-Memory nor Dedicated\-System\-Memory.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgpuinfolist}{}\section{vtk\-G\-P\-U\-Info\-List}\label{vtkrendering_vtkgpuinfolist}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-G\-P\-U\-Info\-List stores a list of vtk\-G\-P\-U\-Info. An host can have several G\-P\-Us. It creates and sets the list by probing the host with system calls. This an abstract class. Concrete classes are O\-S specific.

To create an instance of class vtk\-G\-P\-U\-Info\-List, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGPUInfoList
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-G\-P\-U\-Info\-List has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-G\-P\-U\-Info\-List class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-G\-P\-U\-Info\-List = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-G\-P\-U\-Info\-List = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Probe ()} -\/ Build the list of vtk\-Info\-G\-P\-U if not done yet. Default implementation created an empty list. Useful if there is no implementation available for a given architecture yet. \begin{DoxyPostcond}{Postcondition}
probed\-: Is\-Probed()  
\end{DoxyPostcond}

\item {\ttfamily bool = obj.\-Is\-Probed ()} -\/ Tells if the operating system has been probed. Initial value is false.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-G\-P\-Us ()} -\/ Return the number of G\-P\-Us. \begin{DoxyPrecond}{Precondition}
probed\-: Is\-Probed()  
\end{DoxyPrecond}

\item {\ttfamily vtk\-G\-P\-U\-Info = obj.\-Get\-G\-P\-U\-Info (int i)} -\/ Return information about G\-P\-U i. \begin{DoxyPrecond}{Precondition}
probed\-: Is\-Probed() 

valid\-\_\-index\-: i$>$=0 \&\& i$<$Get\-Number\-Of\-G\-P\-Us() 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
result\-\_\-exists\-: result!=0  
\end{DoxyPostcond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkgraphicsfactory}{}\section{vtk\-Graphics\-Factory}\label{vtkrendering_vtkgraphicsfactory}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Graphics\-Factory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphicsFactory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graphics\-Factory has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Graphics\-Factory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graphics\-Factory = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graphics\-Factory = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgraphmapper}{}\section{vtk\-Graph\-Mapper}\label{vtkrendering_vtkgraphmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Graph\-Mapper is a mapper to map vtk\-Graph (and all derived classes) to graphics primitives.

To create an instance of class vtk\-Graph\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Graph\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor act)}  
\item {\ttfamily obj.\-Set\-Vertex\-Color\-Array\-Name (string name)} -\/ The array to use for coloring vertices. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Vertex\-Color\-Array\-Name ()} -\/ The array to use for coloring vertices. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily obj.\-Set\-Color\-Vertices (bool vis)} -\/ Whether to color vertices. Default is off.  
\item {\ttfamily bool = obj.\-Get\-Color\-Vertices ()} -\/ Whether to color vertices. Default is off.  
\item {\ttfamily obj.\-Color\-Vertices\-On ()} -\/ Whether to color vertices. Default is off.  
\item {\ttfamily obj.\-Color\-Vertices\-Off ()} -\/ Whether to color vertices. Default is off.  
\item {\ttfamily obj.\-Set\-Scaled\-Glyphs (bool arg)} -\/ Whether scaled glyphs are on or not. Default is off. By default this mapper uses vertex glyphs that do not scale. If you turn this option on you will get circles at each vertex and they will scale as you zoom in/out.  
\item {\ttfamily bool = obj.\-Get\-Scaled\-Glyphs ()} -\/ Whether scaled glyphs are on or not. Default is off. By default this mapper uses vertex glyphs that do not scale. If you turn this option on you will get circles at each vertex and they will scale as you zoom in/out.  
\item {\ttfamily obj.\-Scaled\-Glyphs\-On ()} -\/ Whether scaled glyphs are on or not. Default is off. By default this mapper uses vertex glyphs that do not scale. If you turn this option on you will get circles at each vertex and they will scale as you zoom in/out.  
\item {\ttfamily obj.\-Scaled\-Glyphs\-Off ()} -\/ Whether scaled glyphs are on or not. Default is off. By default this mapper uses vertex glyphs that do not scale. If you turn this option on you will get circles at each vertex and they will scale as you zoom in/out.  
\item {\ttfamily obj.\-Set\-Scaling\-Array\-Name (string )} -\/ Glyph scaling array name. Default is \char`\"{}scale\char`\"{}  
\item {\ttfamily string = obj.\-Get\-Scaling\-Array\-Name ()} -\/ Glyph scaling array name. Default is \char`\"{}scale\char`\"{}  
\item {\ttfamily obj.\-Set\-Edge\-Visibility (bool vis)} -\/ Whether to show edges or not. Default is on.  
\item {\ttfamily bool = obj.\-Get\-Edge\-Visibility ()} -\/ Whether to show edges or not. Default is on.  
\item {\ttfamily obj.\-Edge\-Visibility\-On ()} -\/ Whether to show edges or not. Default is on.  
\item {\ttfamily obj.\-Edge\-Visibility\-Off ()} -\/ Whether to show edges or not. Default is on.  
\item {\ttfamily obj.\-Set\-Edge\-Color\-Array\-Name (string name)} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Edge\-Color\-Array\-Name ()} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily obj.\-Set\-Color\-Edges (bool vis)} -\/ Whether to color edges. Default is off.  
\item {\ttfamily bool = obj.\-Get\-Color\-Edges ()} -\/ Whether to color edges. Default is off.  
\item {\ttfamily obj.\-Color\-Edges\-On ()} -\/ Whether to color edges. Default is off.  
\item {\ttfamily obj.\-Color\-Edges\-Off ()} -\/ Whether to color edges. Default is off.  
\item {\ttfamily obj.\-Set\-Enabled\-Edges\-Array\-Name (string )} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Enabled\-Edges\-Array\-Name ()} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily obj.\-Set\-Enable\-Edges\-By\-Array (int )} -\/ Whether to enable/disable edges using array values. Default is off.  
\item {\ttfamily int = obj.\-Get\-Enable\-Edges\-By\-Array ()} -\/ Whether to enable/disable edges using array values. Default is off.  
\item {\ttfamily obj.\-Enable\-Edges\-By\-Array\-On ()} -\/ Whether to enable/disable edges using array values. Default is off.  
\item {\ttfamily obj.\-Enable\-Edges\-By\-Array\-Off ()} -\/ Whether to enable/disable edges using array values. Default is off.  
\item {\ttfamily obj.\-Set\-Enabled\-Vertices\-Array\-Name (string )} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Enabled\-Vertices\-Array\-Name ()} -\/ The array to use for coloring edges. Default is \char`\"{}color\char`\"{}.  
\item {\ttfamily obj.\-Set\-Enable\-Vertices\-By\-Array (int )} -\/ Whether to enable/disable vertices using array values. Default is off.  
\item {\ttfamily int = obj.\-Get\-Enable\-Vertices\-By\-Array ()} -\/ Whether to enable/disable vertices using array values. Default is off.  
\item {\ttfamily obj.\-Enable\-Vertices\-By\-Array\-On ()} -\/ Whether to enable/disable vertices using array values. Default is off.  
\item {\ttfamily obj.\-Enable\-Vertices\-By\-Array\-Off ()} -\/ Whether to enable/disable vertices using array values. Default is off.  
\item {\ttfamily obj.\-Set\-Icon\-Array\-Name (string name)} -\/ The array to use for assigning icons.  
\item {\ttfamily string = obj.\-Get\-Icon\-Array\-Name ()} -\/ The array to use for assigning icons.  
\item {\ttfamily obj.\-Add\-Icon\-Type (string type, int index)} -\/ Associate the icon at index \char`\"{}index\char`\"{} in the vtk\-Texture to all vertices containing \char`\"{}type\char`\"{} as a value in the vertex attribute array specified by Icon\-Array\-Name.  
\item {\ttfamily obj.\-Clear\-Icon\-Types ()} -\/ Clear all icon mappings.  
\item {\ttfamily obj.\-Set\-Icon\-Size (int size)} -\/ Specify the Width and Height, in pixels, of an icon in the icon sheet.  
\item {\ttfamily obj.\-Set\-Icon\-Alignment (int alignment)} -\/ Specify where the icons should be placed in relation to the vertex. See vtk\-Icon\-Glyph\-Filter.\-h for possible values.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Icon\-Texture ()} -\/ The texture containing the icon sheet.  
\item {\ttfamily obj.\-Set\-Icon\-Texture (vtk\-Texture texture)} -\/ The texture containing the icon sheet.  
\item {\ttfamily obj.\-Set\-Icon\-Visibility (bool vis)} -\/ Whether to show icons. Default is off.  
\item {\ttfamily bool = obj.\-Get\-Icon\-Visibility ()} -\/ Whether to show icons. Default is off.  
\item {\ttfamily obj.\-Icon\-Visibility\-On ()} -\/ Whether to show icons. Default is off.  
\item {\ttfamily obj.\-Icon\-Visibility\-Off ()} -\/ Whether to show icons. Default is off.  
\item {\ttfamily float = obj.\-Get\-Vertex\-Point\-Size ()} -\/ Get/\-Set the vertex point size  
\item {\ttfamily obj.\-Set\-Vertex\-Point\-Size (float size)} -\/ Get/\-Set the vertex point size  
\item {\ttfamily float = obj.\-Get\-Edge\-Line\-Width ()} -\/ Get/\-Set the edge line width  
\item {\ttfamily obj.\-Set\-Edge\-Line\-Width (float width)} -\/ Get/\-Set the edge line width  
\item {\ttfamily obj.\-Apply\-View\-Theme (vtk\-View\-Theme theme)} -\/ Apply the theme to this view.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the mtime also considering the lookup table.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Graph input)} -\/ Set the Input of this mapper.  
\item {\ttfamily vtk\-Graph = obj.\-Get\-Input ()} -\/ Set the Input of this mapper.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds)} -\/ Access to the lookup tables used by the vertex and edge mappers.  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Edge\-Lookup\-Table ()} -\/ Access to the lookup tables used by the vertex and edge mappers.  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Vertex\-Lookup\-Table ()} -\/ Access to the lookup tables used by the vertex and edge mappers.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkgraphtoglyphs}{}\section{vtk\-Graph\-To\-Glyphs}\label{vtkrendering_vtkgraphtoglyphs}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Converts a vtk\-Graph to a vtk\-Poly\-Data containing a glyph for each vertex. This assumes that the points of the graph have already been filled (perhaps by vtk\-Graph\-Layout). The glyphs will automatically be scaled to be the same size in screen coordinates. To do this the filter requires a pointer to the renderer into which the glyphs will be rendered.

To create an instance of class vtk\-Graph\-To\-Glyphs, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkGraphToGlyphs
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Graph\-To\-Glyphs 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\-Graph\-To\-Glyphs class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Graph\-To\-Glyphs = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Graph\-To\-Glyphs = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Glyph\-Type (int )} -\/ The glyph type, specified as one of the enumerated values in this class. V\-E\-R\-T\-E\-X is a special glyph that cannot be scaled, but instead is rendered as an Open\-G\-L vertex primitive. This may appear as a box or circle depending on the hardware.  
\item {\ttfamily int = obj.\-Get\-Glyph\-Type ()} -\/ The glyph type, specified as one of the enumerated values in this class. V\-E\-R\-T\-E\-X is a special glyph that cannot be scaled, but instead is rendered as an Open\-G\-L vertex primitive. This may appear as a box or circle depending on the hardware.  
\item {\ttfamily obj.\-Set\-Filled (bool )} -\/ Whether to fill the glyph, or to just render the outline.  
\item {\ttfamily bool = obj.\-Get\-Filled ()} -\/ Whether to fill the glyph, or to just render the outline.  
\item {\ttfamily obj.\-Filled\-On ()} -\/ Whether to fill the glyph, or to just render the outline.  
\item {\ttfamily obj.\-Filled\-Off ()} -\/ Whether to fill the glyph, or to just render the outline.  
\item {\ttfamily obj.\-Set\-Screen\-Size (double )} -\/ Set the desired screen size of each glyph. If you are using scaling, this will be the size of the glyph when rendering an object with scaling value 1.\-0.  
\item {\ttfamily double = obj.\-Get\-Screen\-Size ()} -\/ Set the desired screen size of each glyph. If you are using scaling, this will be the size of the glyph when rendering an object with scaling value 1.\-0.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ The renderer in which the glyphs will be placed.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ The renderer in which the glyphs will be placed.  
\item {\ttfamily obj.\-Set\-Scaling (bool b)} -\/ Whether to use the input array to process in order to scale the vertices.  
\item {\ttfamily bool = obj.\-Get\-Scaling ()} -\/ Whether to use the input array to process in order to scale the vertices.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ The modified time of this filter.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkhardwareselectionpolydatapainter}{}\section{vtk\-Hardware\-Selection\-Poly\-Data\-Painter}\label{vtkrendering_vtkhardwareselectionpolydatapainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hardware\-Selection\-Poly\-Data\-Painter is a painter for polydata used when rendering hardware selection passes.

To create an instance of class vtk\-Hardware\-Selection\-Poly\-Data\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHardwareSelectionPolyDataPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hardware\-Selection\-Poly\-Data\-Painter 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\-Hardware\-Selection\-Poly\-Data\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hardware\-Selection\-Poly\-Data\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hardware\-Selection\-Poly\-Data\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enable\-Selection (int )} -\/ Enable/\-Disable vtk\-Hardware\-Selector class. Useful when using this painter as an internal painter. Default is enabled.  
\item {\ttfamily int = obj.\-Get\-Enable\-Selection ()} -\/ Enable/\-Disable vtk\-Hardware\-Selector class. Useful when using this painter as an internal painter. Default is enabled.  
\item {\ttfamily obj.\-Enable\-Selection\-On ()} -\/ Enable/\-Disable vtk\-Hardware\-Selector class. Useful when using this painter as an internal painter. Default is enabled.  
\item {\ttfamily obj.\-Enable\-Selection\-Off ()} -\/ Enable/\-Disable vtk\-Hardware\-Selector class. Useful when using this painter as an internal painter. Default is enabled.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkhardwareselector}{}\section{vtk\-Hardware\-Selector}\label{vtkrendering_vtkhardwareselector}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Hardware\-Selector is a helper that orchestrates color buffer based selection. This relies on Open\-G\-L. vtk\-Hardware\-Selector can be used to select visible cells or points within a given rectangle of the Render\-Window. To use it, call in order\-: \begin{DoxyItemize}
\item Set\-Renderer() -\/ to select the renderer in which we want to select the cells/points. \item Set\-Area() -\/ to set the rectangular region in the render window to select in. \item Set\-Field\-Association() -\/ to select the attribute to select i.\-e. cells/points etc. \item Finally, call Select(). Select will cause the attached vtk\-Renderer to render in a special color mode, where each cell/point is given it own color so that later inspection of the Rendered Pixels can determine what cells are visible. Select() returns a new vtk\-Selection instance with the cells/points selected.\end{DoxyItemize}
Limitations\-: Antialiasing will break this class. If your graphics card settings force their use this class will return invalid results.

Currently only cells from Poly\-Data\-Mappers can be selected from. When vtk\-Renderer\-::\-Selector is non-\/null vtk\-Painter\-Poly\-Data\-Mapper uses the vtk\-Hardware\-Selection\-Poly\-Data\-Painter which make appropriate calls to Begin\-Render\-Prop(), End\-Render\-Prop(), Render\-Attribute\-Id() to render colors correctly. Until alternatives to vtk\-Hardware\-Selection\-Poly\-Data\-Painter exist that can do a similar coloration of other vtk\-Data\-Set types, only polygonal data can be selected. If you need to select other data types, consider using vtk\-Data\-Set\-Mapper and turning on it's Pass\-Through\-Cell\-Ids feature, or using vtk\-Frustum\-Extractor.

Only Opaque geometry in Actors is selected from. Assemblies and L\-O\-D\-Mappers are not currently supported.

During selection, visible datasets that can not be selected from are temporarily hidden so as not to produce invalid indices from their colors.

To create an instance of class vtk\-Hardware\-Selector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHardwareSelector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hardware\-Selector 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\-Hardware\-Selector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hardware\-Selector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hardware\-Selector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer )} -\/ Get/\-Set the renderer to perform the selection on.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Get/\-Set the renderer to perform the selection on.  
\item {\ttfamily obj.\-Set\-Area (int , int , int , int )} -\/ Get/\-Set the area to select as (xmin, ymin, xmax, ymax).  
\item {\ttfamily obj.\-Set\-Area (int a\mbox{[}4\mbox{]})} -\/ Get/\-Set the area to select as (xmin, ymin, xmax, ymax).  
\item {\ttfamily int = obj. Get\-Area ()} -\/ Get/\-Set the area to select as (xmin, ymin, xmax, ymax).  
\item {\ttfamily obj.\-Set\-Field\-Association (int )} -\/ Set the field type to select. Valid values are \begin{DoxyItemize}
\item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-V\-E\-R\-T\-I\-C\-E\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-E\-D\-G\-E\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-R\-O\-W\-S Currently only F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S and F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S are supported.  \item {\ttfamily int = obj.\-Get\-Field\-Association ()} -\/ Set the field type to select. Valid values are \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-V\-E\-R\-T\-I\-C\-E\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-E\-D\-G\-E\-S \item vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-R\-O\-W\-S Currently only F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S and F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S are supported.  \item {\ttfamily vtk\-Selection = obj.\-Select ()} -\/ Perform the selection. Returns a new instance of vtk\-Selection containing the selection on success.  \item {\ttfamily bool = obj.\-Capture\-Buffers ()} -\/ It is possible to use the vtk\-Hardware\-Selector for a custom picking. (Look at vtk\-Scene\-Picker). In that case instead of Select() on can use Capture\-Buffers() to render the selection buffers and then get information about pixel locations suing Get\-Pixel\-Information(). Use Clear\-Buffers() to clear buffers after one's done with the scene. The optional final parameter max\-Dist will look for a cell within the specified number of pixels from display\-\_\-position.  \item {\ttfamily obj.\-Clear\-Buffers ()} -\/ Called by any vtk\-Mapper or vtk\-Prop subclass to render an attribute's id.  \item {\ttfamily obj.\-Render\-Attribute\-Id (vtk\-Id\-Type attribid)} -\/ Called by any vtk\-Mapper or vtk\-Prop subclass to render an attribute's id.  \item {\ttfamily obj.\-Begin\-Render\-Prop ()} -\/ Called by the mapper (vtk\-Hardware\-Selection\-Poly\-Data\-Painter) before and after rendering each prop.  \item {\ttfamily obj.\-End\-Render\-Prop ()} -\/ Called by the mapper (vtk\-Hardware\-Selection\-Poly\-Data\-Painter) before and after rendering each prop.  \item {\ttfamily obj.\-Set\-Process\-I\-D (int )} -\/ Get/\-Set the process id. If process id $<$ 0 (default -\/1), then the P\-R\-O\-C\-E\-S\-S\-\_\-\-P\-A\-S\-S is not rendered.  \item {\ttfamily int = obj.\-Get\-Process\-I\-D ()} -\/ Get/\-Set the process id. If process id $<$ 0 (default -\/1), then the P\-R\-O\-C\-E\-S\-S\-\_\-\-P\-A\-S\-S is not rendered.  \item {\ttfamily int = obj.\-Get\-Current\-Pass ()} -\/ Get the current pass number.  \item {\ttfamily vtk\-Selection = obj.\-Generate\-Selection ()} -\/ Generates the vtk\-Selection from pixel buffers. Requires that Capture\-Buffers() has already been called. Optionally you may pass a screen region (xmin, ymin, xmax, ymax) to generate a selection from. The region must be a subregion of the region specified by Set\-Area(), otherwise it will be clipped to that region.  \item {\ttfamily vtk\-Selection = obj.\-Generate\-Selection (int r\mbox{[}4\mbox{]})} -\/ Generates the vtk\-Selection from pixel buffers. Requires that Capture\-Buffers() has already been called. Optionally you may pass a screen region (xmin, ymin, xmax, ymax) to generate a selection from. The region must be a subregion of the region specified by Set\-Area(), otherwise it will be clipped to that region.  \item {\ttfamily vtk\-Selection = obj.\-Generate\-Selection (int x1, int y1, int x2, int y2)} -\/ Generates the vtk\-Selection from pixel buffers. Requires that Capture\-Buffers() has already been called. Optionally you may pass a screen region (xmin, ymin, xmax, ymax) to generate a selection from. The region must be a subregion of the region specified by Set\-Area(), otherwise it will be clipped to that region.  \end{DoxyItemize}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkhierarchicalpolydatamapper}{}\section{vtk\-Hierarchical\-Poly\-Data\-Mapper}\label{vtkrendering_vtkhierarchicalpolydatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Legacy class. Use vtk\-Composite\-Poly\-Data\-Mapper instead.

To create an instance of class vtk\-Hierarchical\-Poly\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHierarchicalPolyDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hierarchical\-Poly\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hierarchical\-Poly\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Hierarchical\-Poly\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Hierarchical\-Poly\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkidentcoloredpainter}{}\section{vtk\-Ident\-Colored\-Painter}\label{vtkrendering_vtkidentcoloredpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
D\-E\-P\-R\-E\-C\-A\-T\-E\-D. Refer to vtk\-Hardware\-Selection\-Poly\-Data\-Painter instead. This painter will color each polygon in a color that encodes an integer. Doing so allows us to determine what polygon is behind each pixel on the screen.

To create an instance of class vtk\-Ident\-Colored\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIdentColoredPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Ident\-Colored\-Painter 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\-Ident\-Colored\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Ident\-Colored\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Ident\-Colored\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Reset\-Current\-Id ()}  
\item {\ttfamily obj.\-Color\-By\-Constant (int constant)}  
\item {\ttfamily obj.\-Color\-By\-Increasing\-Ident (int plane)}  
\item {\ttfamily obj.\-Color\-By\-Actor\-Id (vtk\-Prop Actor\-Id)}  
\item {\ttfamily obj.\-Color\-By\-Vertex ()}  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Actor\-From\-Id (vtk\-Id\-Type id)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimageactor}{}\section{vtk\-Image\-Actor}\label{vtkrendering_vtkimageactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Actor is used to render an image in a 3\-D scene. The image is placed at the origin of the image, and its size is controlled by the image dimensions and image spacing. The orientation of the image is orthogonal to one of the x-\/y-\/z axes depending on which plane the image is defined in. vtk\-Image\-Actor duplicates the functionality of combinations of other V\-T\-K classes in a convenient, single class.

To create an instance of class vtk\-Image\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-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\-Image\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data )} -\/ Set/\-Get the image data input for the image actor.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the image data input for the image actor.  
\item {\ttfamily int = obj.\-Get\-Interpolate ()} -\/ Turn on/off linear interpolation of the image when rendering.  
\item {\ttfamily obj.\-Set\-Interpolate (int )} -\/ Turn on/off linear interpolation of the image when rendering.  
\item {\ttfamily obj.\-Interpolate\-On ()} -\/ Turn on/off linear interpolation of the image when rendering.  
\item {\ttfamily obj.\-Interpolate\-Off ()} -\/ Turn on/off linear interpolation of the image when rendering.  
\item {\ttfamily obj.\-Set\-Opacity (double )} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity\-Min\-Value ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity\-Max\-Value ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily obj.\-Set\-Display\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The image extent is generally set explicitly, but if not set it will be determined from the input image data.  
\item {\ttfamily obj.\-Set\-Display\-Extent (int min\-X, int max\-X, int min\-Y, int max\-Y, int min\-Z, int max\-Z)} -\/ The image extent is generally set explicitly, but if not set it will be determined from the input image data.  
\item {\ttfamily obj.\-Get\-Display\-Extent (int extent\mbox{[}6\mbox{]})} -\/ The image extent is generally set explicitly, but if not set it will be determined from the input image data.  
\item {\ttfamily int = obj.\-Get\-Display\-Extent ()} -\/ Get the bounds of this image actor. Either copy the bounds into a user provided array or return a pointer to an array. In either case the boudns is expressed as a 6-\/vector (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds of this image actor. Either copy the bounds into a user provided array or return a pointer to an array. In either case the boudns is expressed as a 6-\/vector (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds of this image actor. Either copy the bounds into a user provided array or return a pointer to an array. In either case the boudns is expressed as a 6-\/vector (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Display\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds of the data that is displayed by this image actor. If the transformation matrix for this actor is the identity matrix, this will return the same value as Get\-Bounds.  
\item {\ttfamily int = obj.\-Get\-Slice\-Number ()} -\/ Return the slice number (\& min/max slice number) computed from the display extent.  
\item {\ttfamily int = obj.\-Get\-Slice\-Number\-Max ()} -\/ Return the slice number (\& min/max slice number) computed from the display extent.  
\item {\ttfamily int = obj.\-Get\-Slice\-Number\-Min ()} -\/ Return the slice number (\& min/max slice number) computed from the display extent.  
\item {\ttfamily obj.\-Set\-Z\-Slice (int z)} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Z\-Slice ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Min ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Max ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimagemapper}{}\section{vtk\-Image\-Mapper}\label{vtkrendering_vtkimagemapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Mapper provides 2\-D image display support for vtk. It is a Mapper2\-D subclass that can be associated with an Actor2\-D and placed within a Render\-Window or Image\-Window.

To create an instance of class vtk\-Image\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Image\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Modifiedtime as we have added a lookuptable  
\item {\ttfamily obj.\-Set\-Color\-Window (double )} -\/ Set/\-Get the window value for window/level  
\item {\ttfamily double = obj.\-Get\-Color\-Window ()} -\/ Set/\-Get the window value for window/level  
\item {\ttfamily obj.\-Set\-Color\-Level (double )} -\/ Set/\-Get the level value for window/level  
\item {\ttfamily double = obj.\-Get\-Color\-Level ()} -\/ Set/\-Get the level value for window/level  
\item {\ttfamily obj.\-Set\-Z\-Slice (int )} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Z\-Slice ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Min ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Max ()} -\/ Set/\-Get the current slice number. The axis Z in Z\-Slice does not necessarily have any relation to the z axis of the data on disk. It is simply the axis orthogonal to the x,y, display plane. Get\-Whole\-Z\-Max and Min are convenience methods for obtaining the number of slices that can be displayed. Again the number of slices is in reference to the display z axis, which is not necessarily the z axis on disk. (due to reformatting etc)  
\item {\ttfamily obj.\-Render\-Start (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the image to the screen.  
\item {\ttfamily obj.\-Render\-Data (vtk\-Viewport , vtk\-Image\-Data , vtk\-Actor2\-D )} -\/ Function called by Render to actually draw the image to to the screen  
\item {\ttfamily double = obj.\-Get\-Color\-Shift ()} -\/ Methods used internally for performing the Window/\-Level mapping.  
\item {\ttfamily double = obj.\-Get\-Color\-Scale ()} -\/ Methods used internally for performing the Window/\-Level mapping.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data input)} -\/ Set the Input of a filter.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set the Input of a filter.  
\item {\ttfamily obj.\-Set\-Render\-To\-Rectangle (int )} -\/ If Render\-To\-Rectangle is set (by default not), then the imagemapper will render the image into the rectangle supplied by the Actor2\-D's Position\-Coordinate and Position2\-Coordinate  
\item {\ttfamily int = obj.\-Get\-Render\-To\-Rectangle ()} -\/ If Render\-To\-Rectangle is set (by default not), then the imagemapper will render the image into the rectangle supplied by the Actor2\-D's Position\-Coordinate and Position2\-Coordinate  
\item {\ttfamily obj.\-Render\-To\-Rectangle\-On ()} -\/ If Render\-To\-Rectangle is set (by default not), then the imagemapper will render the image into the rectangle supplied by the Actor2\-D's Position\-Coordinate and Position2\-Coordinate  
\item {\ttfamily obj.\-Render\-To\-Rectangle\-Off ()} -\/ If Render\-To\-Rectangle is set (by default not), then the imagemapper will render the image into the rectangle supplied by the Actor2\-D's Position\-Coordinate and Position2\-Coordinate  
\item {\ttfamily obj.\-Set\-Use\-Custom\-Extents (int )} -\/ Usually, the entire image is displayed, if Use\-Custom\-Extents is set (by default not), then the region supplied in the Custom\-Display\-Extents is used in preference. Note that the Custom extents are x,y only and the zslice is still applied  
\item {\ttfamily int = obj.\-Get\-Use\-Custom\-Extents ()} -\/ Usually, the entire image is displayed, if Use\-Custom\-Extents is set (by default not), then the region supplied in the Custom\-Display\-Extents is used in preference. Note that the Custom extents are x,y only and the zslice is still applied  
\item {\ttfamily obj.\-Use\-Custom\-Extents\-On ()} -\/ Usually, the entire image is displayed, if Use\-Custom\-Extents is set (by default not), then the region supplied in the Custom\-Display\-Extents is used in preference. Note that the Custom extents are x,y only and the zslice is still applied  
\item {\ttfamily obj.\-Use\-Custom\-Extents\-Off ()} -\/ Usually, the entire image is displayed, if Use\-Custom\-Extents is set (by default not), then the region supplied in the Custom\-Display\-Extents is used in preference. Note that the Custom extents are x,y only and the zslice is still applied  
\item {\ttfamily obj.\-Set\-Custom\-Display\-Extents (int \mbox{[}4\mbox{]})} -\/ The image extents which should be displayed with Use\-Custom\-Extents Note that the Custom extents are x,y only and the zslice is still applied  
\item {\ttfamily int = obj. Get\-Custom\-Display\-Extents ()} -\/ The image extents which should be displayed with Use\-Custom\-Extents Note that the Custom extents are x,y only and the zslice is still applied  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimageprocessingpass}{}\section{vtk\-Image\-Processing\-Pass}\label{vtkrendering_vtkimageprocessingpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Abstract class with some convenient methods frequently used in subclasses.

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

To create an instance of class vtk\-Image\-Processing\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageProcessingPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Processing\-Pass 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\-Processing\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Processing\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Processing\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Delegate\-Pass ()} -\/ Delegate for rendering the image to be processed. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Camera\-Pass or to a post-\/processing pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Delegate\-Pass (vtk\-Render\-Pass delegate\-Pass)} -\/ Delegate for rendering the image to be processed. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Camera\-Pass or to a post-\/processing pass. Initial value is a N\-U\-L\-L pointer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimageviewer}{}\section{vtk\-Image\-Viewer}\label{vtkrendering_vtkimageviewer}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Viewer is a convenience class for displaying a 2d image. It packages up the functionality found in vtk\-Render\-Window, vtk\-Renderer, vtk\-Actor2\-D and vtk\-Image\-Mapper into a single easy to use class. Behind the scenes these four classes are actually used to to provide the required functionality. vtk\-Image\-Viewer is simply a wrapper around them.

To create an instance of class vtk\-Image\-Viewer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageViewer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Viewer 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\-Viewer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Viewer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Viewer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Window\-Name ()} -\/ Get name of rendering window  
\item {\ttfamily obj.\-Render (void )} -\/ Render the resulting image.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data in)} -\/ Set/\-Get the input to the viewer.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the input to the viewer.  
\item {\ttfamily obj.\-Set\-Input\-Connection (vtk\-Algorithm\-Output input)} -\/ Set/\-Get the input to the viewer.  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Min ()} -\/ What is the possible Min/ Max z slices available.  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Max ()} -\/ What is the possible Min/ Max z slices available.  
\item {\ttfamily int = obj.\-Get\-Z\-Slice ()} -\/ Set/\-Get the current Z Slice to display  
\item {\ttfamily obj.\-Set\-Z\-Slice (int s)} -\/ Set/\-Get the current Z Slice to display  
\item {\ttfamily double = obj.\-Get\-Color\-Window ()} -\/ Sets window/level for mapping pixels to colors.  
\item {\ttfamily double = obj.\-Get\-Color\-Level ()} -\/ Sets window/level for mapping pixels to colors.  
\item {\ttfamily obj.\-Set\-Color\-Window (double s)} -\/ Sets window/level for mapping pixels to colors.  
\item {\ttfamily obj.\-Set\-Color\-Level (double s)} -\/ Sets window/level for mapping pixels to colors.  
\item {\ttfamily int = obj.\-Get\-Gray\-Scale\-Hint ()} -\/ By default this is a color viewer. Gray\-Scale\-Hint\-On will improve the appearance of gray scale images on some systems.  
\item {\ttfamily obj.\-Set\-Gray\-Scale\-Hint (int )} -\/ By default this is a color viewer. Gray\-Scale\-Hint\-On will improve the appearance of gray scale images on some systems.  
\item {\ttfamily obj.\-Gray\-Scale\-Hint\-On ()} -\/ By default this is a color viewer. Gray\-Scale\-Hint\-On will improve the appearance of gray scale images on some systems.  
\item {\ttfamily obj.\-Gray\-Scale\-Hint\-Off ()} -\/ By default this is a color viewer. Gray\-Scale\-Hint\-On will improve the appearance of gray scale images on some systems.  
\item {\ttfamily int = obj.\-Get\-Position ()} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily obj.\-Set\-Position (int a, int b)} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily obj.\-Set\-Position (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily int = obj.\-Get\-Size ()} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a, int b)} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Get the internal objects  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Get the internal objects  
\item {\ttfamily vtk\-Image\-Mapper = obj.\-Get\-Image\-Mapper ()} -\/ Get the internal objects  
\item {\ttfamily vtk\-Actor2\-D = obj.\-Get\-Actor2\-D ()} -\/ Get the internal objects  
\item {\ttfamily obj.\-Setup\-Interactor (vtk\-Render\-Window\-Interactor )} -\/ Create and attach an interactor for this window  
\item {\ttfamily obj.\-Set\-Off\-Screen\-Rendering (int )} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily int = obj.\-Get\-Off\-Screen\-Rendering ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-On ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-Off ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimageviewer2}{}\section{vtk\-Image\-Viewer2}\label{vtkrendering_vtkimageviewer2}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Viewer2 is a convenience class for displaying a 2\-D image. It packages up the functionality found in vtk\-Render\-Window, vtk\-Renderer, vtk\-Image\-Actor and vtk\-Image\-Map\-To\-Window\-Level\-Colors into a single easy to use class. This class also creates an image interactor style (vtk\-Interactor\-Style\-Image) that allows zooming and panning of images, and supports interactive window/level operations on the image. Note that vtk\-Image\-Viewer2 is simply a wrapper around these classes.

vtk\-Image\-Viewer2 uses the 3\-D rendering and texture mapping engine to draw an image on a plane. This allows for rapid rendering, zooming, and panning. The image is placed in the 3\-D scene at a depth based on the z-\/coordinate of the particular image slice. Each call to Set\-Slice() changes the image data (slice) displayed A\-N\-D changes the depth of the displayed slice in the 3\-D scene. This can be controlled by the Auto\-Adjust\-Camera\-Clipping\-Range ivar of the Interactor\-Style member.

It is possible to mix images and geometry, using the methods\-:

viewer-\/$>$Set\-Input( my\-Image ); viewer-\/$>$Get\-Renderer()-\/$>$Add\-Actor( my\-Actor );

This can be used to annotate an image with a Poly\-Data of \char`\"{}edges\char`\"{} or or highlight sections of an image or display a 3\-D isosurface with a slice from the volume, etc. Any portions of your geometry that are in front of the displayed slice will be visible; any portions of your geometry that are behind the displayed slice will be obscured. A more general framework (with respect to viewing direction) for achieving this effect is provided by the vtk\-Image\-Plane\-Widget .

Note that pressing 'r' will reset the window/level and pressing shift+'r' or control+'r' will reset the camera.

To create an instance of class vtk\-Image\-Viewer2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageViewer2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Viewer2 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\-Viewer2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Viewer2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Viewer2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily string = obj.\-Get\-Window\-Name ()} -\/ Get the name of rendering window.  
\item {\ttfamily obj.\-Render (void )} -\/ Render the resulting image.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Image\-Data in)} -\/ Set/\-Get the input image to the viewer.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Input ()} -\/ Set/\-Get the input image to the viewer.  
\item {\ttfamily obj.\-Set\-Input\-Connection (vtk\-Algorithm\-Output input)} -\/ Set/\-Get the input image to the viewer.  
\item {\ttfamily int = obj.\-Get\-Slice\-Orientation ()} -\/ Set/get the slice orientation  
\item {\ttfamily obj.\-Set\-Slice\-Orientation (int orientation)} -\/ Set/get the slice orientation  
\item {\ttfamily obj.\-Set\-Slice\-Orientation\-To\-X\-Y ()} -\/ Set/get the slice orientation  
\item {\ttfamily obj.\-Set\-Slice\-Orientation\-To\-Y\-Z ()} -\/ Set/get the slice orientation  
\item {\ttfamily obj.\-Set\-Slice\-Orientation\-To\-X\-Z ()} -\/ Set/get the slice orientation  
\item {\ttfamily int = obj.\-Get\-Slice ()} -\/ Set/\-Get the current slice to display (depending on the orientation this can be in X, Y or Z).  
\item {\ttfamily obj.\-Set\-Slice (int s)} -\/ Set/\-Get the current slice to display (depending on the orientation this can be in X, Y or Z).  
\item {\ttfamily obj.\-Update\-Display\-Extent ()} -\/ Update the display extent manually so that the proper slice for the given orientation is displayed. It will also try to set a reasonable camera clipping range. This method is called automatically when the Input is changed, but most of the time the input of this class is likely to remain the same, i.\-e. connected to the output of a filter, or an image reader. When the input of this filter or reader itself is changed, an error message might be displayed since the current display extent is probably outside the new whole extent. Calling this method will ensure that the display extent is reset properly.  
\item {\ttfamily int = obj.\-Get\-Slice\-Min ()} -\/ Return the minimum and maximum slice values (depending on the orientation this can be in X, Y or Z).  
\item {\ttfamily int = obj.\-Get\-Slice\-Max ()} -\/ Return the minimum and maximum slice values (depending on the orientation this can be in X, Y or Z).  
\item {\ttfamily obj.\-Get\-Slice\-Range (int range\mbox{[}2\mbox{]})} -\/ Return the minimum and maximum slice values (depending on the orientation this can be in X, Y or Z).  
\item {\ttfamily double = obj.\-Get\-Color\-Window ()} -\/ Set window and level for mapping pixels to colors.  
\item {\ttfamily double = obj.\-Get\-Color\-Level ()} -\/ Set window and level for mapping pixels to colors.  
\item {\ttfamily obj.\-Set\-Color\-Window (double s)} -\/ Set window and level for mapping pixels to colors.  
\item {\ttfamily obj.\-Set\-Color\-Level (double s)} -\/ Set window and level for mapping pixels to colors.  
\item {\ttfamily obj.\-Set\-Position (int a, int b)} -\/ Set/\-Get the position in screen coordinates of the rendering window.  
\item {\ttfamily obj.\-Set\-Position (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a, int b)} -\/ Set/\-Get the size of the window in screen coordinates in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Get\-Image\-Actor ()} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily vtk\-Image\-Map\-To\-Window\-Level\-Colors = obj.\-Get\-Window\-Level ()} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily vtk\-Interactor\-Style\-Image = obj.\-Get\-Interactor\-Style ()} -\/ Get the internal render window, renderer, image actor, and image map instances.  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window arg)} -\/ Set your own renderwindow and renderer  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer arg)} -\/ Set your own renderwindow and renderer  
\item {\ttfamily obj.\-Setup\-Interactor (vtk\-Render\-Window\-Interactor )} -\/ Attach an interactor for the internal render window.  
\item {\ttfamily obj.\-Set\-Off\-Screen\-Rendering (int )} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily int = obj.\-Get\-Off\-Screen\-Rendering ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-On ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily obj.\-Off\-Screen\-Rendering\-Off ()} -\/ Create a window in memory instead of on the screen. This may not be supported for every type of window and on some windows you may need to invoke this prior to the first render.  
\item {\ttfamily int = obj.\-Get\-Whole\-Z\-Min ()} -\/  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimagingfactory}{}\section{vtk\-Imaging\-Factory}\label{vtkrendering_vtkimagingfactory}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Imaging\-Factory, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImagingFactory
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Imaging\-Factory has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Imaging\-Factory class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Imaging\-Factory = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Imaging\-Factory = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkimporter}{}\section{vtk\-Importer}\label{vtkrendering_vtkimporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Importer is an abstract class that specifies the protocol for importing actors, cameras, lights and properties into a vtk\-Render\-Window. The following takes place\-: 1) Create a Render\-Window and Renderer if none is provided. 2) Call Import\-Begin, if Import\-Begin returns False, return 3) Call Read\-Data, which calls\-: a) Import the Actors b) Import the cameras c) Import the lights d) Import the Properties 7) Call Import\-End

Subclasses optionally implement the Import\-Actors, Import\-Cameras, Import\-Lights and Import\-Properties or Read\-Data methods. An Import\-Begin and Import\-End can optionally be provided to perform Importer-\/specific initialization and termination. The Read method initiates the import process. If a Render\-Window is provided, its Renderer will contained the imported objects. If the Render\-Window has no Renderer, one is created. If no Render\-Window is provided, both a Render\-Window and Renderer will be created. Both the Render\-Window and Renderer can be accessed using Get methods.

To create an instance of class vtk\-Importer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Importer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Importer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Importer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()}  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window )}  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()}  
\item {\ttfamily obj.\-Read ()}  
\item {\ttfamily obj.\-Update ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractoreventrecorder}{}\section{vtk\-Interactor\-Event\-Recorder}\label{vtkrendering_vtkinteractoreventrecorder}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Event\-Recorder records all V\-T\-K events invoked from a vtk\-Render\-Window\-Interactor. The events are recorded to a file. vtk\-Interactor\-Event\-Recorder can also be used to play those events back and invoke them on an vtk\-Render\-Window\-Interactor. (Note\-: the events can also be played back from a file or string.)

The format of the event file is simple. It is\-: Event\-Name X Y ctrl shift keycode repeat\-Count key\-Sym The format also allows \char`\"{}\#\char`\"{} comments.

To create an instance of class vtk\-Interactor\-Event\-Recorder, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorEventRecorder
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Event\-Recorder 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\-Interactor\-Event\-Recorder class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Event\-Recorder = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Event\-Recorder = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )}  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor iren)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Set/\-Get the name of a file events should be written to/from.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Set/\-Get the name of a file events should be written to/from.  
\item {\ttfamily obj.\-Record ()} -\/ Invoke this method to begin recording events. The events will be recorded to the filename indicated.  
\item {\ttfamily obj.\-Play ()} -\/ Invoke this method to begin playing events from the current position. The events will be played back from the filename indicated.  
\item {\ttfamily obj.\-Stop ()} -\/ Invoke this method to stop recording/playing events.  
\item {\ttfamily obj.\-Rewind ()} -\/ Rewind to the beginning of the file.  
\item {\ttfamily obj.\-Set\-Read\-From\-Input\-String (int )} -\/ Enable reading from an Input\-String as compared to the default behavior, which is to read from a file.  
\item {\ttfamily int = obj.\-Get\-Read\-From\-Input\-String ()} -\/ Enable reading from an Input\-String as compared to the default behavior, which is to read from a file.  
\item {\ttfamily obj.\-Read\-From\-Input\-String\-On ()} -\/ Enable reading from an Input\-String as compared to the default behavior, which is to read from a file.  
\item {\ttfamily obj.\-Read\-From\-Input\-String\-Off ()} -\/ Enable reading from an Input\-String as compared to the default behavior, which is to read from a file.  
\item {\ttfamily obj.\-Set\-Input\-String (string )} -\/ Set/\-Get the string to read from.  
\item {\ttfamily string = obj.\-Get\-Input\-String ()} -\/ Set/\-Get the string to read from.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorobserver}{}\section{vtk\-Interactor\-Observer}\label{vtkrendering_vtkinteractorobserver}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Observer is an abstract superclass for subclasses that observe events invoked by vtk\-Render\-Window\-Interactor. These subclasses are typically things like 3\-D widgets; objects that interact with actors in the scene, or interactively probe the scene for information.

vtk\-Interactor\-Observer defines the method Set\-Interactor() and enables and disables the processing of events by the vtk\-Interactor\-Observer. Use the methods Enabled\-On() or Set\-Enabled(1) to turn on the interactor observer, and the methods Enabled\-Off() or Set\-Enabled(0) to turn off the interactor. Initial value is 0.

To support interactive manipulation of objects, this class (and subclasses) invoke the events Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event. These events are invoked when the vtk\-Interactor\-Observer enters a state where rapid response is desired\-: mouse motion, etc. The events can be used, for example, to set the desired update frame rate (Start\-Interaction\-Event), operate on data or update a pipeline (Interaction\-Event), and set the desired frame rate back to normal values (End\-Interaction\-Event). Two other events, Enable\-Event and Disable\-Event, are invoked when the interactor observer is enabled or disabled.

To create an instance of class vtk\-Interactor\-Observer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorObserver
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Observer 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\-Interactor\-Observer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Observer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Observer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods for turning the interactor observer on and off, and determining its state. All subclasses must provide the Set\-Enabled() method. Enabling a vtk\-Interactor\-Observer has the side effect of adding observers; disabling it removes the observers. Prior to enabling the vtk\-Interactor\-Observer you must set the render window interactor (via Set\-Interactor()). Initial value is 0.  
\item {\ttfamily int = obj.\-Get\-Enabled ()} -\/ Methods for turning the interactor observer on and off, and determining its state. All subclasses must provide the Set\-Enabled() method. Enabling a vtk\-Interactor\-Observer has the side effect of adding observers; disabling it removes the observers. Prior to enabling the vtk\-Interactor\-Observer you must set the render window interactor (via Set\-Interactor()). Initial value is 0.  
\item {\ttfamily obj.\-Enabled\-On ()} -\/ Methods for turning the interactor observer on and off, and determining its state. All subclasses must provide the Set\-Enabled() method. Enabling a vtk\-Interactor\-Observer has the side effect of adding observers; disabling it removes the observers. Prior to enabling the vtk\-Interactor\-Observer you must set the render window interactor (via Set\-Interactor()). Initial value is 0.  
\item {\ttfamily obj.\-Enabled\-Off ()} -\/ Methods for turning the interactor observer on and off, and determining its state. All subclasses must provide the Set\-Enabled() method. Enabling a vtk\-Interactor\-Observer has the side effect of adding observers; disabling it removes the observers. Prior to enabling the vtk\-Interactor\-Observer you must set the render window interactor (via Set\-Interactor()). Initial value is 0.  
\item {\ttfamily obj.\-On ()} -\/ Methods for turning the interactor observer on and off, and determining its state. All subclasses must provide the Set\-Enabled() method. Enabling a vtk\-Interactor\-Observer has the side effect of adding observers; disabling it removes the observers. Prior to enabling the vtk\-Interactor\-Observer you must set the render window interactor (via Set\-Interactor()). Initial value is 0.  
\item {\ttfamily obj.\-Off ()} -\/ This method is used to associate the widget with the render window interactor. Observers of the appropriate events invoked in the render window interactor are set up as a result of this method invocation. The Set\-Interactor() method must be invoked prior to enabling the vtk\-Interactor\-Observer.  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor iren)} -\/ This method is used to associate the widget with the render window interactor. Observers of the appropriate events invoked in the render window interactor are set up as a result of this method invocation. The Set\-Interactor() method must be invoked prior to enabling the vtk\-Interactor\-Observer.  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-Get\-Interactor ()} -\/ This method is used to associate the widget with the render window interactor. Observers of the appropriate events invoked in the render window interactor are set up as a result of this method invocation. The Set\-Interactor() method must be invoked prior to enabling the vtk\-Interactor\-Observer.  
\item {\ttfamily obj.\-Set\-Priority (float )} -\/ Set/\-Get the priority at which events are processed. This is used when multiple interactor observers are used simultaneously. The default value is 0.\-0 (lowest priority.) Note that when multiple interactor observer have the same priority, then the last observer added will process the event first. (Note\-: once the Set\-Interactor() method has been called, changing the priority does not effect event processing. You will have to Set\-Interactor(\-N\-U\-L\-L), change priority, and then Set\-Interactor(iren) to have the priority take effect.)  
\item {\ttfamily float = obj.\-Get\-Priority\-Min\-Value ()} -\/ Set/\-Get the priority at which events are processed. This is used when multiple interactor observers are used simultaneously. The default value is 0.\-0 (lowest priority.) Note that when multiple interactor observer have the same priority, then the last observer added will process the event first. (Note\-: once the Set\-Interactor() method has been called, changing the priority does not effect event processing. You will have to Set\-Interactor(\-N\-U\-L\-L), change priority, and then Set\-Interactor(iren) to have the priority take effect.)  
\item {\ttfamily float = obj.\-Get\-Priority\-Max\-Value ()} -\/ Set/\-Get the priority at which events are processed. This is used when multiple interactor observers are used simultaneously. The default value is 0.\-0 (lowest priority.) Note that when multiple interactor observer have the same priority, then the last observer added will process the event first. (Note\-: once the Set\-Interactor() method has been called, changing the priority does not effect event processing. You will have to Set\-Interactor(\-N\-U\-L\-L), change priority, and then Set\-Interactor(iren) to have the priority take effect.)  
\item {\ttfamily float = obj.\-Get\-Priority ()} -\/ Set/\-Get the priority at which events are processed. This is used when multiple interactor observers are used simultaneously. The default value is 0.\-0 (lowest priority.) Note that when multiple interactor observer have the same priority, then the last observer added will process the event first. (Note\-: once the Set\-Interactor() method has been called, changing the priority does not effect event processing. You will have to Set\-Interactor(\-N\-U\-L\-L), change priority, and then Set\-Interactor(iren) to have the priority take effect.)  
\item {\ttfamily obj.\-Set\-Key\-Press\-Activation (int )} -\/ Enable/\-Disable of the use of a keypress to turn on and off the interactor observer. (By default, the keypress is 'i' for \char`\"{}interactor
 observer\char`\"{}.) Set the Key\-Press\-Activation\-Value to change which key activates the widget.)  
\item {\ttfamily int = obj.\-Get\-Key\-Press\-Activation ()} -\/ Enable/\-Disable of the use of a keypress to turn on and off the interactor observer. (By default, the keypress is 'i' for \char`\"{}interactor
 observer\char`\"{}.) Set the Key\-Press\-Activation\-Value to change which key activates the widget.)  
\item {\ttfamily obj.\-Key\-Press\-Activation\-On ()} -\/ Enable/\-Disable of the use of a keypress to turn on and off the interactor observer. (By default, the keypress is 'i' for \char`\"{}interactor
 observer\char`\"{}.) Set the Key\-Press\-Activation\-Value to change which key activates the widget.)  
\item {\ttfamily obj.\-Key\-Press\-Activation\-Off ()} -\/ Enable/\-Disable of the use of a keypress to turn on and off the interactor observer. (By default, the keypress is 'i' for \char`\"{}interactor
 observer\char`\"{}.) Set the Key\-Press\-Activation\-Value to change which key activates the widget.)  
\item {\ttfamily obj.\-Set\-Key\-Press\-Activation\-Value (char )} -\/ Specify which key press value to use to activate the interactor observer (if key press activation is enabled). By default, the key press activation value is 'i'. Note\-: once the Set\-Interactor() method is invoked, changing the key press activation value will not affect the key press until Set\-Interactor(\-N\-U\-L\-L)/\-Set\-Interactor(iren) is called.  
\item {\ttfamily char = obj.\-Get\-Key\-Press\-Activation\-Value ()} -\/ Specify which key press value to use to activate the interactor observer (if key press activation is enabled). By default, the key press activation value is 'i'. Note\-: once the Set\-Interactor() method is invoked, changing the key press activation value will not affect the key press until Set\-Interactor(\-N\-U\-L\-L)/\-Set\-Interactor(iren) is called.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Default\-Renderer ()} -\/ Set/\-Get the default renderer to use when activating the interactor observer. Normally when the widget is activated (Set\-Enabled(1) or when keypress activation takes place), the renderer over which the mouse pointer is positioned is used. Alternatively, you can specify the renderer to bind the interactor to when the interactor observer is activated.  
\item {\ttfamily obj.\-Set\-Default\-Renderer (vtk\-Renderer )} -\/ Set/\-Get the default renderer to use when activating the interactor observer. Normally when the widget is activated (Set\-Enabled(1) or when keypress activation takes place), the renderer over which the mouse pointer is positioned is used. Alternatively, you can specify the renderer to bind the interactor to when the interactor observer is activated.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Current\-Renderer ()} -\/ Set/\-Get the current renderer. Normally when the widget is activated (Set\-Enabled(1) or when keypress activation takes place), the renderer over which the mouse pointer is positioned is used and assigned to this Ivar. Alternatively, you might want to set the Current\-Renderer explicitly. W\-A\-R\-N\-I\-N\-G\-: note that if the Default\-Renderer Ivar is set (see above), it will always override the parameter passed to Set\-Current\-Renderer, unless it is N\-U\-L\-L. (i.\-e., Set\-Current\-Renderer(foo) = Set\-Current\-Renderer(\-Default\-Renderer).  
\item {\ttfamily obj.\-Set\-Current\-Renderer (vtk\-Renderer )} -\/ Set/\-Get the current renderer. Normally when the widget is activated (Set\-Enabled(1) or when keypress activation takes place), the renderer over which the mouse pointer is positioned is used and assigned to this Ivar. Alternatively, you might want to set the Current\-Renderer explicitly. W\-A\-R\-N\-I\-N\-G\-: note that if the Default\-Renderer Ivar is set (see above), it will always override the parameter passed to Set\-Current\-Renderer, unless it is N\-U\-L\-L. (i.\-e., Set\-Current\-Renderer(foo) = Set\-Current\-Renderer(\-Default\-Renderer).  
\item {\ttfamily obj.\-On\-Char ()} -\/ Sets up the keypress-\/i event.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyle}{}\section{vtk\-Interactor\-Style}\label{vtkrendering_vtkinteractorstyle}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style is a base class implementing the majority of motion control routines and defines an event driven interface to support vtk\-Render\-Window\-Interactor. vtk\-Render\-Window\-Interactor implements platform dependent key/mouse routing and timer control, which forwards events in a neutral form to vtk\-Interactor\-Style.

vtk\-Interactor\-Style implements the \char`\"{}joystick\char`\"{} style of interaction. That is, holding down the mouse keys generates a stream of events that cause continuous actions (e.\-g., rotate, translate, pan, zoom). (The class vtk\-Interactor\-Style\-Trackball implements a grab and move style.) The event bindings for this class include the following\-:
\begin{DoxyItemize}
\item Keypress j / Keypress t\-: toggle between joystick (position sensitive) and trackball (motion sensitive) styles. In joystick style, motion occurs continuously as long as a mouse button is pressed. In trackball style, motion occurs when the mouse button is pressed and the mouse pointer moves.
\item Keypress c / Keypress a\-: toggle between camera and actor modes. In camera mode, mouse events affect the camera position and focal point. In actor mode, mouse events affect the actor that is under the mouse pointer.
\item Button 1\-: rotate the camera around its focal point (if camera mode) or rotate the actor around its origin (if actor mode). The rotation is in the direction defined from the center of the renderer's viewport towards the mouse position. In joystick mode, the magnitude of the rotation is determined by the distance the mouse is from the center of the render window.
\item Button 2\-: pan the camera (if camera mode) or translate the actor (if actor mode). In joystick mode, the direction of pan or translation is from the center of the viewport towards the mouse position. In trackball mode, the direction of motion is the direction the mouse moves. (Note\-: with 2-\/button mice, pan is defined as $<$Shift$>$-\/\-Button 1.)
\item Button 3\-: zoom the camera (if camera mode) or scale the actor (if actor mode). Zoom in/increase scale if the mouse position is in the top half of the viewport; zoom out/decrease scale if the mouse position is in the bottom half. In joystick mode, the amount of zoom is controlled by the distance of the mouse pointer from the horizontal centerline of the window.
\item Keypress 3\-: toggle the render window into and out of stereo mode. By default, red-\/blue stereo pairs are created. Some systems support Crystal Eyes L\-C\-D stereo glasses; you have to invoke Set\-Stereo\-Type\-To\-Crystal\-Eyes() on the rendering window.
\item Keypress e\-: exit the application.
\item Keypress f\-: fly to the picked point
\item Keypress p\-: perform a pick operation. The render window interactor has an internal instance of vtk\-Cell\-Picker that it uses to pick.
\item Keypress r\-: reset the camera view along the current view direction. Centers the actors and moves the camera so that all actors are visible.
\item Keypress s\-: modify the representation of all actors so that they are surfaces.
\item Keypress u\-: invoke the user-\/defined function. Typically, this keypress will bring up an interactor that you can type commands in. Typing u calls User\-Call\-Back() on the vtk\-Render\-Window\-Interactor, which invokes a vtk\-Command\-::\-User\-Event. In other words, to define a user-\/defined callback, just add an observer to the vtk\-Command\-::\-User\-Event on the vtk\-Render\-Window\-Interactor object.
\item Keypress w\-: modify the representation of all actors so that they are wireframe.
\end{DoxyItemize}

vtk\-Interactor\-Style can be subclassed to provide new interaction styles and a facility to override any of the default mouse/key operations which currently handle trackball or joystick styles is provided. Note that this class will fire a variety of events that can be watched using an observer, such as Left\-Button\-Press\-Event, Left\-Button\-Release\-Event, Middle\-Button\-Press\-Event, Middle\-Button\-Release\-Event, Right\-Button\-Press\-Event, Right\-Button\-Release\-Event, Enter\-Event, Leave\-Event, Key\-Press\-Event, Key\-Release\-Event, Char\-Event, Expose\-Event, Configure\-Event, Timer\-Event, Mouse\-Move\-Event,

To create an instance of class vtk\-Interactor\-Style, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyle
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style 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\-Interactor\-Style class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor interactor)} -\/ Set/\-Get the Interactor wrapper being controlled by this object. (Satisfy superclass A\-P\-I.)  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Turn on/off this interactor. Interactor styles operate a little bit differently than other types of interactor observers. When the Set\-Interactor() method is invoked, the automatically enable themselves. This is a legacy requirement, and convenient for the user.  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Camera\-Clipping\-Range (int )} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Camera\-Clipping\-Range\-Min\-Value ()} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Camera\-Clipping\-Range\-Max\-Value ()} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily int = obj.\-Get\-Auto\-Adjust\-Camera\-Clipping\-Range ()} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily obj.\-Auto\-Adjust\-Camera\-Clipping\-Range\-On ()} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily obj.\-Auto\-Adjust\-Camera\-Clipping\-Range\-Off ()} -\/ If Auto\-Adjust\-Camera\-Clipping\-Range is on, then before each render the camera clipping range will be adjusted to \char`\"{}fit\char`\"{} the whole scene. Clipping will still occur if objects in the scene are behind the camera or come very close. If Auto\-Adjust\-Camera\-Clipping\-Range is off, no adjustment will be made per render, but the camera clipping range will still be reset when the camera is reset.  
\item {\ttfamily obj.\-Find\-Poked\-Renderer (int , int )} -\/ When an event occurs, we must determine which Renderer the event occurred within, since one Render\-Window may contain multiple renderers.  
\item {\ttfamily int = obj.\-Get\-State ()} -\/ Some useful information for interaction  
\item {\ttfamily int = obj.\-Get\-Use\-Timers ()} -\/ Set/\-Get timer hint  
\item {\ttfamily obj.\-Set\-Use\-Timers (int )} -\/ Set/\-Get timer hint  
\item {\ttfamily obj.\-Use\-Timers\-On ()} -\/ Set/\-Get timer hint  
\item {\ttfamily obj.\-Use\-Timers\-Off ()} -\/ Set/\-Get timer hint  
\item {\ttfamily obj.\-Set\-Timer\-Duration (long )} -\/ If using timers, specify the default timer interval (in milliseconds). Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily Get\-Timer\-Duration\-Min\-Value = obj.()} -\/ If using timers, specify the default timer interval (in milliseconds). Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily Get\-Timer\-Duration\-Max\-Value = obj.()} -\/ If using timers, specify the default timer interval (in milliseconds). Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily long = obj.\-Get\-Timer\-Duration ()} -\/ If using timers, specify the default timer interval (in milliseconds). Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily obj.\-Set\-Handle\-Observers (int )} -\/ Does Process\-Events handle observers on this class or not  
\item {\ttfamily int = obj.\-Get\-Handle\-Observers ()} -\/ Does Process\-Events handle observers on this class or not  
\item {\ttfamily obj.\-Handle\-Observers\-On ()} -\/ Does Process\-Events handle observers on this class or not  
\item {\ttfamily obj.\-Handle\-Observers\-Off ()} -\/ Does Process\-Events handle observers on this class or not  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Forward ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Backward ()} -\/ Generic event bindings can be overridden in subclasses  
\item {\ttfamily obj.\-On\-Char ()} -\/ On\-Char is triggered when an A\-S\-C\-I\-I key is pressed. Some basic key presses are handled here ('q' for Quit, 'p' for Pick, etc)  
\item {\ttfamily obj.\-On\-Key\-Down ()}  
\item {\ttfamily obj.\-On\-Key\-Up ()}  
\item {\ttfamily obj.\-On\-Key\-Press ()}  
\item {\ttfamily obj.\-On\-Key\-Release ()}  
\item {\ttfamily obj.\-On\-Expose ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Configure ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Enter ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Leave ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Timer ()} -\/ On\-Timer calls Rotate, Rotate etc which should be overridden by style subclasses.  
\item {\ttfamily obj.\-Rotate ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Spin ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Pan ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Dolly ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Zoom ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Uniform\-Scale ()} -\/ These methods for the different interactions in different modes are overridden in subclasses to perform the correct motion. Since they might be called from On\-Timer, they do not have mouse coord parameters (use interactor's Get\-Event\-Position and Get\-Last\-Event\-Position)  
\item {\ttfamily obj.\-Start\-State (int newstate)} -\/ utility routines used by state changes  
\item {\ttfamily obj.\-Stop\-State ()} -\/ utility routines used by state changes  
\item {\ttfamily obj.\-Start\-Animate ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Stop\-Animate ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Rotate ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Rotate ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Zoom ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Zoom ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Pan ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Pan ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Spin ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Spin ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Dolly ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Dolly ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Uniform\-Scale ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Uniform\-Scale ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Start\-Timer ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-End\-Timer ()} -\/ Interaction mode entry points used internally.  
\item {\ttfamily obj.\-Highlight\-Prop (vtk\-Prop prop)} -\/ When picking successfully selects an actor, this method highlights the picked prop appropriately. Currently this is done by placing a bounding box around a picked vtk\-Prop3\-D, and using the Pick\-Color to highlight a vtk\-Prop2\-D.  
\item {\ttfamily obj.\-Highlight\-Actor2\-D (vtk\-Actor2\-D actor2\-D)} -\/ When picking successfully selects an actor, this method highlights the picked prop appropriately. Currently this is done by placing a bounding box around a picked vtk\-Prop3\-D, and using the Pick\-Color to highlight a vtk\-Prop2\-D.  
\item {\ttfamily obj.\-Highlight\-Prop3\-D (vtk\-Prop3\-D prop3\-D)} -\/ When picking successfully selects an actor, this method highlights the picked prop appropriately. Currently this is done by placing a bounding box around a picked vtk\-Prop3\-D, and using the Pick\-Color to highlight a vtk\-Prop2\-D.  
\item {\ttfamily obj.\-Set\-Pick\-Color (double , double , double )} -\/ Set/\-Get the pick color (used by default to color vtk\-Actor2\-D's). The color is expressed as red/green/blue values between (0.\-0,1.\-0).  
\item {\ttfamily obj.\-Set\-Pick\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the pick color (used by default to color vtk\-Actor2\-D's). The color is expressed as red/green/blue values between (0.\-0,1.\-0).  
\item {\ttfamily double = obj. Get\-Pick\-Color ()} -\/ Set/\-Get the pick color (used by default to color vtk\-Actor2\-D's). The color is expressed as red/green/blue values between (0.\-0,1.\-0).  
\item {\ttfamily obj.\-Set\-Mouse\-Wheel\-Motion\-Factor (double )} -\/ Set/\-Get the mouse wheel motion factor. Default to 1.\-0. Set it to a different value to emphasize or de-\/emphasize the action triggered by mouse wheel motion.  
\item {\ttfamily double = obj.\-Get\-Mouse\-Wheel\-Motion\-Factor ()} -\/ Set/\-Get the mouse wheel motion factor. Default to 1.\-0. Set it to a different value to emphasize or de-\/emphasize the action triggered by mouse wheel motion.  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style = obj.\-Get\-T\-Dx\-Style ()} -\/ 3\-Dconnexion device interactor style. Initial value is a pointer to an object of class vtk\-Tdx\-Interactor\-Style\-Camera.  
\item {\ttfamily obj.\-Set\-T\-Dx\-Style (vtk\-T\-Dx\-Interactor\-Style tdx\-Style)} -\/ 3\-Dconnexion device interactor style. Initial value is a pointer to an object of class vtk\-Tdx\-Interactor\-Style\-Camera.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleflight}{}\section{vtk\-Interactor\-Style\-Flight}\label{vtkrendering_vtkinteractorstyleflight}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Left mouse button press produces forward motion. Right mouse button press produces reverse motion. Moving mouse during motion steers user in desired direction. Keyboard controls are\-: Left/\-Right/\-Up/\-Down Arrows for steering direction 'A' forward, 'Z' reverse motion Ctrl Key causes sidestep instead of steering in mouse and key modes Shift key is accelerator in mouse and key modes Ctrl and Shift together causes Roll in mouse and key modes

By default, one \char`\"{}step\char`\"{} of motion corresponds to 1/250th of the diagonal of bounding box of visible actors, '+' and '-\/' keys allow user to increase or decrease step size.

To create an instance of class vtk\-Interactor\-Style\-Flight, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleFlight
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Flight 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\-Interactor\-Style\-Flight class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Flight = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Flight = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Jump\-To (double campos\mbox{[}3\mbox{]}, double focpos\mbox{[}3\mbox{]})} -\/ Move the Eye/\-Camera to a specific location (no intermediate steps are taken  
\item {\ttfamily obj.\-Set\-Motion\-Step\-Size (double )} -\/ Set the basic unit step size \-: by default 1/250 of bounding diagonal  
\item {\ttfamily double = obj.\-Get\-Motion\-Step\-Size ()} -\/ Set the basic unit step size \-: by default 1/250 of bounding diagonal  
\item {\ttfamily obj.\-Set\-Motion\-Acceleration\-Factor (double )} -\/ Set acceleration factor when shift key is applied \-: default 10  
\item {\ttfamily double = obj.\-Get\-Motion\-Acceleration\-Factor ()} -\/ Set acceleration factor when shift key is applied \-: default 10  
\item {\ttfamily obj.\-Set\-Angle\-Step\-Size (double )} -\/ Set the basic angular unit for turning \-: default 1 degree  
\item {\ttfamily double = obj.\-Get\-Angle\-Step\-Size ()} -\/ Set the basic angular unit for turning \-: default 1 degree  
\item {\ttfamily obj.\-Set\-Angle\-Acceleration\-Factor (double )} -\/ Set angular acceleration when shift key is applied \-: default 5  
\item {\ttfamily double = obj.\-Get\-Angle\-Acceleration\-Factor ()} -\/ Set angular acceleration when shift key is applied \-: default 5  
\item {\ttfamily obj.\-Set\-Disable\-Motion (int )} -\/ Disable motion (temporarily -\/ for viewing etc)  
\item {\ttfamily int = obj.\-Get\-Disable\-Motion ()} -\/ Disable motion (temporarily -\/ for viewing etc)  
\item {\ttfamily obj.\-Disable\-Motion\-On ()} -\/ Disable motion (temporarily -\/ for viewing etc)  
\item {\ttfamily obj.\-Disable\-Motion\-Off ()} -\/ Disable motion (temporarily -\/ for viewing etc)  
\item {\ttfamily obj.\-Set\-Restore\-Up\-Vector (int )} -\/ When flying, apply a restorative force to the \char`\"{}\-Up\char`\"{} vector. This is activated when the current 'up' is close to the actual 'up' (as defined in Default\-Up\-Vector). This prevents excessive twisting forces when viewing from arbitrary angles, but keep the horizon level when the user is flying over terrain.  
\item {\ttfamily int = obj.\-Get\-Restore\-Up\-Vector ()} -\/ When flying, apply a restorative force to the \char`\"{}\-Up\char`\"{} vector. This is activated when the current 'up' is close to the actual 'up' (as defined in Default\-Up\-Vector). This prevents excessive twisting forces when viewing from arbitrary angles, but keep the horizon level when the user is flying over terrain.  
\item {\ttfamily obj.\-Restore\-Up\-Vector\-On ()} -\/ When flying, apply a restorative force to the \char`\"{}\-Up\char`\"{} vector. This is activated when the current 'up' is close to the actual 'up' (as defined in Default\-Up\-Vector). This prevents excessive twisting forces when viewing from arbitrary angles, but keep the horizon level when the user is flying over terrain.  
\item {\ttfamily obj.\-Restore\-Up\-Vector\-Off ()} -\/ When flying, apply a restorative force to the \char`\"{}\-Up\char`\"{} vector. This is activated when the current 'up' is close to the actual 'up' (as defined in Default\-Up\-Vector). This prevents excessive twisting forces when viewing from arbitrary angles, but keep the horizon level when the user is flying over terrain.  
\item {\ttfamily double = obj. Get\-Default\-Up\-Vector ()}  
\item {\ttfamily obj.\-Set\-Default\-Up\-Vector (double \mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Concrete implementation of Mouse event bindings for flight  
\item {\ttfamily obj.\-On\-Char ()} -\/ Concrete implementation of Keyboard event bindings for flight  
\item {\ttfamily obj.\-On\-Key\-Down ()} -\/ Concrete implementation of Keyboard event bindings for flight  
\item {\ttfamily obj.\-On\-Key\-Up ()} -\/ Concrete implementation of Keyboard event bindings for flight  
\item {\ttfamily obj.\-On\-Timer ()} -\/ Concrete implementation of Keyboard event bindings for flight  
\item {\ttfamily obj.\-Forward\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\item {\ttfamily obj.\-Reverse\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\item {\ttfamily obj.\-Start\-Forward\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\item {\ttfamily obj.\-End\-Forward\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\item {\ttfamily obj.\-Start\-Reverse\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\item {\ttfamily obj.\-End\-Reverse\-Fly ()} -\/ Concrete implementation of Keyboard event bindings for flight


\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleimage}{}\section{vtk\-Interactor\-Style\-Image}\label{vtkrendering_vtkinteractorstyleimage}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Image allows the user to interactively manipulate (rotate, pan, zoomm etc.) the camera. vtk\-Interactor\-Style\-Image is specially designed to work with images that are being rendered with vtk\-Image\-Actor. Several events are overloaded from its superclass vtk\-Interactor\-Style, hence the mouse bindings are different. (The bindings keep the camera's view plane normal perpendicular to the x-\/y plane.) In summary the mouse events are as follows\-:
\begin{DoxyItemize}
\item Left Mouse button triggers window level events
\item C\-T\-R\-L Left Mouse spins the camera around its view plane normal
\item S\-H\-I\-F\-T Left Mouse pans the camera
\item C\-T\-R\-L S\-H\-I\-F\-T Left Mouse dollys (a positional zoom) the camera
\item Middle mouse button pans the camera
\item Right mouse button dollys the camera.
\item S\-H\-I\-F\-T Right Mouse triggers pick events
\end{DoxyItemize}

Note that the renderer's actors are not moved; instead the camera is moved.

To create an instance of class vtk\-Interactor\-Style\-Image, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleImage
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-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\-Interactor\-Style\-Image class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Image = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Image = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Window\-Level\-Start\-Position ()} -\/ Some useful information for handling window level  
\item {\ttfamily int = obj. Get\-Window\-Level\-Current\-Position ()} -\/ Some useful information for handling window level  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Char ()} -\/ Override the \char`\"{}fly-\/to\char`\"{} (f keypress) for images.  
\item {\ttfamily obj.\-Window\-Level ()}  
\item {\ttfamily obj.\-Pick ()}  
\item {\ttfamily obj.\-Start\-Window\-Level ()}  
\item {\ttfamily obj.\-End\-Window\-Level ()}  
\item {\ttfamily obj.\-Start\-Pick ()}  
\item {\ttfamily obj.\-End\-Pick ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylejoystickactor}{}\section{vtk\-Interactor\-Style\-Joystick\-Actor}\label{vtkrendering_vtkinteractorstylejoystickactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class vtk\-Interactor\-Style\-Joystick\-Actor allows the user to interact with (rotate, zoom, etc.) separate objects in the scene independent of each other. The position of the mouse relative to the center of the object determines the speed of the object's motion. The mouse's velocity detemines the acceleration of the object's motion, so the object will continue moving even when the mouse is not moving. For a 3-\/button mouse, the left button is for rotation, the right button for zooming, the middle button for panning, and ctrl + left button for spinning. (With fewer mouse buttons, ctrl + shift + left button is for zooming, and shift + left button is for panning.)

To create an instance of class vtk\-Interactor\-Style\-Joystick\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleJoystickActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Joystick\-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\-Interactor\-Style\-Joystick\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Joystick\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Joystick\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-Rotate ()}  
\item {\ttfamily obj.\-Spin ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-Dolly ()}  
\item {\ttfamily obj.\-Uniform\-Scale ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylejoystickcamera}{}\section{vtk\-Interactor\-Style\-Joystick\-Camera}\label{vtkrendering_vtkinteractorstylejoystickcamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Joystick\-Camera allows the user to move (rotate, pan, etc.) the camera, the point of view for the scene. The position of the mouse relative to the center of the scene determines the speed at which the camera moves, and the speed of the mouse movement determines the acceleration of the camera, so the camera continues to move even if the mouse if not moving. For a 3-\/button mouse, the left button is for rotation, the right button for zooming, the middle button for panning, and ctrl + left button for spinning. (With fewer mouse buttons, ctrl + shift + left button is for zooming, and shift + left button is for panning.)

To create an instance of class vtk\-Interactor\-Style\-Joystick\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleJoystickCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Joystick\-Camera 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\-Interactor\-Style\-Joystick\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Joystick\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Joystick\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Forward ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Backward ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-Rotate ()}  
\item {\ttfamily obj.\-Spin ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-Dolly ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylerubberband2d}{}\section{vtk\-Interactor\-Style\-Rubber\-Band2\-D}\label{vtkrendering_vtkinteractorstylerubberband2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Rubber\-Band2\-D manages interaction in a 2\-D view. Camera rotation is not allowed with this interactor style. The style also allows draws a rubber band using the left button. All camera changes invoke Interaction\-Begin\-Event when the button is pressed, Interaction\-Event when the mouse (or wheel) is moved, and Interaction\-End\-Event when the button is released. The bindings are as follows\-: Left mouse -\/ Select (invokes a Selection\-Changed\-Event). Right mouse -\/ Zoom. Middle mouse -\/ Pan. Scroll wheel -\/ Zoom.

To create an instance of class vtk\-Interactor\-Style\-Rubber\-Band2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleRubberBand2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Rubber\-Band2\-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\-Interactor\-Style\-Rubber\-Band2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()}  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Forward ()}  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Backward ()}  
\item {\ttfamily obj.\-Set\-Render\-On\-Mouse\-Move (bool )} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily bool = obj.\-Get\-Render\-On\-Mouse\-Move ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily obj.\-Render\-On\-Mouse\-Move\-On ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily obj.\-Render\-On\-Mouse\-Move\-Off ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily int = obj.\-Get\-Interaction ()} -\/ Current interaction state  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylerubberband3d}{}\section{vtk\-Interactor\-Style\-Rubber\-Band3\-D}\label{vtkrendering_vtkinteractorstylerubberband3d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Rubber\-Band3\-D manages interaction in a 3\-D view. The style also allows draws a rubber band using the left button. All camera changes invoke Interaction\-Begin\-Event when the button is pressed, Interaction\-Event when the mouse (or wheel) is moved, and Interaction\-End\-Event when the button is released. The bindings are as follows\-: Left mouse -\/ Select (invokes a Selection\-Changed\-Event). Right mouse -\/ Rotate. Shift + right mouse -\/ Zoom. Middle mouse -\/ Pan. Scroll wheel -\/ Zoom.

To create an instance of class vtk\-Interactor\-Style\-Rubber\-Band3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleRubberBand3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Rubber\-Band3\-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\-Interactor\-Style\-Rubber\-Band3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()}  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()}  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Forward ()}  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Backward ()}  
\item {\ttfamily obj.\-Set\-Render\-On\-Mouse\-Move (bool )} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily bool = obj.\-Get\-Render\-On\-Mouse\-Move ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily obj.\-Render\-On\-Mouse\-Move\-On ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily obj.\-Render\-On\-Mouse\-Move\-Off ()} -\/ Whether to invoke a render when the mouse moves.  
\item {\ttfamily int = obj.\-Get\-Interaction ()} -\/ Current interaction state  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylerubberbandpick}{}\section{vtk\-Interactor\-Style\-Rubber\-Band\-Pick}\label{vtkrendering_vtkinteractorstylerubberbandpick}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This interactor style allows the user to draw a rectangle in the render window by hitting 'r' and then using the left mouse button. When the mouse button is released, the attached picker operates on the pixel in the center of the selection rectangle. If the picker happens to be a vtk\-Area\-Picker it will operate on the entire selection rectangle. When the 'p' key is hit the above pick operation occurs on a 1x1 rectangle. In other respects it behaves the same as its parent class.

To create an instance of class vtk\-Interactor\-Style\-Rubber\-Band\-Pick, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleRubberBandPick
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Rubber\-Band\-Pick 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\-Interactor\-Style\-Rubber\-Band\-Pick class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band\-Pick = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band\-Pick = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start\-Select ()}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings  
\item {\ttfamily obj.\-On\-Char ()} -\/ Event bindings  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstylerubberbandzoom}{}\section{vtk\-Interactor\-Style\-Rubber\-Band\-Zoom}\label{vtkrendering_vtkinteractorstylerubberbandzoom}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This interactor style allows the user to draw a rectangle in the render window using the left mouse button. When the mouse button is released, the current camera zooms by an amount determined from the shorter side of the drawn rectangle.

To create an instance of class vtk\-Interactor\-Style\-Rubber\-Band\-Zoom, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleRubberBandZoom
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Rubber\-Band\-Zoom 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\-Interactor\-Style\-Rubber\-Band\-Zoom class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band\-Zoom = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Rubber\-Band\-Zoom = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleswitch}{}\section{vtk\-Interactor\-Style\-Switch}\label{vtkrendering_vtkinteractorstyleswitch}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class vtk\-Interactor\-Style\-Switch allows handles interactively switching between four interactor styles -- joystick actor, joystick camera, trackball actor, and trackball camera. Type 'j' or 't' to select joystick or trackball, and type 'c' or 'a' to select camera or actor. The default interactor style is joystick camera.

To create an instance of class vtk\-Interactor\-Style\-Switch, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleSwitch
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Switch 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\-Interactor\-Style\-Switch class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Switch = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Switch = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor iren)} -\/ The sub styles need the interactor too.  
\item {\ttfamily obj.\-Set\-Auto\-Adjust\-Camera\-Clipping\-Range (int value)} -\/ We must override this method in order to pass the setting down to the underlying styles  
\item {\ttfamily vtk\-Interactor\-Style = obj.\-Get\-Current\-Style ()} -\/ Set/\-Get current style  
\item {\ttfamily obj.\-Set\-Current\-Style\-To\-Joystick\-Actor ()} -\/ Set/\-Get current style  
\item {\ttfamily obj.\-Set\-Current\-Style\-To\-Joystick\-Camera ()} -\/ Set/\-Get current style  
\item {\ttfamily obj.\-Set\-Current\-Style\-To\-Trackball\-Actor ()} -\/ Set/\-Get current style  
\item {\ttfamily obj.\-Set\-Current\-Style\-To\-Trackball\-Camera ()} -\/ Set/\-Get current style  
\item {\ttfamily obj.\-On\-Char ()} -\/ Only care about the char event, which is used to switch between different styles.  
\item {\ttfamily obj.\-Set\-Default\-Renderer (vtk\-Renderer )} -\/ Overridden from vtk\-Interactor\-Observer because the interactor styles used by this class must also be updated.  
\item {\ttfamily obj.\-Set\-Current\-Renderer (vtk\-Renderer )} -\/ Overridden from vtk\-Interactor\-Observer because the interactor styles used by this class must also be updated.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleterrain}{}\section{vtk\-Interactor\-Style\-Terrain}\label{vtkrendering_vtkinteractorstyleterrain}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Terrain is used to manipulate a camera which is viewing a scene with a natural view up, e.\-g., terrain. The camera in such a scene is manipulated by specifying azimuth (angle around the view up vector) and elevation (the angle from the horizon).

The mouse binding for this class is as follows. Left mouse click followed rotates the camera around the focal point using both elevation and azimuth invocations on the camera. Left mouse motion in the horizontal direction results in azimuth motion; left mouse motion in the vertical direction results in elevation motion. Therefore, diagonal motion results in a combination of azimuth and elevation. (If the shift key is held during motion, then only one of elevation or azimuth is invoked, depending on the whether the mouse motion is primarily horizontal or vertical.) Middle mouse button pans the camera across the scene (again the shift key has a similar effect on limiting the motion to the vertical or horizontal direction. The right mouse is used to dolly (e.\-g., a type of zoom) towards or away from the focal point.

The class also supports some keypress events. The \char`\"{}r\char`\"{} key resets the camera. The \char`\"{}e\char`\"{} key invokes the exit callback and by default exits the program. The \char`\"{}f\char`\"{} key sets a new camera focal point and flys towards that point. The \char`\"{}u\char`\"{} key invokes the user event. The \char`\"{}3\char`\"{} key toggles between stereo and non-\/stero mode. The \char`\"{}l\char`\"{} key toggles on/off a latitude/longitude markers that can be used to estimate/control position.

To create an instance of class vtk\-Interactor\-Style\-Terrain, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleTerrain
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Terrain 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\-Interactor\-Style\-Terrain class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Terrain = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Terrain = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Char ()} -\/ Override the \char`\"{}fly-\/to\char`\"{} (f keypress) for images.  
\item {\ttfamily obj.\-Rotate ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-Dolly ()}  
\item {\ttfamily obj.\-Set\-Lat\-Long\-Lines (int )} -\/ Turn on/off the latitude/longitude lines.  
\item {\ttfamily int = obj.\-Get\-Lat\-Long\-Lines ()} -\/ Turn on/off the latitude/longitude lines.  
\item {\ttfamily obj.\-Lat\-Long\-Lines\-On ()} -\/ Turn on/off the latitude/longitude lines.  
\item {\ttfamily obj.\-Lat\-Long\-Lines\-Off ()} -\/ Turn on/off the latitude/longitude lines.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyletrackball}{}\section{vtk\-Interactor\-Style\-Trackball}\label{vtkrendering_vtkinteractorstyletrackball}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Trackball is an implementation of vtk\-Interactor\-Style that defines the trackball style. It is now deprecated and as such a subclass of vtk\-Interactor\-Style\-Switch

To create an instance of class vtk\-Interactor\-Style\-Trackball, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleTrackball
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Trackball 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\-Interactor\-Style\-Trackball class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyletrackballactor}{}\section{vtk\-Interactor\-Style\-Trackball\-Actor}\label{vtkrendering_vtkinteractorstyletrackballactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Trackball\-Actor allows the user to interact with (rotate, pan, etc.) objects in the scene indendent of each other. In trackball interaction, the magnitude of the mouse motion is proportional to the actor motion associated with a particular mouse binding. For example, small left-\/button motions cause small changes in the rotation of the actor around its center point.

The mouse bindings are as follows. For a 3-\/button mouse, the left button is for rotation, the right button for zooming, the middle button for panning, and ctrl + left button for spinning. (With fewer mouse buttons, ctrl + shift + left button is for zooming, and shift + left button is for panning.)

To create an instance of class vtk\-Interactor\-Style\-Trackball\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleTrackballActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Trackball\-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\-Interactor\-Style\-Trackball\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-Rotate ()}  
\item {\ttfamily obj.\-Spin ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-Dolly ()}  
\item {\ttfamily obj.\-Uniform\-Scale ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyletrackballcamera}{}\section{vtk\-Interactor\-Style\-Trackball\-Camera}\label{vtkrendering_vtkinteractorstyletrackballcamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Interactor\-Style\-Trackball\-Camera allows the user to interactively manipulate (rotate, pan, etc.) the camera, the viewpoint of the scene. In trackball interaction, the magnitude of the mouse motion is proportional to the camera motion associated with a particular mouse binding. For example, small left-\/button motions cause small changes in the rotation of the camera around its focal point. For a 3-\/button mouse, the left button is for rotation, the right button for zooming, the middle button for panning, and ctrl + left button for spinning. (With fewer mouse buttons, ctrl + shift + left button is for zooming, and shift + left button is for panning.)

To create an instance of class vtk\-Interactor\-Style\-Trackball\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleTrackballCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Trackball\-Camera 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\-Interactor\-Style\-Trackball\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Trackball\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Forward ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Mouse\-Wheel\-Backward ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-Rotate ()}  
\item {\ttfamily obj.\-Spin ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-Dolly ()}  
\item {\ttfamily obj.\-Set\-Motion\-Factor (double )} -\/ Set the apparent sensitivity of the interactor style to mouse motion.  
\item {\ttfamily double = obj.\-Get\-Motion\-Factor ()} -\/ Set the apparent sensitivity of the interactor style to mouse motion.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleunicam}{}\section{vtk\-Interactor\-Style\-Unicam}\label{vtkrendering_vtkinteractorstyleunicam}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Uni\-Cam is a camera interactor. Here, just the primary features of the Uni\-Cam technique are implemented. Uni\-Cam requires just one mouse button and supports context sensitive dollying, panning, and rotation. (In this implementation, it uses the right mouse button, leaving the middle and left available for other functions.) For more information, see the paper at\-:

\href{ftp://ftp.cs.brown.edu/pub/papers/graphics/research/unicam.pdf}{\tt ftp\-://ftp.\-cs.\-brown.\-edu/pub/papers/graphics/research/unicam.\-pdf}

The following is a brief description of the Uni\-Cam Camera Controls. You can perform 3 operations on the camera\-: rotate, pan, and dolly the camera. All operations are reached through the right mouse button \& mouse movements.

I\-M\-P\-O\-R\-T\-A\-N\-T\-: Uni\-Cam assumes there is an axis that makes sense as a \char`\"{}up\char`\"{} vector for the world. By default, this axis is defined to be the vector $<$0,0,1$>$. You can set it explicitly for the data you are viewing with the 'Set\-World\-Up\-Vector(..)' method in C++, or similarly in Tcl/\-Tk (or other interpreted languages).


\begin{DoxyEnumerate}
\item R\-O\-T\-A\-T\-E\-:
\end{DoxyEnumerate}

Position the cursor over the point you wish to rotate around and press and release the left mouse button. A 'focus dot' appears indicating the point that will be the center of rotation. To rotate, press and hold the left mouse button and drag the mouse.. release the button to complete the rotation.

Rotations can be done without placing a focus dot first by moving the mouse cursor to within 10\% of the window border \& pressing and holding the left button followed by dragging the mouse. The last focus dot position will be re-\/used.


\begin{DoxyEnumerate}
\item P\-A\-N\-:
\end{DoxyEnumerate}

Click and hold the left mouse button, and initially move the mouse left or right. The point under the initial pick will pick correlate w/ the mouse tip-- (i.\-e., direct manipulation).


\begin{DoxyEnumerate}
\item D\-O\-L\-L\-Y (+ P\-A\-N)\-:
\end{DoxyEnumerate}

Click and hold the left mouse button, and initially move the mouse up or down. Moving the mouse down will dolly towards the picked point, and moving the mouse up will dolly away from it. Dollying occurs relative to the picked point which simplifies the task of dollying towards a region of interest. Left and right mouse movements will pan the camera left and right.

To create an instance of class vtk\-Interactor\-Style\-Unicam, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleUnicam
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-Unicam 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\-Interactor\-Style\-Unicam class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-Unicam = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-Unicam = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-World\-Up\-Vector (double a\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-World\-Up\-Vector (double x, double y, double z)}  
\item {\ttfamily double = obj. Get\-World\-Up\-Vector ()}  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Concrete implementation of event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Concrete implementation of event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Concrete implementation of event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Move ()} -\/ Concrete implementation of event bindings  
\item {\ttfamily obj.\-On\-Timer ()} -\/ On\-Timer calls Rotate\-Camera, Rotate\-Actor etc which should be overridden by style subclasses.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkinteractorstyleuser}{}\section{vtk\-Interactor\-Style\-User}\label{vtkrendering_vtkinteractorstyleuser}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The most common way to customize user interaction is to write a subclass of vtk\-Interactor\-Style\-: vtk\-Interactor\-Style\-User allows you to customize the interaction to without subclassing vtk\-Interactor\-Style. This is particularly useful for setting up custom interaction modes in scripting languages such as Tcl and Python. This class allows you to hook into the Mouse\-Move, Button\-Press/\-Release, Key\-Press/\-Release, etc. events. If you want to hook into just a single mouse button, but leave the interaction modes for the others unchanged, you must use e.\-g. Set\-Middle\-Button\-Press\-Method() instead of the more general Set\-Button\-Press\-Method().

To create an instance of class vtk\-Interactor\-Style\-User, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkInteractorStyleUser
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Interactor\-Style\-User 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\-Interactor\-Style\-User class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Interactor\-Style\-User = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Interactor\-Style\-User = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Last\-Pos ()} -\/ Get the most recent mouse position during mouse motion. In your user interaction method, you must use this to track the mouse movement. Do not use Get\-Event\-Position(), which records the last position where a mouse button was pressed.  
\item {\ttfamily int = obj. Get\-Old\-Pos ()} -\/ Get the previous mouse position during mouse motion, or after a key press. This can be used to calculate the relative displacement of the mouse.  
\item {\ttfamily int = obj.\-Get\-Shift\-Key ()} -\/ Test whether modifiers were held down when mouse button or key was pressed  
\item {\ttfamily int = obj.\-Get\-Ctrl\-Key ()} -\/ Test whether modifiers were held down when mouse button or key was pressed  
\item {\ttfamily int = obj.\-Get\-Char ()} -\/ Get the character for a Char event.  
\item {\ttfamily string = obj.\-Get\-Key\-Sym ()} -\/ Get the Key\-Sym (in the same format as Tk Key\-Syms) for a Key\-Press or Key\-Release method.  
\item {\ttfamily int = obj.\-Get\-Button ()} -\/ Get the mouse button that was last pressed inside the window (returns zero when the button is released).  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Generic event bindings  
\item {\ttfamily obj.\-On\-Char ()} -\/ Keyboard functions  
\item {\ttfamily obj.\-On\-Key\-Press ()} -\/ Keyboard functions  
\item {\ttfamily obj.\-On\-Key\-Release ()} -\/ Keyboard functions  
\item {\ttfamily obj.\-On\-Expose ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Configure ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Enter ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Leave ()} -\/ These are more esoteric events, but are useful in some cases.  
\item {\ttfamily obj.\-On\-Timer ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkivexporter}{}\section{vtk\-I\-V\-Exporter}\label{vtkrendering_vtkivexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-I\-V\-Exporter is a concrete subclass of vtk\-Exporter that writes Open\-Inventor 2.\-0 files.

To create an instance of class vtk\-I\-V\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkIVExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-I\-V\-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\-I\-V\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-I\-V\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-I\-V\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the name of the Open\-Inventor file to write.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the name of the Open\-Inventor file to write.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabeleddatamapper}{}\section{vtk\-Labeled\-Data\-Mapper}\label{vtkrendering_vtklabeleddatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Labeled\-Data\-Mapper is a mapper that renders text at dataset points. Various items can be labeled including point ids, scalars, vectors, normals, texture coordinates, tensors, and field data components.

The format with which the label is drawn is specified using a printf style format string. The font attributes of the text can be set through the vtk\-Text\-Property associated to this mapper.

By default, all the components of multi-\/component data such as vectors, normals, texture coordinates, tensors, and multi-\/component scalars are labeled. However, you can specify a single component if you prefer. (Note\-: the label format specifies the format to use for a single component. The label is creating by looping over all components and using the label format to render each component.)

To create an instance of class vtk\-Labeled\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabeledDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Labeled\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Labeled\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Labeled\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Labeled\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels. This should be a printf-\/style format string.

By default, the mapper will try to print each component of the tuple using a sane format\-: d for integers, f for floats, g for doubles, ld for longs, et cetera. If you need a different format, set it here. You can do things like limit the number of significant digits, add prefixes/suffixes, basically anything that printf can do. If you only want to print one component of a vector, see the ivar Labeled\-Component.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels. This should be a printf-\/style format string.

By default, the mapper will try to print each component of the tuple using a sane format\-: d for integers, f for floats, g for doubles, ld for longs, et cetera. If you need a different format, set it here. You can do things like limit the number of significant digits, add prefixes/suffixes, basically anything that printf can do. If you only want to print one component of a vector, see the ivar Labeled\-Component.  
\item {\ttfamily obj.\-Set\-Labeled\-Component (int )} -\/ Set/\-Get the component number to label if the data to print has more than one component. For example, all the components of scalars, vectors, normals, etc. are labeled by default (Labeled\-Component=(-\/1)). However, if this ivar is nonnegative, then only the one component specified is labeled.  
\item {\ttfamily int = obj.\-Get\-Labeled\-Component ()} -\/ Set/\-Get the component number to label if the data to print has more than one component. For example, all the components of scalars, vectors, normals, etc. are labeled by default (Labeled\-Component=(-\/1)). However, if this ivar is nonnegative, then only the one component specified is labeled.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Array (int array\-Index)} -\/ Set/\-Get the field data array to label. This instance variable is only applicable if field data is labeled. This will clear Field\-Data\-Name when set.  
\item {\ttfamily int = obj.\-Get\-Field\-Data\-Array ()} -\/ Set/\-Get the field data array to label. This instance variable is only applicable if field data is labeled. This will clear Field\-Data\-Name when set.  
\item {\ttfamily obj.\-Set\-Field\-Data\-Name (string array\-Name)} -\/ Set/\-Get the name of the field data array to label. This instance variable is only applicable if field data is labeled. This will override Field\-Data\-Array when set.  
\item {\ttfamily string = obj.\-Get\-Field\-Data\-Name ()} -\/ Set/\-Get the name of the field data array to label. This instance variable is only applicable if field data is labeled. This will override Field\-Data\-Array when set.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the input dataset to the mapper. This mapper handles any type of data.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Use Get\-Input\-Data\-Object() to get the input data object for composite datasets.  
\item {\ttfamily obj.\-Set\-Label\-Mode (int )} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily int = obj.\-Get\-Label\-Mode ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Ids ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Scalars ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Vectors ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Normals ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-T\-Coords ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Tensors ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Mode\-To\-Label\-Field\-Data ()} -\/ Specify which data to plot\-: I\-Ds, scalars, vectors, normals, texture coords, tensors, or field data. If the data has more than one component, use the method Set\-Labeled\-Component to control which components to plot. The default is V\-T\-K\-\_\-\-L\-A\-B\-E\-L\-\_\-\-I\-D\-S.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property. If an integer argument is provided, you may provide different text properties for different label types. The type is determined by an optional type input array.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the text property. If an integer argument is provided, you may provide different text properties for different label types. The type is determined by an optional type input array.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p, int type)} -\/ Set/\-Get the text property. If an integer argument is provided, you may provide different text properties for different label types. The type is determined by an optional type input array.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property (int type)} -\/ Set/\-Get the text property. If an integer argument is provided, you may provide different text properties for different label types. The type is determined by an optional type input array.  
\item {\ttfamily obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()} -\/ The transform to apply to the labels before mapping to 2\-D.  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform t)} -\/ The transform to apply to the labels before mapping to 2\-D.  
\item {\ttfamily int = obj.\-Get\-Coordinate\-System ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Set\-Coordinate\-System (int )} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily int = obj.\-Get\-Coordinate\-System\-Min\-Value ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily int = obj.\-Get\-Coordinate\-System\-Max\-Value ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Coordinate\-System\-World ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Coordinate\-System\-Display ()} -\/ Return the modified time for this object.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the modified time for this object.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabeledtreemapdatamapper}{}\section{vtk\-Labeled\-Tree\-Map\-Data\-Mapper}\label{vtkrendering_vtklabeledtreemapdatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Labeled\-Tree\-Map\-Data\-Mapper is a mapper that renders text on a tree map. A tree map is a vtk\-Tree with an associated 4-\/tuple array used for storing the boundary rectangle for each vertex in the tree. The user must specify the array name used for storing the rectangles.

The mapper iterates through the tree and attempts and renders a label inside the vertex's rectangle as long as the following conditions hold\-:
\begin{DoxyEnumerate}
\item The vertex level is within the range of levels specified for labeling.
\item The label can fully fit inside its box.
\item The label does not overlap an ancestor's label.
\end{DoxyEnumerate}

To create an instance of class vtk\-Labeled\-Tree\-Map\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabeledTreeMapDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Labeled\-Tree\-Map\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Labeled\-Tree\-Map\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Labeled\-Tree\-Map\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Labeled\-Tree\-Map\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Input\-Tree ()} -\/ The input to this filter.  
\item {\ttfamily obj.\-Set\-Rectangles\-Array\-Name (string name)} -\/ The name of the 4-\/tuple array used for  
\item {\ttfamily int = obj.\-Get\-Clip\-Text\-Mode ()} -\/ Indicates if the label can be displayed clipped by the Window mode = 0 -\/ ok to clip labels 1 -\/ auto center labels w/r to the area of the vertex's clipped region  
\item {\ttfamily obj.\-Set\-Clip\-Text\-Mode (int )} -\/ Indicates if the label can be displayed clipped by the Window mode = 0 -\/ ok to clip labels 1 -\/ auto center labels w/r to the area of the vertex's clipped region  
\item {\ttfamily int = obj.\-Get\-Child\-Motion ()} -\/ Indicates if the label can be moved by its ancestors  
\item {\ttfamily obj.\-Set\-Child\-Motion (int )} -\/ Indicates if the label can be moved by its ancestors  
\item {\ttfamily int = obj.\-Get\-Dynamic\-Level ()} -\/ Indicates at which level labeling should be dynamic  
\item {\ttfamily obj.\-Set\-Dynamic\-Level (int )} -\/ Indicates at which level labeling should be dynamic  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this actor.  
\item {\ttfamily obj.\-Set\-Font\-Size\-Range (int max\-Size, int min\-Size, int delta)} -\/ The range of font sizes to use when rendering the labels.  
\item {\ttfamily obj.\-Get\-Font\-Size\-Range (int range\mbox{[}3\mbox{]})} -\/ The range of font sizes to use when rendering the labels.  
\item {\ttfamily obj.\-Set\-Level\-Range (int start\-Level, int end\-Level)} -\/ The range of levels to attempt to label. The level of a vertex is the length of the path to the root (the root has level 0).  
\item {\ttfamily obj.\-Get\-Level\-Range (int range\mbox{[}2\mbox{]})} -\/ The range of levels to attempt to label. The level of a vertex is the length of the path to the root (the root has level 0).  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelhierarchy}{}\section{vtk\-Label\-Hierarchy}\label{vtkrendering_vtklabelhierarchy}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class represents labels in a hierarchy used to denote rendering priority. A binary tree of labels is maintained that subdivides the bounds of the of the label anchors spatially. Which level of the tree a label occupies determines its priority; those at higher levels of the tree will be more likely to render than those at lower levels of the tree.

Pass vtk\-Label\-Hierarchy objects to a vtk\-Label\-Placement\-Mapper filter for dynamic, non-\/overlapping, per-\/frame placement of labels.

Note that if we have a d-\/dimensional binary tree and we want a fixed number $n$ of labels in each node (all nodes, not just leaves), we can compute the depth of tree required assuming a uniform distribution of points. Given a total of $N$ points we know that $\frac{N}{|T|} = n$, where $|T|$ is the cardinality of the tree (i.\-e., the number of nodes it contains). Because we have a uniform distribution, the tree will be uniformly subdivided and thus $|T| = 1 + 2^d + \left(2^d\right)^2 + \cdots + \left(2^d\right)^k$, where $d$ is the dimensionality of the input points (fixed at 3 for now). As $k$ becomes large, $|T|\approx 2 \left(2^d\right)^k$. Using this approximation, we can solve for $k$\-: \[ k = \frac{\log{\frac{N}{2n}}}{\log{2^d}} \] Given a set of $N$ input label anchors, we'll compute $k$ and then bin the anchors into tree nodes at level $k$ of the tree. After this, all the nodes will be in the leaves of the tree and those leaves will be at the $k$-\/th level; no anchors will be in levels $1, 2, \ldots, k-1$. To fix that, we'll choose to move some anchors upwards. The exact number to move upwards depends on {\itshape Target\-Label\-Count}. We'll move as many up as required to have {\itshape Target\-Label\-Count} at each node.

You should avoid situations where {\itshape Maximum\-Depth} does not allow for {\itshape Target\-Label\-Count} or fewer entries at each node. The {\itshape Maximum\-Depth} is a hard limit while {\itshape Target\-Label\-Count} is a suggested optimum. You will end up with many more than {\itshape Target\-Label\-Count} entries per node and things will be sloooow.

To create an instance of class vtk\-Label\-Hierarchy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelHierarchy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Hierarchy 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\-Label\-Hierarchy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Points (vtk\-Points )} -\/ Override Set\-Points so we can reset the hierarchy when the points change.  
\item {\ttfamily obj.\-Compute\-Hierarchy ()} -\/ Fill the hierarchy with the input labels.  
\item {\ttfamily obj.\-Set\-Target\-Label\-Count (int )} -\/ The number of labels that is ideally present at any octree node. It is best if this is a multiple of $2^d$.  
\item {\ttfamily int = obj.\-Get\-Target\-Label\-Count ()} -\/ The number of labels that is ideally present at any octree node. It is best if this is a multiple of $2^d$.  
\item {\ttfamily obj.\-Set\-Maximum\-Depth (int )} -\/ The maximum depth of the octree.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Depth ()} -\/ The maximum depth of the octree.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property tprop)} -\/ The default text property assigned to labels in this hierarchy.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ The default text property assigned to labels in this hierarchy.  
\item {\ttfamily obj.\-Set\-Priorities (vtk\-Data\-Array arr)} -\/ Set/get the array specifying the importance (priority) of each label.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Priorities ()} -\/ Set/get the array specifying the importance (priority) of each label.  
\item {\ttfamily obj.\-Set\-Labels (vtk\-Abstract\-Array arr)} -\/ Set/get the array specifying the text of each label.  
\item {\ttfamily vtk\-Abstract\-Array = obj.\-Get\-Labels ()} -\/ Set/get the array specifying the text of each label.  
\item {\ttfamily obj.\-Set\-Orientations (vtk\-Data\-Array arr)} -\/ Set/get the array specifying the orientation of each label.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Orientations ()} -\/ Set/get the array specifying the orientation of each label.  
\item {\ttfamily obj.\-Set\-Icon\-Indices (vtk\-Int\-Array arr)} -\/ Set/get the array specifying the icon index of each label.  
\item {\ttfamily vtk\-Int\-Array = obj.\-Get\-Icon\-Indices ()} -\/ Set/get the array specifying the icon index of each label.  
\item {\ttfamily obj.\-Set\-Sizes (vtk\-Data\-Array arr)} -\/ Set/get the array specifying the size of each label.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Sizes ()} -\/ Set/get the array specifying the size of each label.  
\item {\ttfamily obj.\-Set\-Bounded\-Sizes (vtk\-Data\-Array arr)} -\/ Set/get the array specifying the maximum width and height in world coordinates of each label.  
\item {\ttfamily vtk\-Data\-Array = obj.\-Get\-Bounded\-Sizes ()} -\/ Set/get the array specifying the maximum width and height in world coordinates of each label.  
\item {\ttfamily obj.\-Get\-Discrete\-Node\-Coordinates\-From\-World\-Point (int ijk\mbox{[}3\mbox{]}, double pt\mbox{[}3\mbox{]}, int level)} -\/ Given a depth in the hierarchy ({\itshape level}) and a point {\itshape pt} in world space, compute {\itshape ijk}. This is used to find other octree nodes at the same {\itshape level} that are within the search radius for candidate labels to be placed. It is called with {\itshape pt} set to the camera eye point and pythagorean quadruples increasingly distant from the origin are added to {\itshape ijk} to identify octree nodes whose labels should be placed. 
\begin{DoxyParams}[1]{Parameters}
\mbox{\tt out}  & {\em ijk} & -\/ discrete coordinates of the octree node at {\itshape level} containing {\itshape pt}. \\
\hline
\mbox{\tt in}  & {\em pt} & -\/ input world point coordinates \\
\hline
\mbox{\tt in}  & {\em level} & -\/ input octree level to be considered  \\
\hline
\end{DoxyParams}

\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Number\-Of\-Cells ()} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily vtk\-Cell = obj.\-Get\-Cell (vtk\-Id\-Type )} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily obj.\-Get\-Cell (vtk\-Id\-Type , vtk\-Generic\-Cell )} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily int = obj.\-Get\-Cell\-Type (vtk\-Id\-Type )} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily obj.\-Get\-Cell\-Points (vtk\-Id\-Type , vtk\-Id\-List )} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily obj.\-Get\-Point\-Cells (vtk\-Id\-Type , vtk\-Id\-List )} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily int = obj.\-Get\-Max\-Cell\-Size ()} -\/ Inherited members (from vtk\-Data\-Set)  
\item {\ttfamily vtk\-Points = obj.\-Get\-Center\-Pts ()} -\/ Provide access to original coordinates of sets of coincident points  
\item {\ttfamily vtk\-Coincident\-Points = obj.\-Get\-Coincident\-Points ()} -\/ Provide access to the set of coincident points that have been perturbed by the hierarchy in order to render labels for each without overlap.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelhierarchyalgorithm}{}\section{vtk\-Label\-Hierarchy\-Algorithm}\label{vtkrendering_vtklabelhierarchyalgorithm}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Label\-Hierarchy\-Algorithm is a convenience class to make writing algorithms easier. It is also designed to help transition old algorithms to the new pipeline architecture. There are some assumptions and defaults made by this class you should be aware of. This class defaults such that your filter will have one input port and one output port. If that is not the case simply change it with Set\-Number\-Of\-Input\-Ports etc. See this class constructor for the default. This class also provides a Fill\-Input\-Port\-Info method that by default says that all inputs will be Data\-Objects. If that isn't the case then please override this method in your subclass. This class breaks out the downstream requests into separate functions such as Request\-Data and Request\-Information. You should implement Request\-Data( request, input\-Vec, output\-Vec) in subclasses.

To create an instance of class vtk\-Label\-Hierarchy\-Algorithm, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelHierarchyAlgorithm
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Hierarchy\-Algorithm 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\-Label\-Hierarchy\-Algorithm class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Algorithm = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Algorithm = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Get\-Output (int )} -\/ Get the output data object for a port on this algorithm.  
\item {\ttfamily obj.\-Set\-Output (vtk\-Data\-Object d)} -\/ Get the output data object for a port on this algorithm.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()}  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input (int port)}  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Get\-Label\-Hierarchy\-Input (int port)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Set\-Input\-Connection(). These methods transform the input index to the input port index, not an index of a connection within a single port.  
\item {\ttfamily obj.\-Set\-Input (int , vtk\-Data\-Object )} -\/ Set an input of this algorithm. You should not override these methods because they are not the only way to connect a pipeline. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Set\-Input\-Connection(). These methods transform the input index to the input port index, not an index of a connection within a single port.  
\item {\ttfamily obj.\-Add\-Input (vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\item {\ttfamily obj.\-Add\-Input (int , vtk\-Data\-Object )} -\/ Add an input of this algorithm. Note that these methods support old-\/style pipeline connections. When writing new code you should use the more general vtk\-Algorithm\-::\-Add\-Input\-Connection(). See Set\-Input() for details.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelhierarchycompositeiterator}{}\section{vtk\-Label\-Hierarchy\-Composite\-Iterator}\label{vtkrendering_vtklabelhierarchycompositeiterator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Iterates over child iterators in a round-\/robin order. Each iterator may have its own count, which is the number of times it is repeated until moving to the next iterator.

For example, if you initialize the iterator with 
\begin{DoxyPre}
 it->AddIterator(A, 1);
 it->AddIterator(B, 3);
 \end{DoxyPre}
 The order of iterators will be A,B,B,B,A,B,B,B,...

To create an instance of class vtk\-Label\-Hierarchy\-Composite\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelHierarchyCompositeIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Hierarchy\-Composite\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Label\-Hierarchy\-Composite\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Composite\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Composite\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Iterator (vtk\-Label\-Hierarchy\-Iterator it)} -\/ Adds a label iterator to this composite iterator. The second optional argument is the number of times to repeat the iterator before moving to the next one round-\/robin style. Default is 1.  
\item {\ttfamily obj.\-Add\-Iterator (vtk\-Label\-Hierarchy\-Iterator it, int count)} -\/ Adds a label iterator to this composite iterator. The second optional argument is the number of times to repeat the iterator before moving to the next one round-\/robin style. Default is 1.  
\item {\ttfamily obj.\-Clear\-Iterators ()} -\/ Remove all iterators from this composite iterator.  
\item {\ttfamily obj.\-Begin (vtk\-Id\-Type\-Array )} -\/ Initializes the iterator. last\-Labels is an array holding labels which should be traversed before any other labels in the hierarchy. This could include labels placed during a previous rendering or a label located under the mouse pointer. You may pass a null pointer.  
\item {\ttfamily obj.\-Next ()} -\/ Advance the iterator.  
\item {\ttfamily bool = obj.\-Is\-At\-End ()} -\/ Returns true if the iterator is at the end.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Label\-Id ()} -\/ Retrieves the current label id.  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Get\-Hierarchy ()} -\/ Retrieve the current label hierarchy.  
\item {\ttfamily obj.\-Box\-Node ()} -\/ Not implemented.  
\item {\ttfamily obj.\-Box\-All\-Nodes (vtk\-Poly\-Data )}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelhierarchyiterator}{}\section{vtk\-Label\-Hierarchy\-Iterator}\label{vtkrendering_vtklabelhierarchyiterator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Abstract superclass for iterators over vtk\-Label\-Hierarchy.

To create an instance of class vtk\-Label\-Hierarchy\-Iterator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelHierarchyIterator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Hierarchy\-Iterator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Label\-Hierarchy\-Iterator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Iterator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Hierarchy\-Iterator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Begin (vtk\-Id\-Type\-Array )} -\/ Advance the iterator.  
\item {\ttfamily obj.\-Next ()} -\/ Returns true if the iterator is at the end.  
\item {\ttfamily bool = obj.\-Is\-At\-End ()} -\/ Retrieves the current label location.  
\item {\ttfamily obj.\-Get\-Point (double x\mbox{[}3\mbox{]})} -\/ Retrieves the current label location.  
\item {\ttfamily obj.\-Get\-Size (double sz\mbox{[}2\mbox{]})} -\/ Retrieves the current label size.  
\item {\ttfamily obj.\-Get\-Bounded\-Size (double sz\mbox{[}2\mbox{]})} -\/ Retrieves the current label maximum width in world coordinates.  
\item {\ttfamily int = obj.\-Get\-Type ()} -\/ Retrieves the current label type.  
\item {\ttfamily double = obj.\-Get\-Orientation ()} -\/ Retrieves the current label orientation.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Label\-Id ()} -\/ Get the label hierarchy associated with the current label.  
\item {\ttfamily vtk\-Label\-Hierarchy = obj.\-Get\-Hierarchy ()} -\/ Get the label hierarchy associated with the current label.  
\item {\ttfamily obj.\-Set\-Traversed\-Bounds (vtk\-Poly\-Data )} -\/ Sets a polydata to fill with geometry representing the bounding boxes of the traversed octree nodes.  
\item {\ttfamily obj.\-Box\-Node ()} -\/ Add a representation to Traversed\-Bounds for the current octree node. This should be called by subclasses inside Next(). Does nothing if Traversed\-Bounds is N\-U\-L\-L.  
\item {\ttfamily obj.\-Box\-All\-Nodes (vtk\-Poly\-Data )} -\/ Add a representation for all existing octree nodes to the specified polydata. This is equivalent to setting Traversed\-Bounds, iterating over the entire hierarchy, and then resetting Traversed\-Bounds to its original value.  
\item {\ttfamily obj.\-Set\-All\-Bounds (int )} -\/ Set/get whether all nodes in the hierarchy should be added to the Traversed\-Bounds polydata or only those traversed. When non-\/zero, all nodes will be added. By default, All\-Bounds is 0.  
\item {\ttfamily int = obj.\-Get\-All\-Bounds ()} -\/ Set/get whether all nodes in the hierarchy should be added to the Traversed\-Bounds polydata or only those traversed. When non-\/zero, all nodes will be added. By default, All\-Bounds is 0.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelplacementmapper}{}\section{vtk\-Label\-Placement\-Mapper}\label{vtkrendering_vtklabelplacementmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To use this mapper, first send your data through vtk\-Point\-Set\-To\-Label\-Hierarchy, which takes a set of points, associates special arrays to the points (label, priority, etc.), and produces a prioritized spatial tree of labels.

This mapper then takes that hierarchy (or hierarchies) as input, and every frame will decide which labels and/or icons to place in order of priority, and will render only those labels/icons. A label render strategy is used to render the labels, and can use e.\-g. Free\-Type or Qt for rendering.

To create an instance of class vtk\-Label\-Placement\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelPlacementMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Placement\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Label\-Placement\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Placement\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Placement\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw non-\/overlapping labels to the screen.  
\item {\ttfamily obj.\-Set\-Render\-Strategy (vtk\-Label\-Render\-Strategy s)} -\/ Set the label rendering strategy.  
\item {\ttfamily vtk\-Label\-Render\-Strategy = obj.\-Get\-Render\-Strategy ()} -\/ Set the label rendering strategy.  
\item {\ttfamily obj.\-Set\-Maximum\-Label\-Fraction (double )} -\/ The maximum fraction of the screen that the labels may cover. Label placement stops when this fraction is reached.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction\-Min\-Value ()} -\/ The maximum fraction of the screen that the labels may cover. Label placement stops when this fraction is reached.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction\-Max\-Value ()} -\/ The maximum fraction of the screen that the labels may cover. Label placement stops when this fraction is reached.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction ()} -\/ The maximum fraction of the screen that the labels may cover. Label placement stops when this fraction is reached.  
\item {\ttfamily obj.\-Set\-Iterator\-Type (int )} -\/ The type of iterator used when traversing the labels. May be vtk\-Label\-Hierarchy\-::\-F\-R\-U\-S\-T\-U\-M or vtk\-Label\-Hierarchy\-::\-F\-U\-L\-L\-\_\-\-S\-O\-R\-T  
\item {\ttfamily int = obj.\-Get\-Iterator\-Type ()} -\/ The type of iterator used when traversing the labels. May be vtk\-Label\-Hierarchy\-::\-F\-R\-U\-S\-T\-U\-M or vtk\-Label\-Hierarchy\-::\-F\-U\-L\-L\-\_\-\-S\-O\-R\-T  
\item {\ttfamily obj.\-Set\-Use\-Unicode\-Strings (bool )} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily bool = obj.\-Get\-Use\-Unicode\-Strings ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-On ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-Off ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily bool = obj.\-Get\-Positions\-As\-Normals ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Set\-Positions\-As\-Normals (bool )} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Positions\-As\-Normals\-On ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Positions\-As\-Normals\-Off ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily bool = obj.\-Get\-Generate\-Perturbed\-Label\-Spokes ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Set\-Generate\-Perturbed\-Label\-Spokes (bool )} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Generate\-Perturbed\-Label\-Spokes\-On ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Generate\-Perturbed\-Label\-Spokes\-Off ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily bool = obj.\-Get\-Use\-Depth\-Buffer ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Set\-Use\-Depth\-Buffer (bool )} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Use\-Depth\-Buffer\-On ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Use\-Depth\-Buffer\-Off ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Set\-Place\-All\-Labels (bool )} -\/ Tells the placer to place every label regardless of overlap. Off by default.  
\item {\ttfamily bool = obj.\-Get\-Place\-All\-Labels ()} -\/ Tells the placer to place every label regardless of overlap. Off by default.  
\item {\ttfamily obj.\-Place\-All\-Labels\-On ()} -\/ Tells the placer to place every label regardless of overlap. Off by default.  
\item {\ttfamily obj.\-Place\-All\-Labels\-Off ()} -\/ Tells the placer to place every label regardless of overlap. Off by default.  
\item {\ttfamily obj.\-Set\-Output\-Traversed\-Bounds (bool )} -\/ Whether to render traversed bounds. Off by default.  
\item {\ttfamily bool = obj.\-Get\-Output\-Traversed\-Bounds ()} -\/ Whether to render traversed bounds. Off by default.  
\item {\ttfamily obj.\-Output\-Traversed\-Bounds\-On ()} -\/ Whether to render traversed bounds. Off by default.  
\item {\ttfamily obj.\-Output\-Traversed\-Bounds\-Off ()} -\/ Whether to render traversed bounds. Off by default.  
\item {\ttfamily obj.\-Set\-Shape (int )} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily int = obj.\-Get\-Shape\-Min\-Value ()} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily int = obj.\-Get\-Shape\-Max\-Value ()} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily int = obj.\-Get\-Shape ()} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily obj.\-Set\-Shape\-To\-None ()} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily obj.\-Set\-Shape\-To\-Rect ()} -\/ The shape of the label background, should be one of the values in the Label\-Shape enumeration.  
\item {\ttfamily obj.\-Set\-Shape\-To\-Rounded\-Rect ()} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily obj.\-Set\-Style (int )} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily int = obj.\-Get\-Style\-Min\-Value ()} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily int = obj.\-Get\-Style\-Max\-Value ()} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily int = obj.\-Get\-Style ()} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily obj.\-Set\-Style\-To\-Filled ()} -\/ The style of the label background shape, should be one of the values in the Label\-Style enumeration.  
\item {\ttfamily obj.\-Set\-Style\-To\-Outline ()} -\/ The size of the margin on the label background shape. Default is 5.  
\item {\ttfamily obj.\-Set\-Margin (double )} -\/ The size of the margin on the label background shape. Default is 5.  
\item {\ttfamily double = obj.\-Get\-Margin ()} -\/ The size of the margin on the label background shape. Default is 5.  
\item {\ttfamily obj.\-Set\-Background\-Color (double , double , double )} -\/ The color of the background shape.  
\item {\ttfamily obj.\-Set\-Background\-Color (double a\mbox{[}3\mbox{]})} -\/ The color of the background shape.  
\item {\ttfamily double = obj. Get\-Background\-Color ()} -\/ The color of the background shape.  
\item {\ttfamily obj.\-Set\-Background\-Opacity (double )} -\/ The opacity of the background shape.  
\item {\ttfamily double = obj.\-Get\-Background\-Opacity\-Min\-Value ()} -\/ The opacity of the background shape.  
\item {\ttfamily double = obj.\-Get\-Background\-Opacity\-Max\-Value ()} -\/ The opacity of the background shape.  
\item {\ttfamily double = obj.\-Get\-Background\-Opacity ()} -\/ The opacity of the background shape.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Anchor\-Transform ()} -\/ Get the transform for the anchor points.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelplacer}{}\section{vtk\-Label\-Placer}\label{vtkrendering_vtklabelplacer}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
{\bfseries This class is deprecated and will be removed from V\-T\-K in a future release. Use vtk\-Label\-Placement\-Mapper instead.}

This should probably be a mapper unto itself (given that the polydata output could be large and will realistically always be iterated over exactly once before being tossed for the next frame of the render).

In any event, it takes as input one (or more, eventually) vtk\-Label\-Hierarchies that represent prioritized lists of labels sorted by their placement in space. As output, it provides vtk\-Poly\-Data containing only V\-T\-K\-\_\-\-Q\-U\-A\-D cells, each representing a single label from the input. Each quadrilateral has cell data indicating what label in the input it corresponds to (via an array named \char`\"{}\-Label\-Id\char`\"{}).

To create an instance of class vtk\-Label\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Placer 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\-Label\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Placer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer )}  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Anchor\-Transform ()}  
\item {\ttfamily obj.\-Set\-Gravity (int gravity)} -\/ The placement of the label relative to the anchor point.  
\item {\ttfamily int = obj.\-Get\-Gravity ()} -\/ The placement of the label relative to the anchor point.  
\item {\ttfamily obj.\-Set\-Maximum\-Label\-Fraction (double )} -\/ The maximum amount of screen space labels can take up before placement terminates.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction\-Min\-Value ()} -\/ The maximum amount of screen space labels can take up before placement terminates.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction\-Max\-Value ()} -\/ The maximum amount of screen space labels can take up before placement terminates.  
\item {\ttfamily double = obj.\-Get\-Maximum\-Label\-Fraction ()} -\/ The maximum amount of screen space labels can take up before placement terminates.  
\item {\ttfamily obj.\-Set\-Iterator\-Type (int )} -\/ The type of iterator used when traversing the labels. May be vtk\-Label\-Hierarchy\-::\-F\-R\-U\-S\-T\-U\-M or vtk\-Label\-Hierarchy\-::\-F\-U\-L\-L\-\_\-\-S\-O\-R\-T.  
\item {\ttfamily int = obj.\-Get\-Iterator\-Type ()} -\/ The type of iterator used when traversing the labels. May be vtk\-Label\-Hierarchy\-::\-F\-R\-U\-S\-T\-U\-M or vtk\-Label\-Hierarchy\-::\-F\-U\-L\-L\-\_\-\-S\-O\-R\-T.  
\item {\ttfamily obj.\-Set\-Use\-Unicode\-Strings (bool )} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily bool = obj.\-Get\-Use\-Unicode\-Strings ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-On ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-Off ()} -\/ Set whether, or not, to use unicode strings.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()}  
\item {\ttfamily bool = obj.\-Get\-Positions\-As\-Normals ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Set\-Positions\-As\-Normals (bool )} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Positions\-As\-Normals\-On ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily obj.\-Positions\-As\-Normals\-Off ()} -\/ Use label anchor point coordinates as normal vectors and eliminate those pointing away from the camera. Valid only when points are on a sphere centered at the origin (such as a 3\-D geographic view). Off by default.  
\item {\ttfamily bool = obj.\-Get\-Generate\-Perturbed\-Label\-Spokes ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Set\-Generate\-Perturbed\-Label\-Spokes (bool )} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Generate\-Perturbed\-Label\-Spokes\-On ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily obj.\-Generate\-Perturbed\-Label\-Spokes\-Off ()} -\/ Enable drawing spokes (lines) to anchor point coordinates that were perturbed for being coincident with other anchor point coordinates.  
\item {\ttfamily bool = obj.\-Get\-Use\-Depth\-Buffer ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Set\-Use\-Depth\-Buffer (bool )} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Use\-Depth\-Buffer\-On ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily obj.\-Use\-Depth\-Buffer\-Off ()} -\/ Use the depth buffer to test each label to see if it should not be displayed if it would be occluded by other objects in the scene. Off by default.  
\item {\ttfamily bool = obj.\-Get\-Output\-Traversed\-Bounds ()} -\/ In the second output, output the geometry of the traversed octree nodes.  
\item {\ttfamily obj.\-Set\-Output\-Traversed\-Bounds (bool )} -\/ In the second output, output the geometry of the traversed octree nodes.  
\item {\ttfamily obj.\-Output\-Traversed\-Bounds\-On ()} -\/ In the second output, output the geometry of the traversed octree nodes.  
\item {\ttfamily obj.\-Output\-Traversed\-Bounds\-Off ()} -\/ In the second output, output the geometry of the traversed octree nodes.  
\item {\ttfamily int = obj.\-Get\-Output\-Coordinate\-System ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Set\-Output\-Coordinate\-System (int )} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily int = obj.\-Get\-Output\-Coordinate\-System\-Min\-Value ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily int = obj.\-Get\-Output\-Coordinate\-System\-Max\-Value ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Output\-Coordinate\-System\-World ()} -\/ Set/get the coordinate system used for output labels. The output datasets may have point coordinates reported in the world space or display space.  
\item {\ttfamily obj.\-Output\-Coordinate\-System\-Display ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelrenderstrategy}{}\section{vtk\-Label\-Render\-Strategy}\label{vtkrendering_vtklabelrenderstrategy}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
These methods should only be called within a mapper.

To create an instance of class vtk\-Label\-Render\-Strategy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelRenderStrategy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Render\-Strategy 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\-Label\-Render\-Strategy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Render\-Strategy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Render\-Strategy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily bool = obj.\-Supports\-Rotation ()} -\/ Whether the text rendering strategy supports bounded size. The superclass returns true. Subclasses should override this to return the appropriate value. Subclasses that return true from this method should implement the version of Render\-Label() that takes a maximum size (see Render\-Label()).  
\item {\ttfamily bool = obj.\-Supports\-Bounded\-Size ()} -\/ Set the renderer associated with this strategy.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Set the renderer associated with this strategy.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Set the renderer associated with this strategy.  
\item {\ttfamily obj.\-Set\-Default\-Text\-Property (vtk\-Text\-Property tprop)} -\/ Set the default text property for the strategy.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Default\-Text\-Property ()} -\/ Set the default text property for the strategy.  
\item {\ttfamily obj.\-Start\-Frame ()} -\/ End a rendering frame.  
\item {\ttfamily obj.\-End\-Frame ()} -\/ Release any graphics resources that are being consumed by this strategy. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklabelsizecalculator}{}\section{vtk\-Label\-Size\-Calculator}\label{vtkrendering_vtklabelsizecalculator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This filter takes an input dataset, an array to process (which must be a string array), and a text property. It creates a new output array (named \char`\"{}\-Label\-Size\char`\"{} by default) with 4 components per tuple that contain the width, height, horizontal offset, and descender height (in that order) of each string in the array.

Use the inherited Select\-Input\-Array\-To\-Process to indicate a string array. In no input array is specified, the first of the following that is a string array is used\-: point scalars, cell scalars, field scalars.

The second input array to process is an array specifying the type of each label. Different label types may have different font properties. This array must be a vtk\-Int\-Array. Any type that does not map to a font property that was set will be set to the type 0's type property.

To create an instance of class vtk\-Label\-Size\-Calculator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLabelSizeCalculator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Label\-Size\-Calculator 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\-Label\-Size\-Calculator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Label\-Size\-Calculator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Label\-Size\-Calculator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Font\-Property (vtk\-Text\-Property font\-Prop, int type)} -\/ Get/\-Set the font used compute label sizes. This defaults to \char`\"{}\-Arial\char`\"{} at 12 points. If type is provided, it refers to the type of the text label provided in the optional label type array. The default type is type 0.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Font\-Property (int type)} -\/ Get/\-Set the font used compute label sizes. This defaults to \char`\"{}\-Arial\char`\"{} at 12 points. If type is provided, it refers to the type of the text label provided in the optional label type array. The default type is type 0.  
\item {\ttfamily obj.\-Set\-Label\-Size\-Array\-Name (string )} -\/ The name of the output array containing text label sizes This defaults to \char`\"{}\-Label\-Size\char`\"{}  
\item {\ttfamily string = obj.\-Get\-Label\-Size\-Array\-Name ()} -\/ The name of the output array containing text label sizes This defaults to \char`\"{}\-Label\-Size\char`\"{}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkleaderactor2d}{}\section{vtk\-Leader\-Actor2\-D}\label{vtkrendering_vtkleaderactor2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Leader\-Actor2\-D creates a leader with an optional label and arrows. (A leader is typically used to indicate distance between points.) vtk\-Leader\-Actor2\-D is a type of vtk\-Actor2\-D; that is, it is drawn on the overlay plane and is not occluded by 3\-D geometry. To use this class, you typically specify two points defining the start and end points of the line (x-\/y definition using vtk\-Coordinate class), whether to place arrows on one or both end points, and whether to label the leader. Also, this class has a special feature that allows curved leaders to be created by specifying a radius.

Use the vtk\-Leader\-Actor2\-D uses its superclass vtk\-Actor2\-D instance variables Position and Position2 vtk\-Coordinates to place an instance of vtk\-Leader\-Actor2\-D (i.\-e., these two data members represent the start and end points of the leader). Using these vtk\-Coordinates you can specify the position of the leader in a variety of coordinate systems.

To control the appearance of the actor, use the superclasses vtk\-Actor2\-D\-::vtk\-Property2\-D and the vtk\-Text\-Property objects associated with this actor.

To create an instance of class vtk\-Leader\-Actor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLeaderActor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Leader\-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\-Leader\-Actor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Leader\-Actor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Leader\-Actor2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Radius (double )} -\/ Set/\-Get a radius which can be used to curve the leader. If a radius is specified whose absolute value is greater than one half the distance between the two points defined by the superclasses' Position and Position2 ivars, then the leader will be curved. A positive radius will produce a curve such that the center is to the right of the line from Position and Position2; a negative radius will produce a curve in the opposite sense. By default, the radius is set to zero and thus there is no curvature. Note that the radius is expresses as a multiple of the distance between (Position,Position2); this avoids issues relative to coordinate system transformations.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get a radius which can be used to curve the leader. If a radius is specified whose absolute value is greater than one half the distance between the two points defined by the superclasses' Position and Position2 ivars, then the leader will be curved. A positive radius will produce a curve such that the center is to the right of the line from Position and Position2; a negative radius will produce a curve in the opposite sense. By default, the radius is set to zero and thus there is no curvature. Note that the radius is expresses as a multiple of the distance between (Position,Position2); this avoids issues relative to coordinate system transformations.  
\item {\ttfamily obj.\-Set\-Label (string )} -\/ Set/\-Get the label for the leader. If the label is an empty string, then it will not be drawn.  
\item {\ttfamily string = obj.\-Get\-Label ()} -\/ Set/\-Get the label for the leader. If the label is an empty string, then it will not be drawn.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property of the label.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the text property of the label.  
\item {\ttfamily obj.\-Set\-Label\-Factor (double )} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label the leader.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label the leader.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label the leader.  
\item {\ttfamily double = obj.\-Get\-Label\-Factor ()} -\/ Set/\-Get the factor that controls the overall size of the fonts used to label the leader.  
\item {\ttfamily obj.\-Set\-Arrow\-Placement (int )} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Placement\-Min\-Value ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Placement\-Max\-Value ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Placement ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily obj.\-Set\-Arrow\-Placement\-To\-None ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily obj.\-Set\-Arrow\-Placement\-To\-Point1 ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily obj.\-Set\-Arrow\-Placement\-To\-Point2 ()} -\/ Control whether arrow heads are drawn on the leader. Arrows may be drawn on one end, both ends, or not at all.  
\item {\ttfamily obj.\-Set\-Arrow\-Placement\-To\-Both ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily obj.\-Set\-Arrow\-Style (int )} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Style\-Min\-Value ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Style\-Max\-Value ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily int = obj.\-Get\-Arrow\-Style ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily obj.\-Set\-Arrow\-Style\-To\-Filled ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily obj.\-Set\-Arrow\-Style\-To\-Open ()} -\/ Control the appearance of the arrow heads. A solid arrow head is a filled triangle; a open arrow looks like a \char`\"{}\-V\char`\"{}; and a hollow arrow looks like a non-\/filled triangle.  
\item {\ttfamily obj.\-Set\-Arrow\-Style\-To\-Hollow ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily obj.\-Set\-Arrow\-Length (double )} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Length\-Min\-Value ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Length\-Max\-Value ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Length ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily obj.\-Set\-Arrow\-Width (double )} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Width\-Min\-Value ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Width\-Max\-Value ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily double = obj.\-Get\-Arrow\-Width ()} -\/ Specify the arrow length and base width (in normalized viewport coordinates).  
\item {\ttfamily obj.\-Set\-Minimum\-Arrow\-Size (double )} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Minimum\-Arrow\-Size\-Min\-Value ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Minimum\-Arrow\-Size\-Max\-Value ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Minimum\-Arrow\-Size ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily obj.\-Set\-Maximum\-Arrow\-Size (double )} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Maximum\-Arrow\-Size\-Min\-Value ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Maximum\-Arrow\-Size\-Max\-Value ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily double = obj.\-Get\-Maximum\-Arrow\-Size ()} -\/ Limit the minimum and maximum size of the arrows. These values are expressed in pixels and clamp the minimum/maximum possible size for the width/length of the arrow head. (When clamped, the ratio between length and width is preserved.)  
\item {\ttfamily obj.\-Set\-Auto\-Label (int )} -\/ Enable auto-\/labelling. In this mode, the label is automatically updated based on distance (in world coordinates) between the two end points; or if a curved leader is being generated, the angle in degrees between the two points.  
\item {\ttfamily int = obj.\-Get\-Auto\-Label ()} -\/ Enable auto-\/labelling. In this mode, the label is automatically updated based on distance (in world coordinates) between the two end points; or if a curved leader is being generated, the angle in degrees between the two points.  
\item {\ttfamily obj.\-Auto\-Label\-On ()} -\/ Enable auto-\/labelling. In this mode, the label is automatically updated based on distance (in world coordinates) between the two end points; or if a curved leader is being generated, the angle in degrees between the two points.  
\item {\ttfamily obj.\-Auto\-Label\-Off ()} -\/ Enable auto-\/labelling. In this mode, the label is automatically updated based on distance (in world coordinates) between the two end points; or if a curved leader is being generated, the angle in degrees between the two points.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Specify the format to use for auto-\/labelling.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Specify the format to use for auto-\/labelling.  
\item {\ttfamily double = obj.\-Get\-Length ()} -\/ Obtain the length of the leader if the leader is not curved, otherwise obtain the angle that the leader circumscribes.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Obtain the length of the leader if the leader is not curved, otherwise obtain the angle that the leader circumscribes.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop and vtk\-Actor2\-D superclasses.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop and vtk\-Actor2\-D superclasses.  
\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 )}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklight}{}\section{vtk\-Light}\label{vtkrendering_vtklight}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Light is a virtual light for 3\-D rendering. It provides methods to locate and point the light, turn it on and off, and set its brightness and color. In addition to the basic infinite distance point light source attributes, you also can specify the light attenuation values and cone angle. These attributes are only used if the light is a positional light. The default is a directional light (e.\-g. infinite point light source).

Lights have a type that describes how the light should move with respect to the camera. A Headlight is always located at the current camera position and shines on the camera's focal point. A Camera\-Light also moves with the camera, but may not be coincident to it. Camera\-Lights are defined in a normalized coordinate space where the camera is located at (0, 0, 1), the camera is looking at (0, 0, 0), and up is (0, 1, 0). Finally, a Scene\-Light is part of the scene itself and does not move with the camera. (Renderers are responsible for moving the light based on its type.)

Lights have a transformation matrix that describes the space in which they are positioned. A light's world space position and focal point are defined by their local position and focal point, transformed by their transformation matrix (if it exists).

To create an instance of class vtk\-Light, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLight
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Light class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Light = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Light = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Light = obj.\-Shallow\-Clone ()} -\/ Create a new light object with the same light parameters than the current object (any ivar from the superclasses (vtk\-Object and vtk\-Object\-Base), like reference counting, timestamp and observers are not copied). This is a shallow clone (Transform\-Matrix is referenced)  
\item {\ttfamily obj.\-Render (vtk\-Renderer , int )} -\/ Abstract interface to renderer. Each concrete subclass of vtk\-Light will load its data into the graphics system in response to this method invocation. The actual loading is performed by a vtk\-Light\-Device subclass, which will get created automatically.  
\item {\ttfamily obj.\-Set\-Ambient\-Color (double , double , double )} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Ambient\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily double = obj. Get\-Ambient\-Color ()} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Diffuse\-Color (double , double , double )} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Diffuse\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily double = obj. Get\-Diffuse\-Color ()} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Specular\-Color (double , double , double )} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Specular\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily double = obj. Get\-Specular\-Color ()} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Color (double , double , double )} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Get\-Color (double rgb\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily double = obj.\-Get\-Color ()} -\/ Set/\-Get the color of the light. It is possible to set the ambient, diffuse and specular colors separately. The Set\-Color() method sets the diffuse and specular colors to the same color (this is a feature to preserve backward compatbility.)  
\item {\ttfamily obj.\-Set\-Position (double , double , double )} -\/ Set/\-Get the position of the light. Note\-: The position of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space position, use vtk\-Get\-Transformed\-Position() instead of vtk\-Get\-Position().  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the light. Note\-: The position of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space position, use vtk\-Get\-Transformed\-Position() instead of vtk\-Get\-Position().  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get the position of the light. Note\-: The position of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space position, use vtk\-Get\-Transformed\-Position() instead of vtk\-Get\-Position().  
\item {\ttfamily obj.\-Set\-Position (float a)} -\/ Set/\-Get the position of the light. Note\-: The position of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space position, use vtk\-Get\-Transformed\-Position() instead of vtk\-Get\-Position().  
\item {\ttfamily obj.\-Set\-Focal\-Point (double , double , double )} -\/ Set/\-Get the point at which the light is shining. Note\-: The focal point of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space focal point, use vtk\-Get\-Transformed\-Focal\-Point() instead of vtk\-Get\-Focal\-Point().  
\item {\ttfamily obj.\-Set\-Focal\-Point (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the point at which the light is shining. Note\-: The focal point of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space focal point, use vtk\-Get\-Transformed\-Focal\-Point() instead of vtk\-Get\-Focal\-Point().  
\item {\ttfamily double = obj. Get\-Focal\-Point ()} -\/ Set/\-Get the point at which the light is shining. Note\-: The focal point of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space focal point, use vtk\-Get\-Transformed\-Focal\-Point() instead of vtk\-Get\-Focal\-Point().  
\item {\ttfamily obj.\-Set\-Focal\-Point (float a)} -\/ Set/\-Get the point at which the light is shining. Note\-: The focal point of the light is defined in the coordinate space indicated by its transformation matrix (if it exists). Thus, to get the light's world space focal point, use vtk\-Get\-Transformed\-Focal\-Point() instead of vtk\-Get\-Focal\-Point().  
\item {\ttfamily obj.\-Set\-Intensity (double )} -\/ Set/\-Get the brightness of the light (from one to zero).  
\item {\ttfamily double = obj.\-Get\-Intensity ()} -\/ Set/\-Get the brightness of the light (from one to zero).  
\item {\ttfamily obj.\-Set\-Switch (int )} -\/ Turn the light on or off.  
\item {\ttfamily int = obj.\-Get\-Switch ()} -\/ Turn the light on or off.  
\item {\ttfamily obj.\-Switch\-On ()} -\/ Turn the light on or off.  
\item {\ttfamily obj.\-Switch\-Off ()} -\/ Turn the light on or off.  
\item {\ttfamily obj.\-Set\-Positional (int )} -\/ Turn positional lighting on or off.  
\item {\ttfamily int = obj.\-Get\-Positional ()} -\/ Turn positional lighting on or off.  
\item {\ttfamily obj.\-Positional\-On ()} -\/ Turn positional lighting on or off.  
\item {\ttfamily obj.\-Positional\-Off ()} -\/ Turn positional lighting on or off.  
\item {\ttfamily obj.\-Set\-Exponent (double )} -\/ Set/\-Get the exponent of the cosine used in positional lighting.  
\item {\ttfamily double = obj.\-Get\-Exponent\-Min\-Value ()} -\/ Set/\-Get the exponent of the cosine used in positional lighting.  
\item {\ttfamily double = obj.\-Get\-Exponent\-Max\-Value ()} -\/ Set/\-Get the exponent of the cosine used in positional lighting.  
\item {\ttfamily double = obj.\-Get\-Exponent ()} -\/ Set/\-Get the exponent of the cosine used in positional lighting.  
\item {\ttfamily obj.\-Set\-Cone\-Angle (double )} -\/ Set/\-Get the lighting cone angle of a positional light in degrees. This is the angle between the axis of the cone and a ray along the edge of the cone. A value of 180 indicates that you want no spot lighting effects just a positional light.  
\item {\ttfamily double = obj.\-Get\-Cone\-Angle ()} -\/ Set/\-Get the lighting cone angle of a positional light in degrees. This is the angle between the axis of the cone and a ray along the edge of the cone. A value of 180 indicates that you want no spot lighting effects just a positional light.  
\item {\ttfamily obj.\-Set\-Attenuation\-Values (double , double , double )} -\/ Set/\-Get the quadratic attenuation constants. They are specified as constant, linear, and quadratic, in that order.  
\item {\ttfamily obj.\-Set\-Attenuation\-Values (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the quadratic attenuation constants. They are specified as constant, linear, and quadratic, in that order.  
\item {\ttfamily double = obj. Get\-Attenuation\-Values ()} -\/ Set/\-Get the quadratic attenuation constants. They are specified as constant, linear, and quadratic, in that order.  
\item {\ttfamily obj.\-Set\-Transform\-Matrix (vtk\-Matrix4x4 )} -\/ Set/\-Get the light's transformation matrix. If a matrix is set for a light, the light's parameters (position and focal point) are transformed by the matrix before being rendered.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Transform\-Matrix ()} -\/ Set/\-Get the light's transformation matrix. If a matrix is set for a light, the light's parameters (position and focal point) are transformed by the matrix before being rendered.  
\item {\ttfamily obj.\-Get\-Transformed\-Position (double a\mbox{[}3\mbox{]})} -\/ Get the position of the light, modified by the transformation matrix (if it exists).  
\item {\ttfamily double = obj.\-Get\-Transformed\-Position ()} -\/ Get the position of the light, modified by the transformation matrix (if it exists).  
\item {\ttfamily obj.\-Get\-Transformed\-Focal\-Point (double a\mbox{[}3\mbox{]})} -\/ Get the focal point of the light, modified by the transformation matrix (if it exists).  
\item {\ttfamily double = obj.\-Get\-Transformed\-Focal\-Point ()} -\/ Get the focal point of the light, modified by the transformation matrix (if it exists).  
\item {\ttfamily obj.\-Set\-Direction\-Angle (double elevation, double azimuth)} -\/ Set the position and focal point of a light based on elevation and azimuth. The light is moved so it is shining from the given angle. Angles are given in degrees. If the light is a positional light, it is made directional instead.  
\item {\ttfamily obj.\-Set\-Direction\-Angle (double ang\mbox{[}2\mbox{]})} -\/ Set the position and focal point of a light based on elevation and azimuth. The light is moved so it is shining from the given angle. Angles are given in degrees. If the light is a positional light, it is made directional instead.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Light light)} -\/ Perform deep copy of this light.  
\item {\ttfamily obj.\-Set\-Light\-Type (int )} -\/ Set/\-Get the type of the light. A Scene\-Light is a light located in the world coordinate space. A light is initially created as a scene light.

A Headlight is always located at the camera and is pointed at the camera's focal point. The renderer is free to modify the position and focal point of the camera at any time.

A Camera\-Light is also attached to the camera, but is not necessarily located at the camera's position. Camera\-Lights are defined in a coordinate space where the camera is located at (0, 0, 1), looking towards (0, 0, 0) at a distance of 1, with up being (0, 1, 0).

Note\-: Use Set\-Light\-Type\-To\-Scene\-Light, rather than Set\-Light\-Type(3), since the former clears the light's transform matrix.  
\item {\ttfamily int = obj.\-Get\-Light\-Type ()} -\/ Set/\-Get the type of the light. A Scene\-Light is a light located in the world coordinate space. A light is initially created as a scene light.

A Headlight is always located at the camera and is pointed at the camera's focal point. The renderer is free to modify the position and focal point of the camera at any time.

A Camera\-Light is also attached to the camera, but is not necessarily located at the camera's position. Camera\-Lights are defined in a coordinate space where the camera is located at (0, 0, 1), looking towards (0, 0, 0) at a distance of 1, with up being (0, 1, 0).

Note\-: Use Set\-Light\-Type\-To\-Scene\-Light, rather than Set\-Light\-Type(3), since the former clears the light's transform matrix.  
\item {\ttfamily obj.\-Set\-Light\-Type\-To\-Headlight ()} -\/ Set/\-Get the type of the light. A Scene\-Light is a light located in the world coordinate space. A light is initially created as a scene light.

A Headlight is always located at the camera and is pointed at the camera's focal point. The renderer is free to modify the position and focal point of the camera at any time.

A Camera\-Light is also attached to the camera, but is not necessarily located at the camera's position. Camera\-Lights are defined in a coordinate space where the camera is located at (0, 0, 1), looking towards (0, 0, 0) at a distance of 1, with up being (0, 1, 0).

Note\-: Use Set\-Light\-Type\-To\-Scene\-Light, rather than Set\-Light\-Type(3), since the former clears the light's transform matrix.  
\item {\ttfamily obj.\-Set\-Light\-Type\-To\-Scene\-Light ()} -\/ Set/\-Get the type of the light. A Scene\-Light is a light located in the world coordinate space. A light is initially created as a scene light.

A Headlight is always located at the camera and is pointed at the camera's focal point. The renderer is free to modify the position and focal point of the camera at any time.

A Camera\-Light is also attached to the camera, but is not necessarily located at the camera's position. Camera\-Lights are defined in a coordinate space where the camera is located at (0, 0, 1), looking towards (0, 0, 0) at a distance of 1, with up being (0, 1, 0).

Note\-: Use Set\-Light\-Type\-To\-Scene\-Light, rather than Set\-Light\-Type(3), since the former clears the light's transform matrix.  
\item {\ttfamily obj.\-Set\-Light\-Type\-To\-Camera\-Light ()} -\/ Query the type of the light.  
\item {\ttfamily int = obj.\-Light\-Type\-Is\-Headlight ()} -\/ Query the type of the light.  
\item {\ttfamily int = obj.\-Light\-Type\-Is\-Scene\-Light ()} -\/ Query the type of the light.  
\item {\ttfamily int = obj.\-Light\-Type\-Is\-Camera\-Light ()} -\/ Query the type of the light.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklightactor}{}\section{vtk\-Light\-Actor}\label{vtkrendering_vtklightactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Light\-Actor is a composite actor used to represent a spotlight. The cone angle is equal to the spotlight angle, the cone apex is at the position of the light, the direction of the light goes from the cone apex to the center of the base of the cone. The square frustum position is the light position, the frustum focal point is in the direction of the light direction. The frustum vertical view angle (aperture) (this is also the horizontal view angle as the frustum is square) is equal to twice the cone angle. The clipping range of the frustum is arbitrary set by the user (initially at 0.\-5,11.\-0).

To create an instance of class vtk\-Light\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLightActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Light\-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\-Light\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Light\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Light\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Light (vtk\-Light light)} -\/ The spotlight to represent. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Light = obj.\-Get\-Light ()} -\/ The spotlight to represent. Initial value is N\-U\-L\-L.  
\item {\ttfamily obj.\-Set\-Clipping\-Range (double d\-Near, double d\-Far)} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. Initial values are (0.\-5,11.\-0)  
\item {\ttfamily obj.\-Set\-Clipping\-Range (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. Initial values are (0.\-5,11.\-0)  
\item {\ttfamily double = obj. Get\-Clipping\-Range ()} -\/ Set/\-Get the location of the near and far clipping planes along the direction of projection. Both of these values must be positive. Initial values are (0.\-5,11.\-0)  
\item {\ttfamily int = obj.\-Render\-Opaque\-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? No.  
\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 long = obj.\-Get\-M\-Time ()} -\/ Get the actors mtime plus consider its properties and texture if set.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklightcollection}{}\section{vtk\-Light\-Collection}\label{vtkrendering_vtklightcollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Light\-Collection represents and provides methods to manipulate a list of lights (i.\-e., vtk\-Light and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Light\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLightCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Light\-Collection 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\-Light\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Light\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Light\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Light a)} -\/ Add a light to the list.  
\item {\ttfamily vtk\-Light = obj.\-Get\-Next\-Item ()} -\/ Get the next light in the list. N\-U\-L\-L is returned when the collection is exhausted.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklightkit}{}\section{vtk\-Light\-Kit}\label{vtkrendering_vtklightkit}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Light\-Kit is designed to make general purpose lighting of vtk scenes simple, flexible, and attractive (or at least not horribly ugly without significant effort). Use a Light\-Kit when you want more control over your lighting than you can get with the default vtk light, which is a headlight located at the camera. (Head\-Lights are very simple to use, but they don't show the shape of objects very well, don't give a good sense of \char`\"{}up\char`\"{} and \char`\"{}down\char`\"{}, and don't evenly light the object.)

A Light\-Kit consists of three lights, a key light, a fill light, and a headlight. The main light is the key light. It is usually positioned so that it appears like an overhead light (like the sun, or a ceiling light). It is generally positioned to shine down on the scene from about a 45 degree angle vertically and at least a little offset side to side. The key light usually at least about twice as bright as the total of all other lights in the scene to provide good modeling of object features.

The other lights in the kit (the fill light, headlight, and a pair of back lights) are weaker sources that provide extra illumination to fill in the spots that the key light misses. The fill light is usually positioned across from or opposite from the key light (though still on the same side of the object as the camera) in order to simulate diffuse reflections from other objects in the scene. The headlight, always located at the position of the camera, reduces the contrast between areas lit by the key and fill light. The two back lights, one on the left of the object as seen from the observer and one on the right, fill on the high-\/contrast areas behind the object. To enforce the relationship between the different lights, the intensity of the fill, back and headlights are set as a ratio to the key light brightness. Thus, the brightness of all the lights in the scene can be changed by changing the key light intensity.

All lights are directional lights (infinitely far away with no falloff). Lights move with the camera.

For simplicity, the position of lights in the Light\-Kit can only be specified using angles\-: the elevation (latitude) and azimuth (longitude) of each light with respect to the camera, expressed in degrees. (Lights always shine on the camera's lookat point.) For example, a light at (elevation=0, azimuth=0) is located at the camera (a headlight). A light at (elevation=90, azimuth=0) is above the lookat point, shining down. Negative azimuth values move the lights clockwise as seen above, positive values counter-\/clockwise. So, a light at (elevation=45, azimuth=-\/20) is above and in front of the object and shining slightly from the left side.

vtk\-Light\-Kit limits the colors that can be assigned to any light to those of incandescent sources such as light bulbs and sunlight. It defines a special color spectrum called \char`\"{}warmth\char`\"{} from which light colors can be chosen, where 0 is cold blue, 0.\-5 is neutral white, and 1 is deep sunset red. Colors close to 0.\-5 are \char`\"{}cool whites\char`\"{} and \char`\"{}warm whites,\char`\"{} respectively.

Since colors far from white on the warmth scale appear less bright, key-\/to-\/fill and key-\/to-\/headlight ratios are skewed by key, fill, and headlight colors. If the flag Maintain\-Luminance is set, vtk\-Light\-Kit will attempt to compensate for these perceptual differences by increasing the brightness of more saturated colors.

A Light\-Kit is not explicitly part of the vtk pipeline. Rather, it is a composite object that controls the behavior of lights using a unified user interface. Every time a parameter of vtk\-Light\-Kit is adjusted, the properties of its lights are modified.

.S\-E\-C\-T\-I\-O\-N Credits vtk\-Light\-Kit was originally written and contributed to vtk by Michael Halle (\href{mailto:mhalle@bwh.harvard.edu}{\tt mhalle@bwh.\-harvard.\-edu}) at the Surgical Planning Lab, Brigham and Women's Hospital.

To create an instance of class vtk\-Light\-Kit, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLightKit
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Light\-Kit 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\-Light\-Kit class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Light\-Kit = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Light\-Kit = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Key\-Light\-Intensity (double )} -\/ Set/\-Get the intensity of the key light. The key light is the brightest light in the scene. The intensities of the other two lights are ratios of the key light's intensity.  
\item {\ttfamily double = obj.\-Get\-Key\-Light\-Intensity ()} -\/ Set/\-Get the intensity of the key light. The key light is the brightest light in the scene. The intensities of the other two lights are ratios of the key light's intensity.  
\item {\ttfamily obj.\-Set\-Key\-To\-Fill\-Ratio (double )} -\/ Set/\-Get the key-\/to-\/fill ratio. This ratio controls how bright the fill light is compared to the key light\-: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining constrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light\-: a good range for the key-\/to-\/fill ratio is between 2 and 10.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Fill\-Ratio\-Min\-Value ()} -\/ Set/\-Get the key-\/to-\/fill ratio. This ratio controls how bright the fill light is compared to the key light\-: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining constrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light\-: a good range for the key-\/to-\/fill ratio is between 2 and 10.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Fill\-Ratio\-Max\-Value ()} -\/ Set/\-Get the key-\/to-\/fill ratio. This ratio controls how bright the fill light is compared to the key light\-: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining constrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light\-: a good range for the key-\/to-\/fill ratio is between 2 and 10.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Fill\-Ratio ()} -\/ Set/\-Get the key-\/to-\/fill ratio. This ratio controls how bright the fill light is compared to the key light\-: larger values correspond to a dimmer fill light. The purpose of the fill light is to light parts of the object not lit by the key light, while still maintaining constrast. This type of lighting may correspond to indirect illumination from the key light, bounced off a wall, floor, or other object. The fill light should never be brighter than the key light\-: a good range for the key-\/to-\/fill ratio is between 2 and 10.  
\item {\ttfamily obj.\-Set\-Key\-To\-Head\-Ratio (double )} -\/ Set/\-Get the key-\/to-\/headlight ratio. Similar to the key-\/to-\/fill ratio, this ratio controls how bright the headlight light is compared to the key light\-: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \char`\"{}shadows\char`\"{} of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light\-: ratios of 2 to 15 are typical.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Head\-Ratio\-Min\-Value ()} -\/ Set/\-Get the key-\/to-\/headlight ratio. Similar to the key-\/to-\/fill ratio, this ratio controls how bright the headlight light is compared to the key light\-: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \char`\"{}shadows\char`\"{} of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light\-: ratios of 2 to 15 are typical.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Head\-Ratio\-Max\-Value ()} -\/ Set/\-Get the key-\/to-\/headlight ratio. Similar to the key-\/to-\/fill ratio, this ratio controls how bright the headlight light is compared to the key light\-: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \char`\"{}shadows\char`\"{} of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light\-: ratios of 2 to 15 are typical.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Head\-Ratio ()} -\/ Set/\-Get the key-\/to-\/headlight ratio. Similar to the key-\/to-\/fill ratio, this ratio controls how bright the headlight light is compared to the key light\-: larger values correspond to a dimmer headlight light. The headlight is special kind of fill light, lighting only the parts of the object that the camera can see. As such, a headlight tends to reduce the contrast of a scene. It can be used to fill in \char`\"{}shadows\char`\"{} of the object missed by the key and fill lights. The headlight should always be significantly dimmer than the key light\-: ratios of 2 to 15 are typical.  
\item {\ttfamily obj.\-Set\-Key\-To\-Back\-Ratio (double )} -\/ Set/\-Get the key-\/to-\/back light ratio. This ratio controls how bright the back lights are compared to the key light\-: larger values correspond to dimmer back lights. The back lights fill in the remaining high-\/contrast regions behind the object. Values between 2 and 10 are good.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Back\-Ratio\-Min\-Value ()} -\/ Set/\-Get the key-\/to-\/back light ratio. This ratio controls how bright the back lights are compared to the key light\-: larger values correspond to dimmer back lights. The back lights fill in the remaining high-\/contrast regions behind the object. Values between 2 and 10 are good.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Back\-Ratio\-Max\-Value ()} -\/ Set/\-Get the key-\/to-\/back light ratio. This ratio controls how bright the back lights are compared to the key light\-: larger values correspond to dimmer back lights. The back lights fill in the remaining high-\/contrast regions behind the object. Values between 2 and 10 are good.  
\item {\ttfamily double = obj.\-Get\-Key\-To\-Back\-Ratio ()} -\/ Set/\-Get the key-\/to-\/back light ratio. This ratio controls how bright the back lights are compared to the key light\-: larger values correspond to dimmer back lights. The back lights fill in the remaining high-\/contrast regions behind the object. Values between 2 and 10 are good.  
\item {\ttfamily obj.\-Set\-Key\-Light\-Warmth (double )} -\/ Set the warmth of each the lights. Warmth is a parameter that varies from 0 to 1, where 0 is \char`\"{}cold\char`\"{} (looks icy or lit by a very blue sky), 1 is \char`\"{}warm\char`\"{} (the red of a very red sunset, or the embers of a campfire), and 0.\-5 is a neutral white. The warmth scale is non-\/linear. Warmth values close to 0.\-5 are subtly \char`\"{}warmer\char`\"{} or \char`\"{}cooler,\char`\"{} much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.\-5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly.  
\item {\ttfamily double = obj.\-Get\-Key\-Light\-Warmth ()} -\/ Set the warmth of each the lights. Warmth is a parameter that varies from 0 to 1, where 0 is \char`\"{}cold\char`\"{} (looks icy or lit by a very blue sky), 1 is \char`\"{}warm\char`\"{} (the red of a very red sunset, or the embers of a campfire), and 0.\-5 is a neutral white. The warmth scale is non-\/linear. Warmth values close to 0.\-5 are subtly \char`\"{}warmer\char`\"{} or \char`\"{}cooler,\char`\"{} much like a warmer tungsten incandescent bulb, a cooler halogen, or daylight (cooler still). Moving further away from 0.\-5, colors become more quickly varying towards blues and reds. With regards to aesthetics, extremes of warmth should be used sparingly.  
\item {\ttfamily obj.\-Set\-Fill\-Light\-Warmth (double )}  
\item {\ttfamily double = obj.\-Get\-Fill\-Light\-Warmth ()}  
\item {\ttfamily obj.\-Set\-Head\-Light\-Warmth (double )}  
\item {\ttfamily double = obj.\-Get\-Head\-Light\-Warmth ()}  
\item {\ttfamily obj.\-Set\-Back\-Light\-Warmth (double )}  
\item {\ttfamily double = obj.\-Get\-Back\-Light\-Warmth ()}  
\item {\ttfamily double = obj. Get\-Key\-Light\-Color ()} -\/ Returns the floating-\/point R\-G\-B values of each of the light's color.  
\item {\ttfamily double = obj. Get\-Fill\-Light\-Color ()} -\/ Returns the floating-\/point R\-G\-B values of each of the light's color.  
\item {\ttfamily double = obj. Get\-Head\-Light\-Color ()} -\/ Returns the floating-\/point R\-G\-B values of each of the light's color.  
\item {\ttfamily double = obj. Get\-Back\-Light\-Color ()} -\/ Returns the floating-\/point R\-G\-B values of each of the light's color.  
\item {\ttfamily obj.\-Set\-Headlight\-Warmth (double v)} -\/ To maintain a deprecation A\-P\-I\-:  
\item {\ttfamily double = obj.\-Get\-Headlight\-Warmth ()} -\/ To maintain a deprecation A\-P\-I\-:  
\item {\ttfamily obj.\-Get\-Headlight\-Color (double color)} -\/ To maintain a deprecation A\-P\-I\-:  
\item {\ttfamily obj.\-Maintain\-Luminance\-On ()} -\/ If Maintain\-Luminance is set, the Light\-Kit will attempt to maintain the apparent intensity of lights based on their perceptual brightnesses. By default, Maintain\-Luminance is off.  
\item {\ttfamily obj.\-Maintain\-Luminance\-Off ()} -\/ If Maintain\-Luminance is set, the Light\-Kit will attempt to maintain the apparent intensity of lights based on their perceptual brightnesses. By default, Maintain\-Luminance is off.  
\item {\ttfamily int = obj.\-Get\-Maintain\-Luminance ()} -\/ If Maintain\-Luminance is set, the Light\-Kit will attempt to maintain the apparent intensity of lights based on their perceptual brightnesses. By default, Maintain\-Luminance is off.  
\item {\ttfamily obj.\-Set\-Maintain\-Luminance (int )} -\/ If Maintain\-Luminance is set, the Light\-Kit will attempt to maintain the apparent intensity of lights based on their perceptual brightnesses. By default, Maintain\-Luminance is off.  
\item {\ttfamily obj.\-Set\-Key\-Light\-Angle (double elevation, double azimuth)} -\/ Get/\-Set the position of the key, fill, and back lights using angular methods. Elevation corresponds to latitude, azimuth to longitude. It is recommended that the key light always be on the viewer's side of the object and above the object, while the fill light generally lights the part of the object not lit by the fill light. The headlight, which is always located at the viewer, can then be used to reduce the contrast in the image. There are a pair of back lights. They are located at the same elevation and at opposing azimuths (ie, one to the left, and one to the right). They are generally set at the equator (elevation = 0), and at approximately 120 degrees (lighting from each side and behind).  
\item {\ttfamily obj.\-Set\-Key\-Light\-Angle (double angle\mbox{[}2\mbox{]})} -\/ Get/\-Set the position of the key, fill, and back lights using angular methods. Elevation corresponds to latitude, azimuth to longitude. It is recommended that the key light always be on the viewer's side of the object and above the object, while the fill light generally lights the part of the object not lit by the fill light. The headlight, which is always located at the viewer, can then be used to reduce the contrast in the image. There are a pair of back lights. They are located at the same elevation and at opposing azimuths (ie, one to the left, and one to the right). They are generally set at the equator (elevation = 0), and at approximately 120 degrees (lighting from each side and behind).  
\item {\ttfamily obj.\-Set\-Key\-Light\-Elevation (double x)}  
\item {\ttfamily obj.\-Set\-Key\-Light\-Azimuth (double x)}  
\item {\ttfamily double = obj. Get\-Key\-Light\-Angle ()}  
\item {\ttfamily double = obj.\-Get\-Key\-Light\-Elevation ()}  
\item {\ttfamily double = obj.\-Get\-Key\-Light\-Azimuth ()}  
\item {\ttfamily obj.\-Set\-Fill\-Light\-Angle (double elevation, double azimuth)}  
\item {\ttfamily obj.\-Set\-Fill\-Light\-Angle (double angle\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Fill\-Light\-Elevation (double x)}  
\item {\ttfamily obj.\-Set\-Fill\-Light\-Azimuth (double x)}  
\item {\ttfamily double = obj. Get\-Fill\-Light\-Angle ()}  
\item {\ttfamily double = obj.\-Get\-Fill\-Light\-Elevation ()}  
\item {\ttfamily double = obj.\-Get\-Fill\-Light\-Azimuth ()}  
\item {\ttfamily obj.\-Set\-Back\-Light\-Angle (double elevation, double azimuth)}  
\item {\ttfamily obj.\-Set\-Back\-Light\-Angle (double angle\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Back\-Light\-Elevation (double x)}  
\item {\ttfamily obj.\-Set\-Back\-Light\-Azimuth (double x)}  
\item {\ttfamily double = obj. Get\-Back\-Light\-Angle ()}  
\item {\ttfamily double = obj.\-Get\-Back\-Light\-Elevation ()}  
\item {\ttfamily double = obj.\-Get\-Back\-Light\-Azimuth ()}  
\item {\ttfamily obj.\-Add\-Lights\-To\-Renderer (vtk\-Renderer renderer)} -\/ Add lights to, or remove lights from, a renderer. Lights may be added to more than one renderer, if desired.  
\item {\ttfamily obj.\-Remove\-Lights\-From\-Renderer (vtk\-Renderer renderer)} -\/ Add lights to, or remove lights from, a renderer. Lights may be added to more than one renderer, if desired.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Light\-Kit kit)}  
\item {\ttfamily obj.\-Modified ()}  
\item {\ttfamily obj.\-Update ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklightspass}{}\section{vtk\-Lights\-Pass}\label{vtkrendering_vtklightspass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Render the lights.

This pass expects an initialized camera. It disables all the lights, apply transformations for lights following the camera, and turn on the enables lights.

To create an instance of class vtk\-Lights\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLightsPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Lights\-Pass 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\-Lights\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Lights\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Lights\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklineintegralconvolution2d}{}\section{vtk\-Line\-Integral\-Convolution2\-D}\label{vtkrendering_vtklineintegralconvolution2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class resorts to G\-L\-S\-L to implement G\-P\-U-\/based Line Integral Convolution (L\-I\-C) for visualizing a 2\-D vector field that may be obtained by projecting an original 3\-D vector field onto a surface (such that the resulting 2\-D vector at each grid point on the surface is tangential to the local normal, as done in vtk\-Surface\-L\-I\-C\-Painter).

As an image-\/based technique, 2\-D L\-I\-C works by (1) integrating a bidirectional streamline from the center of each pixel (of the L\-I\-C output image), (2) locating the pixels along / hit by this streamline as the correlated pixels of the starting pixel (seed point / pixel), (3) indexing a (usually white) noise texture (another input to L\-I\-C, in addition to the 2\-D vector field, usually with the same size as that of the 2\-D vetor field) to determine the values (colors) of these pixels (the starting and the correlated pixels), typically through bi-\/linear interpolation, and (4) performing convolution (weighted averaging) on these values, by adopting a low-\/pass filter (such as box, ramp, and Hanning kernels), to obtain the result value (color) that is then assigned to the seed pixel.

The G\-L\-S\-L-\/based G\-P\-U implementation herein maps the aforementioned pipeline to fragment shaders and a box kernel is employed. Both the white noise and the vector field are provided to the G\-P\-U as texture objects (supported by the multi-\/texturing capability). In addition, there are four texture objects (color buffers) allocated to constitute two pairs that work in a ping-\/pong fashion, with one as the read buffers and the other as the write / render targets. Maintained by a frame buffer object (G\-L\-\_\-\-E\-X\-T\-\_\-framebuffer\-\_\-object), each pair employs one buffer to store the current (dynamically updated) position (by means of the texture coordinate that keeps being warped by the underlying vector) of the (virtual) particle initially released from each fragment while using the bother buffer to store the current (dynamically updated too) accumulated texture value that each seed fragment (before the 'mesh' is warped) collects. Given Number\-Of\-Steps integration steps in each direction, there are a total of (2 $\ast$ Number\-Of\-Steps + 1) fragments (including the seed fragment) are convolved and each contributes 1 / (2 $\ast$ Number\-Of\-Steps
\begin{DoxyItemize}
\item 1) of the associated texture value to fulfill the box filter.
\end{DoxyItemize}

One pass of L\-I\-C (basic L\-I\-C) tends to produce low-\/contrast / blurred images and vtk\-Line\-Integral\-Convolution2\-D provides an option for creating enhanced L\-I\-C images. Enhanced L\-I\-C improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. It performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. Enhanced L\-I\-C automatically degenerates to basic L\-I\-C during user interaction.

vtk\-Line\-Integral\-Convolution2\-D applies masking to zero-\/vector fragments so that un-\/filtered white noise areas are made totally transparent by class vtk\-Surface\-L\-I\-C\-Painter to show the underlying geometry surface.

.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

To create an instance of class vtk\-Line\-Integral\-Convolution2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLineIntegralConvolution2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Line\-Integral\-Convolution2\-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\-Line\-Integral\-Convolution2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Line\-Integral\-Convolution2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Line\-Integral\-Convolution2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enhanced\-L\-I\-C (int )} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily int = obj.\-Get\-Enhanced\-L\-I\-C ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Enhanced\-L\-I\-C\-On ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Enhanced\-L\-I\-C\-Off ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Set\-L\-I\-C\-For\-Surface (int )}  
\item {\ttfamily int = obj.\-Get\-L\-I\-C\-For\-Surface ()}  
\item {\ttfamily obj.\-L\-I\-C\-For\-Surface\-On ()}  
\item {\ttfamily obj.\-L\-I\-C\-For\-Surface\-Off ()}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Steps (int )} -\/ Number of streamline integration steps (initial value is 1). In term of visual quality, the greater (within some range) the better.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Steps ()} -\/ Number of streamline integration steps (initial value is 1). In term of visual quality, the greater (within some range) the better.  
\item {\ttfamily obj.\-Set\-L\-I\-C\-Step\-Size (double )} -\/ Get/\-Set the streamline integration step size (0.\-01 by default). This is the length of each step in normalized image space i.\-e. in range \mbox{[}0, 1\mbox{]}. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is, but G\-P\-U only supports float. Thus it will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Step\-Size\-Min\-Value ()} -\/ Get/\-Set the streamline integration step size (0.\-01 by default). This is the length of each step in normalized image space i.\-e. in range \mbox{[}0, 1\mbox{]}. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is, but G\-P\-U only supports float. Thus it will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Step\-Size\-Max\-Value ()} -\/ Get/\-Set the streamline integration step size (0.\-01 by default). This is the length of each step in normalized image space i.\-e. in range \mbox{[}0, 1\mbox{]}. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is, but G\-P\-U only supports float. Thus it will be converted to float in the execution of the algorithm.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Step\-Size ()} -\/ Get/\-Set the streamline integration step size (0.\-01 by default). This is the length of each step in normalized image space i.\-e. in range \mbox{[}0, 1\mbox{]}. In term of visual quality, the smaller the better. The type for the interface is double as V\-T\-K interface is, but G\-P\-U only supports float. Thus it will be converted to float in the execution of the algorithm.  
\item {\ttfamily obj.\-Set\-Noise (vtk\-Texture\-Object noise)} -\/ Set/\-Get the input white noise texture (initial value is N\-U\-L\-L).  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Get\-Noise ()} -\/ Set/\-Get the input white noise texture (initial value is N\-U\-L\-L).  
\item {\ttfamily obj.\-Set\-Vector\-Field (vtk\-Texture\-Object vector\-Field)} -\/ Set/\-Get the vector field (initial value is N\-U\-L\-L).  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Get\-Vector\-Field ()} -\/ Set/\-Get the vector field (initial value is N\-U\-L\-L).  
\item {\ttfamily obj.\-Set\-Component\-Ids (int , int )} -\/ If Vector\-Field has $>$= 3 components, we must choose which 2 components form the (X, Y) components for the vector field. Must be in the range \mbox{[}0, 3\mbox{]}.  
\item {\ttfamily obj.\-Set\-Component\-Ids (int a\mbox{[}2\mbox{]})} -\/ If Vector\-Field has $>$= 3 components, we must choose which 2 components form the (X, Y) components for the vector field. Must be in the range \mbox{[}0, 3\mbox{]}.  
\item {\ttfamily int = obj. Get\-Component\-Ids ()} -\/ If Vector\-Field has $>$= 3 components, we must choose which 2 components form the (X, Y) components for the vector field. Must be in the range \mbox{[}0, 3\mbox{]}.  
\item {\ttfamily obj.\-Set\-Grid\-Spacings (double , double )} -\/ Set/\-Get the spacing in each dimension of the plane on which the vector field is defined. This class performs L\-I\-C in the normalized image space and hence generally it needs to transform the input vector field (given in physical space) to the normalized image space. The Spacing is needed to determine the tranform. Default is (1.\-0, 1.\-0). It is possible to disable vector transformation by setting Transform\-Vectors to 0.  
\item {\ttfamily obj.\-Set\-Grid\-Spacings (double a\mbox{[}2\mbox{]})} -\/ Set/\-Get the spacing in each dimension of the plane on which the vector field is defined. This class performs L\-I\-C in the normalized image space and hence generally it needs to transform the input vector field (given in physical space) to the normalized image space. The Spacing is needed to determine the tranform. Default is (1.\-0, 1.\-0). It is possible to disable vector transformation by setting Transform\-Vectors to 0.  
\item {\ttfamily double = obj. Get\-Grid\-Spacings ()} -\/ Set/\-Get the spacing in each dimension of the plane on which the vector field is defined. This class performs L\-I\-C in the normalized image space and hence generally it needs to transform the input vector field (given in physical space) to the normalized image space. The Spacing is needed to determine the tranform. Default is (1.\-0, 1.\-0). It is possible to disable vector transformation by setting Transform\-Vectors to 0.  
\item {\ttfamily obj.\-Set\-Transform\-Vectors (int )} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily int = obj.\-Get\-Transform\-Vectors\-Min\-Value ()} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily int = obj.\-Get\-Transform\-Vectors\-Max\-Value ()} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily obj.\-Transform\-Vectors\-On ()} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily obj.\-Transform\-Vectors\-Off ()} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily int = obj.\-Get\-Transform\-Vectors ()} -\/ This class performs L\-I\-C in the normalized image space. Hence, by default it transforms the input vectors to the normalized image space (using the Grid\-Spacings and input vector field dimensions). Set this to 0 to disable tranformation if the vectors are already tranformed.  
\item {\ttfamily obj.\-Set\-Magnification (int )} -\/ The the magnification factor (default is 1.\-0).  
\item {\ttfamily int = obj.\-Get\-Magnification\-Min\-Value ()} -\/ The the magnification factor (default is 1.\-0).  
\item {\ttfamily int = obj.\-Get\-Magnification\-Max\-Value ()} -\/ The the magnification factor (default is 1.\-0).  
\item {\ttfamily int = obj.\-Get\-Magnification ()} -\/ The the magnification factor (default is 1.\-0).  
\item {\ttfamily obj.\-Set\-Vector\-Shift\-Scale (double shift, double scale)} -\/ Returns if the context supports the required extensions.  
\item {\ttfamily int = obj.\-Execute ()} -\/ Perform the L\-I\-C and obtain the L\-I\-C texture. Return 1 if no error.  
\item {\ttfamily int = obj.\-Execute (int extent\mbox{[}4\mbox{]})} -\/ Same as Execute() except that the L\-I\-C operation is performed only on a window (given by the {\ttfamily extent}) in the input Vector\-Field. The {\ttfamily extent} is relative to the input Vector\-Field. The output L\-I\-C image will be of the size specified by extent.  
\item {\ttfamily int = obj.\-Execute (int extent\mbox{[}4\mbox{]})} -\/ Same as Execute() except that the L\-I\-C operation is performed only on a window (given by the {\ttfamily extent}) in the input Vector\-Field. The {\ttfamily extent} is relative to the input Vector\-Field. The output L\-I\-C image will be of the size specified by extent.  
\item {\ttfamily obj.\-Set\-L\-I\-C (vtk\-Texture\-Object lic)} -\/ L\-I\-C texture (initial value is N\-U\-L\-L) set by Execute().  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Get\-L\-I\-C ()} -\/ L\-I\-C texture (initial value is N\-U\-L\-L) set by Execute().  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklinespainter}{}\section{vtk\-Lines\-Painter}\label{vtkrendering_vtklinespainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter tries to paint lines efficiently. Request to Render any other primitive are ignored and not passed to the delegate painter, if any. This painter cannot handle cell colors/normals. If they are present the request is passed on to the Delegate painter. If this class is able to render the primitive, the render request is not propagated to the delegate painter.

To create an instance of class vtk\-Lines\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinesPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Lines\-Painter 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\-Lines\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Lines\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Lines\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklodactor}{}\section{vtk\-L\-O\-D\-Actor}\label{vtkrendering_vtklodactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-L\-O\-D\-Actor is an actor that stores multiple levels of detail (L\-O\-D) and can automatically switch between them. It selects which level of detail to use based on how much time it has been allocated to render. Currently a very simple method of Total\-Time/\-Number\-Of\-Actors is used. (In the future this should be modified to dynamically allocate the rendering time between different actors based on their needs.)

There are three levels of detail by default. The top level is just the normal data. The lowest level of detail is a simple bounding box outline of the actor. The middle level of detail is a point cloud of a fixed number of points that have been randomly sampled from the mapper's input data. Point attributes are copied over to the point cloud. These two lower levels of detail are accomplished by creating instances of a vtk\-Outline\-Filter (low-\/res) and vtk\-Mask\-Points (medium-\/res). Additional levels of detail can be add using the Add\-L\-O\-D\-Mapper() method.

To control the frame rate, you typically set the vtk\-Render\-Window\-Interactor Desired\-Update\-Rate and Still\-Update\-Rate. This then will cause vtk\-L\-O\-D\-Actor to adjust its L\-O\-D to fulfill the requested update rate.

For greater control on levels of detail, see also vtk\-L\-O\-D\-Prop3\-D. That class allows arbitrary definition of each L\-O\-D.

To create an instance of class vtk\-L\-O\-D\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLODActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-L\-O\-D\-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\-L\-O\-D\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-L\-O\-D\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-L\-O\-D\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer , vtk\-Mapper )} -\/ This causes the actor to be rendered. It, in turn, will render the actor's property and then mapper.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ This method is used internally by the rendering process. We overide the superclass method to properly set the estimated render time.  
\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.\-Add\-L\-O\-D\-Mapper (vtk\-Mapper mapper)} -\/ Add another level of detail. They do not have to be in any order of complexity.  
\item {\ttfamily obj.\-Set\-Low\-Res\-Filter (vtk\-Poly\-Data\-Algorithm )} -\/ You may plug in your own filters to decimate/subsample the input. The default is to use a vtk\-Outline\-Filter (low-\/res) and vtk\-Mask\-Points (medium-\/res).  
\item {\ttfamily obj.\-Set\-Medium\-Res\-Filter (vtk\-Poly\-Data\-Algorithm )} -\/ You may plug in your own filters to decimate/subsample the input. The default is to use a vtk\-Outline\-Filter (low-\/res) and vtk\-Mask\-Points (medium-\/res).  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Low\-Res\-Filter ()} -\/ You may plug in your own filters to decimate/subsample the input. The default is to use a vtk\-Outline\-Filter (low-\/res) and vtk\-Mask\-Points (medium-\/res).  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Medium\-Res\-Filter ()} -\/ You may plug in your own filters to decimate/subsample the input. The default is to use a vtk\-Outline\-Filter (low-\/res) and vtk\-Mask\-Points (medium-\/res).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Cloud\-Points ()} -\/ Set/\-Get the number of random points for the point cloud.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Cloud\-Points (int )} -\/ Set/\-Get the number of random points for the point cloud.  
\item {\ttfamily vtk\-Mapper\-Collection = obj.\-Get\-L\-O\-D\-Mappers ()} -\/ All the mappers for different L\-O\-Ds are stored here. The order is not important.  
\item {\ttfamily obj.\-Modified ()} -\/ When this objects gets modified, this method also modifies the object.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of an L\-O\-D actor. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtklodprop3d}{}\section{vtk\-L\-O\-D\-Prop3\-D}\label{vtkrendering_vtklodprop3d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-L\-O\-D\-Prop3\-D is a class to support level of detail rendering for Prop3\-D. Any number of mapper/property/texture items can be added to this object. Render time will be measured, and will be used to select a L\-O\-D based on the Allocated\-Render\-Time of this Prop3\-D. Depending on the type of the mapper/property, a vtk\-Actor or a vtk\-Volume will be created behind the scenes.

To create an instance of class vtk\-L\-O\-D\-Prop3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLODProp3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-L\-O\-D\-Prop3\-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\-L\-O\-D\-Prop3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-L\-O\-D\-Prop3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-L\-O\-D\-Prop3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Standard vtk\-Prop method to get 3\-D bounds of a 3\-D prop  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, vtk\-Property p, vtk\-Property back, vtk\-Texture t, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, vtk\-Property p, vtk\-Texture t, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, vtk\-Property p, vtk\-Property back, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, vtk\-Property p, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, vtk\-Texture t, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Mapper m, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Abstract\-Volume\-Mapper m, vtk\-Volume\-Property p, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Add\-L\-O\-D (vtk\-Abstract\-Volume\-Mapper m, double time)} -\/ Add a level of detail with a given mapper, property, backface property, texture, and guess of rendering time. The property and texture fields can be set to N\-U\-L\-L (the other methods are included for script access where null variables are not allowed). The time field can be set to 0.\-0 indicating that no initial guess for rendering time is being supplied. The returned integer value is an I\-D that can be used later to delete this L\-O\-D, or set it as the selected L\-O\-D.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-L\-O\-Ds ()} -\/ Get the current number of L\-O\-Ds.  
\item {\ttfamily int = obj.\-Get\-Current\-Index ()} -\/ Get the current index, used to determine the I\-D of the next L\-O\-D that is added. Useful for guessing what I\-Ds have been used (with Number\-Of\-L\-O\-Ds, without depending on the constructor initialization to 1000.  
\item {\ttfamily obj.\-Remove\-L\-O\-D (int id)} -\/ Delete a level of detail given an I\-D. This is the I\-D returned by the Add\-L\-O\-D method  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Property (int id, vtk\-Property p)} -\/ Methods to set / get the property of an L\-O\-D. Since the L\-O\-D could be a volume or an actor, you have to pass in the pointer to the property to get it. The returned property will be N\-U\-L\-L if the id is not valid, or the property is of the wrong type for the corresponding Prop3\-D.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Property (int id, vtk\-Volume\-Property p)} -\/ Methods to set / get the property of an L\-O\-D. Since the L\-O\-D could be a volume or an actor, you have to pass in the pointer to the property to get it. The returned property will be N\-U\-L\-L if the id is not valid, or the property is of the wrong type for the corresponding Prop3\-D.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Mapper (int id, vtk\-Mapper m)} -\/ Methods to set / get the mapper of an L\-O\-D. Since the L\-O\-D could be a volume or an actor, you have to pass in the pointer to the mapper to get it. The returned mapper will be N\-U\-L\-L if the id is not valid, or the mapper is of the wrong type for the corresponding Prop3\-D.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Mapper (int id, vtk\-Abstract\-Volume\-Mapper m)} -\/ Methods to set / get the mapper of an L\-O\-D. Since the L\-O\-D could be a volume or an actor, you have to pass in the pointer to the mapper to get it. The returned mapper will be N\-U\-L\-L if the id is not valid, or the mapper is of the wrong type for the corresponding Prop3\-D.  
\item {\ttfamily vtk\-Abstract\-Mapper3\-D = obj.\-Get\-L\-O\-D\-Mapper (int id)} -\/ Get the L\-O\-D\-Mapper as an vtk\-Abstract\-Mapper3\-D. It is the user's respondibility to safe down cast this to a vtk\-Mapper or vtk\-Volume\-Mapper as appropriate.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Backface\-Property (int id, vtk\-Property t)} -\/ Methods to set / get the backface property of an L\-O\-D. This method is only valid for L\-O\-D ids that are Actors (not Volumes)  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Texture (int id, vtk\-Texture t)} -\/ Methods to set / get the texture of an L\-O\-D. This method is only valid for L\-O\-D ids that are Actors (not Volumes)  
\item {\ttfamily obj.\-Enable\-L\-O\-D (int id)} -\/ Enable / disable a particular L\-O\-D. If it is disabled, it will not be used during automatic selection, but can be selected as the L\-O\-D if automatic L\-O\-D selection is off.  
\item {\ttfamily obj.\-Disable\-L\-O\-D (int id)} -\/ Enable / disable a particular L\-O\-D. If it is disabled, it will not be used during automatic selection, but can be selected as the L\-O\-D if automatic L\-O\-D selection is off.  
\item {\ttfamily int = obj.\-Is\-L\-O\-D\-Enabled (int id)} -\/ Enable / disable a particular L\-O\-D. If it is disabled, it will not be used during automatic selection, but can be selected as the L\-O\-D if automatic L\-O\-D selection is off.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Level (int id, double level)} -\/ Set the level of a particular L\-O\-D. When a L\-O\-D is selected for rendering because it has the largest render time that fits within the allocated time, all L\-O\-D are then checked to see if any one can render faster but has a lower (more resolution/better) level. This quantity is a double to ensure that a level can be inserted between 2 and 3.  
\item {\ttfamily double = obj.\-Get\-L\-O\-D\-Level (int id)} -\/ Set the level of a particular L\-O\-D. When a L\-O\-D is selected for rendering because it has the largest render time that fits within the allocated time, all L\-O\-D are then checked to see if any one can render faster but has a lower (more resolution/better) level. This quantity is a double to ensure that a level can be inserted between 2 and 3.  
\item {\ttfamily double = obj.\-Get\-L\-O\-D\-Index\-Level (int index)} -\/ Set the level of a particular L\-O\-D. When a L\-O\-D is selected for rendering because it has the largest render time that fits within the allocated time, all L\-O\-D are then checked to see if any one can render faster but has a lower (more resolution/better) level. This quantity is a double to ensure that a level can be inserted between 2 and 3.  
\item {\ttfamily double = obj.\-Get\-L\-O\-D\-Estimated\-Render\-Time (int id)} -\/ Access method that can be used to find out the estimated render time (the thing used to select an L\-O\-D) for a given L\-O\-D I\-D or index. Value is returned in seconds.  
\item {\ttfamily double = obj.\-Get\-L\-O\-D\-Index\-Estimated\-Render\-Time (int index)} -\/ Access method that can be used to find out the estimated render time (the thing used to select an L\-O\-D) for a given L\-O\-D I\-D or index. Value is returned in seconds.  
\item {\ttfamily obj.\-Set\-Automatic\-L\-O\-D\-Selection (int )} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-L\-O\-D\-Selection\-Min\-Value ()} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-L\-O\-D\-Selection\-Max\-Value ()} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-L\-O\-D\-Selection ()} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Automatic\-L\-O\-D\-Selection\-On ()} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Automatic\-L\-O\-D\-Selection\-Off ()} -\/ Turn on / off automatic selection of L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Set\-Selected\-L\-O\-D\-I\-D (int )} -\/ Set the id of the L\-O\-D that is to be drawn when automatic L\-O\-D selection is turned off.  
\item {\ttfamily int = obj.\-Get\-Selected\-L\-O\-D\-I\-D ()} -\/ Set the id of the L\-O\-D that is to be drawn when automatic L\-O\-D selection is turned off.  
\item {\ttfamily int = obj.\-Get\-Last\-Rendered\-L\-O\-D\-I\-D ()} -\/ Get the I\-D of the previously (during the last render) selected L\-O\-D index  
\item {\ttfamily int = obj.\-Get\-Pick\-L\-O\-D\-I\-D (void )} -\/ Get the I\-D of the appropriate pick L\-O\-D index  
\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 obj.\-Get\-Volumes (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 obj.\-Set\-Selected\-Pick\-L\-O\-D\-I\-D (int id)} -\/ Set the id of the L\-O\-D that is to be used for picking when automatic L\-O\-D pick selection is turned off.  
\item {\ttfamily int = obj.\-Get\-Selected\-Pick\-L\-O\-D\-I\-D ()} -\/ Set the id of the L\-O\-D that is to be used for picking when automatic L\-O\-D pick selection is turned off.  
\item {\ttfamily obj.\-Set\-Automatic\-Pick\-L\-O\-D\-Selection (int )} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Pick\-L\-O\-D\-Selection\-Min\-Value ()} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Pick\-L\-O\-D\-Selection\-Max\-Value ()} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily int = obj.\-Get\-Automatic\-Pick\-L\-O\-D\-Selection ()} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Automatic\-Pick\-L\-O\-D\-Selection\-On ()} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Automatic\-Pick\-L\-O\-D\-Selection\-Off ()} -\/ Turn on / off automatic selection of picking L\-O\-D. This is on by default. If it is off, then the Selected\-L\-O\-D\-I\-D is rendered regardless of rendering time or desired update rate.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this vtk\-L\-O\-D\-Prop3\-D.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkmaparrayvalues}{}\section{vtk\-Map\-Array\-Values}\label{vtkrendering_vtkmaparrayvalues}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Map\-Array\-Values allows you to associate certain values of an attribute array (on either a vertex, edge, point, or cell) with different values in a newly created attribute array.

vtk\-Map\-Array\-Values manages an internal S\-T\-L map of vtk\-Variants that can be added to or cleared. When this filter executes, each \char`\"{}key\char`\"{} is searched for in the input array and the indices of the output array at which there were matches the set to the mapped \char`\"{}value\char`\"{}.

You can control whether the input array values are passed to the output before the mapping occurs (using Pass\-Array) or, if not, what value to set the unmapped indices to (using Fill\-Value).

One application of this filter is to help address the dirty data problem. For example, using vtk\-Map\-Array\-Values you could associate the vertex values \char`\"{}\-Foo, John\char`\"{}, \char`\"{}\-Foo, John.\char`\"{}, and \char`\"{}\-John Foo\char`\"{} with a single entity.

To create an instance of class vtk\-Map\-Array\-Values, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMapArrayValues
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Map\-Array\-Values 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\-Map\-Array\-Values class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Map\-Array\-Values = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Map\-Array\-Values = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Field\-Type (int )} -\/ Set/\-Get where the data is located that is being mapped. See Field\-Type enumeration for possible values. Default is P\-O\-I\-N\-T\-\_\-\-D\-A\-T\-A.  
\item {\ttfamily int = obj.\-Get\-Field\-Type ()} -\/ Set/\-Get where the data is located that is being mapped. See Field\-Type enumeration for possible values. Default is P\-O\-I\-N\-T\-\_\-\-D\-A\-T\-A.  
\item {\ttfamily obj.\-Set\-Pass\-Array (int )} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is off.  
\item {\ttfamily int = obj.\-Get\-Pass\-Array ()} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is off.  
\item {\ttfamily obj.\-Pass\-Array\-On ()} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is off.  
\item {\ttfamily obj.\-Pass\-Array\-Off ()} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is off.  
\item {\ttfamily obj.\-Set\-Fill\-Value (double )} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is -\/1.  
\item {\ttfamily double = obj.\-Get\-Fill\-Value ()} -\/ Set/\-Get whether to copy the data from the input array to the output array before the mapping occurs. If turned off, Fill\-Value is used to initialize any unmapped array indices. Default is -\/1.  
\item {\ttfamily obj.\-Set\-Input\-Array\-Name (string )} -\/ Set/\-Get the name of the input array. This must be set prior to execution.  
\item {\ttfamily string = obj.\-Get\-Input\-Array\-Name ()} -\/ Set/\-Get the name of the input array. This must be set prior to execution.  
\item {\ttfamily obj.\-Set\-Output\-Array\-Name (string )} -\/ Set/\-Get the name of the output array. Default is \char`\"{}\-Array\-Map\char`\"{}.  
\item {\ttfamily string = obj.\-Get\-Output\-Array\-Name ()} -\/ Set/\-Get the name of the output array. Default is \char`\"{}\-Array\-Map\char`\"{}.  
\item {\ttfamily int = obj.\-Get\-Output\-Array\-Type ()} -\/ Set/\-Get the type of the output array. See vtk\-Set\-Get.\-h for possible values. Default is V\-T\-K\-\_\-\-I\-N\-T.  
\item {\ttfamily obj.\-Set\-Output\-Array\-Type (int )} -\/ Set/\-Get the type of the output array. See vtk\-Set\-Get.\-h for possible values. Default is V\-T\-K\-\_\-\-I\-N\-T.  
\item {\ttfamily obj.\-Add\-To\-Map (int from, int to)} -\/ Add to the internal S\-T\-L map. \char`\"{}from\char`\"{} should be a value in the input array and \char`\"{}to\char`\"{} should be the new value it gets assigned in the output array.  
\item {\ttfamily obj.\-Add\-To\-Map (int from, string to)} -\/ Add to the internal S\-T\-L map. \char`\"{}from\char`\"{} should be a value in the input array and \char`\"{}to\char`\"{} should be the new value it gets assigned in the output array.  
\item {\ttfamily obj.\-Add\-To\-Map (string from, int to)} -\/ Add to the internal S\-T\-L map. \char`\"{}from\char`\"{} should be a value in the input array and \char`\"{}to\char`\"{} should be the new value it gets assigned in the output array.  
\item {\ttfamily obj.\-Add\-To\-Map (string from, string to)} -\/ Add to the internal S\-T\-L map. \char`\"{}from\char`\"{} should be a value in the input array and \char`\"{}to\char`\"{} should be the new value it gets assigned in the output array.  
\item {\ttfamily obj.\-Clear\-Map ()} -\/ Clear the internal map.  
\item {\ttfamily int = obj.\-Get\-Map\-Size ()} -\/ Get the size of the internal map.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkmapper}{}\section{vtk\-Mapper}\label{vtkrendering_vtkmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mapper is an abstract class to specify interface between data and graphics primitives. Subclasses of vtk\-Mapper map data through a lookuptable and control the creation of rendering primitives that interface to the graphics library. The mapping can be controlled by supplying a lookup table and specifying a scalar range to map data through.

There are several important control mechanisms affecting the behavior of this object. The Scalar\-Visibility flag controls whether scalar data (if any) controls the color of the associated actor(s) that refer to the mapper. The Scalar\-Mode ivar is used to determine whether scalar point data or cell data is used to color the object. By default, point data scalars are used unless there are none, in which cell scalars are used. Or you can explicitly control whether to use point or cell scalar data. Finally, the mapping of scalars through the lookup table varies depending on the setting of the Color\-Mode flag. See the documentation for the appropriate methods for an explanation.

Another important feature of this class is whether to use immediate mode rendering (Immediate\-Mode\-Rendering\-On) or display list rendering (Immediate\-Mode\-Rendering\-Off). If display lists are used, a data structure is constructed (generally in the rendering library) which can then be rapidly traversed and rendered by the rendering library. The disadvantage of display lists is that they require additionally memory which may affect the performance of the system.

Another important feature of the mapper is the ability to shift the z-\/buffer to resolve coincident topology. For example, if you'd like to draw a mesh with some edges a different color, and the edges lie on the mesh, this feature can be useful to get nice looking lines. (See the Resolve\-Coincident\-Topology-\/related methods.)

To create an instance of class vtk\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Abstract\-Mapper m)} -\/ Make a shallow copy of this mapper.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If lookup table is modified, then this object is modified as well.  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor a)} -\/ Method initiates the mapping process. Generally sent by the actor as each frame is rendered.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors lut)} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily obj.\-Create\-Default\-Lookup\-Table ()} -\/ Create default lookup table. Generally used to create one when none is available with the scalar data.  
\item {\ttfamily obj.\-Set\-Scalar\-Visibility (int )} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Visibility ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Scalar\-Visibility\-On ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Scalar\-Visibility\-Off ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Set\-Static (int )} -\/ Turn on/off flag to control whether the mapper's data is static. Static data means that the mapper does not propagate updates down the pipeline, greatly decreasing the time it takes to update many mappers. This should only be used if the data never changes.  
\item {\ttfamily int = obj.\-Get\-Static ()} -\/ Turn on/off flag to control whether the mapper's data is static. Static data means that the mapper does not propagate updates down the pipeline, greatly decreasing the time it takes to update many mappers. This should only be used if the data never changes.  
\item {\ttfamily obj.\-Static\-On ()} -\/ Turn on/off flag to control whether the mapper's data is static. Static data means that the mapper does not propagate updates down the pipeline, greatly decreasing the time it takes to update many mappers. This should only be used if the data never changes.  
\item {\ttfamily obj.\-Static\-Off ()} -\/ Turn on/off flag to control whether the mapper's data is static. Static data means that the mapper does not propagate updates down the pipeline, greatly decreasing the time it takes to update many mappers. This should only be used if the data never changes.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Select\-Color\-Array() method.)  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Select\-Color\-Array() method.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Default ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Select\-Color\-Array() method.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Map\-Scalars ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Select\-Color\-Array() method.)  
\item {\ttfamily string = obj.\-Get\-Color\-Mode\-As\-String ()} -\/ Return the method of coloring scalar data.  
\item {\ttfamily obj.\-Set\-Interpolate\-Scalars\-Before\-Mapping (int )} -\/ By default, vertex color is used to map colors to a surface. Colors are interpolated after being mapped. This option avoids color interpolation by using a one dimensional texture map for the colors.  
\item {\ttfamily int = obj.\-Get\-Interpolate\-Scalars\-Before\-Mapping ()} -\/ By default, vertex color is used to map colors to a surface. Colors are interpolated after being mapped. This option avoids color interpolation by using a one dimensional texture map for the colors.  
\item {\ttfamily obj.\-Interpolate\-Scalars\-Before\-Mapping\-On ()} -\/ By default, vertex color is used to map colors to a surface. Colors are interpolated after being mapped. This option avoids color interpolation by using a one dimensional texture map for the colors.  
\item {\ttfamily obj.\-Interpolate\-Scalars\-Before\-Mapping\-Off ()} -\/ By default, vertex color is used to map colors to a surface. Colors are interpolated after being mapped. This option avoids color interpolation by using a one dimensional texture map for the colors.  
\item {\ttfamily obj.\-Set\-Use\-Lookup\-Table\-Scalar\-Range (int )} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily int = obj.\-Get\-Use\-Lookup\-Table\-Scalar\-Range ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Use\-Lookup\-Table\-Scalar\-Range\-On ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Use\-Lookup\-Table\-Scalar\-Range\-Off ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily obj.\-Set\-Immediate\-Mode\-Rendering (int )} -\/ Turn on/off flag to control whether data is rendered using immediate mode or note. Immediate mode rendering tends to be slower but it can handle larger datasets. The default value is immediate mode off. If you are having problems rendering a large dataset you might want to consider using immediate more rendering.  
\item {\ttfamily int = obj.\-Get\-Immediate\-Mode\-Rendering ()} -\/ Turn on/off flag to control whether data is rendered using immediate mode or note. Immediate mode rendering tends to be slower but it can handle larger datasets. The default value is immediate mode off. If you are having problems rendering a large dataset you might want to consider using immediate more rendering.  
\item {\ttfamily obj.\-Immediate\-Mode\-Rendering\-On ()} -\/ Turn on/off flag to control whether data is rendered using immediate mode or note. Immediate mode rendering tends to be slower but it can handle larger datasets. The default value is immediate mode off. If you are having problems rendering a large dataset you might want to consider using immediate more rendering.  
\item {\ttfamily obj.\-Immediate\-Mode\-Rendering\-Off ()} -\/ Turn on/off flag to control whether data is rendered using immediate mode or note. Immediate mode rendering tends to be slower but it can handle larger datasets. The default value is immediate mode off. If you are having problems rendering a large dataset you might want to consider using immediate more rendering.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Default ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Field\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Field\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Select\-Color\-Array before you call Get\-Colors. When Scalar\-Mode is set to use Field Data (Scalar\-Mode\-To\-Field\-Data), you must call Select\-Color\-Array to choose the field data array to be used to color cells. In this mode, if the poly data has triangle strips, the field data is treated as the celldata for each mini-\/cell formed by a triangle in the strip rather than the entire strip.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Field\-Data ()} -\/ When Scalar\-Mode is set to Use\-Point\-Field\-Data or Use\-Cell\-Field\-Data, you can specify which array to use for coloring using these methods. The lookup table will decide how to convert vectors to colors.  
\item {\ttfamily obj.\-Select\-Color\-Array (int array\-Num)} -\/ When Scalar\-Mode is set to Use\-Point\-Field\-Data or Use\-Cell\-Field\-Data, you can specify which array to use for coloring using these methods. The lookup table will decide how to convert vectors to colors.  
\item {\ttfamily obj.\-Select\-Color\-Array (string array\-Name)} -\/ When Scalar\-Mode is set to Use\-Point\-Field\-Data or Use\-Cell\-Field\-Data, you can specify which array to use for coloring using these methods. The lookup table will decide how to convert vectors to colors.  
\item {\ttfamily obj.\-Color\-By\-Array\-Component (int array\-Num, int component)} -\/ Legacy\-: These methods used to be used to specify the array component. It is better to do this in the lookup table.  
\item {\ttfamily obj.\-Color\-By\-Array\-Component (string array\-Name, int component)} -\/ Legacy\-: These methods used to be used to specify the array component. It is better to do this in the lookup table.  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Id ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Access\-Mode ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Return the method for obtaining scalar data.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Mode\-As\-String ()} -\/ Return the method for obtaining scalar data.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Set\-Render\-Time (double time)} -\/ This instance variable is used by vtk\-L\-O\-D\-Actor to determine which mapper to use. It is an estimate of the time necessary to render. Setting the render time does not modify the mapper.  
\item {\ttfamily double = obj.\-Get\-Render\-Time ()} -\/ This instance variable is used by vtk\-L\-O\-D\-Actor to determine which mapper to use. It is an estimate of the time necessary to render. Setting the render time does not modify the mapper.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input\-As\-Data\-Set ()} -\/ Map the scalars (if there are any scalars and Scalar\-Visibility is on) through the lookup table, returning an unsigned char R\-G\-B\-A array. This is typically done as part of the rendering process. The alpha parameter allows the blending of the scalars with an additional alpha (typically which comes from a vtk\-Actor, etc.)  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Map\-Scalars (double alpha)} -\/ Map the scalars (if there are any scalars and Scalar\-Visibility is on) through the lookup table, returning an unsigned char R\-G\-B\-A array. This is typically done as part of the rendering process. The alpha parameter allows the blending of the scalars with an additional alpha (typically which comes from a vtk\-Actor, etc.)  
\item {\ttfamily obj.\-Set\-Scalar\-Material\-Mode (int )} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Material\-Mode ()} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily obj.\-Set\-Scalar\-Material\-Mode\-To\-Default ()} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily obj.\-Set\-Scalar\-Material\-Mode\-To\-Ambient ()} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily obj.\-Set\-Scalar\-Material\-Mode\-To\-Diffuse ()} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily obj.\-Set\-Scalar\-Material\-Mode\-To\-Ambient\-And\-Diffuse ()} -\/ Set/\-Get the light-\/model color mode.  
\item {\ttfamily string = obj.\-Get\-Scalar\-Material\-Mode\-As\-String ()} -\/ Return the light-\/model color mode.  
\item {\ttfamily bool = obj.\-Get\-Supports\-Selection ()} -\/ W\-A\-R\-N\-I\-N\-G\-: I\-N\-T\-E\-R\-N\-A\-L M\-E\-T\-H\-O\-D -\/ N\-O\-T I\-N\-T\-E\-N\-D\-E\-D F\-O\-R G\-E\-N\-E\-R\-A\-L U\-S\-E D\-O N\-O\-T U\-S\-E T\-H\-I\-S M\-E\-T\-H\-O\-D O\-U\-T\-S\-I\-D\-E O\-F T\-H\-E R\-E\-N\-D\-E\-R\-I\-N\-G P\-R\-O\-C\-E\-S\-S Used by vtk\-Hardware\-Selector to determine if the prop supports hardware selection.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkmappercollection}{}\section{vtk\-Mapper\-Collection}\label{vtkrendering_vtkmappercollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Mapper\-Collection represents and provides methods to manipulate a list of mappers (i.\-e., vtk\-Mapper and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Mapper\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkMapperCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Mapper\-Collection 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\-Mapper\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Mapper\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Mapper\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Mapper a)} -\/ Add an mapper to the list.  
\item {\ttfamily vtk\-Mapper = obj.\-Get\-Next\-Item ()} -\/ Get the next mapper in the list.  
\item {\ttfamily vtk\-Mapper = obj.\-Get\-Last\-Item ()} -\/ Get the last mapper in the list.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkobjexporter}{}\section{vtk\-O\-B\-J\-Exporter}\label{vtkrendering_vtkobjexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-O\-B\-J\-Exporter is a concrete subclass of vtk\-Exporter that writes wavefront .O\-B\-J files in A\-S\-C\-I\-I form. It also writes out a mtl file that contains the material properties. The filenames are derived by appending the .obj and .mtl suffix onto the user specified File\-Prefix.

To create an instance of class vtk\-O\-B\-J\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOBJExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-O\-B\-J\-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\-O\-B\-J\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-O\-B\-J\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-O\-B\-J\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Prefix (string )} -\/ Specify the prefix of the files to write out. The resulting filenames will have .obj and .mtl appended to them.  
\item {\ttfamily string = obj.\-Get\-File\-Prefix ()} -\/ Specify the prefix of the files to write out. The resulting filenames will have .obj and .mtl appended to them.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkobservermediator}{}\section{vtk\-Observer\-Mediator}\label{vtkrendering_vtkobservermediator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Observer\-Mediator is a helper class that manages requests for cursor changes from multiple interactor observers (e.\-g. widgets). It keeps a list of widgets (and their priorities) and their current requests for cursor shape. It then satisfies requests based on widget priority and the relative importance of the request (e.\-g., a lower priority widget requesting a particular cursor shape will overrule a higher priority widget requesting a default shape).

To create an instance of class vtk\-Observer\-Mediator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkObserverMediator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Observer\-Mediator 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\-Observer\-Mediator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard macros.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard macros.  
\item {\ttfamily vtk\-Observer\-Mediator = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Observer\-Mediator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor iren)} -\/ Specify the instance of vtk\-Render\-Window whose cursor shape is to be managed.  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-Get\-Interactor ()} -\/ Specify the instance of vtk\-Render\-Window whose cursor shape is to be managed.  
\item {\ttfamily int = obj.\-Request\-Cursor\-Shape (vtk\-Interactor\-Observer , int cursor\-Shape)} -\/ Method used to request a cursor shape. Note that the shape is specified using one of the integral values determined in vtk\-Render\-Window.\-h. The method returns a non-\/zero value if the shape was successfully changed.  
\item {\ttfamily obj.\-Remove\-All\-Cursor\-Shape\-Requests (vtk\-Interactor\-Observer )} -\/ Remove all requests for cursor shape from a given interactor.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkooglexporter}{}\section{vtk\-O\-O\-G\-L\-Exporter}\label{vtkrendering_vtkooglexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-O\-O\-G\-L\-Exporter is a concrete subclass of vtk\-Exporter that writes Geomview O\-O\-G\-L files.

To create an instance of class vtk\-O\-O\-G\-L\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOOGLExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-O\-O\-G\-L\-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\-O\-O\-G\-L\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-O\-O\-G\-L\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-O\-O\-G\-L\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the name of the Geomview file to write.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the name of the Geomview file to write.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopaquepass}{}\section{vtk\-Opaque\-Pass}\label{vtkrendering_vtkopaquepass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Opaque\-Pass renders the opaque geometry of all the props that have the keys contained in vtk\-Render\-State.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color.

To create an instance of class vtk\-Opaque\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpaquePass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Opaque\-Pass 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\-Opaque\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Opaque\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Opaque\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglactor}{}\section{vtk\-Open\-G\-L\-Actor}\label{vtkrendering_vtkopenglactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Actor is a concrete implementation of the abstract class vtk\-Actor. vtk\-Open\-G\-L\-Actor interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-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\-Open\-G\-L\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Mapper mapper)} -\/ Actual actor render method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglcamera}{}\section{vtk\-Open\-G\-L\-Camera}\label{vtkrendering_vtkopenglcamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Camera is a concrete implementation of the abstract class vtk\-Camera. vtk\-Open\-G\-L\-Camera interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Camera has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Update\-Viewport (vtk\-Renderer ren)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglclipplanespainter}{}\section{vtk\-Open\-G\-L\-Clip\-Planes\-Painter}\label{vtkrendering_vtkopenglclipplanespainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter is an open\-G\-L specific painter which handles clipplanes. This painter must typically be placed before the painter that do the primitive rendering.

To create an instance of class vtk\-Open\-G\-L\-Clip\-Planes\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLClipPlanesPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Clip\-Planes\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Clip\-Planes\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Clip\-Planes\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Clip\-Planes\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglcoincidenttopologyresolutionpainter}{}\section{vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter}\label{vtkrendering_vtkopenglcoincidenttopologyresolutionpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Implementation for vtk\-Coincident\-Topology\-Resolution\-Painter using Open\-G\-L.

To create an instance of class vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLCoincidentTopologyResolutionPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Coincident\-Topology\-Resolution\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopengldisplaylistpainter}{}\section{vtk\-Open\-G\-L\-Display\-List\-Painter}\label{vtkrendering_vtkopengldisplaylistpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Display\-List\-Painter creates an Open\-G\-L display list for rendering. This painter creates a different display list for every render request with a different set of typeflags. If any of the data or inputs change, then all display lists are discarded.

To create an instance of class vtk\-Open\-G\-L\-Display\-List\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLDisplayListPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Display\-List\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Display\-List\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Display\-List\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Display\-List\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. In this case, releases the display lists.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglextensionmanager}{}\section{vtk\-Open\-G\-L\-Extension\-Manager}\label{vtkrendering_vtkopenglextensionmanager}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Extension\-Manager acts as an interface to Open\-G\-L extensions. It provides methods to query Open\-G\-L extensions on the current or a given render window and to load extension function pointers. Currently does not support G\-L\-U extensions since the G\-L\-U library is not linked to V\-T\-K.

Before using vtk\-Open\-G\-L\-Extension\-Manager, an Open\-G\-L context must be created. This is generally done with a vtk\-Render\-Window. Note that simply creating the vtk\-Render\-Window is not sufficient. Usually you have to call Render before the actual Open\-G\-L context is created. You can specify the Render\-Window with the Set\-Render\-Window method. \begin{DoxyVerb} vtkOpenGLExtensionManager *extensions = vtkOpenGLExtensionManager::New();
 extensions->SetRenderWindow(renwin);
\end{DoxyVerb}
 If no vtk\-Render\-Window is specified, the current Open\-G\-L context (if any) is used.

Generally speaking, when using Open\-G\-L extensions, you will need an vtk\-Open\-G\-L\-Extension\-Manager and the prototypes defined in vtkgl.\-h. \begin{DoxyVerb} #include "vtkOpenGLExtensionManager.h"
 #include "vtkgl.h"\end{DoxyVerb}
 The vtkgl.\-h include file contains all the constants and function pointers required for using Open\-G\-L extensions in a portable and namespace safe way. vtkgl.\-h is built from parsed glext.\-h, glxext.\-h, and wglext.\-h files. Snapshots of these files are distributed with V\-T\-K, but you can also set C\-Make options to use other files.

To use an Open\-G\-L extension, you first need to make an instance of vtk\-Open\-G\-L\-Extension\-Manager and give it a vtk\-Render\-Window. You can then query the vtk\-Open\-G\-L\-Extension\-Manager to see if the extension is supported with the Extension\-Supported method. Valid names for extensions are given in the Open\-G\-L extension registry at \href{http://www.opengl.org/registry/}{\tt http\-://www.\-opengl.\-org/registry/} . You can also grep vtkgl.\-h (which will be in the binary build directory if V\-T\-K is not installed) for appropriate names. There are also special extensions G\-L\-\_\-\-V\-E\-R\-S\-I\-O\-N\-\_\-\-X\-\_\-\-X (where X\-\_\-\-X is replaced with a major and minor version, respectively) which contain all the constants and functions for Open\-G\-L versions for which the gl.\-h header file is of an older version than the driver.

\begin{DoxyVerb} if (   !extensions->ExtensionSupported("GL_VERSION_1_2")
     || !extensions->ExtensionSupported("GL_ARB_multitexture") ) {
   {
   vtkErrorMacro("Required extensions not supported!");
   }\end{DoxyVerb}


Once you have verified that the extensions you want exist, before you use them you have to load them with the Load\-Extension method.

\begin{DoxyVerb} extensions->LoadExtension("GL_VERSION_1_2");
 extensions->LoadExtension("GL_ARB_multitexture");\end{DoxyVerb}


Alternatively, you can use the Load\-Supported\-Extension method, which checks whether the requested extension is supported and, if so, loads it. The Load\-Supported\-Extension method will not raise any errors or warnings if it fails, so it is important for callers to pay attention to the return value.

\begin{DoxyVerb} if (   extensions->LoadSupportedExtension("GL_VERSION_1_2")
     && extensions->LoadSupportedExtension("GL_ARB_multitexture") ) {
   {
   vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);
   }
 else
   {
   vtkErrorMacro("Required extensions could not be loaded!");
   }\end{DoxyVerb}


Once you have queried and loaded all of the extensions you need, you can delete the vtk\-Open\-G\-L\-Extension\-Manager. To use a constant of an extension, simply replace the \char`\"{}\-G\-L\-\_\-\char`\"{} prefix with \char`\"{}vtkgl\-::\char`\"{}. Likewise, replace the \char`\"{}gl\char`\"{} prefix of functions with \char`\"{}vtkgl\-::\char`\"{}. In rare cases, an extension will add a type. In this case, add vtkgl\-:\-: to the type (i.\-e. vtkgl\-::\-G\-Lchar).

\begin{DoxyVerb} extensions->Delete();
 ...
 vtkgl::ActiveTexture(vtkgl::TEXTURE0_ARB);\end{DoxyVerb}


For wgl extensions, replace the \char`\"{}\-W\-G\-L\-\_\-\char`\"{} and \char`\"{}wgl\char`\"{} prefixes with \char`\"{}vtkwgl\-::\char`\"{}. For gl\-X extensions, replace the \char`\"{}\-G\-L\-X\-\_\-\char`\"{} and \char`\"{}gl\-X\char`\"{} prefixes with \char`\"{}vtkgl\-X\-::\char`\"{}.

To create an instance of class vtk\-Open\-G\-L\-Extension\-Manager, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLExtensionManager
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Extension\-Manager has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Extension\-Manager class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Extension\-Manager = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Extension\-Manager = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Set/\-Get the render window to query extensions on. If set to null, justs queries the current render window.  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window renwin)} -\/ Set/\-Get the render window to query extensions on. If set to null, justs queries the current render window.  
\item {\ttfamily obj.\-Update ()} -\/ Updates the extensions string.  
\item {\ttfamily string = obj.\-Get\-Extensions\-String ()} -\/ Returns a string listing all available extensions. Call Update first to validate this string.  
\item {\ttfamily int = obj.\-Extension\-Supported (string name)} -\/ Returns true if the extension is supported, false otherwise.  
\item {\ttfamily obj.\-Load\-Extension (string name)} -\/ Loads all the functions associated with the given extension into the appropriate static members of vtkgl. This method emits a warning if the requested extension is not supported. It emits an error if the extension does not load successfully.  
\item {\ttfamily int = obj.\-Load\-Supported\-Extension (string name)} -\/ Returns true if the extension is supported and loaded successfully, false otherwise. This method will \char`\"{}fail silently/gracefully\char`\"{} if the extension is not supported or does not load properly. It emits neither warnings nor errors. It is up to the caller to determine if the extension loaded properly by paying attention to the return value.  
\item {\ttfamily obj.\-Load\-Core\-Promoted\-Extension (string name)} -\/ Loads all the functions associated with the given core-\/promoted extension into the appropriate static members of vtkgl associated with the Open\-G\-L version that promoted the extension as a core feature. This method emits a warning if the requested extension is not supported. It emits an error if the extension does not load successfully.

For instance, extension G\-L\-\_\-\-A\-R\-B\-\_\-multitexture was promoted as a core feature into Open\-G\-L 1.\-3. An implementation that uses this feature has to (I\-N T\-H\-I\-S O\-R\-D\-E\-R), check if Open\-G\-L 1.\-3 is supported with Extension\-Supported(\char`\"{}\-G\-L\-\_\-\-V\-E\-R\-S\-I\-O\-N\-\_\-1\-\_\-3\char`\"{}), if true, load the extension with Load\-Extension(\char`\"{}\-G\-L\-\_\-\-V\-E\-R\-S\-I\-O\-N\-\_\-1\-\_\-3\char`\"{}). If false, test for the extension with Extension\-Supported(\char`\"{}\-G\-L\-\_\-\-A\-R\-B\-\_\-multitexture\char`\"{}),if true load the extension with this method Load\-Core\-Promoted\-Extension(\char`\"{}\-G\-L\-\_\-\-A\-R\-B\-\_\-multitexture\char`\"{}). If any of those loading stage succeeded, use vtgl\-::\-Active\-Texture() in any case, N\-O\-T vtgl\-::\-Active\-Texture\-A\-R\-B(). This method avoids the use of if statements everywhere in implementations using core-\/promoted extensions. Without this method, the implementation code should look like\-: \begin{DoxyVerb} int opengl_1_3=extensions->ExtensionSupported("GL_VERSION_1_3");
 if(opengl_1_3)
 {
   extensions->LoadExtension("GL_VERSION_1_3");
 }
 else
 {
  if(extensions->ExtensionSupported("GL_ARB_multitexture"))
  {
   extensions->LoadCorePromotedExtension("GL_ARB_multitexture");
  }
  else
  {
   vtkErrorMacro("Required multitexture feature is not supported!");
  }
 }
 ...
 if(opengl_1_3)
 {
  vtkgl::ActiveTexture(vtkgl::TEXTURE0)
 }
 else
 {
  vtkgl::ActiveTextureARB(vtkgl::TEXTURE0_ARB)
 }\end{DoxyVerb}
 Thanks to this method, the code looks like\-: \begin{DoxyVerb} int opengl_1_3=extensions->ExtensionSupported("GL_VERSION_1_3");
 if(opengl_1_3)
 {
   extensions->LoadExtension("GL_VERSION_1_3");
 }
 else
 {
  if(extensions->ExtensionSupported("GL_ARB_multitexture"))
  {
   extensions->LoadCorePromotedExtension("GL_ARB_multitexture");
  }
  else
  {
   vtkErrorMacro("Required multitexture feature is not supported!");
  }
 }
 ...
 vtkgl::ActiveTexture(vtkgl::TEXTURE0);\end{DoxyVerb}
  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglfreetypetextmapper}{}\section{vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper}\label{vtkrendering_vtkopenglfreetypetextmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper provides 2\-D text annotation support for V\-T\-K using the Free\-Type and F\-T\-G\-L libraries. Normally the user should use vtktext\-Mapper which in turn will use this class.

To create an instance of class vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLFreeTypeTextMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Free\-Type\-Text\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Actally draw the text.  
\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\-Size (vtk\-Viewport viewport, int size\mbox{[}2\mbox{]})} -\/ What is the size of the rectangle required to draw this mapper ?  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglhardwaresupport}{}\section{vtk\-Open\-G\-L\-Hardware\-Support}\label{vtkrendering_vtkopenglhardwaresupport}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Hardware\-Support is an implementation of methods used to query Open\-G\-L and the hardware of what kind of graphics support is available. When V\-T\-K supports more than one Graphics A\-P\-I an abstract super class vtk\-Hardware\-Support should be implemented for this class to derive from.

To create an instance of class vtk\-Open\-G\-L\-Hardware\-Support, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLHardwareSupport
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Hardware\-Support has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Hardware\-Support class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Hardware\-Support = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Hardware\-Support = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fixed\-Texture\-Units ()} -\/ Return the number of fixed-\/function texture units.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Texture\-Units ()} -\/ Return the total number of texture image units accessible by a shader program.  
\item {\ttfamily bool = obj.\-Get\-Supports\-Multi\-Texturing ()} -\/ Test if Multi\-Texturing is supported.  
\item {\ttfamily vtk\-Open\-G\-L\-Extension\-Manager = obj.\-Get\-Extension\-Manager ()} -\/ Set/\-Get a reference to a vtk\-Render\-Window which is Required for most methods of this class to work.  
\item {\ttfamily obj.\-Set\-Extension\-Manager (vtk\-Open\-G\-L\-Extension\-Manager extension\-Manager)} -\/ Set/\-Get a reference to a vtk\-Render\-Window which is Required for most methods of this class to work.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglimageactor}{}\section{vtk\-Open\-G\-L\-Image\-Actor}\label{vtkrendering_vtkopenglimageactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Image\-Actor is a concrete implementation of the abstract class vtk\-Image\-Actor. vtk\-Open\-G\-L\-Image\-Actor interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Image\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLImageActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Image\-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\-Open\-G\-L\-Image\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Image\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Image\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Load (vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this texture. The parameter window could be used to determine which graphic resources to release. Using the same texture object in multiple render windows is N\-O\-T currently supported.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglimagemapper}{}\section{vtk\-Open\-G\-L\-Image\-Mapper}\label{vtkrendering_vtkopenglimagemapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Image\-Mapper is a concrete subclass of vtk\-Image\-Mapper that renders images under Open\-G\-L

To create an instance of class vtk\-Open\-G\-L\-Image\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLImageMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Image\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Image\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Image\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Image\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Called by the Render function in vtk\-Image\-Mapper. Actually draws the image to the screen.  
\item {\ttfamily obj.\-Render\-Data (vtk\-Viewport viewport, vtk\-Image\-Data data, vtk\-Actor2\-D actor)} -\/ Called by the Render function in vtk\-Image\-Mapper. Actually draws the image to the screen.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopengllight}{}\section{vtk\-Open\-G\-L\-Light}\label{vtkrendering_vtkopengllight}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Light is a concrete implementation of the abstract class vtk\-Light. vtk\-Open\-G\-L\-Light interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Light, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLLight
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-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\-Open\-G\-L\-Light class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Light = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Light = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, int light\-\_\-index)} -\/ Implement base class method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopengllightingpainter}{}\section{vtk\-Open\-G\-L\-Lighting\-Painter}\label{vtkrendering_vtkopengllightingpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter manages lighting. Ligting is disabled when rendering points/lines and no normals are present or rendering Polygons/\-T\-Strips and representation is points and no normals are present.

To create an instance of class vtk\-Open\-G\-L\-Lighting\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLLightingPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Lighting\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Lighting\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Lighting\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Lighting\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Time\-To\-Draw ()} -\/ This painter overrides Get\-Time\-To\-Draw() to never pass the request to the delegate. This is done since this class may propagate a single render request multiple times to the delegate. In that case the time accumulation responsibility is borne by the painter causing the multiple rendering requests i.\-e. this painter itself.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglpainterdeviceadapter}{}\section{vtk\-Open\-G\-L\-Painter\-Device\-Adapter}\label{vtkrendering_vtkopenglpainterdeviceadapter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
An adapter between vtk\-Painter and the Open\-G\-L rendering system. Only a handful of attributes with special meaning are supported. The Open\-G\-L attribute used for each attribute is given below.

\begin{DoxyVerb} vtkDataSetAttributes::NORMALS          glNormal
 vtkDataSetAttributes:::SCALARS         glColor
 vtkDataSetAttributes::TCOORDS          glTexCoord
 vtkDataSetAttributes::NUM_ATTRIBUTES   glVertex\end{DoxyVerb}


To create an instance of class vtk\-Open\-G\-L\-Painter\-Device\-Adapter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLPainterDeviceAdapter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Painter\-Device\-Adapter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Painter\-Device\-Adapter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Painter\-Device\-Adapter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Painter\-Device\-Adapter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Begin\-Primitive (int mode)} -\/ Converts mode from V\-T\-K\-\_\-$\ast$ to G\-L\-\_\-$\ast$ and calls gl\-Begin.  
\item {\ttfamily obj.\-End\-Primitive ()} -\/ Calls gl\-End.  
\item {\ttfamily int = obj.\-Is\-Attributes\-Supported (int attribute)} -\/ Returns if the given attribute type is supported by the device. Returns 1 is supported, 0 otherwise.  
\item {\ttfamily obj.\-Enable\-Attribute\-Array (int index)} -\/ Calls gl\-Enable\-Client\-State or gl\-Disable\-Client\-State.  
\item {\ttfamily obj.\-Disable\-Attribute\-Array (int index)} -\/ Calls gl\-Enable\-Client\-State or gl\-Disable\-Client\-State.  
\item {\ttfamily obj.\-Draw\-Arrays (int mode, vtk\-Id\-Type first, vtk\-Id\-Type count)} -\/ Calls gl\-Draw\-Arrays. Mode is converted from V\-T\-K\-\_\-$\ast$ to G\-L\-\_\-$\ast$.  
\item {\ttfamily int = obj.\-Compatible (vtk\-Renderer renderer)} -\/ Returns true if renderer is a vtk\-Open\-G\-L\-Renderer.  
\item {\ttfamily obj.\-Make\-Lighting (int mode)} -\/ Turns lighting on and off.  
\item {\ttfamily int = obj.\-Query\-Lighting ()} -\/ Returns current lighting setting.  
\item {\ttfamily obj.\-Make\-Multisampling (int mode)} -\/ Turns antialiasing on and off.  
\item {\ttfamily int = obj.\-Query\-Multisampling ()} -\/ Returns current antialiasing setting.  
\item {\ttfamily obj.\-Make\-Blending (int mode)} -\/ Turns blending on and off.  
\item {\ttfamily int = obj.\-Query\-Blending ()} -\/ Returns current blending setting.  
\item {\ttfamily obj.\-Make\-Vertex\-Emphasis (bool mode)} -\/ Turns emphasis of vertices on or off for vertex selection. When emphasized verts are drawn nearer to the camera and are drawn larger than normal to make selection of them more reliable.  
\item {\ttfamily obj.\-Make\-Vertex\-Emphasis\-With\-Stencil\-Check (int mode)} -\/  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglpolydatamapper}{}\section{vtk\-Open\-G\-L\-Poly\-Data\-Mapper}\label{vtkrendering_vtkopenglpolydatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Poly\-Data\-Mapper is a subclass of vtk\-Poly\-Data\-Mapper. vtk\-Open\-G\-L\-Poly\-Data\-Mapper is a geometric Poly\-Data\-Mapper for the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Poly\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLPolyDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Poly\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Poly\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Poly\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Poly\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Piece (vtk\-Renderer ren, vtk\-Actor a)} -\/ Implement superclass render method.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily int = obj.\-Draw (vtk\-Renderer ren, vtk\-Actor a)} -\/ Draw method for Open\-G\-L.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglpolydatamapper2d}{}\section{vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D}\label{vtkrendering_vtkopenglpolydatamapper2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D provides 2\-D Poly\-Data annotation support for vtk under Open\-G\-L. Normally the user should use vtk\-Poly\-Data\-Mapper2\-D which in turn will use this class.

To create an instance of class vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLPolyDataMapper2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Poly\-Data\-Mapper2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Actually draw the poly data.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglproperty}{}\section{vtk\-Open\-G\-L\-Property}\label{vtkrendering_vtkopenglproperty}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Property is a concrete implementation of the abstract class vtk\-Property. vtk\-Open\-G\-L\-Property interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Property, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLProperty
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-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\-Open\-G\-L\-Property class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Property = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Property = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Actor a, vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Backface\-Render (vtk\-Actor a, vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, int x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, float x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, double x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglrenderer}{}\section{vtk\-Open\-G\-L\-Renderer}\label{vtkrendering_vtkopenglrenderer}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Renderer is a concrete implementation of the abstract class vtk\-Renderer. vtk\-Open\-G\-L\-Renderer interfaces to the Open\-G\-L graphics library.

To create an instance of class vtk\-Open\-G\-L\-Renderer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLRenderer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Renderer has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Renderer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Renderer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Renderer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Device\-Render (void )} -\/ Concrete open gl render method.  
\item {\ttfamily obj.\-Device\-Render\-Translucent\-Polygonal\-Geometry ()} -\/ Render translucent polygonal geometry. Default implementation just call Update\-Translucent\-Polygonal\-Geometry(). Subclasses of vtk\-Renderer that can deal with depth peeling must override this method.  
\item {\ttfamily obj.\-Clear\-Lights (void )} -\/ Internal method temporarily removes lights before reloading them into graphics pipeline.  
\item {\ttfamily obj.\-Clear (void )}  
\item {\ttfamily int = obj.\-Update\-Lights (void )} -\/ Ask lights to load themselves into graphics pipeline.  
\item {\ttfamily int = obj.\-Get\-Depth\-Peeling\-Higher\-Layer ()} -\/ Is rendering at translucent geometry stage using depth peeling and rendering a layer other than the first one? (Boolean value) If so, the uniform variables Use\-Texture and Texture can be set. (Used by vtk\-Open\-G\-L\-Property or vtk\-Open\-G\-L\-Texture)  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglrenderwindow}{}\section{vtk\-Open\-G\-L\-Render\-Window}\label{vtkrendering_vtkopenglrenderwindow}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Render\-Window is a concrete implementation of the abstract class vtk\-Render\-Window. vtk\-Open\-G\-L\-Renderer interfaces to the Open\-G\-L graphics library. Application programmers should normally use vtk\-Render\-Window instead of the Open\-G\-L specific version.

To create an instance of class vtk\-Open\-G\-L\-Render\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLRenderWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Render\-Window has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Render\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Render\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Render\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Stereo\-Update ()} -\/ Update system if needed due to stereo rendering.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Unsigned\-Char\-Array data)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B...  
\item {\ttfamily int = obj.\-Set\-Pixel\-Data (int x, int y, int x2, int y2, string data, int front)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B...  
\item {\ttfamily int = obj.\-Set\-Pixel\-Data (int x, int y, int x2, int y2, vtk\-Unsigned\-Char\-Array data, int front)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B...  
\item {\ttfamily int = obj.\-Get\-R\-G\-B\-A\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Float\-Array data)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Pixel\-Data (int x, int y, int x2, int y2, float data, int front, int blend)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Pixel\-Data (int x, int y, int x2, int y2, vtk\-Float\-Array data, int front, int blend)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily obj.\-Release\-R\-G\-B\-A\-Pixel\-Data (float data)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Get\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Unsigned\-Char\-Array data)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, string data, int front, int blend)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, vtk\-Unsigned\-Char\-Array data, int front, int blend)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-A\-R\-G\-B\-A...  
\item {\ttfamily int = obj.\-Get\-Zbuffer\-Data (int x1, int y1, int x2, int y2, float z)} -\/ Set/\-Get the zbuffer data from an image  
\item {\ttfamily int = obj.\-Get\-Zbuffer\-Data (int x1, int y1, int x2, int y2, vtk\-Float\-Array z)} -\/ Set/\-Get the zbuffer data from an image  
\item {\ttfamily int = obj.\-Set\-Zbuffer\-Data (int x1, int y1, int x2, int y2, float buffer)} -\/ Set/\-Get the zbuffer data from an image  
\item {\ttfamily int = obj.\-Set\-Zbuffer\-Data (int x1, int y1, int x2, int y2, vtk\-Float\-Array buffer)} -\/ Set/\-Get the zbuffer data from an image  
\item {\ttfamily int = obj.\-Get\-Depth\-Buffer\-Size ()} -\/ Get the size of the depth buffer.  
\item {\ttfamily int = obj.\-Get\-Color\-Buffer\-Sizes (int rgba)} -\/ Get the size of the color buffer. Returns 0 if not able to determine otherwise sets R G B and A into buffer.  
\item {\ttfamily obj.\-Open\-G\-L\-Init ()} -\/ Initialize Open\-G\-L for this window.  
\item {\ttfamily int = obj.\-Get\-Back\-Left\-Buffer ()} -\/ Return the Open\-G\-L name of the back left buffer. It is G\-L\-\_\-\-B\-A\-C\-K\-\_\-\-L\-E\-F\-T if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily int = obj.\-Get\-Back\-Right\-Buffer ()} -\/ Return the Open\-G\-L name of the back right buffer. It is G\-L\-\_\-\-B\-A\-C\-K\-\_\-\-R\-I\-G\-H\-T if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T+1 if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily int = obj.\-Get\-Front\-Left\-Buffer ()} -\/ Return the Open\-G\-L name of the front left buffer. It is G\-L\-\_\-\-F\-R\-O\-N\-T\-\_\-\-L\-E\-F\-T if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily int = obj.\-Get\-Front\-Right\-Buffer ()} -\/ Return the Open\-G\-L name of the front right buffer. It is G\-L\-\_\-\-F\-R\-O\-N\-T\-\_\-\-R\-I\-G\-H\-T if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T+1 if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily int = obj.\-Get\-Back\-Buffer ()} -\/ Return the Open\-G\-L name of the back left buffer. It is G\-L\-\_\-\-B\-A\-C\-K if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily int = obj.\-Get\-Front\-Buffer ()} -\/ Return the Open\-G\-L name of the front left buffer. It is G\-L\-\_\-\-F\-R\-O\-N\-T if G\-L is bound to the window-\/system-\/provided framebuffer. It is vtkgl\-::\-C\-O\-L\-O\-R\-\_\-\-A\-T\-T\-A\-C\-H\-M\-E\-N\-T0\-\_\-\-E\-X\-T if G\-L is bound to an application-\/created framebuffer object (G\-P\-U-\/based offscreen rendering) It is used by vtk\-Open\-G\-L\-Camera.  
\item {\ttfamily obj.\-Check\-Graphic\-Error ()} -\/ Update graphic error status, regardless of Report\-Graphic\-Errors flag. It means this method can be used in any context and is not restricted to debug mode.  
\item {\ttfamily int = obj.\-Has\-Graphic\-Error ()} -\/ Return the last graphic error status. Initial value is false.  
\item {\ttfamily string = obj.\-Get\-Last\-Graphic\-Error\-String ()} -\/ Return a string matching the last graphic error status.  
\item {\ttfamily vtk\-Open\-G\-L\-Extension\-Manager = obj.\-Get\-Extension\-Manager ()} -\/ Returns the extension manager. A new one will be created if one hasn't already been set up.  
\item {\ttfamily vtk\-Open\-G\-L\-Hardware\-Support = obj.\-Get\-Hardware\-Support ()} -\/ Returns an Hardware Support object. A new one will be created if one hasn't already been set up.  
\item {\ttfamily obj.\-Wait\-For\-Completion ()} -\/ Block the thread until the actual rendering is finished(). Useful for measurement only.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglrepresentationpainter}{}\section{vtk\-Open\-G\-L\-Representation\-Painter}\label{vtkrendering_vtkopenglrepresentationpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is Open\-G\-L implementation of a painter handling representation i.\-e. Points, Wireframe, Surface.

To create an instance of class vtk\-Open\-G\-L\-Representation\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLRepresentationPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Representation\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Representation\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Representation\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Representation\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily double = obj.\-Get\-Time\-To\-Draw ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopenglscalarstocolorspainter}{}\section{vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter}\label{vtkrendering_vtkopenglscalarstocolorspainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter is a concrete subclass of vtk\-Scalars\-To\-Colors\-Painter which uses Open\-G\-L for color mapping.

To create an instance of class vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLScalarsToColorsPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Scalars\-To\-Colors\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily int = obj.\-Get\-Premultiply\-Colors\-With\-Alpha (vtk\-Actor actor)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkopengltexture}{}\section{vtk\-Open\-G\-L\-Texture}\label{vtkrendering_vtkopengltexture}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Open\-G\-L\-Texture is a concrete implementation of the abstract class vtk\-Texture. vtk\-Open\-G\-L\-Texture interfaces to the Open\-G\-L rendering library.

To create an instance of class vtk\-Open\-G\-L\-Texture, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOpenGLTexture
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Open\-G\-L\-Texture has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Open\-G\-L\-Texture class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Open\-G\-L\-Texture = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Open\-G\-L\-Texture = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Load (vtk\-Renderer ren)} -\/ Implement base class method.  
\item {\ttfamily obj.\-Post\-Render (vtk\-Renderer ren)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this texture. The parameter window could be used to determine which graphic resources to release. Using the same texture object in multiple render windows is N\-O\-T currently supported.  
\item {\ttfamily long = obj.\-Get\-Index ()} -\/ Get the open\-G\-L texture name to which this texture is bound. This is available only if G\-L version $>$= 1.\-1  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkoverlaypass}{}\section{vtk\-Overlay\-Pass}\label{vtkrendering_vtkoverlaypass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Overlay\-Pass renders the overlay geometry of all the props that have the keys contained in vtk\-Render\-State.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color.

To create an instance of class vtk\-Overlay\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOverlayPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Overlay\-Pass 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\-Overlay\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Overlay\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Overlay\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpainter}{}\section{vtk\-Painter}\label{vtkrendering_vtkpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This defines the interface for a Painter. Painters are helpers used by Mapper to perform the rendering. The mapper sets up a chain of painters and passes the render request to the painter. Every painter may have a delegate painter to which the render request is forwarded. The Painter may modify the request or data before passing it to the delegate painter. All the information to control the rendering must be passed to the painter using the vtk\-Information object. A concrete painter may read special keys from the vtk\-Information object and affect the rendering.

To create an instance of class vtk\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Painter 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\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Information = obj.\-Get\-Information ()} -\/ Get/\-Set the information object associated with this painter.  
\item {\ttfamily obj.\-Set\-Information (vtk\-Information )} -\/ Get/\-Set the information object associated with this painter.  
\item {\ttfamily vtk\-Painter = obj.\-Get\-Delegate\-Painter ()} -\/ Set/\-Get the painter to which this painter should propagare its draw calls.  
\item {\ttfamily obj.\-Set\-Delegate\-Painter (vtk\-Painter )} -\/ Set/\-Get the painter to which this painter should propagare its draw calls.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Take part in garbage collection.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Take part in garbage collection.  
\item {\ttfamily obj.\-Render (vtk\-Renderer renderer, vtk\-Actor actor, long typeflags, bool force\-Compile\-Only)} -\/ Generates rendering primitives of appropriate type(s). Multiple types of primitives can be requested by or-\/ring the primitive flags. Default implementation calls Update\-Delegate\-Painter() to update the deletagate painter and then calls Render\-Internal(). force\-Compile\-Only is passed to the display list painters.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this painter. The parameter window could be used to determine which graphic resources to release. The call is propagated to the delegate painter, if any.  
\item {\ttfamily obj.\-Set\-Progress (double )} -\/ Set/\-Get the execution progress of a process object.  
\item {\ttfamily double = obj.\-Get\-Progress\-Min\-Value ()} -\/ Set/\-Get the execution progress of a process object.  
\item {\ttfamily double = obj.\-Get\-Progress\-Max\-Value ()} -\/ Set/\-Get the execution progress of a process object.  
\item {\ttfamily double = obj.\-Get\-Progress ()} -\/ Set/\-Get the execution progress of a process object.  
\item {\ttfamily double = obj.\-Get\-Time\-To\-Draw ()} -\/ Get the time required to draw the geometry last time it was rendered. Default implementation adds the current Time\-To\-Draw with that of the delegate painter.  
\item {\ttfamily obj.\-Update\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Expand or shrink the estimated bounds of the object based on the geometric transformations performed in the painter. If the painter does not modify the geometry, the bounds are passed through.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the data object to paint. Currently we only support one data object per painter chain.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Set the data object to paint. Currently we only support one data object per painter chain.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpainterdeviceadapter}{}\section{vtk\-Painter\-Device\-Adapter}\label{vtkrendering_vtkpainterdeviceadapter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is an adapter between a vtk\-Painter and a rendering device (such as an Open\-G\-L machine). Having an abstract adapter allows vtk\-Painters to be re-\/used for any rendering system.

Although V\-T\-K really only uses Open\-G\-L right now, there are reasons to swap out the rendering functions. Sometimes M\-E\-S\-A with mangled names is used. Also, different shader extensions use different functions. Furthermore, Cg also has its own interface.

The interface for this class should be familier to anyone experienced with Open\-G\-L.

To create an instance of class vtk\-Painter\-Device\-Adapter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPainterDeviceAdapter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Painter\-Device\-Adapter 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\-Painter\-Device\-Adapter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Painter\-Device\-Adapter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Painter\-Device\-Adapter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Begin\-Primitive (int mode)} -\/ Signals the start of sending a primitive to the graphics card. The mode is one of V\-T\-K\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-P\-O\-L\-Y\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-P\-O\-L\-Y\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E\-\_\-\-S\-T\-R\-I\-P, V\-T\-K\-\_\-\-P\-O\-L\-Y\-G\-O\-N, or V\-T\-K\-\_\-\-Q\-U\-A\-D. The primitive is defined by the attributes sent between the calls to Begin\-Primitive and End\-Primitive. You do not need to call End\-Primitive/\-Begin\-Primitive between primitives that have a constant number of points (i.\-e. V\-T\-K\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-D).  
\item {\ttfamily obj.\-End\-Primitive ()} -\/ Signals the end of sending a primitive to the graphics card.  
\item {\ttfamily int = obj.\-Is\-Attributes\-Supported (int attribute)} -\/ Returns if the given attribute type is supported by the device. Returns 1 is supported, 0 otherwise.  
\item {\ttfamily obj.\-Set\-Attribute\-Pointer (int index, vtk\-Data\-Array attribute\-Array)} -\/ Sets an array of attributes. This allows you to send all the data for a particular attribute with one call, thus greatly reducing function call overhead. Once set, the array is enabled with Enable\-Attribute\-Array, and the data is sent with a call to Draw\-Arrays Draw\-Elements.  
\item {\ttfamily obj.\-Enable\-Attribute\-Array (int index)} -\/ Enable/disable the attribute array set with Set\-Attribute\-Pointer.  
\item {\ttfamily obj.\-Disable\-Attribute\-Array (int index)} -\/ Enable/disable the attribute array set with Set\-Attribute\-Pointer.  
\item {\ttfamily obj.\-Draw\-Arrays (int mode, vtk\-Id\-Type first, vtk\-Id\-Type count)} -\/ Send a section of the enabled attribute pointers to the graphics card to define a primitive. The mode is one of V\-T\-K\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-P\-O\-L\-Y\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-P\-O\-L\-Y\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E\-\_\-\-S\-T\-R\-I\-P, V\-T\-K\-\_\-\-P\-O\-L\-Y\-G\-O\-N, or V\-T\-K\-\_\-\-Q\-U\-A\-D. It identifies which type of primitive the attribute data is defining. The parameters first and count identify what part of the attribute arrays define the given primitive. If mode is a primitive that has a constant number of points (i.\-e. V\-T\-K\-\_\-\-V\-E\-R\-T\-E\-X, V\-T\-K\-\_\-\-L\-I\-N\-E, V\-T\-K\-\_\-\-T\-R\-I\-A\-N\-G\-L\-E, and V\-T\-K\-\_\-\-Q\-U\-A\-D), you may draw multiple primitives with one call to Draw\-Arrays.  
\item {\ttfamily int = obj.\-Compatible (vtk\-Renderer renderer)} -\/ Returns true if this device adapter is compatable with the given vtk\-Renderer.  
\item {\ttfamily obj.\-Make\-Lighting (int mode)} -\/ Turns lighting on and off.  
\item {\ttfamily int = obj.\-Query\-Lighting ()} -\/ Returns current lighting setting.  
\item {\ttfamily obj.\-Make\-Multisampling (int mode)} -\/ Turns antialiasing on and off.  
\item {\ttfamily int = obj.\-Query\-Multisampling ()} -\/ Returns current antialiasing setting.  
\item {\ttfamily obj.\-Make\-Blending (int mode)} -\/ Turns blending on and off.  
\item {\ttfamily int = obj.\-Query\-Blending ()} -\/ Returns current blending setting.  
\item {\ttfamily obj.\-Make\-Vertex\-Emphasis (bool mode)} -\/ Turns emphasis of vertices on or off for vertex selection.  
\item {\ttfamily obj.\-Make\-Vertex\-Emphasis\-With\-Stencil\-Check (int )} -\/  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpainterpolydatamapper}{}\section{vtk\-Painter\-Poly\-Data\-Mapper}\label{vtkrendering_vtkpainterpolydatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Poly\-Data\-Mapper that uses painters to do the actual rendering. .S\-E\-C\-T\-I\-O\-N Thanks Support for generic vertex attributes in V\-T\-K was contributed in collaboration with Stephane Ploix at E\-D\-F.

To create an instance of class vtk\-Painter\-Poly\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPainterPolyDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Painter\-Poly\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Painter\-Poly\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Painter\-Poly\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Painter\-Poly\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Piece (vtk\-Renderer ren, vtk\-Actor act)} -\/ Implemented by sub classes. Actual rendering is done here.  
\item {\ttfamily vtk\-Painter = obj.\-Get\-Painter ()} -\/ Get/\-Set the painter used to do the actual rendering. By default, vtk\-Default\-Painter is used to build the rendering painter chain for color mapping/clipping etc. followed by a vtk\-Chooser\-Painter which renders the primitives.  
\item {\ttfamily obj.\-Set\-Painter (vtk\-Painter )} -\/ Get/\-Set the painter used to do the actual rendering. By default, vtk\-Default\-Painter is used to build the rendering painter chain for color mapping/clipping etc. followed by a vtk\-Chooser\-Painter which renders the primitives.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. Merely propagates the call to the painter.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Re-\/implement the superclass Get\-Bounds method.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Re-\/implement the superclass Get\-Bounds method.  
\item {\ttfamily obj.\-Map\-Data\-Array\-To\-Vertex\-Attribute (string vertex\-Attribute\-Name, string data\-Array\-Name, int field\-Association, int componentno)} -\/ Select a data array from the point/cell data and map it to a generic vertex attribute. vertex\-Attribute\-Name is the name of the vertex attribute. data\-Array\-Name is the name of the data array. field\-Association indicates when the data array is a point data array or cell data array (vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S or (vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S). componentno indicates which component from the data array must be passed as the attribute. If -\/1, then all components are passed.  
\item {\ttfamily obj.\-Map\-Data\-Array\-To\-Multi\-Texture\-Attribute (int unit, string data\-Array\-Name, int field\-Association, int componentno)}  
\item {\ttfamily obj.\-Remove\-Vertex\-Attribute\-Mapping (string vertex\-Attribute\-Name)} -\/ Remove a vertex attribute mapping.  
\item {\ttfamily obj.\-Remove\-All\-Vertex\-Attribute\-Mappings ()} -\/ Remove all vertex attributes.  
\item {\ttfamily vtk\-Painter = obj.\-Get\-Selection\-Painter ()} -\/ Get/\-Set the painter used when rendering the selection pass.  
\item {\ttfamily obj.\-Set\-Selection\-Painter (vtk\-Painter )} -\/ Get/\-Set the painter used when rendering the selection pass.  
\item {\ttfamily bool = obj.\-Get\-Supports\-Selection ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkparallelcoordinatesactor}{}\section{vtk\-Parallel\-Coordinates\-Actor}\label{vtkrendering_vtkparallelcoordinatesactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parallel\-Coordinates\-Actor generates a parallel coordinates plot from an input field (i.\-e., vtk\-Data\-Object). Parallel coordinates represent N-\/dimensional data by using a set of N parallel axes (not orthogonal like the usual x-\/y-\/z Cartesian axes). Each N-\/dimensional point is plotted as a polyline, were each of the N components of the point lie on one of the N axes, and the components are connected by straight lines.

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, attributes, number of ticks on the axes, etc.

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated to this actor.

To create an instance of class vtk\-Parallel\-Coordinates\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParallelCoordinatesActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parallel\-Coordinates\-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\-Parallel\-Coordinates\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parallel\-Coordinates\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parallel\-Coordinates\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\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 (string )} -\/ Set/\-Get the title of the parallel coordinates plot.  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the parallel coordinates plot.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show along each axis. 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 each axis. 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 each axis. 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 each axis. This values is a suggestion\-: the number of labels may vary depending on the particulars of the data.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on the axes.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on the axes.  
\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\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Draw the parallel coordinates plot.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Draw the parallel coordinates 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.\-Set\-Input (vtk\-Data\-Object )} -\/ Set the input to the parallel coordinates actor.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Input ()} -\/ Remove a dataset from the list of data to append.  
\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{vtkrendering_vtkparallelcoordinatesinteractorstyle}{}\section{vtk\-Parallel\-Coordinates\-Interactor\-Style}\label{vtkrendering_vtkparallelcoordinatesinteractorstyle}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Parallel\-Coordinates\-Interactor\-Style allows the user to interactively manipulate (rotate, pan, zoomm etc.) the camera. Several events are overloaded from its superclass vtk\-Parallel\-Coordinates\-Interactor\-Style, hence the mouse bindings are different. (The bindings keep the camera's view plane normal perpendicular to the x-\/y plane.) In summary the mouse events are as follows\-:
\begin{DoxyItemize}
\item Left Mouse button triggers window level events
\item C\-T\-R\-L Left Mouse spins the camera around its view plane normal
\item S\-H\-I\-F\-T Left Mouse pans the camera
\item C\-T\-R\-L S\-H\-I\-F\-T Left Mouse dollys (a positional zoom) the camera
\item Middle mouse button pans the camera
\item Right mouse button dollys the camera.
\item S\-H\-I\-F\-T Right Mouse triggers pick events
\end{DoxyItemize}

Note that the renderer's actors are not moved; instead the camera is moved.

To create an instance of class vtk\-Parallel\-Coordinates\-Interactor\-Style, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParallelCoordinatesInteractorStyle
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parallel\-Coordinates\-Interactor\-Style 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\-Parallel\-Coordinates\-Interactor\-Style class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parallel\-Coordinates\-Interactor\-Style = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parallel\-Coordinates\-Interactor\-Style = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj. Get\-Cursor\-Start\-Position ()} -\/ Get the cursor positions in pixel coords  
\item {\ttfamily int = obj. Get\-Cursor\-Current\-Position ()} -\/ Get the cursor positions in pixel coords  
\item {\ttfamily int = obj. Get\-Cursor\-Last\-Position ()} -\/ Get the cursor positions in pixel coords  
\item {\ttfamily obj.\-Get\-Cursor\-Start\-Position (vtk\-Viewport viewport, double pos\mbox{[}2\mbox{]})} -\/ Get the cursor positions in a given coordinate system  
\item {\ttfamily obj.\-Get\-Cursor\-Current\-Position (vtk\-Viewport viewport, double pos\mbox{[}2\mbox{]})} -\/ Get the cursor positions in a given coordinate system  
\item {\ttfamily obj.\-Get\-Cursor\-Last\-Position (vtk\-Viewport viewport, double pos\mbox{[}2\mbox{]})} -\/ Get the cursor positions in a given coordinate system  
\item {\ttfamily obj.\-On\-Mouse\-Move ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Left\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Middle\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Down ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Right\-Button\-Up ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-On\-Leave ()} -\/ Event bindings controlling the effects of pressing mouse buttons or moving the mouse.  
\item {\ttfamily obj.\-Start\-Inspect (int x, int y)}  
\item {\ttfamily obj.\-Inspect (int x, int y)}  
\item {\ttfamily obj.\-End\-Inspect ()}  
\item {\ttfamily obj.\-Start\-Zoom ()}  
\item {\ttfamily obj.\-Zoom ()}  
\item {\ttfamily obj.\-End\-Zoom ()}  
\item {\ttfamily obj.\-Start\-Pan ()}  
\item {\ttfamily obj.\-Pan ()}  
\item {\ttfamily obj.\-End\-Pan ()}  
\item {\ttfamily obj.\-On\-Char ()} -\/ Override the \char`\"{}fly-\/to\char`\"{} (f keypress) for images.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpicker}{}\section{vtk\-Picker}\label{vtkrendering_vtkpicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Picker is used to select instances of vtk\-Prop3\-D by shooting a ray into a graphics window and intersecting with the actor's bounding box. The ray is defined from a point defined in window (or pixel) coordinates, and a point located from the camera's position.

vtk\-Picker may return more than one vtk\-Prop3\-D, since more than one bounding box may be intersected. vtk\-Picker returns an unsorted list of props that were hit, and a list of the corresponding world points of the hits. For the vtk\-Prop3\-D that is closest to the camera, vtk\-Picker returns the pick coordinates in world and untransformed mapper space, the prop itself, the data set, and the mapper. For vtk\-Picker the closest prop is the one whose center point (i.\-e., center of bounding box) projected on the view ray is closest to the camera. Subclasses of vtk\-Picker use other methods for computing the pick point.

To create an instance of class vtk\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Specify tolerance for performing pick operation. Tolerance is specified as fraction of rendering window size. (Rendering window size is measured across diagonal.)  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Specify tolerance for performing pick operation. Tolerance is specified as fraction of rendering window size. (Rendering window size is measured across diagonal.)  
\item {\ttfamily double = obj. Get\-Mapper\-Position ()} -\/ Return position in mapper (i.\-e., non-\/transformed) coordinates of pick point.  
\item {\ttfamily vtk\-Abstract\-Mapper3\-D = obj.\-Get\-Mapper ()} -\/ Return mapper that was picked (if any).  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Data\-Set ()} -\/ Get a pointer to the dataset that was picked (if any). If nothing was picked then N\-U\-L\-L is returned.  
\item {\ttfamily vtk\-Prop3\-D\-Collection = obj.\-Get\-Prop3\-Ds ()} -\/ Return a collection of all the prop 3\-D's that were intersected by the pick ray. This collection is not sorted.  
\item {\ttfamily vtk\-Actor\-Collection = obj.\-Get\-Actors ()} -\/ Return a collection of all the actors that were intersected. This collection is not sorted. (This is a convenience method to maintain backward compatibility.)  
\item {\ttfamily vtk\-Points = obj.\-Get\-Picked\-Positions ()} -\/ Return a list of the points the the actors returned by Get\-Prop3\-Ds were intersected at. The order of this list will match the order of Get\-Prop3\-Ds.  
\item {\ttfamily int = obj.\-Pick (double selection\-X, double selection\-Y, double selection\-Z, vtk\-Renderer renderer)} -\/ Perform pick operation with selection point provided. Normally the first two values for the selection point are x-\/y pixel coordinate, and the third value is =0. Return non-\/zero if something was successfully picked.  
\item {\ttfamily int = obj.\-Pick (double selection\-Pt\mbox{[}3\mbox{]}, vtk\-Renderer ren)} -\/ Perform pick operation with selection point provided. Normally the first two values for the selection point are x-\/y pixel coordinate, and the third value is =0. Return non-\/zero if something was successfully picked.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpixelbufferobject}{}\section{vtk\-Pixel\-Buffer\-Object}\label{vtkrendering_vtkpixelbufferobject}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Provides low-\/level access to G\-P\-U memory. Used to pass raw data to G\-P\-U. The data is uploaded into a pixel buffer.

To create an instance of class vtk\-Pixel\-Buffer\-Object, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPixelBufferObject
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Pixel\-Buffer\-Object 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\-Pixel\-Buffer\-Object class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Pixel\-Buffer\-Object = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Pixel\-Buffer\-Object = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily 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.  
\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.  
\item {\ttfamily int = obj.\-Get\-Usage ()} -\/ Usage is a performance hint. Valid values are\-:
\begin{DoxyItemize}
\item Stream\-Draw specified once by A, used few times S
\item Stream\-Read specified once by R, queried a few times by A
\item Stream\-Copy specified once by R, used a few times S
\item Static\-Draw specified once by A, used many times S
\item Static\-Read specificed once by R, queried many times by A
\item Static\-Copy specified once by R, used many times S
\item Dynamic\-Draw respecified repeatedly by A, used many times S
\item Dynamic\-Read respecified repeatedly by R, queried many times by A
\item Dynamic\-Copy respecified repeatedly by R, used many times S A\-: the application S\-: as the source for G\-L drawing and image specification commands. R\-: reading data from the G\-L Initial value is Static\-Draw, as in Open\-G\-L spec.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Usage (int )} -\/ Usage is a performance hint. Valid values are\-:
\begin{DoxyItemize}
\item Stream\-Draw specified once by A, used few times S
\item Stream\-Read specified once by R, queried a few times by A
\item Stream\-Copy specified once by R, used a few times S
\item Static\-Draw specified once by A, used many times S
\item Static\-Read specificed once by R, queried many times by A
\item Static\-Copy specified once by R, used many times S
\item Dynamic\-Draw respecified repeatedly by A, used many times S
\item Dynamic\-Read respecified repeatedly by R, queried many times by A
\item Dynamic\-Copy respecified repeatedly by R, used many times S A\-: the application S\-: as the source for G\-L drawing and image specification commands. R\-: reading data from the G\-L Initial value is Static\-Draw, as in Open\-G\-L spec.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Type ()} -\/ Get the type with which the data is loaded into the G\-P\-U. eg. V\-T\-K\-\_\-\-F\-L\-O\-A\-T for float32, V\-T\-K\-\_\-\-C\-H\-A\-R for byte, V\-T\-K\-\_\-\-U\-N\-S\-I\-G\-N\-E\-D\-\_\-\-C\-H\-A\-R for unsigned byte etc.  
\item {\ttfamily int = obj.\-Get\-Size ()} -\/ Get the size of the data loaded into the G\-P\-U. Size is in the number of elements of the uploaded Type.  
\item {\ttfamily int = obj.\-Get\-Handle ()} -\/ Get the open\-G\-L buffer handle.  
\item {\ttfamily obj.\-Bind\-To\-Packed\-Buffer ()}  
\item {\ttfamily obj.\-Bind\-To\-Un\-Packed\-Buffer ()} -\/ Inactivate the buffer.  
\item {\ttfamily obj.\-Un\-Bind ()} -\/ Inactivate the buffer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpointpicker}{}\section{vtk\-Point\-Picker}\label{vtkrendering_vtkpointpicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Point\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Point\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Point\-Id ()} -\/ Get the id of the picked point. If Point\-Id = -\/1, nothing was picked.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpointsettolabelhierarchy}{}\section{vtk\-Point\-Set\-To\-Label\-Hierarchy}\label{vtkrendering_vtkpointsettolabelhierarchy}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Every point in the input vtk\-Points object is taken to be an anchor point for a label. Statistics on the input points are used to subdivide an octree referencing the points until the points each octree node contains have a variance close to the node size and a limited population ($<$ 100).

To create an instance of class vtk\-Point\-Set\-To\-Label\-Hierarchy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointSetToLabelHierarchy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Set\-To\-Label\-Hierarchy 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\-Point\-Set\-To\-Label\-Hierarchy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Set\-To\-Label\-Hierarchy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Set\-To\-Label\-Hierarchy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Target\-Label\-Count (int )} -\/ Set/get the \char`\"{}ideal\char`\"{} number of labels to associate with each node in the output hierarchy.  
\item {\ttfamily int = obj.\-Get\-Target\-Label\-Count ()} -\/ Set/get the \char`\"{}ideal\char`\"{} number of labels to associate with each node in the output hierarchy.  
\item {\ttfamily obj.\-Set\-Maximum\-Depth (int )} -\/ Set/get the maximum tree depth in the output hierarchy.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Depth ()} -\/ Set/get the maximum tree depth in the output hierarchy.  
\item {\ttfamily obj.\-Set\-Use\-Unicode\-Strings (bool )} -\/ Whether to use unicode strings.  
\item {\ttfamily bool = obj.\-Get\-Use\-Unicode\-Strings ()} -\/ Whether to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-On ()} -\/ Whether to use unicode strings.  
\item {\ttfamily obj.\-Use\-Unicode\-Strings\-Off ()} -\/ Whether to use unicode strings.  
\item {\ttfamily obj.\-Set\-Label\-Array\-Name (string name)} -\/ Set/get the label array name.  
\item {\ttfamily string = obj.\-Get\-Label\-Array\-Name ()} -\/ Set/get the label array name.  
\item {\ttfamily obj.\-Set\-Size\-Array\-Name (string name)} -\/ Set/get the priority array name.  
\item {\ttfamily string = obj.\-Get\-Size\-Array\-Name ()} -\/ Set/get the priority array name.  
\item {\ttfamily obj.\-Set\-Priority\-Array\-Name (string name)} -\/ Set/get the priority array name.  
\item {\ttfamily string = obj.\-Get\-Priority\-Array\-Name ()} -\/ Set/get the priority array name.  
\item {\ttfamily obj.\-Set\-Icon\-Index\-Array\-Name (string name)} -\/ Set/get the icon index array name.  
\item {\ttfamily string = obj.\-Get\-Icon\-Index\-Array\-Name ()} -\/ Set/get the icon index array name.  
\item {\ttfamily obj.\-Set\-Orientation\-Array\-Name (string name)} -\/ Set/get the text orientation array name.  
\item {\ttfamily string = obj.\-Get\-Orientation\-Array\-Name ()} -\/ Set/get the text orientation array name.  
\item {\ttfamily obj.\-Set\-Bounded\-Size\-Array\-Name (string name)} -\/ Set/get the maximum text width (in world coordinates) array name.  
\item {\ttfamily string = obj.\-Get\-Bounded\-Size\-Array\-Name ()} -\/ Set/get the maximum text width (in world coordinates) array name.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property tprop)} -\/ Set/get the text property assigned to the hierarchy.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/get the text property assigned to the hierarchy.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpointspainter}{}\section{vtk\-Points\-Painter}\label{vtkrendering_vtkpointspainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter tries to paint points efficiently. Request to Render any other primitive are ignored and not passed to the delegate painter, if any. This painter cannot handle cell colors/normals. If they are present the request is passed on to the Delegate painter. If this class is able to render the primitive, the render request is not propagated to the delegate painter.

To create an instance of class vtk\-Points\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointsPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Points\-Painter 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\-Points\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Points\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Points\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpolydatamapper}{}\section{vtk\-Poly\-Data\-Mapper}\label{vtkrendering_vtkpolydatamapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Mapper is a class that maps polygonal data (i.\-e., vtk\-Poly\-Data) to graphics primitives. vtk\-Poly\-Data\-Mapper serves as a superclass for device-\/specific poly data mappers, that actually do the mapping to the rendering/graphics hardware/software.

To create an instance of class vtk\-Poly\-Data\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Poly\-Data\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Piece (vtk\-Renderer ren, vtk\-Actor act)} -\/ Implemented by sub classes. Actual rendering is done here.  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren, vtk\-Actor act)} -\/ This calls Render\-Piece (in a for loop is streaming is necessary).  
\item {\ttfamily obj.\-Set\-Input (vtk\-Poly\-Data in)} -\/ Specify the input data to map.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input ()} -\/ Specify the input data to map.  
\item {\ttfamily obj.\-Update ()} -\/ Update that sets the update piece first.  
\item {\ttfamily obj.\-Set\-Piece (int )} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily int = obj.\-Get\-Piece ()} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Pieces (int )} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Pieces ()} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Sub\-Pieces (int )} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Sub\-Pieces ()} -\/ If you want only a part of the data, specify by setting the piece.  
\item {\ttfamily obj.\-Set\-Ghost\-Level (int )} -\/ Set the number of ghost cells to return.  
\item {\ttfamily int = obj.\-Get\-Ghost\-Level ()} -\/ Set the number of ghost cells to return.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Return bounding box (array of six doubles) of data expressed as (xmin,xmax, ymin,ymax, zmin,zmax).  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Abstract\-Mapper m)} -\/ Make a shallow copy of this mapper.  
\item {\ttfamily obj.\-Map\-Data\-Array\-To\-Vertex\-Attribute (string vertex\-Attribute\-Name, string data\-Array\-Name, int field\-Association, int componentno)} -\/ Select a data array from the point/cell data and map it to a generic vertex attribute. vertex\-Attribute\-Name is the name of the vertex attribute. data\-Array\-Name is the name of the data array. field\-Association indicates when the data array is a point data array or cell data array (vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-P\-O\-I\-N\-T\-S or (vtk\-Data\-Object\-::\-F\-I\-E\-L\-D\-\_\-\-A\-S\-S\-O\-C\-I\-A\-T\-I\-O\-N\-\_\-\-C\-E\-L\-L\-S). componentno indicates which component from the data array must be passed as the attribute. If -\/1, then all components are passed.  
\item {\ttfamily obj.\-Map\-Data\-Array\-To\-Multi\-Texture\-Attribute (int unit, string data\-Array\-Name, int field\-Association, int componentno)}  
\item {\ttfamily obj.\-Remove\-Vertex\-Attribute\-Mapping (string vertex\-Attribute\-Name)} -\/ Remove a vertex attribute mapping.  
\item {\ttfamily obj.\-Remove\-All\-Vertex\-Attribute\-Mappings ()} -\/ Remove all vertex attributes.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpolydatamapper2d}{}\section{vtk\-Poly\-Data\-Mapper2\-D}\label{vtkrendering_vtkpolydatamapper2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Mapper2\-D is a mapper that renders 3\-D polygonal data (vtk\-Poly\-Data) onto the 2\-D image plane (i.\-e., the renderer's viewport). By default, the 3\-D data is transformed into 2\-D data by ignoring the z-\/coordinate of the 3\-D points in vtk\-Poly\-Data, and taking the x-\/y values as local display values (i.\-e., pixel coordinates). Alternatively, you can provide a vtk\-Coordinate object that will transform the data into local display coordinates (use the vtk\-Coordinate\-::\-Set\-Coordinate\-System() methods to indicate which coordinate system you are transforming the data from).

To create an instance of class vtk\-Poly\-Data\-Mapper2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataMapper2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Mapper2\-D has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Poly\-Data\-Mapper2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Mapper2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Mapper2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Poly\-Data in)} -\/ Set the input to the mapper.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input ()} -\/ Set the input to the mapper.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors lut)} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily obj.\-Create\-Default\-Lookup\-Table ()} -\/ Create default lookup table. Generally used to create one when none is available with the scalar data.  
\item {\ttfamily obj.\-Set\-Scalar\-Visibility (int )} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Visibility ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Scalar\-Visibility\-On ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Scalar\-Visibility\-Off ()} -\/ Turn on/off flag to control whether scalar data is used to color objects.  
\item {\ttfamily obj.\-Set\-Color\-Mode (int )} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Color\-By\-Array\-Component() method.)  
\item {\ttfamily int = obj.\-Get\-Color\-Mode ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Color\-By\-Array\-Component() method.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Default ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Color\-By\-Array\-Component() method.)  
\item {\ttfamily obj.\-Set\-Color\-Mode\-To\-Map\-Scalars ()} -\/ Control how the scalar data is mapped to colors. By default (Color\-Mode\-To\-Default), unsigned char scalars are treated as colors, and N\-O\-T mapped through the lookup table, while everything else is. Setting Color\-Mode\-To\-Map\-Scalars means that all scalar data will be mapped through the lookup table. (Note that for multi-\/component scalars, the particular component to use for mapping can be specified using the Color\-By\-Array\-Component() method.)  
\item {\ttfamily string = obj.\-Get\-Color\-Mode\-As\-String ()} -\/ Return the method of coloring scalar data.  
\item {\ttfamily obj.\-Set\-Use\-Lookup\-Table\-Scalar\-Range (int )} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily int = obj.\-Get\-Use\-Lookup\-Table\-Scalar\-Range ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Use\-Lookup\-Table\-Scalar\-Range\-On ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Use\-Lookup\-Table\-Scalar\-Range\-Off ()} -\/ Control whether the mapper sets the lookuptable range based on its own Scalar\-Range, or whether it will use the Lookup\-Table Scalar\-Range regardless of it's own setting. By default the Mapper is allowed to set the Lookup\-Table range, but users who are sharing Lookup\-Tables between mappers/actors will probably wish to force the mapper to use the Lookup\-Table unchanged.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double , double )} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily obj.\-Set\-Scalar\-Range (double a\mbox{[}2\mbox{]})} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily double = obj. Get\-Scalar\-Range ()} -\/ Specify range in terms of scalar minimum and maximum (smin,smax). These values are used to map scalars into lookup table. Has no effect when Use\-Lookup\-Table\-Scalar\-Range is true.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode (int )} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily int = obj.\-Get\-Scalar\-Mode ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Default ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Point\-Field\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Set\-Scalar\-Mode\-To\-Use\-Cell\-Field\-Data ()} -\/ Control how the filter works with scalar point data and cell attribute data. By default (Scalar\-Mode\-To\-Default), the filter will use point data, and if no point data is available, then cell data is used. Alternatively you can explicitly set the filter to use point data (Scalar\-Mode\-To\-Use\-Point\-Data) or cell data (Scalar\-Mode\-To\-Use\-Cell\-Data). You can also choose to get the scalars from an array in point field data (Scalar\-Mode\-To\-Use\-Point\-Field\-Data) or cell field data (Scalar\-Mode\-To\-Use\-Cell\-Field\-Data). If scalars are coming from a field data array, you must call Color\-By\-Array\-Component before you call Get\-Colors.  
\item {\ttfamily obj.\-Color\-By\-Array\-Component (int array\-Num, int component)} -\/ Choose which component of which field data array to color by.  
\item {\ttfamily obj.\-Color\-By\-Array\-Component (string array\-Name, int component)} -\/ Choose which component of which field data array to color by.  
\item {\ttfamily string = obj.\-Get\-Array\-Name ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Id ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Access\-Mode ()} -\/ Get the array name or number and component to color by.  
\item {\ttfamily int = obj.\-Get\-Array\-Component ()} -\/ Overload standard modified time function. If lookup table is modified, then this object is modified as well.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload standard modified time function. If lookup table is modified, then this object is modified as well.  
\item {\ttfamily obj.\-Set\-Transform\-Coordinate (vtk\-Coordinate )} -\/ Specify a vtk\-Coordinate object to be used to transform the vtk\-Poly\-Data point coordinates. By default (no vtk\-Coordinate specified), the point coordinates are taken as local display coordinates.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Transform\-Coordinate ()} -\/ Specify a vtk\-Coordinate object to be used to transform the vtk\-Poly\-Data point coordinates. By default (no vtk\-Coordinate specified), the point coordinates are taken as local display coordinates.  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Map\-Scalars (double alpha)} -\/ Map the scalars (if there are any scalars and Scalar\-Visibility is on) through the lookup table, returning an unsigned char R\-G\-B\-A array. This is typically done as part of the rendering process. The alpha parameter allows the blending of the scalars with an additional alpha (typically which comes from a vtk\-Actor, etc.)  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Abstract\-Mapper m)} -\/ Make a shallow copy of this mapper.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpolydatapainter}{}\section{vtk\-Poly\-Data\-Painter}\label{vtkrendering_vtkpolydatapainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Painter encapsulates a method of drawing poly data. This is a subset of what a mapper does. The painter does no maintenance of the rendering state (camera, lights, etc.). It is solely responsible for issuing rendering commands that build graphics primitives.

To simplify coding, an implementation of vtk\-Poly\-Data\-Painter is allowed to support only certain types of poly data or certain types of primitives.

To create an instance of class vtk\-Poly\-Data\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Painter 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\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Input\-As\-Poly\-Data ()} -\/ Get/set the poly data to render.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Output\-As\-Poly\-Data ()} -\/ Get the output polydata from this Painter. The default implementation forwards the input polydata as the output.  
\item {\ttfamily obj.\-Render (vtk\-Renderer renderer, vtk\-Actor actor, long typeflags, bool force\-Compile\-Only)} -\/ Overridden to stop the render call if input polydata is not set, since Poly\-Data\-Painter cannot paint without any polydata input.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpolygonspainter}{}\section{vtk\-Polygons\-Painter}\label{vtkrendering_vtkpolygonspainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter renders Polys in vtk\-Poly\-Data. It can render the polys in any representation (V\-T\-K\-\_\-\-P\-O\-I\-N\-T\-S, V\-T\-K\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E, V\-T\-K\-\_\-\-S\-U\-R\-F\-A\-C\-E).

To create an instance of class vtk\-Polygons\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolygonsPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Polygons\-Painter 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\-Polygons\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Polygons\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Polygons\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkpovexporter}{}\section{vtk\-P\-O\-V\-Exporter}\label{vtkrendering_vtkpovexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This Exporter can be attached to a render window in order to generate scene description files for the Persistance of Vision Raytracer www.\-povray.\-org.

.S\-E\-C\-T\-I\-O\-N Thanks Li-\/\-Ta Lo (\href{mailto:ollie@lanl.gov}{\tt ollie@lanl.\-gov}) and Jim Ahrens (\href{mailto:ahrens@lanl.gov}{\tt ahrens@lanl.\-gov}) Los Alamos National Laboratory

To create an instance of class vtk\-P\-O\-V\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPOVExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-P\-O\-V\-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\-P\-O\-V\-Exporter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-P\-O\-V\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-P\-O\-V\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )}  
\item {\ttfamily string = obj.\-Get\-File\-Name ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkprimitivepainter}{}\section{vtk\-Primitive\-Painter}\label{vtkrendering_vtkprimitivepainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is the abstract superclass for classes that handle single type of primitive i.\-e. verts, lines, polys or tstrips. Concrete subclasses will pass a Render() call to the delegate painter, if any, only if it could not render. .S\-E\-C\-T\-I\-O\-N Thanks Support for generic vertex attributes in V\-T\-K was contributed in collaboration with Stephane Ploix at E\-D\-F.

To create an instance of class vtk\-Primitive\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPrimitivePainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Primitive\-Painter 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\-Primitive\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Primitive\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Primitive\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Supported\-Primitive ()} -\/ Get the type of primitive supported by this painter. This must be set by concrete subclasses.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkprop3d}{}\section{vtk\-Prop3\-D}\label{vtkrendering_vtkprop3d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Prop3\-D is an abstract class used to represent an entity in a rendering scene (i.\-e., vtk\-Prop3\-D is a vtk\-Prop with an associated transformation matrix). It handles functions related to the position, orientation and scaling. It combines these instance variables into one 4x4 transformation matrix as follows\-: \mbox{[}x y z 1\mbox{]} = \mbox{[}x y z 1\mbox{]} Translate(-\/origin) Scale(scale) Rot(y) Rot(x) Rot (z) Trans(origin) Trans(position). Both vtk\-Actor and vtk\-Volume are specializations of class vtk\-Prop. The constructor defaults to\-: origin(0,0,0) position=(0,0,0) orientation=(0,0,0), no user defined matrix or transform, and no texture map.

To create an instance of class vtk\-Prop3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProp3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Prop3\-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\-Prop3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Prop3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this vtk\-Prop3\-D.  
\item {\ttfamily obj.\-Set\-Position (double \-\_\-arg1, double \-\_\-arg2, double \-\_\-arg3)} -\/ Set/\-Get/\-Add the position of the Prop3\-D in world coordinates.  
\item {\ttfamily obj.\-Set\-Position (double \-\_\-arg\mbox{[}3\mbox{]})} -\/ Set/\-Get/\-Add the position of the Prop3\-D in world coordinates.  
\item {\ttfamily double = obj. Get\-Position ()} -\/ Set/\-Get/\-Add the position of the Prop3\-D in world coordinates.  
\item {\ttfamily obj.\-Add\-Position (double delta\-Position\mbox{[}3\mbox{]})} -\/ Set/\-Get/\-Add the position of the Prop3\-D in world coordinates.  
\item {\ttfamily obj.\-Add\-Position (double delta\-X, double delta\-Y, double delta\-Z)} -\/ Set/\-Get/\-Add the position of the Prop3\-D in world coordinates.  
\item {\ttfamily obj.\-Set\-Origin (double \-\_\-arg1, double \-\_\-arg2, double \-\_\-arg3)} -\/ Set/\-Get the origin of the Prop3\-D. This is the point about which all rotations take place.  
\item {\ttfamily obj.\-Set\-Origin (double \-\_\-arg\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the Prop3\-D. This is the point about which all rotations take place.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Set/\-Get the origin of the Prop3\-D. This is the point about which all rotations take place.  
\item {\ttfamily obj.\-Set\-Scale (double \-\_\-arg1, double \-\_\-arg2, double \-\_\-arg3)} -\/ Set/\-Get the scale of the actor. Scaling in performed independently on the X, Y and Z axis. A scale of zero is illegal and will be replaced with one.  
\item {\ttfamily obj.\-Set\-Scale (double \-\_\-arg\mbox{[}3\mbox{]})} -\/ Set/\-Get the scale of the actor. Scaling in performed independently on the X, Y and Z axis. A scale of zero is illegal and will be replaced with one.  
\item {\ttfamily double = obj. Get\-Scale ()} -\/ Set/\-Get the scale of the actor. Scaling in performed independently on the X, Y and Z axis. A scale of zero is illegal and will be replaced with one.  
\item {\ttfamily obj.\-Set\-Scale (double s)} -\/ Method to set the scale isotropically  
\item {\ttfamily obj.\-Set\-User\-Transform (vtk\-Linear\-Transform transform)} -\/ In addition to the instance variables such as position and orientation, you can add an additional transformation for your own use. This transformation is concatenated with the actor's internal transformation, which you implicitly create through the use of Set\-Position(), Set\-Origin() and Set\-Orientation(). 

If the internal transformation is identity (i.\-e. if you don't set the Position, Origin, or Orientation) then the actors final transformation will be the User\-Transform, concatenated with the User\-Matrix if the User\-Matrix is present.  
\item {\ttfamily vtk\-Linear\-Transform = obj.\-Get\-User\-Transform ()} -\/ In addition to the instance variables such as position and orientation, you can add an additional transformation for your own use. This transformation is concatenated with the actor's internal transformation, which you implicitly create through the use of Set\-Position(), Set\-Origin() and Set\-Orientation(). 

If the internal transformation is identity (i.\-e. if you don't set the Position, Origin, or Orientation) then the actors final transformation will be the User\-Transform, concatenated with the User\-Matrix if the User\-Matrix is present.  
\item {\ttfamily obj.\-Set\-User\-Matrix (vtk\-Matrix4x4 matrix)} -\/ The User\-Matrix can be used in place of User\-Transform.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-User\-Matrix ()} -\/ The User\-Matrix can be used in place of User\-Transform.  
\item {\ttfamily obj.\-Get\-Matrix (vtk\-Matrix4x4 m)} -\/ Return a reference to the Prop3\-D's 4x4 composite matrix. Get the matrix from the position, origin, scale and orientation This matrix is cached, so multiple Get\-Matrix() calls will be efficient.  
\item {\ttfamily obj.\-Get\-Matrix (double m\mbox{[}16\mbox{]})} -\/ Return a reference to the Prop3\-D's 4x4 composite matrix. Get the matrix from the position, origin, scale and orientation This matrix is cached, so multiple Get\-Matrix() calls will be efficient.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds for this Prop3\-D as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds for this Prop3\-D as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax).  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Get the center of the bounding box in world coordinates.  
\item {\ttfamily double = obj.\-Get\-X\-Range ()} -\/ Get the Prop3\-D's x range in world coordinates.  
\item {\ttfamily double = obj.\-Get\-Y\-Range ()} -\/ Get the Prop3\-D's y range in world coordinates.  
\item {\ttfamily double = obj.\-Get\-Z\-Range ()} -\/ Get the Prop3\-D's z range in world coordinates.  
\item {\ttfamily double = obj.\-Get\-Length ()} -\/ Get the length of the diagonal of the bounding box.  
\item {\ttfamily obj.\-Rotate\-X (double )} -\/ Rotate the Prop3\-D in degrees about the X axis using the right hand rule. The axis is the Prop3\-D's X axis, which can change as other rotations are performed. To rotate about the world X axis use Rotate\-W\-X\-Y\-Z (angle, 1, 0, 0). This rotation is applied before all others in the current transformation matrix.  
\item {\ttfamily obj.\-Rotate\-Y (double )} -\/ Rotate the Prop3\-D in degrees about the Y axis using the right hand rule. The axis is the Prop3\-D's Y axis, which can change as other rotations are performed. To rotate about the world Y axis use Rotate\-W\-X\-Y\-Z (angle, 0, 1, 0). This rotation is applied before all others in the current transformation matrix.  
\item {\ttfamily obj.\-Rotate\-Z (double )} -\/ Rotate the Prop3\-D in degrees about the Z axis using the right hand rule. The axis is the Prop3\-D's Z axis, which can change as other rotations are performed. To rotate about the world Z axis use Rotate\-W\-X\-Y\-Z (angle, 0, 0, 1). This rotation is applied before all others in the current transformation matrix.  
\item {\ttfamily obj.\-Rotate\-W\-X\-Y\-Z (double , double , double , double )} -\/ Rotate the Prop3\-D in degrees about an arbitrary axis specified by the last three arguments. The axis is specified in world coordinates. To rotate an about its model axes, use Rotate\-X, Rotate\-Y, Rotate\-Z.  
\item {\ttfamily obj.\-Set\-Orientation (double , double , double )} -\/ Sets the orientation of the Prop3\-D. Orientation is specified as X,Y and Z rotations in that order, but they are performed as Rotate\-Z, Rotate\-X, and finally Rotate\-Y.  
\item {\ttfamily obj.\-Set\-Orientation (double a\mbox{[}3\mbox{]})} -\/ Sets the orientation of the Prop3\-D. Orientation is specified as X,Y and Z rotations in that order, but they are performed as Rotate\-Z, Rotate\-X, and finally Rotate\-Y.  
\item {\ttfamily double = obj.\-Get\-Orientation ()} -\/ Returns the orientation of the Prop3\-D as s vector of X,Y and Z rotation. The ordering in which these rotations must be done to generate the same matrix is Rotate\-Z, Rotate\-X, and finally Rotate\-Y. See also Set\-Orientation.  
\item {\ttfamily obj.\-Get\-Orientation (double o\mbox{[}3\mbox{]})} -\/ Returns the orientation of the Prop3\-D as s vector of X,Y and Z rotation. The ordering in which these rotations must be done to generate the same matrix is Rotate\-Z, Rotate\-X, and finally Rotate\-Y. See also Set\-Orientation.  
\item {\ttfamily double = obj.\-Get\-Orientation\-W\-X\-Y\-Z ()} -\/ Returns the W\-X\-Y\-Z orientation of the Prop3\-D.  
\item {\ttfamily obj.\-Add\-Orientation (double , double , double )} -\/ Add to the current orientation. See Set\-Orientation and Get\-Orientation for more details. This basically does a Get\-Orientation, adds the passed in arguments, and then calls Set\-Orientation.  
\item {\ttfamily obj.\-Add\-Orientation (double a\mbox{[}3\mbox{]})} -\/ Add to the current orientation. See Set\-Orientation and Get\-Orientation for more details. This basically does a Get\-Orientation, adds the passed in arguments, and then calls Set\-Orientation.  
\item {\ttfamily obj.\-Poke\-Matrix (vtk\-Matrix4x4 matrix)} -\/ This method modifies the vtk\-Prop3\-D so that its transformation state is set to the matrix specified. The method does this by setting appropriate transformation-\/related ivars to initial values (i.\-e., not transformed), and placing the user-\/supplied matrix into the User\-Matrix of this vtk\-Prop3\-D. If the method is called again with a N\-U\-L\-L matrix, then the original state of the vtk\-Prop3\-D will be restored. This method is used to support picking and assembly structures.  
\item {\ttfamily obj.\-Init\-Path\-Traversal ()} -\/ Overload vtk\-Prop's method for setting up assembly paths. See the documentation for vtk\-Prop.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the vtk\-Prop3\-D's mtime  
\item {\ttfamily long = obj.\-Get\-User\-Transform\-Matrix\-M\-Time ()} -\/ Get the modified time of the user matrix or user transform.  
\item {\ttfamily obj.\-Compute\-Matrix ()} -\/ Generate the matrix based on ivars  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Matrix ()} -\/ Is the matrix for this actor identity  
\item {\ttfamily int = obj.\-Get\-Is\-Identity ()} -\/ Is the matrix for this actor identity  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkprop3dcollection}{}\section{vtk\-Prop3\-D\-Collection}\label{vtkrendering_vtkprop3dcollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Prop3\-D\-Collection represents and provides methods to manipulate a list of 3\-D props (i.\-e., vtk\-Prop3\-D and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Prop3\-D\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProp3DCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Prop3\-D\-Collection 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\-Prop3\-D\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Prop3\-D\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Prop3\-D\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Prop3\-D p)} -\/ Add an actor to the list.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Next\-Prop3\-D ()} -\/ Get the next actor in the list.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Last\-Prop3\-D ()} -\/ Get the last actor in the list.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkproperty}{}\section{vtk\-Property}\label{vtkrendering_vtkproperty}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Property is an object that represents lighting and other surface properties of a geometric object. The primary properties that can be set are colors (overall, ambient, diffuse, specular, and edge color); specular power; opacity of the object; the representation of the object (points, wireframe, or surface); and the shading method to be used (flat, Gouraud, and Phong). Also, some special graphics features like backface properties can be set and manipulated with this object.

To create an instance of class vtk\-Property, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkProperty
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-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\-Property class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Property = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Property = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Property p)} -\/ Assign one property to another.  
\item {\ttfamily obj.\-Render (vtk\-Actor , vtk\-Renderer )} -\/ This method causes the property to set up whatever is required for its instance variables. This is actually handled by a subclass of vtk\-Property, which is created automatically. This method includes the invoking actor as an argument which can be used by property devices that require the actor.  
\item {\ttfamily obj.\-Backface\-Render (vtk\-Actor , vtk\-Renderer )} -\/ This method renders the property as a backface property. Two\-Sided\-Lighting must be turned off to see any backface properties. Note that only colors and opacity are used for backface properties. Other properties such as Representation, Culling are specified by the Property.  
\item {\ttfamily bool = obj.\-Get\-Lighting ()} -\/ Set/\-Get lighting flag for an object. Initial value is true.  
\item {\ttfamily obj.\-Set\-Lighting (bool )} -\/ Set/\-Get lighting flag for an object. Initial value is true.  
\item {\ttfamily obj.\-Lighting\-On ()} -\/ Set/\-Get lighting flag for an object. Initial value is true.  
\item {\ttfamily obj.\-Lighting\-Off ()} -\/ Set/\-Get lighting flag for an object. Initial value is true.  
\item {\ttfamily obj.\-Set\-Interpolation (int )} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Min\-Value ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Max\-Value ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily int = obj.\-Get\-Interpolation ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily obj.\-Set\-Interpolation\-To\-Flat ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily obj.\-Set\-Interpolation\-To\-Gouraud ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily obj.\-Set\-Interpolation\-To\-Phong ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily string = obj.\-Get\-Interpolation\-As\-String ()} -\/ Set the shading interpolation method for an object.  
\item {\ttfamily obj.\-Set\-Representation (int )} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily int = obj.\-Get\-Representation\-Min\-Value ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily int = obj.\-Get\-Representation\-Max\-Value ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily int = obj.\-Get\-Representation ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Points ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Wireframe ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Surface ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily string = obj.\-Get\-Representation\-As\-String ()} -\/ Control the surface geometry representation for the object.  
\item {\ttfamily obj.\-Set\-Color (double r, double g, double b)} -\/ Set the color of the object. Has the side effect of setting the ambient diffuse and specular colors as well. This is basically a quick overall color setting method.  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set the color of the object. Has the side effect of setting the ambient diffuse and specular colors as well. This is basically a quick overall color setting method.  
\item {\ttfamily double = obj.\-Get\-Color ()} -\/ Set the color of the object. Has the side effect of setting the ambient diffuse and specular colors as well. This is basically a quick overall color setting method.  
\item {\ttfamily obj.\-Get\-Color (double rgb\mbox{[}3\mbox{]})} -\/ Set the color of the object. Has the side effect of setting the ambient diffuse and specular colors as well. This is basically a quick overall color setting method.  
\item {\ttfamily obj.\-Set\-Ambient (double )} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Ambient\-Min\-Value ()} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Ambient\-Max\-Value ()} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Ambient ()} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily obj.\-Set\-Diffuse (double )} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Diffuse\-Min\-Value ()} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Diffuse\-Max\-Value ()} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Diffuse ()} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily obj.\-Set\-Specular (double )} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Specular\-Min\-Value ()} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Specular\-Max\-Value ()} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Specular ()} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily obj.\-Set\-Specular\-Power (double )} -\/ Set/\-Get the specular power.  
\item {\ttfamily double = obj.\-Get\-Specular\-Power\-Min\-Value ()} -\/ Set/\-Get the specular power.  
\item {\ttfamily double = obj.\-Get\-Specular\-Power\-Max\-Value ()} -\/ Set/\-Get the specular power.  
\item {\ttfamily double = obj.\-Get\-Specular\-Power ()} -\/ Set/\-Get the specular power.  
\item {\ttfamily obj.\-Set\-Opacity (double )} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity\-Min\-Value ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity\-Max\-Value ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity ()} -\/ Set/\-Get the object's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily obj.\-Set\-Ambient\-Color (double , double , double )} -\/ Set/\-Get the ambient surface color. Not all renderers support separate ambient and diffuse colors. From a physical standpoint it really doesn't make too much sense to have both. For the rendering libraries that don't support both, the diffuse color is used.  
\item {\ttfamily obj.\-Set\-Ambient\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the ambient surface color. Not all renderers support separate ambient and diffuse colors. From a physical standpoint it really doesn't make too much sense to have both. For the rendering libraries that don't support both, the diffuse color is used.  
\item {\ttfamily double = obj. Get\-Ambient\-Color ()} -\/ Set/\-Get the ambient surface color. Not all renderers support separate ambient and diffuse colors. From a physical standpoint it really doesn't make too much sense to have both. For the rendering libraries that don't support both, the diffuse color is used.  
\item {\ttfamily obj.\-Set\-Diffuse\-Color (double , double , double )} -\/ Set/\-Get the diffuse surface color.  
\item {\ttfamily obj.\-Set\-Diffuse\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the diffuse surface color.  
\item {\ttfamily double = obj. Get\-Diffuse\-Color ()} -\/ Set/\-Get the diffuse surface color.  
\item {\ttfamily obj.\-Set\-Specular\-Color (double , double , double )} -\/ Set/\-Get the specular surface color.  
\item {\ttfamily obj.\-Set\-Specular\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the specular surface color.  
\item {\ttfamily double = obj. Get\-Specular\-Color ()} -\/ Set/\-Get the specular surface color.  
\item {\ttfamily int = obj.\-Get\-Edge\-Visibility ()} -\/ Turn on/off the visibility of edges. On some renderers it is possible to render the edges of geometric primitives separately from the interior.  
\item {\ttfamily obj.\-Set\-Edge\-Visibility (int )} -\/ Turn on/off the visibility of edges. On some renderers it is possible to render the edges of geometric primitives separately from the interior.  
\item {\ttfamily obj.\-Edge\-Visibility\-On ()} -\/ Turn on/off the visibility of edges. On some renderers it is possible to render the edges of geometric primitives separately from the interior.  
\item {\ttfamily obj.\-Edge\-Visibility\-Off ()} -\/ Turn on/off the visibility of edges. On some renderers it is possible to render the edges of geometric primitives separately from the interior.  
\item {\ttfamily obj.\-Set\-Edge\-Color (double , double , double )} -\/ Set/\-Get the color of primitive edges (if edge visibility is enabled).  
\item {\ttfamily obj.\-Set\-Edge\-Color (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the color of primitive edges (if edge visibility is enabled).  
\item {\ttfamily double = obj. Get\-Edge\-Color ()} -\/ Set/\-Get the color of primitive edges (if edge visibility is enabled).  
\item {\ttfamily obj.\-Set\-Line\-Width (float )} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width\-Min\-Value ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width\-Max\-Value ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Line\-Width ()} -\/ Set/\-Get the width of a Line. The width is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily obj.\-Set\-Line\-Stipple\-Pattern (int )} -\/ Set/\-Get the stippling pattern of a Line, as a 16-\/bit binary pattern (1 = pixel on, 0 = pixel off). This is only implemented for Open\-G\-L. The default is 0x\-F\-F\-F\-F.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Pattern ()} -\/ Set/\-Get the stippling pattern of a Line, as a 16-\/bit binary pattern (1 = pixel on, 0 = pixel off). This is only implemented for Open\-G\-L. The default is 0x\-F\-F\-F\-F.  
\item {\ttfamily obj.\-Set\-Line\-Stipple\-Repeat\-Factor (int )} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor\-Min\-Value ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor\-Max\-Value ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily int = obj.\-Get\-Line\-Stipple\-Repeat\-Factor ()} -\/ Set/\-Get the stippling repeat factor of a Line, which specifies how many times each bit in the pattern is to be repeated. This is only implemented for Open\-G\-L. The default is 1.  
\item {\ttfamily obj.\-Set\-Point\-Size (float )} -\/ Set/\-Get the diameter of a point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size\-Min\-Value ()} -\/ Set/\-Get the diameter of a point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size\-Max\-Value ()} -\/ Set/\-Get the diameter of a point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily float = obj.\-Get\-Point\-Size ()} -\/ Set/\-Get the diameter of a point. The size is expressed in screen units. This is only implemented for Open\-G\-L. The default is 1.\-0.  
\item {\ttfamily int = obj.\-Get\-Backface\-Culling ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If backface culling is on, polygons facing away from camera are not drawn.  
\item {\ttfamily obj.\-Set\-Backface\-Culling (int )} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If backface culling is on, polygons facing away from camera are not drawn.  
\item {\ttfamily obj.\-Backface\-Culling\-On ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If backface culling is on, polygons facing away from camera are not drawn.  
\item {\ttfamily obj.\-Backface\-Culling\-Off ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If backface culling is on, polygons facing away from camera are not drawn.  
\item {\ttfamily int = obj.\-Get\-Frontface\-Culling ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If frontface culling is on, polygons facing towards camera are not drawn.  
\item {\ttfamily obj.\-Set\-Frontface\-Culling (int )} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If frontface culling is on, polygons facing towards camera are not drawn.  
\item {\ttfamily obj.\-Frontface\-Culling\-On ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If frontface culling is on, polygons facing towards camera are not drawn.  
\item {\ttfamily obj.\-Frontface\-Culling\-Off ()} -\/ Turn on/off fast culling of polygons based on orientation of normal with respect to camera. If frontface culling is on, polygons facing towards camera are not drawn.  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-Get\-Material ()} -\/ Get the material representation used for shading. The material will be used only when shading is enabled.  
\item {\ttfamily string = obj.\-Get\-Material\-Name ()} -\/ Returns the name of the material currenly loaded, if any.  
\item {\ttfamily obj.\-Load\-Material (string name)} -\/ Load the material. The material can be the name of a built-\/on material or the filename for a V\-T\-K material X\-M\-L description.  
\item {\ttfamily obj.\-Load\-Material\-From\-String (string materialxml)} -\/ Load the material given the contents of the material file.  
\item {\ttfamily obj.\-Load\-Material (vtk\-X\-M\-L\-Material )} -\/ Load the material given the material representation.  
\item {\ttfamily obj.\-Set\-Shading (int )} -\/ Enable/\-Disable shading. When shading is enabled, the Material must be set.  
\item {\ttfamily int = obj.\-Get\-Shading ()} -\/ Enable/\-Disable shading. When shading is enabled, the Material must be set.  
\item {\ttfamily obj.\-Shading\-On ()} -\/ Enable/\-Disable shading. When shading is enabled, the Material must be set.  
\item {\ttfamily obj.\-Shading\-Off ()} -\/ Enable/\-Disable shading. When shading is enabled, the Material must be set.  
\item {\ttfamily vtk\-Shader\-Program = obj.\-Get\-Shader\-Program ()} -\/ Get the Shader program. If Material is not set/or not loaded properly, this will return null.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, int x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, float x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, double x)} -\/ Provide values to initialize shader variables. Useful to initialize shader variables that change over time (animation, G\-U\-I widgets inputs, etc. )
\begin{DoxyItemize}
\item {\ttfamily name} -\/ hardware name of the uniform variable
\item {\ttfamily num\-Vars} -\/ number of variables being set
\item {\ttfamily x} -\/ values  
\end{DoxyItemize}
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int v)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, float v)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, double v)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int v1, int v2)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, float v1, float v2)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, double v1, double v2)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int v1, int v2, int v3)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, float v1, float v2, float v3)} -\/ Methods to provide to add shader variables from tcl.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, double v1, double v2, double v3)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily obj.\-Set\-Texture (string name, vtk\-Texture texture)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture (string name)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily obj.\-Set\-Texture (int unit, vtk\-Texture texture)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture (int unit)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily obj.\-Remove\-Texture (int unit)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. A property does not need to have an associated texture map and multiple properties can share one texture. Textures must be assigned unique names.  
\item {\ttfamily obj.\-Remove\-Texture (string name)} -\/ Remove a texture from the collection. Note that the indices of all the subsquent textures, if any, will change.  
\item {\ttfamily obj.\-Remove\-All\-Textures ()} -\/ Remove all the textures.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Textures ()} -\/ Returns the number of textures in this property.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window win)} -\/ Release any graphics resources that are being consumed by this property. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkproppicker}{}\section{vtk\-Prop\-Picker}\label{vtkrendering_vtkproppicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Prop\-Picker is used to pick an actor/prop given a selection point (in display coordinates) and a renderer. This class uses graphics hardware/rendering system to pick rapidly (as compared to using ray casting as does vtk\-Cell\-Picker and vtk\-Point\-Picker). This class determines the actor/prop and pick position in world coordinates; point and cell ids are not determined.

To create an instance of class vtk\-Prop\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPropPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Prop\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Prop\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Prop\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Prop\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Pick\-Prop (double selection\-X, double selection\-Y, vtk\-Renderer renderer)} -\/ Perform the pick and set the Picked\-Prop ivar. If something is picked, a 1 is returned, otherwise 0 is returned. Use the Get\-View\-Prop() method to get the instance of vtk\-Prop that was picked. Props are picked from the renderers list of pickable Props.  
\item {\ttfamily int = obj.\-Pick\-Prop (double selection\-X, double selection\-Y, vtk\-Renderer renderer, vtk\-Prop\-Collection pickfrom)} -\/ Perform a pick from the user-\/provided list of vtk\-Props and not from the list of vtk\-Props that the render maintains.  
\item {\ttfamily int = obj.\-Pick (double selection\-X, double selection\-Y, double selection\-Z, vtk\-Renderer renderer)} -\/ Overide superclasses' Pick() method.  
\item {\ttfamily int = obj.\-Pick (double selection\-Pt\mbox{[}3\mbox{]}, vtk\-Renderer renderer)} -\/ Overide superclasses' Pick() method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkqimagetoimagesource}{}\section{vtk\-Q\-Image\-To\-Image\-Source}\label{vtkrendering_vtkqimagetoimagesource}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Q\-Image\-To\-Image\-Source produces image data from a Q\-Image.

To create an instance of class vtk\-Q\-Image\-To\-Image\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQImageToImageSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Q\-Image\-To\-Image\-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\-Q\-Image\-To\-Image\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Q\-Image\-To\-Image\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Q\-Image\-To\-Image\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkqtinitialization}{}\section{vtk\-Qt\-Initialization}\label{vtkrendering_vtkqtinitialization}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Utility class that initializes Qt by creating an instance of Q\-Application in its ctor, if one doesn't already exist. This is mainly of use in Para\-View with filters that use Qt in their implementation -\/ create an instance of vtk\-Qt\-Initialization prior to instantiating any filters that require Qt.

To create an instance of class vtk\-Qt\-Initialization, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQtInitialization
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Qt\-Initialization 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\-Qt\-Initialization class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Qt\-Initialization = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Qt\-Initialization = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkqtlabelrenderstrategy}{}\section{vtk\-Qt\-Label\-Render\-Strategy}\label{vtkrendering_vtkqtlabelrenderstrategy}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class uses Qt to render labels and compute sizes. The labels are rendered to a Q\-Image, then End\-Frame() converts that image to a vtk\-Image\-Data and textures the image onto a quad spanning the render area.

To create an instance of class vtk\-Qt\-Label\-Render\-Strategy, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQtLabelRenderStrategy
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Qt\-Label\-Render\-Strategy 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\-Qt\-Label\-Render\-Strategy class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Qt\-Label\-Render\-Strategy = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Qt\-Label\-Render\-Strategy = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start\-Frame ()} -\/ Start a rendering frame. Renderer must be set.  
\item {\ttfamily obj.\-End\-Frame ()} -\/ End a rendering frame.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window window)} -\/ Release any graphics resources that are being consumed by this strategy. The parameter window could be used to determine which graphic resources to release.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkqttreeringlabelmapper}{}\section{vtk\-Qt\-Tree\-Ring\-Label\-Mapper}\label{vtkrendering_vtkqttreeringlabelmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Qt\-Tree\-Ring\-Label\-Mapper is a mapper that renders text on a tree map. A tree map is a vtk\-Tree with an associated 4-\/tuple array used for storing the boundary rectangle for each vertex in the tree. The user must specify the array name used for storing the rectangles.

The mapper iterates through the tree and attempts and renders a label inside the vertex's rectangle as long as the following conditions hold\-:
\begin{DoxyEnumerate}
\item The vertex level is within the range of levels specified for labeling.
\item The label can fully fit inside its box.
\item The label does not overlap an ancestor's label.
\end{DoxyEnumerate}

To create an instance of class vtk\-Qt\-Tree\-Ring\-Label\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQtTreeRingLabelMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Qt\-Tree\-Ring\-Label\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Qt\-Tree\-Ring\-Label\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Qt\-Tree\-Ring\-Label\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Qt\-Tree\-Ring\-Label\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily obj.\-Render\-Overlay (vtk\-Viewport viewport, vtk\-Actor2\-D actor)} -\/ Draw the text to the screen at each input point.  
\item {\ttfamily vtk\-Tree = obj.\-Get\-Input\-Tree ()} -\/ The input to this filter.  
\item {\ttfamily obj.\-Set\-Sectors\-Array\-Name (string name)} -\/ The name of the 4-\/tuple array used for  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property. Note that multiple type text properties (set with a second integer parameter) are not currently supported, but are provided to avoid compiler warnings.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the text property. Note that multiple type text properties (set with a second integer parameter) are not currently supported, but are provided to avoid compiler warnings.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Property (vtk\-Text\-Property p, int type)} -\/ Set/\-Get the text property. Note that multiple type text properties (set with a second integer parameter) are not currently supported, but are provided to avoid compiler warnings.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property (int type)} -\/ Set/\-Get the name of the text rotation array.  
\item {\ttfamily obj.\-Set\-Text\-Rotation\-Array\-Name (string )} -\/ Set/\-Get the name of the text rotation array.  
\item {\ttfamily string = obj.\-Get\-Text\-Rotation\-Array\-Name ()} -\/ Set/\-Get the name of the text rotation array.  
\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 obj.\-Set\-Renderer (vtk\-Renderer ren)}  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkquadriclodactor}{}\section{vtk\-Quadric\-L\-O\-D\-Actor}\label{vtkrendering_vtkquadriclodactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Quadric\-L\-O\-D\-Actor implements a specific strategy for level-\/of-\/detail using the vtk\-Quadric\-Clustering decimation algorithm. It supports only two levels of detail\-: full resolution and a decimated version. The decimated L\-O\-D is generated using a tuned strategy to produce output consistent with the requested interactive frame rate (i.\-e., the vtk\-Render\-Window\-Interactor's Desired\-Update\-Rate). It also makes use of display lists for performance, and adjusts the vtk\-Quadric\-Clustering algorithm to take into account the dimensionality of the data (e.\-g., 2\-D, x-\/y surfaces may be binned into n x n x 1 to reduce extra polygons in the z-\/direction). Finally, the filter may optionally be set in \char`\"{}\-Static\char`\"{} mode (this works with the vtk\-Mapper\-::\-Set\-Static() method). `\-Enabling Static results in a one time execution of the Mapper's pipeline. After that, the pipeline no longer updated (unless manually forced to do so).

To create an instance of class vtk\-Quadric\-L\-O\-D\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuadricLODActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quadric\-L\-O\-D\-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\-Quadric\-L\-O\-D\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard class methods.  
\item {\ttfamily vtk\-Quadric\-L\-O\-D\-Actor = obj.\-New\-Instance ()} -\/ Standard class methods.  
\item {\ttfamily vtk\-Quadric\-L\-O\-D\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard class methods.  
\item {\ttfamily obj.\-Set\-Defer\-L\-O\-D\-Construction (int )} -\/ Specify whether to build the L\-O\-D immediately (i.\-e., on the first render) or to wait until the L\-O\-D is requested in a subsequent render. By default, L\-O\-D construction is not deferred (Defer\-L\-O\-D\-Construction is false).  
\item {\ttfamily int = obj.\-Get\-Defer\-L\-O\-D\-Construction ()} -\/ Specify whether to build the L\-O\-D immediately (i.\-e., on the first render) or to wait until the L\-O\-D is requested in a subsequent render. By default, L\-O\-D construction is not deferred (Defer\-L\-O\-D\-Construction is false).  
\item {\ttfamily obj.\-Defer\-L\-O\-D\-Construction\-On ()} -\/ Specify whether to build the L\-O\-D immediately (i.\-e., on the first render) or to wait until the L\-O\-D is requested in a subsequent render. By default, L\-O\-D construction is not deferred (Defer\-L\-O\-D\-Construction is false).  
\item {\ttfamily obj.\-Defer\-L\-O\-D\-Construction\-Off ()} -\/ Specify whether to build the L\-O\-D immediately (i.\-e., on the first render) or to wait until the L\-O\-D is requested in a subsequent render. By default, L\-O\-D construction is not deferred (Defer\-L\-O\-D\-Construction is false).  
\item {\ttfamily obj.\-Set\-Static (int )} -\/ Turn on/off a flag to control whether the underlying pipeline is static. If static, this means that the data pipeline executes once and then not again until the user manually modifies this class. By default, Static is off because trying to debug this is tricky, and you should only use it when you know what you are doing.  
\item {\ttfamily int = obj.\-Get\-Static ()} -\/ Turn on/off a flag to control whether the underlying pipeline is static. If static, this means that the data pipeline executes once and then not again until the user manually modifies this class. By default, Static is off because trying to debug this is tricky, and you should only use it when you know what you are doing.  
\item {\ttfamily obj.\-Static\-On ()} -\/ Turn on/off a flag to control whether the underlying pipeline is static. If static, this means that the data pipeline executes once and then not again until the user manually modifies this class. By default, Static is off because trying to debug this is tricky, and you should only use it when you know what you are doing.  
\item {\ttfamily obj.\-Static\-Off ()} -\/ Turn on/off a flag to control whether the underlying pipeline is static. If static, this means that the data pipeline executes once and then not again until the user manually modifies this class. By default, Static is off because trying to debug this is tricky, and you should only use it when you know what you are doing.  
\item {\ttfamily obj.\-Set\-Data\-Configuration (int )} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily int = obj.\-Get\-Data\-Configuration\-Min\-Value ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily int = obj.\-Get\-Data\-Configuration\-Max\-Value ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily int = obj.\-Get\-Data\-Configuration ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-Unknown ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-X\-Line ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-Y\-Line ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-Z\-Line ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-X\-Y\-Plane ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-Y\-Z\-Plane ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-X\-Z\-Plane ()} -\/ Force the binning of the quadric clustering according to application knowledge relative to the dimension of the data. For example, if you know your data lies in a 2\-D x-\/y plane, the performance of the quadric clustering algorithm can be greatly improved by indicating this (i.\-e., the number of resulting triangles, and the quality of the decimation version is better). Setting this parameter forces the binning to be configured consistent with the dimnesionality of the data, and the collapse dimension ratio is ignored. Specifying the value of Data\-Configuration to U\-N\-K\-N\-O\-W\-N (the default value) means that the class will attempt to figure the dimension of the class automatically using the Collapse\-Dimension\-Ratio ivar.  
\item {\ttfamily obj.\-Set\-Data\-Configuration\-To\-X\-Y\-Z\-Volume ()} -\/ If the data configuration is set to U\-N\-K\-N\-O\-W\-N, this class attempts to figure out the dimensionality of the data using Collapse\-Dimension\-Ratio. This ivar is the ratio of short edge of the input bounding box to its long edge, which is then used to collapse the data dimension (and set the quadric bin size in that direction to one). By default, this value is 0.\-05.  
\item {\ttfamily obj.\-Set\-Collapse\-Dimension\-Ratio (double )} -\/ If the data configuration is set to U\-N\-K\-N\-O\-W\-N, this class attempts to figure out the dimensionality of the data using Collapse\-Dimension\-Ratio. This ivar is the ratio of short edge of the input bounding box to its long edge, which is then used to collapse the data dimension (and set the quadric bin size in that direction to one). By default, this value is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Collapse\-Dimension\-Ratio\-Min\-Value ()} -\/ If the data configuration is set to U\-N\-K\-N\-O\-W\-N, this class attempts to figure out the dimensionality of the data using Collapse\-Dimension\-Ratio. This ivar is the ratio of short edge of the input bounding box to its long edge, which is then used to collapse the data dimension (and set the quadric bin size in that direction to one). By default, this value is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Collapse\-Dimension\-Ratio\-Max\-Value ()} -\/ If the data configuration is set to U\-N\-K\-N\-O\-W\-N, this class attempts to figure out the dimensionality of the data using Collapse\-Dimension\-Ratio. This ivar is the ratio of short edge of the input bounding box to its long edge, which is then used to collapse the data dimension (and set the quadric bin size in that direction to one). By default, this value is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Collapse\-Dimension\-Ratio ()} -\/ If the data configuration is set to U\-N\-K\-N\-O\-W\-N, this class attempts to figure out the dimensionality of the data using Collapse\-Dimension\-Ratio. This ivar is the ratio of short edge of the input bounding box to its long edge, which is then used to collapse the data dimension (and set the quadric bin size in that direction to one). By default, this value is 0.\-05.  
\item {\ttfamily obj.\-Set\-L\-O\-D\-Filter (vtk\-Quadric\-Clustering lod\-Filter)} -\/ This class will create a vtk\-Quadric\-Clustering algorithm automatically. However, if you would like to specify the filter to use, or to access it and configure it, these method provide access to the filter.  
\item {\ttfamily vtk\-Quadric\-Clustering = obj.\-Get\-L\-O\-D\-Filter ()} -\/ This class will create a vtk\-Quadric\-Clustering algorithm automatically. However, if you would like to specify the filter to use, or to access it and configure it, these method provide access to the filter.  
\item {\ttfamily obj.\-Set\-Maximum\-Display\-List\-Size (int )} -\/ Specify the maximum display list size. This variable is used to determine whether to use display lists (Immediate\-Mode\-Rendering\-Off) or not. Controlling display list size is important to prevent program crashes (i.\-e., overly large display lists on some graphics hardware will cause faults). The display list size is the length of the vtk\-Cell\-Array representing the topology of the input vtk\-Poly\-Data.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Display\-List\-Size\-Min\-Value ()} -\/ Specify the maximum display list size. This variable is used to determine whether to use display lists (Immediate\-Mode\-Rendering\-Off) or not. Controlling display list size is important to prevent program crashes (i.\-e., overly large display lists on some graphics hardware will cause faults). The display list size is the length of the vtk\-Cell\-Array representing the topology of the input vtk\-Poly\-Data.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Display\-List\-Size\-Max\-Value ()} -\/ Specify the maximum display list size. This variable is used to determine whether to use display lists (Immediate\-Mode\-Rendering\-Off) or not. Controlling display list size is important to prevent program crashes (i.\-e., overly large display lists on some graphics hardware will cause faults). The display list size is the length of the vtk\-Cell\-Array representing the topology of the input vtk\-Poly\-Data.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Display\-List\-Size ()} -\/ Specify the maximum display list size. This variable is used to determine whether to use display lists (Immediate\-Mode\-Rendering\-Off) or not. Controlling display list size is important to prevent program crashes (i.\-e., overly large display lists on some graphics hardware will cause faults). The display list size is the length of the vtk\-Cell\-Array representing the topology of the input vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Prop\-Type (int )} -\/ Indicate that this actor is actually a follower. By default, the prop type is a vtk\-Actor.  
\item {\ttfamily int = obj.\-Get\-Prop\-Type\-Min\-Value ()} -\/ Indicate that this actor is actually a follower. By default, the prop type is a vtk\-Actor.  
\item {\ttfamily int = obj.\-Get\-Prop\-Type\-Max\-Value ()} -\/ Indicate that this actor is actually a follower. By default, the prop type is a vtk\-Actor.  
\item {\ttfamily int = obj.\-Get\-Prop\-Type ()} -\/ Indicate that this actor is actually a follower. By default, the prop type is a vtk\-Actor.  
\item {\ttfamily obj.\-Set\-Prop\-Type\-To\-Follower ()} -\/ Indicate that this actor is actually a follower. By default, the prop type is a vtk\-Actor.  
\item {\ttfamily obj.\-Set\-Prop\-Type\-To\-Actor ()} -\/ Set/\-Get the camera to follow. This method is only applicable when the prop type is set to a vtk\-Follower.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera )} -\/ Set/\-Get the camera to follow. This method is only applicable when the prop type is set to a vtk\-Follower.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera to follow. This method is only applicable when the prop type is set to a vtk\-Follower.  
\item {\ttfamily obj.\-Render (vtk\-Renderer , vtk\-Mapper )} -\/ This causes the actor to be rendered. Depending on the frame rate request, it will use either a full resolution render or an interactive render (i.\-e., it will use the decimated geometry).  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ This method is used internally by the rendering process. We overide the superclass method to properly set the estimated render time.  
\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 L\-O\-D actor. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkquaternioninterpolator}{}\section{vtk\-Quaternion\-Interpolator}\label{vtkrendering_vtkquaternioninterpolator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to interpolate a series of quaternions representing the rotations of a 3\-D object. The interpolation may be linear in form (using spherical linear interpolation S\-L\-E\-R\-P), or via spline interpolation (using S\-Q\-U\-A\-D). In either case the interpolation is specialized to quaternions since the interpolation occurs on the surface of the unit quaternion sphere.

To use this class, specify at least two pairs of (t,q\mbox{[}4\mbox{]}) with the Add\-Quaternion() method. Next interpolate the tuples with the Interpolate\-Quaternion(t,q\mbox{[}4\mbox{]}) method, where \char`\"{}t\char`\"{} must be in the range of (t\-\_\-min,t\-\_\-max) parameter values specified by the Add\-Quaternion() method (t is clamped otherwise), and q\mbox{[}4\mbox{]} is filled in by the method.

There are several important background references. Ken Shoemake described the practical application of quaternions for the interpolation of rotation (K. Shoemake, \char`\"{}\-Animating rotation with quaternion curves\char`\"{}, Computer Graphics (Siggraph '85) 19(3)\-:245--254, 1985). Another fine reference (available on-\/line) is E. B. Dam, M. Koch, and M. Lillholm, Technical Report D\-I\-K\-U-\/\-T\-R-\/98/5, Dept. of Computer Science, University of Copenhagen, Denmark.

To create an instance of class vtk\-Quaternion\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkQuaternionInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Quaternion\-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\-Quaternion\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Quaternion\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Quaternion\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Quaternions ()} -\/ Return the number of quaternions in the list of quaternions to be interpolated.  
\item {\ttfamily double = obj.\-Get\-Minimum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty. This is a convenience method for interpolation.  
\item {\ttfamily double = obj.\-Get\-Maximum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty. This is a convenience method for interpolation.  
\item {\ttfamily obj.\-Initialize ()} -\/ Reset the class so that it contains no data; i.\-e., the array of (t,q\mbox{[}4\mbox{]}) information is discarded.  
\item {\ttfamily obj.\-Add\-Quaternion (double t, double q\mbox{[}4\mbox{]})} -\/ Add another quaternion to the list of quaternions to be interpolated. Note that using the same time t value more than once replaces the previous quaternion at t. At least one quaternions must be added to define an interpolation functios.  
\item {\ttfamily obj.\-Remove\-Quaternion (double t)} -\/ Delete the quaternion at a particular parameter t. If there is no quaternion tuple defined at t, then the method does nothing.  
\item {\ttfamily obj.\-Interpolate\-Quaternion (double t, double q\mbox{[}4\mbox{]})} -\/ Interpolate the list of quaternions and determine a new quaternion (i.\-e., fill in the quaternion provided). If t is outside the range of (min,max) values, then t is clamped to lie within the range.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type (int )} -\/ Specify which type of function to use for interpolation. By default (Set\-Interpolation\-Function\-To\-Spline()), cubic spline interpolation using a modifed Kochanek basis is employed. Otherwise, if Set\-Interpolation\-Function\-To\-Linear() is invoked, linear spherical interpolation is used between each pair of quaternions.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Min\-Value ()} -\/ Specify which type of function to use for interpolation. By default (Set\-Interpolation\-Function\-To\-Spline()), cubic spline interpolation using a modifed Kochanek basis is employed. Otherwise, if Set\-Interpolation\-Function\-To\-Linear() is invoked, linear spherical interpolation is used between each pair of quaternions.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Max\-Value ()} -\/ Specify which type of function to use for interpolation. By default (Set\-Interpolation\-Function\-To\-Spline()), cubic spline interpolation using a modifed Kochanek basis is employed. Otherwise, if Set\-Interpolation\-Function\-To\-Linear() is invoked, linear spherical interpolation is used between each pair of quaternions.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type ()} -\/ Specify which type of function to use for interpolation. By default (Set\-Interpolation\-Function\-To\-Spline()), cubic spline interpolation using a modifed Kochanek basis is employed. Otherwise, if Set\-Interpolation\-Function\-To\-Linear() is invoked, linear spherical interpolation is used between each pair of quaternions.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Linear ()} -\/ Specify which type of function to use for interpolation. By default (Set\-Interpolation\-Function\-To\-Spline()), cubic spline interpolation using a modifed Kochanek basis is employed. Otherwise, if Set\-Interpolation\-Function\-To\-Linear() is invoked, linear spherical interpolation is used between each pair of quaternions.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Spline ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderedareapicker}{}\section{vtk\-Rendered\-Area\-Picker}\label{vtkrendering_vtkrenderedareapicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Like vtk\-Area\-Picker, this class picks all props within a selection area on the screen. The difference is in implementation. This class uses graphics hardware to perform the test where the other uses software bounding box/frustum intersection testing.

This picker is more conservative than vtk\-Area\-Picker. It will reject some objects that pass the bounding box test of vtk\-Area\-Picker. This will happen, for instance, when picking through a corner of the bounding box when the data set does not have any visible geometry in that corner.

To create an instance of class vtk\-Rendered\-Area\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderedAreaPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rendered\-Area\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rendered\-Area\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Rendered\-Area\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Rendered\-Area\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Area\-Pick (double x0, double y0, double x1, double y1, vtk\-Renderer renderer)} -\/ Perform pick operation in volume behind the given screen coordinates. Props intersecting the selection frustum will be accesible via Get\-Prop3\-D. Get\-Planes returns a vtk\-Implicit\-Funciton suitable for vtk\-Extract\-Geometry.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderer}{}\section{vtk\-Renderer}\label{vtkrendering_vtkrenderer}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Renderer provides an abstract specification for renderers. A renderer is an object that controls the rendering process for objects. Rendering is the process of converting geometry, a specification for lights, and a camera view into an image. vtk\-Renderer also performs coordinate transformation between world coordinates, view coordinates (the computer graphics rendering coordinate system), and display coordinates (the actual screen coordinates on the display device). Certain advanced rendering features such as two-\/sided lighting can also be controlled.

To create an instance of class vtk\-Renderer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Renderer 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\-Renderer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Renderer = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Renderer = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Actor (vtk\-Prop p)} -\/ Add/\-Remove different types of props to the renderer. These methods are all synonyms to Add\-View\-Prop and Remove\-View\-Prop. They are here for convenience and backwards compatibility.  
\item {\ttfamily obj.\-Add\-Volume (vtk\-Prop p)} -\/ Add/\-Remove different types of props to the renderer. These methods are all synonyms to Add\-View\-Prop and Remove\-View\-Prop. They are here for convenience and backwards compatibility.  
\item {\ttfamily obj.\-Remove\-Actor (vtk\-Prop p)} -\/ Add/\-Remove different types of props to the renderer. These methods are all synonyms to Add\-View\-Prop and Remove\-View\-Prop. They are here for convenience and backwards compatibility.  
\item {\ttfamily obj.\-Remove\-Volume (vtk\-Prop p)} -\/ Add/\-Remove different types of props to the renderer. These methods are all synonyms to Add\-View\-Prop and Remove\-View\-Prop. They are here for convenience and backwards compatibility.  
\item {\ttfamily obj.\-Add\-Light (vtk\-Light )} -\/ Add a light to the list of lights.  
\item {\ttfamily obj.\-Remove\-Light (vtk\-Light )} -\/ Remove a light from the list of lights.  
\item {\ttfamily obj.\-Remove\-All\-Lights ()} -\/ Remove all lights from the list of lights.  
\item {\ttfamily vtk\-Light\-Collection = obj.\-Get\-Lights ()} -\/ Return the collection of lights.  
\item {\ttfamily obj.\-Set\-Light\-Collection (vtk\-Light\-Collection lights)} -\/ Set the collection of lights. We cannot name it Set\-Lights because of Test\-Set\-Get \begin{DoxyPrecond}{Precondition}
lights\-\_\-exist\-: lights!=0 
\end{DoxyPrecond}
\begin{DoxyPostcond}{Postcondition}
lights\-\_\-set\-: lights==this-\/$>$Get\-Lights()  
\end{DoxyPostcond}

\item {\ttfamily obj.\-Create\-Light (void )} -\/ Create and add a light to renderer.  
\item {\ttfamily vtk\-Light = obj.\-Make\-Light ()} -\/ Create a new Light sutible for use with this type of Renderer. For example, a vtk\-Mesa\-Renderer should create a vtk\-Mesa\-Light in this function. The default is to just call vtk\-Light\-::\-New.  
\item {\ttfamily int = obj.\-Get\-Two\-Sided\-Lighting ()} -\/ Turn on/off two-\/sided lighting of surfaces. If two-\/sided lighting is off, then only the side of the surface facing the light(s) will be lit, and the other side dark. If two-\/sided lighting on, both sides of the surface will be lit.  
\item {\ttfamily obj.\-Set\-Two\-Sided\-Lighting (int )} -\/ Turn on/off two-\/sided lighting of surfaces. If two-\/sided lighting is off, then only the side of the surface facing the light(s) will be lit, and the other side dark. If two-\/sided lighting on, both sides of the surface will be lit.  
\item {\ttfamily obj.\-Two\-Sided\-Lighting\-On ()} -\/ Turn on/off two-\/sided lighting of surfaces. If two-\/sided lighting is off, then only the side of the surface facing the light(s) will be lit, and the other side dark. If two-\/sided lighting on, both sides of the surface will be lit.  
\item {\ttfamily obj.\-Two\-Sided\-Lighting\-Off ()} -\/ Turn on/off two-\/sided lighting of surfaces. If two-\/sided lighting is off, then only the side of the surface facing the light(s) will be lit, and the other side dark. If two-\/sided lighting on, both sides of the surface will be lit.  
\item {\ttfamily obj.\-Set\-Light\-Follow\-Camera (int )} -\/ Turn on/off the automatic repositioning of lights as the camera moves. If Light\-Follow\-Camera is on, lights that are designated as Headlights or Camera\-Lights will be adjusted to move with this renderer's camera. If Light\-Follow\-Camera is off, the lights will not be adjusted.

(Note\-: In previous versions of vtk, this light-\/tracking functionality was part of the interactors, not the renderer. For backwards compatibility, the older, more limited interactor behavior is enabled by default. To disable this mode, turn the interactor's Light\-Follow\-Camera flag O\-F\-F, and leave the renderer's Light\-Follow\-Camera flag O\-N.)  
\item {\ttfamily int = obj.\-Get\-Light\-Follow\-Camera ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. If Light\-Follow\-Camera is on, lights that are designated as Headlights or Camera\-Lights will be adjusted to move with this renderer's camera. If Light\-Follow\-Camera is off, the lights will not be adjusted.

(Note\-: In previous versions of vtk, this light-\/tracking functionality was part of the interactors, not the renderer. For backwards compatibility, the older, more limited interactor behavior is enabled by default. To disable this mode, turn the interactor's Light\-Follow\-Camera flag O\-F\-F, and leave the renderer's Light\-Follow\-Camera flag O\-N.)  
\item {\ttfamily obj.\-Light\-Follow\-Camera\-On ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. If Light\-Follow\-Camera is on, lights that are designated as Headlights or Camera\-Lights will be adjusted to move with this renderer's camera. If Light\-Follow\-Camera is off, the lights will not be adjusted.

(Note\-: In previous versions of vtk, this light-\/tracking functionality was part of the interactors, not the renderer. For backwards compatibility, the older, more limited interactor behavior is enabled by default. To disable this mode, turn the interactor's Light\-Follow\-Camera flag O\-F\-F, and leave the renderer's Light\-Follow\-Camera flag O\-N.)  
\item {\ttfamily obj.\-Light\-Follow\-Camera\-Off ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. If Light\-Follow\-Camera is on, lights that are designated as Headlights or Camera\-Lights will be adjusted to move with this renderer's camera. If Light\-Follow\-Camera is off, the lights will not be adjusted.

(Note\-: In previous versions of vtk, this light-\/tracking functionality was part of the interactors, not the renderer. For backwards compatibility, the older, more limited interactor behavior is enabled by default. To disable this mode, turn the interactor's Light\-Follow\-Camera flag O\-F\-F, and leave the renderer's Light\-Follow\-Camera flag O\-N.)  
\item {\ttfamily int = obj.\-Get\-Automatic\-Light\-Creation ()} -\/ Turn on/off a flag which disables the automatic light creation capability. Normally in V\-T\-K if no lights are associated with the renderer, then a light is automatically created. However, in special circumstances this feature is undesirable, so the following boolean is provided to disable automatic light creation. (Turn Automatic\-Light\-Creation off if you do not want lights to be created.)  
\item {\ttfamily obj.\-Set\-Automatic\-Light\-Creation (int )} -\/ Turn on/off a flag which disables the automatic light creation capability. Normally in V\-T\-K if no lights are associated with the renderer, then a light is automatically created. However, in special circumstances this feature is undesirable, so the following boolean is provided to disable automatic light creation. (Turn Automatic\-Light\-Creation off if you do not want lights to be created.)  
\item {\ttfamily obj.\-Automatic\-Light\-Creation\-On ()} -\/ Turn on/off a flag which disables the automatic light creation capability. Normally in V\-T\-K if no lights are associated with the renderer, then a light is automatically created. However, in special circumstances this feature is undesirable, so the following boolean is provided to disable automatic light creation. (Turn Automatic\-Light\-Creation off if you do not want lights to be created.)  
\item {\ttfamily obj.\-Automatic\-Light\-Creation\-Off ()} -\/ Turn on/off a flag which disables the automatic light creation capability. Normally in V\-T\-K if no lights are associated with the renderer, then a light is automatically created. However, in special circumstances this feature is undesirable, so the following boolean is provided to disable automatic light creation. (Turn Automatic\-Light\-Creation off if you do not want lights to be created.)  
\item {\ttfamily int = obj.\-Update\-Lights\-Geometry\-To\-Follow\-Camera (void )} -\/ Ask the lights in the scene that are not in world space (for instance, Headlights or Camera\-Lights that are attached to the camera) to update their geometry to match the active camera.  
\item {\ttfamily vtk\-Volume\-Collection = obj.\-Get\-Volumes ()} -\/ Return the collection of volumes.  
\item {\ttfamily vtk\-Actor\-Collection = obj.\-Get\-Actors ()} -\/ Return any actors in this renderer.  
\item {\ttfamily obj.\-Set\-Active\-Camera (vtk\-Camera )} -\/ Specify the camera to use for this renderer.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Active\-Camera ()} -\/ Get the current camera. If there is not camera assigned to the renderer already, a new one is created automatically. This does {\itshape not} reset the camera.  
\item {\ttfamily vtk\-Camera = obj.\-Make\-Camera ()} -\/ Create a new Camera sutible for use with this type of Renderer. For example, a vtk\-Mesa\-Renderer should create a vtk\-Mesa\-Camera in this function. The default is to just call vtk\-Camera\-::\-New.  
\item {\ttfamily obj.\-Set\-Erase (int )} -\/ When this flag is off, the renderer will not erase the background or the Zbuffer. It is used to have overlapping renderers. Both the Render\-Window Erase and Render Erase must be on for the camera to clear the renderer. By default, Erase is on.  
\item {\ttfamily int = obj.\-Get\-Erase ()} -\/ When this flag is off, the renderer will not erase the background or the Zbuffer. It is used to have overlapping renderers. Both the Render\-Window Erase and Render Erase must be on for the camera to clear the renderer. By default, Erase is on.  
\item {\ttfamily obj.\-Erase\-On ()} -\/ When this flag is off, the renderer will not erase the background or the Zbuffer. It is used to have overlapping renderers. Both the Render\-Window Erase and Render Erase must be on for the camera to clear the renderer. By default, Erase is on.  
\item {\ttfamily obj.\-Erase\-Off ()} -\/ When this flag is off, the renderer will not erase the background or the Zbuffer. It is used to have overlapping renderers. Both the Render\-Window Erase and Render Erase must be on for the camera to clear the renderer. By default, Erase is on.  
\item {\ttfamily obj.\-Set\-Draw (int )} -\/ When this flag is off, render commands are ignored. It is used to either multiplex a vtk\-Render\-Window or render only part of a vtk\-Render\-Window. By default, Draw is on.  
\item {\ttfamily int = obj.\-Get\-Draw ()} -\/ When this flag is off, render commands are ignored. It is used to either multiplex a vtk\-Render\-Window or render only part of a vtk\-Render\-Window. By default, Draw is on.  
\item {\ttfamily obj.\-Draw\-On ()} -\/ When this flag is off, render commands are ignored. It is used to either multiplex a vtk\-Render\-Window or render only part of a vtk\-Render\-Window. By default, Draw is on.  
\item {\ttfamily obj.\-Draw\-Off ()} -\/ When this flag is off, render commands are ignored. It is used to either multiplex a vtk\-Render\-Window or render only part of a vtk\-Render\-Window. By default, Draw is on.  
\item {\ttfamily obj.\-Add\-Culler (vtk\-Culler )} -\/ Add an culler to the list of cullers.  
\item {\ttfamily obj.\-Remove\-Culler (vtk\-Culler )} -\/ Remove an actor from the list of cullers.  
\item {\ttfamily vtk\-Culler\-Collection = obj.\-Get\-Cullers ()} -\/ Return the collection of cullers.  
\item {\ttfamily obj.\-Set\-Ambient (double , double , double )} -\/ Set the intensity of ambient lighting.  
\item {\ttfamily obj.\-Set\-Ambient (double a\mbox{[}3\mbox{]})} -\/ Set the intensity of ambient lighting.  
\item {\ttfamily double = obj. Get\-Ambient ()} -\/ Set the intensity of ambient lighting.  
\item {\ttfamily obj.\-Set\-Allocated\-Render\-Time (double )} -\/ Set/\-Get the amount of time this renderer is allowed to spend rendering its scene. This is used by vtk\-L\-O\-D\-Actor's.  
\item {\ttfamily double = obj.\-Get\-Allocated\-Render\-Time ()} -\/ Set/\-Get the amount of time this renderer is allowed to spend rendering its scene. This is used by vtk\-L\-O\-D\-Actor's.  
\item {\ttfamily double = obj.\-Get\-Time\-Factor ()} -\/ Get the ratio between allocated time and actual render time. Time\-Factor has been taken out of the render process. It is still computed in case someone finds it useful. It may be taken away in the future.  
\item {\ttfamily obj.\-Render ()} -\/ C\-A\-L\-L\-E\-D B\-Y vtk\-Render\-Window O\-N\-L\-Y. End-\/user pass your way and call vtk\-Render\-Window\-::\-Render(). Create an image. This is a superclass method which will in turn call the Device\-Render method of Subclasses of vtk\-Renderer.  
\item {\ttfamily obj.\-Device\-Render ()} -\/ Create an image. Subclasses of vtk\-Renderer must implement this method.  
\item {\ttfamily obj.\-Device\-Render\-Translucent\-Polygonal\-Geometry ()} -\/ Render translucent polygonal geometry. Default implementation just call Update\-Translucent\-Polygonal\-Geometry(). Subclasses of vtk\-Renderer that can deal with depth peeling must override this method. It updates boolean ivar Last\-Rendering\-Used\-Depth\-Peeling.  
\item {\ttfamily obj.\-Clear ()} -\/ Clear the image to the background color.  
\item {\ttfamily int = obj.\-Visible\-Actor\-Count ()} -\/ Returns the number of visible actors.  
\item {\ttfamily int = obj.\-Visible\-Volume\-Count ()} -\/ Returns the number of visible volumes.  
\item {\ttfamily obj.\-Compute\-Visible\-Prop\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Compute the bounding box of all the visible props Used in Reset\-Camera() and Reset\-Camera\-Clipping\-Range()  
\item {\ttfamily double = obj.\-Compute\-Visible\-Prop\-Bounds ()} -\/ Wrapper-\/friendly version of Compute\-Visible\-Prop\-Bounds  
\item {\ttfamily obj.\-Reset\-Camera\-Clipping\-Range ()} -\/ Reset the camera clipping range based on the bounds of the visible actors. This ensures that no props are cut off  
\item {\ttfamily obj.\-Reset\-Camera\-Clipping\-Range (double bounds\mbox{[}6\mbox{]})} -\/ Reset the camera clipping range based on a bounding box. This method is called from Reset\-Camera\-Clipping\-Range()  
\item {\ttfamily obj.\-Reset\-Camera\-Clipping\-Range (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Reset the camera clipping range based on a bounding box. This method is called from Reset\-Camera\-Clipping\-Range()  
\item {\ttfamily obj.\-Set\-Near\-Clipping\-Plane\-Tolerance (double )} -\/ Specify tolerance for near clipping plane distance to the camera as a percentage of the far clipping plane distance. By default this will be set to 0.\-01 for 16 bit zbuffers and 0.\-001 for higher depth z buffers  
\item {\ttfamily double = obj.\-Get\-Near\-Clipping\-Plane\-Tolerance\-Min\-Value ()} -\/ Specify tolerance for near clipping plane distance to the camera as a percentage of the far clipping plane distance. By default this will be set to 0.\-01 for 16 bit zbuffers and 0.\-001 for higher depth z buffers  
\item {\ttfamily double = obj.\-Get\-Near\-Clipping\-Plane\-Tolerance\-Max\-Value ()} -\/ Specify tolerance for near clipping plane distance to the camera as a percentage of the far clipping plane distance. By default this will be set to 0.\-01 for 16 bit zbuffers and 0.\-001 for higher depth z buffers  
\item {\ttfamily double = obj.\-Get\-Near\-Clipping\-Plane\-Tolerance ()} -\/ Specify tolerance for near clipping plane distance to the camera as a percentage of the far clipping plane distance. By default this will be set to 0.\-01 for 16 bit zbuffers and 0.\-001 for higher depth z buffers  
\item {\ttfamily obj.\-Reset\-Camera ()} -\/ Automatically set up the camera based on the visible actors. The camera will reposition itself to view the center point of the actors, and move along its initial view plane normal (i.\-e., vector defined from camera position to focal point) so that all of the actors can be seen.  
\item {\ttfamily obj.\-Reset\-Camera (double bounds\mbox{[}6\mbox{]})} -\/ Automatically set up the camera based on a specified bounding box (xmin,xmax, ymin,ymax, zmin,zmax). Camera will reposition itself so that its focal point is the center of the bounding box, and adjust its distance and position to preserve its initial view plane normal (i.\-e., vector defined from camera position to focal point). Note\-: is the view plane is parallel to the view up axis, the view up axis will be reset to one of the three coordinate axes.  
\item {\ttfamily obj.\-Reset\-Camera (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Alternative version of Reset\-Camera(bounds\mbox{[}6\mbox{]});  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window )} -\/ Specify the rendering window in which to draw. This is automatically set when the renderer is created by Make\-Renderer. The user probably shouldn't ever need to call this method.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Specify the rendering window in which to draw. This is automatically set when the renderer is created by Make\-Renderer. The user probably shouldn't ever need to call this method.  
\item {\ttfamily vtk\-Window = obj.\-Get\-V\-T\-K\-Window ()} -\/ Specify the rendering window in which to draw. This is automatically set when the renderer is created by Make\-Renderer. The user probably shouldn't ever need to call this method.  
\item {\ttfamily obj.\-Set\-Backing\-Store (int )} -\/ Turn on/off using backing store. This may cause the re-\/rendering time to be slightly slower when the view changes. But it is much faster when the image has not changed, such as during an expose event.  
\item {\ttfamily int = obj.\-Get\-Backing\-Store ()} -\/ Turn on/off using backing store. This may cause the re-\/rendering time to be slightly slower when the view changes. But it is much faster when the image has not changed, such as during an expose event.  
\item {\ttfamily obj.\-Backing\-Store\-On ()} -\/ Turn on/off using backing store. This may cause the re-\/rendering time to be slightly slower when the view changes. But it is much faster when the image has not changed, such as during an expose event.  
\item {\ttfamily obj.\-Backing\-Store\-Off ()} -\/ Turn on/off using backing store. This may cause the re-\/rendering time to be slightly slower when the view changes. But it is much faster when the image has not changed, such as during an expose event.  
\item {\ttfamily obj.\-Set\-Interactive (int )} -\/ Turn on/off interactive status. An interactive renderer is one that can receive events from an interactor. Should only be set if there are multiple renderers in the same section of the viewport.  
\item {\ttfamily int = obj.\-Get\-Interactive ()} -\/ Turn on/off interactive status. An interactive renderer is one that can receive events from an interactor. Should only be set if there are multiple renderers in the same section of the viewport.  
\item {\ttfamily obj.\-Interactive\-On ()} -\/ Turn on/off interactive status. An interactive renderer is one that can receive events from an interactor. Should only be set if there are multiple renderers in the same section of the viewport.  
\item {\ttfamily obj.\-Interactive\-Off ()} -\/ Turn on/off interactive status. An interactive renderer is one that can receive events from an interactor. Should only be set if there are multiple renderers in the same section of the viewport.  
\item {\ttfamily obj.\-Set\-Layer (int )} -\/ Set/\-Get the layer that this renderer belongs to. This is only used if there are layered renderers.  
\item {\ttfamily int = obj.\-Get\-Layer ()} -\/ Set/\-Get the layer that this renderer belongs to. This is only used if there are layered renderers.  
\item {\ttfamily obj.\-Set\-Preserve\-Depth\-Buffer (int )} -\/ Normally a renderer is treated as transparent if Layer $>$ 0. To treat a renderer at Layer 0 as transparent, set this flag to true.  
\item {\ttfamily int = obj.\-Get\-Preserve\-Depth\-Buffer ()} -\/ Normally a renderer is treated as transparent if Layer $>$ 0. To treat a renderer at Layer 0 as transparent, set this flag to true.  
\item {\ttfamily obj.\-Preserve\-Depth\-Buffer\-On ()} -\/ Normally a renderer is treated as transparent if Layer $>$ 0. To treat a renderer at Layer 0 as transparent, set this flag to true.  
\item {\ttfamily obj.\-Preserve\-Depth\-Buffer\-Off ()} -\/ Normally a renderer is treated as transparent if Layer $>$ 0. To treat a renderer at Layer 0 as transparent, set this flag to true.  
\item {\ttfamily int = obj.\-Transparent ()} -\/ Returns a boolean indicating if this renderer is transparent. It is transparent if it is not in the deepest layer of its render window.  
\item {\ttfamily obj.\-World\-To\-View ()} -\/ Convert world point coordinates to view coordinates.  
\item {\ttfamily obj.\-View\-To\-World ()} -\/ Convert view point coordinates to world coordinates.  
\item {\ttfamily double = obj.\-Get\-Z (int x, int y)} -\/ Given a pixel location, return the Z value. The z value is normalized (0,1) between the front and back clipping planes.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time of the renderer also considering its ivars.  
\item {\ttfamily double = obj.\-Get\-Last\-Render\-Time\-In\-Seconds ()} -\/ Get the time required, in seconds, for the last Render call.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Props\-Rendered ()} -\/ Should be used internally only during a render Get the number of props that were rendered using a Render\-Opaque\-Geometry or Render\-Translucent\-Polygonal\-Geometry call. This is used to know if something is in the frame buffer.  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Pick\-Prop (double selection\-X, double selection\-Y)} -\/ Return the prop (via a vtk\-Assembly\-Path) that has the highest z value at the given x, y position in the viewport. Basically, the top most prop that renders the pixel at selection\-X, selection\-Y will be returned. If nothing was picked then N\-U\-L\-L is returned. This method selects from the renderers Prop list.  
\item {\ttfamily vtk\-Assembly\-Path = obj.\-Pick\-Prop (double selection\-X1, double selection\-Y1, double selection\-X2, double selection\-Y2)} -\/ Return the prop (via a vtk\-Assembly\-Path) that has the highest z value at the given x, y position in the viewport. Basically, the top most prop that renders the pixel at selection\-X, selection\-Y will be returned. If nothing was picked then N\-U\-L\-L is returned. This method selects from the renderers Prop list.  
\item {\ttfamily obj.\-Stereo\-Midpoint ()} -\/ Do anything necessary between rendering the left and right viewpoints in a stereo render. Doesn't do anything except in the derived vtk\-Ice\-T\-Renderer in Para\-View.  
\item {\ttfamily double = obj.\-Get\-Tiled\-Aspect\-Ratio ()} -\/ Compute the aspect ratio of this renderer for the current tile. When tiled displays are used the aspect ratio of the renderer for a given tile may be diferent that the aspect ratio of the renderer when rendered in it entirity  
\item {\ttfamily int = obj.\-Is\-Active\-Camera\-Created ()} -\/ Turn on/off rendering of translucent material with depth peeling technique. The render window must have alpha bits (ie call Set\-Alpha\-Bit\-Planes(1)) and no multisample buffer (ie call Set\-Multi\-Samples(0) ) to support depth peeling. If Use\-Depth\-Peeling is on and the G\-P\-U supports it, depth peeling is used for rendering translucent materials. If Use\-Depth\-Peeling is off, alpha blending is used. Initial value is off.  
\item {\ttfamily obj.\-Set\-Use\-Depth\-Peeling (int )} -\/ Turn on/off rendering of translucent material with depth peeling technique. The render window must have alpha bits (ie call Set\-Alpha\-Bit\-Planes(1)) and no multisample buffer (ie call Set\-Multi\-Samples(0) ) to support depth peeling. If Use\-Depth\-Peeling is on and the G\-P\-U supports it, depth peeling is used for rendering translucent materials. If Use\-Depth\-Peeling is off, alpha blending is used. Initial value is off.  
\item {\ttfamily int = obj.\-Get\-Use\-Depth\-Peeling ()} -\/ Turn on/off rendering of translucent material with depth peeling technique. The render window must have alpha bits (ie call Set\-Alpha\-Bit\-Planes(1)) and no multisample buffer (ie call Set\-Multi\-Samples(0) ) to support depth peeling. If Use\-Depth\-Peeling is on and the G\-P\-U supports it, depth peeling is used for rendering translucent materials. If Use\-Depth\-Peeling is off, alpha blending is used. Initial value is off.  
\item {\ttfamily obj.\-Use\-Depth\-Peeling\-On ()} -\/ Turn on/off rendering of translucent material with depth peeling technique. The render window must have alpha bits (ie call Set\-Alpha\-Bit\-Planes(1)) and no multisample buffer (ie call Set\-Multi\-Samples(0) ) to support depth peeling. If Use\-Depth\-Peeling is on and the G\-P\-U supports it, depth peeling is used for rendering translucent materials. If Use\-Depth\-Peeling is off, alpha blending is used. Initial value is off.  
\item {\ttfamily obj.\-Use\-Depth\-Peeling\-Off ()} -\/ Turn on/off rendering of translucent material with depth peeling technique. The render window must have alpha bits (ie call Set\-Alpha\-Bit\-Planes(1)) and no multisample buffer (ie call Set\-Multi\-Samples(0) ) to support depth peeling. If Use\-Depth\-Peeling is on and the G\-P\-U supports it, depth peeling is used for rendering translucent materials. If Use\-Depth\-Peeling is off, alpha blending is used. Initial value is off.  
\item {\ttfamily obj.\-Set\-Occlusion\-Ratio (double )} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio\-Min\-Value ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio\-Max\-Value ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily double = obj.\-Get\-Occlusion\-Ratio ()} -\/ In case of use of depth peeling technique for rendering translucent material, define the threshold under which the algorithm stops to iterate over peel layers. This is the ratio of the number of pixels that have been touched by the last layer over the total number of pixels of the viewport area. Initial value is 0.\-0, meaning rendering have to be exact. Greater values may speed-\/up the rendering with small impact on the quality.  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Peels (int )} -\/ In case of depth peeling, define the maximum number of peeling layers. Initial value is 4. A special value of 0 means no maximum limit. It has to be a positive value.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Peels ()} -\/ In case of depth peeling, define the maximum number of peeling layers. Initial value is 4. A special value of 0 means no maximum limit. It has to be a positive value.  
\item {\ttfamily int = obj.\-Get\-Last\-Rendering\-Used\-Depth\-Peeling ()} -\/ Tells if the last call to Device\-Render\-Translucent\-Polygonal\-Geometry() actually used depth peeling. Initial value is false.  
\item {\ttfamily obj.\-Set\-Delegate (vtk\-Renderer\-Delegate d)} -\/ Set/\-Get a custom Render call. Allows to hook a Render call from an external project.\-It will be used in place of vtk\-Renderer\-::\-Render() if it is not N\-U\-L\-L and its Used ivar is set to true. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Renderer\-Delegate = obj.\-Get\-Delegate ()} -\/ Set/\-Get a custom Render call. Allows to hook a Render call from an external project.\-It will be used in place of vtk\-Renderer\-::\-Render() if it is not N\-U\-L\-L and its Used ivar is set to true. Initial value is N\-U\-L\-L.  
\item {\ttfamily obj.\-Set\-Pass (vtk\-Render\-Pass p)} -\/ Set/\-Get a custom render pass. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Pass ()} -\/ Set/\-Get a custom render pass. Initial value is N\-U\-L\-L.  
\item {\ttfamily vtk\-Hardware\-Selector = obj.\-Get\-Selector ()} -\/ Get the current hardware selector. If the Selector is set, it implies the current render pass is for selection. Mappers/\-Properties may choose to behave differently when rendering for hardware selection.  
\item {\ttfamily obj.\-Set\-Background\-Texture (vtk\-Texture )} -\/ Set/\-Get the texture to be used for the background. If set and enabled this gets the priority over the gradient background.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Background\-Texture ()} -\/ Set/\-Get the texture to be used for the background. If set and enabled this gets the priority over the gradient background.  
\item {\ttfamily obj.\-Set\-Textured\-Background (bool )} -\/ Set/\-Get whether this viewport should have a textured background. Default is off.  
\item {\ttfamily bool = obj.\-Get\-Textured\-Background ()} -\/ Set/\-Get whether this viewport should have a textured background. Default is off.  
\item {\ttfamily obj.\-Textured\-Background\-On ()} -\/ Set/\-Get whether this viewport should have a textured background. Default is off.  
\item {\ttfamily obj.\-Textured\-Background\-Off ()} -\/ Set/\-Get whether this viewport should have a textured background. Default is off.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderercollection}{}\section{vtk\-Renderer\-Collection}\label{vtkrendering_vtkrenderercollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Renderer\-Collection represents and provides methods to manipulate a list of renderers (i.\-e., vtk\-Renderer and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Renderer\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRendererCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Renderer\-Collection 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\-Renderer\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Renderer\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Renderer\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Renderer a)} -\/ Get the next Renderer in the list. Return N\-U\-L\-L when at the end of the list.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Next\-Item ()} -\/ Get the next Renderer in the list. Return N\-U\-L\-L when at the end of the list.  
\item {\ttfamily obj.\-Render ()} -\/ Forward the Render() method to each renderer in the list.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-First\-Renderer ()} -\/ Get the first Renderer in the list. Return N\-U\-L\-L when at the end of the list.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrendererdelegate}{}\section{vtk\-Renderer\-Delegate}\label{vtkrendering_vtkrendererdelegate}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Renderer\-Delegate is an abstract class with a pure virtual method Render. This method replaces the Render method of vtk\-Renderer to allow custom rendering from an external project. A Renderer\-Delegate is connected to a vtk\-Renderer with method Set\-Delegate(). An external project just has to provide a concrete implementation of vtk\-Renderer\-Delegate.

To create an instance of class vtk\-Renderer\-Delegate, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRendererDelegate
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Renderer\-Delegate 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\-Renderer\-Delegate class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Renderer\-Delegate = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Renderer\-Delegate = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer r)} -\/ Render the props of vtk\-Renderer if Used is on.  
\item {\ttfamily obj.\-Set\-Used (bool )} -\/ Tells if the delegate has to be used by the renderer or not. Initial value is off.  
\item {\ttfamily bool = obj.\-Get\-Used ()} -\/ Tells if the delegate has to be used by the renderer or not. Initial value is off.  
\item {\ttfamily obj.\-Used\-On ()} -\/ Tells if the delegate has to be used by the renderer or not. Initial value is off.  
\item {\ttfamily obj.\-Used\-Off ()} -\/ Tells if the delegate has to be used by the renderer or not. Initial value is off.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderersource}{}\section{vtk\-Renderer\-Source}\label{vtkrendering_vtkrenderersource}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Renderer\-Source is a source object that gets its input from a renderer and converts it to structured points. This can then be used in a visualization pipeline. You must explicitly send a Modify() to this object to get it to reload its data from the renderer. Consider using vtk\-Window\-To\-Image\-Filter instead of this class.

The data placed into the output is the renderer's image rgb values. Optionally, you can also grab the image depth (e.\-g., z-\/buffer) values, and place then into the output (point) field data.

To create an instance of class vtk\-Renderer\-Source, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRendererSource
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Renderer\-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\-Renderer\-Source class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Renderer\-Source = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Renderer\-Source = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the Renderer.  
\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 obj.\-Set\-Whole\-Window (int )} -\/ Use the entire Render\-Window as a data source or just the Renderer. The default is zero, just the Renderer.  
\item {\ttfamily int = obj.\-Get\-Whole\-Window ()} -\/ Use the entire Render\-Window as a data source or just the Renderer. The default is zero, just the Renderer.  
\item {\ttfamily obj.\-Whole\-Window\-On ()} -\/ Use the entire Render\-Window as a data source or just the Renderer. The default is zero, just the Renderer.  
\item {\ttfamily obj.\-Whole\-Window\-Off ()} -\/ Use the entire Render\-Window as a data source or just the Renderer. The default is zero, just the Renderer.  
\item {\ttfamily obj.\-Set\-Render\-Flag (int )} -\/ If this flag is on, the Executing causes a render first.  
\item {\ttfamily int = obj.\-Get\-Render\-Flag ()} -\/ If this flag is on, the Executing causes a render first.  
\item {\ttfamily obj.\-Render\-Flag\-On ()} -\/ If this flag is on, the Executing causes a render first.  
\item {\ttfamily obj.\-Render\-Flag\-Off ()} -\/ If this flag is on, the Executing causes a render first.  
\item {\ttfamily obj.\-Set\-Depth\-Values (int )} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed into a field data attributes named \char`\"{}\-Z\-Buffer\char`\"{} .  
\item {\ttfamily int = obj.\-Get\-Depth\-Values ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed into a field data attributes named \char`\"{}\-Z\-Buffer\char`\"{} .  
\item {\ttfamily obj.\-Depth\-Values\-On ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed into a field data attributes named \char`\"{}\-Z\-Buffer\char`\"{} .  
\item {\ttfamily obj.\-Depth\-Values\-Off ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed into a field data attributes named \char`\"{}\-Z\-Buffer\char`\"{} .  
\item {\ttfamily obj.\-Set\-Depth\-Values\-In\-Scalars (int )} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed in the scalars as a fourth Z component (shift and scaled to map the full 0..255 range).  
\item {\ttfamily int = obj.\-Get\-Depth\-Values\-In\-Scalars ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed in the scalars as a fourth Z component (shift and scaled to map the full 0..255 range).  
\item {\ttfamily obj.\-Depth\-Values\-In\-Scalars\-On ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed in the scalars as a fourth Z component (shift and scaled to map the full 0..255 range).  
\item {\ttfamily obj.\-Depth\-Values\-In\-Scalars\-Off ()} -\/ A boolean value to control whether to grab z-\/buffer (i.\-e., depth values) along with the image data. The z-\/buffer data is placed in the scalars as a fourth Z component (shift and scaled to map the full 0..255 range).  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderpass}{}\section{vtk\-Render\-Pass}\label{vtkrendering_vtkrenderpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Pass is a deferred class with a simple deferred method Render. This method performs a rendering pass of the scene described in vtk\-Render\-State. Subclasses define what really happens during rendering.

Directions to write a subclass of vtk\-Render\-Pass\-: It is up to the subclass to decide if it needs to delegate part of its job to some other vtk\-Render\-Pass objects (\char`\"{}delegates\char`\"{}).
\begin{DoxyItemize}
\item The subclass has to define ivar to set/get its delegates.
\item The documentation of the subclass has to describe\-:
\begin{DoxyItemize}
\item what each delegate is supposed to perform
\item if a delegate is supposed to be used once or multiple times
\item what it expects to have in the framebuffer before starting (status of colorbuffers, depth buffer, stencil buffer)
\item what it will change in the framebuffer.
\end{DoxyItemize}
\item A pass cannot modify the vtk\-Render\-State where it will perform but it can build a new vtk\-Render\-State (it can change the Frame\-Buffer, change the prop array, changed the required prop properties keys (usually adding some to a copy of the existing list) but it has to keep the same vtk\-Renderer object), make it current and pass it to its delegate.
\item at the end of the execution of Render, the pass has to ensure the current vtk\-Render\-State is the one it has in argument.
\end{DoxyItemize}

To create an instance of class vtk\-Render\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Pass 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\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Rendered\-Props ()} -\/ Number of props rendered at the last Render call.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. Default implementation is empty. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderpasscollection}{}\section{vtk\-Render\-Pass\-Collection}\label{vtkrendering_vtkrenderpasscollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Pass\-Collection represents a list of Render\-Passes (i.\-e., vtk\-Render\-Pass and subclasses) and provides methods to manipulate the list. The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Render\-Pass\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderPassCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Pass\-Collection 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\-Pass\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Pass\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Pass\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Render\-Pass pass)} -\/ Add an Render\-Pass to the list.  
\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Next\-Render\-Pass ()} -\/ Get the next Render\-Pass in the list.  
\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Last\-Render\-Pass ()} -\/ Get the last Render\-Pass in the list.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderwindow}{}\section{vtk\-Render\-Window}\label{vtkrendering_vtkrenderwindow}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Window is an abstract object to specify the behavior of a rendering window. A rendering window is a window in a graphical user interface where renderers draw their images. Methods are provided to synchronize the rendering process, set window size, and control double buffering. The window also allows rendering in stereo. The interlaced render stereo type is for output to a V\-Rex stereo projector. All of the odd horizontal lines are from the left eye, and the even lines are from the right eye. The user has to make the render window aligned with the V\-Rex projector, or the eye will be swapped.

To create an instance of class vtk\-Render\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Window 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\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Renderer (vtk\-Renderer )} -\/ Add a renderer to the list of renderers.  
\item {\ttfamily obj.\-Remove\-Renderer (vtk\-Renderer )} -\/ Remove a renderer from the list of renderers.  
\item {\ttfamily int = obj.\-Has\-Renderer (vtk\-Renderer )} -\/ Query if a renderer is in the list of renderers.  
\item {\ttfamily vtk\-Renderer\-Collection = obj.\-Get\-Renderers ()} -\/ Return the collection of renderers in the render window.  
\item {\ttfamily obj.\-Render ()} -\/ Ask each renderer owned by this Render\-Window to render its image and synchronize this process.  
\item {\ttfamily obj.\-Start ()} -\/ Initialize the rendering process.  
\item {\ttfamily obj.\-Finalize ()} -\/ Finalize the rendering process.  
\item {\ttfamily obj.\-Frame ()} -\/ A termination method performed at the end of the rendering process to do things like swapping buffers (if necessary) or similar actions.  
\item {\ttfamily obj.\-Wait\-For\-Completion ()} -\/ Block the thread until the actual rendering is finished(). Useful for measurement only.  
\item {\ttfamily obj.\-Copy\-Result\-Frame ()} -\/ Performed at the end of the rendering process to generate image. This is typically done right before swapping buffers.  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-Make\-Render\-Window\-Interactor ()} -\/ Create an interactor to control renderers in this window. We need to know what type of interactor to create, because we might be in X Windows or M\-S Windows.  
\item {\ttfamily obj.\-Hide\-Cursor ()} -\/ Hide or Show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead. Set cursor position in window (note that (0,0) is the lower left corner).  
\item {\ttfamily obj.\-Show\-Cursor ()} -\/ Hide or Show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead. Set cursor position in window (note that (0,0) is the lower left corner).  
\item {\ttfamily obj.\-Set\-Cursor\-Position (int , int )} -\/ Hide or Show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead. Set cursor position in window (note that (0,0) is the lower left corner).  
\item {\ttfamily obj.\-Set\-Current\-Cursor (int )} -\/ Change the shape of the cursor.  
\item {\ttfamily int = obj.\-Get\-Current\-Cursor ()} -\/ Change the shape of the cursor.  
\item {\ttfamily obj.\-Set\-Full\-Screen (int )} -\/ Turn on/off rendering full screen window size.  
\item {\ttfamily int = obj.\-Get\-Full\-Screen ()} -\/ Turn on/off rendering full screen window size.  
\item {\ttfamily obj.\-Full\-Screen\-On ()} -\/ Turn on/off rendering full screen window size.  
\item {\ttfamily obj.\-Full\-Screen\-Off ()} -\/ Turn on/off rendering full screen window size.  
\item {\ttfamily obj.\-Set\-Borders (int )} -\/ Turn on/off window manager borders. Typically, you shouldn't turn the borders off, because that bypasses the window manager and can cause undesirable behavior.  
\item {\ttfamily int = obj.\-Get\-Borders ()} -\/ Turn on/off window manager borders. Typically, you shouldn't turn the borders off, because that bypasses the window manager and can cause undesirable behavior.  
\item {\ttfamily obj.\-Borders\-On ()} -\/ Turn on/off window manager borders. Typically, you shouldn't turn the borders off, because that bypasses the window manager and can cause undesirable behavior.  
\item {\ttfamily obj.\-Borders\-Off ()} -\/ Turn on/off window manager borders. Typically, you shouldn't turn the borders off, because that bypasses the window manager and can cause undesirable behavior.  
\item {\ttfamily int = obj.\-Get\-Stereo\-Capable\-Window ()} -\/ Prescribe that the window be created in a stereo-\/capable mode. This method must be called before the window is realized. Default is off.  
\item {\ttfamily obj.\-Stereo\-Capable\-Window\-On ()} -\/ Prescribe that the window be created in a stereo-\/capable mode. This method must be called before the window is realized. Default is off.  
\item {\ttfamily obj.\-Stereo\-Capable\-Window\-Off ()} -\/ Prescribe that the window be created in a stereo-\/capable mode. This method must be called before the window is realized. Default is off.  
\item {\ttfamily obj.\-Set\-Stereo\-Capable\-Window (int capable)} -\/ Prescribe that the window be created in a stereo-\/capable mode. This method must be called before the window is realized. Default is off.  
\item {\ttfamily int = obj.\-Get\-Stereo\-Render ()} -\/ Turn on/off stereo rendering.  
\item {\ttfamily obj.\-Set\-Stereo\-Render (int stereo)} -\/ Turn on/off stereo rendering.  
\item {\ttfamily obj.\-Stereo\-Render\-On ()} -\/ Turn on/off stereo rendering.  
\item {\ttfamily obj.\-Stereo\-Render\-Off ()} -\/ Turn on/off stereo rendering.  
\item {\ttfamily obj.\-Set\-Alpha\-Bit\-Planes (int )} -\/ Turn on/off the use of alpha bitplanes.  
\item {\ttfamily int = obj.\-Get\-Alpha\-Bit\-Planes ()} -\/ Turn on/off the use of alpha bitplanes.  
\item {\ttfamily obj.\-Alpha\-Bit\-Planes\-On ()} -\/ Turn on/off the use of alpha bitplanes.  
\item {\ttfamily obj.\-Alpha\-Bit\-Planes\-Off ()} -\/ Turn on/off the use of alpha bitplanes.  
\item {\ttfamily obj.\-Set\-Point\-Smoothing (int )} -\/ Turn on/off point smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily int = obj.\-Get\-Point\-Smoothing ()} -\/ Turn on/off point smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Point\-Smoothing\-On ()} -\/ Turn on/off point smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Point\-Smoothing\-Off ()} -\/ Turn on/off point smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Set\-Line\-Smoothing (int )} -\/ Turn on/off line smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily int = obj.\-Get\-Line\-Smoothing ()} -\/ Turn on/off line smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Line\-Smoothing\-On ()} -\/ Turn on/off line smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Line\-Smoothing\-Off ()} -\/ Turn on/off line smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Set\-Polygon\-Smoothing (int )} -\/ Turn on/off polygon smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily int = obj.\-Get\-Polygon\-Smoothing ()} -\/ Turn on/off polygon smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Polygon\-Smoothing\-On ()} -\/ Turn on/off polygon smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily obj.\-Polygon\-Smoothing\-Off ()} -\/ Turn on/off polygon smoothing. Default is off. This must be applied before the first Render.  
\item {\ttfamily int = obj.\-Get\-Stereo\-Type ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type (int )} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Crystal\-Eyes ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Red\-Blue ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Interlaced ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Left ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Right ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Dresden ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Anaglyph ()} -\/ Set/\-Get what type of stereo rendering to use. Crystal\-Eyes mode uses frame-\/sequential capabilities available in Open\-G\-L to drive L\-C\-D shutter glasses and stereo projectors. Red\-Blue mode is a simple type of stereo for use with red-\/blue glasses. Anaglyph mode is a superset of Red\-Blue mode, but the color output channels can be configured using the Anaglyph\-Color\-Mask and the color of the original image can be (somewhat) maintained using Anaglyph\-Color\-Saturation; the default colors for Anaglyph mode is red-\/cyan. Interlaced stereo mode produces a composite image where horizontal lines alternate between left and right views. Stereo\-Left and Stereo\-Right modes choose one or the other stereo view. Dresden mode is yet another stereoscopic interleaving.  
\item {\ttfamily obj.\-Set\-Stereo\-Type\-To\-Checkerboard ()}  
\item {\ttfamily string = obj.\-Get\-Stereo\-Type\-As\-String ()}  
\item {\ttfamily obj.\-Stereo\-Update ()} -\/ Update the system, if needed, due to stereo rendering. For some stereo methods, subclasses might need to switch some hardware settings here.  
\item {\ttfamily obj.\-Stereo\-Midpoint ()} -\/ Intermediate method performs operations required between the rendering of the left and right eye.  
\item {\ttfamily obj.\-Stereo\-Render\-Complete ()} -\/ Handles work required once both views have been rendered when using stereo rendering.  
\item {\ttfamily obj.\-Set\-Anaglyph\-Color\-Saturation (float )}  
\item {\ttfamily float = obj.\-Get\-Anaglyph\-Color\-Saturation\-Min\-Value ()}  
\item {\ttfamily float = obj.\-Get\-Anaglyph\-Color\-Saturation\-Max\-Value ()}  
\item {\ttfamily float = obj.\-Get\-Anaglyph\-Color\-Saturation ()}  
\item {\ttfamily obj.\-Set\-Anaglyph\-Color\-Mask (int , int )}  
\item {\ttfamily obj.\-Set\-Anaglyph\-Color\-Mask (int a\mbox{[}2\mbox{]})}  
\item {\ttfamily int = obj. Get\-Anaglyph\-Color\-Mask ()}  
\item {\ttfamily obj.\-Window\-Remap ()} -\/ Remap the rendering window. This probably only works on U\-N\-I\-X right now. It is useful for changing properties that can't normally be changed once the window is up.  
\item {\ttfamily obj.\-Set\-Swap\-Buffers (int )} -\/ Turn on/off buffer swapping between images.  
\item {\ttfamily int = obj.\-Get\-Swap\-Buffers ()} -\/ Turn on/off buffer swapping between images.  
\item {\ttfamily obj.\-Swap\-Buffers\-On ()} -\/ Turn on/off buffer swapping between images.  
\item {\ttfamily obj.\-Swap\-Buffers\-Off ()} -\/ Turn on/off buffer swapping between images.  
\item {\ttfamily int = obj.\-Set\-Pixel\-Data (int x, int y, int x2, int y2, string data, int front)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B\-R\-G\-B. The front argument indicates if the front buffer should be used or the back buffer. It is the caller's responsibility to delete the resulting array. It is very important to realize that the memory in this array is organized from the bottom of the window to the top. The origin of the screen is in the lower left corner. The y axis increases as you go up the screen. So the storage of pixels is from left to right and from bottom to top. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Set\-Pixel\-Data (int x, int y, int x2, int y2, vtk\-Unsigned\-Char\-Array data, int front)} -\/ Set/\-Get the pixel data of an image, transmitted as R\-G\-B\-R\-G\-B\-R\-G\-B. The front argument indicates if the front buffer should be used or the back buffer. It is the caller's responsibility to delete the resulting array. It is very important to realize that the memory in this array is organized from the bottom of the window to the top. The origin of the screen is in the lower left corner. The y axis increases as you go up the screen. So the storage of pixels is from left to right and from bottom to top. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Get\-R\-G\-B\-A\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Float\-Array data)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Pixel\-Data (int x, int y, int x2, int y2, float , int front, int blend)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Pixel\-Data (int , int , int , int , vtk\-Float\-Array , int , int blend)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily obj.\-Release\-R\-G\-B\-A\-Pixel\-Data (float data)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Get\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, int front, vtk\-Unsigned\-Char\-Array data)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, string data, int front, int blend)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Set\-R\-G\-B\-A\-Char\-Pixel\-Data (int x, int y, int x2, int y2, vtk\-Unsigned\-Char\-Array data, int front, int blend)} -\/ Same as Get/\-Set\-Pixel\-Data except that the image also contains an alpha component. The image is transmitted as R\-G\-B\-A\-R\-G\-B\-A\-R\-G\-B\-A... each of which is a float value. The \char`\"{}blend\char`\"{} parameter controls whether the Set\-R\-G\-B\-A\-Pixel\-Data method blends the data with the previous contents of the frame buffer or completely replaces the frame buffer data.  
\item {\ttfamily int = obj.\-Get\-Zbuffer\-Data (int x, int y, int x2, int y2, float z)} -\/ Set/\-Get the zbuffer data from the frame buffer. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Get\-Zbuffer\-Data (int x, int y, int x2, int y2, vtk\-Float\-Array z)} -\/ Set/\-Get the zbuffer data from the frame buffer. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Set\-Zbuffer\-Data (int x, int y, int x2, int y2, float z)} -\/ Set/\-Get the zbuffer data from the frame buffer. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily int = obj.\-Set\-Zbuffer\-Data (int x, int y, int x2, int y2, vtk\-Float\-Array z)} -\/ Set/\-Get the zbuffer data from the frame buffer. (x,y) is any corner of the rectangle. (x2,y2) is its opposite corner on the diagonal.  
\item {\ttfamily float = obj.\-Get\-Zbuffer\-Data\-At\-Point (int x, int y)} -\/ Set the number of frames for doing antialiasing. The default is zero. Typically five or six will yield reasonable results without taking too long.  
\item {\ttfamily int = obj.\-Get\-A\-A\-Frames ()} -\/ Set the number of frames for doing antialiasing. The default is zero. Typically five or six will yield reasonable results without taking too long.  
\item {\ttfamily obj.\-Set\-A\-A\-Frames (int )} -\/ Set the number of frames for doing antialiasing. The default is zero. Typically five or six will yield reasonable results without taking too long.  
\item {\ttfamily int = obj.\-Get\-F\-D\-Frames ()} -\/ Set the number of frames for doing focal depth. The default is zero. Depending on how your scene is organized you can get away with as few as four frames for focal depth or you might need thirty. One thing to note is that if you are using focal depth frames, then you will not need many (if any) frames for antialiasing.  
\item {\ttfamily obj.\-Set\-F\-D\-Frames (int )} -\/ Set the number of frames for doing focal depth. The default is zero. Depending on how your scene is organized you can get away with as few as four frames for focal depth or you might need thirty. One thing to note is that if you are using focal depth frames, then you will not need many (if any) frames for antialiasing.  
\item {\ttfamily int = obj.\-Get\-Sub\-Frames ()} -\/ Set the number of sub frames for doing motion blur. The default is zero. Once this is set greater than one, you will no longer see a new frame for every Render(). If you set this to five, you will need to do five Render() invocations before seeing the result. This isn't very impressive unless something is changing between the Renders. Changing this value may reset the current subframe count.  
\item {\ttfamily obj.\-Set\-Sub\-Frames (int sub\-Frames)} -\/ Set the number of sub frames for doing motion blur. The default is zero. Once this is set greater than one, you will no longer see a new frame for every Render(). If you set this to five, you will need to do five Render() invocations before seeing the result. This isn't very impressive unless something is changing between the Renders. Changing this value may reset the current subframe count.  
\item {\ttfamily int = obj.\-Get\-Never\-Rendered ()} -\/ This flag is set if the window hasn't rendered since it was created  
\item {\ttfamily int = obj.\-Get\-Abort\-Render ()} -\/ This is a flag that can be set to interrupt a rendering that is in progress.  
\item {\ttfamily obj.\-Set\-Abort\-Render (int )} -\/ This is a flag that can be set to interrupt a rendering that is in progress.  
\item {\ttfamily int = obj.\-Get\-In\-Abort\-Check ()} -\/ This is a flag that can be set to interrupt a rendering that is in progress.  
\item {\ttfamily obj.\-Set\-In\-Abort\-Check (int )} -\/ This is a flag that can be set to interrupt a rendering that is in progress.  
\item {\ttfamily int = obj.\-Check\-Abort\-Status ()} -\/ This is a flag that can be set to interrupt a rendering that is in progress.  
\item {\ttfamily int = obj.\-Get\-Is\-Picking ()}  
\item {\ttfamily obj.\-Set\-Is\-Picking (int )}  
\item {\ttfamily obj.\-Is\-Picking\-On ()}  
\item {\ttfamily obj.\-Is\-Picking\-Off ()}  
\item {\ttfamily int = obj.\-Get\-Event\-Pending ()} -\/ Check to see if a mouse button has been pressed. All other events are ignored by this method. Ideally, you want to abort the render on any event which causes the Desired\-Update\-Rate to switch from a high-\/quality rate to a more interactive rate.  
\item {\ttfamily int = obj.\-Check\-In\-Render\-Status ()} -\/ Clear status (after an exception was thrown for example)  
\item {\ttfamily obj.\-Clear\-In\-Render\-Status ()} -\/ Set/\-Get the desired update rate. This is used with the vtk\-L\-O\-D\-Actor class. When using level of detail actors you need to specify what update rate you require. The L\-O\-D\-Actors then will pick the correct resolution to meet your desired update rate in frames per second. A value of zero indicates that they can use all the time they want to.  
\item {\ttfamily obj.\-Set\-Desired\-Update\-Rate (double )} -\/ Set/\-Get the desired update rate. This is used with the vtk\-L\-O\-D\-Actor class. When using level of detail actors you need to specify what update rate you require. The L\-O\-D\-Actors then will pick the correct resolution to meet your desired update rate in frames per second. A value of zero indicates that they can use all the time they want to.  
\item {\ttfamily double = obj.\-Get\-Desired\-Update\-Rate ()} -\/ Set/\-Get the desired update rate. This is used with the vtk\-L\-O\-D\-Actor class. When using level of detail actors you need to specify what update rate you require. The L\-O\-D\-Actors then will pick the correct resolution to meet your desired update rate in frames per second. A value of zero indicates that they can use all the time they want to.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Layers ()} -\/ Get the number of layers for renderers. Each renderer should have its layer set individually. Some algorithms iterate through all layers, so it is not wise to set the number of layers to be exorbitantly large (say bigger than 100).  
\item {\ttfamily obj.\-Set\-Number\-Of\-Layers (int )} -\/ Get the number of layers for renderers. Each renderer should have its layer set individually. Some algorithms iterate through all layers, so it is not wise to set the number of layers to be exorbitantly large (say bigger than 100).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Layers\-Min\-Value ()} -\/ Get the number of layers for renderers. Each renderer should have its layer set individually. Some algorithms iterate through all layers, so it is not wise to set the number of layers to be exorbitantly large (say bigger than 100).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Layers\-Max\-Value ()} -\/ Get the number of layers for renderers. Each renderer should have its layer set individually. Some algorithms iterate through all layers, so it is not wise to set the number of layers to be exorbitantly large (say bigger than 100).  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-Get\-Interactor ()} -\/ Get the interactor associated with this render window  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor )} -\/ Set the interactor to the render window  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ This Method detects loops of Render\-Window$<$-\/$>$Interactor, so objects are freed properly.  
\item {\ttfamily obj.\-Set\-Window\-Info (string )} -\/ Dummy stubs for vtk\-Window A\-P\-I.  
\item {\ttfamily obj.\-Set\-Next\-Window\-Info (string )} -\/ Dummy stubs for vtk\-Window A\-P\-I.  
\item {\ttfamily obj.\-Set\-Parent\-Info (string )} -\/ Dummy stubs for vtk\-Window A\-P\-I.  
\item {\ttfamily obj.\-Make\-Current ()} -\/ Attempt to make this window the current graphics context for the calling thread.  
\item {\ttfamily bool = obj.\-Is\-Current ()} -\/ Tells if this window is the current graphics context for the calling thread.  
\item {\ttfamily obj.\-Set\-Force\-Make\-Current ()} -\/ If called, allow Make\-Current() to skip cache-\/check when called. Make\-Current() reverts to original behavior of cache-\/checking on the next render.  
\item {\ttfamily string = obj.\-Report\-Capabilities ()} -\/ Get report of capabilities for the render window  
\item {\ttfamily int = obj.\-Supports\-Open\-G\-L ()} -\/ Does this render window support Open\-G\-L? 0-\/false, 1-\/true  
\item {\ttfamily int = obj.\-Is\-Direct ()} -\/ Is this render window using hardware acceleration? 0-\/false, 1-\/true  
\item {\ttfamily int = obj.\-Get\-Depth\-Buffer\-Size ()} -\/ This method should be defined by the subclass. How many bits of precision are there in the zbuffer?  
\item {\ttfamily int = obj.\-Get\-Color\-Buffer\-Sizes (int rgba)} -\/ Get the size of the color buffer. Returns 0 if not able to determine otherwise sets R G B and A into buffer.  
\item {\ttfamily vtk\-Painter\-Device\-Adapter = obj.\-Get\-Painter\-Device\-Adapter ()} -\/ Get the vtk\-Painter\-Device\-Adapter which can be used to paint on this render window.  
\item {\ttfamily obj.\-Set\-Multi\-Samples (int )} -\/ Set / Get the number of multisamples to use for hardware antialiasing.  
\item {\ttfamily int = obj.\-Get\-Multi\-Samples ()} -\/ Set / Get the number of multisamples to use for hardware antialiasing.  
\item {\ttfamily obj.\-Set\-Stencil\-Capable (int )} -\/ Set / Get the availability of the stencil buffer.  
\item {\ttfamily int = obj.\-Get\-Stencil\-Capable ()} -\/ Set / Get the availability of the stencil buffer.  
\item {\ttfamily obj.\-Stencil\-Capable\-On ()} -\/ Set / Get the availability of the stencil buffer.  
\item {\ttfamily obj.\-Stencil\-Capable\-Off ()} -\/ Set / Get the availability of the stencil buffer.  
\item {\ttfamily obj.\-Set\-Report\-Graphic\-Errors (int )} -\/ Turn on/off report of graphic errors. Initial value is false (off). This flag is used by vtk\-Graphic\-Error\-Macro.  
\item {\ttfamily int = obj.\-Get\-Report\-Graphic\-Errors ()} -\/ Turn on/off report of graphic errors. Initial value is false (off). This flag is used by vtk\-Graphic\-Error\-Macro.  
\item {\ttfamily obj.\-Report\-Graphic\-Errors\-On ()} -\/ Turn on/off report of graphic errors. Initial value is false (off). This flag is used by vtk\-Graphic\-Error\-Macro.  
\item {\ttfamily obj.\-Report\-Graphic\-Errors\-Off ()} -\/ Turn on/off report of graphic errors. Initial value is false (off). This flag is used by vtk\-Graphic\-Error\-Macro.  
\item {\ttfamily obj.\-Check\-Graphic\-Error ()} -\/ Update graphic error status, regardless of Report\-Graphic\-Errors flag. It means this method can be used in any context and is not restricted to debug mode.  
\item {\ttfamily int = obj.\-Has\-Graphic\-Error ()} -\/ Return the last graphic error status. Initial value is false.  
\item {\ttfamily string = obj.\-Get\-Last\-Graphic\-Error\-String ()} -\/ Return a string matching the last graphic error status.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderwindowcollection}{}\section{vtk\-Render\-Window\-Collection}\label{vtkrendering_vtkrenderwindowcollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Window\-Collection represents and provides methods to manipulate a list of Render\-Windows. The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Render\-Window\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderWindowCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Window\-Collection 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\-Window\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Window\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Window\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Render\-Window a)} -\/ Get the next Render\-Window in the list. Return N\-U\-L\-L when at the end of the list.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Next\-Item ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrenderwindowinteractor}{}\section{vtk\-Render\-Window\-Interactor}\label{vtkrendering_vtkrenderwindowinteractor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Render\-Window\-Interactor provides a platform-\/independent interaction mechanism for mouse/key/time events. It serves as a base class for platform-\/dependent implementations that handle routing of mouse/key/timer messages to vtk\-Interactor\-Observer and its subclasses. vtk\-Render\-Window\-Interactor also provides controls for picking, rendering frame rate, and headlights.

vtk\-Render\-Window\-Interactor has changed from previous implementations and now serves only as a shell to hold user preferences and route messages to vtk\-Interactor\-Style. Callbacks are available for many events. Platform specific subclasses should provide methods for manipulating timers, Terminate\-App, and an event loop if required via Initialize/\-Start/\-Enable/\-Disable.

To create an instance of class vtk\-Render\-Window\-Interactor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRenderWindowInteractor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Render\-Window\-Interactor 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\-Window\-Interactor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Render\-Window\-Interactor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize ()} -\/ Prepare for handling events. This must be called before the interactor will work.  
\item {\ttfamily obj.\-Re\-Initialize ()} -\/ This Method detects loops of Render\-Window-\/\-Interactor, so objects are freed properly.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ This Method detects loops of Render\-Window-\/\-Interactor, so objects are freed properly.  
\item {\ttfamily obj.\-Start ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily obj.\-Enable ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily obj.\-Disable ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily int = obj.\-Get\-Enabled ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily obj.\-Enable\-Render\-On ()} -\/ Enable/\-Disable whether vtk\-Render\-Window\-Interactor\-::\-Render() calls this-\/$>$Render\-Window-\/$>$Render().  
\item {\ttfamily obj.\-Enable\-Render\-Off ()} -\/ Enable/\-Disable whether vtk\-Render\-Window\-Interactor\-::\-Render() calls this-\/$>$Render\-Window-\/$>$Render().  
\item {\ttfamily obj.\-Set\-Enable\-Render (bool )} -\/ Enable/\-Disable whether vtk\-Render\-Window\-Interactor\-::\-Render() calls this-\/$>$Render\-Window-\/$>$Render().  
\item {\ttfamily bool = obj.\-Get\-Enable\-Render ()} -\/ Enable/\-Disable whether vtk\-Render\-Window\-Interactor\-::\-Render() calls this-\/$>$Render\-Window-\/$>$Render().  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window aren)} -\/ Set/\-Get the rendering window being controlled by this object.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Set/\-Get the rendering window being controlled by this object.  
\item {\ttfamily obj.\-Update\-Size (int x, int y)} -\/ Event loop notification member for window size change. Window size is measured in pixels.  
\item {\ttfamily int = obj.\-Create\-Timer (int timer\-Type)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Destroy\-Timer ()} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Create\-Repeating\-Timer (long duration)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Create\-One\-Shot\-Timer (long duration)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Is\-One\-Shot\-Timer (int timer\-Id)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily long = obj.\-Get\-Timer\-Duration (int timer\-Id)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Reset\-Timer (int timer\-Id)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Destroy\-Timer (int timer\-Id)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily int = obj.\-Get\-V\-T\-K\-Timer\-Id (int platform\-Timer\-Id)} -\/ This class provides two groups of methods for manipulating timers. The first group (Create\-Timer(timer\-Type) and Destroy\-Timer()) implicitly use an internal timer id (and are present for backward compatibility). The second group (Create\-Repeating\-Timer(long),Create\-One\-Shot\-Timer(long), Reset\-Timer(int),Destroy\-Timer(int)) use timer ids so multiple timers can be independently managed. In the first group, the Create\-Timer() method takes an argument indicating whether the timer is created the first time (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-F\-I\-R\-S\-T) or whether it is being reset (timer\-Type==V\-T\-K\-I\-\_\-\-T\-I\-M\-E\-R\-\_\-\-U\-P\-D\-A\-T\-E). (In initial implementations of V\-T\-K this was how one shot and repeating timers were managed.) In the second group, the create methods take a timer duration argument (in milliseconds) and return a timer id. Thus the Reset\-Timer(timer\-Id) and Destroy\-Timer(timer\-Id) methods take this timer id and operate on the timer as appropriate. Methods are also available for determining  
\item {\ttfamily obj.\-Set\-Timer\-Duration (long )} -\/ Specify the default timer interval (in milliseconds). (This is used in conjunction with the timer methods described previously, e.\-g., Create\-Timer() uses this value; and Create\-Repeating\-Timer(duration) and Create\-One\-Shot\-Timer(duration) use the default value if the parameter \char`\"{}duration\char`\"{} is less than or equal to zero.) Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily Get\-Timer\-Duration\-Min\-Value = obj.()} -\/ Specify the default timer interval (in milliseconds). (This is used in conjunction with the timer methods described previously, e.\-g., Create\-Timer() uses this value; and Create\-Repeating\-Timer(duration) and Create\-One\-Shot\-Timer(duration) use the default value if the parameter \char`\"{}duration\char`\"{} is less than or equal to zero.) Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily Get\-Timer\-Duration\-Max\-Value = obj.()} -\/ Specify the default timer interval (in milliseconds). (This is used in conjunction with the timer methods described previously, e.\-g., Create\-Timer() uses this value; and Create\-Repeating\-Timer(duration) and Create\-One\-Shot\-Timer(duration) use the default value if the parameter \char`\"{}duration\char`\"{} is less than or equal to zero.) Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily long = obj.\-Get\-Timer\-Duration ()} -\/ Specify the default timer interval (in milliseconds). (This is used in conjunction with the timer methods described previously, e.\-g., Create\-Timer() uses this value; and Create\-Repeating\-Timer(duration) and Create\-One\-Shot\-Timer(duration) use the default value if the parameter \char`\"{}duration\char`\"{} is less than or equal to zero.) Care must be taken when adjusting the timer interval from the default value of 10 milliseconds--it may adversely affect the interactors.  
\item {\ttfamily obj.\-Set\-Timer\-Event\-Id (int )} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily int = obj.\-Get\-Timer\-Event\-Id ()} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily obj.\-Set\-Timer\-Event\-Type (int )} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily int = obj.\-Get\-Timer\-Event\-Type ()} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily obj.\-Set\-Timer\-Event\-Duration (int )} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily int = obj.\-Get\-Timer\-Event\-Duration ()} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily obj.\-Set\-Timer\-Event\-Platform\-Id (int )} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily int = obj.\-Get\-Timer\-Event\-Platform\-Id ()} -\/ These methods are used to communicate information about the currently firing Create\-Timer\-Event or Destroy\-Timer\-Event. The caller of Create\-Timer\-Event sets up Timer\-Event\-Id, Timer\-Event\-Type and Timer\-Event\-Duration. The observer of Create\-Timer\-Event should set up an appropriate platform specific timer based on those values and set the Timer\-Event\-Platform\-Id before returning. The caller of Destroy\-Timer\-Event sets up Timer\-Event\-Platform\-Id. The observer of Destroy\-Timer\-Event should simply destroy the platform specific timer created by Create\-Timer\-Event. See vtk\-Generic\-Render\-Window\-Interactor's Internal\-Create\-Timer and Internal\-Destroy\-Timer for an example.  
\item {\ttfamily obj.\-Terminate\-App (void )} -\/ External switching between joystick/trackball/new? modes. Initial value is a vtk\-Interactor\-Style\-Switch object.  
\item {\ttfamily obj.\-Set\-Interactor\-Style (vtk\-Interactor\-Observer )} -\/ External switching between joystick/trackball/new? modes. Initial value is a vtk\-Interactor\-Style\-Switch object.  
\item {\ttfamily vtk\-Interactor\-Observer = obj.\-Get\-Interactor\-Style ()} -\/ External switching between joystick/trackball/new? modes. Initial value is a vtk\-Interactor\-Style\-Switch object.  
\item {\ttfamily obj.\-Set\-Light\-Follow\-Camera (int )} -\/ Turn on/off the automatic repositioning of lights as the camera moves. Default is On.  
\item {\ttfamily int = obj.\-Get\-Light\-Follow\-Camera ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. Default is On.  
\item {\ttfamily obj.\-Light\-Follow\-Camera\-On ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. Default is On.  
\item {\ttfamily obj.\-Light\-Follow\-Camera\-Off ()} -\/ Turn on/off the automatic repositioning of lights as the camera moves. Default is On.  
\item {\ttfamily obj.\-Set\-Desired\-Update\-Rate (double )} -\/ Set/\-Get the desired update rate. This is used by vtk\-L\-O\-D\-Actor's to tell them how quickly they need to render. This update is in effect only when the camera is being rotated, or zoomed. When the interactor is still, the Still\-Update\-Rate is used instead. The default is 15.  
\item {\ttfamily double = obj.\-Get\-Desired\-Update\-Rate\-Min\-Value ()} -\/ Set/\-Get the desired update rate. This is used by vtk\-L\-O\-D\-Actor's to tell them how quickly they need to render. This update is in effect only when the camera is being rotated, or zoomed. When the interactor is still, the Still\-Update\-Rate is used instead. The default is 15.  
\item {\ttfamily double = obj.\-Get\-Desired\-Update\-Rate\-Max\-Value ()} -\/ Set/\-Get the desired update rate. This is used by vtk\-L\-O\-D\-Actor's to tell them how quickly they need to render. This update is in effect only when the camera is being rotated, or zoomed. When the interactor is still, the Still\-Update\-Rate is used instead. The default is 15.  
\item {\ttfamily double = obj.\-Get\-Desired\-Update\-Rate ()} -\/ Set/\-Get the desired update rate. This is used by vtk\-L\-O\-D\-Actor's to tell them how quickly they need to render. This update is in effect only when the camera is being rotated, or zoomed. When the interactor is still, the Still\-Update\-Rate is used instead. The default is 15.  
\item {\ttfamily obj.\-Set\-Still\-Update\-Rate (double )} -\/ Set/\-Get the desired update rate when movement has stopped. For the non-\/still update rate, see the Set\-Desired\-Update\-Rate method. The default is 0.\-0001  
\item {\ttfamily double = obj.\-Get\-Still\-Update\-Rate\-Min\-Value ()} -\/ Set/\-Get the desired update rate when movement has stopped. For the non-\/still update rate, see the Set\-Desired\-Update\-Rate method. The default is 0.\-0001  
\item {\ttfamily double = obj.\-Get\-Still\-Update\-Rate\-Max\-Value ()} -\/ Set/\-Get the desired update rate when movement has stopped. For the non-\/still update rate, see the Set\-Desired\-Update\-Rate method. The default is 0.\-0001  
\item {\ttfamily double = obj.\-Get\-Still\-Update\-Rate ()} -\/ Set/\-Get the desired update rate when movement has stopped. For the non-\/still update rate, see the Set\-Desired\-Update\-Rate method. The default is 0.\-0001  
\item {\ttfamily int = obj.\-Get\-Initialized ()} -\/ See whether interactor has been initialized yet. Default is 0.  
\item {\ttfamily obj.\-Set\-Picker (vtk\-Abstract\-Picker )} -\/ Set/\-Get the object used to perform pick operations. In order to pick instances of vtk\-Prop, the picker must be a subclass of vtk\-Abstract\-Prop\-Picker, meaning that it can identify a particular instance of vtk\-Prop.  
\item {\ttfamily vtk\-Abstract\-Picker = obj.\-Get\-Picker ()} -\/ Set/\-Get the object used to perform pick operations. In order to pick instances of vtk\-Prop, the picker must be a subclass of vtk\-Abstract\-Prop\-Picker, meaning that it can identify a particular instance of vtk\-Prop.  
\item {\ttfamily vtk\-Abstract\-Prop\-Picker = obj.\-Create\-Default\-Picker ()} -\/ Create default picker. Used to create one when none is specified. Default is an instance of vtk\-Prop\-Picker.  
\item {\ttfamily obj.\-Exit\-Callback ()} -\/ These methods correspond to the the Exit, User and Pick callbacks. They allow for the Style to invoke them.  
\item {\ttfamily obj.\-User\-Callback ()} -\/ These methods correspond to the the Exit, User and Pick callbacks. They allow for the Style to invoke them.  
\item {\ttfamily obj.\-Start\-Pick\-Callback ()} -\/ These methods correspond to the the Exit, User and Pick callbacks. They allow for the Style to invoke them.  
\item {\ttfamily obj.\-End\-Pick\-Callback ()} -\/ These methods correspond to the the Exit, User and Pick callbacks. They allow for the Style to invoke them.  
\item {\ttfamily obj.\-Get\-Mouse\-Position (int x, int y)} -\/ Hide or show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead.  
\item {\ttfamily obj.\-Hide\-Cursor ()} -\/ Hide or show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead.  
\item {\ttfamily obj.\-Show\-Cursor ()} -\/ Hide or show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead.  
\item {\ttfamily obj.\-Render ()} -\/ Render the scene. Just pass the render call on to the associated vtk\-Render\-Window.  
\item {\ttfamily obj.\-Fly\-To (vtk\-Renderer ren, double x, double y, double z)} -\/ Given a position x, move the current camera's focal point to x. The movement is animated over the number of frames specified in Number\-Of\-Fly\-Frames. The L\-O\-D desired frame rate is used.  
\item {\ttfamily obj.\-Fly\-To (vtk\-Renderer ren, double x)} -\/ Given a position x, move the current camera's focal point to x. The movement is animated over the number of frames specified in Number\-Of\-Fly\-Frames. The L\-O\-D desired frame rate is used.  
\item {\ttfamily obj.\-Fly\-To\-Image (vtk\-Renderer ren, double x, double y)} -\/ Given a position x, move the current camera's focal point to x. The movement is animated over the number of frames specified in Number\-Of\-Fly\-Frames. The L\-O\-D desired frame rate is used.  
\item {\ttfamily obj.\-Fly\-To\-Image (vtk\-Renderer ren, double x)} -\/ Set the number of frames to fly to when Fly\-To is invoked.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Fly\-Frames (int )} -\/ Set the number of frames to fly to when Fly\-To is invoked.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fly\-Frames\-Min\-Value ()} -\/ Set the number of frames to fly to when Fly\-To is invoked.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fly\-Frames\-Max\-Value ()} -\/ Set the number of frames to fly to when Fly\-To is invoked.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Fly\-Frames ()} -\/ Set the number of frames to fly to when Fly\-To is invoked.  
\item {\ttfamily obj.\-Set\-Dolly (double )} -\/ Set the total Dolly value to use when flying to (Fly\-To()) a specified point. Negative values fly away from the point.  
\item {\ttfamily double = obj.\-Get\-Dolly ()} -\/ Set the total Dolly value to use when flying to (Fly\-To()) a specified point. Negative values fly away from the point.  
\item {\ttfamily int = obj. Get\-Event\-Position ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily int = obj. Get\-Last\-Event\-Position ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Last\-Event\-Position (int , int )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Last\-Event\-Position (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Event\-Position (int x, int y)} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Event\-Position (int pos\mbox{[}2\mbox{]})} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Event\-Position\-Flip\-Y (int x, int y)} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Event\-Position\-Flip\-Y (int pos\mbox{[}2\mbox{]})} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Alt\-Key (int )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily int = obj.\-Get\-Alt\-Key ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Control\-Key (int )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily int = obj.\-Get\-Control\-Key ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Shift\-Key (int )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily int = obj.\-Get\-Shift\-Key ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Key\-Code (char )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily char = obj.\-Get\-Key\-Code ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Repeat\-Count (int )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily int = obj.\-Get\-Repeat\-Count ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Key\-Sym (string )} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily string = obj.\-Get\-Key\-Sym ()} -\/ Set/\-Get information about the current event. The current x,y position is in the Event\-Position, and the previous event position is in Last\-Event\-Position, updated automatically each time Event\-Position is set using its Set() method. Mouse positions are measured in pixels. The other information is about key board input.  
\item {\ttfamily obj.\-Set\-Event\-Information (int x, int y, int ctrl, int shift, char keycode, int repeatcount, string keysym)} -\/ Calls Set\-Event\-Information, but flips the Y based on the current Size\mbox{[}1\mbox{]} value (i.\-e. y = this-\/$>$Size\mbox{[}1\mbox{]} -\/ y -\/ 1).  
\item {\ttfamily obj.\-Set\-Event\-Information\-Flip\-Y (int x, int y, int ctrl, int shift, char keycode, int repeatcount, string keysym)} -\/ Set all the keyboard-\/related event information in one call.  
\item {\ttfamily obj.\-Set\-Key\-Event\-Information (int ctrl, int shift, char keycode, int repeatcount, string keysym)} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily obj.\-Set\-Size (int , int )} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily int = obj. Get\-Size ()} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily obj.\-Set\-Event\-Size (int , int )} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily obj.\-Set\-Event\-Size (int a\mbox{[}2\mbox{]})} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily int = obj. Get\-Event\-Size ()} -\/ This methods sets the Size ivar of the interactor without actually changing the size of the window. Normally application programmers would use Update\-Size if anything. This is useful for letting someone else change the size of the rendering window and just letting the interactor know about the change. The current event width/height (if any) is in Event\-Size (Expose event, for example). Window size is measured in pixels.  
\item {\ttfamily vtk\-Renderer = obj.\-Find\-Poked\-Renderer (int , int )} -\/ When an event occurs, we must determine which Renderer the event occurred within, since one Render\-Window may contain multiple renderers.  
\item {\ttfamily vtk\-Observer\-Mediator = obj.\-Get\-Observer\-Mediator ()} -\/ Return the object used to mediate between vtk\-Interactor\-Observers contending for resources. Multiple interactor observers will often request different resources (e.\-g., cursor shape); the mediator uses a strategy to provide the resource based on priority of the observer plus the particular request (default versus non-\/default cursor shape).  
\item {\ttfamily obj.\-Set\-Use\-T\-Dx (bool )} -\/ Use a 3\-D\-Connexion device. Initial value is false. If V\-T\-K is not build with the T\-Dx option, this is no-\/op. If V\-T\-K is build with the T\-Dx option, and a device is not connected, a warning is emitted. It is must be called before the first Render to be effective, otherwise it is ignored.  
\item {\ttfamily bool = obj.\-Get\-Use\-T\-Dx ()} -\/ Use a 3\-D\-Connexion device. Initial value is false. If V\-T\-K is not build with the T\-Dx option, this is no-\/op. If V\-T\-K is build with the T\-Dx option, and a device is not connected, a warning is emitted. It is must be called before the first Render to be effective, otherwise it is ignored.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkrepresentationpainter}{}\section{vtk\-Representation\-Painter}\label{vtkrendering_vtkrepresentationpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This painter merely defines the interface. Subclasses will change the polygon rendering mode dependent on the graphics library.

To create an instance of class vtk\-Representation\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRepresentationPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Representation\-Painter 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\-Representation\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Representation\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Representation\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkscalarbaractor}{}\section{vtk\-Scalar\-Bar\-Actor}\label{vtkrendering_vtkscalarbaractor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Scalar\-Bar\-Actor creates a scalar bar with annotation text. A scalar bar is a legend that indicates to the viewer the correspondence between color value and data value. The legend consists of a rectangular bar made of rectangular pieces each colored a constant value. Since vtk\-Scalar\-Bar\-Actor is a subclass of vtk\-Actor2\-D, it is drawn in the image plane (i.\-e., in the renderer's viewport) on top of the 3\-D graphics window.

To use vtk\-Scalar\-Bar\-Actor you must associate a vtk\-Scalars\-To\-Colors (or subclass) with it. The lookup table defines the colors and the range of scalar values used to map scalar data. Typically, the number of colors shown in the scalar bar is not equal to the number of colors in the lookup table, in which case sampling of the lookup table is performed.

Other optional capabilities include specifying the fraction of the viewport size (both x and y directions) which will control the size of the scalar bar and the number of annotation labels. The actual position of the scalar bar on the screen is controlled by using the vtk\-Actor2\-D\-::\-Set\-Position() method (by default the scalar bar is centered in the viewport). Other features include the ability to orient the scalar bar horizontally of vertically and controlling the format (printf style) with which to print the labels on the scalar bar. Also, the vtk\-Scalar\-Bar\-Actor's property is applied to the scalar bar and annotation (including layer, and compositing operator).

Set the text property/attributes of the title and the labels through the vtk\-Text\-Property objects associated to this actor.

To create an instance of class vtk\-Scalar\-Bar\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScalarBarActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scalar\-Bar\-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\-Scalar\-Bar\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scalar\-Bar\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scalar\-Bar\-Actor = 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.\-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\-Lookup\-Table (vtk\-Scalars\-To\-Colors )} -\/ Set/\-Get the vtk\-Lookup\-Table to use. The lookup table specifies the number of colors to use in the table (if not overridden), as well as the scalar range.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Set/\-Get the vtk\-Lookup\-Table to use. The lookup table specifies the number of colors to use in the table (if not overridden), as well as the scalar range.  
\item {\ttfamily obj.\-Set\-Use\-Opacity (int )} -\/ Should be display the opacity as well. This is displayed by changing the opacity of the scalar bar in accordance with the opacity of the given color. For clarity, a texture grid is placed in the background if Opacity is O\-N. You might also want to play with Set\-Texture\-Grid\-With in that case. \mbox{[}Default\-: off\mbox{]}  
\item {\ttfamily int = obj.\-Get\-Use\-Opacity ()} -\/ Should be display the opacity as well. This is displayed by changing the opacity of the scalar bar in accordance with the opacity of the given color. For clarity, a texture grid is placed in the background if Opacity is O\-N. You might also want to play with Set\-Texture\-Grid\-With in that case. \mbox{[}Default\-: off\mbox{]}  
\item {\ttfamily obj.\-Use\-Opacity\-On ()} -\/ Should be display the opacity as well. This is displayed by changing the opacity of the scalar bar in accordance with the opacity of the given color. For clarity, a texture grid is placed in the background if Opacity is O\-N. You might also want to play with Set\-Texture\-Grid\-With in that case. \mbox{[}Default\-: off\mbox{]}  
\item {\ttfamily obj.\-Use\-Opacity\-Off ()} -\/ Should be display the opacity as well. This is displayed by changing the opacity of the scalar bar in accordance with the opacity of the given color. For clarity, a texture grid is placed in the background if Opacity is O\-N. You might also want to play with Set\-Texture\-Grid\-With in that case. \mbox{[}Default\-: off\mbox{]}  
\item {\ttfamily obj.\-Set\-Maximum\-Number\-Of\-Colors (int )} -\/ Set/\-Get the maximum number of scalar bar segments to show. This may differ from the number of colors in the lookup table, in which case the colors are samples from the lookup table.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Colors\-Min\-Value ()} -\/ Set/\-Get the maximum number of scalar bar segments to show. This may differ from the number of colors in the lookup table, in which case the colors are samples from the lookup table.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Colors\-Max\-Value ()} -\/ Set/\-Get the maximum number of scalar bar segments to show. This may differ from the number of colors in the lookup table, in which case the colors are samples from the lookup table.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Number\-Of\-Colors ()} -\/ Set/\-Get the maximum number of scalar bar segments to show. This may differ from the number of colors in the lookup table, in which case the colors are samples from the lookup table.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Labels (int )} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Min\-Value ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels\-Max\-Value ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Labels ()} -\/ Set/\-Get the number of annotation labels to show.  
\item {\ttfamily obj.\-Set\-Orientation (int )} -\/ Control the orientation of the scalar bar.  
\item {\ttfamily int = obj.\-Get\-Orientation\-Min\-Value ()} -\/ Control the orientation of the scalar bar.  
\item {\ttfamily int = obj.\-Get\-Orientation\-Max\-Value ()} -\/ Control the orientation of the scalar bar.  
\item {\ttfamily int = obj.\-Get\-Orientation ()} -\/ Control the orientation of the scalar bar.  
\item {\ttfamily obj.\-Set\-Orientation\-To\-Horizontal ()} -\/ Control the orientation of the scalar bar.  
\item {\ttfamily obj.\-Set\-Orientation\-To\-Vertical ()} -\/ Control the orientation of the scalar bar.  
\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\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the labels text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Text\-Property ()} -\/ Set/\-Get the labels text property.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the labels on the scalar bar.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the labels on the scalar bar.  
\item {\ttfamily obj.\-Set\-Title (string )} -\/ Set/\-Get the title of the scalar bar actor,  
\item {\ttfamily string = obj.\-Get\-Title ()} -\/ Set/\-Get the title of the scalar bar actor,  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of a scalar bar actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Set\-Texture\-Grid\-Width (double )} -\/ Set the width of the texture grid. Used only if Use\-Opacity is O\-N.  
\item {\ttfamily double = obj.\-Get\-Texture\-Grid\-Width ()} -\/ Set the width of the texture grid. Used only if Use\-Opacity is O\-N.  
\item {\ttfamily vtk\-Actor2\-D = obj.\-Get\-Texture\-Actor ()} -\/ Get the texture actor.. you may want to change some properties on it  
\item {\ttfamily obj.\-Set\-Text\-Position (int )} -\/ Have the text preceding the scalar bar or suceeding it ? Succeed implies the that the text is Above scalar bar if orientation is horizontal or Right of scalar bar if orientation is vertical. Precede is the opposite  
\item {\ttfamily int = obj.\-Get\-Text\-Position\-Min\-Value ()} -\/ Have the text preceding the scalar bar or suceeding it ? Succeed implies the that the text is Above scalar bar if orientation is horizontal or Right of scalar bar if orientation is vertical. Precede is the opposite  
\item {\ttfamily int = obj.\-Get\-Text\-Position\-Max\-Value ()} -\/ Have the text preceding the scalar bar or suceeding it ? Succeed implies the that the text is Above scalar bar if orientation is horizontal or Right of scalar bar if orientation is vertical. Precede is the opposite  
\item {\ttfamily int = obj.\-Get\-Text\-Position ()} -\/ Have the text preceding the scalar bar or suceeding it ? Succeed implies the that the text is Above scalar bar if orientation is horizontal or Right of scalar bar if orientation is vertical. Precede is the opposite  
\item {\ttfamily obj.\-Set\-Text\-Position\-To\-Precede\-Scalar\-Bar ()} -\/ Have the text preceding the scalar bar or suceeding it ? Succeed implies the that the text is Above scalar bar if orientation is horizontal or Right of scalar bar if orientation is vertical. Precede is the opposite  
\item {\ttfamily obj.\-Set\-Text\-Position\-To\-Succeed\-Scalar\-Bar ()} -\/ Set/\-Get the maximum width and height in pixels. Specifying the size as a relative fraction of the viewport can sometimes undersirably strech the size of the actor too much. These methods allow the user to set bounds on the maximum size of the scalar bar in pixels along any direction. Defaults to unbounded.  
\item {\ttfamily obj.\-Set\-Maximum\-Width\-In\-Pixels (int )} -\/ Set/\-Get the maximum width and height in pixels. Specifying the size as a relative fraction of the viewport can sometimes undersirably strech the size of the actor too much. These methods allow the user to set bounds on the maximum size of the scalar bar in pixels along any direction. Defaults to unbounded.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Width\-In\-Pixels ()} -\/ Set/\-Get the maximum width and height in pixels. Specifying the size as a relative fraction of the viewport can sometimes undersirably strech the size of the actor too much. These methods allow the user to set bounds on the maximum size of the scalar bar in pixels along any direction. Defaults to unbounded.  
\item {\ttfamily obj.\-Set\-Maximum\-Height\-In\-Pixels (int )} -\/ Set/\-Get the maximum width and height in pixels. Specifying the size as a relative fraction of the viewport can sometimes undersirably strech the size of the actor too much. These methods allow the user to set bounds on the maximum size of the scalar bar in pixels along any direction. Defaults to unbounded.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Height\-In\-Pixels ()} -\/ Set/\-Get the maximum width and height in pixels. Specifying the size as a relative fraction of the viewport can sometimes undersirably strech the size of the actor too much. These methods allow the user to set bounds on the maximum size of the scalar bar in pixels along any direction. Defaults to unbounded.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkscalarstocolorspainter}{}\section{vtk\-Scalars\-To\-Colors\-Painter}\label{vtkrendering_vtkscalarstocolorspainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a painter that converts scalars to colors. It enable/disables coloring state depending on the Scalar\-Mode. This painter is composite dataset enabled.

To create an instance of class vtk\-Scalars\-To\-Colors\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScalarsToColorsPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scalars\-To\-Colors\-Painter 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\-Scalars\-To\-Colors\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scalars\-To\-Colors\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scalars\-To\-Colors\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors lut)} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Specify a lookup table for the mapper to use.  
\item {\ttfamily obj.\-Create\-Default\-Lookup\-Table ()} -\/ Create default lookup table. Generally used to create one when none is available with the scalar data.  
\item {\ttfamily int = obj.\-Get\-Premultiply\-Colors\-With\-Alpha (vtk\-Actor actor)} -\/ For alpha blending, we sometime premultiply the colors with alpha and change the alpha blending function. This call returns whether we are premultiplying or using the default blending function. Currently this checks if the actor has a texture, if not it returns true. T\-O\-D\-O\-: It is possible to make this decision dependent on key passed down from a painter upstream that makes a more informed decision for alpha blending depending on extensions available, for example.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()} -\/ Subclasses need to override this to return the output of the pipeline.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkscaledtextactor}{}\section{vtk\-Scaled\-Text\-Actor}\label{vtkrendering_vtkscaledtextactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Scaled\-Text\-Actor is deprecated. New code should use vtk\-Text\-Actor with the Scaled = true option.

To create an instance of class vtk\-Scaled\-Text\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScaledTextActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scaled\-Text\-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\-Scaled\-Text\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scaled\-Text\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scaled\-Text\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkscenepicker}{}\section{vtk\-Scene\-Picker}\label{vtkrendering_vtkscenepicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The Scene picker, unline conventional pickers picks an entire viewport at one shot and caches the result, which can be retrieved later. The utility of the class arises during {\bfseries Actor Selection}. Let's say you have a couple of polygonal objects in your scene and you wish to have a status bar that indicates the object your mouse is over. Picking repeatedly every time your mouse moves would be very slow. The scene picker automatically picks your viewport every time the camera is changed and caches the information. Additionally, it observes the vtk\-Render\-Window\-Interactor to avoid picking during interaction, so that you still maintain your interactivity. In effect, the picker does an additional pick-\/render of your scene every time you stop interacting with your scene. As an example, see Rendering/\-Test\-Scene\-Picker.

To create an instance of class vtk\-Scene\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScenePicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scene\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Scene\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scene\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scene\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer )} -\/ Set the renderer. Scene picks are restricted to the viewport.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Set the renderer. Scene picks are restricted to the viewport.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Cell\-Id (int display\-Pos\mbox{[}2\mbox{]})} -\/ Get cell id at the pick position. Returns -\/1 if no cell was picked. Makes sense only after Pick has been called.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Vertex\-Id (int display\-Pos\mbox{[}2\mbox{]})} -\/ Get cell id at the pick position. Returns -\/1 if no cell was picked. Makes sense only after Pick has been called.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-View\-Prop (int display\-Pos\mbox{[}2\mbox{]})} -\/ Get actor at the pick position. Returns N\-U\-L\-L if none. Makes sense only after Pick has been called.  
\item {\ttfamily obj.\-Set\-Enable\-Vertex\-Picking (int )} -\/ Vertex picking (using the method Get\-Vertex\-Id()), required additional resources and can slow down still render time by 5-\/10\%. Enabled by default.  
\item {\ttfamily int = obj.\-Get\-Enable\-Vertex\-Picking ()} -\/ Vertex picking (using the method Get\-Vertex\-Id()), required additional resources and can slow down still render time by 5-\/10\%. Enabled by default.  
\item {\ttfamily obj.\-Enable\-Vertex\-Picking\-On ()} -\/ Vertex picking (using the method Get\-Vertex\-Id()), required additional resources and can slow down still render time by 5-\/10\%. Enabled by default.  
\item {\ttfamily obj.\-Enable\-Vertex\-Picking\-Off ()} -\/ Vertex picking (using the method Get\-Vertex\-Id()), required additional resources and can slow down still render time by 5-\/10\%. Enabled by default.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkselectvisiblepoints}{}\section{vtk\-Select\-Visible\-Points}\label{vtkrendering_vtkselectvisiblepoints}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Select\-Visible\-Points is a filter that selects points based on whether they are visible or not. Visibility is determined by accessing the z-\/buffer of a rendering window. (The position of each input point is converted into display coordinates, and then the z-\/value at that point is obtained. If within the user-\/specified tolerance, the point is considered visible.)

Points that are visible (or if the ivar Select\-Invisible is on, invisible points) are passed to the output. Associated data attributes are passed to the output as well.

This filter also allows you to specify a rectangular window in display (pixel) coordinates in which the visible points must lie. This can be used as a sort of local \char`\"{}brushing\char`\"{} operation to select just data within a window.

To create an instance of class vtk\-Select\-Visible\-Points, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSelectVisiblePoints
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Select\-Visible\-Points 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\-Select\-Visible\-Points class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Select\-Visible\-Points = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Select\-Visible\-Points = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Specify the renderer in which the visibility computation is to be performed.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Set/\-Get the flag which enables selection in a rectangular display region.  
\item {\ttfamily obj.\-Set\-Selection\-Window (int )} -\/ Set/\-Get the flag which enables selection in a rectangular display region.  
\item {\ttfamily int = obj.\-Get\-Selection\-Window ()} -\/ Set/\-Get the flag which enables selection in a rectangular display region.  
\item {\ttfamily obj.\-Selection\-Window\-On ()} -\/ Set/\-Get the flag which enables selection in a rectangular display region.  
\item {\ttfamily obj.\-Selection\-Window\-Off ()} -\/ Set/\-Get the flag which enables selection in a rectangular display region.  
\item {\ttfamily obj.\-Set\-Selection (int , int , int , int )} -\/ Specify the selection window in display coordinates. You must specify a rectangular region using (xmin,xmax,ymin,ymax).  
\item {\ttfamily obj.\-Set\-Selection (int a\mbox{[}4\mbox{]})} -\/ Specify the selection window in display coordinates. You must specify a rectangular region using (xmin,xmax,ymin,ymax).  
\item {\ttfamily int = obj. Get\-Selection ()} -\/ Specify the selection window in display coordinates. You must specify a rectangular region using (xmin,xmax,ymin,ymax).  
\item {\ttfamily obj.\-Set\-Select\-Invisible (int )} -\/ Set/\-Get the flag which enables inverse selection; i.\-e., invisible points are selected.  
\item {\ttfamily int = obj.\-Get\-Select\-Invisible ()} -\/ Set/\-Get the flag which enables inverse selection; i.\-e., invisible points are selected.  
\item {\ttfamily obj.\-Select\-Invisible\-On ()} -\/ Set/\-Get the flag which enables inverse selection; i.\-e., invisible points are selected.  
\item {\ttfamily obj.\-Select\-Invisible\-Off ()} -\/ Set/\-Get the flag which enables inverse selection; i.\-e., invisible points are selected.  
\item {\ttfamily obj.\-Set\-Tolerance (double )} -\/ Set/\-Get a tolerance to use to determine whether a point is visible. A tolerance is usually required because the conversion from world space to display space during rendering introduces numerical round-\/off.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ Set/\-Get a tolerance to use to determine whether a point is visible. A tolerance is usually required because the conversion from world space to display space during rendering introduces numerical round-\/off.  
\item {\ttfamily double = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ Set/\-Get a tolerance to use to determine whether a point is visible. A tolerance is usually required because the conversion from world space to display space during rendering introduces numerical round-\/off.  
\item {\ttfamily double = obj.\-Get\-Tolerance ()} -\/ Set/\-Get a tolerance to use to determine whether a point is visible. A tolerance is usually required because the conversion from world space to display space during rendering introduces numerical round-\/off.  
\item {\ttfamily bool = obj.\-Is\-Point\-Occluded (double x\mbox{[}\mbox{]}, float z\-Ptr)} -\/ Tests if a point x is being occluded or not against the Z-\/\-Buffer array passed in by z\-Ptr. Call Initialize before calling this method.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return M\-Time also considering the renderer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtksequencepass}{}\section{vtk\-Sequence\-Pass}\label{vtkrendering_vtksequencepass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Sequence\-Pass executes a list of render passes sequentially. This class allows to define a sequence of render passes at run time. The other solution to write a sequence of render passes is to write an effective subclass of vtk\-Render\-Pass.

As vtk\-Sequence\-Pass is a vtk\-Render\-Pass itself, it is possible to have a hierarchy of render passes built at runtime.

To create an instance of class vtk\-Sequence\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSequencePass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sequence\-Pass 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\-Sequence\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sequence\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sequence\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\item {\ttfamily vtk\-Render\-Pass\-Collection = obj.\-Get\-Passes ()} -\/ The ordered list of render passes to execute sequentially. If the pointer is N\-U\-L\-L or the list is empty, it is silently ignored. There is no warning. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Passes (vtk\-Render\-Pass\-Collection passes)} -\/ The ordered list of render passes to execute sequentially. If the pointer is N\-U\-L\-L or the list is empty, it is silently ignored. There is no warning. Initial value is a N\-U\-L\-L pointer.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkshader}{}\section{vtk\-Shader}\label{vtkrendering_vtkshader}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shader is a base class for interfacing V\-T\-K to hardware shader libraries. vtk\-Shader interprets a vtk\-X\-M\-L\-Data\-Element that describes a particular shader. Descendants of this class inherit this functionality and additionally interface to specific shader libraries like N\-Vidia's Cg and Open\-G\-L2.\-0 (G\-L\-S\-L) to perform operations, on individual shaders.

During each render, the vtk\-Shader\-Program calls Compile(), Pass\-Shader\-Variables(), Bind() and after the actor has been rendered, calls Unbind(), in that order.

To create an instance of class vtk\-Shader, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShader
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shader has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Shader class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shader = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shader = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Compile ()} -\/ Called to compile the shader code. The subclasses must only compile the code in this method. Returns if the compile was successful. Subclasses should compile the code only if it was not already compiled.  
\item {\ttfamily obj.\-Pass\-Shader\-Variables (vtk\-Actor actor, vtk\-Renderer ren)} -\/ Called to pass V\-T\-K actor/property/light values and other Shader variables over to the shader. This is called by the Shader\-Program during each render.  
\item {\ttfamily obj.\-Bind ()} -\/ Called to unbind the shader. As with Bind(), this is only applicable to Cg.  
\item {\ttfamily obj.\-Unbind ()} -\/ 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 )} -\/ Get/\-Set the X\-M\-L\-Shader representation for this shader. A shader is not valid without a X\-M\-L\-Shader.  
\item {\ttfamily obj.\-Set\-X\-M\-L\-Shader (vtk\-X\-M\-L\-Shader )} -\/ Get/\-Set the X\-M\-L\-Shader representation for this shader. A shader is not valid without a X\-M\-L\-Shader.  
\item {\ttfamily vtk\-X\-M\-L\-Shader = obj.\-Get\-X\-M\-L\-Shader ()} -\/ Get/\-Set the X\-M\-L\-Shader representation for this shader. A shader is not valid without a X\-M\-L\-Shader.  
\item {\ttfamily int = obj.\-Has\-Shader\-Variable (string name)} -\/ Indicates if a variable by the given name exists.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-\_\-of\-\_\-elements, int values)} -\/ Methods to add shader variables to this shader. The shader variable type must match with that declared in the Material xml, otherwise, the variable is not made available to the shader.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-\_\-of\-\_\-elements, float values)} -\/ Methods to add shader variables to this shader. The shader variable type must match with that declared in the Material xml, otherwise, the variable is not made available to the shader.  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-\_\-of\-\_\-elements, double values)} -\/ Methods to add shader variables to this shader. The shader variable type must match with that declared in the Material xml, otherwise, the variable is not made available to the shader.  
\item {\ttfamily int = obj.\-Get\-Shader\-Variable\-Size (string name)} -\/ Get number of elements in a Shader variable. Return 0 if failed to find the shader variable.  
\item {\ttfamily int = obj.\-Get\-Shader\-Variable\-Type (string name)} -\/ Returns the type of a Shader variable with the given name. Return 0 on error.  
\item {\ttfamily int = obj.\-Get\-Shader\-Variable (string name, int values)} -\/ Methods to get the value of shader variables with the given name. Values must be at least the size of the shader variable (obtained by Get\-Shader\-Variable\-Size(). Returns if the operation was successful.  
\item {\ttfamily int = obj.\-Get\-Shader\-Variable (string name, float values)} -\/ Methods to get the value of shader variables with the given name. Values must be at least the size of the shader variable (obtained by Get\-Shader\-Variable\-Size(). Returns if the operation was successful.  
\item {\ttfamily int = obj.\-Get\-Shader\-Variable (string name, double values)} -\/ Methods to get the value of shader variables with the given name. Values must be at least the size of the shader variable (obtained by Get\-Shader\-Variable\-Size(). Returns if the operation was successful.  
\item {\ttfamily int = obj.\-Get\-Scope ()} -\/ Returns the scope of the shader i.\-e. if it's a vertex or fragment shader. (vtk\-X\-M\-L\-Shader\-::\-S\-C\-O\-P\-E\-\_\-\-V\-E\-R\-T\-E\-X or vtk\-X\-M\-L\-Shader\-::\-S\-C\-O\-P\-E\-\_\-\-F\-R\-A\-G\-M\-E\-N\-T).  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkshaderprogram}{}\section{vtk\-Shader\-Program}\label{vtkrendering_vtkshaderprogram}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Shader\-Program is a superclass for managing Hardware Shaders defined in the X\-M\-L Material file and interfacing V\-T\-K to those shaders. It's concrete descendants are responsible for installing vertex and fragment programs to the graphics hardware.

.S\-E\-C\-T\-I\-O\-N Shader Operations are shader library operations that are performed on individual shaders, that is, without consideration of the partner shader.

.S\-E\-C\-T\-I\-O\-N Program Operations are shader library operations that treat the vertex and fragment shader as a single unit.

.S\-E\-C\-T\-I\-O\-N Design This class is a Strategy pattern for 'Program' operations, which treat vertex/fragment shader pairs as a single 'Program', as required by some shader libraries (G\-L\-S\-L). Typically, 'Shader' operations are delegated to instances of vtk\-Shader (managed by descendants of this class) while 'Program' operations are handled by descendants of this class, vtk\-Cg\-Shader\-Program, vtk\-G\-L\-S\-L\-Shader\-Program.

To create an instance of class vtk\-Shader\-Program, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShaderProgram
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shader\-Program 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\-Shader\-Program class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shader\-Program = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shader\-Program = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-X\-M\-L\-Material = obj.\-Get\-Material ()}  
\item {\ttfamily obj.\-Set\-Material (vtk\-X\-M\-L\-Material )}  
\item {\ttfamily int = obj.\-Add\-Shader (vtk\-Shader shader)}  
\item {\ttfamily obj.\-Remove\-Shader (int index)} -\/ Remove a shader at the given index.  
\item {\ttfamily obj.\-Remove\-Shader (vtk\-Shader shader)} -\/ Removes the given shader.  
\item {\ttfamily vtk\-Collection\-Iterator = obj.\-New\-Shader\-Iterator ()} -\/ Returns a new iterator to iterate over the shaders.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Shaders ()} -\/ Returns the number of shaders available in this shader program.  
\item {\ttfamily obj.\-Read\-Material ()}  
\item {\ttfamily obj.\-Render (vtk\-Actor , vtk\-Renderer )}  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, int x)}  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, float x)}  
\item {\ttfamily obj.\-Add\-Shader\-Variable (string name, int num\-Vars, double x)}  
\item {\ttfamily obj.\-Post\-Render (vtk\-Actor , vtk\-Renderer )} -\/ Called to unload the shaders after the actor has been rendered.  
\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 vtk\-Shader\-Device\-Adapter = obj.\-Get\-Shader\-Device\-Adapter ()} -\/ Get the vtk\-Shader\-Device\-Adapter which can be used to execute this shader program.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkshadowmappass}{}\section{vtk\-Shadow\-Map\-Pass}\label{vtkrendering_vtkshadowmappass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Render the opaque polygonal geometry of a scene with shadow maps (a technique to render hard shadows in hardware).

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color. An opaque pass may have been performed right after the initialization.

Its delegate is usually set to a vtk\-Opaque\-Pass.

.S\-E\-C\-T\-I\-O\-N Implementation The first pass of the algorithm is to generate a shadow map per light (depth map from the light point of view) by rendering the opaque objects with the O\-C\-C\-L\-U\-D\-E\-R property keys. The second pass is to render the opaque objects with the R\-E\-C\-E\-I\-V\-E\-R keys.

To create an instance of class vtk\-Shadow\-Map\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkShadowMapPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Shadow\-Map\-Pass 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\-Shadow\-Map\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Shadow\-Map\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Shadow\-Map\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Opaque\-Pass ()} -\/ Delegate for rendering the opaque polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Opaque\-Pass (vtk\-Render\-Pass opaque\-Pass)} -\/ Delegate for rendering the opaque polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily vtk\-Render\-Pass = obj.\-Get\-Composite\-Z\-Pass ()} -\/ Delegate for rendering the opaque polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Composite\-Z\-Pass (vtk\-Render\-Pass opaque\-Pass)} -\/ Delegate for rendering the opaque polygonal geometry. If it is N\-U\-L\-L, nothing will be rendered and a warning will be emitted. It is usually set to a vtk\-Translucent\-Pass. Initial value is a N\-U\-L\-L pointer.  
\item {\ttfamily obj.\-Set\-Resolution (int )} -\/ Set/\-Get the number of pixels in each dimension of the shadow maps (shadow maps are square). Initial value is 256. The greater the better. Resolution does not have to be a power-\/of-\/two value.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the number of pixels in each dimension of the shadow maps (shadow maps are square). Initial value is 256. The greater the better. Resolution does not have to be a power-\/of-\/two value.  
\item {\ttfamily obj.\-Set\-Polygon\-Offset\-Factor (float )} -\/ Factor used to scale the maximum depth slope of a polygon (definition from Open\-G\-L 2.\-1 spec section 3.\-5.\-5 \char`\"{}\-Depth Offset\char`\"{} page 112). This is used during the creation the shadow maps (not during mapping of the shadow maps onto the geometry) Play with this value and Polygon\-Offset\-Units to solve self-\/shadowing. Valid values can be either positive or negative. Initial value is 1.\-1f (recommended by the n\-Vidia presentation about Shadow Mapping by Cass Everitt). 3.\-1f works well with the regression test.  
\item {\ttfamily float = obj.\-Get\-Polygon\-Offset\-Factor ()} -\/ Factor used to scale the maximum depth slope of a polygon (definition from Open\-G\-L 2.\-1 spec section 3.\-5.\-5 \char`\"{}\-Depth Offset\char`\"{} page 112). This is used during the creation the shadow maps (not during mapping of the shadow maps onto the geometry) Play with this value and Polygon\-Offset\-Units to solve self-\/shadowing. Valid values can be either positive or negative. Initial value is 1.\-1f (recommended by the n\-Vidia presentation about Shadow Mapping by Cass Everitt). 3.\-1f works well with the regression test.  
\item {\ttfamily obj.\-Set\-Polygon\-Offset\-Units (float )} -\/ Factor used to scale an implementation dependent constant that relates to the usable resolution of the depth buffer (definition from Open\-G\-L 2.\-1 spec section 3.\-5.\-5 \char`\"{}\-Depth Offset\char`\"{} page 112). This is used during the creation the shadow maps (not during mapping of the shadow maps onto the geometry) Play with this value and Polygon\-Offset\-Factor to solve self-\/shadowing. Valid values can be either positive or negative. Initial value is 4.\-0f (recommended by the n\-Vidia presentation about Shadow Mapping by Cass Everitt). 10.\-0f works well with the regression test.  
\item {\ttfamily float = obj.\-Get\-Polygon\-Offset\-Units ()} -\/ Factor used to scale an implementation dependent constant that relates to the usable resolution of the depth buffer (definition from Open\-G\-L 2.\-1 spec section 3.\-5.\-5 \char`\"{}\-Depth Offset\char`\"{} page 112). This is used during the creation the shadow maps (not during mapping of the shadow maps onto the geometry) Play with this value and Polygon\-Offset\-Factor to solve self-\/shadowing. Valid values can be either positive or negative. Initial value is 4.\-0f (recommended by the n\-Vidia presentation about Shadow Mapping by Cass Everitt). 10.\-0f works well with the regression test.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtksobelgradientmagnitudepass}{}\section{vtk\-Sobel\-Gradient\-Magnitude\-Pass}\label{vtkrendering_vtksobelgradientmagnitudepass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Detect the edges of the image renderered by its delegate. Edge-\/detection uses a Sobel high-\/pass filter (3x3 kernel).

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color. An opaque pass may have been performed right after the initialization.

The delegate is used once.

Its delegate is usually set to a vtk\-Camera\-Pass or to a post-\/processing pass.

This pass requires a Open\-G\-L context that supports texture objects (T\-O), framebuffer objects (F\-B\-O) and G\-L\-S\-L. If not, it will emit an error message and will render its delegate and return.

.S\-E\-C\-T\-I\-O\-N Implementation To compute the gradient magnitude, the x and y components of the gradient (Gx and Gy) have to be computed first. Each computation of Gx and Gy uses a separable filter. The first pass takes the image from the delegate as the single input texture. The first pass has two outputs, one for the first part of Gx, Gx1, result of a convolution with (-\/1 0 1), one for the first part of Gy, Gy1, result of a convolution with (1 2 1). The second pass has two inputs, Gx1 and Gy1. Kernel (1 2 1)$^\wedge$\-T is applied to Gx1 and kernel (-\/1 0 1)$^\wedge$\-T is applied to Gx2. It gives the values for Gx and Gy. Thoses values are then used to compute the magnitude of the gradient which is stored in the render target. The gradient computation happens per component (R,G,B). A is arbitrarly set to 1 (full opacity).

To create an instance of class vtk\-Sobel\-Gradient\-Magnitude\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSobelGradientMagnitudePass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sobel\-Gradient\-Magnitude\-Pass 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\-Sobel\-Gradient\-Magnitude\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sobel\-Gradient\-Magnitude\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sobel\-Gradient\-Magnitude\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Release graphics resources and ask components to release their own resources. \begin{DoxyPrecond}{Precondition}
w\-\_\-exists\-: w!=0  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkstandardpolydatapainter}{}\section{vtk\-Standard\-Poly\-Data\-Painter}\label{vtkrendering_vtkstandardpolydatapainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Standard\-Poly\-Data\-Painter is a catch-\/all painter. It should work with pretty much any vtk\-Poly\-Data, and attributes, and vtk\-Poly\-Data\-Painter\-Device\-Adapter. On the flip side, the vtk\-Standard\-Poly\-Data\-Painter will be slower than the more special purpose painters.

To create an instance of class vtk\-Standard\-Poly\-Data\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkStandardPolyDataPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Standard\-Poly\-Data\-Painter 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\-Standard\-Poly\-Data\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Standard\-Poly\-Data\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Standard\-Poly\-Data\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Multi\-Texture\-Coords\-Array (vtk\-Data\-Array array)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtksurfacelicdefaultpainter}{}\section{vtk\-Surface\-L\-I\-C\-Default\-Painter}\label{vtkrendering_vtksurfacelicdefaultpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Surface\-L\-I\-C\-Default\-Painter is a vtk\-Default\-Painter replacement that inserts the vtk\-Surface\-L\-I\-C\-Painter at the correct position in the painter chain.

To create an instance of class vtk\-Surface\-L\-I\-C\-Default\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSurfaceLICDefaultPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Surface\-L\-I\-C\-Default\-Painter 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\-Surface\-L\-I\-C\-Default\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Surface\-L\-I\-C\-Default\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Surface\-L\-I\-C\-Default\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Surface\-L\-I\-C\-Painter (vtk\-Surface\-L\-I\-C\-Painter )} -\/ Get/\-Set the Surface L\-I\-C painter.  
\item {\ttfamily vtk\-Surface\-L\-I\-C\-Painter = obj.\-Get\-Surface\-L\-I\-C\-Painter ()} -\/ Get/\-Set the Surface L\-I\-C painter.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtksurfacelicpainter}{}\section{vtk\-Surface\-L\-I\-C\-Painter}\label{vtkrendering_vtksurfacelicpainter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Surface\-L\-I\-C\-Painter painter performs L\-I\-C on the surface of arbitrary geometry. Point vectors are used as the vector field for generating the L\-I\-C. The implementation is based on \char`\"{}\-Image Space Based Visualization on Unstread
  Flow on Surfaces\char`\"{} by Laramee, Jobard and Hauser appered in proceedings of I\-E\-E\-E Visualization '03, pages 131-\/138.

To create an instance of class vtk\-Surface\-L\-I\-C\-Painter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSurfaceLICPainter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Surface\-L\-I\-C\-Painter 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\-Surface\-L\-I\-C\-Painter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Surface\-L\-I\-C\-Painter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Surface\-L\-I\-C\-Painter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this mapper. The parameter window could be used to determine which graphic resources to release. In this case, releases the display lists.  
\item {\ttfamily vtk\-Data\-Object = obj.\-Get\-Output ()} -\/ Get the output data object from this painter. Overridden to pass the input points (or cells) vectors as the tcoords to the deletage painters. This is required by the internal G\-L\-S\-L shader programs used for generating L\-I\-C.  
\item {\ttfamily obj.\-Set\-Enable (int )} -\/ Enable/\-Disable this painter.  
\item {\ttfamily int = obj.\-Get\-Enable ()} -\/ Enable/\-Disable this painter.  
\item {\ttfamily obj.\-Enable\-On ()} -\/ Enable/\-Disable this painter.  
\item {\ttfamily obj.\-Enable\-Off ()} -\/ Enable/\-Disable this painter.  
\item {\ttfamily obj.\-Set\-Input\-Array\-To\-Process (int field\-Association, string name)} -\/ Set the vectors to used for applying L\-I\-C. By default point vectors are used. Arguments are same as those passed to vtk\-Algorithm\-::\-Set\-Input\-Array\-To\-Process except the first 3 arguments i.\-e. idx, port, connection.  
\item {\ttfamily obj.\-Set\-Input\-Array\-To\-Process (int field\-Association, int field\-Attribute\-Type)} -\/ Set the vectors to used for applying L\-I\-C. By default point vectors are used. Arguments are same as those passed to vtk\-Algorithm\-::\-Set\-Input\-Array\-To\-Process except the first 3 arguments i.\-e. idx, port, connection.  
\item {\ttfamily obj.\-Set\-Enhanced\-L\-I\-C (int )} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily int = obj.\-Get\-Enhanced\-L\-I\-C ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Enhanced\-L\-I\-C\-On ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Enhanced\-L\-I\-C\-Off ()} -\/ Enable/\-Disable enhanced L\-I\-C that improves image quality by increasing inter-\/streamline contrast while suppressing artifacts. Enhanced L\-I\-C performs two passes of L\-I\-C, with a 3x3 Laplacian high-\/pass filter in between that processes the output of pass \#1 L\-I\-C and forwards the result as the input 'noise' to pass \#2 L\-I\-C. This flag is automatically turned off during user interaction.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Steps (int )} -\/ Get/\-Set the number of integration steps in each direction.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Steps ()} -\/ Get/\-Set the number of integration steps in each direction.  
\item {\ttfamily obj.\-Set\-Step\-Size (double )} -\/ Get/\-Set the step size (in pixels).  
\item {\ttfamily double = obj.\-Get\-Step\-Size ()} -\/ Get/\-Set the step size (in pixels).  
\item {\ttfamily obj.\-Set\-L\-I\-C\-Intensity (double )} -\/ Control the contribution of the L\-I\-C in the final output image. 0.\-0 produces same result as disabling L\-I\-C alltogether, while 1.\-0 implies show L\-I\-C result alone.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Intensity\-Min\-Value ()} -\/ Control the contribution of the L\-I\-C in the final output image. 0.\-0 produces same result as disabling L\-I\-C alltogether, while 1.\-0 implies show L\-I\-C result alone.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Intensity\-Max\-Value ()} -\/ Control the contribution of the L\-I\-C in the final output image. 0.\-0 produces same result as disabling L\-I\-C alltogether, while 1.\-0 implies show L\-I\-C result alone.  
\item {\ttfamily double = obj.\-Get\-L\-I\-C\-Intensity ()} -\/ Control the contribution of the L\-I\-C in the final output image. 0.\-0 produces same result as disabling L\-I\-C alltogether, while 1.\-0 implies show L\-I\-C result alone.  
\item {\ttfamily int = obj.\-Get\-Rendering\-Preparation\-Success ()} -\/ Check if the L\-I\-C process runs properly.  
\item {\ttfamily int = obj.\-Get\-L\-I\-C\-Success ()} -\/ Returns true is the rendering context supports extensions needed by this painter.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktdxinteractorstyle}{}\section{vtk\-T\-Dx\-Interactor\-Style}\label{vtkrendering_vtktdxinteractorstyle}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-T\-Dx\-Interactor\-Style is an abstract class defining an event-\/driven interface to support 3\-D\-Connexion device events send by vtk\-Render\-Window\-Interactor. vtk\-Render\-Window\-Interactor forwards events in a platform independent form to vtk\-Interactor\-Style which can then delegate some processing to vtk\-T\-Dx\-Interactor\-Style.

To create an instance of class vtk\-T\-Dx\-Interactor\-Style, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTDxInteractorStyle
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-T\-Dx\-Interactor\-Style 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\-T\-Dx\-Interactor\-Style class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style\-Settings = obj.\-Get\-Settings ()} -\/ 3\-Dconnexion device settings. (sensitivity, individual axis filters). Initial object is not null.  
\item {\ttfamily obj.\-Set\-Settings (vtk\-T\-Dx\-Interactor\-Style\-Settings settings)} -\/ 3\-Dconnexion device settings. (sensitivity, individual axis filters). Initial object is not null.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktdxinteractorstylecamera}{}\section{vtk\-T\-Dx\-Interactor\-Style\-Camera}\label{vtkrendering_vtktdxinteractorstylecamera}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-T\-Dx\-Interactor\-Style\-Camera allows the end-\/user to manipulate tha camera with a 3\-D\-Connexion device.

To create an instance of class vtk\-T\-Dx\-Interactor\-Style\-Camera, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTDxInteractorStyleCamera
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-T\-Dx\-Interactor\-Style\-Camera 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\-T\-Dx\-Interactor\-Style\-Camera class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style\-Camera = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style\-Camera = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktdxinteractorstylesettings}{}\section{vtk\-T\-Dx\-Interactor\-Style\-Settings}\label{vtkrendering_vtktdxinteractorstylesettings}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-T\-Dx\-Interactor\-Style\-Settings defines settings for 3\-D\-Connexion device such as sensitivity, axis filters

To create an instance of class vtk\-T\-Dx\-Interactor\-Style\-Settings, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTDxInteractorStyleSettings
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-T\-Dx\-Interactor\-Style\-Settings 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\-T\-Dx\-Interactor\-Style\-Settings class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style\-Settings = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-T\-Dx\-Interactor\-Style\-Settings = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Angle\-Sensitivity (double )} -\/ Sensitivity of the rotation angle. This can be any value\-: positive, negative, null.
\begin{DoxyItemize}
\item x$<$-\/1.\-0\-: faster reversed
\item x=-\/1.\-0\-: reversed neutral
\item -\/1.\-0$<$x$<$0.\-0\-: reversed slower
\item x=0.\-0\-: no rotation
\item 0.\-0$<$x$<$1.\-0\-: slower
\item x=1.\-0\-: neutral
\item x$>$1.\-0\-: faster  
\end{DoxyItemize}
\item {\ttfamily double = obj.\-Get\-Angle\-Sensitivity ()} -\/ Sensitivity of the rotation angle. This can be any value\-: positive, negative, null.
\begin{DoxyItemize}
\item x$<$-\/1.\-0\-: faster reversed
\item x=-\/1.\-0\-: reversed neutral
\item -\/1.\-0$<$x$<$0.\-0\-: reversed slower
\item x=0.\-0\-: no rotation
\item 0.\-0$<$x$<$1.\-0\-: slower
\item x=1.\-0\-: neutral
\item x$>$1.\-0\-: faster  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Use\-Rotation\-X (bool )} -\/ Use or mask the rotation component around the X-\/axis. Initial value is true.  
\item {\ttfamily bool = obj.\-Get\-Use\-Rotation\-X ()} -\/ Use or mask the rotation component around the X-\/axis. Initial value is true.  
\item {\ttfamily obj.\-Set\-Use\-Rotation\-Y (bool )} -\/ Use or mask the rotation component around the Y-\/axis. Initial value is true.  
\item {\ttfamily bool = obj.\-Get\-Use\-Rotation\-Y ()} -\/ Use or mask the rotation component around the Y-\/axis. Initial value is true.  
\item {\ttfamily obj.\-Set\-Use\-Rotation\-Z (bool )} -\/ Use or mask the rotation component around the Z-\/axis. Initial value is true.  
\item {\ttfamily bool = obj.\-Get\-Use\-Rotation\-Z ()} -\/ Use or mask the rotation component around the Z-\/axis. Initial value is true.  
\item {\ttfamily obj.\-Set\-Translation\-X\-Sensitivity (double )} -\/ Sensitivity of the translation along the X-\/axis. This can be any value\-: positive, negative, null.
\begin{DoxyItemize}
\item x$<$-\/1.\-0\-: faster reversed
\item x=-\/1.\-0\-: reversed neutral
\item -\/1.\-0$<$x$<$0.\-0\-: reversed slower
\item x=0.\-0\-: no translation
\item 0.\-0$<$x$<$1.\-0\-: slower
\item x=1.\-0\-: neutral
\item x$>$1.\-0\-: faster Initial value is 1.\-0  
\end{DoxyItemize}
\item {\ttfamily double = obj.\-Get\-Translation\-X\-Sensitivity ()} -\/ Sensitivity of the translation along the X-\/axis. This can be any value\-: positive, negative, null.
\begin{DoxyItemize}
\item x$<$-\/1.\-0\-: faster reversed
\item x=-\/1.\-0\-: reversed neutral
\item -\/1.\-0$<$x$<$0.\-0\-: reversed slower
\item x=0.\-0\-: no translation
\item 0.\-0$<$x$<$1.\-0\-: slower
\item x=1.\-0\-: neutral
\item x$>$1.\-0\-: faster Initial value is 1.\-0  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Translation\-Y\-Sensitivity (double )} -\/ Sensitivity of the translation along the Y-\/axis. See comment of Set\-Translation\-X\-Sensitivity().  
\item {\ttfamily double = obj.\-Get\-Translation\-Y\-Sensitivity ()} -\/ Sensitivity of the translation along the Y-\/axis. See comment of Set\-Translation\-X\-Sensitivity().  
\item {\ttfamily obj.\-Set\-Translation\-Z\-Sensitivity (double )} -\/ Sensitivity of the translation along the Z-\/axis. See comment of Set\-Translation\-X\-Sensitivity().  
\item {\ttfamily double = obj.\-Get\-Translation\-Z\-Sensitivity ()} -\/ Sensitivity of the translation along the Z-\/axis. See comment of Set\-Translation\-X\-Sensitivity().  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktesting}{}\section{vtk\-Testing}\label{vtkrendering_vtktesting}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This is a V\-T\-K regression testing framework. Looks like this\-:

vtk\-Testing$\ast$ t = vtk\-Testing\-::\-New();

Two options for setting arguments

Option 1\-: for ( cc = 1; cc $<$ argc; cc ++ ) \{ t-\/$>$Add\-Argument(argv\mbox{[}cc\mbox{]}); \}

Option 2\-: t-\/$>$Add\-Argument(\char`\"{}-\/\-D\char`\"{}); t-\/$>$Add\-Argument(my\-\_\-data\-\_\-dir); t-\/$>$Add\-Argument(\char`\"{}-\/\-V\char`\"{}); t-\/$>$Add\-Argument(my\-\_\-valid\-\_\-image);

...

Two options of doing testing\-:

Option 1\-: t-\/$>$Set\-Render\-Window(ren\-Win); int res = t-\/$>$Regression\-Test(threshold);

Option 2\-: int res = t-\/$>$Regression\-Test(test\-\_\-image, threshold);

...

if ( res == vtk\-Testing\-::\-P\-A\-S\-S\-E\-D ) \{ Test passed \} else \{ Test failed \}

To create an instance of class vtk\-Testing, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTesting
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Testing 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\-Testing class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Testing = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Testing = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Front\-Buffer (int )} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily int = obj.\-Get\-Front\-Buffer\-Min\-Value ()} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily int = obj.\-Get\-Front\-Buffer\-Max\-Value ()} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily obj.\-Front\-Buffer\-On ()} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily obj.\-Front\-Buffer\-Off ()} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily int = obj.\-Get\-Front\-Buffer ()} -\/ Use front buffer for tests. By default use back buffer.  
\item {\ttfamily int = obj.\-Regression\-Test (double thresh)} -\/ Perform the test and return result. At the same time the output will be written cout  
\item {\ttfamily int = obj.\-Regression\-Test (vtk\-Image\-Data image, double thresh)} -\/ Compare the image with the valid image.  
\item {\ttfamily int = obj.\-Compare\-Average\-Of\-L2\-Norm (vtk\-Data\-Set pd\-A, vtk\-Data\-Set pd\-B, double tol)} -\/ Compute the average L2 norm between all point data data arrays of types float and double present in the data sets \char`\"{}ds\-A\char`\"{} and \char`\"{}ds\-B\char`\"{} (this includes instances of vtk\-Points) Compare the result of each L2 comutation to \char`\"{}tol\char`\"{}.  
\item {\ttfamily int = obj.\-Compare\-Average\-Of\-L2\-Norm (vtk\-Data\-Array da\-A, vtk\-Data\-Array da\-B, double tol)} -\/ Compute the average L2 norm between two data arrays \char`\"{}da\-A\char`\"{} and \char`\"{}da\-B\char`\"{} and compare against \char`\"{}tol\char`\"{}.  
\item {\ttfamily obj.\-Set\-Render\-Window (vtk\-Render\-Window rw)} -\/ Set and get the render window that will be used for regression testing.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Render\-Window ()} -\/ Set and get the render window that will be used for regression testing.  
\item {\ttfamily obj.\-Set\-Valid\-Image\-File\-Name (string )} -\/ Set/\-Get the name of the valid image file  
\item {\ttfamily string = obj.\-Get\-Valid\-Image\-File\-Name ()} -\/ Set/\-Get the name of the valid image file  
\item {\ttfamily double = obj.\-Get\-Image\-Difference ()} -\/ Get the image difference.  
\item {\ttfamily obj.\-Add\-Argument (string argv)} -\/ Pass the command line arguments into this class to be processed. Many of the Get methods such as Get\-Valid\-Image and Get\-Baseline\-Root rely on the arguments to be passed in prior to retrieving these values. Just call Add\-Argument for each argument that was passed into the command line  
\item {\ttfamily obj.\-Clean\-Arguments ()}  
\item {\ttfamily string = obj.\-Get\-Data\-Root ()} -\/ Get some paramters from the command line arguments, env, or defaults  
\item {\ttfamily obj.\-Set\-Data\-Root (string )} -\/ Get some paramters from the command line arguments, env, or defaults  
\item {\ttfamily string = obj.\-Get\-Temp\-Directory ()} -\/ Get some paramters from the command line arguments, env, or defaults  
\item {\ttfamily obj.\-Set\-Temp\-Directory (string )} -\/ Get some paramters from the command line arguments, env, or defaults  
\item {\ttfamily int = obj.\-Is\-Valid\-Image\-Specified ()} -\/ Is a valid image specified on the command line areguments?  
\item {\ttfamily int = obj.\-Is\-Interactive\-Mode\-Specified ()} -\/ Is the interactive mode specified?  
\item {\ttfamily int = obj.\-Is\-Flag\-Specified (string flag)} -\/ Is some arbitrary user flag (\char`\"{}-\/\-X\char`\"{}, \char`\"{}-\/\-Z\char`\"{} etc) specified  
\item {\ttfamily obj.\-Set\-Border\-Offset (int )} -\/ Number of pixels added as borders to avoid problems with window decorations added by some window managers.  
\item {\ttfamily int = obj.\-Get\-Border\-Offset ()} -\/ Number of pixels added as borders to avoid problems with window decorations added by some window managers.  
\item {\ttfamily obj.\-Set\-Verbose (int )} -\/ Get/\-Set verbosity level. A level of 0 is quiet.  
\item {\ttfamily int = obj.\-Get\-Verbose ()} -\/ Get/\-Set verbosity level. A level of 0 is quiet.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktextactor}{}\section{vtk\-Text\-Actor}\label{vtkrendering_vtktextactor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Text\-Actor can be used to place text annotation into a window. When Text\-Scale\-Mode is N\-O\-N\-E, the text is fixed font and operation is the same as a vtk\-Poly\-Data\-Mapper2\-D/vtk\-Actor2\-D pair. When Text\-Scale\-Mode is V\-I\-E\-W\-P\-O\-R\-T, the font resizes such that it maintains a consistent size relative to the viewport in which it is rendered. When Text\-Scale\-Mode is P\-R\-O\-P, the font resizes such that the text fits inside the box defined by the position 1 \& 2 coordinates. This class replaces the deprecated vtk\-Scaled\-Text\-Actor and acts as a convenient wrapper for a vtk\-Text\-Mapper/vtk\-Actor2\-D pair. Set the text property/attributes through the vtk\-Text\-Property associated to this actor.

To create an instance of class vtk\-Text\-Actor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextActor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-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\-Text\-Actor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Text\-Actor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Text\-Actor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this text actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily obj.\-Set\-Mapper (vtk\-Poly\-Data\-Mapper2\-D mapper)} -\/ Override the vtk\-Poly\-Data\-Mapper2\-D that defines the text to be drawn. One will be created by default if none is supplied  
\item {\ttfamily obj.\-Set\-Input (string input\-String)} -\/ Set the text string to be displayed. \char`\"{}\textbackslash{}n\char`\"{} is recognized as a carriage return/linefeed (line separator). Only 7-\/bit A\-S\-C\-I\-I is allowed (anything else, such as Latin1 or U\-T\-F8, is not acceptable). Convenience method to the underlying mapper  
\item {\ttfamily string = obj.\-Get\-Input ()} -\/ Set the text string to be displayed. \char`\"{}\textbackslash{}n\char`\"{} is recognized as a carriage return/linefeed (line separator). Only 7-\/bit A\-S\-C\-I\-I is allowed (anything else, such as Latin1 or U\-T\-F8, is not acceptable). Convenience method to the underlying mapper  
\item {\ttfamily obj.\-Set\-Minimum\-Size (int , int )} -\/ Set/\-Get the minimum size in pixels for this actor. Defaults to 10,10. Only valid when Text\-Scale\-Mode is P\-R\-O\-P.  
\item {\ttfamily obj.\-Set\-Minimum\-Size (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the minimum size in pixels for this actor. Defaults to 10,10. Only valid when Text\-Scale\-Mode is P\-R\-O\-P.  
\item {\ttfamily int = obj. Get\-Minimum\-Size ()} -\/ Set/\-Get the minimum size in pixels for this actor. Defaults to 10,10. Only valid when Text\-Scale\-Mode is P\-R\-O\-P.  
\item {\ttfamily obj.\-Set\-Maximum\-Line\-Height (float )} -\/ 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. Only valid when Text\-Scale\-Mode is P\-R\-O\-P.  
\item {\ttfamily float = 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. Only valid when Text\-Scale\-Mode is P\-R\-O\-P.  
\item {\ttfamily obj.\-Set\-Text\-Scale\-Mode (int )} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily int = obj.\-Get\-Text\-Scale\-Mode\-Min\-Value ()} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily int = obj.\-Get\-Text\-Scale\-Mode\-Max\-Value ()} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily int = obj.\-Get\-Text\-Scale\-Mode ()} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily obj.\-Set\-Text\-Scale\-Mode\-To\-None ()} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily obj.\-Set\-Text\-Scale\-Mode\-To\-Prop ()} -\/ Set how text should be scaled. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-N\-O\-N\-E, the the font size will be fixed by the size given in Text\-Property. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-P\-R\-O\-P, the text will be scaled to fit exactly in the prop as specified by the position 1 \& 2 coordinates. If set to vtk\-Text\-Actor\-::\-T\-E\-X\-T\-\_\-\-S\-C\-A\-L\-E\-\_\-\-M\-O\-D\-E\-\_\-\-V\-I\-E\-W\-P\-O\-R\-T, the text will be scaled based on the size of the viewport it is displayed in.  
\item {\ttfamily obj.\-Set\-Text\-Scale\-Mode\-To\-Viewport ()} -\/ D\-O N\-O\-T C\-A\-L\-L. Deprecated in V\-T\-K 5.\-4. Use Set\-Text\-Scale\-Mode or Get\-Text\-Scale\-Mode instead.  
\item {\ttfamily obj.\-Set\-Scaled\-Text (int )} -\/ D\-O N\-O\-T C\-A\-L\-L. Deprecated in V\-T\-K 5.\-4. Use Set\-Text\-Scale\-Mode or Get\-Text\-Scale\-Mode instead.  
\item {\ttfamily int = obj.\-Get\-Scaled\-Text ()} -\/ D\-O N\-O\-T C\-A\-L\-L. Deprecated in V\-T\-K 5.\-4. Use Set\-Text\-Scale\-Mode or Get\-Text\-Scale\-Mode instead.  
\item {\ttfamily obj.\-Scaled\-Text\-On ()} -\/ D\-O N\-O\-T C\-A\-L\-L. Deprecated in V\-T\-K 5.\-4. Use Set\-Text\-Scale\-Mode or Get\-Text\-Scale\-Mode instead.  
\item {\ttfamily obj.\-Scaled\-Text\-Off ()} -\/ D\-O N\-O\-T C\-A\-L\-L. Deprecated in V\-T\-K 5.\-4. Use Set\-Text\-Scale\-Mode or Get\-Text\-Scale\-Mode instead.  
\item {\ttfamily obj.\-Set\-Use\-Border\-Align (int )} -\/ Turn on or off the Use\-Border\-Align option. When Use\-Border\-Align is on, the bounding rectangle is used to align the text, which is the proper behavior when using vtk\-Text\-Representation  
\item {\ttfamily int = obj.\-Get\-Use\-Border\-Align ()} -\/ Turn on or off the Use\-Border\-Align option. When Use\-Border\-Align is on, the bounding rectangle is used to align the text, which is the proper behavior when using vtk\-Text\-Representation  
\item {\ttfamily obj.\-Use\-Border\-Align\-On ()} -\/ Turn on or off the Use\-Border\-Align option. When Use\-Border\-Align is on, the bounding rectangle is used to align the text, which is the proper behavior when using vtk\-Text\-Representation  
\item {\ttfamily obj.\-Use\-Border\-Align\-Off ()} -\/ Turn on or off the Use\-Border\-Align option. When Use\-Border\-Align is on, the bounding rectangle is used to align the text, which is the proper behavior when using vtk\-Text\-Representation  
\item {\ttfamily obj.\-Set\-Alignment\-Point (int point)} -\/ This method is being depricated. Use Set\-Justification and Set\-Vertical\-Justification in text property instead. Set/\-Get the Alignment point if zero (default), the text aligns itself to the bottom left corner (which is defined by the Position\-Coordinate) otherwise the text aligns itself to corner/midpoint or centre \begin{DoxyVerb}      6   7   8
      3   4   5
      0   1   2\end{DoxyVerb}
 This is the same as setting the Text\-Property's justification. Currently Text\-Actor is not oriented around its Alignment\-Point.  
\item {\ttfamily int = obj.\-Get\-Alignment\-Point ()} -\/ This method is being depricated. Use Set\-Justification and Set\-Vertical\-Justification in text property instead. Set/\-Get the Alignment point if zero (default), the text aligns itself to the bottom left corner (which is defined by the Position\-Coordinate) otherwise the text aligns itself to corner/midpoint or centre \begin{DoxyVerb}      6   7   8
      3   4   5
      0   1   2\end{DoxyVerb}
 This is the same as setting the Text\-Property's justification. Currently Text\-Actor is not oriented around its Alignment\-Point.  
\item {\ttfamily obj.\-Set\-Orientation (float orientation)} -\/ Counterclockwise rotation around the Alignment point. Units are in degrees and defaults to 0. The orientation in the text property rotates the text in the texture map. It will proba ly not give you the effect you desire.  
\item {\ttfamily float = obj.\-Get\-Orientation ()} -\/ Counterclockwise rotation around the Alignment point. Units are in degrees and defaults to 0. The orientation in the text property rotates the text in the texture map. It will proba ly not give you the effect you desire.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the text property.  
\item {\ttfamily obj.\-Set\-Non\-Linear\-Font\-Scale (double exponent, int target)} -\/ Enable non-\/linear scaling of font sizes. This is useful in combination with scaled text. With small windows you want to use the entire scaled text area. With larger windows you want to reduce the font size some so that the entire area is not used. These values modify the computed font size as follows\-: new\-Font\-Size = pow(\-Font\-Size,exponent)$\ast$pow(target,1.\-0 -\/ exponent) typically exponent should be around 0.\-7 and target should be around 10  
\item {\ttfamily obj.\-Specified\-To\-Display (double pos, vtk\-Viewport vport, int specified)} -\/ This is just a simple coordinate conversion method used in the render process.  
\item {\ttfamily obj.\-Display\-To\-Specified (double pos, vtk\-Viewport vport, int specified)} -\/ This is just a simple coordinate conversion method used in the render process.  
\item {\ttfamily obj.\-Compute\-Scaled\-Font (vtk\-Viewport viewport)} -\/ Compute the scale the font should be given the viewport. The result is placed in the Scaled\-Text\-Property ivar.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Scaled\-Text\-Property ()} -\/ Get the scaled font. Use Compute\-Scaled\-Font to set the scale for a given viewport.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktextactor3d}{}\section{vtk\-Text\-Actor3\-D}\label{vtkrendering_vtktextactor3d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The input text is rendered into a buffer, which in turn is used as a texture applied onto a quad (a vtk\-Image\-Actor is used under the hood). .S\-E\-C\-T\-I\-O\-N Warning This class is experimental at the moment.
\begin{DoxyItemize}
\item The orientation is not optimized, the quad should be oriented, not the text itself when it is rendered in the buffer (we end up with excessively big textures for 45 degrees angles). This will be fixed first.
\item No checking is done at the moment regarding hardware texture size limits.
\item Alignment is not supported (soon).
\item Multiline is not supported.
\item Need to fix angle out of 0$<$-\/$>$360
\end{DoxyItemize}

To create an instance of class vtk\-Text\-Actor3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextActor3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-Actor3\-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\-Text\-Actor3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Text\-Actor3\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Text\-Actor3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (string )} -\/ Set the text string to be displayed.  
\item {\ttfamily string = obj.\-Get\-Input ()} -\/ Set the text string to be displayed.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the text property.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this text actor. Overloads the virtual vtk\-Prop method.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds for this Prop3\-D as (Xmin,Xmax,Ymin,Ymax,Zmin,Zmax). These are the padded-\/to-\/power-\/of-\/two texture bounds.  
\item {\ttfamily int = obj.\-Get\-Bounding\-Box (int bbox\mbox{[}4\mbox{]})} -\/ Get the Freetype-\/derived real bounding box for the given vtk\-Text\-Property and text string str. Results are returned in the four element bbox int array. This call can be used for sizing other elements.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktextmapper}{}\section{vtk\-Text\-Mapper}\label{vtkrendering_vtktextmapper}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Text\-Mapper provides 2\-D text annotation support for V\-T\-K. It is a vtk\-Mapper2\-D that can be associated with a vtk\-Actor2\-D and placed into a vtk\-Renderer.

To use vtk\-Text\-Mapper, specify an input text string.

To create an instance of class vtk\-Text\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-Mapper has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Text\-Mapper class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Text\-Mapper = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Text\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Get\-Size (vtk\-Viewport , int size\mbox{[}2\mbox{]})} -\/ Return the size\mbox{[}2\mbox{]}/width/height of the rectangle required to draw this mapper (in pixels).  
\item {\ttfamily int = obj.\-Get\-Width (vtk\-Viewport v)} -\/ Return the size\mbox{[}2\mbox{]}/width/height of the rectangle required to draw this mapper (in pixels).  
\item {\ttfamily int = obj.\-Get\-Height (vtk\-Viewport v)} -\/ Return the size\mbox{[}2\mbox{]}/width/height of the rectangle required to draw this mapper (in pixels).  
\item {\ttfamily obj.\-Set\-Input (string input\-String)} -\/ Set the input text string to the mapper. The mapper recognizes \char`\"{}\textbackslash{}n\char`\"{} as a carriage return/linefeed (line separator).  
\item {\ttfamily string = obj.\-Get\-Input ()} -\/ Set the input text string to the mapper. The mapper recognizes \char`\"{}\textbackslash{}n\char`\"{} as a carriage return/linefeed (line separator).  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/\-Get the text property.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the text property.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Text\-Mapper tm)} -\/ Shallow copy of an actor.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Lines (string input)} -\/ Determine the number of lines in the input string (delimited by \char`\"{}\textbackslash{}n\char`\"{}).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Lines ()} -\/ Get the number of lines in the input string (the method Get\-Number\-Of\-Lines(char$\ast$) must have been previously called for the return value to be valid).  
\item {\ttfamily int = obj.\-Set\-Constrained\-Font\-Size (vtk\-Viewport , int target\-Width, int target\-Height)} -\/ Set and return the font size required to make this mapper fit in a given target rectangle (width x height, in pixels). A static version of the method is also available for convenience to other classes (e.\-g., widgets).  
\item {\ttfamily int = obj.\-Get\-System\-Font\-Size (int size)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktextproperty}{}\section{vtk\-Text\-Property}\label{vtkrendering_vtktextproperty}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Text\-Property is an object that represents text properties. The primary properties that can be set are color, opacity, font size, font family horizontal and vertical justification, bold/italic/shadow styles.

To create an instance of class vtk\-Text\-Property, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextProperty
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-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\-Text\-Property class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Text\-Property = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Text\-Property = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Color (double , double , double )} -\/ Set the color of the text.  
\item {\ttfamily obj.\-Set\-Color (double a\mbox{[}3\mbox{]})} -\/ Set the color of the text.  
\item {\ttfamily double = obj. Get\-Color ()} -\/ Set the color of the text.  
\item {\ttfamily obj.\-Set\-Opacity (double )} -\/ Set/\-Get the text's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily double = obj.\-Get\-Opacity ()} -\/ Set/\-Get the text's opacity. 1.\-0 is totally opaque and 0.\-0 is completely transparent.  
\item {\ttfamily string = obj.\-Get\-Font\-Family\-As\-String ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Family\-As\-String (string )} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Family (int t)} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily int = obj.\-Get\-Font\-Family ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily int = obj.\-Get\-Font\-Family\-Min\-Value ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Family\-To\-Arial ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Family\-To\-Courier ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Family\-To\-Times ()} -\/ Set/\-Get the font family. Supports legacy three font family system.  
\item {\ttfamily obj.\-Set\-Font\-Size (int )} -\/ Set/\-Get the font size (in points).  
\item {\ttfamily int = obj.\-Get\-Font\-Size\-Min\-Value ()} -\/ Set/\-Get the font size (in points).  
\item {\ttfamily int = obj.\-Get\-Font\-Size\-Max\-Value ()} -\/ Set/\-Get the font size (in points).  
\item {\ttfamily int = obj.\-Get\-Font\-Size ()} -\/ Set/\-Get the font size (in points).  
\item {\ttfamily obj.\-Set\-Bold (int )} -\/ Enable/disable text bolding.  
\item {\ttfamily int = obj.\-Get\-Bold ()} -\/ Enable/disable text bolding.  
\item {\ttfamily obj.\-Bold\-On ()} -\/ Enable/disable text bolding.  
\item {\ttfamily obj.\-Bold\-Off ()} -\/ Enable/disable text bolding.  
\item {\ttfamily obj.\-Set\-Italic (int )} -\/ Enable/disable text italic.  
\item {\ttfamily int = obj.\-Get\-Italic ()} -\/ Enable/disable text italic.  
\item {\ttfamily obj.\-Italic\-On ()} -\/ Enable/disable text italic.  
\item {\ttfamily obj.\-Italic\-Off ()} -\/ Enable/disable text italic.  
\item {\ttfamily obj.\-Set\-Shadow (int )} -\/ Enable/disable text shadow.  
\item {\ttfamily int = obj.\-Get\-Shadow ()} -\/ Enable/disable text shadow.  
\item {\ttfamily obj.\-Shadow\-On ()} -\/ Enable/disable text shadow.  
\item {\ttfamily obj.\-Shadow\-Off ()} -\/ Enable/disable text shadow.  
\item {\ttfamily obj.\-Set\-Shadow\-Offset (int , int )} -\/ Set/\-Get the shadow offset, i.\-e. the distance from the text to its shadow, in the same unit as Font\-Size.  
\item {\ttfamily obj.\-Set\-Shadow\-Offset (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the shadow offset, i.\-e. the distance from the text to its shadow, in the same unit as Font\-Size.  
\item {\ttfamily int = obj. Get\-Shadow\-Offset ()} -\/ Set/\-Get the shadow offset, i.\-e. the distance from the text to its shadow, in the same unit as Font\-Size.  
\item {\ttfamily obj.\-Get\-Shadow\-Color (double color\mbox{[}3\mbox{]})} -\/ Get the shadow color. It is computed from the Color ivar  
\item {\ttfamily obj.\-Set\-Justification (int )} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily int = obj.\-Get\-Justification\-Min\-Value ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily int = obj.\-Get\-Justification\-Max\-Value ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily int = obj.\-Get\-Justification ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily obj.\-Set\-Justification\-To\-Left ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily obj.\-Set\-Justification\-To\-Centered ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily obj.\-Set\-Justification\-To\-Right ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily string = obj.\-Get\-Justification\-As\-String ()} -\/ Set/\-Get the horizontal justification to left (default), centered, or right.  
\item {\ttfamily obj.\-Set\-Vertical\-Justification (int )} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily int = obj.\-Get\-Vertical\-Justification\-Min\-Value ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily int = obj.\-Get\-Vertical\-Justification\-Max\-Value ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily int = obj.\-Get\-Vertical\-Justification ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily obj.\-Set\-Vertical\-Justification\-To\-Bottom ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily obj.\-Set\-Vertical\-Justification\-To\-Centered ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily obj.\-Set\-Vertical\-Justification\-To\-Top ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily string = obj.\-Get\-Vertical\-Justification\-As\-String ()} -\/ Set/\-Get the vertical justification to bottom (default), middle, or top.  
\item {\ttfamily obj.\-Set\-Orientation (double )} -\/ Set/\-Get the text's orientation (in degrees).  
\item {\ttfamily double = obj.\-Get\-Orientation ()} -\/ Set/\-Get the text's orientation (in degrees).  
\item {\ttfamily obj.\-Set\-Line\-Spacing (double )} -\/ Set/\-Get the (extra) spacing between lines, expressed as a text height multiplication factor.  
\item {\ttfamily double = obj.\-Get\-Line\-Spacing ()} -\/ Set/\-Get the (extra) spacing between lines, expressed as a text height multiplication factor.  
\item {\ttfamily obj.\-Set\-Line\-Offset (double )} -\/ Set/\-Get the vertical offset (measured in pixels).  
\item {\ttfamily double = obj.\-Get\-Line\-Offset ()} -\/ Set/\-Get the vertical offset (measured in pixels).  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Text\-Property tprop)} -\/ Shallow copy of a text property.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktexture}{}\section{vtk\-Texture}\label{vtkrendering_vtktexture}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Texture is an object that handles loading and binding of texture maps. It obtains its data from an input image data dataset type. Thus you can create visualization pipelines to read, process, and construct textures. Note that textures will only work if texture coordinates are also defined, and if the rendering system supports texture.

Instances of vtk\-Texture are associated with actors via the actor's Set\-Texture() method. Actors can share texture maps (this is encouraged to save memory resources.)

To create an instance of class vtk\-Texture, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTexture
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Texture 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\-Texture class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Texture = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Texture = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Render (vtk\-Renderer ren)} -\/ Renders a texture map. It first checks the object's modified time to make sure the texture maps Input is valid, then it invokes the Load() method.  
\item {\ttfamily obj.\-Post\-Render (vtk\-Renderer )} -\/ Cleans up after the texture rendering to restore the state of the graphics context.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Release any graphics resources that are being consumed by this texture. The parameter window could be used to determine which graphic resources to release.  
\item {\ttfamily obj.\-Load (vtk\-Renderer )} -\/ Abstract interface to renderer. Each concrete subclass of vtk\-Texture will load its data into graphics system in response to this method invocation.  
\item {\ttfamily int = obj.\-Get\-Repeat ()} -\/ Turn on/off the repetition of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range.  
\item {\ttfamily obj.\-Set\-Repeat (int )} -\/ Turn on/off the repetition of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range.  
\item {\ttfamily obj.\-Repeat\-On ()} -\/ Turn on/off the repetition of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range.  
\item {\ttfamily obj.\-Repeat\-Off ()} -\/ Turn on/off the repetition of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range.  
\item {\ttfamily int = obj.\-Get\-Edge\-Clamp ()} -\/ Turn on/off the clamping of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range. Only used when Repeat is off, and edge clamping is supported by the graphics card.  
\item {\ttfamily obj.\-Set\-Edge\-Clamp (int )} -\/ Turn on/off the clamping of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range. Only used when Repeat is off, and edge clamping is supported by the graphics card.  
\item {\ttfamily obj.\-Edge\-Clamp\-On ()} -\/ Turn on/off the clamping of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range. Only used when Repeat is off, and edge clamping is supported by the graphics card.  
\item {\ttfamily obj.\-Edge\-Clamp\-Off ()} -\/ Turn on/off the clamping of the texture map when the texture coords extend beyond the \mbox{[}0,1\mbox{]} range. Only used when Repeat is off, and edge clamping is supported by the graphics card.  
\item {\ttfamily int = obj.\-Get\-Interpolate ()} -\/ Turn on/off linear interpolation of the texture map when rendering.  
\item {\ttfamily obj.\-Set\-Interpolate (int )} -\/ Turn on/off linear interpolation of the texture map when rendering.  
\item {\ttfamily obj.\-Interpolate\-On ()} -\/ Turn on/off linear interpolation of the texture map when rendering.  
\item {\ttfamily obj.\-Interpolate\-Off ()} -\/ Turn on/off linear interpolation of the texture map when rendering.  
\item {\ttfamily obj.\-Set\-Quality (int )} -\/ Force texture quality to 16-\/bit or 32-\/bit. This might not be supported on all machines.  
\item {\ttfamily int = obj.\-Get\-Quality ()} -\/ Force texture quality to 16-\/bit or 32-\/bit. This might not be supported on all machines.  
\item {\ttfamily obj.\-Set\-Quality\-To\-Default ()} -\/ Force texture quality to 16-\/bit or 32-\/bit. This might not be supported on all machines.  
\item {\ttfamily obj.\-Set\-Quality\-To16\-Bit ()} -\/ Force texture quality to 16-\/bit or 32-\/bit. This might not be supported on all machines.  
\item {\ttfamily obj.\-Set\-Quality\-To32\-Bit ()} -\/ Force texture quality to 16-\/bit or 32-\/bit. This might not be supported on all machines.  
\item {\ttfamily int = obj.\-Get\-Map\-Color\-Scalars\-Through\-Lookup\-Table ()} -\/ Turn on/off the mapping of color scalars through the lookup table. The default is Off. If Off, unsigned char scalars will be used directly as texture. If On, scalars will be mapped through the lookup table to generate 4-\/component unsigned char scalars. This ivar does not affect other scalars like unsigned short, float, etc. These scalars are always mapped through lookup tables.  
\item {\ttfamily obj.\-Set\-Map\-Color\-Scalars\-Through\-Lookup\-Table (int )} -\/ Turn on/off the mapping of color scalars through the lookup table. The default is Off. If Off, unsigned char scalars will be used directly as texture. If On, scalars will be mapped through the lookup table to generate 4-\/component unsigned char scalars. This ivar does not affect other scalars like unsigned short, float, etc. These scalars are always mapped through lookup tables.  
\item {\ttfamily obj.\-Map\-Color\-Scalars\-Through\-Lookup\-Table\-On ()} -\/ Turn on/off the mapping of color scalars through the lookup table. The default is Off. If Off, unsigned char scalars will be used directly as texture. If On, scalars will be mapped through the lookup table to generate 4-\/component unsigned char scalars. This ivar does not affect other scalars like unsigned short, float, etc. These scalars are always mapped through lookup tables.  
\item {\ttfamily obj.\-Map\-Color\-Scalars\-Through\-Lookup\-Table\-Off ()} -\/ Turn on/off the mapping of color scalars through the lookup table. The default is Off. If Off, unsigned char scalars will be used directly as texture. If On, scalars will be mapped through the lookup table to generate 4-\/component unsigned char scalars. This ivar does not affect other scalars like unsigned short, float, etc. These scalars are always mapped through lookup tables.  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Scalars\-To\-Colors )} -\/ Specify the lookup table to convert scalars if necessary  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Lookup\-Table ()} -\/ Specify the lookup table to convert scalars if necessary  
\item {\ttfamily vtk\-Unsigned\-Char\-Array = obj.\-Get\-Mapped\-Scalars ()} -\/ Get Mapped Scalars  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform transform)} -\/ Set a transform on the texture which allows one to scale, rotate and translate the texture.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()} -\/ Set a transform on the texture which allows one to scale, rotate and translate the texture.  
\item {\ttfamily int = obj.\-Get\-Blending\-Mode ()} -\/ Used to specify how the texture will blend its R\-G\-B and Alpha values with other textures and the fragment the texture is rendered upon.  
\item {\ttfamily obj.\-Set\-Blending\-Mode (int )} -\/ Used to specify how the texture will blend its R\-G\-B and Alpha values with other textures and the fragment the texture is rendered upon.  
\item {\ttfamily bool = obj.\-Get\-Premultiplied\-Alpha ()} -\/ Whether the texture colors are premultiplied by alpha. Initial value is false.  
\item {\ttfamily obj.\-Set\-Premultiplied\-Alpha (bool )} -\/ Whether the texture colors are premultiplied by alpha. Initial value is false.  
\item {\ttfamily obj.\-Premultiplied\-Alpha\-On ()} -\/ Whether the texture colors are premultiplied by alpha. Initial value is false.  
\item {\ttfamily obj.\-Premultiplied\-Alpha\-Off ()} -\/ Whether the texture colors are premultiplied by alpha. Initial value is false.  
\item {\ttfamily int = obj.\-Get\-Restrict\-Power\-Of2\-Image\-Smaller ()} -\/ When the texture is forced to be a power of 2, the default behavior is for the \char`\"{}new\char`\"{} image's dimensions to be greater than or equal to with respects to the original. Setting Restrict\-Power\-Of2\-Image\-Smaller to be 1 (or O\-N) with force the new image's dimensions to be less than or equal to with respects to the original.  
\item {\ttfamily obj.\-Set\-Restrict\-Power\-Of2\-Image\-Smaller (int )} -\/ When the texture is forced to be a power of 2, the default behavior is for the \char`\"{}new\char`\"{} image's dimensions to be greater than or equal to with respects to the original. Setting Restrict\-Power\-Of2\-Image\-Smaller to be 1 (or O\-N) with force the new image's dimensions to be less than or equal to with respects to the original.  
\item {\ttfamily obj.\-Restrict\-Power\-Of2\-Image\-Smaller\-On ()} -\/ When the texture is forced to be a power of 2, the default behavior is for the \char`\"{}new\char`\"{} image's dimensions to be greater than or equal to with respects to the original. Setting Restrict\-Power\-Of2\-Image\-Smaller to be 1 (or O\-N) with force the new image's dimensions to be less than or equal to with respects to the original.  
\item {\ttfamily obj.\-Restrict\-Power\-Of2\-Image\-Smaller\-Off ()} -\/ When the texture is forced to be a power of 2, the default behavior is for the \char`\"{}new\char`\"{} image's dimensions to be greater than or equal to with respects to the original. Setting Restrict\-Power\-Of2\-Image\-Smaller to be 1 (or O\-N) with force the new image's dimensions to be less than or equal to with respects to the original.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktexturedactor2d}{}\section{vtk\-Textured\-Actor2\-D}\label{vtkrendering_vtktexturedactor2d}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Textured\-Actor2\-D is an Actor2\-D which has additional support for textures, just like vtk\-Actor. To use textures, the geometry must have texture coordinates, and the texture must be set with Set\-Texture().

To create an instance of class vtk\-Textured\-Actor2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTexturedActor2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Textured\-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\-Textured\-Actor2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Textured\-Actor2\-D = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Textured\-Actor2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Texture (vtk\-Texture texture)} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. An actor does not need to have an associated texture map and multiple actors can share one texture.  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture ()} -\/ Set/\-Get the texture object to control rendering texture maps. This will be a vtk\-Texture object. An actor does not need to have an associated texture map and multiple actors can share one texture.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window win)} -\/ 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 int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Support the standard render methods.  
\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 long = obj.\-Get\-M\-Time ()} -\/ Return this object's modified time.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this vtk\-Textured\-Actor2\-D. Overrides vtk\-Actor2\-D method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktextureobject}{}\section{vtk\-Texture\-Object}\label{vtkrendering_vtktextureobject}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Texture\-Object represents an Open\-G\-L texture object. It provides A\-P\-I to create textures using data already loaded into pixel buffer objects. It can also be used to create textures without uploading any data.

To create an instance of class vtk\-Texture\-Object, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextureObject
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Texture\-Object 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\-Texture\-Object class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Texture\-Object = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Texture\-Object = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Context (vtk\-Render\-Window )} -\/ Get/\-Set the context. 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.  
\item {\ttfamily vtk\-Render\-Window = obj.\-Get\-Context ()} -\/ Get/\-Set the context. 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.  
\item {\ttfamily int = obj.\-Get\-Width ()} -\/ Get the texture dimensions. These are the properties of the Open\-G\-L texture this instance represents.  
\item {\ttfamily int = obj.\-Get\-Height ()} -\/ Get the texture dimensions. These are the properties of the Open\-G\-L texture this instance represents.  
\item {\ttfamily int = obj.\-Get\-Depth ()} -\/ Get the texture dimensions. These are the properties of the Open\-G\-L texture this instance represents.  
\item {\ttfamily int = obj.\-Get\-Components ()} -\/ Get the texture dimensions. These are the properties of the Open\-G\-L texture this instance represents.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Dimensions ()}  
\item {\ttfamily int = obj.\-Get\-Target ()} -\/ Returns Open\-G\-L texture target to which the texture is/can be bound.  
\item {\ttfamily int = obj.\-Get\-Handle ()} -\/ Returns the Open\-G\-L handle.  
\item {\ttfamily obj.\-Bind ()} -\/ Activate the texture. The texture must have been created using Create(). Render\-Window must be set before calling this.  
\item {\ttfamily obj.\-Un\-Bind ()} -\/ Activate the texture. The texture must have been created using Create(). Render\-Window must be set before calling this.  
\item {\ttfamily bool = obj.\-Is\-Bound ()} -\/ Tells if the texture object is bound to the active texture image unit. (a texture object can be bound to multiple texture image unit).  
\item {\ttfamily obj.\-Send\-Parameters ()} -\/ Send all the texture object parameters to the hardware if not done yet. \begin{DoxyPrecond}{Precondition}
is\-\_\-bound\-: Is\-Bound()  
\end{DoxyPrecond}

\item {\ttfamily bool = obj.\-Create1\-D (int num\-Comps, vtk\-Pixel\-Buffer\-Object pbo, bool shader\-Supports\-Texture\-Int)} -\/ Create a 1\-D texture using the P\-B\-O. Eventually we may start supporting creating a texture from subset of data in the P\-B\-O, but for simplicity we'll begin with entire P\-B\-O data. num\-Comps must be in \mbox{[}1-\/4\mbox{]}. shader\-Supports\-Texture\-Int is true if the shader has an alternate implementation supporting sampler with integer values. Even if the card supports texture int, it does not mean that the implementor of the shader made a version that supports texture int.  
\item {\ttfamily bool = obj.\-Create2\-D (int width, int height, int num\-Comps, vtk\-Pixel\-Buffer\-Object pbo, bool shader\-Supports\-Texture\-Int)} -\/ Create a 2\-D texture using the P\-B\-O. Eventually we may start supporting creating a texture from subset of data in the P\-B\-O, but for simplicity we'll begin with entire P\-B\-O data. num\-Comps must be in \mbox{[}1-\/4\mbox{]}.  
\item {\ttfamily bool = obj.\-Create\-Depth (int width, int height, int internal\-Format, vtk\-Pixel\-Buffer\-Object pbo)} -\/ Create a 2\-D depth texture using a P\-B\-O. \begin{DoxyPrecond}{Precondition}
\-: valid\-\_\-internal\-Format\-: internal\-Format$>$=0 \&\& internal\-Format$<$Number\-Of\-Depth\-Formats  
\end{DoxyPrecond}

\item {\ttfamily bool = obj.\-Allocate\-Depth (int width, int height, int internal\-Format)} -\/ Create a 2\-D depth texture but does not initialize its values.  
\item {\ttfamily bool = obj.\-Allocate1\-D (int width, int num\-Comps, int vtk\-Type)} -\/ Create a 1\-D color texture but does not initialize its values. Internal format is deduced from num\-Comps and vtk\-Type.  
\item {\ttfamily bool = obj.\-Allocate2\-D (int width, int height, int num\-Comps, int vtk\-Type)} -\/ Create a 2\-D color texture but does not initialize its values. Internal format is deduced from num\-Comps and vtk\-Type.  
\item {\ttfamily bool = obj.\-Allocate3\-D (int width, int height, int depth, int num\-Comps, int vtk\-Type)} -\/ Create a 3\-D color texture but does not initialize its values. Internal format is deduced from num\-Comps and vtk\-Type.  
\item {\ttfamily bool = obj.\-Create3\-D (int width, int height, int depth, int num\-Comps, vtk\-Pixel\-Buffer\-Object pbo, bool shader\-Supports\-Texture\-Int)} -\/ Create a 3\-D texture using the P\-B\-O. Eventually we may start supporting creating a texture from subset of data in the P\-B\-O, but for simplicity we'll begin with entire P\-B\-O data. num\-Comps must be in \mbox{[}1-\/4\mbox{]}.  
\item {\ttfamily bool = obj.\-Create2\-D (int width, int height, int num\-Comps, int vtktype, bool shader\-Supports\-Texture\-Int)} -\/ Create texture without uploading any data. To create a D\-E\-P\-T\-H\-\_\-\-C\-O\-M\-P\-O\-N\-E\-N\-T texture, vtktype must be set to V\-T\-K\-\_\-\-V\-O\-I\-D and num\-Comps must be 1.  
\item {\ttfamily bool = obj.\-Create3\-D (int width, int height, int depth, int num\-Comps, int vtktype, bool shader\-Supports\-Texture\-Int)} -\/ Create texture without uploading any data. To create a D\-E\-P\-T\-H\-\_\-\-C\-O\-M\-P\-O\-N\-E\-N\-T texture, vtktype must be set to V\-T\-K\-\_\-\-V\-O\-I\-D and num\-Comps must be 1.  
\item {\ttfamily vtk\-Pixel\-Buffer\-Object = obj.\-Download ()} -\/ This is used to download raw data from the texture into a pixel bufer. The pixel buffer A\-P\-I can then be used to download the pixel buffer data to C\-P\-U arrays. The caller takes on the responsibility of deleting the returns vtk\-Pixel\-Buffer\-Object once it done with it.  
\item {\ttfamily int = obj.\-Get\-Data\-Type ()} -\/ Get the data type for the texture as a vtk type int i.\-e. V\-T\-K\-\_\-\-I\-N\-T etc.  
\item {\ttfamily int = obj.\-Get\-Internal\-Format (int vtktype, int num\-Comps, bool shader\-Supports\-Texture\-Int)}  
\item {\ttfamily int = obj.\-Get\-Format (int vtktype, int num\-Comps, bool shader\-Supports\-Texture\-Int)}  
\item {\ttfamily int = obj.\-Get\-Wrap\-S ()} -\/ Wrap mode for the first texture coordinate \char`\"{}s\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Wrap\-S (int )} -\/ Wrap mode for the first texture coordinate \char`\"{}s\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Wrap\-T ()} -\/ Wrap mode for the first texture coordinate \char`\"{}t\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Wrap\-T (int )} -\/ Wrap mode for the first texture coordinate \char`\"{}t\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Wrap\-R ()} -\/ Wrap mode for the first texture coordinate \char`\"{}r\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Wrap\-R (int )} -\/ Wrap mode for the first texture coordinate \char`\"{}r\char`\"{} Valid values are\-:
\begin{DoxyItemize}
\item Clamp
\item Clamp\-To\-Edge
\item Repeat
\item Clamp\-To\-Border
\item Mirrored\-Repeat Initial value is Repeat (as in Open\-G\-L spec)  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Minification\-Filter ()} -\/ Minification filter mode. Valid values are\-:
\begin{DoxyItemize}
\item Nearest
\item Linear
\item Nearest\-Mipmap\-Nearest
\item Nearest\-Mipmap\-Linear
\item Linear\-Mipmap\-Nearest
\item Linear\-Mipmap\-Linear Initial value is Nearest (note initial value in Open\-G\-L spec is Nearest\-Mip\-Map\-Linear but this is error-\/prone because it makes the texture object incomplete. ).  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Minification\-Filter (int )} -\/ Minification filter mode. Valid values are\-:
\begin{DoxyItemize}
\item Nearest
\item Linear
\item Nearest\-Mipmap\-Nearest
\item Nearest\-Mipmap\-Linear
\item Linear\-Mipmap\-Nearest
\item Linear\-Mipmap\-Linear Initial value is Nearest (note initial value in Open\-G\-L spec is Nearest\-Mip\-Map\-Linear but this is error-\/prone because it makes the texture object incomplete. ).  
\end{DoxyItemize}
\item {\ttfamily bool = obj.\-Get\-Linear\-Magnification ()} -\/ Tells if the magnification mode is linear (true) or nearest (false). Initial value is false (initial value in Open\-G\-L spec is true).  
\item {\ttfamily obj.\-Set\-Linear\-Magnification (bool )} -\/ Tells if the magnification mode is linear (true) or nearest (false). Initial value is false (initial value in Open\-G\-L spec is true).  
\item {\ttfamily obj.\-Set\-Border\-Color (float , float , float , float )} -\/ Border Color (R\-G\-B\-A). Each component is in \mbox{[}0.\-0f,1.\-0f\mbox{]}. Initial value is (0.\-0f,0.\-0f,0.\-0f,0.\-0f), as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Border\-Color (float a\mbox{[}4\mbox{]})} -\/ Border Color (R\-G\-B\-A). Each component is in \mbox{[}0.\-0f,1.\-0f\mbox{]}. Initial value is (0.\-0f,0.\-0f,0.\-0f,0.\-0f), as in Open\-G\-L spec.  
\item {\ttfamily float = obj. Get\-Border\-Color ()} -\/ Border Color (R\-G\-B\-A). Each component is in \mbox{[}0.\-0f,1.\-0f\mbox{]}. Initial value is (0.\-0f,0.\-0f,0.\-0f,0.\-0f), as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Priority (float )} -\/ Priority of the texture object to be resident on the card for higher performance in the range \mbox{[}0.\-0f,1.\-0f\mbox{]}. Initial value is 1.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily float = obj.\-Get\-Priority ()} -\/ Priority of the texture object to be resident on the card for higher performance in the range \mbox{[}0.\-0f,1.\-0f\mbox{]}. Initial value is 1.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Min\-L\-O\-D (float )} -\/ Lower-\/clamp the computed L\-O\-D against this value. Any float value is valid. Initial value is -\/1000.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily float = obj.\-Get\-Min\-L\-O\-D ()} -\/ Lower-\/clamp the computed L\-O\-D against this value. Any float value is valid. Initial value is -\/1000.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Max\-L\-O\-D (float )} -\/ Upper-\/clamp the computed L\-O\-D against this value. Any float value is valid. Initial value is 1000.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily float = obj.\-Get\-Max\-L\-O\-D ()} -\/ Upper-\/clamp the computed L\-O\-D against this value. Any float value is valid. Initial value is 1000.\-0f, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Base\-Level (int )} -\/ Level of detail of the first texture image. A texture object is a list of texture images. It is a non-\/negative integer value. Initial value is 0, as in Open\-G\-L spec.  
\item {\ttfamily int = obj.\-Get\-Base\-Level ()} -\/ Level of detail of the first texture image. A texture object is a list of texture images. It is a non-\/negative integer value. Initial value is 0, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Max\-Level (int )} -\/ Level of detail of the first texture image. A texture object is a list of texture images. It is a non-\/negative integer value. Initial value is 1000, as in Open\-G\-L spec.  
\item {\ttfamily int = obj.\-Get\-Max\-Level ()} -\/ Level of detail of the first texture image. A texture object is a list of texture images. It is a non-\/negative integer value. Initial value is 1000, as in Open\-G\-L spec.  
\item {\ttfamily bool = obj.\-Get\-Depth\-Texture\-Compare ()} -\/ Tells if the output of a texture unit with a depth texture uses comparison or not. Comparison happens between D\-\_\-t the depth texture value in the range \mbox{[}0,1\mbox{]} and with R the interpolated third texture coordinate clamped to range \mbox{[}0,1\mbox{]}. The result of the comparison is noted `r'. If this flag is false, r=D\-\_\-t. Initial value is false, as in Open\-G\-L spec. Ignored if the texture object is not a depth texture.  
\item {\ttfamily obj.\-Set\-Depth\-Texture\-Compare (bool )} -\/ Tells if the output of a texture unit with a depth texture uses comparison or not. Comparison happens between D\-\_\-t the depth texture value in the range \mbox{[}0,1\mbox{]} and with R the interpolated third texture coordinate clamped to range \mbox{[}0,1\mbox{]}. The result of the comparison is noted `r'. If this flag is false, r=D\-\_\-t. Initial value is false, as in Open\-G\-L spec. Ignored if the texture object is not a depth texture.  
\item {\ttfamily int = obj.\-Get\-Depth\-Texture\-Compare\-Function ()} -\/ In case Depth\-Texture\-Compare is true, specify the comparison function in use. The result of the comparison is noted `r'. Valid values are\-:
\begin{DoxyItemize}
\item Value
\item Lequal\-: r=R$<$=Dt ? 1.\-0 \-: 0.\-0
\item Gequal\-: r=R$>$=Dt ? 1.\-0 \-: 0.\-0
\item Less\-: r=R$<$D\-\_\-t ? 1.\-0 \-: 0.\-0
\item Greater\-: r=R$>$Dt ? 1.\-0 \-: 0.\-0
\item Equal\-: r=R==Dt ? 1.\-0 \-: 0.\-0
\item Not\-Equal\-: r=R!=Dt ? 1.\-0 \-: 0.\-0
\item Always\-True\-: r=1.\-0
\item Never\-: r=0.\-0 If the magnification of minification factor are not nearest, percentage closer filtering (P\-C\-F) is used\-: R is compared to several D\-\_\-t and r is the average of the comparisons (it is N\-O\-T the average of D\-\_\-t compared once to R). Initial value is Lequal, as in Open\-G\-L spec. Ignored if the texture object is not a depth texture.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Depth\-Texture\-Compare\-Function (int )} -\/ In case Depth\-Texture\-Compare is true, specify the comparison function in use. The result of the comparison is noted `r'. Valid values are\-:
\begin{DoxyItemize}
\item Value
\item Lequal\-: r=R$<$=Dt ? 1.\-0 \-: 0.\-0
\item Gequal\-: r=R$>$=Dt ? 1.\-0 \-: 0.\-0
\item Less\-: r=R$<$D\-\_\-t ? 1.\-0 \-: 0.\-0
\item Greater\-: r=R$>$Dt ? 1.\-0 \-: 0.\-0
\item Equal\-: r=R==Dt ? 1.\-0 \-: 0.\-0
\item Not\-Equal\-: r=R!=Dt ? 1.\-0 \-: 0.\-0
\item Always\-True\-: r=1.\-0
\item Never\-: r=0.\-0 If the magnification of minification factor are not nearest, percentage closer filtering (P\-C\-F) is used\-: R is compared to several D\-\_\-t and r is the average of the comparisons (it is N\-O\-T the average of D\-\_\-t compared once to R). Initial value is Lequal, as in Open\-G\-L spec. Ignored if the texture object is not a depth texture.  
\end{DoxyItemize}
\item {\ttfamily int = obj.\-Get\-Depth\-Texture\-Mode ()} -\/ Defines the mapping from depth component `r' to R\-G\-B\-A components. Ignored if the texture object is not a depth texture. Valid modes are\-:
\begin{DoxyItemize}
\item Luminance\-: (R,G,B,A)=(r,r,r,1)
\item Intensity\-: (R,G,B,A)=(r,r,r,r)
\item Alpha\-: (R.\-G.\-B.\-A)=(0,0,0,r) Initial value is Luminance, as in Open\-G\-L spec.  
\end{DoxyItemize}
\item {\ttfamily obj.\-Set\-Depth\-Texture\-Mode (int )} -\/ Defines the mapping from depth component `r' to R\-G\-B\-A components. Ignored if the texture object is not a depth texture. Valid modes are\-:
\begin{DoxyItemize}
\item Luminance\-: (R,G,B,A)=(r,r,r,1)
\item Intensity\-: (R,G,B,A)=(r,r,r,r)
\item Alpha\-: (R.\-G.\-B.\-A)=(0,0,0,r) Initial value is Luminance, as in Open\-G\-L spec.  
\end{DoxyItemize}
\item {\ttfamily bool = obj.\-Get\-Generate\-Mipmap ()} -\/ Tells the hardware to generate mipmap textures from the first texture image at Base\-Level. Initial value is false, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Set\-Generate\-Mipmap (bool )} -\/ Tells the hardware to generate mipmap textures from the first texture image at Base\-Level. Initial value is false, as in Open\-G\-L spec.  
\item {\ttfamily obj.\-Copy\-To\-Frame\-Buffer (int src\-Xmin, int src\-Ymin, int src\-Xmax, int src\-Ymax, int dst\-Xmin, int dst\-Ymin, int width, int height)} -\/ Copy a sub-\/part of the texture (src) in the current framebuffer at location (dst\-Xmin,dst\-Ymin). (dst\-Xmin,dst\-Ymin) is the location of the lower left corner of the rectangle. width and height are the dimensions of the framebuffer.
\begin{DoxyItemize}
\item texture coordinates are sent on texture coordinate processing unit 0.
\item if the fixed-\/pipeline fragment shader is used, texturing has to be set on texture image unit 0 and the texture object has to be bound on texture image unit 0.
\item if a customized fragment shader is used, you are free to pick the texture image unit you want. You can even have multiple texture objects attached on multiple texture image units. In this case, you call this method only on one of them. \begin{DoxyPrecond}{Precondition}
positive\-\_\-src\-Xmin\-: src\-Xmin$>$=0 

max\-\_\-src\-Xmax\-: src\-Xmax$<$this-\/$>$Get\-Width() 

increasing\-\_\-x\-: src\-Xmin$<$=src\-Xmax 

positive\-\_\-src\-Ymin\-: src\-Ymin$>$=0 

max\-\_\-src\-Ymax\-: src\-Ymax$<$this-\/$>$Get\-Height() 

increasing\-\_\-y\-: src\-Ymin$<$=src\-Ymax 

positive\-\_\-dst\-Xmin\-: dst\-Xmin$>$=0 

positive\-\_\-dst\-Ymin\-: dst\-Ymin$>$=0 

positive\-\_\-width\-: width$>$0 

positive\-\_\-height\-: height$>$0 

x\-\_\-fit\-: dest\-Xmin+(src\-Xmax-\/src\-Xmin)$<$width 

y\-\_\-fit\-: dest\-Ymin+(src\-Ymax-\/src\-Ymin)$<$height  
\end{DoxyPrecond}

\end{DoxyItemize}
\item {\ttfamily obj.\-Copy\-From\-Frame\-Buffer (int src\-Xmin, int src\-Ymin, int dst\-Xmin, int dst\-Ymin, int width, int height)} -\/ Copy a sub-\/part of a logical buffer of the framebuffer (color or depth) to the texture object. src is the framebuffer, dst is the texture. (src\-Xmin,src\-Ymin) is the location of the lower left corner of the rectangle in the framebuffer. (dst\-Xmin,dst\-Ymin) is the location of the lower left corner of the rectangle in the texture. width and height specifies the size of the rectangle in pixels. If the logical buffer is a color buffer, it has to be selected first with gl\-Read\-Buffer(). \begin{DoxyPrecond}{Precondition}
is2\-D\-: Get\-Number\-Of\-Dimensions()==2  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtktransforminterpolator}{}\section{vtk\-Transform\-Interpolator}\label{vtkrendering_vtktransforminterpolator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to interpolate a series of 4x4 transformation matrices. Position, scale and orientation (i.\-e., rotations) are interpolated separately, and can be interpolated linearly or with a spline function. Note that orientation is interpolated using quaternions via S\-L\-E\-R\-P (spherical linear interpolation) or the special vtk\-Quaternion\-Spline class.

To use this class, specify at least two pairs of (t,transformation matrix) with the Add\-Transform() method. Then interpolated the transforms with the Interpolate\-Transform(t,transform) method, where \char`\"{}t\char`\"{} must be in the range of (min,max) times specified by the Add\-Transform() method.

By default, spline interpolation is used for the interpolation of the transformation matrices. The position, scale and orientation of the matrices are interpolated with instances of the classes vtk\-Tuple\-Interpolator (position,scale) and vtk\-Quaternion\-Interpolator (rotation). The user can override the interpolation behavior by gaining access to these separate interpolation classes. These interpolator classes (vtk\-Tuple\-Interpolator and vtk\-Quaternion\-Interpolator) can be modified to perform linear versus spline interpolation, and/or different spline basis functions can be specified.

To create an instance of class vtk\-Transform\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTransformInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Transform\-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\-Transform\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Transform\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Transform\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Transforms ()} -\/ Return the number of transforms in the list of transforms.  
\item {\ttfamily double = obj.\-Get\-Minimum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty.  
\item {\ttfamily double = obj.\-Get\-Maximum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty.  
\item {\ttfamily obj.\-Initialize ()} -\/ Clear the list of transforms.  
\item {\ttfamily obj.\-Add\-Transform (double t, vtk\-Transform xform)} -\/ Add another transform to the list of transformations defining the transform function. Note that using the same time t value more than once replaces the previous transform value at t. At least two transforms must be added to define a function. There are variants to this method depending on whether you are adding a vtk\-Transform, vtk\-Maxtirx4x4, and/or vtk\-Prop3\-D.  
\item {\ttfamily obj.\-Add\-Transform (double t, vtk\-Matrix4x4 matrix)} -\/ Add another transform to the list of transformations defining the transform function. Note that using the same time t value more than once replaces the previous transform value at t. At least two transforms must be added to define a function. There are variants to this method depending on whether you are adding a vtk\-Transform, vtk\-Maxtirx4x4, and/or vtk\-Prop3\-D.  
\item {\ttfamily obj.\-Add\-Transform (double t, vtk\-Prop3\-D prop3\-D)} -\/ Add another transform to the list of transformations defining the transform function. Note that using the same time t value more than once replaces the previous transform value at t. At least two transforms must be added to define a function. There are variants to this method depending on whether you are adding a vtk\-Transform, vtk\-Maxtirx4x4, and/or vtk\-Prop3\-D.  
\item {\ttfamily obj.\-Remove\-Transform (double t)} -\/ Delete the transform at a particular parameter t. If there is no transform defined at location t, then the method does nothing.  
\item {\ttfamily obj.\-Interpolate\-Transform (double t, vtk\-Transform xform)} -\/ Interpolate the list of transforms and determine a new transform (i.\-e., fill in the transformation provided). If t is outside the range of (min,max) values, then t is clamped.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type (int )} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Min\-Value ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Max\-Value ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Linear ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Spline ()} -\/ These are convenience methods to switch between linear and spline interpolation. The methods simply forward the request for linear or spline interpolation to the position, scale and orientation interpolators. Note that if the Interpolation\-Type is set to \char`\"{}\-Manual\char`\"{}, then the interpolators are expected to be directly manipulated and this class does not forward the request for interpolation type to its interpolators.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Manual ()} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily obj.\-Set\-Position\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Position\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the position portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily obj.\-Set\-Scale\-Interpolator (vtk\-Tuple\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the scale portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Get\-Scale\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the scale portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily obj.\-Set\-Rotation\-Interpolator (vtk\-Quaternion\-Interpolator )} -\/ Set/\-Get the tuple interpolator used to interpolate the orientation portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily vtk\-Quaternion\-Interpolator = obj.\-Get\-Rotation\-Interpolator ()} -\/ Set/\-Get the tuple interpolator used to interpolate the orientation portion of the transformation matrix. Note that you can modify the behavior of the interpolator (linear vs spline interpolation; change spline basis) by manipulating the interpolator instances.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time() because we depend on the interpolators which may be modified outside of this class.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktranslucentpass}{}\section{vtk\-Translucent\-Pass}\label{vtkrendering_vtktranslucentpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Translucent\-Pass renders the translucent polygonal geometry of all the props that have the keys contained in vtk\-Render\-State.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color.

To create an instance of class vtk\-Translucent\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTranslucentPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Translucent\-Pass 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\-Translucent\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Translucent\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Translucent\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtktupleinterpolator}{}\section{vtk\-Tuple\-Interpolator}\label{vtkrendering_vtktupleinterpolator}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to interpolate a tuple which may have an arbitrary number of components (but at least one component). The interpolation may be linear in form, or via a subclasses of vtk\-Spline.

To use this class, begin by specifying the number of components of the tuple and the interpolation function to use. Then specify at least one pair of (t,tuple) with the Add\-Tuple() method. Next interpolate the tuples with the Interpolate\-Tuple(t,tuple) method, where \char`\"{}t\char`\"{} must be in the range of (t\-\_\-min,t\-\_\-max) parameter values specified by the Add\-Tuple() method (if not then t is clamped), and tuple\mbox{[}\mbox{]} is filled in by the method (make sure that tuple \mbox{[}\mbox{]} is long enough to hold the interpolated data).

You can control the type of interpolation to use. By default, the interpolation is based on a Kochanek spline. However, other types of splines can be specified. You can also set the interpolation method to linear, in which case the specified spline has no effect on the interpolation.

To create an instance of class vtk\-Tuple\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTupleInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tuple\-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\-Tuple\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Tuple\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Number\-Of\-Components (int num\-Comp)} -\/ Specify the number of tuple components to interpolate. Note that setting this value discards any previously inserted data.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Components ()} -\/ Specify the number of tuple components to interpolate. Note that setting this value discards any previously inserted data.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Tuples ()} -\/ Return the number of tuples in the list of tuples to be interpolated.  
\item {\ttfamily double = obj.\-Get\-Minimum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty. This is a convenience method for interpolation.  
\item {\ttfamily double = obj.\-Get\-Maximum\-T ()} -\/ Obtain some information about the interpolation range. The numbers returned (corresponding to parameter t, usually thought of as time) are undefined if the list of transforms is empty. This is a convenience method for interpolation.  
\item {\ttfamily obj.\-Initialize ()} -\/ Reset the class so that it contains no (t,tuple) information.  
\item {\ttfamily obj.\-Add\-Tuple (double t, double tuple\mbox{[}\mbox{]})} -\/ Add another tuple to the list of tuples to be interpolated. Note that using the same time t value more than once replaces the previous tuple value at t. At least two tuples must be added to define an interpolation function.  
\item {\ttfamily obj.\-Remove\-Tuple (double t)} -\/ Delete the tuple at a particular parameter t. If there is no tuple defined at t, then the method does nothing.  
\item {\ttfamily obj.\-Interpolate\-Tuple (double t, double tuple\mbox{[}\mbox{]})} -\/ Interpolate the list of tuples and determine a new tuple (i.\-e., fill in the tuple provided). If t is outside the range of (min,max) values, then t is clamped. Note that each component of tuple\mbox{[}\mbox{]} is interpolated independently.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type (int type)} -\/ Specify which type of function to use for interpolation. By default spline interpolation (Set\-Interpolation\-Function\-To\-Spline()) is used (i.\-e., a Kochanek spline) and the Interpolating\-Spline instance variable is used to birth the actual interpolation splines via a combination of New\-Instance() and Deep\-Copy(). You may also choose to use linear interpolation by invoking Set\-Interpolation\-Function\-To\-Linear(). Note that changing the type of interpolation causes previously inserted data to be discarded.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type ()} -\/ Specify which type of function to use for interpolation. By default spline interpolation (Set\-Interpolation\-Function\-To\-Spline()) is used (i.\-e., a Kochanek spline) and the Interpolating\-Spline instance variable is used to birth the actual interpolation splines via a combination of New\-Instance() and Deep\-Copy(). You may also choose to use linear interpolation by invoking Set\-Interpolation\-Function\-To\-Linear(). Note that changing the type of interpolation causes previously inserted data to be discarded.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Linear ()} -\/ Specify which type of function to use for interpolation. By default spline interpolation (Set\-Interpolation\-Function\-To\-Spline()) is used (i.\-e., a Kochanek spline) and the Interpolating\-Spline instance variable is used to birth the actual interpolation splines via a combination of New\-Instance() and Deep\-Copy(). You may also choose to use linear interpolation by invoking Set\-Interpolation\-Function\-To\-Linear(). Note that changing the type of interpolation causes previously inserted data to be discarded.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Spline ()} -\/ If the Interpolation\-Type is set to spline, then this method applies. By default Kochanek interpolation is used, but you can specify any instance of vtk\-Spline to use. Note that the actual interpolating splines are created by invoking New\-Instance() followed by Deep\-Copy() on the interpolating spline specified here, for each tuple component to interpolate.  
\item {\ttfamily obj.\-Set\-Interpolating\-Spline (vtk\-Spline )} -\/ If the Interpolation\-Type is set to spline, then this method applies. By default Kochanek interpolation is used, but you can specify any instance of vtk\-Spline to use. Note that the actual interpolating splines are created by invoking New\-Instance() followed by Deep\-Copy() on the interpolating spline specified here, for each tuple component to interpolate.  
\item {\ttfamily vtk\-Spline = obj.\-Get\-Interpolating\-Spline ()} -\/ If the Interpolation\-Type is set to spline, then this method applies. By default Kochanek interpolation is used, but you can specify any instance of vtk\-Spline to use. Note that the actual interpolating splines are created by invoking New\-Instance() followed by Deep\-Copy() on the interpolating spline specified here, for each tuple component to interpolate.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkuniformvariables}{}\section{vtk\-Uniform\-Variables}\label{vtkrendering_vtkuniformvariables}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Uniform\-Variables is a list of uniform variables attached to either a vtk\-Shader2 object or to a vtk\-Shader\-Program2. Uniform variables on a vtk\-Shader\-Program2 override values of uniform variables on a vtk\-Shader2.

To create an instance of class vtk\-Uniform\-Variables, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkUniformVariables
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Uniform\-Variables 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\-Uniform\-Variables class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Uniform\-Variables = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Uniform\-Variables = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Uniformi (string name, int number\-Of\-Components, int value)} -\/ Set an integer uniform variable. \begin{DoxyPrecond}{Precondition}
name\-\_\-exists\-: name!=0 

value\-\_\-exists\-: value!=0 

valid\-\_\-number\-Of\-Components\-: number\-Of\-Components$>$=1 \&\& number\-Of\-Components$<$=4  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Uniformf (string name, int number\-Of\-Components, float value)} -\/ Set an float uniform variable. \begin{DoxyPrecond}{Precondition}
name\-\_\-exists\-: name!=0 

value\-\_\-exists\-: value!=0 

valid\-\_\-number\-Of\-Components\-: number\-Of\-Components$>$=1 \&\& number\-Of\-Components$<$=4  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Uniformiv (string name, int number\-Of\-Components, int number\-Of\-Elements, int value)} -\/ Set an array of integer uniform variables. The array `value' is of size `number\-Of\-Elements'$\ast$`number\-Of\-Components.'. \begin{DoxyPrecond}{Precondition}
name\-\_\-exists\-: name!=0 

value\-\_\-exists\-: value!=0 

valid\-\_\-number\-Of\-Components\-: number\-Of\-Components$>$=1 \&\& number\-Of\-Components$<$=4 

valid\-\_\-number\-Of\-Elements\-: number\-Of\-Elements$>$=1  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Uniformfv (string name, int number\-Of\-Components, int number\-Of\-Elements, float value)} -\/ Set an array of float uniform variables. The array `value' is of size `number\-Of\-Elements'$\ast$`number\-Of\-Components.'. \begin{DoxyPrecond}{Precondition}
name\-\_\-exists\-: name!=0 

value\-\_\-exists\-: value!=0 

valid\-\_\-number\-Of\-Components\-: number\-Of\-Components$>$=1 \&\& number\-Of\-Components$<$=4 

valid\-\_\-number\-Of\-Elements\-: number\-Of\-Elements$>$=1  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Set\-Uniform\-Matrix (string name, int rows, int columns, float value)} -\/ Set a matrix uniform variable. \begin{DoxyPrecond}{Precondition}
name\-\_\-exists\-: name!=0 

value\-\_\-exists\-: value!=0 

valid\-\_\-rows\-: rows$>$=2 \&\& rows$<$=4 

valid\-\_\-columns\-: columns$>$=2 \&\& columns$<$=4  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Remove\-Uniform (string name)} -\/ Remove uniform `name' from the list.  
\item {\ttfamily obj.\-Remove\-All\-Uniforms ()} -\/ Remove all uniforms from the list.  
\item {\ttfamily obj.\-Send (string name, int uniform\-Index)} -\/ \begin{DoxyPrecond}{Precondition}
need a valid Open\-G\-L context and a shader program in use.  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Start ()} -\/ Place the internal cursor on the first uniform.  
\item {\ttfamily bool = obj.\-Is\-At\-End ()} -\/ Is the iteration done?  
\item {\ttfamily string = obj.\-Get\-Current\-Name ()} -\/ Name of the uniform at the current cursor position. \begin{DoxyPrecond}{Precondition}
not\-\_\-done\-: !this-\/$>$Is\-At\-End()  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Send\-Current\-Uniform (int uniform\-Index)} -\/ \begin{DoxyPrecond}{Precondition}
need a valid Open\-G\-L context and a shader program in use. 

not\-\_\-done\-: !this-\/$>$Is\-At\-End()  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Next ()} -\/ Move the cursor to the next uniform. \begin{DoxyPrecond}{Precondition}
not\-\_\-done\-: !this-\/$>$Is\-At\-End()  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Deep\-Copy (vtk\-Uniform\-Variables other)} -\/ Copy all the variables from `other'. Any existing variable will be deleted first. \begin{DoxyPrecond}{Precondition}
other\-\_\-exists\-: other!=0 

not\-\_\-self\-: other!=this  
\end{DoxyPrecond}

\item {\ttfamily obj.\-Merge (vtk\-Uniform\-Variables other)} -\/ Copy all the variables from `other'. Any existing variable will be overwritten. \begin{DoxyPrecond}{Precondition}
other\-\_\-exists\-: other!=0 

not\-\_\-self\-: other!=this  
\end{DoxyPrecond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkviewtheme}{}\section{vtk\-View\-Theme}\label{vtkrendering_vtkviewtheme}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This may be set on any subclass of vtk\-View. The view class will attempt to use the values set in the theme to customize the view. Views will not generally use every aspect of the theme. N\-O\-T\-I\-C\-E\-: This class will be deprecated in favor of a more robust solution based on style sheets. Do not become overly-\/dependent on the functionality of themes.

To create an instance of class vtk\-View\-Theme, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkViewTheme
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-View\-Theme 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\-View\-Theme class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-View\-Theme = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-View\-Theme = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Point\-Size (double )} -\/ The size of points or vertices  
\item {\ttfamily double = obj.\-Get\-Point\-Size ()} -\/ The size of points or vertices  
\item {\ttfamily obj.\-Set\-Line\-Width (double )} -\/ The width of lines or edges  
\item {\ttfamily double = obj.\-Get\-Line\-Width ()} -\/ The width of lines or edges  
\item {\ttfamily obj.\-Set\-Point\-Color (double , double , double )} -\/ The color and opacity of points or vertices when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Point\-Color (double a\mbox{[}3\mbox{]})} -\/ The color and opacity of points or vertices when not mapped through a lookup table.  
\item {\ttfamily double = obj. Get\-Point\-Color ()} -\/ The color and opacity of points or vertices when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Point\-Opacity (double )} -\/ The color and opacity of points or vertices when not mapped through a lookup table.  
\item {\ttfamily double = obj.\-Get\-Point\-Opacity ()} -\/ The color and opacity of points or vertices when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Point\-Hue\-Range (double mn, double mx)} -\/ The ranges to use in the point lookup table. You may also do this by accessing the point lookup table directly with Get\-Point\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Set\-Point\-Hue\-Range (double rng\mbox{[}2\mbox{]})} -\/ The ranges to use in the point lookup table. You may also do this by accessing the point lookup table directly with Get\-Point\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Get\-Point\-Hue\-Range (double rng\mbox{[}2\mbox{]})} -\/ The ranges to use in the point lookup table. You may also do this by accessing the point lookup table directly with Get\-Point\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Set\-Point\-Saturation\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Point\-Saturation\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Point\-Saturation\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Point\-Value\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Point\-Value\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Point\-Value\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Point\-Alpha\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Point\-Alpha\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Point\-Alpha\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Point\-Lookup\-Table ()} -\/ Set/\-Get the point lookup table.  
\item {\ttfamily obj.\-Set\-Point\-Lookup\-Table (vtk\-Scalars\-To\-Colors lut)} -\/ Set/\-Get the point lookup table.  
\item {\ttfamily obj.\-Set\-Scale\-Point\-Lookup\-Table (bool )} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily bool = obj.\-Get\-Scale\-Point\-Lookup\-Table ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Scale\-Point\-Lookup\-Table\-On ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Scale\-Point\-Lookup\-Table\-Off ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Set\-Cell\-Color (double , double , double )} -\/ The color and opacity of cells or edges when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Cell\-Color (double a\mbox{[}3\mbox{]})} -\/ The color and opacity of cells or edges when not mapped through a lookup table.  
\item {\ttfamily double = obj. Get\-Cell\-Color ()} -\/ The color and opacity of cells or edges when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Cell\-Opacity (double )} -\/ The color and opacity of cells or edges when not mapped through a lookup table.  
\item {\ttfamily double = obj.\-Get\-Cell\-Opacity ()} -\/ The color and opacity of cells or edges when not mapped through a lookup table.  
\item {\ttfamily obj.\-Set\-Cell\-Hue\-Range (double mn, double mx)} -\/ The ranges to use in the cell lookup table. You may also do this by accessing the cell lookup table directly with Get\-Cell\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Set\-Cell\-Hue\-Range (double rng\mbox{[}2\mbox{]})} -\/ The ranges to use in the cell lookup table. You may also do this by accessing the cell lookup table directly with Get\-Cell\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Get\-Cell\-Hue\-Range (double rng\mbox{[}2\mbox{]})} -\/ The ranges to use in the cell lookup table. You may also do this by accessing the cell lookup table directly with Get\-Cell\-Lookup\-Table() and calling these methods.  
\item {\ttfamily obj.\-Set\-Cell\-Saturation\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Cell\-Saturation\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Cell\-Saturation\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Cell\-Value\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Cell\-Value\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Cell\-Value\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Set\-Cell\-Alpha\-Range (double mn, double mx)}  
\item {\ttfamily obj.\-Set\-Cell\-Alpha\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily obj.\-Get\-Cell\-Alpha\-Range (double rng\mbox{[}2\mbox{]})}  
\item {\ttfamily vtk\-Scalars\-To\-Colors = obj.\-Get\-Cell\-Lookup\-Table ()} -\/ Set/\-Get the cell lookup table.  
\item {\ttfamily obj.\-Set\-Cell\-Lookup\-Table (vtk\-Scalars\-To\-Colors lut)} -\/ Set/\-Get the cell lookup table.  
\item {\ttfamily obj.\-Set\-Scale\-Cell\-Lookup\-Table (bool )} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily bool = obj.\-Get\-Scale\-Cell\-Lookup\-Table ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Scale\-Cell\-Lookup\-Table\-On ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Scale\-Cell\-Lookup\-Table\-Off ()} -\/ Whether to scale the lookup table to fit the range of the data.  
\item {\ttfamily obj.\-Set\-Outline\-Color (double , double , double )} -\/ The color of any outlines in the view.  
\item {\ttfamily obj.\-Set\-Outline\-Color (double a\mbox{[}3\mbox{]})} -\/ The color of any outlines in the view.  
\item {\ttfamily double = obj. Get\-Outline\-Color ()} -\/ The color of any outlines in the view.  
\item {\ttfamily obj.\-Set\-Selected\-Point\-Color (double , double , double )} -\/ The color of selected points or vertices.  
\item {\ttfamily obj.\-Set\-Selected\-Point\-Color (double a\mbox{[}3\mbox{]})} -\/ The color of selected points or vertices.  
\item {\ttfamily double = obj. Get\-Selected\-Point\-Color ()} -\/ The color of selected points or vertices.  
\item {\ttfamily obj.\-Set\-Selected\-Point\-Opacity (double )} -\/ The color of selected points or vertices.  
\item {\ttfamily double = obj.\-Get\-Selected\-Point\-Opacity ()} -\/ The color of selected points or vertices.  
\item {\ttfamily obj.\-Set\-Selected\-Cell\-Color (double , double , double )} -\/ The color of selected cells or edges.  
\item {\ttfamily obj.\-Set\-Selected\-Cell\-Color (double a\mbox{[}3\mbox{]})} -\/ The color of selected cells or edges.  
\item {\ttfamily double = obj. Get\-Selected\-Cell\-Color ()} -\/ The color of selected cells or edges.  
\item {\ttfamily obj.\-Set\-Selected\-Cell\-Opacity (double )} -\/ The color of selected cells or edges.  
\item {\ttfamily double = obj.\-Get\-Selected\-Cell\-Opacity ()} -\/ The color of selected cells or edges.  
\item {\ttfamily obj.\-Set\-Background\-Color (double , double , double )} -\/ The view background color.  
\item {\ttfamily obj.\-Set\-Background\-Color (double a\mbox{[}3\mbox{]})} -\/ The view background color.  
\item {\ttfamily double = obj. Get\-Background\-Color ()} -\/ The view background color.  
\item {\ttfamily obj.\-Set\-Background\-Color2 (double , double , double )} -\/ The second background color (for gradients).  
\item {\ttfamily obj.\-Set\-Background\-Color2 (double a\mbox{[}3\mbox{]})} -\/ The second background color (for gradients).  
\item {\ttfamily double = obj. Get\-Background\-Color2 ()} -\/ The second background color (for gradients).  
\item {\ttfamily obj.\-Set\-Point\-Text\-Property (vtk\-Text\-Property tprop)} -\/ The text property to use for labelling points/vertices.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Point\-Text\-Property ()} -\/ The text property to use for labelling points/vertices.  
\item {\ttfamily obj.\-Set\-Cell\-Text\-Property (vtk\-Text\-Property tprop)} -\/ The text property to use for labelling edges/cells.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Cell\-Text\-Property ()} -\/ The text property to use for labelling edges/cells.  
\item {\ttfamily obj.\-Set\-Vertex\-Label\-Color (double r, double g, double b)} -\/ The color to use for labelling graph vertices. This is deprecated. Use Get\-Point\-Text\-Property()-\/$>$Set\-Color() instead.  
\item {\ttfamily obj.\-Set\-Vertex\-Label\-Color (double c\mbox{[}3\mbox{]})} -\/ The color to use for labelling graph vertices. This is deprecated. Use Get\-Point\-Text\-Property()-\/$>$Set\-Color() instead.  
\item {\ttfamily obj.\-Get\-Vertex\-Label\-Color (double c\mbox{[}3\mbox{]})} -\/ The color to use for labelling graph edges. This is deprecated. Use Get\-Cell\-Text\-Property()-\/$>$Set\-Color() instead.  
\item {\ttfamily obj.\-Set\-Edge\-Label\-Color (double r, double g, double b)} -\/ The color to use for labelling graph edges. This is deprecated. Use Get\-Cell\-Text\-Property()-\/$>$Set\-Color() instead.  
\item {\ttfamily obj.\-Set\-Edge\-Label\-Color (double c\mbox{[}3\mbox{]})} -\/ The color to use for labelling graph edges. This is deprecated. Use Get\-Cell\-Text\-Property()-\/$>$Set\-Color() instead.  
\item {\ttfamily obj.\-Get\-Edge\-Label\-Color (double c\mbox{[}3\mbox{]})} -\/ Convenience methods for creating some default view themes. The return reference is reference-\/counted, so you will have to call Delete() on the reference when you are finished with it.  
\item {\ttfamily bool = obj.\-Lookup\-Matches\-Point\-Theme (vtk\-Scalars\-To\-Colors s2c)} -\/ Whether a given lookup table matches the point or cell theme of this theme.  
\item {\ttfamily bool = obj.\-Lookup\-Matches\-Cell\-Theme (vtk\-Scalars\-To\-Colors s2c)} -\/ Whether a given lookup table matches the point or cell theme of this theme.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvisibilitysort}{}\section{vtk\-Visibility\-Sort}\label{vtkrendering_vtkvisibilitysort}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Visibility\-Sort encapsulates a method for depth sorting the cells of a vtk\-Data\-Set for a given viewpoint. It should be noted that subclasses are not required to give an absolutely correct sorting. Many types of unstructured grids may have sorting cycles, meaning that there is no possible correct sorting. Some subclasses also only give an approximate sorting in the interest of speed.

.S\-E\-C\-T\-I\-O\-N Note The Input field of this class tends to causes reference cycles. To help break these cycles, garbage collection is enabled on this object and the input parameter is traced. For this to work, though, an object in the loop holding the visibility sort should also report that to the garbage collector.

To create an instance of class vtk\-Visibility\-Sort, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVisibilitySort
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Visibility\-Sort 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\-Visibility\-Sort class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Visibility\-Sort = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Visibility\-Sort = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Init\-Traversal ()} -\/ To facilitate incremental sorting algorithms, the cells are retrieved in an iteration process. That is, call Init\-Traversal to start the iteration and call Get\-Next\-Cells to get the cell I\-Ds in order. However, for efficiencies sake, Get\-Next\-Cells returns an ordered list of several id's in once call (but not necessarily all). Get\-Next\-Cells will return N\-U\-L\-L once the entire sorted list is output. The vtk\-Id\-Type\-Array returned from Get\-Next\-Cells is a cached array, so do not delete it. At the same note, do not expect the array to be valid after subsequent calls to Get\-Next\-Cells.  
\item {\ttfamily vtk\-Id\-Type\-Array = obj.\-Get\-Next\-Cells ()} -\/ To facilitate incremental sorting algorithms, the cells are retrieved in an iteration process. That is, call Init\-Traversal to start the iteration and call Get\-Next\-Cells to get the cell I\-Ds in order. However, for efficiencies sake, Get\-Next\-Cells returns an ordered list of several id's in once call (but not necessarily all). Get\-Next\-Cells will return N\-U\-L\-L once the entire sorted list is output. The vtk\-Id\-Type\-Array returned from Get\-Next\-Cells is a cached array, so do not delete it. At the same note, do not expect the array to be valid after subsequent calls to Get\-Next\-Cells.  
\item {\ttfamily obj.\-Set\-Max\-Cells\-Returned (int )} -\/ Set/\-Get the maximum number of cells that Get\-Next\-Cells will return in one invocation.  
\item {\ttfamily int = obj.\-Get\-Max\-Cells\-Returned\-Min\-Value ()} -\/ Set/\-Get the maximum number of cells that Get\-Next\-Cells will return in one invocation.  
\item {\ttfamily int = obj.\-Get\-Max\-Cells\-Returned\-Max\-Value ()} -\/ Set/\-Get the maximum number of cells that Get\-Next\-Cells will return in one invocation.  
\item {\ttfamily int = obj.\-Get\-Max\-Cells\-Returned ()} -\/ Set/\-Get the maximum number of cells that Get\-Next\-Cells will return in one invocation.  
\item {\ttfamily obj.\-Set\-Model\-Transform (vtk\-Matrix4x4 mat)} -\/ Set/\-Get the matrix that transforms from object space to world space. Generally, you get this matrix from a call to Get\-Matrix of a vtk\-Prop3\-D (vtk\-Actor).  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Model\-Transform ()} -\/ Set/\-Get the matrix that transforms from object space to world space. Generally, you get this matrix from a call to Get\-Matrix of a vtk\-Prop3\-D (vtk\-Actor).  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Inverse\-Model\-Transform ()}  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera camera)} -\/ Set/\-Get the camera that specifies the viewing parameters.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Set/\-Get the camera that specifies the viewing parameters.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set data)} -\/ Set/\-Get the data set containing the cells to sort.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Set/\-Get the data set containing the cells to sort.  
\item {\ttfamily int = obj.\-Get\-Direction ()} -\/ Set/\-Get the sorting direction. Be default, the direction is set to back to front.  
\item {\ttfamily obj.\-Set\-Direction (int )} -\/ Set/\-Get the sorting direction. Be default, the direction is set to back to front.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Back\-To\-Front ()} -\/ Set/\-Get the sorting direction. Be default, the direction is set to back to front.  
\item {\ttfamily obj.\-Set\-Direction\-To\-Front\-To\-Back ()} -\/ Overwritten to enable garbage collection.  
\item {\ttfamily obj.\-Register (vtk\-Object\-Base o)} -\/ Overwritten to enable garbage collection.  
\item {\ttfamily obj.\-Un\-Register (vtk\-Object\-Base o)} -\/ Overwritten to enable garbage collection.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvisiblecellselector}{}\section{vtk\-Visible\-Cell\-Selector}\label{vtkrendering_vtkvisiblecellselector}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
D\-E\-P\-R\-E\-C\-A\-T\-E\-D\-: Please refer to vtk\-Hardware\-Selector instead. This class can be used to determine what cells are visible within a given rectangle of the Render\-Window. To use it, call in order, Set\-Renderer(), Set\-Area(), Set\-Processor\-Id(), Set\-Render\-Passes(), and then Select(). Select will cause the attached vtk\-Renderer to render in a special color mode, where each cell is given it own color so that later inspection of the Rendered Pixels can determine what cells are visible. In practice up to five different rendering passes may occur depending on your choices in Set\-Render\-Passes. After Select(), a list of the visible cells can be obtained by calling Get\-Selected\-Ids().

Limitations\-: Antialiasing will break this class. If your graphics card settings force their use this class will return invalid results.

Currently only cells from Poly\-Data\-Mappers can be selected from. When vtk\-Renderer is put into a Select\-Mode, it temporarily swaps in a new vtk\-Ident\-Colored\-Painter to do the color index rendering of each cell in each vtk\-Prop that it renders. Until alternatives to vtk\-Ident\-Colored\-Painter exist that can do a similar coloration of other vtk\-Data\-Set types, only polygonal data can be selected. If you need to select other data types, consider using vtk\-Data\-Set\-Mapper and turning on it's Pass\-Through\-Cell\-Ids feature, or using vtk\-Frustum\-Extractor.

Only Opaque geometry in Actors is selected from. Assemblies and L\-O\-D\-Mappers are not currently supported.

During selection, visible datasets that can not be selected from are temporarily hidden so as not to produce invalid indices from their colors.

To create an instance of class vtk\-Visible\-Cell\-Selector, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVisibleCellSelector
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Visible\-Cell\-Selector 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\-Visible\-Cell\-Selector class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Visible\-Cell\-Selector = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Visible\-Cell\-Selector = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer )} -\/ Call to let this know where to select within.  
\item {\ttfamily obj.\-Set\-Area (int x0, int y0, int x1, int y1)} -\/ Call to set the selection area region. This crops the selected area to the renderers pixel limits.  
\item {\ttfamily obj.\-Set\-Processor\-Id (int pid)} -\/ Call to let this know what processor number to render as in the processor select pass. Internally this adds 1 to pid because 0 is reserved for miss.  
\item {\ttfamily int = obj.\-Get\-Processor\-Id ()} -\/ Call to let this know what processor number to render as in the processor select pass. Internally this adds 1 to pid because 0 is reserved for miss.  
\item {\ttfamily obj.\-Set\-Render\-Passes (int Do\-Processor, int Do\-Actor, int Do\-Cell\-Id\-Hi, int Do\-Cell\-Id\-Mid, int Do\-Cell\-Id\-Lo, int Do\-Vertex\-Id)} -\/ Call to let this know what selection render passes to do. If you have only one processor or one actor, you can leave Do\-Processor and Do\-Actor as false (the default). If you have less than 2$^\wedge$48 cells in any actor, you do not need the Cell\-Id\-Hi pass, or similarly if you have less than 2$^\wedge$24 cells, you do not need Do\-Cell\-Id\-Mid. The Do\-Point\-Id will enable another render pass for determining visible vertices.  
\item {\ttfamily obj.\-Select ()} -\/ Execute the selection algorithm.  
\item {\ttfamily obj.\-Get\-Selected\-Ids (vtk\-Id\-Type\-Array To\-Copy\-Into)} -\/ After Select(), this will return the list of selected Ids. The Processor\-Id and Actor Id are returned in the first two components. The Cell\-Id is returned in the last two components (only 64 bits total).  
\item {\ttfamily obj.\-Get\-Selected\-Ids (vtk\-Selection To\-Copy\-Into)} -\/ After Select(), this will return the list of selected Ids.  
\item {\ttfamily obj.\-Get\-Selected\-Vertices (vtk\-Id\-Type\-Array Vertex\-Pointers, vtk\-Id\-Type\-Array Vertex\-Ids)} -\/ After Select(), (assuming Do\-Vertex\-Id is on), the will return arrays that describe which cell vertices are visible. The Vertex\-Pointers array contains one index into the Vertex\-Ids array for every visible cell. Any index may be -\/1 in which case no vertices were visible for that cell. The Vertex\-Ids array contains a set of integers for each cell that has visible vertices. The first entry in the set is the number of visible vertices. The rest are visible vertex ranks. A set such at 2,0,4, means that a particular polygon's first and fifth vertices were visible.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Actor\-From\-Id (vtk\-Id\-Type id)} -\/ After a select, this will return a pointer to the actor corresponding to a particular id. This will return N\-U\-L\-L if id is out of range.  
\item {\ttfamily obj.\-Print\-Selected\-Ids (vtk\-Id\-Type\-Array Ids\-To\-Print)} -\/ For debugging -\/ prints out the list of selected ids.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvolume}{}\section{vtk\-Volume}\label{vtkrendering_vtkvolume}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume is used to represent a volumetric entity in a rendering scene. It inherits functions related to the volume's position, orientation and origin from vtk\-Prop3\-D. The volume maintains a reference to the volumetric data (i.\-e., the volume mapper). The volume also contains a reference to a volume property which contains all common volume rendering parameters.

To create an instance of class vtk\-Volume, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolume
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Mapper (vtk\-Abstract\-Volume\-Mapper mapper)} -\/ Set/\-Get the volume mapper.  
\item {\ttfamily vtk\-Abstract\-Volume\-Mapper = obj.\-Get\-Mapper ()} -\/ Set/\-Get the volume mapper.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Volume\-Property property)} -\/ Set/\-Get the volume property.  
\item {\ttfamily vtk\-Volume\-Property = obj.\-Get\-Property ()} -\/ Set/\-Get the volume property.  
\item {\ttfamily obj.\-Get\-Volumes (vtk\-Prop\-Collection vc)} -\/ For some exporters and other other operations we must be able to collect all the actors or volumes. This method is used in that process.  
\item {\ttfamily obj.\-Update ()} -\/ Update the volume rendering pipeline by updating the volume mapper  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily obj.\-Get\-Bounds (double bounds\mbox{[}6\mbox{]})} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Min\-X\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Max\-X\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Min\-Y\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Max\-Y\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Min\-Z\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily double = obj.\-Get\-Max\-Z\-Bound ()} -\/ Get the bounds -\/ either all six at once (xmin, xmax, ymin, ymax, zmin, zmax) or one at a time.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Return the M\-Time also considering the property etc.  
\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, mappers, etc.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Shallow copy of this vtk\-Volume. Overloads the virtual vtk\-Prop method.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvolumecollection}{}\section{vtk\-Volume\-Collection}\label{vtkrendering_vtkvolumecollection}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Collection represents and provides methods to manipulate a list of volumes (i.\-e., vtk\-Volume and subclasses). The list is unsorted and duplicate entries are not prevented.

To create an instance of class vtk\-Volume\-Collection, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeCollection
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-Collection has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Volume\-Collection class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Collection = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Collection = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Add\-Item (vtk\-Volume a)} -\/ Get the next Volume in the list. Return N\-U\-L\-L when at the end of the list.  
\item {\ttfamily vtk\-Volume = obj.\-Get\-Next\-Volume ()} -\/ Get the next Volume in the list. Return N\-U\-L\-L when at the end of the list.  
\item {\ttfamily vtk\-Volume = obj.\-Get\-Next\-Item ()} -\/ Access routine provided for compatibility with previous versions of V\-T\-K. Please use the Get\-Next\-Volume() variant where possible.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvolumeproperty}{}\section{vtk\-Volume\-Property}\label{vtkrendering_vtkvolumeproperty}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volume\-Property is used to represent common properties associated with volume rendering. This includes properties for determining the type of interpolation to use when sampling a volume, the color of a volume, the scalar opacity of a volume, the gradient opacity of a volume, and the shading parameters of a volume.

When the scalar opacity or the gradient opacity of a volume is not set, then the function is defined to be a constant value of 1.\-0. When a scalar and gradient opacity are both set simultaneously, then the opacity is defined to be the product of the scalar opacity and gradient opacity transfer functions.

Most properties can be set per \char`\"{}component\char`\"{} for volume mappers that support multiple independent components. If you are using 2 component data as L\-V or 4 component data as R\-G\-B\-V (as specified in the mapper) only the first scalar opacity and gradient opacity transfer functions will be used (and all color functions will be ignored). Omitting the index parameter on the Set/\-Get methods will access index = 0.

To create an instance of class vtk\-Volume\-Property, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumeProperty
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volume\-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\-Volume\-Property class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volume\-Property = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volume\-Property = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Volume\-Property p)}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Get the modified time for this object (or the properties registered with this object).  
\item {\ttfamily obj.\-Set\-Independent\-Components (int )} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily int = obj.\-Get\-Independent\-Components\-Min\-Value ()} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily int = obj.\-Get\-Independent\-Components\-Max\-Value ()} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily int = obj.\-Get\-Independent\-Components ()} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily obj.\-Independent\-Components\-On ()} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily obj.\-Independent\-Components\-Off ()} -\/ Does the data have independent components, or do some define color only? If Independent\-Components is On (the default) then each component will be independently passed through a lookup table to determine R\-G\-B\-A, shaded. Some volume Mappers can handle 1 to 4 component unsigned char or unsigned short data (see each mapper header file to determine functionality). If Independent\-Components is Off, then you must have either 2 or 4 component data. For 2 component data, the first is passed through the first color transfer function and the second component is passed through the first opacity transfer function. Normals will be generated off of the second component. For 4 component data, the first three will directly represent R\-G\-B (no lookup table). The fourth component will be passed through the first scalar opacity transfer function for opacity. Normals will be generated from the fourth component.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type (int )} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Min\-Value ()} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type\-Max\-Value ()} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily int = obj.\-Get\-Interpolation\-Type ()} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Nearest ()} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Interpolation\-Type\-To\-Linear ()} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily string = obj.\-Get\-Interpolation\-Type\-As\-String (void )} -\/ Set the interpolation type for sampling a volume. Initial value is V\-T\-K\-\_\-\-N\-E\-A\-R\-E\-S\-T\-\_\-\-I\-N\-T\-E\-R\-P\-O\-L\-A\-T\-I\-O\-N.  
\item {\ttfamily obj.\-Set\-Component\-Weight (int index, double value)} -\/ Set/\-Get the scalar component weights  
\item {\ttfamily double = obj.\-Get\-Component\-Weight (int index)} -\/ Set/\-Get the scalar component weights  
\item {\ttfamily obj.\-Set\-Color (int index, vtk\-Piecewise\-Function function)} -\/ Set the color of a volume to a gray level transfer function for the component indicated by index. This will set the color channels for this component to 1.  
\item {\ttfamily obj.\-Set\-Color (vtk\-Piecewise\-Function f)} -\/ Set the color of a volume to a gray level transfer function for the component indicated by index. This will set the color channels for this component to 1.  
\item {\ttfamily obj.\-Set\-Color (int index, vtk\-Color\-Transfer\-Function function)} -\/ Set the color of a volume to an R\-G\-B transfer function for the component indicated by index. This will set the color channels for this component to 3. This will also recompute the color channels  
\item {\ttfamily obj.\-Set\-Color (vtk\-Color\-Transfer\-Function f)} -\/ Set the color of a volume to an R\-G\-B transfer function for the component indicated by index. This will set the color channels for this component to 3. This will also recompute the color channels  
\item {\ttfamily int = obj.\-Get\-Color\-Channels (int index)} -\/ Get the number of color channels in the transfer function for the given component.  
\item {\ttfamily int = obj.\-Get\-Color\-Channels ()} -\/ Get the number of color channels in the transfer function for the given component.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Gray\-Transfer\-Function (int index)} -\/ Get the gray transfer function. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Gray\-Transfer\-Function ()} -\/ Get the gray transfer function. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily vtk\-Color\-Transfer\-Function = obj.\-Get\-R\-G\-B\-Transfer\-Function (int index)} -\/ Get the R\-G\-B transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily vtk\-Color\-Transfer\-Function = obj.\-Get\-R\-G\-B\-Transfer\-Function ()} -\/ Get the R\-G\-B transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily obj.\-Set\-Scalar\-Opacity (int index, vtk\-Piecewise\-Function function)} -\/ Set the opacity of a volume to an opacity transfer function based on scalar value for the component indicated by index.  
\item {\ttfamily obj.\-Set\-Scalar\-Opacity (vtk\-Piecewise\-Function f)} -\/ Set the opacity of a volume to an opacity transfer function based on scalar value for the component indicated by index.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Scalar\-Opacity (int index)} -\/ Get the scalar opacity transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Scalar\-Opacity ()} -\/ Get the scalar opacity transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned.  
\item {\ttfamily obj.\-Set\-Scalar\-Opacity\-Unit\-Distance (int index, double distance)} -\/ Set/\-Get the unit distance on which the scalar opacity transfer function is defined. By default this is 1.\-0, meaning that over a distance of 1.\-0 units, a given opacity (from the transfer function) is accumulated. This is adjusted for the actual sampling distance during rendering.  
\item {\ttfamily obj.\-Set\-Scalar\-Opacity\-Unit\-Distance (double distance)} -\/ Set/\-Get the unit distance on which the scalar opacity transfer function is defined. By default this is 1.\-0, meaning that over a distance of 1.\-0 units, a given opacity (from the transfer function) is accumulated. This is adjusted for the actual sampling distance during rendering.  
\item {\ttfamily double = obj.\-Get\-Scalar\-Opacity\-Unit\-Distance (int index)} -\/ Set/\-Get the unit distance on which the scalar opacity transfer function is defined. By default this is 1.\-0, meaning that over a distance of 1.\-0 units, a given opacity (from the transfer function) is accumulated. This is adjusted for the actual sampling distance during rendering.  
\item {\ttfamily double = obj.\-Get\-Scalar\-Opacity\-Unit\-Distance ()} -\/ Set the opacity of a volume to an opacity transfer function based on gradient magnitude for the given component.  
\item {\ttfamily obj.\-Set\-Gradient\-Opacity (int index, vtk\-Piecewise\-Function function)} -\/ Set the opacity of a volume to an opacity transfer function based on gradient magnitude for the given component.  
\item {\ttfamily obj.\-Set\-Gradient\-Opacity (vtk\-Piecewise\-Function function)} -\/ Get the gradient magnitude opacity transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned. This default function is always returned if Disable\-Gradient\-Opacity is On for that component.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Gradient\-Opacity (int index)} -\/ Get the gradient magnitude opacity transfer function for the given component. If no transfer function has been set for this component, a default one is created and returned. This default function is always returned if Disable\-Gradient\-Opacity is On for that component.  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Gradient\-Opacity ()} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Set\-Disable\-Gradient\-Opacity (int index, int value)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Set\-Disable\-Gradient\-Opacity (int value)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Disable\-Gradient\-Opacity\-On (int index)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Disable\-Gradient\-Opacity\-On ()} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Disable\-Gradient\-Opacity\-Off (int index)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily obj.\-Disable\-Gradient\-Opacity\-Off ()} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily int = obj.\-Get\-Disable\-Gradient\-Opacity (int index)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily int = obj.\-Get\-Disable\-Gradient\-Opacity ()} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Stored\-Gradient\-Opacity (int index)} -\/ Enable/\-Disable the gradient opacity function for the given component. If set to true, any call to Get\-Gradient\-Opacity() will return a default function for this component. Note that the gradient opacity function is still stored, it is not set or reset and can be retrieved using Get\-Stored\-Gradient\-Opacity().  
\item {\ttfamily vtk\-Piecewise\-Function = obj.\-Get\-Stored\-Gradient\-Opacity ()} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Set\-Shade (int index, int value)} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Set\-Shade (int value)} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily int = obj.\-Get\-Shade (int index)} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily int = obj.\-Get\-Shade ()} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Shade\-On (int index)} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Shade\-On ()} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Shade\-Off (int index)} -\/ Set/\-Get the shading of a volume. If shading is turned off, then the mapper for the volume will not perform shading calculations. If shading is turned on, the mapper may perform shading calculations -\/ in some cases shading does not apply (for example, in a maximum intensity projection) and therefore shading will not be performed even if this flag is on. For a compositing type of mapper, turning shading off is generally the same as setting ambient=1, diffuse=0, specular=0. Shading can be independently turned on/off per component.  
\item {\ttfamily obj.\-Shade\-Off ()} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily obj.\-Set\-Ambient (int index, double value)} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily obj.\-Set\-Ambient (double value)} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Ambient (int index)} -\/ Set/\-Get the ambient lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Ambient ()} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily obj.\-Set\-Diffuse (int index, double value)} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily obj.\-Set\-Diffuse (double value)} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Diffuse (int index)} -\/ Set/\-Get the diffuse lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Diffuse ()} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily obj.\-Set\-Specular (int index, double value)} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily obj.\-Set\-Specular (double value)} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Specular (int index)} -\/ Set/\-Get the specular lighting coefficient.  
\item {\ttfamily double = obj.\-Get\-Specular ()} -\/ Set/\-Get the specular power.  
\item {\ttfamily obj.\-Set\-Specular\-Power (int index, double value)} -\/ Set/\-Get the specular power.  
\item {\ttfamily obj.\-Set\-Specular\-Power (double value)} -\/ Set/\-Get the specular power.  
\item {\ttfamily double = obj.\-Get\-Specular\-Power (int index)} -\/ Set/\-Get the specular power.  
\item {\ttfamily double = obj.\-Get\-Specular\-Power ()}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvolumetricpass}{}\section{vtk\-Volumetric\-Pass}\label{vtkrendering_vtkvolumetricpass}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Volumetric\-Pass renders the volumetric geometry of all the props that have the keys contained in vtk\-Render\-State.

This pass expects an initialized depth buffer and color buffer. Initialized buffers means they have been cleared with farest z-\/value and background color/gradient/transparent color.

To create an instance of class vtk\-Volumetric\-Pass, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVolumetricPass
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Volumetric\-Pass 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\-Volumetric\-Pass class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Volumetric\-Pass = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Volumetric\-Pass = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkvrmlexporter}{}\section{vtk\-V\-R\-M\-L\-Exporter}\label{vtkrendering_vtkvrmlexporter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-V\-R\-M\-L\-Exporter is a concrete subclass of vtk\-Exporter that writes V\-R\-M\-L 2.\-0 files. This is based on the V\-R\-M\-L 2.\-0 draft \#3 but it should be pretty stable since we aren't using any of the newer features.

To create an instance of class vtk\-V\-R\-M\-L\-Exporter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkVRMLExporter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-V\-R\-M\-L\-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\-V\-R\-M\-L\-Exporter 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\-Exporter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-V\-R\-M\-L\-Exporter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-File\-Name (string )} -\/ Specify the name of the V\-R\-M\-L file to write.  
\item {\ttfamily string = obj.\-Get\-File\-Name ()} -\/ Specify the name of the V\-R\-M\-L file to write.  
\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.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkwindowtoimagefilter}{}\section{vtk\-Window\-To\-Image\-Filter}\label{vtkrendering_vtkwindowtoimagefilter}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Window\-To\-Image\-Filter provides methods needed to read the data in a vtk\-Window and use it as input to the imaging pipeline. This is useful for saving an image to a file for example. The window can be read as either R\-G\-B or R\-G\-B\-A pixels; in addition, the depth buffer can also be read. R\-G\-B and R\-G\-B\-A pixels are of type unsigned char, while Z-\/\-Buffer data is returned as floats. Use this filter to convert Render\-Windows or Image\-Windows to an image format.

To create an instance of class vtk\-Window\-To\-Image\-Filter, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWindowToImageFilter
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Window\-To\-Image\-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\-Window\-To\-Image\-Filter class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Window\-To\-Image\-Filter = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Window\-To\-Image\-Filter = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Input (vtk\-Window input)} -\/ Indicates what renderer to get the pixel data from. Initial value is 0.  
\item {\ttfamily vtk\-Window = obj.\-Get\-Input ()} -\/ Returns which renderer is being used as the source for the pixel data. Initial value is 0.  
\item {\ttfamily obj.\-Set\-Magnification (int )} -\/ The magnification of the current render window. Initial value is 1.  
\item {\ttfamily int = obj.\-Get\-Magnification\-Min\-Value ()} -\/ The magnification of the current render window. Initial value is 1.  
\item {\ttfamily int = obj.\-Get\-Magnification\-Max\-Value ()} -\/ The magnification of the current render window. Initial value is 1.  
\item {\ttfamily int = obj.\-Get\-Magnification ()} -\/ The magnification of the current render window. Initial value is 1.  
\item {\ttfamily obj.\-Read\-Front\-Buffer\-On ()} -\/ Set/\-Get the flag that determines which buffer to read from. The default is to read from the front buffer.  
\item {\ttfamily obj.\-Read\-Front\-Buffer\-Off ()} -\/ Set/\-Get the flag that determines which buffer to read from. The default is to read from the front buffer.  
\item {\ttfamily int = obj.\-Get\-Read\-Front\-Buffer ()} -\/ Set/\-Get the flag that determines which buffer to read from. The default is to read from the front buffer.  
\item {\ttfamily obj.\-Set\-Read\-Front\-Buffer (int )} -\/ Set/\-Get the flag that determines which buffer to read from. The default is to read from the front buffer.  
\item {\ttfamily obj.\-Should\-Rerender\-On ()} -\/ Set/get whether to re-\/render the input window. Initial value is true. (This option makes no difference if Magnification $>$ 1.)  
\item {\ttfamily obj.\-Should\-Rerender\-Off ()} -\/ Set/get whether to re-\/render the input window. Initial value is true. (This option makes no difference if Magnification $>$ 1.)  
\item {\ttfamily obj.\-Set\-Should\-Rerender (int )} -\/ Set/get whether to re-\/render the input window. Initial value is true. (This option makes no difference if Magnification $>$ 1.)  
\item {\ttfamily int = obj.\-Get\-Should\-Rerender ()} -\/ Set/get whether to re-\/render the input window. Initial value is true. (This option makes no difference if Magnification $>$ 1.)  
\item {\ttfamily obj.\-Set\-Viewport (double , double , double , double )} -\/ Set/get the extents to be used to generate the image. Initial value is \{0,0,1,1\} (This option does not work if Magnification $>$ 1.)  
\item {\ttfamily obj.\-Set\-Viewport (double a\mbox{[}4\mbox{]})} -\/ Set/get the extents to be used to generate the image. Initial value is \{0,0,1,1\} (This option does not work if Magnification $>$ 1.)  
\item {\ttfamily double = obj. Get\-Viewport ()} -\/ Set/get the extents to be used to generate the image. Initial value is \{0,0,1,1\} (This option does not work if Magnification $>$ 1.)  
\item {\ttfamily obj.\-Set\-Input\-Buffer\-Type (int )} -\/ Set/get the window buffer from which data will be read. Choices include V\-T\-K\-\_\-\-R\-G\-B (read the color image from the window), V\-T\-K\-\_\-\-R\-G\-B\-A (same, but include the alpha channel), and V\-T\-K\-\_\-\-Z\-B\-U\-F\-F\-E\-R (depth buffer, returned as a float array). Initial value is V\-T\-K\-\_\-\-R\-G\-B.  
\item {\ttfamily int = obj.\-Get\-Input\-Buffer\-Type ()} -\/ Set/get the window buffer from which data will be read. Choices include V\-T\-K\-\_\-\-R\-G\-B (read the color image from the window), V\-T\-K\-\_\-\-R\-G\-B\-A (same, but include the alpha channel), and V\-T\-K\-\_\-\-Z\-B\-U\-F\-F\-E\-R (depth buffer, returned as a float array). Initial value is V\-T\-K\-\_\-\-R\-G\-B.  
\item {\ttfamily obj.\-Set\-Input\-Buffer\-Type\-To\-R\-G\-B ()} -\/ Set/get the window buffer from which data will be read. Choices include V\-T\-K\-\_\-\-R\-G\-B (read the color image from the window), V\-T\-K\-\_\-\-R\-G\-B\-A (same, but include the alpha channel), and V\-T\-K\-\_\-\-Z\-B\-U\-F\-F\-E\-R (depth buffer, returned as a float array). Initial value is V\-T\-K\-\_\-\-R\-G\-B.  
\item {\ttfamily obj.\-Set\-Input\-Buffer\-Type\-To\-R\-G\-B\-A ()} -\/ Set/get the window buffer from which data will be read. Choices include V\-T\-K\-\_\-\-R\-G\-B (read the color image from the window), V\-T\-K\-\_\-\-R\-G\-B\-A (same, but include the alpha channel), and V\-T\-K\-\_\-\-Z\-B\-U\-F\-F\-E\-R (depth buffer, returned as a float array). Initial value is V\-T\-K\-\_\-\-R\-G\-B.  
\item {\ttfamily obj.\-Set\-Input\-Buffer\-Type\-To\-Z\-Buffer ()} -\/ Set/get the window buffer from which data will be read. Choices include V\-T\-K\-\_\-\-R\-G\-B (read the color image from the window), V\-T\-K\-\_\-\-R\-G\-B\-A (same, but include the alpha channel), and V\-T\-K\-\_\-\-Z\-B\-U\-F\-F\-E\-R (depth buffer, returned as a float array). Initial value is V\-T\-K\-\_\-\-R\-G\-B.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Output ()} -\/ Get the output data object for a port on this algorithm.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkworldpointpicker}{}\section{vtk\-World\-Point\-Picker}\label{vtkrendering_vtkworldpointpicker}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-World\-Point\-Picker is used to find the x,y,z world coordinate of a screen x,y,z. This picker cannot pick actors and/or mappers, it simply determines an x-\/y-\/z coordinate in world space. (It will always return a x-\/y-\/z, even if the selection point is not over a prop/actor.)

To create an instance of class vtk\-World\-Point\-Picker, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWorldPointPicker
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-World\-Point\-Picker has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-World\-Point\-Picker class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-World\-Point\-Picker = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-World\-Point\-Picker = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily int = obj.\-Pick (double selection\-X, double selection\-Y, double selection\-Z, vtk\-Renderer renderer)} -\/ Perform the pick. (This method overload's the superclass.)  
\item {\ttfamily int = obj.\-Pick (double selection\-Pt\mbox{[}3\mbox{]}, vtk\-Renderer renderer)} -\/ Perform the pick. (This method overload's the superclass.)  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkxgpuinfolist}{}\section{vtk\-X\-G\-P\-U\-Info\-List}\label{vtkrendering_vtkxgpuinfolist}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-G\-P\-U\-Info\-List implements Probe() method of vtk\-G\-P\-U\-Info\-List through some X server extensions A\-P\-I. N\-V-\/\-C\-O\-N\-T\-R\-O\-L for Nvidia. A\-T\-I\-F\-G\-L\-E\-X\-T\-E\-N\-S\-I\-O\-N for A\-T\-I is not supported yet. There is no support for other vendors.

To create an instance of class vtk\-X\-G\-P\-U\-Info\-List, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXGPUInfoList
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-G\-P\-U\-Info\-List 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\-G\-P\-U\-Info\-List class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-G\-P\-U\-Info\-List = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-G\-P\-U\-Info\-List = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Probe ()} -\/ Build the list of vtk\-Info\-G\-P\-U if not done yet. \begin{DoxyPostcond}{Postcondition}
probed\-: Is\-Probed()  
\end{DoxyPostcond}

\end{DoxyItemize}\hypertarget{vtkrendering_vtkxopenglrenderwindow}{}\section{vtk\-X\-Open\-G\-L\-Render\-Window}\label{vtkrendering_vtkxopenglrenderwindow}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-Open\-G\-L\-Render\-Window is a concrete implementation of the abstract class vtk\-Render\-Window. vtk\-Open\-G\-L\-Renderer interfaces to the Open\-G\-L graphics library. Application programmers should normally use vtk\-Render\-Window instead of the Open\-G\-L specific version.

To create an instance of class vtk\-X\-Open\-G\-L\-Render\-Window, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXOpenGLRenderWindow
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-Open\-G\-L\-Render\-Window 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\-Open\-G\-L\-Render\-Window class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-Open\-G\-L\-Render\-Window = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-Open\-G\-L\-Render\-Window = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Start (void )} -\/ Begin the rendering process.  
\item {\ttfamily obj.\-Frame (void )} -\/ End the rendering process and display the image.  
\item {\ttfamily obj.\-Window\-Initialize (void )} -\/ Initialize the window for rendering.  
\item {\ttfamily obj.\-Initialize (void )} -\/ Initialize the rendering window. This will setup all system-\/specific resources. This method and Finalize() must be symmetric and it should be possible to call them multiple times, even changing Window\-Id in-\/between. This is what Window\-Remap does.  
\item {\ttfamily obj.\-Finalize (void )} -\/ \char`\"{}\-Deinitialize\char`\"{} the rendering window. This will shutdown all system-\/specific resources. After having called this, it should be possible to destroy a window that was used for a Set\-Window\-Id() call without any ill effects.  
\item {\ttfamily obj.\-Set\-Full\-Screen (int )} -\/ Change the window to fill the entire screen.  
\item {\ttfamily obj.\-Window\-Remap (void )} -\/ Resize the window.  
\item {\ttfamily obj.\-Pref\-Full\-Screen (void )} -\/ Set the preferred window size to full screen.  
\item {\ttfamily obj.\-Set\-Size (int , int )} -\/ Specify the size of the rendering window in pixels.  
\item {\ttfamily obj.\-Set\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify the size of the rendering window in pixels.  
\item {\ttfamily int = obj.\-Get\-Desired\-Depth ()} -\/ Get the X properties of an ideal rendering window.  
\item {\ttfamily obj.\-Set\-Stereo\-Capable\-Window (int capable)} -\/ Prescribe that the window be created in a stereo-\/capable mode. This method must be called before the window is realized. This method overrides the superclass method since this class can actually check whether the window has been realized yet.  
\item {\ttfamily obj.\-Make\-Current ()} -\/ Make this window the current Open\-G\-L context.  
\item {\ttfamily bool = obj.\-Is\-Current ()} -\/ Tells if this window is the current Open\-G\-L context for the calling thread.  
\item {\ttfamily obj.\-Set\-Force\-Make\-Current ()} -\/ If called, allow Make\-Current() to skip cache-\/check when called. Make\-Current() reverts to original behavior of cache-\/checking on the next render.  
\item {\ttfamily string = obj.\-Report\-Capabilities ()} -\/ Get report of capabilities for the render window  
\item {\ttfamily int = obj.\-Supports\-Open\-G\-L ()} -\/ Does this render window support Open\-G\-L? 0-\/false, 1-\/true  
\item {\ttfamily int = obj.\-Is\-Direct ()} -\/ Is this render window using hardware acceleration? 0-\/false, 1-\/true  
\item {\ttfamily obj.\-Set\-Window\-Name (string )}  
\item {\ttfamily obj.\-Set\-Position (int , int )} -\/ Move the window to a new position on the display.  
\item {\ttfamily obj.\-Set\-Position (int a\mbox{[}2\mbox{]})} -\/ Move the window to a new position on the display.  
\item {\ttfamily obj.\-Hide\-Cursor ()} -\/ Hide or Show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead.  
\item {\ttfamily obj.\-Show\-Cursor ()} -\/ Hide or Show the mouse cursor, it is nice to be able to hide the default cursor if you want V\-T\-K to display a 3\-D cursor instead.  
\item {\ttfamily obj.\-Set\-Current\-Cursor (int )} -\/ Change the shape of the cursor  
\item {\ttfamily int = obj.\-Get\-Event\-Pending ()} -\/ Check to see if a mouse button has been pressed. All other events are ignored by this method. This is a useful check to abort a long render.  
\item {\ttfamily obj.\-Set\-Window\-Info (string info)} -\/ Set this Render\-Window's X window id to a pre-\/existing window.  
\item {\ttfamily obj.\-Set\-Next\-Window\-Info (string info)} -\/ Set the window info that will be used after Window\-Remap()  
\item {\ttfamily obj.\-Set\-Parent\-Info (string info)} -\/ Sets the X window id of the window that W\-I\-L\-L B\-E created.  
\item {\ttfamily obj.\-Render ()} -\/ This computes the size of the render window before calling the supper classes render  
\item {\ttfamily obj.\-Set\-Off\-Screen\-Rendering (int i)} -\/ Render without displaying the window.  
\end{DoxyItemize}\hypertarget{vtkrendering_vtkxrenderwindowinteractor}{}\section{vtk\-X\-Render\-Window\-Interactor}\label{vtkrendering_vtkxrenderwindowinteractor}
Section\-: \hyperlink{sec_vtkrendering}{Visualization Toolkit Rendering Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-X\-Render\-Window\-Interactor is a convenience object that provides event bindings to common graphics functions. For example, camera and actor functions such as zoom-\/in/zoom-\/out, azimuth, roll, and pan. I\-T is one of the window system specific subclasses of vtk\-Render\-Window\-Interactor. Please see vtk\-Render\-Window\-Interactor documentation for event bindings.

To create an instance of class vtk\-X\-Render\-Window\-Interactor, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXRenderWindowInteractor
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-Render\-Window\-Interactor 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\-Render\-Window\-Interactor class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-Render\-Window\-Interactor = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-Render\-Window\-Interactor = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Initialize ()} -\/ Initializes the event handlers without an Xt\-App\-Context. This is good for when you don't have a user interface, but you still want to have mouse interaction.  
\item {\ttfamily obj.\-Terminate\-App ()} -\/ Break the event loop on 'q','e' keypress. Want more ???  
\item {\ttfamily int = obj.\-Get\-Break\-Loop\-Flag ()} -\/ The Break\-Loop\-Flag is checked in the Start() method. Setting it to anything other than zero will cause the interactor loop to terminate and return to the calling function.  
\item {\ttfamily obj.\-Set\-Break\-Loop\-Flag (int )} -\/ The Break\-Loop\-Flag is checked in the Start() method. Setting it to anything other than zero will cause the interactor loop to terminate and return to the calling function.  
\item {\ttfamily obj.\-Break\-Loop\-Flag\-Off ()} -\/ The Break\-Loop\-Flag is checked in the Start() method. Setting it to anything other than zero will cause the interactor loop to terminate and return to the calling function.  
\item {\ttfamily obj.\-Break\-Loop\-Flag\-On ()} -\/ The Break\-Loop\-Flag is checked in the Start() method. Setting it to anything other than zero will cause the interactor loop to terminate and return to the calling function.  
\item {\ttfamily obj.\-Enable ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily obj.\-Disable ()} -\/ Enable/\-Disable interactions. By default interactors are enabled when initialized. Initialize() must be called prior to enabling/disabling interaction. These methods are used when a window/widget is being shared by multiple renderers and interactors. This allows a \char`\"{}modal\char`\"{} display where one interactor is active when its data is to be displayed and all other interactors associated with the widget are disabled when their data is not displayed.  
\item {\ttfamily obj.\-Start ()} -\/ This will start up the X event loop and never return. If you call this method it will loop processing X events until the application is exited.  
\item {\ttfamily obj.\-Update\-Size (int , int )} -\/ Update the Size data member and set the associated Render\-Window's size.  
\item {\ttfamily obj.\-Get\-Mouse\-Position (int x, int y)} -\/ Re-\/defines virtual function to get mouse position by querying X-\/server.  
\end{DoxyItemize}