
\begin{DoxyItemize}
\item \hyperlink{vtkwidgets_vtk3dwidget}{vtk3\-D\-Widget}  
\item \hyperlink{vtkwidgets_vtkabstractpolygonalhandlerepresentation3d}{vtk\-Abstract\-Polygonal\-Handle\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtkabstractwidget}{vtk\-Abstract\-Widget}  
\item \hyperlink{vtkwidgets_vtkaffinerepresentation}{vtk\-Affine\-Representation}  
\item \hyperlink{vtkwidgets_vtkaffinerepresentation2d}{vtk\-Affine\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtkaffinewidget}{vtk\-Affine\-Widget}  
\item \hyperlink{vtkwidgets_vtkanglerepresentation}{vtk\-Angle\-Representation}  
\item \hyperlink{vtkwidgets_vtkanglerepresentation2d}{vtk\-Angle\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtkanglerepresentation3d}{vtk\-Angle\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtkanglewidget}{vtk\-Angle\-Widget}  
\item \hyperlink{vtkwidgets_vtkballoonrepresentation}{vtk\-Balloon\-Representation}  
\item \hyperlink{vtkwidgets_vtkballoonwidget}{vtk\-Balloon\-Widget}  
\item \hyperlink{vtkwidgets_vtkbeziercontourlineinterpolator}{vtk\-Bezier\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkbidimensionalrepresentation2d}{vtk\-Bi\-Dimensional\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtkbidimensionalwidget}{vtk\-Bi\-Dimensional\-Widget}  
\item \hyperlink{vtkwidgets_vtkborderrepresentation}{vtk\-Border\-Representation}  
\item \hyperlink{vtkwidgets_vtkborderwidget}{vtk\-Border\-Widget}  
\item \hyperlink{vtkwidgets_vtkboundedplanepointplacer}{vtk\-Bounded\-Plane\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkboxrepresentation}{vtk\-Box\-Representation}  
\item \hyperlink{vtkwidgets_vtkboxwidget}{vtk\-Box\-Widget}  
\item \hyperlink{vtkwidgets_vtkboxwidget2}{vtk\-Box\-Widget2}  
\item \hyperlink{vtkwidgets_vtkcamerarepresentation}{vtk\-Camera\-Representation}  
\item \hyperlink{vtkwidgets_vtkcamerawidget}{vtk\-Camera\-Widget}  
\item \hyperlink{vtkwidgets_vtkcaptionrepresentation}{vtk\-Caption\-Representation}  
\item \hyperlink{vtkwidgets_vtkcaptionwidget}{vtk\-Caption\-Widget}  
\item \hyperlink{vtkwidgets_vtkcenteredsliderrepresentation}{vtk\-Centered\-Slider\-Representation}  
\item \hyperlink{vtkwidgets_vtkcenteredsliderwidget}{vtk\-Centered\-Slider\-Widget}  
\item \hyperlink{vtkwidgets_vtkcheckerboardrepresentation}{vtk\-Checkerboard\-Representation}  
\item \hyperlink{vtkwidgets_vtkcheckerboardwidget}{vtk\-Checkerboard\-Widget}  
\item \hyperlink{vtkwidgets_vtkclosedsurfacepointplacer}{vtk\-Closed\-Surface\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkconstrainedpointhandlerepresentation}{vtk\-Constrained\-Point\-Handle\-Representation}  
\item \hyperlink{vtkwidgets_vtkcontinuousvaluewidget}{vtk\-Continuous\-Value\-Widget}  
\item \hyperlink{vtkwidgets_vtkcontinuousvaluewidgetrepresentation}{vtk\-Continuous\-Value\-Widget\-Representation}  
\item \hyperlink{vtkwidgets_vtkcontourlineinterpolator}{vtk\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkcontourrepresentation}{vtk\-Contour\-Representation}  
\item \hyperlink{vtkwidgets_vtkcontourwidget}{vtk\-Contour\-Widget}  
\item \hyperlink{vtkwidgets_vtkdijkstraimagecontourlineinterpolator}{vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkdistancerepresentation}{vtk\-Distance\-Representation}  
\item \hyperlink{vtkwidgets_vtkdistancerepresentation2d}{vtk\-Distance\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtkdistancewidget}{vtk\-Distance\-Widget}  
\item \hyperlink{vtkwidgets_vtkellipsoidtensorproberepresentation}{vtk\-Ellipsoid\-Tensor\-Probe\-Representation}  
\item \hyperlink{vtkwidgets_vtkevent}{vtk\-Event}  
\item \hyperlink{vtkwidgets_vtkfocalplanecontourrepresentation}{vtk\-Focal\-Plane\-Contour\-Representation}  
\item \hyperlink{vtkwidgets_vtkfocalplanepointplacer}{vtk\-Focal\-Plane\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkhandlerepresentation}{vtk\-Handle\-Representation}  
\item \hyperlink{vtkwidgets_vtkhandlewidget}{vtk\-Handle\-Widget}  
\item \hyperlink{vtkwidgets_vtkhoverwidget}{vtk\-Hover\-Widget}  
\item \hyperlink{vtkwidgets_vtkimageactorpointplacer}{vtk\-Image\-Actor\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkimageorthoplanes}{vtk\-Image\-Ortho\-Planes}  
\item \hyperlink{vtkwidgets_vtkimageplanewidget}{vtk\-Image\-Plane\-Widget}  
\item \hyperlink{vtkwidgets_vtkimagetracerwidget}{vtk\-Image\-Tracer\-Widget}  
\item \hyperlink{vtkwidgets_vtkimplicitplanerepresentation}{vtk\-Implicit\-Plane\-Representation}  
\item \hyperlink{vtkwidgets_vtkimplicitplanewidget}{vtk\-Implicit\-Plane\-Widget}  
\item \hyperlink{vtkwidgets_vtkimplicitplanewidget2}{vtk\-Implicit\-Plane\-Widget2}  
\item \hyperlink{vtkwidgets_vtklinearcontourlineinterpolator}{vtk\-Linear\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtklinerepresentation}{vtk\-Line\-Representation}  
\item \hyperlink{vtkwidgets_vtklinewidget}{vtk\-Line\-Widget}  
\item \hyperlink{vtkwidgets_vtklinewidget2}{vtk\-Line\-Widget2}  
\item \hyperlink{vtkwidgets_vtklogorepresentation}{vtk\-Logo\-Representation}  
\item \hyperlink{vtkwidgets_vtklogowidget}{vtk\-Logo\-Widget}  
\item \hyperlink{vtkwidgets_vtkorientationmarkerwidget}{vtk\-Orientation\-Marker\-Widget}  
\item \hyperlink{vtkwidgets_vtkorientedglyphcontourrepresentation}{vtk\-Oriented\-Glyph\-Contour\-Representation}  
\item \hyperlink{vtkwidgets_vtkorientedglyphfocalplanecontourrepresentation}{vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation}  
\item \hyperlink{vtkwidgets_vtkorientedpolygonalhandlerepresentation3d}{vtk\-Oriented\-Polygonal\-Handle\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtkparallelopipedrepresentation}{vtk\-Parallelopiped\-Representation}  
\item \hyperlink{vtkwidgets_vtkparallelopipedwidget}{vtk\-Parallelopiped\-Widget}  
\item \hyperlink{vtkwidgets_vtkplanewidget}{vtk\-Plane\-Widget}  
\item \hyperlink{vtkwidgets_vtkplaybackrepresentation}{vtk\-Playback\-Representation}  
\item \hyperlink{vtkwidgets_vtkplaybackwidget}{vtk\-Playback\-Widget}  
\item \hyperlink{vtkwidgets_vtkpointhandlerepresentation2d}{vtk\-Point\-Handle\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtkpointhandlerepresentation3d}{vtk\-Point\-Handle\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtkpointplacer}{vtk\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkpointwidget}{vtk\-Point\-Widget}  
\item \hyperlink{vtkwidgets_vtkpolydatacontourlineinterpolator}{vtk\-Poly\-Data\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkpolydatapointplacer}{vtk\-Poly\-Data\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkpolydatasourcewidget}{vtk\-Poly\-Data\-Source\-Widget}  
\item \hyperlink{vtkwidgets_vtkpolygonalhandlerepresentation3d}{vtk\-Polygonal\-Handle\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtkpolygonalsurfacecontourlineinterpolator}{vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkpolygonalsurfacepointplacer}{vtk\-Polygonal\-Surface\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtkrectilinearwiperepresentation}{vtk\-Rectilinear\-Wipe\-Representation}  
\item \hyperlink{vtkwidgets_vtkrectilinearwipewidget}{vtk\-Rectilinear\-Wipe\-Widget}  
\item \hyperlink{vtkwidgets_vtkscalarbarrepresentation}{vtk\-Scalar\-Bar\-Representation}  
\item \hyperlink{vtkwidgets_vtkscalarbarwidget}{vtk\-Scalar\-Bar\-Widget}  
\item \hyperlink{vtkwidgets_vtkseedrepresentation}{vtk\-Seed\-Representation}  
\item \hyperlink{vtkwidgets_vtkseedwidget}{vtk\-Seed\-Widget}  
\item \hyperlink{vtkwidgets_vtksliderrepresentation}{vtk\-Slider\-Representation}  
\item \hyperlink{vtkwidgets_vtksliderrepresentation2d}{vtk\-Slider\-Representation2\-D}  
\item \hyperlink{vtkwidgets_vtksliderrepresentation3d}{vtk\-Slider\-Representation3\-D}  
\item \hyperlink{vtkwidgets_vtksliderwidget}{vtk\-Slider\-Widget}  
\item \hyperlink{vtkwidgets_vtkspherehandlerepresentation}{vtk\-Sphere\-Handle\-Representation}  
\item \hyperlink{vtkwidgets_vtksphererepresentation}{vtk\-Sphere\-Representation}  
\item \hyperlink{vtkwidgets_vtkspherewidget}{vtk\-Sphere\-Widget}  
\item \hyperlink{vtkwidgets_vtkspherewidget2}{vtk\-Sphere\-Widget2}  
\item \hyperlink{vtkwidgets_vtksplinerepresentation}{vtk\-Spline\-Representation}  
\item \hyperlink{vtkwidgets_vtksplinewidget}{vtk\-Spline\-Widget}  
\item \hyperlink{vtkwidgets_vtksplinewidget2}{vtk\-Spline\-Widget2}  
\item \hyperlink{vtkwidgets_vtktensorproberepresentation}{vtk\-Tensor\-Probe\-Representation}  
\item \hyperlink{vtkwidgets_vtktensorprobewidget}{vtk\-Tensor\-Probe\-Widget}  
\item \hyperlink{vtkwidgets_vtkterraincontourlineinterpolator}{vtk\-Terrain\-Contour\-Line\-Interpolator}  
\item \hyperlink{vtkwidgets_vtkterraindatapointplacer}{vtk\-Terrain\-Data\-Point\-Placer}  
\item \hyperlink{vtkwidgets_vtktextrepresentation}{vtk\-Text\-Representation}  
\item \hyperlink{vtkwidgets_vtktextwidget}{vtk\-Text\-Widget}  
\item \hyperlink{vtkwidgets_vtkwidgetcallbackmapper}{vtk\-Widget\-Callback\-Mapper}  
\item \hyperlink{vtkwidgets_vtkwidgetevent}{vtk\-Widget\-Event}  
\item \hyperlink{vtkwidgets_vtkwidgeteventtranslator}{vtk\-Widget\-Event\-Translator}  
\item \hyperlink{vtkwidgets_vtkwidgetrepresentation}{vtk\-Widget\-Representation}  
\item \hyperlink{vtkwidgets_vtkwidgetset}{vtk\-Widget\-Set}  
\item \hyperlink{vtkwidgets_vtkxyplotwidget}{vtk\-X\-Y\-Plot\-Widget}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtk3dwidget}{}\section{vtk3\-D\-Widget}\label{vtkwidgets_vtk3dwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk3\-D\-Widget is an abstract superclass for 3\-D interactor observers. These 3\-D widgets represent themselves in the scene, and have special callbacks associated with them that allows interactive manipulation of the widget. Inparticular, the difference between a vtk3\-D\-Widget and its abstract superclass vtk\-Interactor\-Observer is that vtk3\-D\-Widgets are \char`\"{}placed\char`\"{} in 3\-D space. vtk\-Interactor\-Observers have no notion of where they are placed, and may not exist in 3\-D space at all. 3\-D widgets also provide auxiliary functions like producing a transformation, creating polydata (for seeding streamlines, probes, etc.) or creating implicit functions. See the concrete subclasses for particulars.

Typically the widget is used by specifying a vtk\-Prop3\-D or V\-T\-K dataset as input, and then invoking the \char`\"{}\-On\char`\"{} method to activate it. (You can also specify a bounding box to help position the widget.) Prior to invoking the On() method, the user may also wish to use the Place\-Widget() to initially position it. The 'i' (for \char`\"{}interactor\char`\"{}) keypresses also can be used to turn the widgets on and off (methods exist to change the key value and enable keypress activiation).

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 vtk3\-D\-Widget 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 the vtk\-Prop3\-D or other object (Interaction\-Event), and set the desired frame rate back to normal values (End\-Interaction\-Event).

Note that the Priority attribute inherited from vtk\-Interactor\-Observer has a new default value which is now 0.\-5 so that all 3\-D widgets have a higher priority than the usual interactor styles.

To create an instance of class vtk3\-D\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtk3DWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk3\-D\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk3\-D\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk3\-D\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk3\-D\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ This method is used to initially place the widget. The placement of the widget depends on whether a Prop3\-D or input dataset is provided. If one of these two is provided, they will be used to obtain a bounding box, around which the widget is placed. Otherwise, you can manually specify a bounds with the Place\-Widget(bounds) method. Note\-: Place\-Widget(bounds) is required by all subclasses; the other methods are provided as convenience methods.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ This method is used to initially place the widget. The placement of the widget depends on whether a Prop3\-D or input dataset is provided. If one of these two is provided, they will be used to obtain a bounding box, around which the widget is placed. Otherwise, you can manually specify a bounds with the Place\-Widget(bounds) method. Note\-: Place\-Widget(bounds) is required by all subclasses; the other methods are provided as convenience methods.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ This method is used to initially place the widget. The placement of the widget depends on whether a Prop3\-D or input dataset is provided. If one of these two is provided, they will be used to obtain a bounding box, around which the widget is placed. Otherwise, you can manually specify a bounds with the Place\-Widget(bounds) method. Note\-: Place\-Widget(bounds) is required by all subclasses; the other methods are provided as convenience methods.  
\item {\ttfamily obj.\-Set\-Prop3\-D (vtk\-Prop3\-D )} -\/ Specify a vtk\-Prop3\-D around which to place the widget. This is not required, but if supplied, it is used to initially position the widget.  
\item {\ttfamily vtk\-Prop3\-D = obj.\-Get\-Prop3\-D ()} -\/ Specify a vtk\-Prop3\-D around which to place the widget. This is not required, but if supplied, it is used to initially position the widget.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set )} -\/ Specify the input dataset. This is not required, but if supplied, and no vtk\-Prop3\-D is specified, it is used to initially position the widget.  
\item {\ttfamily vtk\-Data\-Set = obj.\-Get\-Input ()} -\/ Specify the input dataset. This is not required, but if supplied, and no vtk\-Prop3\-D is specified, it is used to initially position the widget.  
\item {\ttfamily obj.\-Set\-Place\-Factor (double )} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor\-Min\-Value ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor\-Max\-Value ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily obj.\-Set\-Handle\-Size (double )} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget. These handles (like spheres, etc.) are used to manipulate the widget, and are sized as a fraction of the screen diagonal.  
\item {\ttfamily double = obj.\-Get\-Handle\-Size\-Min\-Value ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget. These handles (like spheres, etc.) are used to manipulate the widget, and are sized as a fraction of the screen diagonal.  
\item {\ttfamily double = obj.\-Get\-Handle\-Size\-Max\-Value ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget. These handles (like spheres, etc.) are used to manipulate the widget, and are sized as a fraction of the screen diagonal.  
\item {\ttfamily double = obj.\-Get\-Handle\-Size ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget. These handles (like spheres, etc.) are used to manipulate the widget, and are sized as a fraction of the screen diagonal.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkabstractpolygonalhandlerepresentation3d}{}\section{vtk\-Abstract\-Polygonal\-Handle\-Representation3\-D}\label{vtkwidgets_vtkabstractpolygonalhandlerepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class serves as the geometrical representation of a vtk\-Handle\-Widget. The handle can be represented by an arbitrary polygonal data (vtk\-Poly\-Data), set via Set\-Handle(vtk\-Poly\-Data $\ast$). The actual position of the handle will be initially assumed to be (0,0,0). You can specify an offset from this position if desired. This class differs from vtk\-Polygonal\-Handle\-Representation3\-D in that the handle will always remain front facing, ie it maintains a fixed orientation with respect to the camera. This is done by using vtk\-Followers internally to render the actors.

To create an instance of class vtk\-Abstract\-Polygonal\-Handle\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractPolygonalHandleRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Polygonal\-Handle\-Representation3\-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\-Polygonal\-Handle\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Abstract\-Polygonal\-Handle\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Abstract\-Polygonal\-Handle\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-World\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates.  
\item {\ttfamily obj.\-Set\-Display\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates.  
\item {\ttfamily obj.\-Set\-Handle (vtk\-Poly\-Data )} -\/ Set/get the handle polydata.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Handle ()} -\/ Set/get the handle polydata.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Selected\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Abstract\-Transform = obj.\-Get\-Transform ()} -\/ Get the transform used to transform the generic handle polydata before placing it in the render window  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Set\-Label\-Visibility (int )} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily int = obj.\-Get\-Label\-Visibility ()} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily obj.\-Label\-Visibility\-On ()} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily obj.\-Label\-Visibility\-Off ()} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily obj.\-Set\-Label\-Text (string label)} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily string = obj.\-Get\-Label\-Text ()} -\/ A label may be associated with the seed. The string can be set via Set\-Label\-Text. The visibility of the label can be turned on / off.  
\item {\ttfamily obj.\-Set\-Label\-Text\-Scale (double scale\mbox{[}3\mbox{]})} -\/ Scale text (font size along each dimension).  
\item {\ttfamily vtk\-Follower = obj.\-Get\-Label\-Text\-Actor ()} -\/ Get the label text actor  
\item {\ttfamily obj.\-Set\-Uniform\-Scale (double scale)} -\/ The handle may be scaled uniformly in all three dimensions using this A\-P\-I. The handle can also be scaled interactively using the right mouse button.  
\item {\ttfamily obj.\-Set\-Handle\-Visibility (int )} -\/ Toogle the visibility of the handle on and off  
\item {\ttfamily int = obj.\-Get\-Handle\-Visibility ()} -\/ Toogle the visibility of the handle on and off  
\item {\ttfamily obj.\-Handle\-Visibility\-On ()} -\/ Toogle the visibility of the handle on and off  
\item {\ttfamily obj.\-Handle\-Visibility\-Off ()} -\/ Toogle the visibility of the handle on and off  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkabstractwidget}{}\section{vtk\-Abstract\-Widget}\label{vtkwidgets_vtkabstractwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Abstract\-Widget defines an A\-P\-I and implements methods common to all widgets using the interaction/representation design. In this design, the term interaction means that part of the widget that performs event handling, while the representation corresponds to a vtk\-Prop (or the subclass vtk\-Widget\-Representation) used to represent the widget. vtk\-Abstract\-Widget also implements some methods common to all subclasses.

Note that vtk\-Abstract\-Widget provides access to the vtk\-Widget\-Event\-Translator. This class is responsible for translating V\-T\-K events (defined in vtk\-Command.\-h) into widget events (defined in vtk\-Widget\-Event.\-h). This class can be manipulated so that different V\-T\-K events can be mapped into widget events, thereby allowing the modification of event bindings. Each subclass of vtk\-Abstract\-Widget defines the events to which it responds.

To create an instance of class vtk\-Abstract\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAbstractWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Abstract\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard macros implementing standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard macros implementing standard V\-T\-K methods.  
\item {\ttfamily vtk\-Abstract\-Widget = obj.\-New\-Instance ()} -\/ Standard macros implementing standard V\-T\-K methods.  
\item {\ttfamily vtk\-Abstract\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros implementing standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods for activating this widget. Note that the widget representation must be specified or the widget will not appear. Process\-Events (On by default) must be On for Enabled widget to respond to interaction. If Process\-Events is Off, enabling/disabling a widget merely affects the visibility of the representation.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily int = obj.\-Get\-Process\-Events\-Min\-Value ()} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily int = obj.\-Get\-Process\-Events\-Max\-Value ()} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily int = obj.\-Get\-Process\-Events ()} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily obj.\-Process\-Events\-On ()} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily obj.\-Process\-Events\-Off ()} -\/ Methods to change the whether the widget responds to interaction. Set this to Off to disable interaction. On by default. Subclasses must overide Set\-Process\-Events() to make sure that they pass on the flag to all component widgets.  
\item {\ttfamily vtk\-Widget\-Event\-Translator = obj.\-Get\-Event\-Translator ()} -\/ Create the default widget representation if one is not set. The representation defines the geometry of the widget (i.\-e., how it appears) as well as providing special methods for manipulting the state and appearance of the widget.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set. The representation defines the geometry of the widget (i.\-e., how it appears) as well as providing special methods for manipulting the state and appearance of the widget.  
\item {\ttfamily obj.\-Render ()} -\/ This method is called by subclasses when a render method is to be invoked on the vtk\-Render\-Window\-Interactor. This method should be called (instead of vtk\-Render\-Window\-::\-Render() because it has built into it optimizations for minimizing renders and/or speeding renders.  
\item {\ttfamily obj.\-Set\-Parent (vtk\-Abstract\-Widget parent)} -\/ Specifying a parent to this widget is used when creating composite widgets. It is an internal method not meant to be used by the public. When a widget has a parent, it defers the rendering to the parent. It may also defer managing the cursor (see Manages\-Cursor ivar).  
\item {\ttfamily vtk\-Abstract\-Widget = obj.\-Get\-Parent ()} -\/ Specifying a parent to this widget is used when creating composite widgets. It is an internal method not meant to be used by the public. When a widget has a parent, it defers the rendering to the parent. It may also defer managing the cursor (see Manages\-Cursor ivar).  
\item {\ttfamily vtk\-Widget\-Representation = obj.\-Get\-Representation ()} -\/ Turn on or off the management of the cursor. Cursor management is typically disabled for subclasses when composite widgets are created. For example, vtk\-Handle\-Widgets are often used to create composite widgets, and the parent widget takes over the cursor management.  
\item {\ttfamily obj.\-Set\-Manages\-Cursor (int )} -\/ Turn on or off the management of the cursor. Cursor management is typically disabled for subclasses when composite widgets are created. For example, vtk\-Handle\-Widgets are often used to create composite widgets, and the parent widget takes over the cursor management.  
\item {\ttfamily int = obj.\-Get\-Manages\-Cursor ()} -\/ Turn on or off the management of the cursor. Cursor management is typically disabled for subclasses when composite widgets are created. For example, vtk\-Handle\-Widgets are often used to create composite widgets, and the parent widget takes over the cursor management.  
\item {\ttfamily obj.\-Manages\-Cursor\-On ()} -\/ Turn on or off the management of the cursor. Cursor management is typically disabled for subclasses when composite widgets are created. For example, vtk\-Handle\-Widgets are often used to create composite widgets, and the parent widget takes over the cursor management.  
\item {\ttfamily obj.\-Manages\-Cursor\-Off ()} -\/ Turn on or off the management of the cursor. Cursor management is typically disabled for subclasses when composite widgets are created. For example, vtk\-Handle\-Widgets are often used to create composite widgets, and the parent widget takes over the cursor management.  
\item {\ttfamily obj.\-Set\-Priority (float )} -\/ Override the superclass method. This will automatically change the priority of the widget. Unlike the superclass documentation, no methods such as Set\-Interactor to null and reset it etc. are necessary  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkaffinerepresentation}{}\section{vtk\-Affine\-Representation}\label{vtkwidgets_vtkaffinerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class defines an A\-P\-I for affine transformation widget representations. These representations interact with vtk\-Affine\-Widget. The basic functionality of the affine representation is to maintain a transformation matrix.

This class may be subclassed so that alternative representations can be created. The class defines an A\-P\-I and a default implementation that the vtk\-Affine\-Widget interacts with to render itself in the scene.

To create an instance of class vtk\-Affine\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAffineRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Affine\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Affine\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Affine\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Affine\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Get\-Transform (vtk\-Transform t)} -\/ Retrieve a linear transform characterizing the affine transformation generated by this widget. This method copies its internal transform into the transform provided. The transform is relative to the initial placement of the representation (i.\-e., when Place\-Widget() is invoked).  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkaffinerepresentation2d}{}\section{vtk\-Affine\-Representation2\-D}\label{vtkwidgets_vtkaffinerepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent a vtk\-Affine\-Widget. This representation consists of three parts\-: a box, a circle, and a cross. The box is used for scaling and shearing, the circle for rotation, and the cross for translation. These parts are drawn in the overlay plane and maintain a constant size (width and height) specified in terms of normalized viewport coordinates.

The representation maintains an internal transformation matrix (see superclass' Get\-Transform() method). The transformations generated by this widget assume that the representation lies in the x-\/y plane. If this is not the case, the user is responsible for transforming this representation's matrix into the correct coordinate space (by judicious matrix multiplication). Note that the transformation matrix returned by Get\-Transform() is relative to the last Place\-Widget() invocation. (The Place\-Widget() sets the origin around which rotation and scaling occurs; the origin is the center point of the bounding box provided.)

To create an instance of class vtk\-Affine\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAffineRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Affine\-Representation2\-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\-Affine\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Affine\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Affine\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Box\-Width (int )} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Box\-Width\-Min\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Box\-Width\-Max\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Box\-Width ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily obj.\-Set\-Circle\-Width (int )} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Circle\-Width\-Min\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Circle\-Width\-Max\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Circle\-Width ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily obj.\-Set\-Axes\-Width (int )} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Axes\-Width\-Min\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Axes\-Width\-Max\-Value ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily int = obj.\-Get\-Axes\-Width ()} -\/ Specify the width of the various parts of the representation (in pixels). The three parts are of the representation are the translation axes, the rotation circle, and the scale/shear box. Note that since the widget resizes itself so that the width and height are always the same, only the width needs to be specified.  
\item {\ttfamily obj.\-Set\-Origin (double o\mbox{[}3\mbox{]})} -\/ Specify the origin of the widget (in world coordinates). The origin is the point where the widget places itself. Note that rotations and scaling occurs around the origin.  
\item {\ttfamily obj.\-Set\-Origin (double ox, double oy, double oz)} -\/ Specify the origin of the widget (in world coordinates). The origin is the point where the widget places itself. Note that rotations and scaling occurs around the origin.  
\item {\ttfamily double = obj. Get\-Origin ()} -\/ Specify the origin of the widget (in world coordinates). The origin is the point where the widget places itself. Note that rotations and scaling occurs around the origin.  
\item {\ttfamily obj.\-Get\-Transform (vtk\-Transform t)} -\/ Retrieve a linear transform characterizing the affine transformation generated by this widget. This method copies its internal transform into the transform provided. Note that the Place\-Widget() method initializes the internal matrix to identity. All subsequent widget operations (i.\-e., scale, translate, rotate, shear) are concatenated with the internal transform.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property2\-D )} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Selected\-Property (vtk\-Property2\-D )} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property )} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Selected\-Property ()} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Display\-Text (int )} -\/ Enable the display of text with numeric values characterizing the transformation. Rotation and shear are expressed in degrees; translation the distance in world coordinates; and scale normalized (sx,sy) values.  
\item {\ttfamily int = obj.\-Get\-Display\-Text ()} -\/ Enable the display of text with numeric values characterizing the transformation. Rotation and shear are expressed in degrees; translation the distance in world coordinates; and scale normalized (sx,sy) values.  
\item {\ttfamily obj.\-Display\-Text\-On ()} -\/ Enable the display of text with numeric values characterizing the transformation. Rotation and shear are expressed in degrees; translation the distance in world coordinates; and scale normalized (sx,sy) values.  
\item {\ttfamily obj.\-Display\-Text\-Off ()} -\/ Enable the display of text with numeric values characterizing the transformation. Rotation and shear are expressed in degrees; translation the distance in world coordinates; and scale normalized (sx,sy) values.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily obj.\-End\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Affine\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other. Note\-: Place\-Widget() reinitializes the transformation matrix (i.\-e., sets it to identity). It also sets the origin for scaling and rotation.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkaffinewidget}{}\section{vtk\-Affine\-Widget}\label{vtkwidgets_vtkaffinewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Affine\-Widget is used to perform affine transformations on objects. (Affine transformations are transformations that keep parallel lines parallel. Affine transformations include translation, scaling, rotation, and shearing.)

To use this widget, set the widget representation. The representation maintains a transformation matrix and other instance variables consistent with the transformations applied by this widget.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - select widget: depending on which part is selected
                          translation, rotation, scaling, or shearing may follow.
   LeftButtonReleaseEvent - end selection of widget.
   MouseMoveEvent - interactive movement across widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Affine\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- focal point is being selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for widget motion
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Affine\-Widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Affine\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAffineWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Affine\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Affine\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Affine\-Widget = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Affine\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Affine\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods for activiating this widget. This implementation extends the superclasses' in order to resize the widget handles due to a render start event.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkanglerepresentation}{}\section{vtk\-Angle\-Representation}\label{vtkwidgets_vtkanglerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Angle\-Representation is a superclass for classes representing the vtk\-Angle\-Widget. This representation consists of two rays and three vtk\-Handle\-Representations to place and manipulate the three points defining the angle representation. (Note\-: the three points are referred to as Point1, Center, and Point2, at the two end points (Point1 and Point2) and Center (around which the angle is measured).

To create an instance of class vtk\-Angle\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAngleRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Angle\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Angle\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ This representation and all subclasses must keep an angle (in degrees) consistent with the state of the widget.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the three points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Handle\-Representation handle)} -\/ This method is used to specify the type of handle representation to use for the three internal vtk\-Handle\-Widgets within vtk\-Angle\-Representation. To use this method, create a dummy vtk\-Handle\-Representation (or subclass), and then invoke this method with this dummy. Then the vtk\-Angle\-Representation uses this dummy to clone three vtk\-Handle\-Representations of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Angle widget.)  
\item {\ttfamily obj.\-Instantiate\-Handle\-Representation ()} -\/ This method is used to specify the type of handle representation to use for the three internal vtk\-Handle\-Widgets within vtk\-Angle\-Representation. To use this method, create a dummy vtk\-Handle\-Representation (or subclass), and then invoke this method with this dummy. Then the vtk\-Angle\-Representation uses this dummy to clone three vtk\-Handle\-Representations of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Angle widget.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point1\-Representation ()} -\/ Set/\-Get the handle representations used for the vtk\-Angle\-Representation.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Center\-Representation ()} -\/ Set/\-Get the handle representations used for the vtk\-Angle\-Representation.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point2\-Representation ()} -\/ Set/\-Get the handle representations used for the vtk\-Angle\-Representation.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the end points of the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the end points of the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the end points of the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the end points of the representation to be active.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Specify the format to use for labelling the angle. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the angle value.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Specify the format to use for labelling the angle. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the angle value.  
\item {\ttfamily obj.\-Set\-Ray1\-Visibility (int )} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily int = obj.\-Get\-Ray1\-Visibility ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Ray1\-Visibility\-On ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Ray1\-Visibility\-Off ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Set\-Ray2\-Visibility (int )} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily int = obj.\-Get\-Ray2\-Visibility ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Ray2\-Visibility\-On ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Ray2\-Visibility\-Off ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Set\-Arc\-Visibility (int )} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily int = obj.\-Get\-Arc\-Visibility ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Arc\-Visibility\-On ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Arc\-Visibility\-Off ()} -\/ Special methods for turning off the rays and arc that define the cone and arc of the angle.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Center\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkanglerepresentation2d}{}\section{vtk\-Angle\-Representation2\-D}\label{vtkwidgets_vtkanglerepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Angle\-Representation2\-D is a representation for the vtk\-Angle\-Widget. This representation consists of two rays and three vtk\-Handle\-Representations to place and manipulate the three points defining the angle representation. (Note\-: the three points are referred to as Point1, Center, and Point2, at the two end points (Point1 and Point2) and Center (around which the angle is measured). This particular implementation is a 2\-D representation, meaning that it draws in the overlay plane.

To create an instance of class vtk\-Angle\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAngleRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Angle\-Representation2\-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\-Angle\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Satisfy the superclasses A\-P\-I.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily vtk\-Leader\-Actor2\-D = obj.\-Get\-Ray1 ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily vtk\-Leader\-Actor2\-D = obj.\-Get\-Ray2 ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily vtk\-Leader\-Actor2\-D = obj.\-Get\-Arc ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Method defined by vtk\-Widget\-Representation superclass and needed here.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkanglerepresentation3d}{}\section{vtk\-Angle\-Representation3\-D}\label{vtkwidgets_vtkanglerepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Angle\-Representation3\-D is a representation for the vtk\-Angle\-Widget. This representation consists of two rays and three vtk\-Handle\-Representations to place and manipulate the three points defining the angle representation. (Note\-: the three points are referred to as Point1, Center, and Point2, at the two end points (Point1 and Point2) and Center (around which the angle is measured). This particular implementation is a 3\-D representation, meaning that it draws in the overlay plane.

To create an instance of class vtk\-Angle\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAngleRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Angle\-Representation3\-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\-Angle\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Angle\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily double = obj.\-Get\-Angle ()} -\/ Satisfy the superclasses A\-P\-I. Angle returned is in radians.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Center\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Center\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Ray1 ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Ray2 ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily vtk\-Actor = obj.\-Get\-Arc ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily vtk\-Follower = obj.\-Get\-Text\-Actor ()} -\/ Set/\-Get the three leaders used to create this representation. By obtaining these leaders the user can set the appropriate properties, etc.  
\item {\ttfamily obj.\-Set\-Text\-Actor\-Scale (double scale\mbox{[}3\mbox{]})} -\/ Scale text.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Method defined by vtk\-Widget\-Representation superclass and needed here.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods required by vtk\-Prop superclass.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkanglewidget}{}\section{vtk\-Angle\-Widget}\label{vtkwidgets_vtkanglewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Angle\-Widget is used to measure the angle between two rays (defined by three points). The three points (two end points and a center) can be positioned independently, and when they are released, a special Place\-Point\-Event is invoked so that special operations may be take to reposition the point (snap to grid, etc.) The widget has two different modes of interaction\-: when initially defined (i.\-e., placing the three points) and then a manipulate mode (adjusting the position of the three points).

To use this widget, specify an instance of vtk\-Angle\-Widget and a representation (a subclass of vtk\-Angle\-Representation). The widget is implemented using three instances of vtk\-Handle\-Widget which are used to position the three points. The representations for these handle widgets are provided by the vtk\-Angle\-Representation.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - add a point or select a handle 
   MouseMoveEvent - position the second or third point, or move a handle
   LeftButtonReleaseEvent - release the selected handle
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Angle\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::AddPoint -- add one point; depending on the state
                               it may the first, second or third point 
                               added. Or, if near a handle, select the handle.
   vtkWidgetEvent::Move -- position the second or third point, or move the
                           handle depending on the state.
   vtkWidgetEvent::EndSelect -- the handle manipulation process has completed.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (beginning to interact)
   vtkCommand::EndInteractionEvent (completing interaction)
   vtkCommand::InteractionEvent (moving a handle)
   vtkCommand::PlacePointEvent (after a point is positioned; 
                                call data includes handle id (0,1,2))
 \end{DoxyPre}


To create an instance of class vtk\-Angle\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkAngleWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Angle\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Angle\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Angle\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Angle\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Angle\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily int = obj.\-Is\-Angle\-Valid ()} -\/ A flag indicates whether the angle is valid. The angle value only becomes valid after two of the three points are placed.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkballoonrepresentation}{}\section{vtk\-Balloon\-Representation}\label{vtkwidgets_vtkballoonrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Balloon\-Representation is used to represent the vtk\-Balloon\-Widget. This representation is defined by two items\-: a text string and an image. At least one of these two items must be defined, but it is allowable to specify both, or just an image or just text. If both the text and image are specified, then methods are available for positioning the text and image with respect to each other.

The balloon representation consists of three parts\-: text, a rectangular frame behind the text, and an image placed next to the frame and sized to match the frame.

The size of the balloon is ultimately controlled by the text properties (i.\-e., font size). This representation uses a layout policy as follows.

If there is just text and no image, then the text properties and padding are used to control the size of the balloon.

If there is just an image and no text, then the Image\-Size\mbox{[}2\mbox{]} member is used to control the image size. (The image will fit into this rectangle, but will not necessarily fill the whole rectangle, i.\-e., the image is not stretched).

If there is text and an image, the following approach ia used. First, based on the font size and other related properties (e.\-g., padding), determine the size of the frame. Second, depending on the layout of the image and text frame, control the size of the neighboring image (since the frame and image share a common edge). However, if this results in an image that is smaller than Image\-Size\mbox{[}2\mbox{]}, then the image size will be set to Image\-Size\mbox{[}2\mbox{]} and the frame will be adjusted accordingly. The text is always placed in the center of the frame if the frame is resized.

To create an instance of class vtk\-Balloon\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBalloonRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Balloon\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Balloon\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Balloon\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Balloon\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Balloon\-Image (vtk\-Image\-Data img)} -\/ Specify/retrieve the image to display in the balloon.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Balloon\-Image ()} -\/ Specify/retrieve the image to display in the balloon.  
\item {\ttfamily string = obj.\-Get\-Balloon\-Text ()} -\/ Specify/retrieve the text to display in the balloon.  
\item {\ttfamily obj.\-Set\-Balloon\-Text (string )} -\/ Specify/retrieve the text to display in the balloon.  
\item {\ttfamily obj.\-Set\-Image\-Size (int , int )} -\/ Specify the minimum size for the image. Note that this is a bounding rectangle, the image will fit inside of it. However, if the balloon consists of text plus an image, then the image may be bigger than Image\-Size\mbox{[}2\mbox{]} to fit into the balloon frame.  
\item {\ttfamily obj.\-Set\-Image\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify the minimum size for the image. Note that this is a bounding rectangle, the image will fit inside of it. However, if the balloon consists of text plus an image, then the image may be bigger than Image\-Size\mbox{[}2\mbox{]} to fit into the balloon frame.  
\item {\ttfamily int = obj. Get\-Image\-Size ()} -\/ Specify the minimum size for the image. Note that this is a bounding rectangle, the image will fit inside of it. However, if the balloon consists of text plus an image, then the image may be bigger than Image\-Size\mbox{[}2\mbox{]} to fit into the balloon frame.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property p)} -\/ Set/get the text property (relevant only if text is shown).  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/get the text property (relevant only if text is shown).  
\item {\ttfamily obj.\-Set\-Frame\-Property (vtk\-Property2\-D p)} -\/ Set/get the frame property (relevant only if text is shown). The frame lies behind the text.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Frame\-Property ()} -\/ Set/get the frame property (relevant only if text is shown). The frame lies behind the text.  
\item {\ttfamily obj.\-Set\-Image\-Property (vtk\-Property2\-D p)} -\/ Set/get the image property (relevant only if an image is shown).  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Image\-Property ()} -\/ Set/get the image property (relevant only if an image is shown).  
\item {\ttfamily obj.\-Set\-Balloon\-Layout (int )} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily int = obj.\-Get\-Balloon\-Layout ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Image\-Left ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Image\-Right ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Image\-Bottom ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Image\-Top ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Text\-Left ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Text\-Right ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Text\-Top ()} -\/ Specify the layout of the image and text within the balloon. Note that there are reduncies in these methods, for example Set\-Balloon\-Layout\-To\-Image\-Left() results in the same effect as Set\-Balloon\-Layout\-To\-Text\-Right(). If only text is specified, or only an image is specified, then it doesn't matter how the layout is specified.  
\item {\ttfamily obj.\-Set\-Balloon\-Layout\-To\-Text\-Bottom ()} -\/ Set/\-Get the offset from the mouse pointer from which to place the balloon. The representation will try and honor this offset unless there is a collision with the side of the renderer, in which case the balloon will be repositioned to lie within the rendering window.  
\item {\ttfamily obj.\-Set\-Offset (int , int )} -\/ Set/\-Get the offset from the mouse pointer from which to place the balloon. The representation will try and honor this offset unless there is a collision with the side of the renderer, in which case the balloon will be repositioned to lie within the rendering window.  
\item {\ttfamily obj.\-Set\-Offset (int a\mbox{[}2\mbox{]})} -\/ Set/\-Get the offset from the mouse pointer from which to place the balloon. The representation will try and honor this offset unless there is a collision with the side of the renderer, in which case the balloon will be repositioned to lie within the rendering window.  
\item {\ttfamily int = obj. Get\-Offset ()} -\/ Set/\-Get the offset from the mouse pointer from which to place the balloon. The representation will try and honor this offset unless there is a collision with the side of the renderer, in which case the balloon will be repositioned to lie within the rendering window.  
\item {\ttfamily obj.\-Set\-Padding (int )} -\/ Set/\-Get the padding (in pixels) that is used between the text and the frame.  
\item {\ttfamily int = obj.\-Get\-Padding\-Min\-Value ()} -\/ Set/\-Get the padding (in pixels) that is used between the text and the frame.  
\item {\ttfamily int = obj.\-Get\-Padding\-Max\-Value ()} -\/ Set/\-Get the padding (in pixels) that is used between the text and the frame.  
\item {\ttfamily int = obj.\-Get\-Padding ()} -\/ Set/\-Get the padding (in pixels) that is used between the text and the frame.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-End\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkballoonwidget}{}\section{vtk\-Balloon\-Widget}\label{vtkwidgets_vtkballoonwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Balloon\-Widget is used to popup text and/or an image when the mouse hovers over an instance of vtk\-Prop. The widget keeps track of (vtk\-Prop,vtk\-Balloon) pairs (where the internal vtk\-Balloon class is defined by a pair of vtk\-Std\-String and vtk\-Image\-Data), and when the mouse stops moving for a user-\/specified period of time over the vtk\-Prop, then the vtk\-Balloon is drawn nearby the vtk\-Prop. Note that an instance of vtk\-Balloon\-Representation is used to draw the balloon.

To use this widget, specify an instance of vtk\-Balloon\-Widget and a representation (e.\-g., vtk\-Balloon\-Representation). Then list all instances of vtk\-Prop, a text string, and/or an instance of vtk\-Image\-Data to be associated with each vtk\-Prop. (Note that you can specify both text and an image, or just one or the other.) You may also wish to specify the hover delay (i.\-e., set in the superclass vtk\-Hover\-Widget).

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget observes the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   MouseMoveEvent - occurs when mouse is moved in render window.
   TimerEvent - occurs when the time between events (e.g., mouse move)
                is greater than TimerDuration.
   KeyPressEvent - when the "Enter" key is pressed after the balloon appears,
                   a callback is activited (e.g., WidgetActivateEvent).
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Balloon\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Move -- start the timer
   vtkWidgetEvent::TimedOut -- when hovering occurs,
   vtkWidgetEvent::SelectAction -- activate any callbacks associated 
                                   with the balloon.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::TimerEvent (when hovering is determined to occur)
   vtkCommand::EndInteractionEvent (after a hover has occured and the
                                    mouse begins moving again).
   vtkCommand::WidgetActivateEvent (when the balloon is selected with a
                                    keypress).
 \end{DoxyPre}


To create an instance of class vtk\-Balloon\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBalloonWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Balloon\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Balloon\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Balloon\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Balloon\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it performs special timer-\/related operations.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Balloon\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Add\-Balloon (vtk\-Prop prop, string str, vtk\-Image\-Data img)} -\/ Add and remove text and/or an image to be associated with a vtk\-Prop. You may add one or both of them.  
\item {\ttfamily obj.\-Add\-Balloon (vtk\-Prop prop, string str)} -\/ Add and remove text and/or an image to be associated with a vtk\-Prop. You may add one or both of them.  
\item {\ttfamily obj.\-Remove\-Balloon (vtk\-Prop prop)} -\/ Add and remove text and/or an image to be associated with a vtk\-Prop. You may add one or both of them.  
\item {\ttfamily string = obj.\-Get\-Balloon\-String (vtk\-Prop prop)} -\/ Methods to retrieve the information associated with each vtk\-Prop (i.\-e., the information that makes up each balloon). A N\-U\-L\-L will be returned if the vtk\-Prop does not exist, or if a string or image have not been associated with the specified vtk\-Prop.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Balloon\-Image (vtk\-Prop prop)} -\/ Methods to retrieve the information associated with each vtk\-Prop (i.\-e., the information that makes up each balloon). A N\-U\-L\-L will be returned if the vtk\-Prop does not exist, or if a string or image have not been associated with the specified vtk\-Prop.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Current\-Prop ()} -\/ Set/\-Get the object used to perform pick operations. Since the vtk\-Balloon\-Widget operates on vtk\-Props, the picker must be a subclass of vtk\-Abstract\-Prop\-Picker. (Note\-: if not specified, an instance of vtk\-Prop\-Picker is used.)  
\item {\ttfamily obj.\-Set\-Picker (vtk\-Abstract\-Prop\-Picker )} -\/ Set/\-Get the object used to perform pick operations. Since the vtk\-Balloon\-Widget operates on vtk\-Props, the picker must be a subclass of vtk\-Abstract\-Prop\-Picker. (Note\-: if not specified, an instance of vtk\-Prop\-Picker is used.)  
\item {\ttfamily vtk\-Abstract\-Prop\-Picker = obj.\-Get\-Picker ()} -\/ Set/\-Get the object used to perform pick operations. Since the vtk\-Balloon\-Widget operates on vtk\-Props, the picker must be a subclass of vtk\-Abstract\-Prop\-Picker. (Note\-: if not specified, an instance of vtk\-Prop\-Picker is used.)  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkbeziercontourlineinterpolator}{}\section{vtk\-Bezier\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkbeziercontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The line interpolator interpolates supplied nodes (see Interpolate\-Line) with bezier line segments. The finess of the curve may be controlled using Set\-Maximum\-Curve\-Error and Set\-Maximum\-Number\-Of\-Line\-Segments.

To create an instance of class vtk\-Bezier\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBezierContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bezier\-Contour\-Line\-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\-Bezier\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Bezier\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Bezier\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)}  
\item {\ttfamily obj.\-Set\-Maximum\-Curve\-Error (double )} -\/ The difference between a line segment connecting two points and the curve connecting the same points. In the limit of the length of the curve dx -\/$>$ 0, the two values will be the same. The smaller this number, the finer the bezier curve will be interpolated. Default is 0.\-005  
\item {\ttfamily double = obj.\-Get\-Maximum\-Curve\-Error\-Min\-Value ()} -\/ The difference between a line segment connecting two points and the curve connecting the same points. In the limit of the length of the curve dx -\/$>$ 0, the two values will be the same. The smaller this number, the finer the bezier curve will be interpolated. Default is 0.\-005  
\item {\ttfamily double = obj.\-Get\-Maximum\-Curve\-Error\-Max\-Value ()} -\/ The difference between a line segment connecting two points and the curve connecting the same points. In the limit of the length of the curve dx -\/$>$ 0, the two values will be the same. The smaller this number, the finer the bezier curve will be interpolated. Default is 0.\-005  
\item {\ttfamily double = obj.\-Get\-Maximum\-Curve\-Error ()} -\/ The difference between a line segment connecting two points and the curve connecting the same points. In the limit of the length of the curve dx -\/$>$ 0, the two values will be the same. The smaller this number, the finer the bezier curve will be interpolated. Default is 0.\-005  
\item {\ttfamily obj.\-Set\-Maximum\-Curve\-Line\-Segments (int )} -\/ Maximum number of bezier line segments between two nodes. Larger values create a finer interpolation. Default is 100.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Curve\-Line\-Segments\-Min\-Value ()} -\/ Maximum number of bezier line segments between two nodes. Larger values create a finer interpolation. Default is 100.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Curve\-Line\-Segments\-Max\-Value ()} -\/ Maximum number of bezier line segments between two nodes. Larger values create a finer interpolation. Default is 100.  
\item {\ttfamily int = obj.\-Get\-Maximum\-Curve\-Line\-Segments ()} -\/ Maximum number of bezier line segments between two nodes. Larger values create a finer interpolation. Default is 100.  
\item {\ttfamily obj.\-Get\-Span (int node\-Index, vtk\-Int\-Array node\-Indices, vtk\-Contour\-Representation rep)} -\/ Span of the interpolator. ie. the number of control points its supposed to interpolate given a node.

The first argument is the current node\-Index. ie, you'd be trying to interpolate between nodes \char`\"{}node\-Index\char`\"{} and \char`\"{}node\-Index-\/1\char`\"{}, unless you're closing the contour in which case, you're trying to interpolate \char`\"{}node\-Index\char`\"{} and \char`\"{}\-Node=0\char`\"{}. The node span is returned in a vtk\-Int\-Array.

The node span is returned in a vtk\-Int\-Array. The node span returned by this interpolator will be a 2-\/tuple with a span of 4.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkbidimensionalrepresentation2d}{}\section{vtk\-Bi\-Dimensional\-Representation2\-D}\label{vtkwidgets_vtkbidimensionalrepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Bi\-Dimensional\-Representation2\-D is used to represent the bi-\/dimensional measure in a 2\-D (overlay) context. This representation consists of two perpendicular lines defined by four vtk\-Handle\-Representations. The four handles can be independently manipulated consistent with the orthogonal constraint on the lines. (Note\-: the four points are referred to as Point1, Point2, Point3 and Point4. Point1 and Point2 define the first line; and Point3 and Point4 define the second orthogonal line.)

To create this widget, you click to place the first two points. The third point is mirrored with the fourth point; when you place the third point (which is orthogonal to the lined defined by the first two points), the fourth point is dropped as well. After definition, the four points can be moved (in constrained fashion, preserving orthogonality). Further, the entire widget can be translated by grabbing the center point of the widget; each line can be moved along the other line; and the entire widget can be rotated around its center point.

To create an instance of class vtk\-Bi\-Dimensional\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBiDimensionalRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bi\-Dimensional\-Representation2\-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\-Bi\-Dimensional\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Bi\-Dimensional\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Bi\-Dimensional\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point3\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point4\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point3\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point4\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point3\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point4\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point3\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point4\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the four points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Line1\-Visibility (int )} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily int = obj.\-Get\-Line1\-Visibility ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Line1\-Visibility\-On ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Line1\-Visibility\-Off ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Set\-Line2\-Visibility (int )} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily int = obj.\-Get\-Line2\-Visibility ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Line2\-Visibility\-On ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Line2\-Visibility\-Off ()} -\/ Special methods for turning off the lines that define the bi-\/dimensional measure. Generally these methods are used by the vtk\-Bi\-Dimensional\-Widget to control the appearance of the widget. Note\-: turning off Line1 actually turns off Line1 and Line2.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Handle\-Representation handle)} -\/ This method is used to specify the type of handle representation to use for the four internal vtk\-Handle\-Representations within vtk\-Bi\-Dimensional\-Representation2\-D. To use this method, create a dummy vtk\-Handle\-Representation (or subclass), and then invoke this method with this dummy. Then the vtk\-Bi\-Dimensional\-Representation2\-D uses this dummy to clone four vtk\-Handle\-Representations of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Bi\-Dimensional\-Widget for the purposes of cloning.)  
\item {\ttfamily obj.\-Instantiate\-Handle\-Representation ()} -\/ This method is used to specify the type of handle representation to use for the four internal vtk\-Handle\-Representations within vtk\-Bi\-Dimensional\-Representation2\-D. To use this method, create a dummy vtk\-Handle\-Representation (or subclass), and then invoke this method with this dummy. Then the vtk\-Bi\-Dimensional\-Representation2\-D uses this dummy to clone four vtk\-Handle\-Representations of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Bi\-Dimensional\-Widget for the purposes of cloning.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point1\-Representation ()} -\/ Set/\-Get the handle representations used within the vtk\-Bi\-Dimensional\-Representation2\-D. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point2\-Representation ()} -\/ Set/\-Get the handle representations used within the vtk\-Bi\-Dimensional\-Representation2\-D. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point3\-Representation ()} -\/ Set/\-Get the handle representations used within the vtk\-Bi\-Dimensional\-Representation2\-D. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point4\-Representation ()} -\/ Set/\-Get the handle representations used within the vtk\-Bi\-Dimensional\-Representation2\-D. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Line\-Property ()} -\/ Retrieve the property used to control the appearance of the two orthogonal lines.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Selected\-Line\-Property ()} -\/ Retrieve the property used to control the appearance of the two orthogonal lines.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Retrieve the property used to control the appearance of the text labels.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the representation to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the representation (in pixels) in which the cursor is considered near enough to the representation to be active.  
\item {\ttfamily double = obj.\-Get\-Length1 ()} -\/ Return the length of the line defined by (Point1,Point2). This is the distance in the world coordinate system.  
\item {\ttfamily double = obj.\-Get\-Length2 ()} -\/ Return the length of the line defined by (Point3,Point4). This is the distance in the world coordinate system.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Specify the format to use for labelling the distance. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the distance value.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Specify the format to use for labelling the distance. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the distance value.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Definition (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Point2\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Point3\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Manipulation (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Highlight (int highlight\-On)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily obj.\-Set\-Show\-Label\-Above\-Widget (int )} -\/ Toggle whether to display the label above or below the widget. Defaults to 1.  
\item {\ttfamily int = obj.\-Get\-Show\-Label\-Above\-Widget ()} -\/ Toggle whether to display the label above or below the widget. Defaults to 1.  
\item {\ttfamily obj.\-Show\-Label\-Above\-Widget\-On ()} -\/ Toggle whether to display the label above or below the widget. Defaults to 1.  
\item {\ttfamily obj.\-Show\-Label\-Above\-Widget\-Off ()} -\/ Toggle whether to display the label above or below the widget. Defaults to 1.  
\item {\ttfamily obj.\-Set\-I\-D (long id)} -\/ Set/get the id to display in the label.  
\item {\ttfamily long = obj.\-Get\-I\-D ()} -\/ Set/get the id to display in the label.  
\item {\ttfamily string = obj.\-Get\-Label\-Text ()} -\/ Get the text shown in the widget's label.  
\item {\ttfamily obj.\-Get\-Label\-Position (double pos\mbox{[}3\mbox{]})} -\/ Get the position of the widget's label in display coordinates.  
\item {\ttfamily obj.\-Get\-World\-Label\-Position (double pos\mbox{[}3\mbox{]})} -\/ Get the position of the widget's label in display coordinates.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkbidimensionalwidget}{}\section{vtk\-Bi\-Dimensional\-Widget}\label{vtkwidgets_vtkbidimensionalwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Bi\-Dimensional\-Widget is used to measure the bi-\/dimensional length of an object. The bi-\/dimensional measure is defined by two finite, orthogonal lines that intersect within the finite extent of both lines. The lengths of these two lines gives the bi-\/dimensional measure. Each line is defined by two handle widgets at the end points of each line.

The orthognal constraint on the two lines limits how the four end points can be positioned. The first two points can be placed arbitrarily to define the first line (similar to vtk\-Distance\-Widget). The placement of the third point is limited by the finite extent of the first line. As the third point is placed, the fourth point is placed on the opposite side of the first line. Once the third point is placed, the second line is defined since the fourth point is defined at the same time, but the fourth point can be moved along the second line (i.\-e., maintaining the orthogonal relationship between the two lines). Onced defined, any of the four points can be moved along their constraint lines. Also, each line can be translated along the other line (in an orthogonal direction), and the whole bi-\/dimensional widget can be rotated about its center point (see the description of the event bindings). Finally, selecting the point where the two orthogonal axes intersect, the entire widget can be translated in any direction.

Placement of any point results in a special Place\-Point\-Event invocation so that special operations may be performed to reposition the point. Motion of any point, moving the lines, or rotating the widget cause Interaction\-Events to be invoked. Note that the widget has two fundamental modes\-: a define mode (when initially placing the points) and a manipulate mode (after the points are placed). Line translation and rotation are only possible in manipulate mode.

To use this widget, specify an instance of vtk\-Bi\-Dimensional\-Widget and a representation (e.\-g., vtk\-Bi\-Dimensional\-Representation2\-D). The widget is implemented using four instances of vtk\-Handle\-Widget which are used to position the end points of the two intersecting lines. The representations for these handle widgets are provided by the vtk\-Bi\-Dimensional\-Representation2\-D class.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - define a point or manipulate a handle, line,
                          perform rotation or translate the widget.
   MouseMoveEvent - position the points, move a line, rotate or translate the widget
   LeftButtonReleaseEvent - release the selected handle and end interaction
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Bi\-Dimensional\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::AddPoint -- (In Define mode:) Add one point; depending on the 
                               state it may the first, second, third or fourth 
                               point added. (In Manipulate mode:) If near a handle, 
                               select the handle. Or if near a line, select the line.
   vtkWidgetEvent::Move -- (In Define mode:) Position the second, third or fourth 
                           point. (In Manipulate mode:) Move the handle, line or widget.
   vtkWidgetEvent::EndSelect -- the manipulation process has completed.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (beginning to interact)
   vtkCommand::EndInteractionEvent (completing interaction)
   vtkCommand::InteractionEvent (moving a handle, line or performing rotation)
   vtkCommand::PlacePointEvent (after a point is positioned; 
                                call data includes handle id (0,1,2,4))
 \end{DoxyPre}


To create an instance of class vtk\-Bi\-Dimensional\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBiDimensionalWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bi\-Dimensional\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Bi\-Dimensional\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Bi\-Dimensional\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Bi\-Dimensional\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Bi\-Dimensional\-Representation2\-D r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily int = obj.\-Is\-Measure\-Valid ()} -\/ A flag indicates whether the bi-\/dimensional measure is valid. The widget becomes valid after two of the four points are placed.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkborderrepresentation}{}\section{vtk\-Border\-Representation}\label{vtkwidgets_vtkborderrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent and render a vt\-Border\-Widget. To use this class, you need to specify the two corners of a rectangular region.

The class is typically subclassed so that specialized representations can be created. The class defines an A\-P\-I and a default implementation that the vtk\-Border\-Representation interacts with to render itself in the scene.

To create an instance of class vtk\-Border\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBorderRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Border\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Border\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Define standard methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Define standard methods.  
\item {\ttfamily vtk\-Border\-Representation = obj.\-New\-Instance ()} -\/ Define standard methods.  
\item {\ttfamily vtk\-Border\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Define standard methods.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Position\-Coordinate ()} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily obj.\-Set\-Position (double, double)} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily obj.\-Set\-Position (double a\mbox{[}2\mbox{]})} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily double = obj.\-Get\-Position ()} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Position2\-Coordinate ()} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily obj.\-Set\-Position2 (double, double)} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily obj.\-Set\-Position2 (double a\mbox{[}2\mbox{]})} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily double = obj.\-Get\-Position2 ()} -\/ Specify opposite corners of the box defining the boundary of the widget. By default, these coordinates are in the normalized viewport coordinate system, with Position the lower left of the outline, and Position2 relative to Position. Note that using these methods are affected by the Proportional\-Resize flag. That is, if the aspect ratio of the representation is to be preserved (e.\-g., Proportional\-Resize is on), then the rectangle (Position,Position2) is a bounding rectangle. Also,  
\item {\ttfamily obj.\-Set\-Show\-Border (int )} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily int = obj.\-Get\-Show\-Border\-Min\-Value ()} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily int = obj.\-Get\-Show\-Border\-Max\-Value ()} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily int = obj.\-Get\-Show\-Border ()} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily obj.\-Set\-Show\-Border\-To\-Off ()} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily obj.\-Set\-Show\-Border\-To\-On ()} -\/ Specify when and if the border should appear. If Show\-Border is \char`\"{}on\char`\"{}, then the border will always appear. If Show\-Border is \char`\"{}off\char`\"{} then the border will never appear. If Show\-Border is \char`\"{}active\char`\"{} then the border will appear when the mouse pointer enters the region bounded by the border widget.  
\item {\ttfamily obj.\-Set\-Show\-Border\-To\-Active ()} -\/ Specify the properties of the border.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Border\-Property ()} -\/ Specify the properties of the border.  
\item {\ttfamily obj.\-Set\-Proportional\-Resize (int )} -\/ Indicate whether resizing operations should keep the x-\/y directions proportional to one another. Also, if Proportional\-Resize is on, then the rectangle (Position,Position2) is a bounding rectangle, and the representation will be placed in the rectangle in such a way as to preserve the aspect ratio of the representation.  
\item {\ttfamily int = obj.\-Get\-Proportional\-Resize ()} -\/ Indicate whether resizing operations should keep the x-\/y directions proportional to one another. Also, if Proportional\-Resize is on, then the rectangle (Position,Position2) is a bounding rectangle, and the representation will be placed in the rectangle in such a way as to preserve the aspect ratio of the representation.  
\item {\ttfamily obj.\-Proportional\-Resize\-On ()} -\/ Indicate whether resizing operations should keep the x-\/y directions proportional to one another. Also, if Proportional\-Resize is on, then the rectangle (Position,Position2) is a bounding rectangle, and the representation will be placed in the rectangle in such a way as to preserve the aspect ratio of the representation.  
\item {\ttfamily obj.\-Proportional\-Resize\-Off ()} -\/ Indicate whether resizing operations should keep the x-\/y directions proportional to one another. Also, if Proportional\-Resize is on, then the rectangle (Position,Position2) is a bounding rectangle, and the representation will be placed in the rectangle in such a way as to preserve the aspect ratio of the representation.  
\item {\ttfamily obj.\-Set\-Minimum\-Size (int , int )} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily obj.\-Set\-Minimum\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily int = obj. Get\-Minimum\-Size ()} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily obj.\-Set\-Maximum\-Size (int , int )} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily obj.\-Set\-Maximum\-Size (int a\mbox{[}2\mbox{]})} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily int = obj. Get\-Maximum\-Size ()} -\/ Specify a minimum and/or maximum size (in pixels) that this representation can take. These methods require two values\-: size values in the x and y directions, respectively.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily double = obj. Get\-Selection\-Point ()} -\/ After a selection event within the region interior to the border; the normalized selection coordinates may be obtained.  
\item {\ttfamily obj.\-Set\-Moving (int )} -\/ This is a modifier of the interaction state. When set, widget interaction allows the border (and stuff inside of it) to be translated with mouse motion.  
\item {\ttfamily int = obj.\-Get\-Moving ()} -\/ This is a modifier of the interaction state. When set, widget interaction allows the border (and stuff inside of it) to be translated with mouse motion.  
\item {\ttfamily obj.\-Moving\-On ()} -\/ This is a modifier of the interaction state. When set, widget interaction allows the border (and stuff inside of it) to be translated with mouse motion.  
\item {\ttfamily obj.\-Moving\-Off ()} -\/ This is a modifier of the interaction state. When set, widget interaction allows the border (and stuff inside of it) to be translated with mouse motion.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses should implement these methods. See the superclasses' documentation for more information.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses should implement these methods. See the superclasses' documentation for more information.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses should implement these methods. See the superclasses' documentation for more information.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ Subclasses should implement these methods. See the superclasses' documentation for more information.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Subclasses should implement these methods. See the superclasses' documentation for more information.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkborderwidget}{}\section{vtk\-Border\-Widget}\label{vtkwidgets_vtkborderwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a superclass for 2\-D widgets that may require a rectangular border. Besides drawing a border, the widget provides methods for resizing and moving the rectangular region (and associated border). The widget provides methods and internal data members so that subclasses can take advantage of this widgets capabilities, requiring only that the subclass defines a \char`\"{}representation\char`\"{}, i.\-e., some combination of props or actors that can be managed in the 2\-D rectangular region.

The class defines basic positioning functionality, including the ability to size the widget with locked x/y proportions. The area within the border may be made \char`\"{}selectable\char`\"{} as well, meaning that a selection event interior to the widget invokes a virtual Select\-Region() method, which can be used to pick objects or otherwise manipulate data interior to the widget.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 On the boundary of the widget:
   LeftButtonPressEvent - select boundary
   LeftButtonReleaseEvent - deselect boundary
   MouseMoveEvent - move/resize widget depending on which portion of the
                    boundary was selected.
 On the interior of the widget:
   LeftButtonPressEvent - invoke SelectButton() callback (if the ivar
                          Selectable is on)
 Anywhere on the widget:
   MiddleButtonPressEvent - move the widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Border\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Translate -- the widget is to be translated
   vtkWidgetEvent::Move -- a request for slider motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, this widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Border\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBorderWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Border\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Border\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Border\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Border\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Selectable (int )} -\/ Indicate whether the interior region of the widget can be selected or not. If not, then events (such as left mouse down) allow the user to \char`\"{}move\char`\"{} the widget, and no selection is possible. Otherwise the Select\-Region() method is invoked.  
\item {\ttfamily int = obj.\-Get\-Selectable ()} -\/ Indicate whether the interior region of the widget can be selected or not. If not, then events (such as left mouse down) allow the user to \char`\"{}move\char`\"{} the widget, and no selection is possible. Otherwise the Select\-Region() method is invoked.  
\item {\ttfamily obj.\-Selectable\-On ()} -\/ Indicate whether the interior region of the widget can be selected or not. If not, then events (such as left mouse down) allow the user to \char`\"{}move\char`\"{} the widget, and no selection is possible. Otherwise the Select\-Region() method is invoked.  
\item {\ttfamily obj.\-Selectable\-Off ()} -\/ Indicate whether the interior region of the widget can be selected or not. If not, then events (such as left mouse down) allow the user to \char`\"{}move\char`\"{} the widget, and no selection is possible. Otherwise the Select\-Region() method is invoked.  
\item {\ttfamily obj.\-Set\-Resizable (int )} -\/ Indicate whether the boundary of the widget can be resized. If not, the cursor will not change to \char`\"{}resize\char`\"{} type when mouse over the boundary.  
\item {\ttfamily int = obj.\-Get\-Resizable ()} -\/ Indicate whether the boundary of the widget can be resized. If not, the cursor will not change to \char`\"{}resize\char`\"{} type when mouse over the boundary.  
\item {\ttfamily obj.\-Resizable\-On ()} -\/ Indicate whether the boundary of the widget can be resized. If not, the cursor will not change to \char`\"{}resize\char`\"{} type when mouse over the boundary.  
\item {\ttfamily obj.\-Resizable\-Off ()} -\/ Indicate whether the boundary of the widget can be resized. If not, the cursor will not change to \char`\"{}resize\char`\"{} type when mouse over the boundary.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Border\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkboundedplanepointplacer}{}\section{vtk\-Bounded\-Plane\-Point\-Placer}\label{vtkwidgets_vtkboundedplanepointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Bounded\-Plane\-Point\-Placer is a type of point placer that constrains its points to a finite (i.\-e., bounded) plance.

To create an instance of class vtk\-Bounded\-Plane\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoundedPlanePointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Bounded\-Plane\-Point\-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\-Bounded\-Plane\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Bounded\-Plane\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Bounded\-Plane\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Projection\-Normal (int )} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Min\-Value ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Max\-Value ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-X\-Axis ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Y\-Axis ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Z\-Axis ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Oblique ()} -\/ If the Projection\-Normal is set to Oblique, then this is the oblique plane used to constrain the handle position.  
\item {\ttfamily obj.\-Set\-Oblique\-Plane (vtk\-Plane )} -\/ If the Projection\-Normal is set to Oblique, then this is the oblique plane used to constrain the handle position.  
\item {\ttfamily obj.\-Set\-Projection\-Position (double position)} -\/ The position of the bounding plane from the origin along the normal. The origin and normal are defined in the oblique plane when the Projection\-Normal is oblique. For the X, Y, and Z axes projection normals, the normal is the axis direction, and the origin is (0,0,0).  
\item {\ttfamily double = obj.\-Get\-Projection\-Position ()} -\/ The position of the bounding plane from the origin along the normal. The origin and normal are defined in the oblique plane when the Projection\-Normal is oblique. For the X, Y, and Z axes projection normals, the normal is the axis direction, and the origin is (0,0,0).  
\item {\ttfamily obj.\-Add\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-All\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Plane\-Collection )} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-Get\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Planes planes)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position, compute the world position and world orientation for this point. A plane is defined by a combination of the Projection\-Normal, Projection\-Origin, and Oblique\-Plane ivars. The display position is projected onto this plane to determine a world position, and the orientation is set to the normal of the plane. If the point cannot project onto the plane or if it falls outside the bounds imposed by the Bounding\-Planes, then 0 is returned, otherwise 1 is returned to indicate a valid return position and orientation.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute the new world position and orientation of this point. This method is typically used by the representation to move the point.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Give a world position check if it is valid -\/ does it lie on the plane and within the bounds? Returns 1 if it is valid, 0 otherwise.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})}  
\item {\ttfamily int = obj.\-Update\-World\-Position (vtk\-Renderer ren, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ If the constraints on this placer are changed, then this method will be called by the representation on each of its points. For this placer, the world position will be converted to a display position, then Compute\-World\-Position will be used to update the point.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkboxrepresentation}{}\section{vtk\-Box\-Representation}\label{vtkwidgets_vtkboxrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a concrete representation for the vtk\-Box\-Widget2. It represents a box with seven handles\-: one on each of the six faces, plus a center handle. Through interaction with the widget, the box representation can be arbitrarily positioned in the 3\-D space.

To use this representation, you normally use the Place\-Widget() method to position the widget at a specified region in space.

To create an instance of class vtk\-Box\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoxRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Box\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Box\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Get\-Planes (vtk\-Planes planes)} -\/ Get the planes describing the implicit function defined by the box widget. The user must provide the instance of the class vtk\-Planes. Note that vtk\-Planes is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data. (The direction of the normals of the planes can be reversed enabling the Inside\-Out flag.)  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. This data memeber is used in conjunction with the Get\-Planes() method. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. This data memeber is used in conjunction with the Get\-Planes() method. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. This data memeber is used in conjunction with the Get\-Planes() method. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. This data memeber is used in conjunction with the Get\-Planes() method. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Get\-Transform (vtk\-Transform t)} -\/ Retrieve a linear transform characterizing the transformation of the box. Note that the transformation is relative to where Place\-Widget() was initially called. This method modifies the transform provided. The transform can be used to control the position of vtk\-Prop3\-D's, as well as other transformation operations (e.\-g., vtk\-Tranform\-Poly\-Data).  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform t)} -\/ Set the position, scale and orientation of the box widget using the transform specified. Note that the transformation is relative to where Place\-Widget() was initially called (i.\-e., the original bounding box).  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that define the box widget. The polydata consists of 6 quadrilateral faces and 15 points. The first eight points define the eight corner vertices; the next six define the -\/x,+x, -\/y,+y, -\/z,+z face points; and the final point (the 15th out of 15 points) defines the center of the box. These point values are guaranteed to be up-\/to-\/date when either the widget's corresponding Interaction\-Event or End\-Interaction\-Event events are invoked. The user provides the vtk\-Poly\-Data and the points and cells are added to it.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles, when selected or normal, can be specified.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles, when selected or normal, can be specified.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Face\-Property ()} -\/ Get the face properties (the faces of the box). The properties of the face when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Face\-Property ()} -\/ Get the face properties (the faces of the box). The properties of the face when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Outline\-Property ()} -\/ Get the outline properties (the outline of the box). The properties of the outline when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Outline\-Property ()} -\/ Get the outline properties (the outline of the box). The properties of the outline when selected and normal can be set.  
\item {\ttfamily obj.\-Set\-Outline\-Face\-Wires (int )} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily int = obj.\-Get\-Outline\-Face\-Wires ()} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily obj.\-Outline\-Face\-Wires\-On ()} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily obj.\-Outline\-Face\-Wires\-Off ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Set\-Outline\-Cursor\-Wires (int )} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily int = obj.\-Get\-Outline\-Cursor\-Wires ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Outline\-Cursor\-Wires\-On ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Outline\-Cursor\-Wires\-Off ()} -\/ Switches handles (the spheres) on or off by manipulating the underlying actor visibility.  
\item {\ttfamily obj.\-Handles\-On ()} -\/ Switches handles (the spheres) on or off by manipulating the underlying actor visibility.  
\item {\ttfamily obj.\-Handles\-Off ()} -\/ Switches handles (the spheres) on or off by manipulating the underlying actor visibility.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily obj.\-Set\-Interaction\-State (int state)} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Box\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkboxwidget}{}\section{vtk\-Box\-Widget}\label{vtkwidgets_vtkboxwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a region of interest that is represented by an arbitrarily oriented hexahedron with interior face angles of 90 degrees (orthogonal faces). The object creates 7 handles that can be moused on and manipulated. The first six correspond to the six faces, the seventh is in the center of the hexahedron. In addition, a bounding box outline is shown, the \char`\"{}faces\char`\"{} of which can be selected for object rotation or scaling. A nice feature of the object is that the vtk\-Box\-Widget, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Box\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Box\-Widget will terminate the processing of the event that it handles.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. The interactor will act normally until the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, at which point the vtk\-Box\-Widget will appear. (See superclass documentation for information about changing this behavior.) By grabbing the six face handles (use the left mouse button), faces can be moved. By grabbing the center handle (with the left mouse button), the entire hexahedron can be translated. (Translation can also be employed by using the \char`\"{}shift-\/left-\/mouse-\/button\char`\"{} combination inside of the widget.) Scaling is achieved by using the right mouse button \char`\"{}up\char`\"{} the render window (makes the widget bigger) or \char`\"{}down\char`\"{} the render window (makes the widget smaller). To rotate vtk\-Box\-Widget, pick a face (but not a face handle) and move the left mouse. (Note\-: the mouse button must be held down during manipulation.) Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again. (See the superclass documentation on key press activiation.)

The vtk\-Box\-Widget is very flexible. It can be used to select, cut, clip, or perform any other operation that depends on an implicit function (use the Get\-Planes() method); or it can be used to transform objects using a linear transformation (use the Get\-Transform() method). Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button).

Some additional features of this class include the ability to control the rendered properties of the widget. You can set the properties of the selected and unselected representations of the parts of the widget. For example, you can set the property for the handles, faces, and outline in their normal and selected states.

To create an instance of class vtk\-Box\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoxWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Box\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Box\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Get the planes describing the implicit function defined by the box widget. The user must provide the instance of the class vtk\-Planes. Note that vtk\-Planes is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data. (The direction of the normals of the planes can be reversed enabling the Inside\-Out flag.)  
\item {\ttfamily obj.\-Get\-Planes (vtk\-Planes planes)} -\/ Get the planes describing the implicit function defined by the box widget. The user must provide the instance of the class vtk\-Planes. Note that vtk\-Planes is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data. (The direction of the normals of the planes can be reversed enabling the Inside\-Out flag.)  
\item {\ttfamily obj.\-Set\-Inside\-Out (int )} -\/ Set/\-Get the Inside\-Out flag. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily int = obj.\-Get\-Inside\-Out ()} -\/ Set/\-Get the Inside\-Out flag. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-On ()} -\/ Set/\-Get the Inside\-Out flag. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Inside\-Out\-Off ()} -\/ Set/\-Get the Inside\-Out flag. When off, the normals point out of the box. When on, the normals point into the hexahedron. Inside\-Out is off by default.  
\item {\ttfamily obj.\-Get\-Transform (vtk\-Transform t)} -\/ Retrieve a linear transform characterizing the transformation of the box. Note that the transformation is relative to where Place\-Widget was initially called. This method modifies the transform provided. The transform can be used to control the position of vtk\-Prop3\-D's, as well as other transformation operations (e.\-g., vtk\-Tranform\-Poly\-Data).  
\item {\ttfamily obj.\-Set\-Transform (vtk\-Transform t)} -\/ Set the position, scale and orientation of the box widget using the transform specified. Note that the transformation is relative to where Place\-Widget was initially called (i.\-e., the original bounding box).  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that define the box widget. The polydata consists of 6 quadrilateral faces and 15 points. The first eight points define the eight corner vertices; the next six define the -\/x,+x, -\/y,+y, -\/z,+z face points; and the final point (the 15th out of 15 points) defines the center of the hexahedron. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction\-Event events are invoked. The user provides the vtk\-Poly\-Data and the points and cells are added to it.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be set.  
\item {\ttfamily obj.\-Handles\-On ()} -\/ Switches handles (the spheres) on or off by manipulating the actor visibility.  
\item {\ttfamily obj.\-Handles\-Off ()} -\/ Switches handles (the spheres) on or off by manipulating the actor visibility.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Face\-Property ()} -\/ Get the face properties (the faces of the box). The properties of the face when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Face\-Property ()} -\/ Get the face properties (the faces of the box). The properties of the face when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Outline\-Property ()} -\/ Get the outline properties (the outline of the box). The properties of the outline when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Outline\-Property ()} -\/ Get the outline properties (the outline of the box). The properties of the outline when selected and normal can be set.  
\item {\ttfamily obj.\-Set\-Outline\-Face\-Wires (int )} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily int = obj.\-Get\-Outline\-Face\-Wires ()} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily obj.\-Outline\-Face\-Wires\-On ()} -\/ Control the representation of the outline. This flag enables face wires. By default face wires are off.  
\item {\ttfamily obj.\-Outline\-Face\-Wires\-Off ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Set\-Outline\-Cursor\-Wires (int )} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily int = obj.\-Get\-Outline\-Cursor\-Wires ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Outline\-Cursor\-Wires\-On ()} -\/ Control the representation of the outline. This flag enables the cursor lines running between the handles. By default cursor wires are on.  
\item {\ttfamily obj.\-Outline\-Cursor\-Wires\-Off ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Translation\-Enabled (int )} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Translation\-Enabled ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-On ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-Off ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Scaling\-Enabled (int )} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Scaling\-Enabled ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-On ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-Off ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Rotation\-Enabled (int )} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Rotation\-Enabled ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Rotation\-Enabled\-On ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Rotation\-Enabled\-Off ()} -\/ Control the behavior of the widget. Translation, rotation, and scaling can all be enabled and disabled.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkboxwidget2}{}\section{vtk\-Box\-Widget2}\label{vtkwidgets_vtkboxwidget2}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget interacts with a vtk\-Box\-Representation class (i.\-e., it handles the events that drive its corresponding representation). The representation is assumed to represent a region of interest that is represented by an arbitrarily oriented hexahedron (or box) with interior face angles of 90 degrees (i.\-e., orthogonal faces). The representation manifests seven handles that can be moused on and manipulated, plus the six faces can also be interacted with. The first six handles are placed on the six faces, the seventh is in the center of the box. In addition, a bounding box outline is shown, the \char`\"{}faces\char`\"{} of which can be selected for object rotation or scaling. A nice feature of vtk\-Box\-Widget2, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Box\-Widget2 does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Box\-Widget will terminate the processing of the event that it handles.

To use this widget, you generally pair it with a vtk\-Box\-Representation (or a subclass). Variuos options are available in the representation for controlling how the widget appears, and how the widget functions.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If one of the seven handles are selected:
   LeftButtonPressEvent - select the appropriate handle 
   LeftButtonReleaseEvent - release the currently selected handle 
   MouseMoveEvent - move the handle
 If one of the faces is selected:
   LeftButtonPressEvent - select a box face
   LeftButtonReleaseEvent - release the box face
   MouseMoveEvent - rotate the box
 In all the cases, independent of what is picked, the widget responds to the 
 following VTK events:
   MiddleButtonPressEvent - translate the widget
   MiddleButtonReleaseEvent - release the widget
   RightButtonPressEvent - scale the widget's representation
   RightButtonReleaseEvent - stop scaling the widget
   MouseMoveEvent - scale (if right button) or move (if middle button) the widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Box\-Widget2's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Scale -- some part of the widget has been selected
   vtkWidgetEvent::EndScale -- the selection process has completed
   vtkWidgetEvent::Translate -- some part of the widget has been selected
   vtkWidgetEvent::EndTranslate -- the selection process has completed
   vtkWidgetEvent::Move -- a request for motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Box\-Widget2 invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Box\-Widget2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkBoxWidget2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Box\-Widget2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Box\-Widget2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard class methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard class methods for type information and printing.  
\item {\ttfamily vtk\-Box\-Widget2 = obj.\-New\-Instance ()} -\/ Standard class methods for type information and printing.  
\item {\ttfamily vtk\-Box\-Widget2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard class methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Box\-Representation r)} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Translation\-Enabled (int )} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Translation\-Enabled ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-On ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-Off ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Scaling\-Enabled (int )} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Scaling\-Enabled ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-On ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-Off ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Rotation\-Enabled (int )} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Rotation\-Enabled ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Rotation\-Enabled\-On ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Rotation\-Enabled\-Off ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, rotation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set. By default, this is an instance of the vtk\-Box\-Representation class.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcamerarepresentation}{}\section{vtk\-Camera\-Representation}\label{vtkwidgets_vtkcamerarepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively saving a series of camera views into an interpolated path (using vtk\-Camera\-Interpolator). The class typically works in conjunction with vtk\-Camera\-Widget. To use this class simply specify the camera to interpolate and use the methods Add\-Camera\-To\-Path(), Animate\-Path(), and Initialize\-Path() to add a new camera view, animate the current views, and initialize the interpolation.

To create an instance of class vtk\-Camera\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCameraRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Camera\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Camera\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Camera (vtk\-Camera camera)} -\/ Specify the camera to interpolate. This must be specified by the user.  
\item {\ttfamily vtk\-Camera = obj.\-Get\-Camera ()} -\/ Specify the camera to interpolate. This must be specified by the user.  
\item {\ttfamily obj.\-Set\-Interpolator (vtk\-Camera\-Interpolator cam\-Int)} -\/ Get the vtk\-Camera\-Interpolator used to interpolate and save the sequence of camera views. If not defined, one is created automatically. Note that you can access this object to set the interpolation type (linear, spline) and other instance variables.  
\item {\ttfamily vtk\-Camera\-Interpolator = obj.\-Get\-Interpolator ()} -\/ Get the vtk\-Camera\-Interpolator used to interpolate and save the sequence of camera views. If not defined, one is created automatically. Note that you can access this object to set the interpolation type (linear, spline) and other instance variables.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Frames (int )} -\/ Set the number of frames to generate when playback is initiated.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Frames\-Min\-Value ()} -\/ Set the number of frames to generate when playback is initiated.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Frames\-Max\-Value ()} -\/ Set the number of frames to generate when playback is initiated.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Frames ()} -\/ Set the number of frames to generate when playback is initiated.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ By obtaining this property you can specify the properties of the representation.  
\item {\ttfamily obj.\-Add\-Camera\-To\-Path ()} -\/ These methods are used to create interpolated camera paths. The Add\-Camera\-To\-Path() method adds the view defined by the current camera (via Set\-Camera()) to the interpolated camera path. Animate\-Path() interpolates Number\-Of\-Frames along the current path. Initialize\-Path() resets the interpolated path to its initial, empty configuration.  
\item {\ttfamily obj.\-Animate\-Path (vtk\-Render\-Window\-Interactor rwi)} -\/ These methods are used to create interpolated camera paths. The Add\-Camera\-To\-Path() method adds the view defined by the current camera (via Set\-Camera()) to the interpolated camera path. Animate\-Path() interpolates Number\-Of\-Frames along the current path. Initialize\-Path() resets the interpolated path to its initial, empty configuration.  
\item {\ttfamily obj.\-Initialize\-Path ()} -\/ These methods are used to create interpolated camera paths. The Add\-Camera\-To\-Path() method adds the view defined by the current camera (via Set\-Camera()) to the interpolated camera path. Animate\-Path() interpolates Number\-Of\-Frames along the current path. Initialize\-Path() resets the interpolated path to its initial, empty configuration.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclasses' A\-P\-I.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcamerawidget}{}\section{vtk\-Camera\-Widget}\label{vtkwidgets_vtkcamerawidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively saving a series of camera views into an interpolated path (using vtk\-Camera\-Interpolator). To use the class start by specifying a camera to interpolate, and then simply start recording by hitting the \char`\"{}record\char`\"{} button, manipulate the camera (by using an interactor, direct scripting, or any other means), and then save the camera view. Repeat this process to record a series of views. The user can then play back interpolated camera views using the vtk\-Camera\-Interpolator.

To create an instance of class vtk\-Camera\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCameraWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Camera\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Camera\-Widget = obj.\-New\-Instance ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Camera\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Camera\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcaptionrepresentation}{}\section{vtk\-Caption\-Representation}\label{vtkwidgets_vtkcaptionrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class represents vtk\-Caption\-Widget. A caption is defined by some text with a leader (e.\-g., arrow) that points from the text to a point in the scene. The caption is defined by an instance of vtk\-Caption\-Actor2\-D. It uses the event bindings of its superclass (vtk\-Border\-Widget) to control the placement of the text, and adds the ability to move the attachment point around. In addition, when the caption text is selected, the widget emits a Activate\-Event that observers can watch for. This is useful for opening G\-U\-I dialogoues to adjust font characteristics, etc. (Please see the superclass for a description of event bindings.)

Note that this widget extends the behavior of its superclass vtk\-Border\-Representation.

To create an instance of class vtk\-Caption\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCaptionRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Caption\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Caption\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Caption\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Caption\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Anchor\-Position (double pos\mbox{[}3\mbox{]})} -\/ Specify the position of the anchor (i.\-e., the point that the caption is anchored to). Note that the position should be specified in world coordinates.  
\item {\ttfamily obj.\-Get\-Anchor\-Position (double pos\mbox{[}3\mbox{]})} -\/ Specify the position of the anchor (i.\-e., the point that the caption is anchored to). Note that the position should be specified in world coordinates.  
\item {\ttfamily obj.\-Set\-Caption\-Actor2\-D (vtk\-Caption\-Actor2\-D caption\-Actor)} -\/ Specify the vtk\-Caption\-Actor2\-D to manage. If not specified, then one is automatically created.  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Get\-Caption\-Actor2\-D ()} -\/ Specify the vtk\-Caption\-Actor2\-D to manage. If not specified, then one is automatically created.  
\item {\ttfamily obj.\-Set\-Anchor\-Representation (vtk\-Point\-Handle\-Representation3\-D )} -\/ Set and get the instances of vtk\-Point\-Handle\-Represention3\-D used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-Get\-Anchor\-Representation ()} -\/ Set and get the instances of vtk\-Point\-Handle\-Represention3\-D used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclasses A\-P\-I.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Set\-Font\-Factor (double )} -\/ Set/\-Get the factor that controls the overall size of the fonts of the caption when the text actor's Scaled\-Text is O\-F\-F  
\item {\ttfamily double = obj.\-Get\-Font\-Factor\-Min\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts of the caption when the text actor's Scaled\-Text is O\-F\-F  
\item {\ttfamily double = obj.\-Get\-Font\-Factor\-Max\-Value ()} -\/ Set/\-Get the factor that controls the overall size of the fonts of the caption when the text actor's Scaled\-Text is O\-F\-F  
\item {\ttfamily double = obj.\-Get\-Font\-Factor ()} -\/ Set/\-Get the factor that controls the overall size of the fonts of the caption when the text actor's Scaled\-Text is O\-F\-F  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcaptionwidget}{}\section{vtk\-Caption\-Widget}\label{vtkwidgets_vtkcaptionwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively placing a caption on the 2\-D overlay plane. A caption is defined by some text with a leader (e.\-g., arrow) that points from the text to a point in the scene. The caption is represented by a vtk\-Caption\-Representation. It uses the event bindings of its superclass (vtk\-Border\-Widget) to control the placement of the text, and adds the ability to move the attachment point around. In addition, when the caption text is selected, the widget emits a Activate\-Event that observers can watch for. This is useful for opening G\-U\-I dialogoues to adjust font characteristics, etc. (Please see the superclass for a description of event bindings.)

Note that this widget extends the behavior of its superclass vtk\-Border\-Widget. The end point of the leader can be selected and moved around with an internal vtk\-Handle\-Widget.

To create an instance of class vtk\-Caption\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCaptionWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Caption\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Caption\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Caption\-Widget = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Caption\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Enabled (int enabling)} -\/ Override superclasses' Set\-Enabled() method because the caption leader has its own dedicated widget.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Caption\-Representation r)} -\/ Specify a vtk\-Caption\-Actor2\-D to manage. This is convenient, alternative method to Set\-Representation(). It internally create a vtk\-Caption\-Representation and then invokes vtk\-Caption\-Representation\-::\-Set\-Caption\-Actor2\-D().  
\item {\ttfamily obj.\-Set\-Caption\-Actor2\-D (vtk\-Caption\-Actor2\-D cap\-Actor)} -\/ Specify a vtk\-Caption\-Actor2\-D to manage. This is convenient, alternative method to Set\-Representation(). It internally create a vtk\-Caption\-Representation and then invokes vtk\-Caption\-Representation\-::\-Set\-Caption\-Actor2\-D().  
\item {\ttfamily vtk\-Caption\-Actor2\-D = obj.\-Get\-Caption\-Actor2\-D ()} -\/ Specify a vtk\-Caption\-Actor2\-D to manage. This is convenient, alternative method to Set\-Representation(). It internally create a vtk\-Caption\-Representation and then invokes vtk\-Caption\-Representation\-::\-Set\-Caption\-Actor2\-D().  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcenteredsliderrepresentation}{}\section{vtk\-Centered\-Slider\-Representation}\label{vtkwidgets_vtkcenteredsliderrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent and render a vtk\-Centered\-Slider\-Widget. To use this class, you must at a minimum specify the end points of the slider. Optional instance variable can be used to modify the appearance of the widget.

To create an instance of class vtk\-Centered\-Slider\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCenteredSliderRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Centered\-Slider\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Centered\-Slider\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Centered\-Slider\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Centered\-Slider\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point1\-Coordinate ()} -\/ Position the first end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point1\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point2\-Coordinate ()} -\/ Position the second end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point2\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily obj.\-Set\-Title\-Text (string )} -\/ Specify the label text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the label text is not displayed.  
\item {\ttfamily string = obj.\-Get\-Title\-Text ()} -\/ Specify the label text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the label text is not displayed.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Tube\-Property ()} -\/ Get the properties for the tube and slider  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Slider\-Property ()} -\/ Get the properties for the tube and slider  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Selected\-Property ()} -\/ Get the selection property. This property is used to modify the appearance of selected objects (e.\-g., the slider).  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Property ()} -\/ Set/\-Get the properties for the label and title text.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Highlight (int )} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcenteredsliderwidget}{}\section{vtk\-Centered\-Slider\-Widget}\label{vtkwidgets_vtkcenteredsliderwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Centered\-Slider\-Widget is used to adjust a scalar value in an application. This class measures deviations form the center point on the slider. Moving the slider modifies the value of the widget, which can be used to set parameters on other objects. Note that the actual appearance of the widget depends on the specific representation for the widget.

To use this widget, set the widget representation. The representation is assumed to consist of a tube, two end caps, and a slider (the details may vary depending on the particulars of the representation). Then in the representation you will typically set minimum and maximum value, as well as the current value. The position of the slider must also be set, as well as various properties.

Note that the value should be obtain from the widget, not from the representation. Also note that Minimum and Maximum values are in terms of value per second. The value you get from this widget's Get\-Value method is multiplied by time.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If the slider bead is selected:
   LeftButtonPressEvent - select slider (if on slider)
   LeftButtonReleaseEvent - release slider (if selected)
   MouseMoveEvent - move slider
 If the end caps or slider tube are selected:
   LeftButtonPressEvent - move (or animate) to cap or point on tube;
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Centered\-Slider\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for slider motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Centered\-Slider\-Widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Centered\-Slider\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCenteredSliderWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Centered\-Slider\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Centered\-Slider\-Widget 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\-Centered\-Slider\-Widget = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Centered\-Slider\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Slider\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Get the value fo this widget.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcheckerboardrepresentation}{}\section{vtk\-Checkerboard\-Representation}\label{vtkwidgets_vtkcheckerboardrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Checkerboard\-Representation is used to implement the representation of the vtk\-Checkerboard\-Widget. The user can adjust the number of divisions in each of the i-\/j directions in a 2\-D image. A frame appears around the vtk\-Image\-Actor with sliders along each side of the frame. The user can interactively adjust the sliders to the desired number of checkerboard subdivisions. The representation uses four instances of vtk\-Slider\-Representation3\-D to implement itself.

To create an instance of class vtk\-Checkerboard\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCheckerboardRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Checkerboard\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Checkerboard\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Checkerboard\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Checkerboard\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Checkerboard (vtk\-Image\-Checkerboard chkrbrd)} -\/ Specify an instance of vtk\-Image\-Checkerboard to manipulate.  
\item {\ttfamily vtk\-Image\-Checkerboard = obj.\-Get\-Checkerboard ()} -\/ Specify an instance of vtk\-Image\-Checkerboard to manipulate.  
\item {\ttfamily obj.\-Set\-Image\-Actor (vtk\-Image\-Actor image\-Actor)} -\/ Specify an instance of vtk\-Image\-Actor to decorate.  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Get\-Image\-Actor ()} -\/ Specify an instance of vtk\-Image\-Actor to decorate.  
\item {\ttfamily obj.\-Set\-Corner\-Offset (double )} -\/ Specify the offset of the ends of the sliders (on the boundary edges of the image) from the corner of the image. The offset is expressed as a normalized fraction of the border edges.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset\-Min\-Value ()} -\/ Specify the offset of the ends of the sliders (on the boundary edges of the image) from the corner of the image. The offset is expressed as a normalized fraction of the border edges.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset\-Max\-Value ()} -\/ Specify the offset of the ends of the sliders (on the boundary edges of the image) from the corner of the image. The offset is expressed as a normalized fraction of the border edges.  
\item {\ttfamily double = obj.\-Get\-Corner\-Offset ()} -\/ Specify the offset of the ends of the sliders (on the boundary edges of the image) from the corner of the image. The offset is expressed as a normalized fraction of the border edges.  
\item {\ttfamily obj.\-Slider\-Value\-Changed (int slider\-Num)} -\/ This method is invoked by the vtk\-Checkerboard\-Widget() when a value of some slider has changed.  
\item {\ttfamily obj.\-Set\-Top\-Representation (vtk\-Slider\-Representation3\-D )} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily obj.\-Set\-Right\-Representation (vtk\-Slider\-Representation3\-D )} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily obj.\-Set\-Bottom\-Representation (vtk\-Slider\-Representation3\-D )} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily obj.\-Set\-Left\-Representation (vtk\-Slider\-Representation3\-D )} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-Get\-Top\-Representation ()} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-Get\-Right\-Representation ()} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-Get\-Bottom\-Representation ()} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-Get\-Left\-Representation ()} -\/ Set and get the instances of vtk\-Slider\-Represention used to implement this representation. Normally default representations are created, but you can specify the ones you want to use.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods required by superclass.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods required by superclass.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by superclass.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by superclass.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by superclass.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods required by superclass.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcheckerboardwidget}{}\section{vtk\-Checkerboard\-Widget}\label{vtkwidgets_vtkcheckerboardwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Checkerboard\-Widget is used to interactively control an instance of vtk\-Image\-Checkerboard (and an associated vtk\-Image\-Actor used to display the checkerboard). The user can adjust the number of divisions in each of the i-\/j directions in a 2\-D image. A frame appears around the vtk\-Image\-Actor with sliders along each side of the frame. The user can interactively adjust the sliders to the desired number of checkerboard subdivisions.

To use this widget, specify an instance of vtk\-Image\-Checkerboard and an instance of vtk\-Image\-Actor. By default, the widget responds to the following events\-: 
\begin{DoxyPre}
 If the slider bead is selected:
   LeftButtonPressEvent - select slider (if on slider)
   LeftButtonReleaseEvent - release slider 
   MouseMoveEvent - move slider
 If the end caps or slider tube of a slider are selected:
   LeftButtonPressEvent - jump (or animate) to cap or point on tube;
 \end{DoxyPre}
 It is possible to change these event bindings. Please refer to the documentation for vtk\-Slider\-Widget for more information. Advanced users may directly access and manipulate the sliders by obtaining the instances of vtk\-Slider\-Widget composing the vtk\-Checkerboard widget.

To create an instance of class vtk\-Checkerboard\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkCheckerboardWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Checkerboard\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Checkerboard\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Checkerboard\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Checkerboard\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Checkerboard\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkclosedsurfacepointplacer}{}\section{vtk\-Closed\-Surface\-Point\-Placer}\label{vtkwidgets_vtkclosedsurfacepointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This placer takes a set of boudning planes and constraints the validity within the supplied convex planes. It is used by the Parallelop\-Piped\-Representation to place constraints on the motion the handles within the parallelopiped.

To create an instance of class vtk\-Closed\-Surface\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkClosedSurfacePointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Closed\-Surface\-Point\-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\-Closed\-Surface\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Closed\-Surface\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Closed\-Surface\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Add\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-All\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Plane\-Collection )} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-Get\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Planes planes)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position, compute the world position and world orientation for this point. A plane is defined by a combination of the Projection\-Normal, Projection\-Origin, and Oblique\-Plane ivars. The display position is projected onto this plane to determine a world position, and the orientation is set to the normal of the plane. If the point cannot project onto the plane or if it falls outside the bounds imposed by the Bounding\-Planes, then 0 is returned, otherwise 1 is returned to indicate a valid return position and orientation.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position and a reference position, \char`\"{}world\-Pos\char`\"{} is calculated as \-: Consider the line \char`\"{}\-L\char`\"{} that passes through the supplied \char`\"{}display\-Pos\char`\"{} and is parallel to the direction of projection of the camera. Clip this line segment with the parallelopiped, let's call it \char`\"{}\-L\-\_\-segment\char`\"{}. The computed world position, \char`\"{}world\-Pos\char`\"{} will be the point on \char`\"{}\-L\-\_\-segment\char`\"{} that is closest to ref\-World\-Pos. N\-O\-T\-E\-: Note that a set of bounding planes must be supplied. The Oblique plane, if supplied is ignored.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Give a world position check if it is valid -\/ does it lie on the plane and within the bounds? Returns 1 if it is valid, 0 otherwise.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})}  
\item {\ttfamily obj.\-Set\-Minimum\-Distance (double )}  
\item {\ttfamily double = obj.\-Get\-Minimum\-Distance\-Min\-Value ()}  
\item {\ttfamily double = obj.\-Get\-Minimum\-Distance\-Max\-Value ()}  
\item {\ttfamily double = obj.\-Get\-Minimum\-Distance ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkconstrainedpointhandlerepresentation}{}\section{vtk\-Constrained\-Point\-Handle\-Representation}\label{vtkwidgets_vtkconstrainedpointhandlerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent a vtk\-Handle\-Widget. It represents a position in 3\-D world coordinates that is constrained to a specified plane. The default look is to draw a white point when this widget is not selected or active, a thin green circle when it is highlighted, and a thicker cyan circle when it is active (being positioned). Defaults can be adjusted -\/ but take care to define cursor geometry that makes sense for this widget. The geometry will be aligned on the constraining plane, with the plane normal aligned with the X axis of the geometry (similar behavior to vtk\-Glyph3\-D).

T\-O\-D\-O\-: still need to work on 1) translation when mouse is outside bounding planes 2) size of the widget

To create an instance of class vtk\-Constrained\-Point\-Handle\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkConstrainedPointHandleRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Constrained\-Point\-Handle\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Constrained\-Point\-Handle\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Constrained\-Point\-Handle\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Constrained\-Point\-Handle\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Cursor\-Shape (vtk\-Poly\-Data cursor\-Shape)} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Cursor\-Shape ()} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily obj.\-Set\-Active\-Cursor\-Shape (vtk\-Poly\-Data active\-Shape)} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Active\-Cursor\-Shape ()} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily obj.\-Set\-Projection\-Normal (int )} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Min\-Value ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Max\-Value ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal ()} -\/ Set the projection normal to lie along the x, y, or z axis, or to be oblique. If it is oblique, then the plane is defined in the Oblique\-Plane ivar.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-X\-Axis ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Y\-Axis ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Z\-Axis ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Oblique ()} -\/ If the Projection\-Normal is set to Oblique, then this is the oblique plane used to constrain the handle position  
\item {\ttfamily obj.\-Set\-Oblique\-Plane (vtk\-Plane )} -\/ If the Projection\-Normal is set to Oblique, then this is the oblique plane used to constrain the handle position  
\item {\ttfamily vtk\-Plane = obj.\-Get\-Oblique\-Plane ()} -\/ If the Projection\-Normal is set to Oblique, then this is the oblique plane used to constrain the handle position  
\item {\ttfamily obj.\-Set\-Projection\-Position (double position)} -\/ The position of the bounding plane from the origin along the normal. The origin and normal are defined in the oblique plane when the Projection\-Normal is Oblique. For the X, Y, and Z axes projection normals, the normal is the axis direction, and the origin is (0,0,0).  
\item {\ttfamily double = obj.\-Get\-Projection\-Position ()} -\/ The position of the bounding plane from the origin along the normal. The origin and normal are defined in the oblique plane when the Projection\-Normal is Oblique. For the X, Y, and Z axes projection normals, the normal is the axis direction, and the origin is (0,0,0).  
\item {\ttfamily obj.\-Add\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-Bounding\-Plane (vtk\-Plane plane)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Remove\-All\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Plane\-Collection )} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily vtk\-Plane\-Collection = obj.\-Get\-Bounding\-Planes ()} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily obj.\-Set\-Bounding\-Planes (vtk\-Planes planes)} -\/ A collection of plane equations used to bound the position of the point. This is in addition to confining the point to a plane -\/ these contraints are meant to, for example, keep a point within the extent of an image. Using a set of plane equations allows for more complex bounds (such as bounding a point to an oblique reliced image that has hexagonal shape) than a simple extent.  
\item {\ttfamily int = obj.\-Check\-Constraint (vtk\-Renderer renderer, double pos\mbox{[}2\mbox{]})} -\/ Overridden from the base class. It converts the display co-\/ordinates to world co-\/ordinates. It returns 1 if the point lies within the constrained region, otherwise return 0  
\item {\ttfamily obj.\-Set\-Position (double x, double y, double z)} -\/ Set/\-Get the position of the point in display coordinates. These are convenience methods that extend the superclasses' Get\-Handle\-Position() method. Note that only the x-\/y coordinate values are used  
\item {\ttfamily obj.\-Set\-Position (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point in display coordinates. These are convenience methods that extend the superclasses' Get\-Handle\-Position() method. Note that only the x-\/y coordinate values are used  
\item {\ttfamily obj.\-Get\-Position (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point in display coordinates. These are convenience methods that extend the superclasses' Get\-Handle\-Position() method. Note that only the x-\/y coordinate values are used  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ This is the property used when the handle is not active (the mouse is not near the handle)  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ This is the property used when the mouse is near the handle (but the user is not yet interacting with it)  
\item {\ttfamily vtk\-Property = obj.\-Get\-Active\-Property ()} -\/ This is the property used when the user is interacting with the handle.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Subclasses of vtk\-Constrained\-Point\-Handle\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Constrained\-Point\-Handle\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Constrained\-Point\-Handle\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Constrained\-Point\-Handle\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Subclasses of vtk\-Constrained\-Point\-Handle\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Set\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Method overridden from Superclass. computes the world co-\/ordinates using Get\-Intersection\-Position()  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcontinuousvaluewidget}{}\section{vtk\-Continuous\-Value\-Widget}\label{vtkwidgets_vtkcontinuousvaluewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Continuous\-Value\-Widget is used to adjust a scalar value in an application. Note that the actual appearance of the widget depends on the specific representation for the widget.

To use this widget, set the widget representation. (the details may vary depending on the particulars of the representation).

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If the slider bead is selected:
   LeftButtonPressEvent - select slider 
   LeftButtonReleaseEvent - release slider 
   MouseMoveEvent - move slider
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Continuous\-Value\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for slider motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Continuous\-Value\-Widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Continuous\-Value\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContinuousValueWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Continuous\-Value\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Continuous\-Value\-Widget 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\-Continuous\-Value\-Widget = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Continuous\-Value\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Continuous\-Value\-Widget\-Representation r)} -\/ Get the value for this widget.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Get the value for this widget.  
\item {\ttfamily obj.\-Set\-Value (double v)} -\/ Get the value for this widget.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcontinuousvaluewidgetrepresentation}{}\section{vtk\-Continuous\-Value\-Widget\-Representation}\label{vtkwidgets_vtkcontinuousvaluewidgetrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used mainly as a superclass for continuous value widgets

To create an instance of class vtk\-Continuous\-Value\-Widget\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContinuousValueWidgetRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Continuous\-Value\-Widget\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Continuous\-Value\-Widget\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Continuous\-Value\-Widget\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Continuous\-Value\-Widget\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Set\-Value (double value)}  
\item {\ttfamily double = obj.\-Get\-Value ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcontourlineinterpolator}{}\section{vtk\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkcontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Contour\-Line\-Interpolator is an abstract base class for interpolators that work are used by the contour representation class to interpolate and/or modify nodes in a contour. Subclasses must override the virtual method\-: {\ttfamily Interpolate\-Line}. This is used by the contour representation to give the interpolator a chance to define an interpolation scheme between nodes. See vtk\-Bezier\-Contour\-Line\-Interpolator for a concrete implementation. Subclasses may also override, {\ttfamily Update\-Node}. This provides a way for the representation to give the interpolator a chance to modify the nodes, as the user constructs the contours. For instance a sticky contour widget may be implemented that moves nodes to nearby regions of high gradient, to be used in contour guided segmentation.

To create an instance of class vtk\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Line\-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\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)} -\/ Subclasses that wish to interpolate a line segment must implement this. For instance vtk\-Bezier\-Contour\-Line\-Interpolator adds nodes between idx1 and idx2, that allow the contour to adhere to a bezier curve.  
\item {\ttfamily int = obj.\-Update\-Node (vtk\-Renderer , vtk\-Contour\-Representation , double , int )} -\/ The interpolator is given a chance to update the node. For instance, the vtk\-Image\-Contour\-Line\-Interpolator updates the idx'th node in the contour, so it automatically sticks to edges in the vicinity as the user constructs the contour. Returns 0 if the node (world position) is unchanged.  
\item {\ttfamily obj.\-Get\-Span (int node\-Index, vtk\-Int\-Array node\-Indices, vtk\-Contour\-Representation rep)} -\/ Span of the interpolator. ie. the number of control points its supposed to interpolate given a node.

The first argument is the current node\-Index. ie, you'd be trying to interpolate between nodes \char`\"{}node\-Index\char`\"{} and \char`\"{}node\-Index-\/1\char`\"{}, unless you're closing the contour in which case, you're trying to interpolate \char`\"{}node\-Index\char`\"{} and \char`\"{}\-Node=0\char`\"{}.

The node span is returned in a vtk\-Int\-Array. The default node span is 1 (ie. node\-Indices is a 2 tuple (node\-Index, node\-Index-\/1)). However, it need not always be 1. For instance, cubic spline interpolators, which have a span of 3 control points, it can be larger. See vtk\-Bezier\-Contour\-Line\-Interpolator for instance.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcontourrepresentation}{}\section{vtk\-Contour\-Representation}\label{vtkwidgets_vtkcontourrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Contour\-Representation is a superclass for various types of representations for the vtk\-Contour\-Widget.

.S\-E\-C\-T\-I\-O\-N Managing contour points The classes vtk\-Contour\-Representation\-Node, vtk\-Contour\-Representation\-Internals, vtk\-Contour\-Representation\-Point manage the data structure used to represent nodes and points on a contour. A contour may contain several nodes and several more points. Nodes are usually the result of user clicked points on the contour. Additional points are created between nodes to generate a smooth curve using some Interpolator. See the method {\ttfamily Set\-Line\-Interpolator}. \begin{DoxyParagraph}{}
The data structure stores both the world and display positions for every point. (This may seem like a duplication.) The default behaviour of this class is to use the World\-Position to do all the math. Typically a point is added at a given display position. Its corresponding world position is computed using the point placer and stored. Any query of the display position of a stored point is done via the Renderer, which computes the display position given a world position.
\end{DoxyParagraph}
\begin{DoxyParagraph}{}
So why maintain the display position ? Consider drawing a contour on a volume widget. You might want the contour to be located at a certain world position in the volume or you might want to be overlayed over the window like an Actor2\-D. The default behaviour of this class is to provide the former behaviour.
\end{DoxyParagraph}
\begin{DoxyParagraph}{}
To achieve the latter behaviour override the methods that return the display position (to return the set display position instead of computing it from the world positions) and the method {\ttfamily Build\-Lines()} to interpolate lines using their display positions intead of world positions.
\end{DoxyParagraph}
To create an instance of class vtk\-Contour\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Contour\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Contour\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Contour\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-World\-Position (double x, double y, double z)} -\/ Add a node at a specific world position. Returns 0 if the node could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Add a node at a specific world position. Returns 0 if the node could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Add a node at a specific world position. Returns 0 if the node could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-Display\-Position (double display\-Pos\mbox{[}2\mbox{]})} -\/ Add a node at a specific display position. This will be converted into a world position according to the current constraints of the point placer. Return 0 if a point could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-Display\-Position (int display\-Pos\mbox{[}2\mbox{]})} -\/ Add a node at a specific display position. This will be converted into a world position according to the current constraints of the point placer. Return 0 if a point could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Add\-Node\-At\-Display\-Position (int X, int Y)} -\/ Add a node at a specific display position. This will be converted into a world position according to the current constraints of the point placer. Return 0 if a point could not be added, 1 otherwise.  
\item {\ttfamily int = obj.\-Activate\-Node (double display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, activate a node. The closest node within tolerance will be activated. If a node is activated, 1 will be returned, otherwise 0 will be returned.  
\item {\ttfamily int = obj.\-Activate\-Node (int display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, activate a node. The closest node within tolerance will be activated. If a node is activated, 1 will be returned, otherwise 0 will be returned.  
\item {\ttfamily int = obj.\-Activate\-Node (int X, int Y)} -\/ Given a display position, activate a node. The closest node within tolerance will be activated. If a node is activated, 1 will be returned, otherwise 0 will be returned.  
\item {\ttfamily int = obj.\-Set\-Active\-Node\-To\-World\-Position (double pos\mbox{[}3\mbox{]})}  
\item {\ttfamily int = obj.\-Set\-Active\-Node\-To\-World\-Position (double pos\mbox{[}3\mbox{]}, double orient\mbox{[}9\mbox{]})}  
\item {\ttfamily int = obj.\-Set\-Active\-Node\-To\-Display\-Position (double pos\mbox{[}2\mbox{]})} -\/ Move the active node based on a specified display position. The display position will be converted into a world position. If the new position is not valid or there is no active node, a 0 will be returned. Otherwise, on success a 1 will be returned.  
\item {\ttfamily int = obj.\-Set\-Active\-Node\-To\-Display\-Position (int pos\mbox{[}2\mbox{]})} -\/ Move the active node based on a specified display position. The display position will be converted into a world position. If the new position is not valid or there is no active node, a 0 will be returned. Otherwise, on success a 1 will be returned.  
\item {\ttfamily int = obj.\-Set\-Active\-Node\-To\-Display\-Position (int X, int Y)} -\/ Move the active node based on a specified display position. The display position will be converted into a world position. If the new position is not valid or there is no active node, a 0 will be returned. Otherwise, on success a 1 will be returned.  
\item {\ttfamily int = obj.\-Toggle\-Active\-Node\-Selected ()} -\/ Set/\-Get whether the active or nth node is selected.  
\item {\ttfamily int = obj.\-Get\-Active\-Node\-Selected ()} -\/ Set/\-Get whether the active or nth node is selected.  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-Selected (int )} -\/ Set/\-Get whether the active or nth node is selected.  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-Selected (int )} -\/ Set/\-Get whether the active or nth node is selected.  
\item {\ttfamily int = obj.\-Get\-Active\-Node\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Get the world position of the active node. Will return 0 if there is no active node, or 1 otherwise.  
\item {\ttfamily int = obj.\-Get\-Active\-Node\-World\-Orientation (double orient\mbox{[}9\mbox{]})} -\/ Get the world orientation of the active node. Will return 0 if there is no active node, or 1 otherwise.  
\item {\ttfamily int = obj.\-Get\-Active\-Node\-Display\-Position (double pos\mbox{[}2\mbox{]})} -\/ Get the display position of the active node. Will return 0 if there is no active node, or 1 otherwise.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Nodes ()} -\/ Get the number of nodes.  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-Display\-Position (int n, double pos\mbox{[}2\mbox{]})} -\/ Get the nth node's display position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-World\-Position (int n, double pos\mbox{[}3\mbox{]})} -\/ Get the nth node's world position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-World\-Orientation (int n, double orient\mbox{[}9\mbox{]})} -\/ Get the nth node's world orientation. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-Display\-Position (int n, int X, int Y)} -\/ Set the nth node's display position. Display position will be converted into world position according to the constraints of the point placer. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting) or the world position is not valid.  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-Display\-Position (int n, int pos\mbox{[}2\mbox{]})} -\/ Set the nth node's display position. Display position will be converted into world position according to the constraints of the point placer. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting) or the world position is not valid.  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-Display\-Position (int n, double pos\mbox{[}2\mbox{]})} -\/ Set the nth node's display position. Display position will be converted into world position according to the constraints of the point placer. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting) or the world position is not valid.  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-World\-Position (int n, double pos\mbox{[}3\mbox{]})} -\/ Set the nth node's world position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting) or the world position is not valid according to the point placer.  
\item {\ttfamily int = obj.\-Set\-Nth\-Node\-World\-Position (int n, double pos\mbox{[}3\mbox{]}, double orient\mbox{[}9\mbox{]})} -\/ Set the nth node's world position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting) or the world position is not valid according to the point placer.  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-Slope (int idx, double slope\mbox{[}3\mbox{]})} -\/ Get the nth node's slope. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Intermediate\-Points (int n)}  
\item {\ttfamily int = obj.\-Get\-Intermediate\-Point\-World\-Position (int n, int idx, double point\mbox{[}3\mbox{]})} -\/ Get the world position of the intermediate point at index idx between nodes n and (n+1) (or n and 0 if n is the last node and the loop is closed). Returns 1 on success or 0 if n or idx are out of range.  
\item {\ttfamily int = obj.\-Add\-Intermediate\-Point\-World\-Position (int n, double point\mbox{[}3\mbox{]})} -\/ Add an intermediate point between node n and n+1 (or n and 0 if n is the last node and the loop is closed). Returns 1 on success or 0 if n is out of range.  
\item {\ttfamily int = obj.\-Delete\-Last\-Node ()} -\/ Delete the last node. Returns 1 on success or 0 if there were not any nodes.  
\item {\ttfamily int = obj.\-Delete\-Active\-Node ()} -\/ Delete the active node. Returns 1 on success or 0 if the active node did not indicate a valid node.  
\item {\ttfamily int = obj.\-Delete\-Nth\-Node (int n)} -\/ Delete the nth node. Return 1 on success or 0 if n is out of range.  
\item {\ttfamily obj.\-Clear\-All\-Nodes ()} -\/ Delete all nodes.  
\item {\ttfamily int = obj.\-Add\-Node\-On\-Contour (int X, int Y)} -\/ Given a specific X, Y pixel location, add a new node on the contour at this location.  
\item {\ttfamily obj.\-Set\-Pixel\-Tolerance (int )} -\/ The tolerance to use when calculations are performed in display coordinates  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance\-Min\-Value ()} -\/ The tolerance to use when calculations are performed in display coordinates  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance\-Max\-Value ()} -\/ The tolerance to use when calculations are performed in display coordinates  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance ()} -\/ The tolerance to use when calculations are performed in display coordinates  
\item {\ttfamily obj.\-Set\-World\-Tolerance (double )} -\/ The tolerance to use when calculations are performed in world coordinates  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance\-Min\-Value ()} -\/ The tolerance to use when calculations are performed in world coordinates  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance\-Max\-Value ()} -\/ The tolerance to use when calculations are performed in world coordinates  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance ()} -\/ The tolerance to use when calculations are performed in world coordinates  
\item {\ttfamily int = obj.\-Get\-Current\-Operation ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily obj.\-Set\-Current\-Operation (int )} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily int = obj.\-Get\-Current\-Operation\-Min\-Value ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily int = obj.\-Get\-Current\-Operation\-Max\-Value ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily obj.\-Set\-Current\-Operation\-To\-Inactive ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily obj.\-Set\-Current\-Operation\-To\-Translate ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily obj.\-Set\-Current\-Operation\-To\-Shift ()} -\/ Set / get the current operation. The widget is either inactive, or it is being translated.  
\item {\ttfamily obj.\-Set\-Current\-Operation\-To\-Scale ()}  
\item {\ttfamily obj.\-Set\-Point\-Placer (vtk\-Point\-Placer )}  
\item {\ttfamily vtk\-Point\-Placer = obj.\-Get\-Point\-Placer ()}  
\item {\ttfamily obj.\-Set\-Line\-Interpolator (vtk\-Contour\-Line\-Interpolator )} -\/ Set / Get the Line Interpolator. The line interpolator is responsible for generating the line segments connecting nodes.  
\item {\ttfamily vtk\-Contour\-Line\-Interpolator = obj.\-Get\-Line\-Interpolator ()} -\/ Set / Get the Line Interpolator. The line interpolator is responsible for generating the line segments connecting nodes.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modified)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily obj.\-Set\-Closed\-Loop (int val)} -\/ Set / Get the Closed\-Loop value. This ivar indicates whether the contour forms a closed loop.  
\item {\ttfamily int = obj.\-Get\-Closed\-Loop ()} -\/ Set / Get the Closed\-Loop value. This ivar indicates whether the contour forms a closed loop.  
\item {\ttfamily obj.\-Closed\-Loop\-On ()} -\/ Set / Get the Closed\-Loop value. This ivar indicates whether the contour forms a closed loop.  
\item {\ttfamily obj.\-Closed\-Loop\-Off ()} -\/ Set / Get the Closed\-Loop value. This ivar indicates whether the contour forms a closed loop.  
\item {\ttfamily obj.\-Set\-Show\-Selected\-Nodes (int )} -\/ A flag to indicate whether to show the Selected nodes Default is to set it to false.  
\item {\ttfamily int = obj.\-Get\-Show\-Selected\-Nodes ()} -\/ A flag to indicate whether to show the Selected nodes Default is to set it to false.  
\item {\ttfamily obj.\-Show\-Selected\-Nodes\-On ()} -\/ A flag to indicate whether to show the Selected nodes Default is to set it to false.  
\item {\ttfamily obj.\-Show\-Selected\-Nodes\-Off ()} -\/ A flag to indicate whether to show the Selected nodes Default is to set it to false.  
\item {\ttfamily obj.\-Get\-Node\-Poly\-Data (vtk\-Poly\-Data poly)} -\/ Get the nodes and not the intermediate points in this contour as a vtk\-Poly\-Data.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkcontourwidget}{}\section{vtk\-Contour\-Widget}\label{vtkwidgets_vtkcontourwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Contour\-Widget is used to select a set of points, and draw lines between these points. The contour may be opened or closed, depending on how the last point is added. The widget handles all processing of widget events (that are triggered by V\-T\-K events). The vtk\-Contour\-Representation is responsible for all placement of the points, calculation of the lines, and contour manipulation. This is done through two main helper classes\-: vtk\-Point\-Placer and vtk\-Contour\-Line\-Interpolator. The representation is also responsible for drawing the points and lines.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - triggers a Select event
   RightButtonPressEvent - triggers a AddFinalPoint event
   MouseMoveEvent - triggers a Move event
   LeftButtonReleaseEvent - triggers an EndSelect event
   Delete key event - triggers a Delete event
   Shift + Delete key event - triggers a Reset event
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Contour\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select 
        widget state is: 
            Start or
            Define: If we already have at least 2 nodes, test
                 whether the current (X,Y) location is near an existing
                 node. If so, close the contour and change to Manipulate
                 state. Otherwise, attempt to add a node at this (X,Y)
                 location.
            Manipulate: If this (X,Y) location activates a node, then
                 set the current operation to Translate. Otherwise, if
                 this location is near the contour, attempt to add a 
                 new node on the contour at this (X,Y) location.\end{DoxyPre}



\begin{DoxyPre}   vtkWidgetEvent::AddFinalPoint
        widget state is: 
            Start: Do nothing.
            Define: If we already have at least 2 nodes, test
                 whether the current (X,Y) location is near an existing
                 node. If so, close the contour and change to Manipulate
                 state. Otherwise, attempt to add a node at this (X,Y)
                 location. If we do, then leave the contour open and
                 change to Manipulate state.
            Manipulate: Do nothing.\end{DoxyPre}



\begin{DoxyPre}   vtkWidgetEvent::Move
        widget state is: 
            Start or
            Define: Do nothing.
            Manipulate: If our operation is Translate, then invoke
                  WidgetInteraction() on the representation. If our 
                  operation is Inactive, then just attempt to activate
                  a node at this (X,Y) location.\end{DoxyPre}



\begin{DoxyPre}   vtkWidgetEvent::EndSelect
        widget state is: 
            Start or
            Define: Do nothing.
            Manipulate: If our operation is not Inactive, set it to
                  Inactive.\end{DoxyPre}



\begin{DoxyPre}   vtkWidgetEvent::Delete
        widget state is: 
            Start: Do nothing.
            Define: Remove the last point on the contour.
            Manipulate: Attempt to activate a node at (X,Y). If
                   we do activate a node, delete it. If we now
                   have less than 3 nodes, go back to Define state.\end{DoxyPre}



\begin{DoxyPre}   vtkWidgetEvent::Reset
        widget state is: 
            Start: Do nothing.
            Define: Remove all points and line segments of the contour.
                 Essentially calls Intialize(NULL) 
            Manipulate: Do nothing.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (beginning to interact)
   vtkCommand::EndInteractionEvent (completing interaction)
   vtkCommand::InteractionEvent (moving after selecting something)
   vtkCommand::PlacePointEvent (after point is positioned; 
                                call data includes handle id (0,1))
   vtkCommand::WidgetValueChangedEvent (Invoked when the contour is closed
                                        for the first time. )
 \end{DoxyPre}


To create an instance of class vtk\-Contour\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkContourWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Contour\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Contour\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Contour\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Contour\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Contour\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Close\-Loop ()} -\/ Convenient method to close the contour loop.  
\item {\ttfamily obj.\-Set\-Allow\-Node\-Picking (int )} -\/ Set / Get the Allow\-Node\-Picking value. This ivar indicates whether the nodes and points between nodes can be picked/un-\/picked by Ctrl+\-Click on the node.  
\item {\ttfamily int = obj.\-Get\-Allow\-Node\-Picking ()} -\/ Set / Get the Allow\-Node\-Picking value. This ivar indicates whether the nodes and points between nodes can be picked/un-\/picked by Ctrl+\-Click on the node.  
\item {\ttfamily obj.\-Allow\-Node\-Picking\-On ()} -\/ Set / Get the Allow\-Node\-Picking value. This ivar indicates whether the nodes and points between nodes can be picked/un-\/picked by Ctrl+\-Click on the node.  
\item {\ttfamily obj.\-Allow\-Node\-Picking\-Off ()} -\/ Set / Get the Allow\-Node\-Picking value. This ivar indicates whether the nodes and points between nodes can be picked/un-\/picked by Ctrl+\-Click on the node.  
\item {\ttfamily obj.\-Set\-Follow\-Cursor (int )} -\/ Follow the cursor ? If this is O\-N, during definition, the last node of the contour will automatically follow the cursor, without waiting for the the point to be dropped. This may be useful for some interpolators, such as the live-\/wire interpolator to see the shape of the contour that will be placed as you move the mouse cursor.  
\item {\ttfamily int = obj.\-Get\-Follow\-Cursor ()} -\/ Follow the cursor ? If this is O\-N, during definition, the last node of the contour will automatically follow the cursor, without waiting for the the point to be dropped. This may be useful for some interpolators, such as the live-\/wire interpolator to see the shape of the contour that will be placed as you move the mouse cursor.  
\item {\ttfamily obj.\-Follow\-Cursor\-On ()} -\/ Follow the cursor ? If this is O\-N, during definition, the last node of the contour will automatically follow the cursor, without waiting for the the point to be dropped. This may be useful for some interpolators, such as the live-\/wire interpolator to see the shape of the contour that will be placed as you move the mouse cursor.  
\item {\ttfamily obj.\-Follow\-Cursor\-Off ()} -\/ Follow the cursor ? If this is O\-N, during definition, the last node of the contour will automatically follow the cursor, without waiting for the the point to be dropped. This may be useful for some interpolators, such as the live-\/wire interpolator to see the shape of the contour that will be placed as you move the mouse cursor.  
\item {\ttfamily obj.\-Set\-Continuous\-Draw (int )} -\/ Define a contour by continuously drawing with the mouse cursor. Press and hold the left mouse button down to continuously draw. Releasing the left mouse button switches into a snap drawing mode. Terminate the contour by pressing the right mouse button. If you do not want to see the nodes as they are added to the contour, set the opacity to 0 of the representation's property. If you do not want to see the last active node as it is being added, set the opacity to 0 of the representation's active property.  
\item {\ttfamily int = obj.\-Get\-Continuous\-Draw ()} -\/ Define a contour by continuously drawing with the mouse cursor. Press and hold the left mouse button down to continuously draw. Releasing the left mouse button switches into a snap drawing mode. Terminate the contour by pressing the right mouse button. If you do not want to see the nodes as they are added to the contour, set the opacity to 0 of the representation's property. If you do not want to see the last active node as it is being added, set the opacity to 0 of the representation's active property.  
\item {\ttfamily obj.\-Continuous\-Draw\-On ()} -\/ Define a contour by continuously drawing with the mouse cursor. Press and hold the left mouse button down to continuously draw. Releasing the left mouse button switches into a snap drawing mode. Terminate the contour by pressing the right mouse button. If you do not want to see the nodes as they are added to the contour, set the opacity to 0 of the representation's property. If you do not want to see the last active node as it is being added, set the opacity to 0 of the representation's active property.  
\item {\ttfamily obj.\-Continuous\-Draw\-Off ()} -\/ Define a contour by continuously drawing with the mouse cursor. Press and hold the left mouse button down to continuously draw. Releasing the left mouse button switches into a snap drawing mode. Terminate the contour by pressing the right mouse button. If you do not want to see the nodes as they are added to the contour, set the opacity to 0 of the representation's property. If you do not want to see the last active node as it is being added, set the opacity to 0 of the representation's active property.  
\item {\ttfamily obj.\-Initialize (vtk\-Poly\-Data poly, int state)} -\/ Initialize the contour widget from a user supplied set of points. The state of the widget decides if you are still defining the widget, or if you've finished defining (added the last point) are manipulating it. Note that if the polydata supplied is closed, the state will be set to manipulate. State\-: Define = 0, Manipulate = 1.  
\item {\ttfamily obj.\-Initialize ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkdijkstraimagecontourlineinterpolator}{}\section{vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkdijkstraimagecontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator interpolates and places contour points on images. The class interpolates nodes by computing a graph lying on the image data. By graph, we mean that the line interpolating the two end points traverses along pixels so as to form a shortest path. A Dijkstra algorithm is used to compute the path.

The class is meant to be used in conjunction with vtk\-Image\-Actor\-Point\-Placer. One reason for this coupling is a performance issue\-: both classes need to perform a cell pick, and coupling avoids multiple cell picks (cell picks are slow). Another issue is that the interpolator may need to set the image input to its vtk\-Dijkstra\-Image\-Geodesic\-Path ivar.

To create an instance of class vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDijkstraImageContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Dijkstra\-Image\-Contour\-Line\-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\-Dijkstra\-Image\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Dijkstra\-Image\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)} -\/ Subclasses that wish to interpolate a line segment must implement this. For instance vtk\-Bezier\-Contour\-Line\-Interpolator adds nodes between idx1 and idx2, that allow the contour to adhere to a bezier curve.  
\item {\ttfamily obj.\-Set\-Cost\-Image (vtk\-Image\-Data )} -\/ Set the image data for the vtk\-Dijkstra\-Image\-Geodesic\-Path. If not set, the interpolator uses the image data input to the image actor. The image actor is obtained from the expected vtk\-Image\-Actor\-Point\-Placer.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Cost\-Image ()} -\/ Set the image data for the vtk\-Dijkstra\-Image\-Geodesic\-Path. If not set, the interpolator uses the image data input to the image actor. The image actor is obtained from the expected vtk\-Image\-Actor\-Point\-Placer.  
\item {\ttfamily vtk\-Dijkstra\-Image\-Geodesic\-Path = obj.\-Get\-Dijkstra\-Image\-Geodesic\-Path ()} -\/ access to the internal dijkstra path  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkdistancerepresentation}{}\section{vtk\-Distance\-Representation}\label{vtkwidgets_vtkdistancerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Distance\-Representation is a superclass for various types of representations for the vtk\-Distance\-Widget. Logically subclasses consist of an axis and two handles for placing/manipulating the end points.

To create an instance of class vtk\-Distance\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDistanceRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Distance\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Distance\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Distance\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ This representation and all subclasses must keep a distance consistent with the state of the widget.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point1\-World\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point2\-World\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Handle\-Representation handle)} -\/ This method is used to specify the type of handle representation to use for the two internal vtk\-Handle\-Widgets within vtk\-Distance\-Widget. To use this method, create a dummy vtk\-Handle\-Widget (or subclass), and then invoke this method with this dummy. Then the vtk\-Distance\-Representation uses this dummy to clone two vtk\-Handle\-Widgets of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Distance widget.)  
\item {\ttfamily obj.\-Instantiate\-Handle\-Representation ()} -\/ This method is used to specify the type of handle representation to use for the two internal vtk\-Handle\-Widgets within vtk\-Distance\-Widget. To use this method, create a dummy vtk\-Handle\-Widget (or subclass), and then invoke this method with this dummy. Then the vtk\-Distance\-Representation uses this dummy to clone two vtk\-Handle\-Widgets of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Distance widget.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point1\-Representation ()} -\/ Set/\-Get the two handle representations used for the vtk\-Distance\-Widget. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Point2\-Representation ()} -\/ Set/\-Get the two handle representations used for the vtk\-Distance\-Widget. (Note\-: properties can be set by grabbing these representations and setting the properties appropriately.)  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Specify the format to use for labelling the distance. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the distance value.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Specify the format to use for labelling the distance. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the distance value.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkdistancerepresentation2d}{}\section{vtk\-Distance\-Representation2\-D}\label{vtkwidgets_vtkdistancerepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Distance\-Representation2\-D is a representation for the vtk\-Distance\-Widget. This representation consists of a measuring line (axis) and two vtk\-Handle\-Widgets to place the end points of the line. Note that this particular widget draws its representation in the overlay plane.

To create an instance of class vtk\-Distance\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDistanceRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Distance\-Representation2\-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\-Distance\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Distance\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Distance\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})}  
\item {\ttfamily vtk\-Axis\-Actor2\-D = obj.\-Get\-Axis ()} -\/ Retrieve the vtk\-Axis\-Actor2\-D used to draw the measurement axis. With this properties can be set and so on.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Method to satisfy superclasses' A\-P\-I.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkdistancewidget}{}\section{vtk\-Distance\-Widget}\label{vtkwidgets_vtkdistancewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Distance\-Widget is used to measure the distance between two points. The two end points can be positioned independently, and when they are released, a special Place\-Point\-Event is invoked so that special operations may be take to reposition the point (snap to grid, etc.) The widget has two different modes of interaction\-: when initially defined (i.\-e., placing the two points) and then a manipulate mode (adjusting the position of the two points).

To use this widget, specify an instance of vtk\-Distance\-Widget and a representation (a subclass of vtk\-Distance\-Representation). The widget is implemented using two instances of vtk\-Handle\-Widget which are used to position the end points of the line. The representations for these two handle widgets are provided by the vtk\-Distance\-Representation.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - add a point or select a handle
   MouseMoveEvent - position the second point or move a handle
   LeftButtonReleaseEvent - release the handle
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Distance\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::AddPoint -- add one point; depending on the state
                               it may the first or second point added. Or,
                               if near a handle, select the handle.
   vtkWidgetEvent::Move -- move the second point or handle depending on the state.
   vtkWidgetEvent::EndSelect -- the handle manipulation process has completed.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (beginning to interact)
   vtkCommand::EndInteractionEvent (completing interaction)
   vtkCommand::InteractionEvent (moving after selecting something)
   vtkCommand::PlacePointEvent (after point is positioned;
                                call data includes handle id (0,1))
 \end{DoxyPre}


To create an instance of class vtk\-Distance\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkDistanceWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Distance\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Distance\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Distance\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Distance\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkellipsoidtensorproberepresentation}{}\section{vtk\-Ellipsoid\-Tensor\-Probe\-Representation}\label{vtkwidgets_vtkellipsoidtensorproberepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Ellipsoid\-Tensor\-Probe\-Representation is a concrete implementation of vtk\-Tensor\-Probe\-Representation. It renders tensors as ellipsoids. Locations between two points when probed have the tensors linearly interpolated from the neighboring locations on the polyline.

To create an instance of class vtk\-Ellipsoid\-Tensor\-Probe\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEllipsoidTensorProbeRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Ellipsoid\-Tensor\-Probe\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Ellipsoid\-Tensor\-Probe\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Ellipsoid\-Tensor\-Probe\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Ellipsoid\-Tensor\-Probe\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Build\-Representation ()}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Select\-Probe (int pos\mbox{[}2\mbox{]})} -\/ Can we pick the tensor glyph at the current cursor pos  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ See vtk\-Prop for details.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ See vtk\-Prop for details.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkevent}{}\section{vtk\-Event}\label{vtkwidgets_vtkevent}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Event is a class that fully describes a V\-T\-K event. It is used by the widgets to help specify the mapping between V\-T\-K events and widget events.

To create an instance of class vtk\-Event, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkEvent
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Event has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Event 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\-Event = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Event = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Event\-Id (long )} -\/ Set the modifier for the event.  
\item {\ttfamily long = obj.\-Get\-Event\-Id ()} -\/ Set the modifier for the event.  
\item {\ttfamily obj.\-Set\-Modifier (int )} -\/ Set the modifier for the event.  
\item {\ttfamily int = obj.\-Get\-Modifier ()} -\/ Set the modifier for the event.  
\item {\ttfamily obj.\-Set\-Key\-Code (char )} -\/ Set the Key\-Code for the event.  
\item {\ttfamily char = obj.\-Get\-Key\-Code ()} -\/ Set the Key\-Code for the event.  
\item {\ttfamily obj.\-Set\-Repeat\-Count (int )} -\/ Set the repease count for the event.  
\item {\ttfamily int = obj.\-Get\-Repeat\-Count ()} -\/ Set the repease count for the event.  
\item {\ttfamily obj.\-Set\-Key\-Sym (string )} -\/ Set the complex key symbol (compound key strokes) for the event.  
\item {\ttfamily string = obj.\-Get\-Key\-Sym ()} -\/ Set the complex key symbol (compound key strokes) for the event.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkfocalplanecontourrepresentation}{}\section{vtk\-Focal\-Plane\-Contour\-Representation}\label{vtkwidgets_vtkfocalplanecontourrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The contour will stay on the focal plane irrespective of camera position/orientation changes. The class was written in order to be able to draw contours on a volume widget and have the contours overlayed on the focal plane in order to do contour segmentation. The superclass, vtk\-Contour\-Representation handles contours that are drawn in actual world position co-\/ordinates, so they would rotate with the camera position/ orientation changes

To create an instance of class vtk\-Focal\-Plane\-Contour\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFocalPlaneContourRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Focal\-Plane\-Contour\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Focal\-Plane\-Contour\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Focal\-Plane\-Contour\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Focal\-Plane\-Contour\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Get\-Intermediate\-Point\-World\-Position (int n, int idx, double point\mbox{[}3\mbox{]})} -\/ Get the world position of the intermediate point at index idx between nodes n and (n+1) (or n and 0 if n is the last node and the loop is closed). Returns 1 on success or 0 if n or idx are out of range.  
\item {\ttfamily int = obj.\-Get\-Intermediate\-Point\-Display\-Position (int n, int idx, double point\mbox{[}3\mbox{]})} -\/ Get the world position of the intermediate point at index idx between nodes n and (n+1) (or n and 0 if n is the last node and the loop is closed). Returns 1 on success or 0 if n or idx are out of range.  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-Display\-Position (int n, double pos\mbox{[}2\mbox{]})} -\/ Get the nth node's display position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily int = obj.\-Get\-Nth\-Node\-World\-Position (int n, double pos\mbox{[}3\mbox{]})} -\/ Get the nth node's world position. Will return 1 on success, or 0 if there are not at least (n+1) nodes (0 based counting).  
\item {\ttfamily obj.\-Update\-Contour\-World\-Positions\-Based\-On\-Display\-Positions ()} -\/ The class maintains its true contour locations based on display co-\/ords This method syncs the world co-\/ords data structure with the display co-\/ords.  
\item {\ttfamily int = obj.\-Update\-Contour ()} -\/ The method must be called whenever the contour needs to be updated, usually from Render\-Opaque\-Geometry()  
\item {\ttfamily obj.\-Update\-Lines (int index)}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkfocalplanepointplacer}{}\section{vtk\-Focal\-Plane\-Point\-Placer}\label{vtkwidgets_vtkfocalplanepointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Focal\-Plane\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkFocalPlanePointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Focal\-Plane\-Point\-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\-Focal\-Plane\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Focal\-Plane\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Focal\-Plane\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})}  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute a new world position. The orientation will be the standard coordinate axes, and the computed world position will be created by projecting the display point onto a plane that is parallel to the focal plane and runs through the reference world position. This method is typically used to move existing points.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Validate a world position. All world positions are valid so these methods always return 1.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Validate a world position. All world positions are valid so these methods always return 1.  
\item {\ttfamily obj.\-Set\-Offset (double )} -\/ Optionally specify a signed offset from the focal plane for the points to be placed at. If negative, the constraint plane is offset closer to the camera. If positive, its further away from the camera.  
\item {\ttfamily double = obj.\-Get\-Offset ()} -\/ Optionally specify a signed offset from the focal plane for the points to be placed at. If negative, the constraint plane is offset closer to the camera. If positive, its further away from the camera.  
\item {\ttfamily obj.\-Set\-Point\-Bounds (double , double , double , double , double , double )} -\/ Optionally Restrict the points to a set of bounds. The placer will invalidate points outside these bounds.  
\item {\ttfamily obj.\-Set\-Point\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Optionally Restrict the points to a set of bounds. The placer will invalidate points outside these bounds.  
\item {\ttfamily double = obj. Get\-Point\-Bounds ()} -\/ Optionally Restrict the points to a set of bounds. The placer will invalidate points outside these bounds.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkhandlerepresentation}{}\section{vtk\-Handle\-Representation}\label{vtkwidgets_vtkhandlerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class defines an A\-P\-I for widget handle representations. These representations interact with vtk\-Handle\-Widget. Various representations can be used depending on the nature of the handle. The basic functionality of the handle representation is to maintain a position. The position is represented via a vtk\-Coordinate, meaning that the position can be easily obtained in a variety of coordinate systems.

Optional features for this representation include an active mode (the widget appears only when the mouse pointer is close to it). The active distance is expressed in pixels and represents a circle in display space.

The class may be subclassed so that alternative representations can be created. The class defines an A\-P\-I and a default implementation that the vtk\-Handle\-Widget interacts with to render itself in the scene.

To create an instance of class vtk\-Handle\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHandleRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Handle\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Handle\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily obj.\-Get\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily double = obj.\-Get\-Display\-Position ()} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily obj.\-Set\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily obj.\-Get\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily double = obj.\-Get\-World\-Position ()} -\/ Handles usually have their coordinates set in display coordinates (generally by an associated widget) and internally maintain the position in world coordinates. (Using world coordinates insures that handles are rendered in the right position when the camera view changes.) These methods are often subclassed because special constraint operations can be used to control the actual positioning.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the widget to be active.  
\item {\ttfamily obj.\-Set\-Active\-Representation (int )} -\/ Flag controls whether the widget becomes visible when the mouse pointer moves close to it (i.\-e., the widget becomes active). By default, Active\-Representation is off and the representation is always visible.  
\item {\ttfamily int = obj.\-Get\-Active\-Representation ()} -\/ Flag controls whether the widget becomes visible when the mouse pointer moves close to it (i.\-e., the widget becomes active). By default, Active\-Representation is off and the representation is always visible.  
\item {\ttfamily obj.\-Active\-Representation\-On ()} -\/ Flag controls whether the widget becomes visible when the mouse pointer moves close to it (i.\-e., the widget becomes active). By default, Active\-Representation is off and the representation is always visible.  
\item {\ttfamily obj.\-Active\-Representation\-Off ()} -\/ Flag controls whether the widget becomes visible when the mouse pointer moves close to it (i.\-e., the widget becomes active). By default, Active\-Representation is off and the representation is always visible.  
\item {\ttfamily obj.\-Set\-Interaction\-State (int )} -\/ The interaction state may be set from a widget (e.\-g., Handle\-Widget) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking processwith the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Min\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., Handle\-Widget) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking processwith the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Max\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., Handle\-Widget) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking processwith the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily obj.\-Set\-Constrained (int )} -\/ Specify whether any motions (such as scale, translate, etc.) are constrained in some way (along an axis, etc.) Widgets can use this to control the resulting motion.  
\item {\ttfamily int = obj.\-Get\-Constrained ()} -\/ Specify whether any motions (such as scale, translate, etc.) are constrained in some way (along an axis, etc.) Widgets can use this to control the resulting motion.  
\item {\ttfamily obj.\-Constrained\-On ()} -\/ Specify whether any motions (such as scale, translate, etc.) are constrained in some way (along an axis, etc.) Widgets can use this to control the resulting motion.  
\item {\ttfamily obj.\-Constrained\-Off ()} -\/ Specify whether any motions (such as scale, translate, etc.) are constrained in some way (along an axis, etc.) Widgets can use this to control the resulting motion.  
\item {\ttfamily int = obj.\-Check\-Constraint (vtk\-Renderer renderer, double pos\mbox{[}2\mbox{]})} -\/ Method has to be overridden in the subclasses which has constraints on placing the handle (Ex. vtk\-Constrained\-Point\-Handle\-Representation). It should return 1 if the position is within the constraint, else it should return 0. By default it returns 1.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Prop prop)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload the superclasses' Get\-M\-Time() because the internal vtk\-Coordinates are used to keep the state of the representation.  
\item {\ttfamily obj.\-Set\-Point\-Placer (vtk\-Point\-Placer )} -\/ Set/\-Get the point placer. Point placers can be used to dictate constraints on the placement of handles. As an example, see vtk\-Bounded\-Plane\-Point\-Placer (constrains the placement of handles to a set of bounded planes) vtk\-Focal\-Plane\-Point\-Placer (constrains placement on the focal plane) etc. The default point placer is vtk\-Point\-Placer (which does not apply any constraints, so the handles are free to move anywhere).  
\item {\ttfamily vtk\-Point\-Placer = obj.\-Get\-Point\-Placer ()} -\/ Set/\-Get the point placer. Point placers can be used to dictate constraints on the placement of handles. As an example, see vtk\-Bounded\-Plane\-Point\-Placer (constrains the placement of handles to a set of bounded planes) vtk\-Focal\-Plane\-Point\-Placer (constrains placement on the focal plane) etc. The default point placer is vtk\-Point\-Placer (which does not apply any constraints, so the handles are free to move anywhere).  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkhandlewidget}{}\section{vtk\-Handle\-Widget}\label{vtkwidgets_vtkhandlewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Handle\-Widget is used to position a handle. A handle is a widget with a position (in display and world space). Various appearances are available depending on its associated representation. The widget provides methods for translation, including constrained translation along coordinate axes. To use this widget, create and associate a representation with the widget.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - select focal point of widget
   LeftButtonReleaseEvent - end selection
   MiddleButtonPressEvent - translate widget
   MiddleButtonReleaseEvent - end translation
   RightButtonPressEvent - scale widget
   RightButtonReleaseEvent - end scaling
   MouseMoveEvent - interactive movement across widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Handle\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- focal point is being selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Translate -- translate the widget
   vtkWidgetEvent::EndTranslate -- end widget translation
   vtkWidgetEvent::Scale -- scale the widget
   vtkWidgetEvent::EndScale -- end scaling the widget
   vtkWidgetEvent::Move -- a request for widget motion
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Handle\-Widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Handle\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHandleWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Handle\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Handle\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Handle\-Widget = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Handle\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Handle\-Representation r)} -\/ Create the default widget representation if one is not set. By default an instance of vtk\-Point\-Handle\-Represenation3\-D is created.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set. By default an instance of vtk\-Point\-Handle\-Represenation3\-D is created.  
\item {\ttfamily obj.\-Set\-Enable\-Axis\-Constraint (int )} -\/ Enable / disable axis constrained motion of the handles. By default the widget responds to the shift modifier to constrain the handle along the axis closest aligned with the motion vector.  
\item {\ttfamily int = obj.\-Get\-Enable\-Axis\-Constraint ()} -\/ Enable / disable axis constrained motion of the handles. By default the widget responds to the shift modifier to constrain the handle along the axis closest aligned with the motion vector.  
\item {\ttfamily obj.\-Enable\-Axis\-Constraint\-On ()} -\/ Enable / disable axis constrained motion of the handles. By default the widget responds to the shift modifier to constrain the handle along the axis closest aligned with the motion vector.  
\item {\ttfamily obj.\-Enable\-Axis\-Constraint\-Off ()} -\/ Enable / disable axis constrained motion of the handles. By default the widget responds to the shift modifier to constrain the handle along the axis closest aligned with the motion vector.  
\item {\ttfamily obj.\-Set\-Allow\-Handle\-Resize (int )} -\/ Allow resizing of handles ? By default the right mouse button scales the handle size.  
\item {\ttfamily int = obj.\-Get\-Allow\-Handle\-Resize ()} -\/ Allow resizing of handles ? By default the right mouse button scales the handle size.  
\item {\ttfamily obj.\-Allow\-Handle\-Resize\-On ()} -\/ Allow resizing of handles ? By default the right mouse button scales the handle size.  
\item {\ttfamily obj.\-Allow\-Handle\-Resize\-Off ()} -\/ Allow resizing of handles ? By default the right mouse button scales the handle size.  
\item {\ttfamily int = obj.\-Get\-Widget\-State ()} -\/ Get the widget state.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkhoverwidget}{}\section{vtk\-Hover\-Widget}\label{vtkwidgets_vtkhoverwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Hover\-Widget is used to invoke an event when hovering in a render window. Hovering occurs when mouse motion (in the render window) does not occur for a specified amount of time (i.\-e., Timer\-Duration). This class can be used as is (by observing Timer\-Events) or for class derivation for those classes wishing to do more with the hover event.

To use this widget, specify an instance of vtk\-Hover\-Widget and specify the time (in milliseconds) defining the hover period. Unlike most widgets, this widget does not require a representation (although subclasses like vtk\-Balloon\-Widget do require a representation).

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget observes the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   MouseMoveEvent - manages a timer used to determine whether the mouse
                    is hovering.
   TimerEvent - when the time between events (e.g., mouse move), then a
                timer event is invoked.
   KeyPressEvent - when the "Enter" key is pressed after the balloon appears,
                   a callback is activited (e.g., WidgetActivateEvent).
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Hover\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Move -- start (or reset) the timer
   vtkWidgetEvent::TimedOut -- when enough time is elapsed between defined
                               VTK events the hover event is invoked.
   vtkWidgetEvent::SelectAction -- activate any callbacks associated 
                                   with the balloon.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself when the widget determines that it is hovering. Note that observers of this widget can listen for these events and take appropriate action. 
\begin{DoxyPre}
   vtkCommand::TimerEvent (when hovering is determined to occur)
   vtkCommand::EndInteractionEvent (after a hover has occured and the
                                    mouse begins moving again).
   vtkCommand::WidgetActivateEvent (when the balloon is selected with a
                                    keypress).
 \end{DoxyPre}


To create an instance of class vtk\-Hover\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkHoverWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Hover\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Hover\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Hover\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Hover\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Timer\-Duration (int )} -\/ Specify the hovering interval (in milliseconds). If after moving the mouse the pointer stays over a vtk\-Prop for this duration, then a vtk\-Timer\-Event\-::\-Timer\-Event is invoked.  
\item {\ttfamily int = obj.\-Get\-Timer\-Duration\-Min\-Value ()} -\/ Specify the hovering interval (in milliseconds). If after moving the mouse the pointer stays over a vtk\-Prop for this duration, then a vtk\-Timer\-Event\-::\-Timer\-Event is invoked.  
\item {\ttfamily int = obj.\-Get\-Timer\-Duration\-Max\-Value ()} -\/ Specify the hovering interval (in milliseconds). If after moving the mouse the pointer stays over a vtk\-Prop for this duration, then a vtk\-Timer\-Event\-::\-Timer\-Event is invoked.  
\item {\ttfamily int = obj.\-Get\-Timer\-Duration ()} -\/ Specify the hovering interval (in milliseconds). If after moving the mouse the pointer stays over a vtk\-Prop for this duration, then a vtk\-Timer\-Event\-::\-Timer\-Event is invoked.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it performs special timer-\/related operations.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimageactorpointplacer}{}\section{vtk\-Image\-Actor\-Point\-Placer}\label{vtkwidgets_vtkimageactorpointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This Point\-Placer is used to constrain the placement of points on the supplied image actor. Additionally, you may set bounds to restrict the placement of the points. The placement of points will then be constrained to lie not only on the Image\-Actor but also within the bounds specified. If no bounds are specified, they may lie anywhere on the supplied Image\-Actor.

To create an instance of class vtk\-Image\-Actor\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageActorPointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Actor\-Point\-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\-Image\-Actor\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Image\-Actor\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Image\-Actor\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given and renderer and a display position in pixels, find a world position and orientation. In this class an internal vtk\-Bounded\-Plane\-Point\-Placer is used to compute the world position and orientation. The internal placer is set to use the plane of the image actor and the bounds of the image actor as the constraints for placing points.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ This method is identical to the one above since the reference position is ignored by the bounded plane point placer.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ This method validates a world position by checking to see if the world position is valid according to the constraints of the internal placer (essentially -\/ is this world position on the image?)  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ This method is identical to the one above since the bounded plane point placer ignores orientation  
\item {\ttfamily int = obj.\-Update\-World\-Position (vtk\-Renderer ren, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Update the world position and orientation according the the current constraints of the placer. Will be called by the representation when it notices that this placer has been modified.  
\item {\ttfamily int = obj.\-Update\-Internal\-State ()} -\/ A method for configuring the internal placer according to the constraints of the image actor. Called by the representation to give the placer a chance to update itself, which may cause the M\-Time to change, which would then cause the representation to update all of its points  
\item {\ttfamily obj.\-Set\-Image\-Actor (vtk\-Image\-Actor )} -\/ Set / get the reference vtk\-Image\-Actor used to place the points. An image actor must be set for this placer to work. An internal bounded plane point placer is created and set to match the bounds of the displayed image.  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Get\-Image\-Actor ()} -\/ Set / get the reference vtk\-Image\-Actor used to place the points. An image actor must be set for this placer to work. An internal bounded plane point placer is created and set to match the bounds of the displayed image.  
\item {\ttfamily obj.\-Set\-Bounds (double , double , double , double , double , double )} -\/ Optionally, you may set bounds to restrict the placement of the points. The placement of points will then be constrained to lie not only on the Image\-Actor but also within the bounds specified. If no bounds are specified, they may lie anywhere on the supplied Image\-Actor.  
\item {\ttfamily obj.\-Set\-Bounds (double a\mbox{[}6\mbox{]})} -\/ Optionally, you may set bounds to restrict the placement of the points. The placement of points will then be constrained to lie not only on the Image\-Actor but also within the bounds specified. If no bounds are specified, they may lie anywhere on the supplied Image\-Actor.  
\item {\ttfamily double = obj. Get\-Bounds ()} -\/ Optionally, you may set bounds to restrict the placement of the points. The placement of points will then be constrained to lie not only on the Image\-Actor but also within the bounds specified. If no bounds are specified, they may lie anywhere on the supplied Image\-Actor.  
\item {\ttfamily obj.\-Set\-World\-Tolerance (double s)} -\/ Set the world tolerance. This propagates it to the internal Bounded\-Plane\-Point\-Placer.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimageorthoplanes}{}\section{vtk\-Image\-Ortho\-Planes}\label{vtkwidgets_vtkimageorthoplanes}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Ortho\-Planes is an event observer class that listens to the events from three vtk\-Image\-Plane\-Widgets and keeps their orientations and scales synchronized.

To create an instance of class vtk\-Image\-Ortho\-Planes, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageOrthoPlanes
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Ortho\-Planes has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Ortho\-Planes class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Ortho\-Planes = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Ortho\-Planes = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Plane (int i, vtk\-Image\-Plane\-Widget image\-Plane\-Widget)} -\/ You must set three planes for the widget.  
\item {\ttfamily vtk\-Image\-Plane\-Widget = obj.\-Get\-Plane (int i)} -\/ You must set three planes for the widget.  
\item {\ttfamily obj.\-Reset\-Planes ()} -\/ Reset the planes to original scale, rotation, and location.  
\item {\ttfamily vtk\-Transform = obj.\-Get\-Transform ()} -\/ Get the transform for the planes.  
\item {\ttfamily obj.\-Handle\-Plane\-Event (vtk\-Image\-Plane\-Widget image\-Plane\-Widget)} -\/ A public method to be used only by the event callback.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimageplanewidget}{}\section{vtk\-Image\-Plane\-Widget}\label{vtkwidgets_vtkimageplanewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a plane that can be interactively placed in an image volume. A nice feature of the object is that the vtk\-Image\-Plane\-Widget, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Image\-Plane\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Image\-Plane\-Widget will terminate the processing of the event that it handles.

The core functionality of the widget is provided by a vtk\-Image\-Reslice object which passes its output onto a texture mapping pipeline for fast slicing through volumetric data. See the key methods\-: Generate\-Texture\-Plane() and Update\-Plane() for implementation details.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. If the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, the vtk\-Image\-Plane\-Widget will appear. (See superclass documentation for information about changing this behavior.)

Selecting the widget with the middle mouse button with and without holding the shift or control keys enables complex reslicing capablilites. To facilitate use, a set of 'margins' (left, right, top, bottom) are shown as a set of plane-\/axes aligned lines, the properties of which can be changed as a group. Without keyboard modifiers\-: selecting in the middle of the margins enables translation of the plane along its normal. Selecting one of the corners within the margins enables spinning around the plane's normal at its center. Selecting within a margin allows rotating about the center of the plane around an axis aligned with the margin (i.\-e., selecting left margin enables rotating around the plane's local y-\/prime axis). With control key modifier\-: margin selection enables edge translation (i.\-e., a constrained form of scaling). Selecting within the margins enables translation of the entire plane. With shift key modifier\-: uniform plane scaling is enabled. Moving the mouse up enlarges the plane while downward movement shrinks it.

Window-\/level is achieved by using the right mouse button. Window-\/level values can be reset by shift + 'r' or control + 'r' while regular reset camera is maintained with 'r' or 'R'. The left mouse button can be used to query the underlying image data with a snap-\/to cross-\/hair cursor. Currently, the nearest point in the input image data to the mouse cursor generates the cross-\/hairs. With oblique slicing, this behaviour may appear unsatisfactory. Text display of window-\/level and image coordinates/data values are provided by a text actor/mapper pair.

Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method). To support interactive manipulation of objects, this class invokes the events Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event as well as Start\-Window\-Level\-Event, Window\-Level\-Event, End\-Window\-Level\-Event and Reset\-Window\-Level\-Event.

The vtk\-Image\-Plane\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Get\-Poly\-Data() method can be used to get the polygonal representation of the plane and can be used as input for other V\-T\-K objects. Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button).

Some additional features of this class include the ability to control the properties of the widget. You can set the properties of\-: the selected and unselected representations of the plane's outline; the text actor via its vtk\-Text\-Property; the cross-\/hair cursor. In addition there are methods to constrain the plane so that it is aligned along the x-\/y-\/z axes. Finally, one can specify the degree of interpolation (vtk\-Image\-Reslice)\-: nearest neighbour, linear, and cubic.

To create an instance of class vtk\-Image\-Plane\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImagePlaneWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Plane\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Plane\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Plane\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Plane\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set the vtk\-Image\-Data$\ast$ input for the vtk\-Image\-Reslice.  
\item {\ttfamily obj.\-Set\-Input (vtk\-Data\-Set input)} -\/ Set the vtk\-Image\-Data$\ast$ input for the vtk\-Image\-Reslice.  
\item {\ttfamily obj.\-Set\-Origin (double x, double y, double z)} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily double = obj.\-Get\-Origin ()} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Get\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y, double z)} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily double = obj.\-Get\-Point1 ()} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Get\-Point1 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y, double z)} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily double = obj.\-Get\-Point2 ()} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily obj.\-Get\-Point2 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Get the center of the plane.  
\item {\ttfamily obj.\-Get\-Center (double xyz\mbox{[}3\mbox{]})} -\/ Get the center of the plane.  
\item {\ttfamily double = obj.\-Get\-Normal ()} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Get\-Normal (double xyz\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Get\-Vector1 (double v1\mbox{[}3\mbox{]})} -\/ Get the vector from the plane origin to point1.  
\item {\ttfamily obj.\-Get\-Vector2 (double v2\mbox{[}3\mbox{]})} -\/ Get the vector from the plane origin to point2.  
\item {\ttfamily int = obj.\-Get\-Slice\-Index ()} -\/ Get the slice position in terms of the data extent.  
\item {\ttfamily obj.\-Set\-Slice\-Index (int index)} -\/ Set the slice position in terms of the data extent.  
\item {\ttfamily double = obj.\-Get\-Slice\-Position ()} -\/ Get the position of the slice along its normal.  
\item {\ttfamily obj.\-Set\-Slice\-Position (double position)} -\/ Set the position of the slice along its normal.  
\item {\ttfamily obj.\-Set\-Reslice\-Interpolate (int )} -\/ Set the interpolation to use when texturing the plane.  
\item {\ttfamily int = obj.\-Get\-Reslice\-Interpolate ()} -\/ Set the interpolation to use when texturing the plane.  
\item {\ttfamily obj.\-Set\-Reslice\-Interpolate\-To\-Nearest\-Neighbour ()} -\/ Set the interpolation to use when texturing the plane.  
\item {\ttfamily obj.\-Set\-Reslice\-Interpolate\-To\-Linear ()} -\/ Set the interpolation to use when texturing the plane.  
\item {\ttfamily obj.\-Set\-Reslice\-Interpolate\-To\-Cubic ()} -\/ Convenience method to get the vtk\-Image\-Reslice output.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Reslice\-Output ()} -\/ Convenience method to get the vtk\-Image\-Reslice output.  
\item {\ttfamily obj.\-Set\-Restrict\-Plane\-To\-Volume (int )} -\/ Make sure that the plane remains within the volume. Default is On.  
\item {\ttfamily int = obj.\-Get\-Restrict\-Plane\-To\-Volume ()} -\/ Make sure that the plane remains within the volume. Default is On.  
\item {\ttfamily obj.\-Restrict\-Plane\-To\-Volume\-On ()} -\/ Make sure that the plane remains within the volume. Default is On.  
\item {\ttfamily obj.\-Restrict\-Plane\-To\-Volume\-Off ()} -\/ Make sure that the plane remains within the volume. Default is On.  
\item {\ttfamily obj.\-Set\-User\-Controlled\-Lookup\-Table (int )} -\/ Let the user control the lookup table. N\-O\-T\-E\-: apply this method B\-E\-F\-O\-R\-E applying the Set\-Lookup\-Table method. Default is Off.  
\item {\ttfamily int = obj.\-Get\-User\-Controlled\-Lookup\-Table ()} -\/ Let the user control the lookup table. N\-O\-T\-E\-: apply this method B\-E\-F\-O\-R\-E applying the Set\-Lookup\-Table method. Default is Off.  
\item {\ttfamily obj.\-User\-Controlled\-Lookup\-Table\-On ()} -\/ Let the user control the lookup table. N\-O\-T\-E\-: apply this method B\-E\-F\-O\-R\-E applying the Set\-Lookup\-Table method. Default is Off.  
\item {\ttfamily obj.\-User\-Controlled\-Lookup\-Table\-Off ()} -\/ Let the user control the lookup table. N\-O\-T\-E\-: apply this method B\-E\-F\-O\-R\-E applying the Set\-Lookup\-Table method. Default is Off.  
\item {\ttfamily obj.\-Set\-Texture\-Interpolate (int )} -\/ Specify whether to interpolate the texture or not. When off, the reslice interpolation is nearest neighbour regardless of how the interpolation is set through the A\-P\-I. Set before setting the vtk\-Image\-Data input. Default is On.  
\item {\ttfamily int = obj.\-Get\-Texture\-Interpolate ()} -\/ Specify whether to interpolate the texture or not. When off, the reslice interpolation is nearest neighbour regardless of how the interpolation is set through the A\-P\-I. Set before setting the vtk\-Image\-Data input. Default is On.  
\item {\ttfamily obj.\-Texture\-Interpolate\-On ()} -\/ Specify whether to interpolate the texture or not. When off, the reslice interpolation is nearest neighbour regardless of how the interpolation is set through the A\-P\-I. Set before setting the vtk\-Image\-Data input. Default is On.  
\item {\ttfamily obj.\-Texture\-Interpolate\-Off ()} -\/ Specify whether to interpolate the texture or not. When off, the reslice interpolation is nearest neighbour regardless of how the interpolation is set through the A\-P\-I. Set before setting the vtk\-Image\-Data input. Default is On.  
\item {\ttfamily obj.\-Set\-Texture\-Visibility (int )} -\/ Control the visibility of the actual texture mapped reformatted plane. in some cases you may only want the plane outline for example.  
\item {\ttfamily int = obj.\-Get\-Texture\-Visibility ()} -\/ Control the visibility of the actual texture mapped reformatted plane. in some cases you may only want the plane outline for example.  
\item {\ttfamily obj.\-Texture\-Visibility\-On ()} -\/ Control the visibility of the actual texture mapped reformatted plane. in some cases you may only want the plane outline for example.  
\item {\ttfamily obj.\-Texture\-Visibility\-Off ()} -\/ Control the visibility of the actual texture mapped reformatted plane. in some cases you may only want the plane outline for example.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the plane. The polydata consists of (res+1)$\ast$(res+1) points, and res$\ast$res quadrilateral polygons, where res is the resolution of the plane. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polygons are added to it.  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Poly\-Data\-Algorithm ()} -\/ Satisfies superclass A\-P\-I. This returns a pointer to the underlying vtk\-Poly\-Data. Make changes to this before calling the initial Place\-Widget() to have the initial placement follow suit. Or, make changes after the widget has been initialised and call Update\-Placement() to realise.  
\item {\ttfamily obj.\-Update\-Placement (void )} -\/ Satisfies superclass A\-P\-I. This will change the state of the widget to match changes that have been made to the underlying vtk\-Poly\-Data\-Source  
\item {\ttfamily vtk\-Texture = obj.\-Get\-Texture ()} -\/ Convenience method to get the texture used by this widget. This can be used in external slice viewers.  
\item {\ttfamily vtk\-Image\-Map\-To\-Colors = obj.\-Get\-Color\-Map ()} -\/ Convenience method to get the vtk\-Image\-Map\-To\-Colors filter used by this widget. The user can properly render other transparent actors in a scene by calling the filter's Set\-Output\-Format\-To\-R\-G\-B and Pass\-Alpha\-To\-Output\-Off.  
\item {\ttfamily obj.\-Set\-Color\-Map (vtk\-Image\-Map\-To\-Colors )} -\/ Convenience method to get the vtk\-Image\-Map\-To\-Colors filter used by this widget. The user can properly render other transparent actors in a scene by calling the filter's Set\-Output\-Format\-To\-R\-G\-B and Pass\-Alpha\-To\-Output\-Off.  
\item {\ttfamily obj.\-Set\-Plane\-Property (vtk\-Property )} -\/ Set/\-Get the plane's outline properties. The properties of the plane's outline when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Plane\-Property ()} -\/ Set/\-Get the plane's outline properties. The properties of the plane's outline when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Selected\-Plane\-Property (vtk\-Property )} -\/ Set/\-Get the plane's outline properties. The properties of the plane's outline when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Plane\-Property ()} -\/ Set/\-Get the plane's outline properties. The properties of the plane's outline when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Plane\-Orientation (int )} -\/ Convenience method sets the plane orientation normal to the x, y, or z axes. Default is X\-Axes (0).  
\item {\ttfamily int = obj.\-Get\-Plane\-Orientation ()} -\/ Convenience method sets the plane orientation normal to the x, y, or z axes. Default is X\-Axes (0).  
\item {\ttfamily obj.\-Set\-Plane\-Orientation\-To\-X\-Axes ()} -\/ Convenience method sets the plane orientation normal to the x, y, or z axes. Default is X\-Axes (0).  
\item {\ttfamily obj.\-Set\-Plane\-Orientation\-To\-Y\-Axes ()} -\/ Convenience method sets the plane orientation normal to the x, y, or z axes. Default is X\-Axes (0).  
\item {\ttfamily obj.\-Set\-Plane\-Orientation\-To\-Z\-Axes ()} -\/ Set the internal picker to one defined by the user. In this way, a set of three orthogonal planes can share the same picker so that picking is performed correctly. The default internal picker can be re-\/set/allocated by setting to 0 (N\-U\-L\-L).  
\item {\ttfamily obj.\-Set\-Picker (vtk\-Abstract\-Prop\-Picker )} -\/ Set the internal picker to one defined by the user. In this way, a set of three orthogonal planes can share the same picker so that picking is performed correctly. The default internal picker can be re-\/set/allocated by setting to 0 (N\-U\-L\-L).  
\item {\ttfamily obj.\-Set\-Lookup\-Table (vtk\-Lookup\-Table )} -\/ Set/\-Get the internal lookuptable (lut) to one defined by the user, or, alternatively, to the lut of another vtk\-Imge\-Plane\-Widget. In this way, a set of three orthogonal planes can share the same lut so that window-\/levelling is performed uniformly among planes. The default internal lut can be re-\/ set/allocated by setting to 0 (N\-U\-L\-L).  
\item {\ttfamily vtk\-Lookup\-Table = obj.\-Get\-Lookup\-Table ()} -\/ Set/\-Get the internal lookuptable (lut) to one defined by the user, or, alternatively, to the lut of another vtk\-Imge\-Plane\-Widget. In this way, a set of three orthogonal planes can share the same lut so that window-\/levelling is performed uniformly among planes. The default internal lut can be re-\/ set/allocated by setting to 0 (N\-U\-L\-L).  
\item {\ttfamily obj.\-Set\-Display\-Text (int )} -\/ Enable/disable text display of window-\/level, image coordinates and scalar values in a render window.  
\item {\ttfamily int = obj.\-Get\-Display\-Text ()} -\/ Enable/disable text display of window-\/level, image coordinates and scalar values in a render window.  
\item {\ttfamily obj.\-Display\-Text\-On ()} -\/ Enable/disable text display of window-\/level, image coordinates and scalar values in a render window.  
\item {\ttfamily obj.\-Display\-Text\-Off ()} -\/ Enable/disable text display of window-\/level, image coordinates and scalar values in a render window.  
\item {\ttfamily obj.\-Set\-Cursor\-Property (vtk\-Property )} -\/ Set the properties of the cross-\/hair cursor.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Cursor\-Property ()} -\/ Set the properties of the cross-\/hair cursor.  
\item {\ttfamily obj.\-Set\-Margin\-Property (vtk\-Property )} -\/ Set the properties of the margins.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Margin\-Property ()} -\/ Set the properties of the margins.  
\item {\ttfamily obj.\-Set\-Margin\-Size\-X (double )} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-X\-Min\-Value ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-X\-Max\-Value ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-X ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily obj.\-Set\-Margin\-Size\-Y (double )} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-Y\-Min\-Value ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-Y\-Max\-Value ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily double = obj.\-Get\-Margin\-Size\-Y ()} -\/ Set the size of the margins based on a percentage of the plane's width and height, limited between 0 and 50\%.  
\item {\ttfamily obj.\-Set\-Text\-Property (vtk\-Text\-Property tprop)} -\/ Set/\-Get the text property for the image data and window-\/level annotation.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Text\-Property ()} -\/ Set/\-Get the text property for the image data and window-\/level annotation.  
\item {\ttfamily obj.\-Set\-Texture\-Plane\-Property (vtk\-Property )} -\/ Set/\-Get the property for the resliced image.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Texture\-Plane\-Property ()} -\/ Set/\-Get the property for the resliced image.  
\item {\ttfamily obj.\-Set\-Window\-Level (double window, double level, int copy)} -\/ Set/\-Get the current window and level values. Set\-Window\-Level should only be called after Set\-Input. If a shared lookup table is being used, a callback is required to update the window level values without having to update the lookup table again.  
\item {\ttfamily obj.\-Get\-Window\-Level (double wl\mbox{[}2\mbox{]})} -\/ Set/\-Get the current window and level values. Set\-Window\-Level should only be called after Set\-Input. If a shared lookup table is being used, a callback is required to update the window level values without having to update the lookup table again.  
\item {\ttfamily double = obj.\-Get\-Window ()} -\/ Set/\-Get the current window and level values. Set\-Window\-Level should only be called after Set\-Input. If a shared lookup table is being used, a callback is required to update the window level values without having to update the lookup table again.  
\item {\ttfamily double = obj.\-Get\-Level ()} -\/ Get the image coordinate position and voxel value. Currently only supports single component image data.  
\item {\ttfamily int = obj.\-Get\-Cursor\-Data (double xyzv\mbox{[}4\mbox{]})} -\/ Get the image coordinate position and voxel value. Currently only supports single component image data.  
\item {\ttfamily int = obj.\-Get\-Cursor\-Data\-Status ()} -\/ Get the status of the cursor data. If this returns 1 the Current\-Cursor\-Position and Current\-Image\-Value will have current data. If it returns 0, these values are invalid.  
\item {\ttfamily double = obj. Get\-Current\-Cursor\-Position ()} -\/ Get the current cursor position. To be used in conjunction with Get\-Cursor\-Data\-Status.  
\item {\ttfamily double = obj.\-Get\-Current\-Image\-Value ()} -\/ Get the current image value at the current cursor position. To be used in conjunction with Get\-Cursor\-Data\-Status. The value is V\-T\-K\-\_\-\-D\-O\-U\-B\-L\-E\-\_\-\-M\-A\-X when the data is invalid.  
\item {\ttfamily obj.\-Set\-Use\-Continuous\-Cursor (int )} -\/ Choose between voxel centered or continuous cursor probing. With voxel centered probing, the cursor snaps to the nearest voxel and the reported cursor coordinates are extent based. With continuous probing, voxel data is interpolated using vtk\-Data\-Set\-Attributes' Interpolate\-Point method and the reported coordinates are 3\-D spatial continuous.  
\item {\ttfamily int = obj.\-Get\-Use\-Continuous\-Cursor ()} -\/ Choose between voxel centered or continuous cursor probing. With voxel centered probing, the cursor snaps to the nearest voxel and the reported cursor coordinates are extent based. With continuous probing, voxel data is interpolated using vtk\-Data\-Set\-Attributes' Interpolate\-Point method and the reported coordinates are 3\-D spatial continuous.  
\item {\ttfamily obj.\-Use\-Continuous\-Cursor\-On ()} -\/ Choose between voxel centered or continuous cursor probing. With voxel centered probing, the cursor snaps to the nearest voxel and the reported cursor coordinates are extent based. With continuous probing, voxel data is interpolated using vtk\-Data\-Set\-Attributes' Interpolate\-Point method and the reported coordinates are 3\-D spatial continuous.  
\item {\ttfamily obj.\-Use\-Continuous\-Cursor\-Off ()} -\/ Choose between voxel centered or continuous cursor probing. With voxel centered probing, the cursor snaps to the nearest voxel and the reported cursor coordinates are extent based. With continuous probing, voxel data is interpolated using vtk\-Data\-Set\-Attributes' Interpolate\-Point method and the reported coordinates are 3\-D spatial continuous.  
\item {\ttfamily obj.\-Set\-Interaction (int interact)} -\/ Enable/disable mouse interaction so the widget remains on display.  
\item {\ttfamily int = obj.\-Get\-Interaction ()} -\/ Enable/disable mouse interaction so the widget remains on display.  
\item {\ttfamily obj.\-Interaction\-On ()} -\/ Enable/disable mouse interaction so the widget remains on display.  
\item {\ttfamily obj.\-Interaction\-Off ()} -\/ Enable/disable mouse interaction so the widget remains on display.  
\item {\ttfamily obj.\-Set\-Left\-Button\-Action (int )} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Action\-Min\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Action\-Max\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Action ()} -\/ Set action associated to buttons.  
\item {\ttfamily obj.\-Set\-Middle\-Button\-Action (int )} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Action\-Min\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Action\-Max\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Action ()} -\/ Set action associated to buttons.  
\item {\ttfamily obj.\-Set\-Right\-Button\-Action (int )} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Action\-Min\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Action\-Max\-Value ()} -\/ Set action associated to buttons.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Action ()} -\/ Set action associated to buttons.  
\item {\ttfamily obj.\-Set\-Left\-Button\-Auto\-Modifier (int )} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Auto\-Modifier\-Min\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Auto\-Modifier\-Max\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Left\-Button\-Auto\-Modifier ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily obj.\-Set\-Middle\-Button\-Auto\-Modifier (int )} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Auto\-Modifier\-Min\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Auto\-Modifier\-Max\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Middle\-Button\-Auto\-Modifier ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily obj.\-Set\-Right\-Button\-Auto\-Modifier (int )} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Auto\-Modifier\-Min\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Auto\-Modifier\-Max\-Value ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\item {\ttfamily int = obj.\-Get\-Right\-Button\-Auto\-Modifier ()} -\/ Set the auto-\/modifiers associated to buttons. This allows users to bind some buttons to actions that are usually triggered by a key modifier. For example, if you do not need cursoring, you can bind the left button action to V\-T\-K\-\_\-\-S\-L\-I\-C\-E\-\_\-\-M\-O\-T\-I\-O\-N\-\_\-\-A\-C\-T\-I\-O\-N (see above) and the left button auto modifier to V\-T\-K\-\_\-\-C\-O\-N\-T\-R\-O\-L\-\_\-\-M\-O\-D\-I\-F\-I\-E\-R\-: you end up with the left button controling panning without pressing a key.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimagetracerwidget}{}\section{vtk\-Image\-Tracer\-Widget}\label{vtkwidgets_vtkimagetracerwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Image\-Tracer\-Widget is different from other widgets in three distinct ways\-: 1) any sub-\/class of vtk\-Prop can be input rather than just vtk\-Prop3\-D, so that vtk\-Image\-Actor can be set as the prop and then traced over, 2) the widget fires pick events at the input prop to decide where to move its handles, 3) the widget has 2\-D glyphs for handles instead of 3\-D spheres as is done in other sub-\/classes of vtk3\-D\-Widget. This widget is primarily designed for manually tracing over image data. The button actions and key modifiers are as follows for controlling the widget\-: 1) left button click over the image, hold and drag draws a free hand line. 2) left button click and release erases the widget line, if it exists, and repositions the first handle. 3) middle button click starts a snap drawn line. The line is terminated by clicking the middle button while depressing the ctrl key. 4) when tracing a continuous or snap drawn line, if the last cursor position is within a specified tolerance to the first handle, the widget line will form a closed loop. 5) right button clicking and holding on any handle that is part of a snap drawn line allows handle dragging\-: existing line segments are updated accordingly. If the path is open and Auto\-Close is set to On, the path can be closed by repositioning the first and last points over one another. 6) ctrl key + right button down on any handle will erase it\-: existing snap drawn line segments are updated accordingly. If the line was formed by continous tracing, the line is deleted leaving one handle. 7) shift key + right button down on any snap drawn line segment will insert a handle at the cursor position. The line segment is split accordingly.

To create an instance of class vtk\-Image\-Tracer\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImageTracerWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Image\-Tracer\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Tracer\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Image\-Tracer\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Image\-Tracer\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set/\-Get the handle properties (the 2\-D glyphs are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily obj.\-Set\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties (the 2\-D glyphs are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the 2\-D glyphs are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily obj.\-Set\-Selected\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties (the 2\-D glyphs are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the 2\-D glyphs are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily obj.\-Set\-Line\-Property (vtk\-Property )} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Selected\-Line\-Property (vtk\-Property )} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-View\-Prop (vtk\-Prop prop)} -\/ Set the prop, usually a vtk\-Image\-Actor, to trace over.  
\item {\ttfamily obj.\-Set\-Project\-To\-Plane (int )} -\/ Force handles to be on a specific ortho plane. Default is Off.  
\item {\ttfamily int = obj.\-Get\-Project\-To\-Plane ()} -\/ Force handles to be on a specific ortho plane. Default is Off.  
\item {\ttfamily obj.\-Project\-To\-Plane\-On ()} -\/ Force handles to be on a specific ortho plane. Default is Off.  
\item {\ttfamily obj.\-Project\-To\-Plane\-Off ()} -\/ Force handles to be on a specific ortho plane. Default is Off.  
\item {\ttfamily obj.\-Set\-Projection\-Normal (int )} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Min\-Value ()} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Max\-Value ()} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal ()} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-X\-Axes ()} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Y\-Axes ()} -\/ Set the projection normal. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively. Since the handles are 2\-D glyphs, it is necessary to specify a plane on which to generate them, even though Project\-To\-Plane may be turned off.  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Z\-Axes ()} -\/ Set the position of the widgets' handles in terms of a plane's position. e.\-g., if Projection\-Normal is 0, all of the x-\/coordinate values of the handles are set to Projection\-Position. No attempt is made to ensure that the position is within the bounds of either the underlying image data or the prop on which tracing is performed.  
\item {\ttfamily obj.\-Set\-Projection\-Position (double position)} -\/ Set the position of the widgets' handles in terms of a plane's position. e.\-g., if Projection\-Normal is 0, all of the x-\/coordinate values of the handles are set to Projection\-Position. No attempt is made to ensure that the position is within the bounds of either the underlying image data or the prop on which tracing is performed.  
\item {\ttfamily double = obj.\-Get\-Projection\-Position ()} -\/ Set the position of the widgets' handles in terms of a plane's position. e.\-g., if Projection\-Normal is 0, all of the x-\/coordinate values of the handles are set to Projection\-Position. No attempt is made to ensure that the position is within the bounds of either the underlying image data or the prop on which tracing is performed.  
\item {\ttfamily obj.\-Set\-Snap\-To\-Image (int snap)} -\/ Force snapping to image data while tracing. Default is Off.  
\item {\ttfamily int = obj.\-Get\-Snap\-To\-Image ()} -\/ Force snapping to image data while tracing. Default is Off.  
\item {\ttfamily obj.\-Snap\-To\-Image\-On ()} -\/ Force snapping to image data while tracing. Default is Off.  
\item {\ttfamily obj.\-Snap\-To\-Image\-Off ()} -\/ Force snapping to image data while tracing. Default is Off.  
\item {\ttfamily obj.\-Set\-Auto\-Close (int )} -\/ In concert with a Capture\-Radius value, automatically form a closed path by connecting first to last path points. Default is Off.  
\item {\ttfamily int = obj.\-Get\-Auto\-Close ()} -\/ In concert with a Capture\-Radius value, automatically form a closed path by connecting first to last path points. Default is Off.  
\item {\ttfamily obj.\-Auto\-Close\-On ()} -\/ In concert with a Capture\-Radius value, automatically form a closed path by connecting first to last path points. Default is Off.  
\item {\ttfamily obj.\-Auto\-Close\-Off ()} -\/ In concert with a Capture\-Radius value, automatically form a closed path by connecting first to last path points. Default is Off.  
\item {\ttfamily obj.\-Set\-Capture\-Radius (double )} -\/ Set/\-Get the capture radius for automatic path closing. For image data, capture radius should be half the distance between voxel/pixel centers. Default is 1.\-0  
\item {\ttfamily double = obj.\-Get\-Capture\-Radius ()} -\/ Set/\-Get the capture radius for automatic path closing. For image data, capture radius should be half the distance between voxel/pixel centers. Default is 1.\-0  
\item {\ttfamily obj.\-Get\-Path (vtk\-Poly\-Data pd)} -\/ Grab the points and lines that define the traced path. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and cells representing the line are added to it.  
\item {\ttfamily vtk\-Glyph\-Source2\-D = obj.\-Get\-Glyph\-Source ()} -\/ Set/\-Get the type of snapping to image data\-: center of a pixel/voxel or nearest point defining a pixel/voxel.  
\item {\ttfamily obj.\-Set\-Image\-Snap\-Type (int )} -\/ Set/\-Get the type of snapping to image data\-: center of a pixel/voxel or nearest point defining a pixel/voxel.  
\item {\ttfamily int = obj.\-Get\-Image\-Snap\-Type\-Min\-Value ()} -\/ Set/\-Get the type of snapping to image data\-: center of a pixel/voxel or nearest point defining a pixel/voxel.  
\item {\ttfamily int = obj.\-Get\-Image\-Snap\-Type\-Max\-Value ()} -\/ Set/\-Get the type of snapping to image data\-: center of a pixel/voxel or nearest point defining a pixel/voxel.  
\item {\ttfamily int = obj.\-Get\-Image\-Snap\-Type ()} -\/ Set/\-Get the type of snapping to image data\-: center of a pixel/voxel or nearest point defining a pixel/voxel.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the handle position in terms of a zero-\/based array of handles.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double x, double y, double z)} -\/ Set/\-Get the handle position in terms of a zero-\/based array of handles.  
\item {\ttfamily obj.\-Get\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the handle position in terms of a zero-\/based array of handles.  
\item {\ttfamily double = obj.\-Get\-Handle\-Position (int handle)} -\/ Set/\-Get the handle position in terms of a zero-\/based array of handles.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Handles ()} -\/ Get the number of handles.  
\item {\ttfamily obj.\-Set\-Interaction (int interact)} -\/ Enable/disable mouse interaction when the widget is visible.  
\item {\ttfamily int = obj.\-Get\-Interaction ()} -\/ Enable/disable mouse interaction when the widget is visible.  
\item {\ttfamily obj.\-Interaction\-On ()} -\/ Enable/disable mouse interaction when the widget is visible.  
\item {\ttfamily obj.\-Interaction\-Off ()} -\/ Enable/disable mouse interaction when the widget is visible.  
\item {\ttfamily obj.\-Initialize\-Handles (vtk\-Points )} -\/ Initialize the widget with a set of points and generate lines between them. If Auto\-Close is on it will handle the case wherein the first and last points are congruent.  
\item {\ttfamily int = obj.\-Is\-Closed ()} -\/ Is the path closed or open?  
\item {\ttfamily obj.\-Set\-Prop (vtk\-Prop prop)} -\/  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimplicitplanerepresentation}{}\section{vtk\-Implicit\-Plane\-Representation}\label{vtkwidgets_vtkimplicitplanerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a concrete representation for the vtk\-Implicit\-Plane\-Widget2. It represents an infinite plane defined by a normal and point in the context of a bounding box. Through interaction with the widget, the plane can be manipulated by adjusting the plane normal or moving the origin point.

To use this representation, you normally define a (plane) origin and (plane) normal. The Place\-Widget() method is also used to intially position the representation.

To create an instance of class vtk\-Implicit\-Plane\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitPlaneRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Plane\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Plane\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Implicit\-Plane\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Implicit\-Plane\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Set\-Origin (double x, double y, double z)} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double x\mbox{[}3\mbox{]})} -\/ Get the origin of the plane.  
\item {\ttfamily double = obj.\-Get\-Origin ()} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Get\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x, double y, double z)} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily double = obj.\-Get\-Normal ()} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Get\-Normal (double xyz\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Normal\-To\-X\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-X\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Y\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Y\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Z\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Z\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Tubing (int )} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily int = obj.\-Get\-Tubing ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Tubing\-On ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Tubing\-Off ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Set\-Draw\-Plane (int plane)} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily int = obj.\-Get\-Draw\-Plane ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Draw\-Plane\-On ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Draw\-Plane\-Off ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Set\-Outline\-Translation (int )} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily int = obj.\-Get\-Outline\-Translation ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Outline\-Translation\-On ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Outline\-Translation\-Off ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Set\-Outside\-Bounds (int )} -\/ Turn on/off the ability to move the widget outside of the bounds specified in the initial Place\-Widget() invocation.  
\item {\ttfamily int = obj.\-Get\-Outside\-Bounds ()} -\/ Turn on/off the ability to move the widget outside of the bounds specified in the initial Place\-Widget() invocation.  
\item {\ttfamily obj.\-Outside\-Bounds\-On ()} -\/ Turn on/off the ability to move the widget outside of the bounds specified in the initial Place\-Widget() invocation.  
\item {\ttfamily obj.\-Outside\-Bounds\-Off ()} -\/ Turn on/off the ability to move the widget outside of the bounds specified in the initial Place\-Widget() invocation.  
\item {\ttfamily obj.\-Set\-Scale\-Enabled (int )} -\/ Turn on/off the ability to scale the widget with the mouse.  
\item {\ttfamily int = obj.\-Get\-Scale\-Enabled ()} -\/ Turn on/off the ability to scale the widget with the mouse.  
\item {\ttfamily obj.\-Scale\-Enabled\-On ()} -\/ Turn on/off the ability to scale the widget with the mouse.  
\item {\ttfamily obj.\-Scale\-Enabled\-Off ()} -\/ Turn on/off the ability to scale the widget with the mouse.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata that defines the plane. The polydata contains a single polygon that is clipped by the bounding box.  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Poly\-Data\-Algorithm ()} -\/ Satisfies superclass A\-P\-I. This returns a pointer to the underlying Poly\-Data (which represents the plane).  
\item {\ttfamily obj.\-Get\-Plane (vtk\-Plane plane)} -\/ Get the implicit function for the plane. The user must provide the instance of the class vtk\-Plane. Note that vtk\-Plane is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data.  
\item {\ttfamily obj.\-Update\-Placement (void )} -\/ Satisfies the superclass A\-P\-I. This will change the state of the widget to match changes that have been made to the underlying Poly\-Data\-Source  
\item {\ttfamily vtk\-Property = obj.\-Get\-Normal\-Property ()} -\/ Get the properties on the normal (line and cone).  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Normal\-Property ()} -\/ Get the properties on the normal (line and cone).  
\item {\ttfamily vtk\-Property = obj.\-Get\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Outline\-Property ()} -\/ Get the property of the outline.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Outline\-Property ()} -\/ Get the property of the outline.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Edges\-Property ()} -\/ Get the property of the intersection edges. (This property also applies to the edges when tubed.)  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-End\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily double = obj.\-Get\-Bounds ()}  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection pc)}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()}  
\item {\ttfamily obj.\-Set\-Interaction\-State (int )} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Implicit\-Plane\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Min\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Implicit\-Plane\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Max\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Implicit\-Plane\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily obj.\-Set\-Representation\-State (int )} -\/ Sets the visual appearance of the representation based on the state it is in. This state is usually the same as Interaction\-State.  
\item {\ttfamily int = obj.\-Get\-Representation\-State ()} -\/ Sets the visual appearance of the representation based on the state it is in. This state is usually the same as Interaction\-State.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimplicitplanewidget}{}\section{vtk\-Implicit\-Plane\-Widget}\label{vtkwidgets_vtkimplicitplanewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines an infinite plane that can be interactively placed in a scene. The widget is represented by a plane with a normal vector; the plane is contained by a bounding box, and where the plane intersects the bounding box the edges are shown (possibly tubed). The normal can be selected and moved to rotate the plane; the plane itself can be selected and translated in various directions. As the plane is moved, the implicit plane function and polygon (representing the plane cut against the bounding box) is updated.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. If the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, the vtk\-Implicit\-Plane\-Widget will appear. (See superclass documentation for information about changing this behavior.) If you select the normal vector, the plane can be arbitrarily rotated. The plane can be translated along the normal by selecting the plane and moving it. The plane (the plane origin) can also be arbitrary moved by selecting the plane with the middle mouse button. The right mouse button can be used to uniformly scale the bounding box (moving \char`\"{}up\char`\"{} the box scales larger; moving \char`\"{}down\char`\"{} the box scales smaller). Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method).

The vtk\-Implicit\-Plane\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Get\-Poly\-Data() method can be used to get a polygonal representation (the single polygon clipped by the bounding box). Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button). (Note\-: there is also a Place\-Widget\-Event that is invoked when the widget is placed with Place\-Widget().)

Some additional features of this class include the ability to control the properties of the widget. You do this by setting property values on the normal vector (selected and unselected properties); the plane (selected and unselected properties); the outline (selected and unselected properties); and the edges. The edges may also be tubed or not.

To create an instance of class vtk\-Implicit\-Plane\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitPlaneWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Plane\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Plane\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Implicit\-Plane\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Implicit\-Plane\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double x, double y, double z)} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double x\mbox{[}3\mbox{]})} -\/ Get the origin of the plane.  
\item {\ttfamily double = obj.\-Get\-Origin ()} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Get\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x, double y, double z)} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily double = obj.\-Get\-Normal ()} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Get\-Normal (double xyz\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Normal\-To\-X\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-X\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Y\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Y\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Z\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Z\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. If one axis is set on, the other two will be set off. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Tubing (int )} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily int = obj.\-Get\-Tubing ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Tubing\-On ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Tubing\-Off ()} -\/ Turn on/off tubing of the wire outline of the plane. The tube thickens the line by wrapping with a vtk\-Tube\-Filter.  
\item {\ttfamily obj.\-Set\-Draw\-Plane (int plane)} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily int = obj.\-Get\-Draw\-Plane ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Draw\-Plane\-On ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Draw\-Plane\-Off ()} -\/ Enable/disable the drawing of the plane. In some cases the plane interferes with the object that it is operating on (i.\-e., the plane interferes with the cut surface it produces producing z-\/buffer artifacts.)  
\item {\ttfamily obj.\-Set\-Outline\-Translation (int )} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily int = obj.\-Get\-Outline\-Translation ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Outline\-Translation\-On ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Outline\-Translation\-Off ()} -\/ Turn on/off the ability to translate the bounding box by grabbing it with the left mouse button.  
\item {\ttfamily obj.\-Set\-Outside\-Bounds (int )} -\/ Turn on/off the ability to move the widget outside of the input's bound  
\item {\ttfamily int = obj.\-Get\-Outside\-Bounds ()} -\/ Turn on/off the ability to move the widget outside of the input's bound  
\item {\ttfamily obj.\-Outside\-Bounds\-On ()} -\/ Turn on/off the ability to move the widget outside of the input's bound  
\item {\ttfamily obj.\-Outside\-Bounds\-Off ()} -\/ Turn on/off the ability to move the widget outside of the input's bound  
\item {\ttfamily obj.\-Set\-Scale\-Enabled (int )} -\/ Turn on/off the ability to scale with the mouse  
\item {\ttfamily int = obj.\-Get\-Scale\-Enabled ()} -\/ Turn on/off the ability to scale with the mouse  
\item {\ttfamily obj.\-Scale\-Enabled\-On ()} -\/ Turn on/off the ability to scale with the mouse  
\item {\ttfamily obj.\-Scale\-Enabled\-Off ()} -\/ Turn on/off the ability to scale with the mouse  
\item {\ttfamily obj.\-Set\-Origin\-Translation (int )} -\/ Turn on/off the ability to translate the origin (sphere) with the left mouse button.  
\item {\ttfamily int = obj.\-Get\-Origin\-Translation ()} -\/ Turn on/off the ability to translate the origin (sphere) with the left mouse button.  
\item {\ttfamily obj.\-Origin\-Translation\-On ()} -\/ Turn on/off the ability to translate the origin (sphere) with the left mouse button.  
\item {\ttfamily obj.\-Origin\-Translation\-Off ()} -\/ Turn on/off the ability to translate the origin (sphere) with the left mouse button.  
\item {\ttfamily obj.\-Set\-Diagonal\-Ratio (double )} -\/ By default the arrow is 30\% of the diagonal length. Diagonal\-Ratio control this ratio in the interval \mbox{[}0-\/2\mbox{]}  
\item {\ttfamily double = obj.\-Get\-Diagonal\-Ratio\-Min\-Value ()} -\/ By default the arrow is 30\% of the diagonal length. Diagonal\-Ratio control this ratio in the interval \mbox{[}0-\/2\mbox{]}  
\item {\ttfamily double = obj.\-Get\-Diagonal\-Ratio\-Max\-Value ()} -\/ By default the arrow is 30\% of the diagonal length. Diagonal\-Ratio control this ratio in the interval \mbox{[}0-\/2\mbox{]}  
\item {\ttfamily double = obj.\-Get\-Diagonal\-Ratio ()} -\/ By default the arrow is 30\% of the diagonal length. Diagonal\-Ratio control this ratio in the interval \mbox{[}0-\/2\mbox{]}  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata that defines the plane. The polydata contains a single polygon that is clipped by the bounding box.  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Poly\-Data\-Algorithm ()} -\/ Satisfies superclass A\-P\-I. This returns a pointer to the underlying Poly\-Data (which represents the plane).  
\item {\ttfamily obj.\-Get\-Plane (vtk\-Plane plane)} -\/ Get the implicit function for the plane. The user must provide the instance of the class vtk\-Plane. Note that vtk\-Plane is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data.  
\item {\ttfamily obj.\-Update\-Placement ()} -\/ Satisfies the superclass A\-P\-I. This will change the state of the widget to match changes that have been made to the underlying Poly\-Data\-Source  
\item {\ttfamily obj.\-Size\-Handles ()} -\/ Control widget appearance  
\item {\ttfamily vtk\-Property = obj.\-Get\-Normal\-Property ()} -\/ Get the properties on the normal (line and cone).  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Normal\-Property ()} -\/ Get the properties on the normal (line and cone).  
\item {\ttfamily vtk\-Property = obj.\-Get\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Outline\-Property ()} -\/ Get the property of the outline.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Outline\-Property ()} -\/ Get the property of the outline.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Edges\-Property ()} -\/ Get the property of the intersection edges. (This property also applies to the edges when tubed.)  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkimplicitplanewidget2}{}\section{vtk\-Implicit\-Plane\-Widget2}\label{vtkwidgets_vtkimplicitplanewidget2}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines an infinite plane that can be interactively placed in a scene. The widget is assumed to consist of four parts\-: 1) a plane contained in a 2) bounding box, with a 3) plane normal, which is rooted at a 4) point on the plane. (The representation paired with this widget determines the actual geometry of the widget.)

To use this widget, you generally pair it with a vtk\-Implicit\-Plane\-Representation (or a subclass). Variuos options are available for controlling how the representation appears, and how the widget functions.

To create an instance of class vtk\-Implicit\-Plane\-Widget2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkImplicitPlaneWidget2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Implicit\-Plane\-Widget2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Implicit\-Plane\-Widget2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard vtk\-Object methods  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard vtk\-Object methods  
\item {\ttfamily vtk\-Implicit\-Plane\-Widget2 = obj.\-New\-Instance ()} -\/ Standard vtk\-Object methods  
\item {\ttfamily vtk\-Implicit\-Plane\-Widget2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard vtk\-Object methods  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Implicit\-Plane\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklinearcontourlineinterpolator}{}\section{vtk\-Linear\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtklinearcontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The line interpolator interpolates supplied nodes (see Interpolate\-Line) with line segments. The finess of the curve may be controlled using Set\-Maximum\-Curve\-Error and Set\-Maximum\-Number\-Of\-Line\-Segments.

To create an instance of class vtk\-Linear\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLinearContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Linear\-Contour\-Line\-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\-Linear\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Linear\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Linear\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklinerepresentation}{}\section{vtk\-Line\-Representation}\label{vtkwidgets_vtklinerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a concrete representation for the vtk\-Line\-Widget2. It represents a straight line with three handles\-: one at the beginning and ending of the line, and one used to translate the line. Through interaction with the widget, the line representation can be arbitrarily placed in the 3\-D space.

To use this representation, you normally specify the position of the two end points (either in world or display coordinates). The Place\-Widget() method is also used to intially position the representation.

To create an instance of class vtk\-Line\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLineRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Line\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Line\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Line\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Get\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point1\-World\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point1\-Display\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point1\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point2\-Display\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Get\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily double = obj.\-Get\-Point2\-World\-Position ()} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-World\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Point2\-Display\-Position (double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of the two points defining this representation. Note that methods are available for both display and world coordinates.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Point\-Handle\-Representation3\-D handle)} -\/ This method is used to specify the type of handle representation to use for the three internal vtk\-Handle\-Widgets within vtk\-Line\-Widget2. To use this method, create a dummy vtk\-Handle\-Widget (or subclass), and then invoke this method with this dummy. Then the vtk\-Line\-Representation uses this dummy to clone three vtk\-Handle\-Widgets of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Line\-Widget2.)  
\item {\ttfamily obj.\-Instantiate\-Handle\-Representation ()} -\/ This method is used to specify the type of handle representation to use for the three internal vtk\-Handle\-Widgets within vtk\-Line\-Widget2. To use this method, create a dummy vtk\-Handle\-Widget (or subclass), and then invoke this method with this dummy. Then the vtk\-Line\-Representation uses this dummy to clone three vtk\-Handle\-Widgets of the same type. Make sure you set the handle representation before the widget is enabled. (The method Instantiate\-Handle\-Representation() is invoked by the vtk\-Line\-Widget2.)  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-Get\-Point1\-Representation ()} -\/ Get the three handle representations used for the vtk\-Line\-Widget2.  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-Get\-Point2\-Representation ()} -\/ Get the three handle representations used for the vtk\-Line\-Widget2.  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-Get\-Line\-Handle\-Representation ()} -\/ Get the three handle representations used for the vtk\-Line\-Widget2.  
\item {\ttfamily vtk\-Property = obj.\-Get\-End\-Point\-Property ()} -\/ Get the end-\/point (sphere) properties. The properties of the end-\/points when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-End\-Point\-Property ()} -\/ Get the end-\/point (sphere) properties. The properties of the end-\/points when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-End\-Point2\-Property ()} -\/ Get the end-\/point (sphere) properties. The properties of the end-\/points when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-End\-Point2\-Property ()} -\/ Get the end-\/point (sphere) properties. The properties of the end-\/points when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Line\-Property ()} -\/ Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Line\-Property ()} -\/ Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the line or end point to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the line or end point to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the line or end point to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the line or end point to be active.  
\item {\ttfamily obj.\-Set\-Resolution (int res)} -\/ Set/\-Get the resolution (number of subdivisions) of the line. A line with resolution greater than one is useful when points along the line are desired; e.\-g., generating a rake of streamlines.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the resolution (number of subdivisions) of the line. A line with resolution greater than one is useful when points along the line are desired; e.\-g., generating a rake of streamlines.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Retrieve the polydata (including points) that defines the line. The polydata consists of n+1 points, where n is the resolution of the line. These point values are guaranteed to be up-\/to-\/date whenever any one of the three handles are moved. To use this method, the user provides the vtk\-Poly\-Data as an input argument, and the points and polyline are copied into it.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection pc)} -\/ Methods supporting the rendering process.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods supporting the rendering process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods supporting the rendering process.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods supporting the rendering process.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods supporting the rendering process.  
\item {\ttfamily obj.\-Set\-Interaction\-State (int )} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Line\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Min\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Line\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State\-Max\-Value ()} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Line\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily obj.\-Set\-Representation\-State (int )} -\/ Sets the visual appearance of the representation based on the state it is in. This state is usually the same as Interaction\-State.  
\item {\ttfamily int = obj.\-Get\-Representation\-State ()} -\/ Sets the visual appearance of the representation based on the state it is in. This state is usually the same as Interaction\-State.  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Overload the superclasses' Get\-M\-Time() because internal classes are used to keep the state of the representation.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Overridden to set the rendererer on the internal representations.  
\item {\ttfamily obj.\-Set\-Distance\-Annotation\-Visibility (int )} -\/ Show the distance between the points  
\item {\ttfamily int = obj.\-Get\-Distance\-Annotation\-Visibility ()} -\/ Show the distance between the points  
\item {\ttfamily obj.\-Distance\-Annotation\-Visibility\-On ()} -\/ Show the distance between the points  
\item {\ttfamily obj.\-Distance\-Annotation\-Visibility\-Off ()} -\/ Show the distance between the points  
\item {\ttfamily obj.\-Set\-Distance\-Annotation\-Format (string )} -\/ Specify the format to use for labelling the angle. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the angle value.  
\item {\ttfamily string = obj.\-Get\-Distance\-Annotation\-Format ()} -\/ Specify the format to use for labelling the angle. Note that an empty string results in no label, or a format string without a \char`\"{}\%\char`\"{} character will not print the angle value.  
\item {\ttfamily obj.\-Set\-Distance\-Annotation\-Scale (double scale\mbox{[}3\mbox{]})} -\/ Scale text (font size along each dimension).  
\item {\ttfamily double = obj.\-Get\-Distance ()} -\/ Get the distance between the points.  
\item {\ttfamily obj.\-Set\-Line\-Color (double r, double g, double b)} -\/ Convenience method to set the line color. Ideally one should use Get\-Line\-Property()-\/$>$Set\-Color().  
\item {\ttfamily vtk\-Property = obj.\-Get\-Distance\-Annotation\-Property ()} -\/ Get the distance annotation property  
\item {\ttfamily vtk\-Follower = obj.\-Get\-Text\-Actor ()} -\/ Get the text actor  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklinewidget}{}\section{vtk\-Line\-Widget}\label{vtkwidgets_vtklinewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a line that can be interactively placed in a scene. The line has two handles (at its endpoints), plus the line can be picked to translate it in the scene. A nice feature of the object is that the vtk\-Line\-Widget, like any 3\-D widget, will work with the current interactor style and any other widgets present in the scene. That is, if vtk\-Line\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Line\-Widget will terminate the processing of the event that it handles.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. The interactor will act normally until the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, at which point the vtk\-Line\-Widget will appear. (See superclass documentation for information about changing this behavior.) By grabbing one of the two end point handles (use the left mouse button), the line can be oriented and stretched (the other end point remains fixed). By grabbing the line itself, or using the middle mouse button, the entire line can be translated. Scaling (about the center of the line) is achieved by using the right mouse button. By moving the mouse \char`\"{}up\char`\"{} the render window the line will be made bigger; by moving \char`\"{}down\char`\"{} the render window the widget will be made smaller. Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method). (Note\-: picking the line or either one of the two end point handles causes a vtk\-Point\-Widget to appear. This widget has the ability to constrain motion to an axis by pressing the \char`\"{}shift\char`\"{} key while moving the mouse.)

The vtk\-Line\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Set/\-Get\-Resolution() methods control the number of subdivisions of the line; the Get\-Poly\-Data() method can be used to get the polygonal representation and can be used for things like seeding streamlines. Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button).

Some additional features of this class include the ability to control the properties of the widget. You can set the properties of the selected and unselected representations of the line. For example, you can set the property for the handles and line. In addition there are methods to constrain the line so that it is aligned along the x-\/y-\/z axes.

To create an instance of class vtk\-Line\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLineWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Line\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Line\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Line\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set/\-Get the resolution (number of subdivisions) of the line.  
\item {\ttfamily obj.\-Set\-Resolution (int r)} -\/ Set/\-Get the resolution (number of subdivisions) of the line.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the position of first end point.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y, double z)} -\/ Set/\-Get the position of first end point.  
\item {\ttfamily obj.\-Set\-Point1 (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of first end point.  
\item {\ttfamily double = obj.\-Get\-Point1 ()} -\/ Set/\-Get the position of first end point.  
\item {\ttfamily obj.\-Get\-Point1 (double xyz\mbox{[}3\mbox{]})} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y, double z)} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Set\-Point2 (double x\mbox{[}3\mbox{]})} -\/ Set position of other end point.  
\item {\ttfamily double = obj.\-Get\-Point2 ()} -\/ Set position of other end point.  
\item {\ttfamily obj.\-Get\-Point2 (double xyz\mbox{[}3\mbox{]})} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Align (int )} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Align\-Min\-Value ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Align\-Max\-Value ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Align ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Align\-To\-X\-Axis ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Align\-To\-Y\-Axis ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Align\-To\-Z\-Axis ()} -\/ Force the line widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the line to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Align\-To\-None ()} -\/ Enable/disable clamping of the point end points to the bounding box of the data. The bounding box is defined from the last Place\-Widget() invocation, and includes the effect of the Place\-Factor which is used to gram/shrink the bounding box.  
\item {\ttfamily obj.\-Set\-Clamp\-To\-Bounds (int )} -\/ Enable/disable clamping of the point end points to the bounding box of the data. The bounding box is defined from the last Place\-Widget() invocation, and includes the effect of the Place\-Factor which is used to gram/shrink the bounding box.  
\item {\ttfamily int = obj.\-Get\-Clamp\-To\-Bounds ()} -\/ Enable/disable clamping of the point end points to the bounding box of the data. The bounding box is defined from the last Place\-Widget() invocation, and includes the effect of the Place\-Factor which is used to gram/shrink the bounding box.  
\item {\ttfamily obj.\-Clamp\-To\-Bounds\-On ()} -\/ Enable/disable clamping of the point end points to the bounding box of the data. The bounding box is defined from the last Place\-Widget() invocation, and includes the effect of the Place\-Factor which is used to gram/shrink the bounding box.  
\item {\ttfamily obj.\-Clamp\-To\-Bounds\-Off ()} -\/ Enable/disable clamping of the point end points to the bounding box of the data. The bounding box is defined from the last Place\-Widget() invocation, and includes the effect of the Place\-Factor which is used to gram/shrink the bounding box.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the line. The polydata consists of n+1 points, where n is the resolution of the line. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polyline are added to it.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Line\-Property ()} -\/ Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Line\-Property ()} -\/ Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklinewidget2}{}\section{vtk\-Line\-Widget2}\label{vtkwidgets_vtklinewidget2}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a straight line that can be interactively placed in a scene. The widget is assumed to consist of two parts\-: 1) two end points and 2) a straight line connecting the two points. (The representation paired with this widget determines the actual geometry of the widget.) The positioning of the two end points is facilitated by using vtk\-Handle\-Widgets to position the points.

To use this widget, you generally pair it with a vtk\-Line\-Representation (or a subclass). Variuos options are available in the representation for controlling how the widget appears, and how the widget functions.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If one of the two end points are selected:
   LeftButtonPressEvent - activate the associated handle widget
   LeftButtonReleaseEvent - release the handle widget associated with the point
   MouseMoveEvent - move the point
 If the line is selected:
   LeftButtonPressEvent - activate a handle widget accociated with the line 
   LeftButtonReleaseEvent - release the handle widget associated with the line
   MouseMoveEvent - translate the line
 In all the cases, independent of what is picked, the widget responds to the 
 following VTK events:
   MiddleButtonPressEvent - translate the widget
   MiddleButtonReleaseEvent - release the widget
   RightButtonPressEvent - scale the widget's representation
   RightButtonReleaseEvent - stop scaling the widget
   MouseMoveEvent - scale (if right button) or move (if middle button) the widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Line\-Widget2's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for slider motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Line\-Widget2 invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Line\-Widget2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLineWidget2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Line\-Widget2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard vtk\-Object methods  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard vtk\-Object methods  
\item {\ttfamily vtk\-Line\-Widget2 = obj.\-New\-Instance ()} -\/ Standard vtk\-Object methods  
\item {\ttfamily vtk\-Line\-Widget2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard vtk\-Object methods  
\item {\ttfamily obj.\-Set\-Enabled (int enabling)} -\/ Override superclasses' Set\-Enabled() method because the line widget must enable its internal handle widgets.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Line\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklogorepresentation}{}\section{vtk\-Logo\-Representation}\label{vtkwidgets_vtklogorepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
To create an instance of class vtk\-Logo\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLogoRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Logo\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Logo\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Logo\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Logo\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Image (vtk\-Image\-Data img)} -\/ Specify/retrieve the image to display in the balloon.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Image ()} -\/ Specify/retrieve the image to display in the balloon.  
\item {\ttfamily obj.\-Set\-Image\-Property (vtk\-Property2\-D p)} -\/ Set/get the image property (relevant only if an image is shown).  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Image\-Property ()} -\/ Set/get the image property (relevant only if an image is shown).  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclasses' A\-P\-I.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection pc)} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtklogowidget}{}\section{vtk\-Logo\-Widget}\label{vtkwidgets_vtklogowidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively displaying and manipulating a logo. Logos are defined by an image; this widget simply allows you to interactively place and resize the image logo. To use this widget, simply create a vtk\-Logo\-Representation (or subclass) and associate it with the vtk\-Logo\-Widget.

To create an instance of class vtk\-Logo\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkLogoWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Logo\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Logo\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Logo\-Widget = obj.\-New\-Instance ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Logo\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Logo\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkorientationmarkerwidget}{}\section{vtk\-Orientation\-Marker\-Widget}\label{vtkwidgets_vtkorientationmarkerwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively manipulating the position, size, and apparent orientation of a prop that represents an orientation marker. This class works by adding its internal renderer to an external \char`\"{}parent\char`\"{} renderer on a different layer. The input orientation marker is rendered as an overlay on the parent renderer and, thus, appears superposed over all props in the parent's scene. The camera view of the orientation the marker is made to match that of the parent's by means of an observer mechanism, giving the illusion that the orientation of the marker reflects that of the prop(s) in the parent's scene.

The widget listens to left mouse button and mouse movement events. It will change the cursor shape based on its location. If the cursor is over the overlay renderer, it will change the cursor shape to a S\-I\-Z\-E\-A\-L\-L shape or to a resize corner shape (e.\-g., S\-I\-Z\-E\-N\-W) if the cursor is near a corner. If the left mouse button is pressed and held down while moving, the overlay renderer, and hence, the orientation marker, is resized or moved. I the case of a resize operation, releasing the left mouse button causes the widget to enforce its renderer to be square. The diagonally opposite corner to the one moved is repositioned such that all edges of the renderer have the same length\-: the minimum.

To use this object, there are two key steps\-: 1) invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor, and 2) invoke Set\-Orientation\-Marker with an instance of vtk\-Prop (see caveats below). Specifically, vtk\-Axes\-Actor and vtk\-Annotated\-Cube\-Actor are two classes designed to work with this class. A composite orientation marker can be generated by adding instances of vtk\-Axes\-Actor and vtk\-Annotated\-Cube\-Actor to a vtk\-Prop\-Assembly, which can then be set as the input orientation marker. The widget can be also be set up in a non-\/interactive fashion by setting Ineractive to Off and sizing/placing the overlay renderer in its parent renderer by calling the widget's Set\-Viewport method.

To create an instance of class vtk\-Orientation\-Marker\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOrientationMarkerWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Orientation\-Marker\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Orientation\-Marker\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Orientation\-Marker\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Orientation\-Marker\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Orientation\-Marker (vtk\-Prop prop)} -\/ Set/get the orientation marker to be displayed in this widget.  
\item {\ttfamily vtk\-Prop = obj.\-Get\-Orientation\-Marker ()} -\/ Set/get the orientation marker to be displayed in this widget.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Enable/disable the widget. Default is 0 (disabled).  
\item {\ttfamily obj.\-Set\-Interactive (int state)} -\/ Set/get whether to allow this widget to be interactively moved/scaled. Default is On.  
\item {\ttfamily int = obj.\-Get\-Interactive ()} -\/ Set/get whether to allow this widget to be interactively moved/scaled. Default is On.  
\item {\ttfamily obj.\-Interactive\-On ()} -\/ Set/get whether to allow this widget to be interactively moved/scaled. Default is On.  
\item {\ttfamily obj.\-Interactive\-Off ()} -\/ Set/get whether to allow this widget to be interactively moved/scaled. Default is On.  
\item {\ttfamily obj.\-Set\-Outline\-Color (double r, double g, double b)} -\/ Set/get the color of the outline of this widget. The outline is visible when (in interactive mode) the cursor is over this widget. Default is white (1,1,1).  
\item {\ttfamily obj.\-Set\-Viewport (double min\-X, double min\-Y, double max\-X, double max\-Y)} -\/ Set/get the viewport to position/size this widget. Default is bottom left corner (0,0,0.\-2,0.\-2).  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkorientedglyphcontourrepresentation}{}\section{vtk\-Oriented\-Glyph\-Contour\-Representation}\label{vtkwidgets_vtkorientedglyphcontourrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides the default concrete representation for the vtk\-Contour\-Widget. It works in conjunction with the vtk\-Contour\-Line\-Interpolator and vtk\-Point\-Placer. See vtk\-Contour\-Widget for details.

To create an instance of class vtk\-Oriented\-Glyph\-Contour\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOrientedGlyphContourRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Oriented\-Glyph\-Contour\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Oriented\-Glyph\-Contour\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Glyph\-Contour\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Glyph\-Contour\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Cursor\-Shape (vtk\-Poly\-Data cursor\-Shape)} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Cursor\-Shape ()} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily obj.\-Set\-Active\-Cursor\-Shape (vtk\-Poly\-Data active\-Shape)} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Active\-Cursor\-Shape ()} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ This is the property used when the handle is not active (the mouse is not near the handle)  
\item {\ttfamily vtk\-Property = obj.\-Get\-Active\-Property ()} -\/ This is the property used when the user is interacting with the handle.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Lines\-Property ()} -\/ This is the property used by the lines.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Subclasses of vtk\-Oriented\-Glyph\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Oriented\-Glyph\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Oriented\-Glyph\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Oriented\-Glyph\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modified)} -\/ Subclasses of vtk\-Oriented\-Glyph\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Contour\-Representation\-As\-Poly\-Data ()} -\/ Get the points in this contour as a vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Always\-On\-Top (int )} -\/ Controls whether the contour widget should always appear on top of other actors in the scene. (In effect, this will disable Open\-G\-L Depth buffer tests while rendering the contour). Default is to set it to false.  
\item {\ttfamily int = obj.\-Get\-Always\-On\-Top ()} -\/ Controls whether the contour widget should always appear on top of other actors in the scene. (In effect, this will disable Open\-G\-L Depth buffer tests while rendering the contour). Default is to set it to false.  
\item {\ttfamily obj.\-Always\-On\-Top\-On ()} -\/ Controls whether the contour widget should always appear on top of other actors in the scene. (In effect, this will disable Open\-G\-L Depth buffer tests while rendering the contour). Default is to set it to false.  
\item {\ttfamily obj.\-Always\-On\-Top\-Off ()} -\/ Controls whether the contour widget should always appear on top of other actors in the scene. (In effect, this will disable Open\-G\-L Depth buffer tests while rendering the contour). Default is to set it to false.  
\item {\ttfamily obj.\-Set\-Line\-Color (double r, double g, double b)} -\/ Convenience method to set the line color. Ideally one should use Get\-Lines\-Property()-\/$>$Set\-Color().  
\item {\ttfamily obj.\-Set\-Show\-Selected\-Nodes (int )} -\/ A flag to indicate whether to show the Selected nodes Default is to set it to false.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkorientedglyphfocalplanecontourrepresentation}{}\section{vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation}\label{vtkwidgets_vtkorientedglyphfocalplanecontourrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent a contour drawn on the focal plane (usually overlayed on top of an image or volume widget). The class was written in order to be able to draw contours on a volume widget and have the contours overlayed on the focal plane in order to do contour segmentation.

To create an instance of class vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOrientedGlyphFocalPlaneContourRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Cursor\-Shape (vtk\-Poly\-Data cursor\-Shape)} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Cursor\-Shape ()} -\/ Specify the cursor shape. Keep in mind that the shape will be aligned with the constraining plane by orienting it such that the x axis of the geometry lies along the normal of the plane.  
\item {\ttfamily obj.\-Set\-Active\-Cursor\-Shape (vtk\-Poly\-Data active\-Shape)} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Active\-Cursor\-Shape ()} -\/ Specify the shape of the cursor (handle) when it is active. This is the geometry that will be used when the mouse is close to the handle or if the user is manipulating the handle.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ This is the property used when the handle is not active (the mouse is not near the handle)  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Active\-Property ()} -\/ This is the property used when the user is interacting with the handle.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Lines\-Property ()} -\/ This is the property used by the lines.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Subclasses of vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modified)} -\/ Subclasses of vtk\-Oriented\-Glyph\-Focal\-Plane\-Contour\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Contour\-Representation\-As\-Poly\-Data ()} -\/ Get the points in this contour as a vtk\-Poly\-Data.  
\item {\ttfamily vtk\-Matrix4x4 = obj.\-Get\-Contour\-Plane\-Direction\-Cosines (double origin\mbox{[}3\mbox{]})} -\/ Direction cosines of the plane on which the contour lies on in world co-\/ordinates. This would be the same matrix that would be set in vtk\-Image\-Reslice or vtk\-Image\-Plane\-Widget if there were a plane passing through the contour points. The origin must be the origin of the data under the contour.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkorientedpolygonalhandlerepresentation3d}{}\section{vtk\-Oriented\-Polygonal\-Handle\-Representation3\-D}\label{vtkwidgets_vtkorientedpolygonalhandlerepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class serves as the geometrical representation of a vtk\-Handle\-Widget. The handle can be represented by an arbitrary polygonal data (vtk\-Poly\-Data), set via Set\-Handle(vtk\-Poly\-Data $\ast$). The actual position of the handle will be initially assumed to be (0,0,0). You can specify an offset from this position if desired. This class differs from vtk\-Polygonal\-Handle\-Representation3\-D in that the handle will always remain front facing, ie it maintains a fixed orientation with respect to the camera. This is done by using vtk\-Followers internally to render the actors.

To create an instance of class vtk\-Oriented\-Polygonal\-Handle\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkOrientedPolygonalHandleRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Oriented\-Polygonal\-Handle\-Representation3\-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\-Oriented\-Polygonal\-Handle\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Polygonal\-Handle\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Oriented\-Polygonal\-Handle\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkparallelopipedrepresentation}{}\section{vtk\-Parallelopiped\-Representation}\label{vtkwidgets_vtkparallelopipedrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides the default geometrical representation for vtk\-Parallelopiped\-Widget. As a result of interactions of the widget, this representation can take on of the following shapes\-: 

1) A parallelopiped. (8 handles, 6 faces) 

2) Paralleopiped with a chair depression on any one handle. (A chair is a depression on one of the handles that carves inwards so as to allow the user to visualize cuts in the volume). (14 handles, 9 faces).

To create an instance of class vtk\-Parallelopiped\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParallelopipedRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parallelopiped\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parallelopiped\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Parallelopiped\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Parallelopiped\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection pc)} -\/ Methods to satisfy the superclass.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Place the widget in the scene. You can use either of the two A\-P\-Is \-: 1) Place\-Widget( double bounds\mbox{[}6\mbox{]} ) Creates a cuboid conforming to the said bounds. 2) Place\-Widget( double corners\mbox{[}8\mbox{]}\mbox{[}3\mbox{]} ) Creates a parallelopiped with corners specified. The order in which corners are specified must obey the following rule\-: Corner 0 -\/ 1 -\/ 2 -\/ 3 -\/ 0 forms a face Corner 4 -\/ 5 -\/ 6 -\/ 7 -\/ 4 forms a face Corner 0 -\/ 4 -\/ 5 -\/ 1 -\/ 0 forms a face Corner 1 -\/ 5 -\/ 6 -\/ 2 -\/ 1 forms a face Corner 2 -\/ 6 -\/ 7 -\/ 3 -\/ 2 forms a face Corner 3 -\/ 7 -\/ 4 -\/ 0 -\/ 3 forms a face  
\item {\ttfamily obj.\-Set\-Interaction\-State (int )} -\/ The interaction state may be set from a widget (e.\-g., Point\-Widget) or other object. This controls how the interaction with the widget proceeds.  
\item {\ttfamily obj.\-Get\-Bounding\-Planes (vtk\-Plane\-Collection pc)} -\/ Get the bounding planes of the object. The first 6 planes will be bounding planes of the parallelopiped. If in chair mode, three additional planes will be present. The last three planes will be those of the chair. The normals of all the planes will point into the object.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ The parallelopiped polydata.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ The parallelopiped polydata.  
\item {\ttfamily obj.\-Set\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties.  
\item {\ttfamily obj.\-Set\-Hovered\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties.  
\item {\ttfamily obj.\-Set\-Selected\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Set/\-Get the handle properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Hovered\-Handle\-Property ()} -\/ Set/\-Get the handle properties.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Set/\-Get the handle properties.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Handle\-Representation handle)}  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Handle\-Representation (int index)}  
\item {\ttfamily obj.\-Handles\-On ()} -\/ Turns the visibility of the handles on/off. Sometimes they may get in the way of visualization.  
\item {\ttfamily obj.\-Handles\-Off ()} -\/ Turns the visibility of the handles on/off. Sometimes they may get in the way of visualization.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Face\-Property ()} -\/ Get the face properties. When a face is being translated, the face gets highlighted with the Selected\-Face\-Property.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Face\-Property ()} -\/ Get the face properties. When a face is being translated, the face gets highlighted with the Selected\-Face\-Property.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Outline\-Property ()} -\/ Get the outline properties. These are the properties with which the parallelopiped wireframe is rendered.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Outline\-Property ()} -\/ Get the outline properties. These are the properties with which the parallelopiped wireframe is rendered.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ This actually constructs the geometry of the widget from the various data parameters.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window w)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods required by vtk\-Prop superclass.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Given and x-\/y display coordinate, compute the interaction state of the widget.  
\item {\ttfamily obj.\-Translate (double translation\mbox{[}3\mbox{]})}  
\item {\ttfamily obj.\-Translate (int X, int Y)}  
\item {\ttfamily obj.\-Scale (int X, int Y)}  
\item {\ttfamily obj.\-Position\-Handles ()} -\/ Synchronize the parallelopiped handle positions with the Polygonal datastructure.  
\item {\ttfamily obj.\-Set\-Minimum\-Thickness (double )} -\/ Minimum thickness for the parallelopiped. User interactions cannot make any individual axis of the parallopiped thinner than this value. Default is 0.\-05 expressed as a fraction of the diagonal of the bounding box used in the Place\-Widget() invocation.  
\item {\ttfamily double = obj.\-Get\-Minimum\-Thickness ()} -\/ Minimum thickness for the parallelopiped. User interactions cannot make any individual axis of the parallopiped thinner than this value. Default is 0.\-05 expressed as a fraction of the diagonal of the bounding box used in the Place\-Widget() invocation.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkparallelopipedwidget}{}\section{vtk\-Parallelopiped\-Widget}\label{vtkwidgets_vtkparallelopipedwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This widget was designed with the aim of visualizing / probing cuts on a skewed image data / structured grid.

.S\-E\-C\-T\-I\-O\-N Interaction The widget allows you to create a parallelopiped (defined by 8 handles). The widget is initially placed by using the \char`\"{}\-Place\-Widget\char`\"{} method in the representation class. After the widget has been created, the following interactions may be used to manipulate it \-: 1) Click on a handle and drag it around moves the handle in space, while keeping the same axis alignment of the parallelopiped 2) Dragging a handle with the shift button pressed resizes the piped along an axis. 3) Control-\/click on a handle creates a chair at that position. (A chair is a depression in the piped that allows you to visualize cuts in the volume). 4) Clicking on a chair and dragging it around moves the chair within the piped. 5) Shift-\/click on the piped enables you to translate it.

To create an instance of class vtk\-Parallelopiped\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkParallelopipedWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Parallelopiped\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Parallelopiped\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Parallelopiped\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Parallelopiped\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Override the superclass method. This is a composite widget, (it internally consists of handle widgets). We will override the superclass method, so that we can pass the enabled state to the internal widgets as well.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Parallelopiped\-Representation r)} -\/ Enable/disable the creation of a chair on this widget. If off, chairs cannot be created.  
\item {\ttfamily obj.\-Set\-Enable\-Chair\-Creation (int )} -\/ Enable/disable the creation of a chair on this widget. If off, chairs cannot be created.  
\item {\ttfamily int = obj.\-Get\-Enable\-Chair\-Creation ()} -\/ Enable/disable the creation of a chair on this widget. If off, chairs cannot be created.  
\item {\ttfamily obj.\-Enable\-Chair\-Creation\-On ()} -\/ Enable/disable the creation of a chair on this widget. If off, chairs cannot be created.  
\item {\ttfamily obj.\-Enable\-Chair\-Creation\-Off ()} -\/ Enable/disable the creation of a chair on this widget. If off, chairs cannot be created.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkplanewidget}{}\section{vtk\-Plane\-Widget}\label{vtkwidgets_vtkplanewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a finite (bounded) plane that can be interactively placed in a scene. The plane has four handles (at its corner vertices), a normal vector, and the plane itself. The handles are used to resize the plane; the normal vector to rotate it, and the plane can be picked and translated. Selecting the plane while pressing C\-T\-R\-L makes it spin around the normal. A nice feature of the object is that the vtk\-Plane\-Widget, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Plane\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Plane\-Widget will terminate the processing of the event that it handles.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. If the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, the vtk\-Plane\-Widget will appear. (See superclass documentation for information about changing this behavior.) By grabbing the one of the four handles (use the left mouse button), the plane can be resized. By grabbing the plane itself, the entire plane can be arbitrarily translated. Pressing C\-T\-R\-L while grabbing the plane will spin the plane around the normal. If you select the normal vector, the plane can be arbitrarily rotated. Selecting any part of the widget with the middle mouse button enables translation of the plane along its normal. (Once selected using middle mouse, moving the mouse in the direction of the normal translates the plane in the direction of the normal; moving in the direction opposite the normal translates the plane in the direction opposite the normal.) Scaling (about the center of the plane) is achieved by using the right mouse button. By moving the mouse \char`\"{}up\char`\"{} the render window the plane will be made bigger; by moving \char`\"{}down\char`\"{} the render window the widget will be made smaller. Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method).

The vtk\-Plane\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Set/\-Get\-Resolution() methods control the number of subdivisions of the plane; the Get\-Poly\-Data() method can be used to get the polygonal representation and can be used for things like seeding stream lines. Get\-Plane() can be used to update a vtk\-Plane implicit function. Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button).

Some additional features of this class include the ability to control the properties of the widget. You can set the properties of the selected and unselected representations of the plane. For example, you can set the property for the handles and plane. In addition there are methods to constrain the plane so that it is perpendicular to the x-\/y-\/z axes.

To create an instance of class vtk\-Plane\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlaneWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Plane\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Plane\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Plane\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Plane\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set/\-Get the resolution (number of subdivisions) of the plane.  
\item {\ttfamily obj.\-Set\-Resolution (int r)} -\/ Set/\-Get the resolution (number of subdivisions) of the plane.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the resolution (number of subdivisions) of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double x, double y, double z)} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Origin (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily double = obj.\-Get\-Origin ()} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Get\-Origin (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the origin of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double x, double y, double z)} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point1 (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily double = obj.\-Get\-Point1 ()} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Get\-Point1 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the first axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double x, double y, double z)} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Point2 (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily double = obj.\-Get\-Point2 ()} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily obj.\-Get\-Point2 (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point defining the second axis of the plane.  
\item {\ttfamily obj.\-Set\-Center (double x, double y, double z)} -\/ Get the center of the plane.  
\item {\ttfamily obj.\-Set\-Center (double x\mbox{[}3\mbox{]})} -\/ Get the center of the plane.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Get the center of the plane.  
\item {\ttfamily obj.\-Get\-Center (double xyz\mbox{[}3\mbox{]})} -\/ Get the center of the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x, double y, double z)} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Normal (double x\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily double = obj.\-Get\-Normal ()} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Get\-Normal (double xyz\mbox{[}3\mbox{]})} -\/ Get the normal to the plane.  
\item {\ttfamily obj.\-Set\-Representation (int )} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily int = obj.\-Get\-Representation\-Min\-Value ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily int = obj.\-Get\-Representation\-Max\-Value ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily int = obj.\-Get\-Representation ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Off ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Outline ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Wireframe ()} -\/ Control how the plane appears when Get\-Poly\-Data() is invoked. If the mode is \char`\"{}outline\char`\"{}, then just the outline of the plane is shown. If the mode is \char`\"{}wireframe\char`\"{} then the plane is drawn with the outline plus the interior mesh (corresponding to the resolution specified). If the mode is \char`\"{}surface\char`\"{} then the plane is drawn as a surface.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Surface ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-X\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-X\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-X\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Y\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Y\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Y\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Set\-Normal\-To\-Z\-Axis (int )} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily int = obj.\-Get\-Normal\-To\-Z\-Axis ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-On ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Normal\-To\-Z\-Axis\-Off ()} -\/ Force the plane widget to be aligned with one of the x-\/y-\/z axes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the plane to the axes if it is orginally not aligned.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the plane. The polydata consists of (res+1)$\ast$(res+1) points, and res$\ast$res quadrilateral polygons, where res is the resolution of the plane. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polyplane are added to it.  
\item {\ttfamily obj.\-Get\-Plane (vtk\-Plane plane)} -\/ Get the planes describing the implicit function defined by the plane widget. The user must provide the instance of the class vtk\-Plane. Note that vtk\-Plane is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data.  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Poly\-Data\-Algorithm ()} -\/ Satisfies superclass A\-P\-I. This returns a pointer to the underlying Poly\-Data. Make changes to this before calling the initial Place\-Widget() to have the initial placement follow suit. Or, make changes after the widget has been initialised and call Update\-Placement() to realise.  
\item {\ttfamily obj.\-Update\-Placement (void )} -\/ Satisfies superclass A\-P\-I. This will change the state of the widget to match changes that have been made to the underlying Poly\-Data\-Source  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be manipulated.  
\item {\ttfamily obj.\-Set\-Plane\-Property (vtk\-Property )} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Plane\-Property ()} -\/ Get the plane properties. The properties of the plane when selected and unselected can be manipulated.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkplaybackrepresentation}{}\section{vtk\-Playback\-Representation}\label{vtkwidgets_vtkplaybackrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent the vtk\-Playback\-Widget. Besides defining geometry, this class defines a series of virtual method stubs that are meant to be subclassed by applications for controlling playback.

To create an instance of class vtk\-Playback\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlaybackRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Playback\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Playback\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Playback\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Playback\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class methods.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ By obtaining this property you can specify the properties of the representation.  
\item {\ttfamily obj.\-Play ()} -\/ Virtual callbacks that subclasses should implement.  
\item {\ttfamily obj.\-Stop ()} -\/ Virtual callbacks that subclasses should implement.  
\item {\ttfamily obj.\-Forward\-One\-Frame ()} -\/ Virtual callbacks that subclasses should implement.  
\item {\ttfamily obj.\-Backward\-One\-Frame ()} -\/ Virtual callbacks that subclasses should implement.  
\item {\ttfamily obj.\-Jump\-To\-Beginning ()} -\/ Virtual callbacks that subclasses should implement.  
\item {\ttfamily obj.\-Jump\-To\-End ()} -\/ Satisfy the superclasses' A\-P\-I.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclasses' A\-P\-I.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkplaybackwidget}{}\section{vtk\-Playback\-Widget}\label{vtkwidgets_vtkplaybackwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively controlling the playback of a serial stream of information (e.\-g., animation sequence, video, etc.). Controls for play, stop, advance one step forward, advance one step backward, jump to beginning, and jump to end are available.

To create an instance of class vtk\-Playback\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPlaybackWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Playback\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Playback\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Playback\-Widget = obj.\-New\-Instance ()} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily vtk\-Playback\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standar V\-T\-K class methods.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Playback\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpointhandlerepresentation2d}{}\section{vtk\-Point\-Handle\-Representation2\-D}\label{vtkwidgets_vtkpointhandlerepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent a vtk\-Handle\-Widget. It represents a position in 2\-D world coordinates using a x-\/y cursor (the cursor defined by an instance of vtk\-Poly\-Data and generated by a vtk\-Poly\-Data\-Algorithm).

To create an instance of class vtk\-Point\-Handle\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointHandleRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Handle\-Representation2\-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\-Point\-Handle\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Handle\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Handle\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Cursor\-Shape (vtk\-Poly\-Data cursor\-Shape)} -\/ Specify the cursor shape with an instance of vtk\-Poly\-Data. Note that shape is assumed to be defined in the display coordinate system. By default a vtk\-Cursor2\-D shape is used.  
\item {\ttfamily vtk\-Poly\-Data = obj.\-Get\-Cursor\-Shape ()} -\/ Specify the cursor shape with an instance of vtk\-Poly\-Data. Note that shape is assumed to be defined in the display coordinate system. By default a vtk\-Cursor2\-D shape is used.  
\item {\ttfamily obj.\-Set\-Display\-Position (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point in display coordinates. This overloads the superclasses Set\-Display\-Position in order to set the focal point of the cursor.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property2\-D )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Selected\-Property (vtk\-Property2\-D )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Selected\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Subclasses of vtk\-Point\-Handle\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Point\-Handle\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Point\-Handle\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Point\-Handle\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Subclasses of vtk\-Point\-Handle\-Representation2\-D must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpointhandlerepresentation3d}{}\section{vtk\-Point\-Handle\-Representation3\-D}\label{vtkwidgets_vtkpointhandlerepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent a vtk\-Handle\-Widget. It represents a position in 3\-D world coordinates using a x-\/y-\/z cursor. The cursor can be configured to show a bounding box and/or shadows.

To create an instance of class vtk\-Point\-Handle\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointHandleRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Handle\-Representation3\-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\-Point\-Handle\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Handle\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-World\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box. This method overloads the superclasses' Set\-World\-Position() and Set\-Display\-Position() in order to set the focal point of the cursor properly.  
\item {\ttfamily obj.\-Set\-Display\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box. This method overloads the superclasses' Set\-World\-Position() and Set\-Display\-Position() in order to set the focal point of the cursor properly.  
\item {\ttfamily obj.\-Set\-Outline (int o)} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily int = obj.\-Get\-Outline ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-On ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-Off ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-Set\-X\-Shadows (int o)} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily int = obj.\-Get\-X\-Shadows ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-On ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-Off ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Set\-Y\-Shadows (int o)} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Y\-Shadows ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-On ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-Off ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Set\-Z\-Shadows (int o)} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Z\-Shadows ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-On ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-Off ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the Set\-Bounds() method.)  
\item {\ttfamily obj.\-Set\-Translation\-Mode (int )} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the Set\-Bounds() method.)  
\item {\ttfamily int = obj.\-Get\-Translation\-Mode ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the Set\-Bounds() method.)  
\item {\ttfamily obj.\-Translation\-Mode\-On ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the Set\-Bounds() method.)  
\item {\ttfamily obj.\-Translation\-Mode\-Off ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated and sized simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). If translation mode is off, the cursor does not scale itself (based on the specified handle size), and the bounding box and shadows do not move or size themselves as the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button, and the bounds can be manually set with the Set\-Bounds() method.)  
\item {\ttfamily obj.\-All\-On ()} -\/ Convenience methods to turn outline and shadows on and off.  
\item {\ttfamily obj.\-All\-Off ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Selected\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Hot\-Spot\-Size (double )} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Min\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Max\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily obj.\-Set\-Handle\-Size (double size)} -\/ Overload the superclasses Set\-Handle\-Size() method to update internal variables.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpointplacer}{}\section{vtk\-Point\-Placer}\label{vtkwidgets_vtkpointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
Most widgets in V\-T\-K have a need to translate of 2\-D display coordinates (as reported by the Render\-Window\-Interactor) to 3\-D world coordinates. This class is an abstraction of this functionality. A few subclasses are listed below\-: 

1) vtk\-Focal\-Plane\-Point\-Placer\-: This class converts 2\-D display positions to world positions such that they lie on the focal plane. 

2) vtk\-Polygonal\-Surface\-Point\-Placer\-: Converts 2\-D display positions to world positions such that they lie on the surface of one or more specified polydatas. 

3) vtk\-Image\-Actor\-Point\-Placer\-: Converts 2\-D display positions to world positions such that they lie on an Image\-Actor 

4) vtk\-Bounded\-Plane\-Point\-Placer\-: Converts 2\-D display positions to world positions such that they lie within a set of specified bounding planes. 

5) vtk\-Terrain\-Data\-Point\-Placer\-: Converts 2\-D display positions to world positions such that they lie on a height field. 

Point placers provide an extensible framework to specify constraints on points. The methods Compute\-World\-Position, Validate\-Display\-Position and Validate\-World\-Position may be overridden to dictate whether a world or display position is allowed. These classes are currently used by the Handle\-Widget and the Contour\-Widget to allow various constraints to be enforced on the placement of their handles.

To create an instance of class vtk\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-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\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position in pixel coordinates, compute the world position and orientation where this point will be placed. This method is typically used by the representation to place the point initially. A return value of 1 indicates that constraints of the placer are met.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute the new world position and orientation of this point. This method is typically used by the representation to move the point. A return value of 1 indicates that constraints of the placer are met.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Given a world position check the validity of this position according to the constraints of the placer.  
\item {\ttfamily int = obj.\-Validate\-Display\-Position (vtk\-Renderer , double display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, check the validity of this position.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a world position and a world orientation, validate it according to the constraints of the placer.  
\item {\ttfamily int = obj.\-Update\-World\-Position (vtk\-Renderer ren, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a current renderer, world position and orientation, update them according to the constraints of the placer. This method is typically used when Update\-Contour is called on the representation, which must be called after changes are made to the constraints in the placer. A return value of 1 indicates that the point has been updated. A return value of 0 indicates that the point could not be updated and was left alone. By default this is a no-\/op -\/ leaving the point as is.  
\item {\ttfamily int = obj.\-Update\-Internal\-State ()} -\/ Set/get the tolerance used when performing computations in display coordinates.  
\item {\ttfamily obj.\-Set\-Pixel\-Tolerance (int )} -\/ Set/get the tolerance used when performing computations in display coordinates.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance\-Min\-Value ()} -\/ Set/get the tolerance used when performing computations in display coordinates.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance\-Max\-Value ()} -\/ Set/get the tolerance used when performing computations in display coordinates.  
\item {\ttfamily int = obj.\-Get\-Pixel\-Tolerance ()} -\/ Set/get the tolerance used when performing computations in display coordinates.  
\item {\ttfamily obj.\-Set\-World\-Tolerance (double )} -\/ Set/get the tolerance used when performing computations in world coordinates.  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance\-Min\-Value ()} -\/ Set/get the tolerance used when performing computations in world coordinates.  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance\-Max\-Value ()} -\/ Set/get the tolerance used when performing computations in world coordinates.  
\item {\ttfamily double = obj.\-Get\-World\-Tolerance ()} -\/ Set/get the tolerance used when performing computations in world coordinates.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpointwidget}{}\section{vtk\-Point\-Widget}\label{vtkwidgets_vtkpointwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget allows the user to position a point in 3\-D space using a 3\-D cursor. The cursor has an outline bounding box, axes-\/aligned cross-\/hairs, and axes shadows. (The outline and shadows can be turned off.) Any of these can be turned off. A nice feature of the object is that the vtk\-Point\-Widget, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Point\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Point\-Widget will terminate the processing of the event that it handles.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. The interactor will act normally until the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, at which point the vtk\-Point\-Widget will appear. (See superclass documentation for information about changing this behavior.) To move the point, the user can grab (left mouse) on any widget line and \char`\"{}slide\char`\"{} the point into position. Scaling is achieved by using the right mouse button \char`\"{}up\char`\"{} the render window (makes the widget bigger) or \char`\"{}down\char`\"{} the render window (makes the widget smaller). To translate the widget use the middle mouse button. (Note\-: all of the translation interactions can be constrained to one of the x-\/y-\/z axes by using the \char`\"{}shift\char`\"{} key.) The vtk\-Point\-Widget produces as output a polydata with a single point and a vertex cell.

Some additional features of this class include the ability to control the rendered properties of the widget. You can set the properties of the selected and unselected representations of the parts of the widget. For example, you can set the property of the 3\-D cursor in its normal and selected states.

To create an instance of class vtk\-Point\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPointWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Point\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Point\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Point\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Grab the polydata (including points) that defines the point. A single point and a vertex compose the vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the point. A single point and a vertex compose the vtk\-Poly\-Data.  
\item {\ttfamily obj.\-Set\-Position (double x, double y, double z)} -\/ Set/\-Get the position of the point. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box.  
\item {\ttfamily obj.\-Set\-Position (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the point. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box.  
\item {\ttfamily double = obj.\-Get\-Position ()} -\/ Set/\-Get the position of the point. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box.  
\item {\ttfamily obj.\-Get\-Position (double xyz\mbox{[}3\mbox{]})} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Set\-Outline (int o)} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily int = obj.\-Get\-Outline ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-On ()} -\/ Turn on/off the wireframe bounding box.  
\item {\ttfamily obj.\-Outline\-Off ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-Set\-X\-Shadows (int o)} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily int = obj.\-Get\-X\-Shadows ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-On ()} -\/ Turn on/off the wireframe x-\/shadows.  
\item {\ttfamily obj.\-X\-Shadows\-Off ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Set\-Y\-Shadows (int o)} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Y\-Shadows ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-On ()} -\/ Turn on/off the wireframe y-\/shadows.  
\item {\ttfamily obj.\-Y\-Shadows\-Off ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Set\-Z\-Shadows (int o)} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily int = obj.\-Get\-Z\-Shadows ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-On ()} -\/ Turn on/off the wireframe z-\/shadows.  
\item {\ttfamily obj.\-Z\-Shadows\-Off ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves.  
\item {\ttfamily obj.\-Set\-Translation\-Mode (int mode)} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves.  
\item {\ttfamily int = obj.\-Get\-Translation\-Mode ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves.  
\item {\ttfamily obj.\-Translation\-Mode\-On ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves.  
\item {\ttfamily obj.\-Translation\-Mode\-Off ()} -\/ Convenience methods to turn outline and shadows on and off.  
\item {\ttfamily obj.\-All\-On ()} -\/ Convenience methods to turn outline and shadows on and off.  
\item {\ttfamily obj.\-All\-Off ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be set.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ Get the handle properties (the little balls are the handles). The properties of the handles when selected and normal can be set.  
\item {\ttfamily obj.\-Set\-Hot\-Spot\-Size (double )} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Min\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Max\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolydatacontourlineinterpolator}{}\section{vtk\-Poly\-Data\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkpolydatacontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Contour\-Line\-Interpolator is an abstract base class for contour line interpolators that interpolate on polygonal data.

To create an instance of class vtk\-Poly\-Data\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Contour\-Line\-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\-Poly\-Data\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Poly\-Data\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Poly\-Data\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)} -\/ Subclasses that wish to interpolate a line segment must implement this. For instance vtk\-Bezier\-Contour\-Line\-Interpolator adds nodes between idx1 and idx2, that allow the contour to adhere to a bezier curve.  
\item {\ttfamily int = obj.\-Update\-Node (vtk\-Renderer , vtk\-Contour\-Representation , double , int )} -\/ The interpolator is given a chance to update the node. vtk\-Image\-Contour\-Line\-Interpolator updates the idx'th node in the contour, so it automatically sticks to edges in the vicinity as the user constructs the contour. Returns 0 if the node (world position) is unchanged.  
\item {\ttfamily vtk\-Poly\-Data\-Collection = obj.\-Get\-Polys ()} -\/ Be sure to add polydata on which you wish to place points to this list or they will not be considered for placement.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolydatapointplacer}{}\section{vtk\-Poly\-Data\-Point\-Placer}\label{vtkwidgets_vtkpolydatapointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Poly\-Data\-Point\-Placer is a base class to place points on the surface of polygonal data.

.S\-E\-C\-T\-I\-O\-N Usage The actors that render polygonal data and wish to be considered for placement by this placer are added to the list as \begin{DoxyVerb} placer->AddProp( polyDataActor );\end{DoxyVerb}


To create an instance of class vtk\-Poly\-Data\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataPointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Point\-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\-Poly\-Data\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Poly\-Data\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Poly\-Data\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Add\-Prop (vtk\-Prop )}  
\item {\ttfamily obj.\-Remove\-View\-Prop (vtk\-Prop prop)}  
\item {\ttfamily obj.\-Remove\-All\-Props ()}  
\item {\ttfamily int = obj.\-Has\-Prop (vtk\-Prop )}  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Props ()}  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position in pixel coordinates, compute the world position and orientation where this point will be placed. This method is typically used by the representation to place the point initially. For the Terrain point placer this computes world points that lie at the specified height above the terrain.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute the new world position and orientation of this point. This method is typically used by the representation to move the point.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Given a world position check the validity of this position according to the constraints of the placer  
\item {\ttfamily int = obj.\-Validate\-Display\-Position (vtk\-Renderer , double display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, check the validity of this position.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a world position and a world orientation, validate it according to the constraints of the placer.  
\item {\ttfamily vtk\-Prop\-Picker = obj.\-Get\-Prop\-Picker ()} -\/ Get the Prop picker.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolydatasourcewidget}{}\section{vtk\-Poly\-Data\-Source\-Widget}\label{vtkwidgets_vtkpolydatasourcewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This abstract class serves as parent to 3\-D widgets that have simple vtk\-Poly\-Data\-Source instances defining their geometry.

In addition to what is offered by the vtk3\-D\-Widget parent, this class makes it possible to manipulate the underlying polydatasource and to Place\-Widget() according to that, instead of having to make use of Set\-Input() or Set\-Prop3\-D().

Implementors of child classes H\-A\-V\-E to implement their Place\-Widget(bounds) to check for the existence of Input and Prop3\-D F\-I\-R\-S\-T. If these don't exist, place according to the underlying Poly\-Data\-Source. Child classes also have to imprement Update\-Placement(), which updates the widget according to the geometry of the underlying Poly\-Data\-Source.

To create an instance of class vtk\-Poly\-Data\-Source\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolyDataSourceWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Poly\-Data\-Source\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Source\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Poly\-Data\-Source\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Poly\-Data\-Source\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Overrides vtk3\-D\-Widget Place\-Widget() so that it doesn't complain if there's no Input and no Prop3\-D.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ We have to redeclare this abstract, Place\-Widget() requires it. You H\-A\-V\-E to override this in your concrete child classes. If there's no Prop3\-D and no Input, your Place\-Widget must make use of the underlying Poly\-Data\-Source to do its work.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Returns underlying vtk\-Poly\-Data\-Source that determines geometry. This can be modified after which Place\-Widget() or Update\-Placement() can be called. Update\-Placement() will always update the planewidget according to the geometry of the underlying Poly\-Data\-Source. Place\-Widget() will only make use of this geometry if there is no Input and no Prop3\-D set.  
\item {\ttfamily vtk\-Poly\-Data\-Source = obj.\-Get\-Poly\-Data\-Source ()} -\/ Returns underlying vtk\-Poly\-Data\-Source that determines geometry. This can be modified after which Place\-Widget() or Update\-Placement() can be called. Update\-Placement() will always update the planewidget according to the geometry of the underlying Poly\-Data\-Source. Place\-Widget() will only make use of this geometry if there is no Input and no Prop3\-D set.  
\item {\ttfamily vtk\-Poly\-Data\-Algorithm = obj.\-Get\-Poly\-Data\-Algorithm ()} -\/ Returns underlying vtk\-Poly\-Data\-Source that determines geometry. This can be modified after which Place\-Widget() or Update\-Placement() can be called. Update\-Placement() will always update the planewidget according to the geometry of the underlying Poly\-Data\-Source. Place\-Widget() will only make use of this geometry if there is no Input and no Prop3\-D set.  
\item {\ttfamily obj.\-Update\-Placement ()} -\/ If you've made changes to the underlying vtk\-Poly\-Data\-Source A\-F\-T\-E\-R your initial call to Place\-Widget(), use this method to realise the changes in the widget.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolygonalhandlerepresentation3d}{}\section{vtk\-Polygonal\-Handle\-Representation3\-D}\label{vtkwidgets_vtkpolygonalhandlerepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class serves as the geometrical representation of a vtk\-Handle\-Widget. The handle can be represented by an arbitrary polygonal data (vtk\-Poly\-Data), set via Set\-Handle(vtk\-Poly\-Data $\ast$). The actual position of the handle will be initially assumed to be (0,0,0). You can specify an offset from this position if desired.

To create an instance of class vtk\-Polygonal\-Handle\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolygonalHandleRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Polygonal\-Handle\-Representation3\-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\-Polygonal\-Handle\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Handle\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Handle\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-World\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates.  
\item {\ttfamily obj.\-Set\-Offset (double , double , double )} -\/ Set/get the offset of the handle position with respect to the handle center, assumed to be the origin.  
\item {\ttfamily obj.\-Set\-Offset (double a\mbox{[}3\mbox{]})} -\/ Set/get the offset of the handle position with respect to the handle center, assumed to be the origin.  
\item {\ttfamily double = obj. Get\-Offset ()} -\/ Set/get the offset of the handle position with respect to the handle center, assumed to be the origin.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolygonalsurfacecontourlineinterpolator}{}\section{vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkpolygonalsurfacecontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator interpolates and places contour points on polygonal surfaces. The class interpolates nodes by computing a {\itshape graph} {\itshape geodesic} lying on the polygonal data. By {\itshape graph} {\itshape Geodesic}, we mean that the line interpolating the two end points traverses along on the mesh edges so as to form the shortest path. A Dijkstra algorithm is used to compute the path. See vtk\-Dijkstra\-Graph\-Geodesic\-Path.

The class is mean to be used in conjunction with vtk\-Polygonal\-Surface\-Point\-Placer. The reason for this weak coupling is a performance issue, both classes need to perform a cell pick, and coupling avoids multiple cell picks (cell picks are slow).

To create an instance of class vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolygonalSurfaceContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Polygonal\-Surface\-Contour\-Line\-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\-Polygonal\-Surface\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)} -\/ Subclasses that wish to interpolate a line segment must implement this. For instance vtk\-Bezier\-Contour\-Line\-Interpolator adds nodes between idx1 and idx2, that allow the contour to adhere to a bezier curve.  
\item {\ttfamily int = obj.\-Update\-Node (vtk\-Renderer , vtk\-Contour\-Representation , double , int )} -\/ The interpolator is given a chance to update the node. vtk\-Image\-Contour\-Line\-Interpolator updates the idx'th node in the contour, so it automatically sticks to edges in the vicinity as the user constructs the contour. Returns 0 if the node (world position) is unchanged.  
\item {\ttfamily obj.\-Set\-Distance\-Offset (double )} -\/ Height offset at which points may be placed on the polygonal surface. If you specify a non-\/zero value here, be sure to have computed vertex normals on your input polygonal data. (easily done with vtk\-Poly\-Data\-Normals).  
\item {\ttfamily double = obj.\-Get\-Distance\-Offset ()} -\/ Height offset at which points may be placed on the polygonal surface. If you specify a non-\/zero value here, be sure to have computed vertex normals on your input polygonal data. (easily done with vtk\-Poly\-Data\-Normals).  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkpolygonalsurfacepointplacer}{}\section{vtk\-Polygonal\-Surface\-Point\-Placer}\label{vtkwidgets_vtkpolygonalsurfacepointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Polygonal\-Surface\-Point\-Placer places points on polygonal data and is meant to be used in conjunction with vtk\-Polygonal\-Surface\-Contour\-Line\-Interpolator.

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

To create an instance of class vtk\-Polygonal\-Surface\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkPolygonalSurfacePointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Polygonal\-Surface\-Point\-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\-Polygonal\-Surface\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Surface\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Polygonal\-Surface\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Add\-Prop (vtk\-Prop )}  
\item {\ttfamily obj.\-Remove\-View\-Prop (vtk\-Prop prop)}  
\item {\ttfamily obj.\-Remove\-All\-Props ()}  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position in pixel coordinates, compute the world position and orientation where this point will be placed. This method is typically used by the representation to place the point initially. For the Terrain point placer this computes world points that lie at the specified height above the terrain.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute the new world position and orientation of this point. This method is typically used by the representation to move the point.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Given a world position check the validity of this position according to the constraints of the placer  
\item {\ttfamily int = obj.\-Validate\-Display\-Position (vtk\-Renderer , double display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, check the validity of this position.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a world position and a world orientation, validate it according to the constraints of the placer.  
\item {\ttfamily vtk\-Cell\-Picker = obj.\-Get\-Cell\-Picker ()} -\/ Get the Prop picker.  
\item {\ttfamily vtk\-Poly\-Data\-Collection = obj.\-Get\-Polys ()} -\/ Be sure to add polydata on which you wish to place points to this list or they will not be considered for placement.  
\item {\ttfamily obj.\-Set\-Distance\-Offset (double )} -\/ Height offset at which points may be placed on the polygonal surface. If you specify a non-\/zero value here, be sure to compute cell normals on your input polygonal data (easily done with vtk\-Poly\-Data\-Normals).  
\item {\ttfamily double = obj.\-Get\-Distance\-Offset ()} -\/ Height offset at which points may be placed on the polygonal surface. If you specify a non-\/zero value here, be sure to compute cell normals on your input polygonal data (easily done with vtk\-Poly\-Data\-Normals).  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkrectilinearwiperepresentation}{}\section{vtk\-Rectilinear\-Wipe\-Representation}\label{vtkwidgets_vtkrectilinearwiperepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent and render a vtk\-Rectilinear\-Wipe\-Widget. To use this class, you need to specify an instance of a vtk\-Image\-Rectilinear\-Wipe and vtk\-Image\-Actor. This provides the information for this representation to construct and place itself.

The class may be subclassed so that alternative representations can be created. The class defines an A\-P\-I and a default implementation that the vtk\-Rectilinear\-Wipe\-Widget interacts with to render itself in the scene.

To create an instance of class vtk\-Rectilinear\-Wipe\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearWipeRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Wipe\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rectilinear\-Wipe\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Rectilinear\-Wipe\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Rectilinear\-Wipe\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Rectilinear\-Wipe (vtk\-Image\-Rectilinear\-Wipe wipe)} -\/ Specify an instance of vtk\-Image\-Rectilinear\-Wipe to manipulate.  
\item {\ttfamily vtk\-Image\-Rectilinear\-Wipe = obj.\-Get\-Rectilinear\-Wipe ()} -\/ Specify an instance of vtk\-Image\-Rectilinear\-Wipe to manipulate.  
\item {\ttfamily obj.\-Set\-Image\-Actor (vtk\-Image\-Actor image\-Actor)} -\/ Specify an instance of vtk\-Image\-Actor to decorate.  
\item {\ttfamily vtk\-Image\-Actor = obj.\-Get\-Image\-Actor ()} -\/ Specify an instance of vtk\-Image\-Actor to decorate.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered to be on the widget, or on a widget feature (e.\-g., a corner point or edge).  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Property ()} -\/ Get the properties for the widget. This can be manipulated to set different colors, line widths, etc.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Rectilinear\-Wipe\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Rectilinear\-Wipe\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Subclasses of vtk\-Rectilinear\-Wipe\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Subclasses of vtk\-Rectilinear\-Wipe\-Representation must implement these methods. These are the methods that the widget and its representation use to communicate with each other.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkrectilinearwipewidget}{}\section{vtk\-Rectilinear\-Wipe\-Widget}\label{vtkwidgets_vtkrectilinearwipewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Rectilinear\-Wipe\-Widget is used to interactively control an instance of vtk\-Image\-Rectilinear\-Wipe (and an associated vtk\-Image\-Actor used to display the rectilinear wipe). A rectilinear wipe is a 2x2 checkerboard pattern created by combining two separate images, where various combinations of the checker squares are possible. Using this widget, the user can adjust the layout of the checker pattern, such as moving the center point, moving the horizontal separator, or moving the vertical separator. These capabilities are particularly useful for comparing two images.

To use this widget, specify its representation (by default the representation is an instance of vtk\-Rectilinear\-Wipe\-Prop). The representation generally requires that you specify an instance of vtk\-Image\-Rectilinear\-Wipe and an instance of vtk\-Image\-Actor. Other instance variables may also be required to be set -- see the documentation for vtk\-Rectilinear\-Wipe\-Prop (or appropriate subclass).

By default, the widget responds to the following events\-: 
\begin{DoxyPre}
 Selecting the center point, horizontal separator, and verticel separator:
   LeftButtonPressEvent - move the separators
   LeftButtonReleaseEvent - release the separators 
   MouseMoveEvent - move the separators
 \end{DoxyPre}
 Selecting the center point allows you to move the horizontal and vertical separators simultaneously. Otherwise only horizontal or vertical motion is possible/

Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Rectilinear\-Wipe\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Rectilinear\-Wipe\-Widget invokes the following V\-T\-K events (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Rectilinear\-Wipe\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkRectilinearWipeWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Rectilinear\-Wipe\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Rectilinear\-Wipe\-Widget 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\-Rectilinear\-Wipe\-Widget = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Rectilinear\-Wipe\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Rectilinear\-Wipe\-Representation r)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkscalarbarrepresentation}{}\section{vtk\-Scalar\-Bar\-Representation}\label{vtkwidgets_vtkscalarbarrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class represents a scalar bar for a vtk\-Scalar\-Bar\-Widget. This class provides support for interactively placing a scalar bar on the 2\-D overlay plane. The scalar bar is defined by an instance of vtk\-Scalar\-Bar\-Actor.

One specialty of this class is that if the scalar bar is moved near enough to an edge, it's orientation is flipped to match that edge.

To create an instance of class vtk\-Scalar\-Bar\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScalarBarRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scalar\-Bar\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scalar\-Bar\-Representation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scalar\-Bar\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily vtk\-Scalar\-Bar\-Actor = obj.\-Get\-Scalar\-Bar\-Actor ()} -\/ The prop that is placed in the renderer.  
\item {\ttfamily obj.\-Set\-Scalar\-Bar\-Actor (vtk\-Scalar\-Bar\-Actor )} -\/ The prop that is placed in the renderer.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection collection)} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window window)} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Set\-Orientation (int orient)} -\/ Get/\-Set the orientation.  
\item {\ttfamily int = obj.\-Get\-Orientation ()} -\/ Get/\-Set the orientation.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkscalarbarwidget}{}\section{vtk\-Scalar\-Bar\-Widget}\label{vtkwidgets_vtkscalarbarwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively manipulating the position, size, and orientation of a scalar bar. It listens to Left mouse events and mouse movement. It also listens to Right mouse events and notifies any observers of Right mouse events on this object when they occur. It will change the cursor shape based on its location. If the cursor is over an edge of the scalar bar it will change the cursor shape to a resize edge shape. If the position of a scalar bar is moved to be close to the center of one of the four edges of the viewport, then the scalar bar will change its orientation to align with that edge. This orientation is sticky in that it will stay that orientation until the position is moved close to another edge.

To create an instance of class vtk\-Scalar\-Bar\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkScalarBarWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Scalar\-Bar\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Scalar\-Bar\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Scalar\-Bar\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Scalar\-Bar\-Representation rep)} -\/ Specify an instance of vtk\-Widget\-Representation used to represent this widget in the scene. Note that the representation is a subclass of vtk\-Prop so it can be added to the renderer independent of the widget.  
\item {\ttfamily vtk\-Scalar\-Bar\-Representation = obj.\-Get\-Scalar\-Bar\-Representation ()} -\/ Get the Scalar\-Bar used by this Widget. One is created automatically.  
\item {\ttfamily obj.\-Set\-Scalar\-Bar\-Actor (vtk\-Scalar\-Bar\-Actor actor)} -\/ Get the Scalar\-Bar used by this Widget. One is created automatically.  
\item {\ttfamily vtk\-Scalar\-Bar\-Actor = obj.\-Get\-Scalar\-Bar\-Actor ()} -\/ Get the Scalar\-Bar used by this Widget. One is created automatically.  
\item {\ttfamily obj.\-Set\-Repositionable (int )} -\/ Can the widget be moved. On by default. If off, the widget cannot be moved around.

T\-O\-D\-O\-: This functionality should probably be moved to the superclass.  
\item {\ttfamily int = obj.\-Get\-Repositionable ()} -\/ Can the widget be moved. On by default. If off, the widget cannot be moved around.

T\-O\-D\-O\-: This functionality should probably be moved to the superclass.  
\item {\ttfamily obj.\-Repositionable\-On ()} -\/ Can the widget be moved. On by default. If off, the widget cannot be moved around.

T\-O\-D\-O\-: This functionality should probably be moved to the superclass.  
\item {\ttfamily obj.\-Repositionable\-Off ()} -\/ Can the widget be moved. On by default. If off, the widget cannot be moved around.

T\-O\-D\-O\-: This functionality should probably be moved to the superclass.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkseedrepresentation}{}\section{vtk\-Seed\-Representation}\label{vtkwidgets_vtkseedrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Seed\-Representation is a superclass for classes representing the vtk\-Seed\-Widget. This representation consists of one or more handles (vtk\-Handle\-Representation) which are used to place and manipulate the points defining the collection of seeds.

To create an instance of class vtk\-Seed\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSeedRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Seed\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Seed\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Seed\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Seed\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Get\-Seed\-World\-Position (int seed\-Num, double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of seed points defining this representation. Note that methods are available for both display and world coordinates. The seeds are accessed by a seed number.  
\item {\ttfamily obj.\-Set\-Seed\-Display\-Position (int seed\-Num, double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of seed points defining this representation. Note that methods are available for both display and world coordinates. The seeds are accessed by a seed number.  
\item {\ttfamily obj.\-Get\-Seed\-Display\-Position (int seed\-Num, double pos\mbox{[}3\mbox{]})} -\/ Methods to Set/\-Get the coordinates of seed points defining this representation. Note that methods are available for both display and world coordinates. The seeds are accessed by a seed number.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Seeds ()} -\/ Return the number of seeds (or handles) that have been created.  
\item {\ttfamily obj.\-Set\-Handle\-Representation (vtk\-Handle\-Representation handle)} -\/ This method is used to specify the type of handle representation to use for the internal vtk\-Handle\-Widgets within vtk\-Seed\-Widget. To use this method, create a dummy vtk\-Handle\-Widget (or subclass), and then invoke this method with this dummy. Then the vtk\-Seed\-Representation uses this dummy to clone vtk\-Handle\-Widgets of the same type. Make sure you set the handle representation before the widget is enabled.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Handle\-Representation (int num)} -\/ Get the handle representations used for a particular seed. A side effect of this method is that it will create a handle representation in the list of representations if one has not yet been created.  
\item {\ttfamily vtk\-Handle\-Representation = obj.\-Get\-Handle\-Representation ()} -\/ Returns the model Handle\-Representation.  
\item {\ttfamily obj.\-Set\-Tolerance (int )} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Min\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance\-Max\-Value ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Tolerance ()} -\/ The tolerance representing the distance to the widget (in pixels) in which the cursor is considered near enough to the end points of the widget to be active.  
\item {\ttfamily int = obj.\-Get\-Active\-Handle ()} -\/ These are methods specific to vtk\-Seed\-Representation and which are invoked from vtk\-Seed\-Widget.  
\item {\ttfamily int = obj.\-Create\-Handle (double e\mbox{[}2\mbox{]})} -\/ These are methods specific to vtk\-Seed\-Representation and which are invoked from vtk\-Seed\-Widget.  
\item {\ttfamily obj.\-Remove\-Last\-Handle ()} -\/ These are methods specific to vtk\-Seed\-Representation and which are invoked from vtk\-Seed\-Widget.  
\item {\ttfamily obj.\-Remove\-Active\-Handle ()} -\/ These are methods specific to vtk\-Seed\-Representation and which are invoked from vtk\-Seed\-Widget.  
\item {\ttfamily obj.\-Remove\-Handle (int n)} -\/ Remove the nth handle.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkseedwidget}{}\section{vtk\-Seed\-Widget}\label{vtkwidgets_vtkseedwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Seed\-Widget is used to placed multiple seed points in the scene. The seed points can be used for operations like connectivity, segmentation, and region growing.

To use this widget, specify an instance of vtk\-Seed\-Widget and a representation (a subclass of vtk\-Seed\-Representation). The widget is implemented using multiple instances of vtk\-Handle\-Widget which can be used to position the seed points (after they are initially placed). The representations for these handle widgets are provided by the vtk\-Seed\-Representation.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
   LeftButtonPressEvent - add a point or select a handle (i.e., seed)
   RightButtonPressEvent - finish adding the seeds
   MouseMoveEvent - move a handle (i.e., seed)
   LeftButtonReleaseEvent - release the selected handle (seed)
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Seed\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::AddPoint -- add one point; depending on the state
                               it may the first or second point added. Or,
                               if near handle, select handle.
   vtkWidgetEvent::Completed -- finished adding seeds.
   vtkWidgetEvent::Move -- move the second point or handle depending on the state.
   vtkWidgetEvent::EndSelect -- the handle manipulation process has completed.
 \end{DoxyPre}


This widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (beginning to interact)
   vtkCommand::EndInteractionEvent (completing interaction)
   vtkCommand::InteractionEvent (moving after selecting something)
   vtkCommand::PlacePointEvent (after point is positioned; 
                                call data includes handle id (0,1))
 \end{DoxyPre}


To create an instance of class vtk\-Seed\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSeedWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Seed\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Seed\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Seed\-Widget = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Seed\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ The method for activiating and deactiviating this widget. This method must be overridden because it is a composite widget and does more than its superclasses' vtk\-Abstract\-Widget\-::\-Set\-Enabled() method.  
\item {\ttfamily obj.\-Set\-Current\-Renderer (vtk\-Renderer )} -\/ Set the current renderer. This method also propagates to all the child handle widgets, if any exist  
\item {\ttfamily obj.\-Set\-Interactor (vtk\-Render\-Window\-Interactor )} -\/ Set the interactor. This method also propagates to all the child handle widgets, if any exist  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Seed\-Representation rep)} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\item {\ttfamily obj.\-Set\-Process\-Events (int )} -\/ Methods to change the whether the widget responds to interaction. Overridden to pass the state to component widgets.  
\item {\ttfamily obj.\-Complete\-Interaction ()} -\/ Method to be called when the seed widget should stop responding to the place point interaction. The seed widget, when defined allows you place seeds by clicking on the render window. Use this method to indicate that you would like to stop placing seeds interactively. If you'd like the widget to stop responding to {\itshape any} user interaction simply disable event processing by the widget by calling widget-\/$>$Process\-Events\-Off()  
\item {\ttfamily obj.\-Restart\-Interaction ()} -\/ Method to be called when the seed widget should start responding to the interaction.  
\item {\ttfamily vtk\-Handle\-Widget = obj.\-Create\-New\-Handle ()} -\/ Use this method to programmatically create a new handle. In interactive mode, (when the widget is in the Placing\-Seeds state) this method is automatically invoked. The method returns the handle created. A valid seed representation must exist for the widget to create a new handle.  
\item {\ttfamily obj.\-Delete\-Seed (int n)} -\/ Delete the nth seed.  
\item {\ttfamily vtk\-Handle\-Widget = obj.\-Get\-Seed (int n)} -\/ Get the nth seed  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksliderrepresentation}{}\section{vtk\-Slider\-Representation}\label{vtkwidgets_vtksliderrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This abstract class is used to specify how the vtk\-Slider\-Widget should interact with representations of the vtk\-Slider\-Widget. This class may be subclassed so that alternative representations can be created. The class defines an A\-P\-I, and a default implementation, that the vtk\-Slider\-Widget interacts with to render itself in the scene.

To create an instance of class vtk\-Slider\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSliderRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Slider\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Slider\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily obj.\-Set\-Value (double value)} -\/ Specify the current value for the widget. The value should lie between the minimum and maximum values.  
\item {\ttfamily double = obj.\-Get\-Value ()} -\/ Specify the current value for the widget. The value should lie between the minimum and maximum values.  
\item {\ttfamily obj.\-Set\-Minimum\-Value (double value)} -\/ Set the current minimum value that the slider can take. Setting the minimum value greater than the maximum value will cause the maximum value to grow to (minimum value + 1).  
\item {\ttfamily double = obj.\-Get\-Minimum\-Value ()} -\/ Set the current minimum value that the slider can take. Setting the minimum value greater than the maximum value will cause the maximum value to grow to (minimum value + 1).  
\item {\ttfamily obj.\-Set\-Maximum\-Value (double value)} -\/ Set the current maximum value that the slider can take. Setting the maximum value less than the minimum value will cause the minimum value to change to (maximum value -\/ 1).  
\item {\ttfamily double = obj.\-Get\-Maximum\-Value ()} -\/ Set the current maximum value that the slider can take. Setting the maximum value less than the minimum value will cause the minimum value to change to (maximum value -\/ 1).  
\item {\ttfamily obj.\-Set\-Slider\-Length (double )} -\/ Specify the length of the slider shape (in normalized display coordinates \mbox{[}0.\-01,0.\-5\mbox{]}). The slider length by default is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Length\-Min\-Value ()} -\/ Specify the length of the slider shape (in normalized display coordinates \mbox{[}0.\-01,0.\-5\mbox{]}). The slider length by default is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Length\-Max\-Value ()} -\/ Specify the length of the slider shape (in normalized display coordinates \mbox{[}0.\-01,0.\-5\mbox{]}). The slider length by default is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Length ()} -\/ Specify the length of the slider shape (in normalized display coordinates \mbox{[}0.\-01,0.\-5\mbox{]}). The slider length by default is 0.\-05.  
\item {\ttfamily obj.\-Set\-Slider\-Width (double )} -\/ Set the width of the slider in the directions orthogonal to the slider axis. Using this it is possible to create ellipsoidal and hockey puck sliders (in some subclasses). By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Width\-Min\-Value ()} -\/ Set the width of the slider in the directions orthogonal to the slider axis. Using this it is possible to create ellipsoidal and hockey puck sliders (in some subclasses). By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Width\-Max\-Value ()} -\/ Set the width of the slider in the directions orthogonal to the slider axis. Using this it is possible to create ellipsoidal and hockey puck sliders (in some subclasses). By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Slider\-Width ()} -\/ Set the width of the slider in the directions orthogonal to the slider axis. Using this it is possible to create ellipsoidal and hockey puck sliders (in some subclasses). By default the width is 0.\-05.  
\item {\ttfamily obj.\-Set\-Tube\-Width (double )} -\/ Set the width of the tube (in normalized display coordinates) on which the slider moves. By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Tube\-Width\-Min\-Value ()} -\/ Set the width of the tube (in normalized display coordinates) on which the slider moves. By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Tube\-Width\-Max\-Value ()} -\/ Set the width of the tube (in normalized display coordinates) on which the slider moves. By default the width is 0.\-05.  
\item {\ttfamily double = obj.\-Get\-Tube\-Width ()} -\/ Set the width of the tube (in normalized display coordinates) on which the slider moves. By default the width is 0.\-05.  
\item {\ttfamily obj.\-Set\-End\-Cap\-Length (double )} -\/ Specify the length of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the length is 0.\-025. If the end cap length is set to 0.\-0, then the end cap will not display at all.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Length\-Min\-Value ()} -\/ Specify the length of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the length is 0.\-025. If the end cap length is set to 0.\-0, then the end cap will not display at all.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Length\-Max\-Value ()} -\/ Specify the length of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the length is 0.\-025. If the end cap length is set to 0.\-0, then the end cap will not display at all.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Length ()} -\/ Specify the length of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the length is 0.\-025. If the end cap length is set to 0.\-0, then the end cap will not display at all.  
\item {\ttfamily obj.\-Set\-End\-Cap\-Width (double )} -\/ Specify the width of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the width is twice the tube width.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Width\-Min\-Value ()} -\/ Specify the width of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the width is twice the tube width.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Width\-Max\-Value ()} -\/ Specify the width of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the width is twice the tube width.  
\item {\ttfamily double = obj.\-Get\-End\-Cap\-Width ()} -\/ Specify the width of each end cap (in normalized coordinates \mbox{[}0.\-0,0.\-25\mbox{]}). By default the width is twice the tube width.  
\item {\ttfamily obj.\-Set\-Title\-Text (string )} -\/ Specify the label text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the label text is not displayed.  
\item {\ttfamily string = obj.\-Get\-Title\-Text ()} -\/ Set/\-Get the format with which to print the slider value.  
\item {\ttfamily obj.\-Set\-Label\-Format (string )} -\/ Set/\-Get the format with which to print the slider value.  
\item {\ttfamily string = obj.\-Get\-Label\-Format ()} -\/ Set/\-Get the format with which to print the slider value.  
\item {\ttfamily obj.\-Set\-Label\-Height (double )} -\/ Specify the relative height of the label as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Label\-Height\-Min\-Value ()} -\/ Specify the relative height of the label as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Label\-Height\-Max\-Value ()} -\/ Specify the relative height of the label as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Label\-Height ()} -\/ Specify the relative height of the label as compared to the length of the slider.  
\item {\ttfamily obj.\-Set\-Title\-Height (double )} -\/ Specify the relative height of the title as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Title\-Height\-Min\-Value ()} -\/ Specify the relative height of the title as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Title\-Height\-Max\-Value ()} -\/ Specify the relative height of the title as compared to the length of the slider.  
\item {\ttfamily double = obj.\-Get\-Title\-Height ()} -\/ Specify the relative height of the title as compared to the length of the slider.  
\item {\ttfamily obj.\-Set\-Show\-Slider\-Label (int )} -\/ Indicate whether the slider text label should be displayed. This is a number corresponding to the current Value of this widget.  
\item {\ttfamily int = obj.\-Get\-Show\-Slider\-Label ()} -\/ Indicate whether the slider text label should be displayed. This is a number corresponding to the current Value of this widget.  
\item {\ttfamily obj.\-Show\-Slider\-Label\-On ()} -\/ Indicate whether the slider text label should be displayed. This is a number corresponding to the current Value of this widget.  
\item {\ttfamily obj.\-Show\-Slider\-Label\-Off ()} -\/ Indicate whether the slider text label should be displayed. This is a number corresponding to the current Value of this widget.  
\item {\ttfamily double = obj.\-Get\-Current\-T ()} -\/ Methods to interface with the vtk\-Slider\-Widget. Subclasses of this class actually do something.  
\item {\ttfamily double = obj.\-Get\-Picked\-T ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksliderrepresentation2d}{}\section{vtk\-Slider\-Representation2\-D}\label{vtkwidgets_vtksliderrepresentation2d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent and render a vtk\-Slider\-Widget. To use this class, you must at a minimum specify the end points of the slider. Optional instance variable can be used to modify the appearance of the widget.

To create an instance of class vtk\-Slider\-Representation2\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSliderRepresentation2D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Slider\-Representation2\-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\-Slider\-Representation2\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation2\-D = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation2\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point1\-Coordinate ()} -\/ Position the first end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point1\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point2\-Coordinate ()} -\/ Position the second end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point2\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily obj.\-Set\-Title\-Text (string )} -\/ Specify the label text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the label text is not displayed.  
\item {\ttfamily string = obj.\-Get\-Title\-Text ()} -\/ Specify the label text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the label text is not displayed.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Slider\-Property ()} -\/ Get the slider properties. The properties of the slider when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Tube\-Property ()} -\/ Get the properties for the tube and end caps.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Cap\-Property ()} -\/ Get the properties for the tube and end caps.  
\item {\ttfamily vtk\-Property2\-D = obj.\-Get\-Selected\-Property ()} -\/ Get the selection property. This property is used to modify the appearance of selected objects (e.\-g., the slider).  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Label\-Property ()} -\/ Set/\-Get the properties for the label and title text.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Title\-Property ()} -\/ Set/\-Get the properties for the label and title text.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Highlight (int )} -\/ Methods to interface with the vtk\-Slider\-Widget. The Place\-Widget() method assumes that the parameter bounds\mbox{[}6\mbox{]} specifies the location in display space where the widget should be placed.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksliderrepresentation3d}{}\section{vtk\-Slider\-Representation3\-D}\label{vtkwidgets_vtksliderrepresentation3d}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to represent and render a vtk\-Slider\-Widget. To use this class, you must at a minimum specify the end points of the slider. Optional instance variable can be used to modify the appearance of the widget.

To create an instance of class vtk\-Slider\-Representation3\-D, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSliderRepresentation3D
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Slider\-Representation3\-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\-Slider\-Representation3\-D class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-New\-Instance ()} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Slider\-Representation3\-D = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for the class.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point1\-Coordinate ()} -\/ Position the first end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point1\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily obj.\-Set\-Point1\-In\-World\-Coordinates (double x, double y, double z)} -\/ Position the first end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point1\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily vtk\-Coordinate = obj.\-Get\-Point2\-Coordinate ()} -\/ Position the second end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point2\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily obj.\-Set\-Point2\-In\-World\-Coordinates (double x, double y, double z)} -\/ Position the second end point of the slider. Note that this point is an instance of vtk\-Coordinate, meaning that Point 1 can be specified in a variety of coordinate systems, and can even be relative to another point. To set the point, you'll want to get the Point2\-Coordinate and then invoke the necessary methods to put it into the correct coordinate system and set the correct initial value.  
\item {\ttfamily obj.\-Set\-Title\-Text (string )} -\/ Specify the title text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the title text is not displayed.  
\item {\ttfamily string = obj.\-Get\-Title\-Text ()} -\/ Specify the title text for this widget. If the value is not set, or set to the empty string \char`\"{}\char`\"{}, then the title text is not displayed.  
\item {\ttfamily obj.\-Set\-Slider\-Shape (int )} -\/ Specify whether to use a sphere or cylinder slider shape. By default, a sphere shape is used.  
\item {\ttfamily int = obj.\-Get\-Slider\-Shape\-Min\-Value ()} -\/ Specify whether to use a sphere or cylinder slider shape. By default, a sphere shape is used.  
\item {\ttfamily int = obj.\-Get\-Slider\-Shape\-Max\-Value ()} -\/ Specify whether to use a sphere or cylinder slider shape. By default, a sphere shape is used.  
\item {\ttfamily int = obj.\-Get\-Slider\-Shape ()} -\/ Specify whether to use a sphere or cylinder slider shape. By default, a sphere shape is used.  
\item {\ttfamily obj.\-Set\-Slider\-Shape\-To\-Sphere ()} -\/ Specify whether to use a sphere or cylinder slider shape. By default, a sphere shape is used.  
\item {\ttfamily obj.\-Set\-Slider\-Shape\-To\-Cylinder ()} -\/ Set the rotation of the slider widget around the axis of the widget. This is used to control which way the widget is initially oriented. (This is especially important for the label and title.)  
\item {\ttfamily obj.\-Set\-Rotation (double )} -\/ Set the rotation of the slider widget around the axis of the widget. This is used to control which way the widget is initially oriented. (This is especially important for the label and title.)  
\item {\ttfamily double = obj.\-Get\-Rotation ()} -\/ Set the rotation of the slider widget around the axis of the widget. This is used to control which way the widget is initially oriented. (This is especially important for the label and title.)  
\item {\ttfamily vtk\-Property = obj.\-Get\-Slider\-Property ()} -\/ Get the slider properties. The properties of the slider when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Tube\-Property ()} -\/ Get the properties for the tube and end caps.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Cap\-Property ()} -\/ Get the properties for the tube and end caps.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ Get the selection property. This property is used to modify the appearance of selected objects (e.\-g., the slider).  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily obj.\-Highlight (int )} -\/ Methods to interface with the vtk\-Slider\-Widget.  
\item {\ttfamily double = obj.\-Get\-Bounds ()}  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )}  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )}  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )}  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()}  
\item {\ttfamily long = obj.\-Get\-M\-Time ()} -\/ Override Get\-M\-Time to include point coordinates  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksliderwidget}{}\section{vtk\-Slider\-Widget}\label{vtkwidgets_vtksliderwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The vtk\-Slider\-Widget is used to set a scalar value in an application. This class assumes that a slider is moved along a 1\-D parameter space (e.\-g., a spherical bead that can be moved along a tube). Moving the slider modifies the value of the widget, which can be used to set parameters on other objects. Note that the actual appearance of the widget depends on the specific representation for the widget.

To use this widget, set the widget representation. The representation is assumed to consist of a tube, two end caps, and a slider (the details may vary depending on the particulars of the representation). Then in the representation you will typically set minimum and maximum value, as well as the current value. The position of the slider must also be set, as well as various properties.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If the slider bead is selected:
   LeftButtonPressEvent - select slider (if on slider)
   LeftButtonReleaseEvent - release slider (if selected)
   MouseMoveEvent - move slider
 If the end caps or slider tube are selected:
   LeftButtonPressEvent - move (or animate) to cap or point on tube;
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Slider\-Widget's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Move -- a request for slider motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Slider\-Widget invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Slider\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSliderWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Slider\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Slider\-Widget 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\-Slider\-Widget = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Slider\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Slider\-Representation r)} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily obj.\-Set\-Animation\-Mode (int )} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily int = obj.\-Get\-Animation\-Mode\-Min\-Value ()} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily int = obj.\-Get\-Animation\-Mode\-Max\-Value ()} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily int = obj.\-Get\-Animation\-Mode ()} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily obj.\-Set\-Animation\-Mode\-To\-Off ()} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily obj.\-Set\-Animation\-Mode\-To\-Jump ()} -\/ Control the behavior of the slider when selecting the tube or caps. If Jump, then selecting the tube, left cap, or right cap causes the slider to jump to the selection point. If the mode is Animate, the slider moves towards the selection point in Number\-Of\-Animation\-Steps number of steps. If Off, then the slider does not move.  
\item {\ttfamily obj.\-Set\-Animation\-Mode\-To\-Animate ()} -\/ Specify the number of animation steps to take if the animation mode is set to animate.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Animation\-Steps (int )} -\/ Specify the number of animation steps to take if the animation mode is set to animate.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Animation\-Steps\-Min\-Value ()} -\/ Specify the number of animation steps to take if the animation mode is set to animate.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Animation\-Steps\-Max\-Value ()} -\/ Specify the number of animation steps to take if the animation mode is set to animate.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Animation\-Steps ()} -\/ Specify the number of animation steps to take if the animation mode is set to animate.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkspherehandlerepresentation}{}\section{vtk\-Sphere\-Handle\-Representation}\label{vtkwidgets_vtkspherehandlerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a concrete implementation of vtk\-Handle\-Representation. It renders handles as spherical blobs in 3\-D space.

To create an instance of class vtk\-Sphere\-Handle\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphereHandleRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Handle\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Handle\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Sphere\-Handle\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Sphere\-Handle\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-World\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box. This method overloads the superclasses' Set\-World\-Position() and Set\-Display\-Position() in order to set the focal point of the cursor properly.  
\item {\ttfamily obj.\-Set\-Display\-Position (double p\mbox{[}3\mbox{]})} -\/ Set the position of the point in world and display coordinates. Note that if the position is set outside of the bounding box, it will be clamped to the boundary of the bounding box. This method overloads the superclasses' Set\-World\-Position() and Set\-Display\-Position() in order to set the focal point of the cursor properly.  
\item {\ttfamily obj.\-Set\-Translation\-Mode (int )} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). Otherwise, only the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button.)  
\item {\ttfamily int = obj.\-Get\-Translation\-Mode ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). Otherwise, only the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button.)  
\item {\ttfamily obj.\-Translation\-Mode\-On ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). Otherwise, only the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button.)  
\item {\ttfamily obj.\-Translation\-Mode\-Off ()} -\/ If translation mode is on, as the widget is moved the bounding box, shadows, and cursor are all translated simultaneously as the point moves (i.\-e., the left and middle mouse buttons act the same). Otherwise, only the cursor focal point moves, which is constrained by the bounds of the point representation. (Note that the bounds can be scaled up using the right mouse button.)  
\item {\ttfamily obj.\-Set\-Sphere\-Radius (double )}  
\item {\ttfamily double = obj.\-Get\-Sphere\-Radius ()}  
\item {\ttfamily obj.\-Set\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Selected\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Property ()} -\/ Set/\-Get the handle properties when unselected and selected.  
\item {\ttfamily obj.\-Set\-Hot\-Spot\-Size (double )} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Min\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size\-Max\-Value ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily double = obj.\-Get\-Hot\-Spot\-Size ()} -\/ Set the \char`\"{}hot spot\char`\"{} size; i.\-e., the region around the focus, in which the motion vector is used to control the constrained sliding action. Note the size is specified as a fraction of the length of the diagonal of the point widget's bounding box.  
\item {\ttfamily obj.\-Set\-Handle\-Size (double size)} -\/ Overload the superclasses Set\-Handle\-Size() method to update internal variables.  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods to make this class properly act like a vtk\-Widget\-Representation.  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Deep\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport viewport)} -\/ Methods to make this class behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods to make this class behave as a vtk\-Prop.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksphererepresentation}{}\section{vtk\-Sphere\-Representation}\label{vtkwidgets_vtksphererepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is a concrete representation for the vtk\-Sphere\-Widget2. It represents a sphere with an optional handle. Through interaction with the widget, the sphere can be arbitrarily positioned and scaled in 3\-D space; and the handle can be moved on the surface of the sphere. Typically the vtk\-Sphere\-Widget2/vtk\-Sphere\-Representation are used to position a sphere for the purpose of extracting, cutting or clipping data; or the handle is moved on the sphere to position a light or camera.

To use this representation, you normally use the Place\-Widget() method to position the widget at a specified region in space. It is also possible to set the center of the sphere, a radius, and/or a handle position.

To create an instance of class vtk\-Sphere\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphereRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for type information and to print out the contents of the class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for type information and to print out the contents of the class.  
\item {\ttfamily vtk\-Sphere\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for type information and to print out the contents of the class.  
\item {\ttfamily vtk\-Sphere\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for type information and to print out the contents of the class.  
\item {\ttfamily obj.\-Set\-Representation (int )} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily int = obj.\-Get\-Representation\-Min\-Value ()} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily int = obj.\-Get\-Representation\-Max\-Value ()} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily int = obj.\-Get\-Representation ()} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Off ()} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Wireframe ()} -\/ Set the representation (i.\-e., appearance) of the sphere. Different representations are useful depending on the application.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Surface ()} -\/ Set/\-Get the resolution of the sphere in the theta direction.  
\item {\ttfamily obj.\-Set\-Theta\-Resolution (int r)} -\/ Set/\-Get the resolution of the sphere in the theta direction.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution ()} -\/ Set/\-Get the resolution of the sphere in the phi direction.  
\item {\ttfamily obj.\-Set\-Phi\-Resolution (int r)} -\/ Set/\-Get the resolution of the sphere in the phi direction.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution ()} -\/ Set/\-Get the center position of the sphere. Note that this may adjust the direction from the handle to the center, as well as the radius of the sphere.  
\item {\ttfamily obj.\-Set\-Center (double c\mbox{[}3\mbox{]})} -\/ Set/\-Get the center position of the sphere. Note that this may adjust the direction from the handle to the center, as well as the radius of the sphere.  
\item {\ttfamily obj.\-Set\-Center (double x, double y, double z)} -\/ Set/\-Get the center position of the sphere. Note that this may adjust the direction from the handle to the center, as well as the radius of the sphere.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Set/\-Get the center position of the sphere. Note that this may adjust the direction from the handle to the center, as well as the radius of the sphere.  
\item {\ttfamily obj.\-Get\-Center (double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the radius of sphere. Default is 0.\-5. Note that this may modify the position of the handle based on the handle direction.  
\item {\ttfamily obj.\-Set\-Radius (double r)} -\/ Set/\-Get the radius of sphere. Default is 0.\-5. Note that this may modify the position of the handle based on the handle direction.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Set\-Handle\-Visibility (int )} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily int = obj.\-Get\-Handle\-Visibility ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Handle\-Visibility\-On ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Handle\-Visibility\-Off ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Set\-Handle\-Position (double handle\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the handle. Note that this may adjust the radius of the sphere and the handle direction.  
\item {\ttfamily obj.\-Set\-Handle\-Position (double x, double y, double z)} -\/ Set/\-Get the position of the handle. Note that this may adjust the radius of the sphere and the handle direction.  
\item {\ttfamily double = obj. Get\-Handle\-Position ()} -\/ Set/\-Get the position of the handle. Note that this may adjust the radius of the sphere and the handle direction.  
\item {\ttfamily obj.\-Set\-Handle\-Direction (double dir\mbox{[}3\mbox{]})} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. This may affect the position of the handle and the radius of the sphere.  
\item {\ttfamily obj.\-Set\-Handle\-Direction (double dx, double dy, double dz)} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. This may affect the position of the handle and the radius of the sphere.  
\item {\ttfamily double = obj. Get\-Handle\-Direction ()} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. This may affect the position of the handle and the radius of the sphere.  
\item {\ttfamily obj.\-Set\-Handle\-Text (int )} -\/ Enable/disable a label that displays the location of the handle in spherical coordinates (radius,theta,phi). The two angles, theta and phi, are displayed in degrees. Note that phi is measured from the north pole down towards the equator; and theta is the angle around the north/south axis.  
\item {\ttfamily int = obj.\-Get\-Handle\-Text ()} -\/ Enable/disable a label that displays the location of the handle in spherical coordinates (radius,theta,phi). The two angles, theta and phi, are displayed in degrees. Note that phi is measured from the north pole down towards the equator; and theta is the angle around the north/south axis.  
\item {\ttfamily obj.\-Handle\-Text\-On ()} -\/ Enable/disable a label that displays the location of the handle in spherical coordinates (radius,theta,phi). The two angles, theta and phi, are displayed in degrees. Note that phi is measured from the north pole down towards the equator; and theta is the angle around the north/south axis.  
\item {\ttfamily obj.\-Handle\-Text\-Off ()} -\/ Enable/disable a label that displays the location of the handle in spherical coordinates (radius,theta,phi). The two angles, theta and phi, are displayed in degrees. Note that phi is measured from the north pole down towards the equator; and theta is the angle around the north/south axis.  
\item {\ttfamily obj.\-Set\-Radial\-Line (int )} -\/ Enable/disable a radial line segment that joins the center of the outer sphere and the handle.  
\item {\ttfamily int = obj.\-Get\-Radial\-Line ()} -\/ Enable/disable a radial line segment that joins the center of the outer sphere and the handle.  
\item {\ttfamily obj.\-Radial\-Line\-On ()} -\/ Enable/disable a radial line segment that joins the center of the outer sphere and the handle.  
\item {\ttfamily obj.\-Radial\-Line\-Off ()} -\/ Enable/disable a radial line segment that joins the center of the outer sphere and the handle.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the sphere. The polydata consists of n+1 points, where n is the resolution of the sphere. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polysphere are added to it.  
\item {\ttfamily obj.\-Get\-Sphere (vtk\-Sphere sphere)} -\/ Get the spherical implicit function defined by this widget. Note that vtk\-Sphere is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Sphere\-Property ()} -\/ Get the sphere properties. The properties of the sphere when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Sphere\-Property ()} -\/ Get the sphere properties. The properties of the sphere when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little ball on the sphere is the handle). The properties of the handle when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little ball on the sphere is the handle). The properties of the handle when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Text\-Property = obj.\-Get\-Handle\-Text\-Property ()} -\/ Get the handle text property. This can be used to control the appearance of the handle text.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Radial\-Line\-Property ()} -\/ Get the property of the radial line. This can be used to control the appearance of the optional line connecting the center to the handle.  
\item {\ttfamily obj.\-Set\-Interaction\-State (int state)} -\/ The interaction state may be set from a widget (e.\-g., vtk\-Sphere\-Widget2) or other object. This controls how the interaction with the widget proceeds. Normally this method is used as part of a handshaking process with the widget\-: First Compute\-Interaction\-State() is invoked that returns a state based on geometric considerations (i.\-e., cursor near a widget feature), then based on events, the widget may modify this further.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Place\-Widget (double center\mbox{[}3\mbox{]}, double handle\-Position\mbox{[}3\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods supporting, and required by, the rendering process.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkspherewidget}{}\section{vtk\-Sphere\-Widget}\label{vtkwidgets_vtkspherewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a sphere that can be interactively placed in a scene.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. The interactor will act normally until the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, at which point the vtk\-Sphere\-Widget will appear. (See superclass documentation for information about changing this behavior.) Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method).

The vtk\-Sphere\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Set/\-Get\-Theta\-Resolution() and Set/\-Get\-Phi\-Resolution() methods control the number of subdivisions of the sphere in the theta and phi directions; the Get\-Poly\-Data() method can be used to get the polygonal representation and can be used for things like seeding streamlines. The Get\-Sphere() method returns a sphere implicit function that can be used for cutting and clipping. Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (any mouse button).

Some additional features of this class include the ability to control the properties of the widget. You can set the properties of the selected and unselected representations of the sphere.

To create an instance of class vtk\-Sphere\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphereWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Sphere\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Sphere\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily obj.\-Set\-Representation (int )} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily int = obj.\-Get\-Representation\-Min\-Value ()} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily int = obj.\-Get\-Representation\-Max\-Value ()} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily int = obj.\-Get\-Representation ()} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Off ()} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Wireframe ()} -\/ Set the representation of the sphere. Different representations are useful depending on the application. The default is V\-T\-K\-\_\-\-S\-P\-H\-E\-R\-E\-\_\-\-W\-I\-R\-E\-F\-R\-A\-M\-E.  
\item {\ttfamily obj.\-Set\-Representation\-To\-Surface ()} -\/ Set/\-Get the resolution of the sphere in the Theta direction. The default is 16.  
\item {\ttfamily obj.\-Set\-Theta\-Resolution (int r)} -\/ Set/\-Get the resolution of the sphere in the Theta direction. The default is 16.  
\item {\ttfamily int = obj.\-Get\-Theta\-Resolution ()} -\/ Set/\-Get the resolution of the sphere in the Phi direction. The default is 8.  
\item {\ttfamily obj.\-Set\-Phi\-Resolution (int r)} -\/ Set/\-Get the resolution of the sphere in the Phi direction. The default is 8.  
\item {\ttfamily int = obj.\-Get\-Phi\-Resolution ()} -\/ Set/\-Get the radius of sphere. Default is .5.  
\item {\ttfamily obj.\-Set\-Radius (double r)} -\/ Set/\-Get the radius of sphere. Default is .5.  
\item {\ttfamily double = obj.\-Get\-Radius ()} -\/ Set/\-Get the center of the sphere.  
\item {\ttfamily obj.\-Set\-Center (double x, double y, double z)} -\/ Set/\-Get the center of the sphere.  
\item {\ttfamily obj.\-Set\-Center (double x\mbox{[}3\mbox{]})} -\/ Set/\-Get the center of the sphere.  
\item {\ttfamily double = obj.\-Get\-Center ()} -\/ Set/\-Get the center of the sphere.  
\item {\ttfamily obj.\-Get\-Center (double xyz\mbox{[}3\mbox{]})} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Set\-Translation (int )} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily int = obj.\-Get\-Translation ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Translation\-On ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Translation\-Off ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Set\-Scale (int )} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily int = obj.\-Get\-Scale ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Scale\-On ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Scale\-Off ()} -\/ Enable translation and scaling of the widget. By default, the widget can be translated and rotated.  
\item {\ttfamily obj.\-Set\-Handle\-Visibility (int )} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily int = obj.\-Get\-Handle\-Visibility ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Handle\-Visibility\-On ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Handle\-Visibility\-Off ()} -\/ The handle sits on the surface of the sphere and may be moved around the surface by picking (left mouse) and then moving. The position of the handle can be retrieved, this is useful for positioning cameras and lights. By default, the handle is turned off.  
\item {\ttfamily obj.\-Set\-Handle\-Direction (double , double , double )} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. The direction of the handle is from the sphere center to the handle position.  
\item {\ttfamily obj.\-Set\-Handle\-Direction (double a\mbox{[}3\mbox{]})} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. The direction of the handle is from the sphere center to the handle position.  
\item {\ttfamily double = obj. Get\-Handle\-Direction ()} -\/ Set/\-Get the direction vector of the handle relative to the center of the sphere. The direction of the handle is from the sphere center to the handle position.  
\item {\ttfamily double = obj. Get\-Handle\-Position ()} -\/ Get the position of the handle.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the sphere. The polydata consists of n+1 points, where n is the resolution of the sphere. These point values are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polysphere are added to it.  
\item {\ttfamily obj.\-Get\-Sphere (vtk\-Sphere sphere)} -\/ Get the spherical implicit function defined by this widget. Note that vtk\-Sphere is a subclass of vtk\-Implicit\-Function, meaning that it can be used by a variety of filters to perform clipping, cutting, and selection of data.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Sphere\-Property ()} -\/ Get the sphere properties. The properties of the sphere when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Sphere\-Property ()} -\/ Get the sphere properties. The properties of the sphere when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Get the handle properties (the little ball on the sphere is the handle). The properties of the handle when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Get the handle properties (the little ball on the sphere is the handle). The properties of the handle when selected and unselected can be manipulated.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkspherewidget2}{}\section{vtk\-Sphere\-Widget2}\label{vtkwidgets_vtkspherewidget2}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget interacts with a vtk\-Sphere\-Representation class (i.\-e., it handles the events that drive its corresponding representation). It can be used to position a point on a sphere (for example, to place a light or camera), or to position a sphere in a scene, including translating and scaling the sphere.

A nice feature of vtk\-Sphere\-Widget2, like any 3\-D widget, is that it will work in combination with the current interactor style (or any other interactor observer). That is, if vtk\-Sphere\-Widget2 does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Sphere\-Widget2 will terminate the processing of the event that it handles.

To use this widget, you generally pair it with a vtk\-Sphere\-Representation (or a subclass). Variuos options are available in the representation for controlling how the widget appears, and how the widget functions.

.S\-E\-C\-T\-I\-O\-N Event Bindings By default, the widget responds to the following V\-T\-K events (i.\-e., it watches the vtk\-Render\-Window\-Interactor for these events)\-: 
\begin{DoxyPre}
 If the handle or sphere are selected:
   LeftButtonPressEvent - select the handle or sphere
   LeftButtonReleaseEvent - release the handle ot sphere
   MouseMoveEvent - move the handle or translate the sphere
 In all the cases, independent of what is picked, the widget responds to the 
 following VTK events:
   MiddleButtonPressEvent - translate the representation
   MiddleButtonReleaseEvent - stop translating the representation
   RightButtonPressEvent - scale the widget's representation
   RightButtonReleaseEvent - stop scaling the representation
   MouseMoveEvent - scale (if right button) or move (if middle button) the widget
 \end{DoxyPre}


Note that the event bindings described above can be changed using this class's vtk\-Widget\-Event\-Translator. This class translates V\-T\-K events into the vtk\-Sphere\-Widget2's widget events\-: 
\begin{DoxyPre}
   vtkWidgetEvent::Select -- some part of the widget has been selected
   vtkWidgetEvent::EndSelect -- the selection process has completed
   vtkWidgetEvent::Scale -- some part of the widget has been selected
   vtkWidgetEvent::EndScale -- the selection process has completed
   vtkWidgetEvent::Translate -- some part of the widget has been selected
   vtkWidgetEvent::EndTranslate -- the selection process has completed
   vtkWidgetEvent::Move -- a request for motion has been invoked
 \end{DoxyPre}


In turn, when these widget events are processed, the vtk\-Sphere\-Widget2 invokes the following V\-T\-K events on itself (which observers can listen for)\-: 
\begin{DoxyPre}
   vtkCommand::StartInteractionEvent (on vtkWidgetEvent::Select)
   vtkCommand::EndInteractionEvent (on vtkWidgetEvent::EndSelect)
   vtkCommand::InteractionEvent (on vtkWidgetEvent::Move)
 \end{DoxyPre}


To create an instance of class vtk\-Sphere\-Widget2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSphereWidget2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Sphere\-Widget2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Sphere\-Widget2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard class methods for type information and printing.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard class methods for type information and printing.  
\item {\ttfamily vtk\-Sphere\-Widget2 = obj.\-New\-Instance ()} -\/ Standard class methods for type information and printing.  
\item {\ttfamily vtk\-Sphere\-Widget2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard class methods for type information and printing.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Sphere\-Representation r)} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Translation\-Enabled (int )} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Translation\-Enabled ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-On ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Translation\-Enabled\-Off ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Set\-Scaling\-Enabled (int )} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily int = obj.\-Get\-Scaling\-Enabled ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-On ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Scaling\-Enabled\-Off ()} -\/ Control the behavior of the widget (i.\-e., how it processes events). Translation, and scaling can all be enabled and disabled.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set. By default, this is an instance of the vtk\-Sphere\-Representation class.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksplinerepresentation}{}\section{vtk\-Spline\-Representation}\label{vtkwidgets_vtksplinerepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spline\-Representation is a vtk\-Widget\-Representation for a spline. This 3\-D widget defines a spline that can be interactively placed in a scene. The spline has handles, the number of which can be changed, plus it can be picked on the spline itself to translate or rotate it in the scene. This is based on vtk\-Spline\-Widget.

To create an instance of class vtk\-Spline\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSplineRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spline\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spline\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spline\-Representation = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spline\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Interaction\-State (int )}  
\item {\ttfamily obj.\-Set\-Project\-To\-Plane (int )} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the Interaction\-State changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily int = obj.\-Get\-Project\-To\-Plane ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the Interaction\-State changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Project\-To\-Plane\-On ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the Interaction\-State changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Project\-To\-Plane\-Off ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the Interaction\-State changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Set\-Plane\-Source (vtk\-Plane\-Source plane)} -\/ Set up a reference to a vtk\-Plane\-Source that could be from another widget object, e.\-g. a vtk\-Poly\-Data\-Source\-Widget.  
\item {\ttfamily obj.\-Set\-Projection\-Normal (int )}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Min\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Max\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-X\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Y\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Z\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Oblique ()} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily obj.\-Set\-Projection\-Position (double position)} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily double = obj.\-Get\-Projection\-Position ()} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the spline. The polydata consists of points and line segments numbering Resolution + 1 and Resoltuion, respectively. Points are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polyline are added to it.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Handles (int npts)} -\/ Set/\-Get the number of handles for this widget.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Handles ()} -\/ Set/\-Get the number of handles for this widget.  
\item {\ttfamily obj.\-Set\-Resolution (int resolution)} -\/ Set/\-Get the number of line segments representing the spline for this widget.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the number of line segments representing the spline for this widget.  
\item {\ttfamily obj.\-Set\-Parametric\-Spline (vtk\-Parametric\-Spline )} -\/ Set the parametric spline object. Through vtk\-Parametric\-Spline's A\-P\-I, the user can supply and configure one of currently two types of spline\-: vtk\-Cardinal\-Spline, vtk\-Kochanek\-Spline. The widget controls the open or closed configuration of the spline. W\-A\-R\-N\-I\-N\-G\-: The widget does not enforce internal consistency so that all three are of the same type.  
\item {\ttfamily vtk\-Parametric\-Spline = obj.\-Get\-Parametric\-Spline ()} -\/ Set the parametric spline object. Through vtk\-Parametric\-Spline's A\-P\-I, the user can supply and configure one of currently two types of spline\-: vtk\-Cardinal\-Spline, vtk\-Kochanek\-Spline. The widget controls the open or closed configuration of the spline. W\-A\-R\-N\-I\-N\-G\-: The widget does not enforce internal consistency so that all three are of the same type.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double x, double y, double z)} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Get\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily vtk\-Double\-Array = obj.\-Get\-Handle\-Positions ()} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Set\-Closed (int closed)} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily int = obj.\-Get\-Closed ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily obj.\-Closed\-On ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily obj.\-Closed\-Off ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily int = obj.\-Is\-Closed ()} -\/ Convenience method to determine whether the spline is closed in a geometric sense. The widget may be set \char`\"{}closed\char`\"{} but still be geometrically open (e.\-g., a straight line).  
\item {\ttfamily double = obj.\-Get\-Summed\-Length ()} -\/ Get the approximate vs. the true arc length of the spline. Calculated as the summed lengths of the individual straight line segments. Use Set\-Resolution to control the accuracy.  
\item {\ttfamily obj.\-Initialize\-Handles (vtk\-Points points)} -\/ Convenience method to allocate and set the handles from a vtk\-Points instance. If the first and last points are the same, the spline sets Closed to the on Interaction\-State and disregards the last point, otherwise Closed remains unchanged.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-End\-Widget\-Interaction (double e\mbox{[}2\mbox{]})} -\/ These are methods that satisfy vtk\-Widget\-Representation's A\-P\-I. Note that a version of place widget is available where the center and handle position are specified.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ Methods supporting, and required by, the rendering process.  
\item {\ttfamily obj.\-Set\-Line\-Color (double r, double g, double b)} -\/ Convenience method to set the line color. Ideally one should use Get\-Line\-Property()-\/$>$Set\-Color().  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksplinewidget}{}\section{vtk\-Spline\-Widget}\label{vtkwidgets_vtksplinewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This 3\-D widget defines a spline that can be interactively placed in a scene. The spline has handles, the number of which can be changed, plus it can be picked on the spline itself to translate or rotate it in the scene. A nice feature of the object is that the vtk\-Spline\-Widget, like any 3\-D widget, will work with the current interactor style. That is, if vtk\-Spline\-Widget does not handle an event, then all other registered observers (including the interactor style) have an opportunity to process the event. Otherwise, the vtk\-Spline\-Widget will terminate the processing of the event that it handles.

To use this object, just invoke Set\-Interactor() with the argument of the method a vtk\-Render\-Window\-Interactor. You may also wish to invoke \char`\"{}\-Place\-Widget()\char`\"{} to initially position the widget. The interactor will act normally until the \char`\"{}i\char`\"{} key (for \char`\"{}interactor\char`\"{}) is pressed, at which point the vtk\-Spline\-Widget will appear. (See superclass documentation for information about changing this behavior.) Events that occur outside of the widget (i.\-e., no part of the widget is picked) are propagated to any other registered obsevers (such as the interaction style). Turn off the widget by pressing the \char`\"{}i\char`\"{} key again (or invoke the Off() method).

The button actions and key modifiers are as follows for controlling the widget\-: 1) left button down on and drag one of the spherical handles to change the shape of the spline\-: the handles act as \char`\"{}control points\char`\"{}. 2) left button or middle button down on a line segment forming the spline allows uniform translation of the widget. 3) ctrl + middle button down on the widget enables spinning of the widget about its center. 4) right button down on the widget enables scaling of the widget. By moving the mouse \char`\"{}up\char`\"{} the render window the spline will be made bigger; by moving \char`\"{}down\char`\"{} the render window the widget will be made smaller. 5) ctrl key + right button down on any handle will erase it providing there will be two or more points remaining to form a spline. 6) shift key + right button down on any line segment will insert a handle onto the spline at the cursor position.

The vtk\-Spline\-Widget has several methods that can be used in conjunction with other V\-T\-K objects. The Set/\-Get\-Resolution() methods control the number of subdivisions of the spline; the Get\-Poly\-Data() method can be used to get the polygonal representation and can be used for things like seeding streamlines or probing other data sets. Typical usage of the widget is to make use of the Start\-Interaction\-Event, Interaction\-Event, and End\-Interaction\-Event events. The Interaction\-Event is called on mouse motion; the other two events are called on button down and button up (either left or right button).

Some additional features of this class include the ability to control the properties of the widget. You can set the properties of the selected and unselected representations of the spline. For example, you can set the property for the handles and spline. In addition there are methods to constrain the spline so that it is aligned with a plane. Note that a simple ruler widget can be derived by setting the resolution to 1, the number of handles to 2, and calling the Get\-Summed\-Length method!

To create an instance of class vtk\-Spline\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSplineWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spline\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spline\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spline\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spline\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double bounds\mbox{[}6\mbox{]})} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget ()} -\/ Methods that satisfy the superclass' A\-P\-I.  
\item {\ttfamily obj.\-Place\-Widget (double xmin, double xmax, double ymin, double ymax, double zmin, double zmax)} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Set\-Project\-To\-Plane (int )} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily int = obj.\-Get\-Project\-To\-Plane ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Project\-To\-Plane\-On ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Project\-To\-Plane\-Off ()} -\/ Force the spline widget to be projected onto one of the orthogonal planes. Remember that when the state changes, a Modified\-Event is invoked. This can be used to snap the spline to the plane if it is orginally not aligned. The normal in Set\-Projection\-Normal is 0,1,2 for Y\-Z,X\-Z,X\-Y planes respectively and 3 for arbitrary oblique planes when the widget is tied to a vtk\-Plane\-Source.  
\item {\ttfamily obj.\-Set\-Plane\-Source (vtk\-Plane\-Source plane)} -\/ Set up a reference to a vtk\-Plane\-Source that could be from another widget object, e.\-g. a vtk\-Poly\-Data\-Source\-Widget.  
\item {\ttfamily obj.\-Set\-Projection\-Normal (int )}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Min\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal\-Max\-Value ()}  
\item {\ttfamily int = obj.\-Get\-Projection\-Normal ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-X\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Y\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Z\-Axes ()}  
\item {\ttfamily obj.\-Set\-Projection\-Normal\-To\-Oblique ()} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily obj.\-Set\-Projection\-Position (double position)} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily double = obj.\-Get\-Projection\-Position ()} -\/ Set the position of spline handles and points in terms of a plane's position. i.\-e., if Projection\-Normal is 0, all of the x-\/coordinate values of the points are set to position. Any value can be passed (and is ignored) to update the spline points when Projection normal is set to 3 for arbritrary plane orientations.  
\item {\ttfamily obj.\-Get\-Poly\-Data (vtk\-Poly\-Data pd)} -\/ Grab the polydata (including points) that defines the spline. The polydata consists of points and line segments numbering Resolution + 1 and Resoltuion, respectively. Points are guaranteed to be up-\/to-\/date when either the Interaction\-Event or End\-Interaction events are invoked. The user provides the vtk\-Poly\-Data and the points and polyline are added to it.  
\item {\ttfamily obj.\-Set\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Selected\-Handle\-Property (vtk\-Property )} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Handle\-Property ()} -\/ Set/\-Get the handle properties (the spheres are the handles). The properties of the handles when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Line\-Property (vtk\-Property )} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Selected\-Line\-Property (vtk\-Property )} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily vtk\-Property = obj.\-Get\-Selected\-Line\-Property ()} -\/ Set/\-Get the line properties. The properties of the line when selected and unselected can be manipulated.  
\item {\ttfamily obj.\-Set\-Number\-Of\-Handles (int npts)} -\/ Set/\-Get the number of handles for this widget.  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Handles ()} -\/ Set/\-Get the number of handles for this widget.  
\item {\ttfamily obj.\-Set\-Resolution (int resolution)} -\/ Set/\-Get the number of line segments representing the spline for this widget.  
\item {\ttfamily int = obj.\-Get\-Resolution ()} -\/ Set/\-Get the number of line segments representing the spline for this widget.  
\item {\ttfamily obj.\-Set\-Parametric\-Spline (vtk\-Parametric\-Spline )} -\/ Set the parametric spline object. Through vtk\-Parametric\-Spline's A\-P\-I, the user can supply and configure one of currently two types of spline\-: vtk\-Cardinal\-Spline, vtk\-Kochanek\-Spline. The widget controls the open or closed configuration of the spline. W\-A\-R\-N\-I\-N\-G\-: The widget does not enforce internal consistency so that all three are of the same type.  
\item {\ttfamily vtk\-Parametric\-Spline = obj.\-Get\-Parametric\-Spline ()} -\/ Set the parametric spline object. Through vtk\-Parametric\-Spline's A\-P\-I, the user can supply and configure one of currently two types of spline\-: vtk\-Cardinal\-Spline, vtk\-Kochanek\-Spline. The widget controls the open or closed configuration of the spline. W\-A\-R\-N\-I\-N\-G\-: The widget does not enforce internal consistency so that all three are of the same type.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double x, double y, double z)} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Set\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Get\-Handle\-Position (int handle, double xyz\mbox{[}3\mbox{]})} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily double = obj.\-Get\-Handle\-Position (int handle)} -\/ Set/\-Get the position of the spline handles. Call Get\-Number\-Of\-Handles to determine the valid range of handle indices.  
\item {\ttfamily obj.\-Set\-Closed (int closed)} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily int = obj.\-Get\-Closed ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily obj.\-Closed\-On ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily obj.\-Closed\-Off ()} -\/ Control whether the spline is open or closed. A closed spline forms a continuous loop\-: the first and last points are the same, and derivatives are continuous. A minimum of 3 handles are required to form a closed loop. This method enforces consistency with user supplied subclasses of vtk\-Spline.  
\item {\ttfamily int = obj.\-Is\-Closed ()} -\/ Convenience method to determine whether the spline is closed in a geometric sense. The widget may be set \char`\"{}closed\char`\"{} but still be geometrically open (e.\-g., a straight line).  
\item {\ttfamily double = obj.\-Get\-Summed\-Length ()} -\/ Get the approximate vs. the true arc length of the spline. Calculated as the summed lengths of the individual straight line segments. Use Set\-Resolution to control the accuracy.  
\item {\ttfamily obj.\-Initialize\-Handles (vtk\-Points points)} -\/ Convenience method to allocate and set the handles from a vtk\-Points instance. If the first and last points are the same, the spline sets Closed to the on state and disregards the last point, otherwise Closed remains unchanged.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtksplinewidget2}{}\section{vtk\-Spline\-Widget2}\label{vtkwidgets_vtksplinewidget2}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Spline\-Widget2 is the vtk\-Abstract\-Widget subclass for vtk\-Spline\-Representation which manages the interactions with vtk\-Spline\-Representation. This is based on vtk\-Spline\-Widget.

To create an instance of class vtk\-Spline\-Widget2, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkSplineWidget2
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Spline\-Widget2 has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Spline\-Widget2 class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-Spline\-Widget2 = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-Spline\-Widget2 = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Spline\-Representation r)} -\/ Create the default widget representation if one is not set. By default, this is an instance of the vtk\-Spline\-Representation class.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set. By default, this is an instance of the vtk\-Spline\-Representation class.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtktensorproberepresentation}{}\section{vtk\-Tensor\-Probe\-Representation}\label{vtkwidgets_vtktensorproberepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class serves as an abstract geometrical representation for the vtk\-Tensor\-Probe\-Widget. It is left to the concrete implementation to render the tensors as it desires. For instance, vtk\-Ellipsoid\-Tensor\-Probe\-Representation renders the tensors as ellipsoids.

To create an instance of class vtk\-Tensor\-Probe\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTensorProbeRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tensor\-Probe\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tensor\-Probe\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Tensor\-Probe\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Tensor\-Probe\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ See vtk\-Widget\-Representation for details.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ See vtk\-Widget\-Representation for details.  
\item {\ttfamily obj.\-Set\-Probe\-Position (double , double , double )} -\/ Set the position of the Tensor probe.  
\item {\ttfamily obj.\-Set\-Probe\-Position (double a\mbox{[}3\mbox{]})} -\/ Set the position of the Tensor probe.  
\item {\ttfamily double = obj. Get\-Probe\-Position ()} -\/ Set the position of the Tensor probe.  
\item {\ttfamily obj.\-Set\-Probe\-Cell\-Id (vtk\-Id\-Type )} -\/ Set the position of the Tensor probe.  
\item {\ttfamily vtk\-Id\-Type = obj.\-Get\-Probe\-Cell\-Id ()} -\/ Set the position of the Tensor probe.  
\item {\ttfamily obj.\-Set\-Trajectory (vtk\-Poly\-Data )} -\/ Set the trajectory that we are trying to probe tensors on  
\item {\ttfamily obj.\-Initialize ()} -\/ Set the probe position to a reasonable location on the trajectory.  
\item {\ttfamily int = obj.\-Select\-Probe (int pos\mbox{[}2\mbox{]})} -\/ This method is invoked by the widget during user interaction. Can we pick the tensor glyph at the current cursor pos  
\item {\ttfamily int = obj.\-Move (double motion\-Vector\mbox{[}2\mbox{]})} -\/ I\-N\-T\-E\-R\-N\-A\-L -\/ Do not use This method is invoked by the widget during user interaction. Move probe based on the position and the motion vector.  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ See vtk\-Prop for details.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ See vtk\-Prop for details.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtktensorprobewidget}{}\section{vtk\-Tensor\-Probe\-Widget}\label{vtkwidgets_vtktensorprobewidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class is used to probe tensors on a trajectory. The representation (vtk\-Tensor\-Probe\-Representation) is free to choose its own method of rendering the tensors. For instance vtk\-Ellipsoid\-Tensor\-Probe\-Representation renders the tensors as ellipsoids. The interactions of the widget are controlled by the left mouse button. A left click on the tensor selects it. It can dragged around the trajectory to probe the tensors on it.

For instance dragging the ellipsoid around with vtk\-Ellipsoid\-Tensor\-Probe\-Representation will manifest itself with the ellipsoid shape changing as needed along the trajectory.

To create an instance of class vtk\-Tensor\-Probe\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTensorProbeWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Tensor\-Probe\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Tensor\-Probe\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Tensor\-Probe\-Widget = obj.\-New\-Instance ()} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily vtk\-Tensor\-Probe\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K class macros.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Tensor\-Probe\-Representation r)} -\/ See vtk\-Widget\-Representation for details.  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ See vtk\-Widget\-Representation for details.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkterraincontourlineinterpolator}{}\section{vtk\-Terrain\-Contour\-Line\-Interpolator}\label{vtkwidgets_vtkterraincontourlineinterpolator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Terrain\-Contour\-Line\-Interpolator interpolates nodes on height field data. The class is meant to be used in conjunciton with a vtk\-Contour\-Widget, enabling you to draw paths on terrain data. The class internally uses a vtk\-Projected\-Terrain\-Path. Users can set kind of interpolation desired between two node points by setting the modes of the this filter. For instance\-:

\begin{DoxyVerb} contourRepresentation->SetLineInterpolator(interpolator);
 interpolator->SetImageData( demDataFile );
 interpolator->GetProjector()->SetProjectionModeToHug();
 interpolator->SetHeightOffset(25.0);\end{DoxyVerb}


You are required to set the Image\-Data to this class as the height-\/field image.

To create an instance of class vtk\-Terrain\-Contour\-Line\-Interpolator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTerrainContourLineInterpolator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Terrain\-Contour\-Line\-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\-Terrain\-Contour\-Line\-Interpolator class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Terrain\-Contour\-Line\-Interpolator = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Terrain\-Contour\-Line\-Interpolator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Interpolate\-Line (vtk\-Renderer ren, vtk\-Contour\-Representation rep, int idx1, int idx2)} -\/ Interpolate to create lines between contour nodes idx1 and idx2. Depending on the projection mode, the interpolated line may either hug the terrain, just connect the two points with a straight line or a non-\/occluded interpolation. Used internally by vtk\-Contour\-Representation.  
\item {\ttfamily int = obj.\-Update\-Node (vtk\-Renderer , vtk\-Contour\-Representation , double , int )} -\/ The interpolator is given a chance to update the node. Used internally by vtk\-Contour\-Representation Returns 0 if the node (world position) is unchanged.  
\item {\ttfamily obj.\-Set\-Image\-Data (vtk\-Image\-Data )} -\/ Set the height field data. The height field data is a 2\-D image. The scalars in the image represent the height field. This must be set.  
\item {\ttfamily vtk\-Image\-Data = obj.\-Get\-Image\-Data ()} -\/ Set the height field data. The height field data is a 2\-D image. The scalars in the image represent the height field. This must be set.  
\item {\ttfamily vtk\-Projected\-Terrain\-Path = obj.\-Get\-Projector ()} -\/ Get the vtk\-Projected\-Terrain\-Path operator used to project the terrain onto the data. This operator has several modes, See the documentation of vtk\-Projected\-Terrain\-Path. The default mode is to hug the terrain data at 0 height offset.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkterraindatapointplacer}{}\section{vtk\-Terrain\-Data\-Point\-Placer}\label{vtkwidgets_vtkterraindatapointplacer}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Terrain\-Data\-Point\-Placer dictates the placement of points on height field data. The class takes as input the list of props that represent the terrain in a rendered scene. A height offset can be specified to dicatate the placement of points at a certain height above the surface.

.S\-E\-C\-T\-I\-O\-N Usage A typical usage of this class is as follows\-: \begin{DoxyVerb} pointPlacer->AddProp(demActor);    // the actor(s) containing the terrain.
 rep->SetPointPlacer(pointPlacer);
 pointPlacer->SetHeightOffset( 100 );\end{DoxyVerb}


To create an instance of class vtk\-Terrain\-Data\-Point\-Placer, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTerrainDataPointPlacer
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Terrain\-Data\-Point\-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\-Terrain\-Data\-Point\-Placer class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Terrain\-Data\-Point\-Placer = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Terrain\-Data\-Point\-Placer = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Add\-Prop (vtk\-Prop )}  
\item {\ttfamily obj.\-Remove\-All\-Props ()}  
\item {\ttfamily obj.\-Set\-Height\-Offset (double )} -\/ This is the height above (or below) the terrain that the dictated point should be placed. Positive values indicate distances above the terrain; negative values indicate distances below the terrain. The default is 0.\-0.  
\item {\ttfamily double = obj.\-Get\-Height\-Offset ()} -\/ This is the height above (or below) the terrain that the dictated point should be placed. Positive values indicate distances above the terrain; negative values indicate distances below the terrain. The default is 0.\-0.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer and a display position in pixel coordinates, compute the world position and orientation where this point will be placed. This method is typically used by the representation to place the point initially. For the Terrain point placer this computes world points that lie at the specified height above the terrain.  
\item {\ttfamily int = obj.\-Compute\-World\-Position (vtk\-Renderer ren, double display\-Pos\mbox{[}2\mbox{]}, double ref\-World\-Pos\mbox{[}3\mbox{]}, double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a renderer, a display position, and a reference world position, compute the new world position and orientation of this point. This method is typically used by the representation to move the point.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]})} -\/ Given a world position check the validity of this position according to the constraints of the placer  
\item {\ttfamily int = obj.\-Validate\-Display\-Position (vtk\-Renderer , double display\-Pos\mbox{[}2\mbox{]})} -\/ Given a display position, check the validity of this position.  
\item {\ttfamily int = obj.\-Validate\-World\-Position (double world\-Pos\mbox{[}3\mbox{]}, double world\-Orient\mbox{[}9\mbox{]})} -\/ Given a world position and a world orientation, validate it according to the constraints of the placer.  
\item {\ttfamily vtk\-Prop\-Picker = obj.\-Get\-Prop\-Picker ()} -\/ Get the Prop picker.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtktextrepresentation}{}\section{vtk\-Text\-Representation}\label{vtkwidgets_vtktextrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class represents text for a vtk\-Text\-Widget. This class provides support for interactively placing text on the 2\-D overlay plane. The text is defined by an instance of vtk\-Text\-Actor.

To create an instance of class vtk\-Text\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Text\-Representation = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Text\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Text\-Actor (vtk\-Text\-Actor text\-Actor)} -\/ Specify the vtk\-Text\-Actor to manage. If not specified, then one is automatically created.  
\item {\ttfamily vtk\-Text\-Actor = obj.\-Get\-Text\-Actor ()} -\/ Specify the vtk\-Text\-Actor to manage. If not specified, then one is automatically created.  
\item {\ttfamily obj.\-Set\-Text (string text)} -\/ Get/\-Set the text string display by this representation.  
\item {\ttfamily string = obj.\-Get\-Text ()} -\/ Get/\-Set the text string display by this representation.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Satisfy the superclasses A\-P\-I.  
\item {\ttfamily obj.\-Get\-Size (double size\mbox{[}2\mbox{]})} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()} -\/ These methods are necessary to make this representation behave as a vtk\-Prop.  
\item {\ttfamily obj.\-Set\-Window\-Location (int enum\-Location)} -\/ Set the text position, by enumeration ( Any\-Location = 0, Lower\-Left\-Corner, Lower\-Right\-Corner, Lower\-Center, Upper\-Left\-Corner, Upper\-Right\-Corner, Upper\-Center) related to the render window  
\item {\ttfamily int = obj.\-Get\-Window\-Location ()} -\/ Set the text position, by enumeration ( Any\-Location = 0, Lower\-Left\-Corner, Lower\-Right\-Corner, Lower\-Center, Upper\-Left\-Corner, Upper\-Right\-Corner, Upper\-Center) related to the render window  
\item {\ttfamily obj.\-Set\-Position (double x, double y)} -\/ Set the text position, by overiding the same function of vtk\-Border\-Representation so that the Modified() will be called.  
\item {\ttfamily obj.\-Set\-Position (double pos\mbox{[}2\mbox{]})} -\/ Set the text position, by overiding the same function of vtk\-Border\-Representation so that the Modified() will be called.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtktextwidget}{}\section{vtk\-Text\-Widget}\label{vtkwidgets_vtktextwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively placing text on the 2\-D overlay plane. The text is defined by an instance of vtk\-Text\-Actor. It uses the event bindings of its superclass (vtk\-Border\-Widget). In addition, when the text is selected, the widget emits a Widget\-Activate\-Event that observers can watch for. This is useful for opening G\-U\-I dialogues to adjust font characteristics, etc. (Please see the superclass for a description of event bindings.)

To create an instance of class vtk\-Text\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkTextWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Text\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be 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\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Text\-Widget = obj.\-New\-Instance ()} -\/ Standard V\-T\-K methods.  
\item {\ttfamily vtk\-Text\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard V\-T\-K methods.  
\item {\ttfamily obj.\-Set\-Representation (vtk\-Text\-Representation r)} -\/ Specify a vtk\-Text\-Actor to manage. This is a convenient, alternative method to specify the representation for the widget (i.\-e., used instead of Set\-Representation()). It internally creates a vtk\-Text\-Representation and then invokes vtk\-Text\-Representation\-::\-Set\-Text\-Actor().  
\item {\ttfamily obj.\-Set\-Text\-Actor (vtk\-Text\-Actor text\-Actor)} -\/ Specify a vtk\-Text\-Actor to manage. This is a convenient, alternative method to specify the representation for the widget (i.\-e., used instead of Set\-Representation()). It internally creates a vtk\-Text\-Representation and then invokes vtk\-Text\-Representation\-::\-Set\-Text\-Actor().  
\item {\ttfamily vtk\-Text\-Actor = obj.\-Get\-Text\-Actor ()} -\/ Specify a vtk\-Text\-Actor to manage. This is a convenient, alternative method to specify the representation for the widget (i.\-e., used instead of Set\-Representation()). It internally creates a vtk\-Text\-Representation and then invokes vtk\-Text\-Representation\-::\-Set\-Text\-Actor().  
\item {\ttfamily obj.\-Create\-Default\-Representation ()} -\/ Create the default widget representation if one is not set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkwidgetcallbackmapper}{}\section{vtk\-Widget\-Callback\-Mapper}\label{vtkwidgets_vtkwidgetcallbackmapper}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Widget\-Callback\-Mapper maps widget events (defined in vtk\-Widget\-Event.\-h) into static class methods, and provides facilities to invoke the methods. This class is templated and meant to be used as an internal helper class by the widget classes. The class works in combination with the class vtk\-Widget\-Event\-Translator, which translates V\-T\-K events into widget events.

To create an instance of class vtk\-Widget\-Callback\-Mapper, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWidgetCallbackMapper
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Widget\-Callback\-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\-Widget\-Callback\-Mapper 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\-Widget\-Callback\-Mapper = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Widget\-Callback\-Mapper = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Event\-Translator (vtk\-Widget\-Event\-Translator t)} -\/ Specify the vtk\-Widget\-Event\-Translator to coordinate with.  
\item {\ttfamily vtk\-Widget\-Event\-Translator = obj.\-Get\-Event\-Translator ()} -\/ Specify the vtk\-Widget\-Event\-Translator to coordinate with.  
\item {\ttfamily obj.\-Invoke\-Callback (long widget\-Event)} -\/ This method invokes the callback given a widget event. A non-\/zero value is returned if the listed event is registered.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkwidgetevent}{}\section{vtk\-Widget\-Event}\label{vtkwidgets_vtkwidgetevent}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Widget\-Event defines widget events. These events are processed by subclasses of vtk\-Interactor\-Observer.

To create an instance of class vtk\-Widget\-Event, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWidgetEvent
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Widget\-Event has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Widget\-Event 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\-Widget\-Event = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Widget\-Event = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkwidgeteventtranslator}{}\section{vtk\-Widget\-Event\-Translator}\label{vtkwidgets_vtkwidgeteventtranslator}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
vtk\-Widget\-Event\-Translator maps V\-T\-K events (defined on vtk\-Command) into widget events (defined in vtk\-Widget\-Event.\-h). This class is typically used in combination with vtk\-Widget\-Callback\-Mapper, which is responsible for translating widget events into method callbacks, and then invoking the callbacks.

This class can be used to define different mappings of V\-T\-K events into the widget events. Thus widgets can be reconfigured to use different event bindings.

To create an instance of class vtk\-Widget\-Event\-Translator, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWidgetEventTranslator
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Widget\-Event\-Translator has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Widget\-Event\-Translator 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\-Widget\-Event\-Translator = obj.\-New\-Instance ()} -\/ Standard macros.  
\item {\ttfamily vtk\-Widget\-Event\-Translator = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard macros.  
\item {\ttfamily obj.\-Set\-Translation (long V\-T\-K\-Event, long widget\-Event)} -\/ Use these methods to create the translation from a V\-T\-K event to a widget event. Specifying vtk\-Widget\-Event\-::\-No\-Event or an empty string for the (to\-Event) erases the mapping for the event.  
\item {\ttfamily obj.\-Set\-Translation (string V\-T\-K\-Event, string widget\-Event)} -\/ Use these methods to create the translation from a V\-T\-K event to a widget event. Specifying vtk\-Widget\-Event\-::\-No\-Event or an empty string for the (to\-Event) erases the mapping for the event.  
\item {\ttfamily obj.\-Set\-Translation (long V\-T\-K\-Event, int modifier, char key\-Code, int repeat\-Count, string key\-Sym, long widget\-Event)} -\/ Use these methods to create the translation from a V\-T\-K event to a widget event. Specifying vtk\-Widget\-Event\-::\-No\-Event or an empty string for the (to\-Event) erases the mapping for the event.  
\item {\ttfamily obj.\-Set\-Translation (vtk\-Event V\-T\-Kevent, long widget\-Event)} -\/ Use these methods to create the translation from a V\-T\-K event to a widget event. Specifying vtk\-Widget\-Event\-::\-No\-Event or an empty string for the (to\-Event) erases the mapping for the event.  
\item {\ttfamily long = obj.\-Get\-Translation (long V\-T\-K\-Event)} -\/ Translate a V\-T\-K event into a widget event. If no event mapping is found, then the methods return vtk\-Widget\-Event\-::\-No\-Event or a N\-U\-L\-L string.  
\item {\ttfamily string = obj.\-Get\-Translation (string V\-T\-K\-Event)} -\/ Translate a V\-T\-K event into a widget event. If no event mapping is found, then the methods return vtk\-Widget\-Event\-::\-No\-Event or a N\-U\-L\-L string.  
\item {\ttfamily long = obj.\-Get\-Translation (long V\-T\-K\-Event, int modifier, char key\-Code, int repeat\-Count, string key\-Sym)} -\/ Translate a V\-T\-K event into a widget event. If no event mapping is found, then the methods return vtk\-Widget\-Event\-::\-No\-Event or a N\-U\-L\-L string.  
\item {\ttfamily long = obj.\-Get\-Translation (vtk\-Event V\-T\-K\-Event)} -\/ Translate a V\-T\-K event into a widget event. If no event mapping is found, then the methods return vtk\-Widget\-Event\-::\-No\-Event or a N\-U\-L\-L string.  
\item {\ttfamily int = obj.\-Remove\-Translation (long V\-T\-K\-Event, int modifier, char key\-Code, int repeat\-Count, string key\-Sym)} -\/ Remove translations for a binding. Returns the number of translations removed.  
\item {\ttfamily int = obj.\-Remove\-Translation (vtk\-Event e)} -\/ Remove translations for a binding. Returns the number of translations removed.  
\item {\ttfamily int = obj.\-Remove\-Translation (long V\-T\-K\-Event)} -\/ Remove translations for a binding. Returns the number of translations removed.  
\item {\ttfamily obj.\-Clear\-Events ()} -\/ Clear all events from the translator (i.\-e., no events will be translated).  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkwidgetrepresentation}{}\section{vtk\-Widget\-Representation}\label{vtkwidgets_vtkwidgetrepresentation}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class is used to define the A\-P\-I for, and partially implement, a representation for different types of widgets. Note that the widget representation (i.\-e., subclasses of vtk\-Widget\-Representation) are a type of vtk\-Prop; meaning that they can be associated with a vtk\-Renderer end embedded in a scene like any other vtk\-Actor. However, vtk\-Widget\-Representation also defines an A\-P\-I that enables it to be paired with a subclass vtk\-Abstract\-Widget, meaning that it can be driven by a widget, serving to represent the widget as the widget responds to registered events.

The A\-P\-I defined here should be regarded as a guideline for implementing widgets and widget representations. Widget behavior is complex, as is the way the representation responds to the registered widget events, so the A\-P\-I may vary from widget to widget to reflect this complexity.

To create an instance of class vtk\-Widget\-Representation, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWidgetRepresentation
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Widget\-Representation has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Widget\-Representation class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Widget\-Representation = obj.\-New\-Instance ()} -\/ Standard methods for instances of this class.  
\item {\ttfamily vtk\-Widget\-Representation = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for instances of this class.  
\item {\ttfamily obj.\-Set\-Renderer (vtk\-Renderer ren)} -\/ Subclasses of vtk\-Widget\-Representation must implement these methods. This is considered the minimum A\-P\-I for a widget representation. 
\begin{DoxyPre}
 SetRenderer() - the renderer in which the widget is to appear must be set.
 BuildRepresentation() - update the geometry of the widget based on its
                         current state.
 \end{DoxyPre}
 W\-A\-R\-N\-I\-N\-G\-: The renderer is N\-O\-T reference counted by the representation, in order to avoid reference loops. Be sure that the representation lifetime does not extend beyond the renderer lifetime.  
\item {\ttfamily vtk\-Renderer = obj.\-Get\-Renderer ()} -\/ Subclasses of vtk\-Widget\-Representation must implement these methods. This is considered the minimum A\-P\-I for a widget representation. 
\begin{DoxyPre}
 SetRenderer() - the renderer in which the widget is to appear must be set.
 BuildRepresentation() - update the geometry of the widget based on its
                         current state.
 \end{DoxyPre}
 W\-A\-R\-N\-I\-N\-G\-: The renderer is N\-O\-T reference counted by the representation, in order to avoid reference loops. Be sure that the representation lifetime does not extend beyond the renderer lifetime.  
\item {\ttfamily obj.\-Build\-Representation ()} -\/ Subclasses of vtk\-Widget\-Representation must implement these methods. This is considered the minimum A\-P\-I for a widget representation. 
\begin{DoxyPre}
 SetRenderer() - the renderer in which the widget is to appear must be set.
 BuildRepresentation() - update the geometry of the widget based on its
                         current state.
 \end{DoxyPre}
 W\-A\-R\-N\-I\-N\-G\-: The renderer is N\-O\-T reference counted by the representation, in order to avoid reference loops. Be sure that the representation lifetime does not extend beyond the renderer lifetime.  
\item {\ttfamily obj.\-Place\-Widget (double )} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily obj.\-Start\-Widget\-Interaction (double event\-Pos\mbox{[}2\mbox{]})} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily obj.\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily obj.\-End\-Widget\-Interaction (double new\-Event\-Pos\mbox{[}2\mbox{]})} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily int = obj.\-Compute\-Interaction\-State (int X, int Y, int modify)} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily int = obj.\-Get\-Interaction\-State ()} -\/ The following is a suggested A\-P\-I for widget representations. These methods define the communication between the widget and its representation. These methods are only suggestions because widgets take on so many different forms that a universal A\-P\-I is not deemed practical. However, these methods should be implemented when possible to insure that the V\-T\-K widget hierarchy remains self-\/consistent. 
\begin{DoxyPre}
 PlaceWidget() - given a bounding box (xmin,xmax,ymin,ymax,zmin,zmax), place 
                 the widget inside of it. The current orientation of the widget 
                 is preserved, only scaling and translation is performed.
 StartWidgetInteraction() - generally corresponds to a initial event (e.g.,
                            mouse down) that starts the interaction process
                            with the widget.
 WidgetInteraction() - invoked when an event causes the widget to change 
                       appearance.
 EndWidgetInteraction() - generally corresponds to a final event (e.g., mouse up)
                          and completes the interaction sequence.
 ComputeInteractionState() - given (X,Y) display coordinates in a renderer, with a
                             possible flag that modifies the computation,
                             what is the state of the widget?
 GetInteractionState() - return the current state of the widget. Note that the
                         value of "0" typically refers to "outside". The 
                         interaction state is strictly a function of the
                         representation, and the widget/represent must agree
                         on what they mean.
 Highlight() - turn on or off any highlights associated with the widget.
               Highlights are generally turned on when the widget is selected.
 \end{DoxyPre}
 Note that subclasses may ignore some of these methods and implement their own depending on the specifics of the widget.  
\item {\ttfamily obj.\-Highlight (int )} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily obj.\-Set\-Place\-Factor (double )} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor\-Min\-Value ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor\-Max\-Value ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily double = obj.\-Get\-Place\-Factor ()} -\/ Set/\-Get a factor representing the scaling of the widget upon placement (via the Place\-Widget() method). Normally the widget is placed so that it just fits within the bounding box defined in Place\-Widget(bounds). The Place\-Factor will make the widget larger (Place\-Factor $>$ 1) or smaller (Place\-Factor $<$ 1). By default, Place\-Factor is set to 0.\-5.  
\item {\ttfamily obj.\-Set\-Handle\-Size (double )} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget (if any). These handles (like spheres, etc.) are used to manipulate the widget. The Handle\-Size data member allows you to change the relative size of the handles. Note that while the handle size is typically expressed in pixels, some subclasses may use a relative size with respect to the viewport. (As a corollary, the value of this ivar is often set by subclasses of this class during instance instantiation.)  
\item {\ttfamily double = obj.\-Get\-Handle\-Size\-Min\-Value ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget (if any). These handles (like spheres, etc.) are used to manipulate the widget. The Handle\-Size data member allows you to change the relative size of the handles. Note that while the handle size is typically expressed in pixels, some subclasses may use a relative size with respect to the viewport. (As a corollary, the value of this ivar is often set by subclasses of this class during instance instantiation.)  
\item {\ttfamily double = obj.\-Get\-Handle\-Size\-Max\-Value ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget (if any). These handles (like spheres, etc.) are used to manipulate the widget. The Handle\-Size data member allows you to change the relative size of the handles. Note that while the handle size is typically expressed in pixels, some subclasses may use a relative size with respect to the viewport. (As a corollary, the value of this ivar is often set by subclasses of this class during instance instantiation.)  
\item {\ttfamily double = obj.\-Get\-Handle\-Size ()} -\/ Set/\-Get the factor that controls the size of the handles that appear as part of the widget (if any). These handles (like spheres, etc.) are used to manipulate the widget. The Handle\-Size data member allows you to change the relative size of the handles. Note that while the handle size is typically expressed in pixels, some subclasses may use a relative size with respect to the viewport. (As a corollary, the value of this ivar is often set by subclasses of this class during instance instantiation.)  
\item {\ttfamily int = obj.\-Get\-Need\-To\-Render ()} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily obj.\-Set\-Need\-To\-Render (int )} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily int = obj.\-Get\-Need\-To\-Render\-Min\-Value ()} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily int = obj.\-Get\-Need\-To\-Render\-Max\-Value ()} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily obj.\-Need\-To\-Render\-On ()} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily obj.\-Need\-To\-Render\-Off ()} -\/ Some subclasses use this data member to keep track of whether to render or not (i.\-e., to minimize the total number of renders).  
\item {\ttfamily double = obj.\-Get\-Bounds ()} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily obj.\-Shallow\-Copy (vtk\-Prop prop)} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily obj.\-Get\-Actors (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily obj.\-Get\-Actors2\-D (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily obj.\-Get\-Volumes (vtk\-Prop\-Collection )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily obj.\-Release\-Graphics\-Resources (vtk\-Window )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily int = obj.\-Render\-Overlay (vtk\-Viewport )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily int = obj.\-Render\-Opaque\-Geometry (vtk\-Viewport )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily int = obj.\-Render\-Translucent\-Polygonal\-Geometry (vtk\-Viewport )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily int = obj.\-Render\-Volumetric\-Geometry (vtk\-Viewport )} -\/ Methods to make this class behave as a vtk\-Prop. They are repeated here (from the vtk\-Prop superclass) as a reminder to the widget implementor. Failure to implement these methods properly may result in the representation not appearing in the scene (i.\-e., not implementing the Render() methods properly) or leaking graphics resources (i.\-e., not implementing Release\-Graphics\-Resources() properly).  
\item {\ttfamily int = obj.\-Has\-Translucent\-Polygonal\-Geometry ()}  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkwidgetset}{}\section{vtk\-Widget\-Set}\label{vtkwidgets_vtkwidgetset}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
The class synchronizes a set of vtk\-Abstract\-Widget(s). Widgets typically invoke \char`\"{}\-Actions\char`\"{} that drive the geometry/behaviour of their representations in response to interactor events. Interactor interactions on a render window are mapped into \char`\"{}\-Callbacks\char`\"{} by the widget, from which \char`\"{}\-Actions\char`\"{} are dispatched to the entire set. This architecture allows us to tie widgets existing in different render windows together. For instance a Handle\-Widget might exist on the sagittal view. Moving it around should update the representations of the corresponding handle widget that lies on the axial and coronal and volume views as well.

.S\-E\-C\-T\-I\-O\-N User A\-P\-I A user would use this class as follows. \begin{DoxyVerb} vtkWidgetSet *set = vtkWidgetSet::New();
 vtkParallelopipedWidget *w1 = vtkParallelopipedWidget::New();
 set->AddWidget(w1);
 w1->SetInteractor(axialRenderWindow->GetInteractor());
 vtkParallelopipedWidget *w2 = vtkParallelopipedWidget::New();
 set->AddWidget(w2);
 w2->SetInteractor(coronalRenderWindow->GetInteractor());
 vtkParallelopipedWidget *w3 = vtkParallelopipedWidget::New();
 set->AddWidget(w3);
 w3->SetInteractor(sagittalRenderWindow->GetInteractor());
 set->SetEnabled(1);\end{DoxyVerb}


.S\-E\-C\-T\-I\-O\-N Motivation The motivation for this class is really to provide a usable A\-P\-I to tie together multiple widgets of the same kind. To enable this, subclasses of vtk\-Abstract\-Widget, must be written as follows\-: They will generally have callback methods mapped to some user interaction such as\-: \begin{DoxyVerb} this->CallbackMapper->SetCallbackMethod(vtkCommand::LeftButtonPressEvent,
                         vtkEvent::NoModifier, 0, 0, NULL, 
                         vtkPaintbrushWidget::BeginDrawStrokeEvent,
                         this, vtkPaintbrushWidget::BeginDrawCallback);\end{DoxyVerb}
 The callback invoked when the left button is pressed looks like\-: \begin{DoxyVerb} void vtkPaintbrushWidget::BeginDrawCallback(vtkAbstractWidget *w)
 {
   vtkPaintbrushWidget *self = vtkPaintbrushWidget::SafeDownCast(w);
   self->WidgetSet->DispatchAction(self, &vtkPaintbrushWidget::BeginDrawAction);
 }\end{DoxyVerb}
 The actual code for handling the drawing is written in the Begin\-Draw\-Action method. \begin{DoxyVerb} void vtkPaintbrushWidget::BeginDrawAction( vtkPaintbrushWidget *dispatcher)
 {
 // Do stuff to draw... 
 // Here dispatcher is the widget that was interacted with, the one that
 // dispatched an action to all the other widgets in its group. You may, if
 // necessary find it helpful to get parameters from it.
 //   For instance for a ResizeAction:
 //     if (this != dispatcher)
 //       {
 //       double *newsize = dispatcher->GetRepresentation()->GetSize();
 //       this->WidgetRep->SetSize(newsize);
 //       }
 //     else
 //       {
 //       this->WidgetRep->IncrementSizeByDelta();
 //       }
 }\end{DoxyVerb}


To create an instance of class vtk\-Widget\-Set, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkWidgetSet
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-Widget\-Set has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-Widget\-Set class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily int = obj.\-Is\-A (string name)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Widget\-Set = obj.\-New\-Instance ()} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily vtk\-Widget\-Set = obj.\-Safe\-Down\-Cast (vtk\-Object o)} -\/ Standard methods for a V\-T\-K class.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Method for activiating and deactiviating all widgets in the group.  
\item {\ttfamily obj.\-Enabled\-On ()} -\/ Method for activiating and deactiviating all widgets in the group.  
\item {\ttfamily obj.\-Enabled\-Off ()} -\/ Method for activiating and deactiviating all widgets in the group.  
\item {\ttfamily obj.\-Add\-Widget (vtk\-Abstract\-Widget )} -\/ Add a widget to the set.  
\item {\ttfamily obj.\-Remove\-Widget (vtk\-Abstract\-Widget )} -\/ Remove a widget from the set  
\item {\ttfamily int = obj.\-Get\-Number\-Of\-Widgets ()} -\/ Get number of widgets in the set.  
\item {\ttfamily vtk\-Abstract\-Widget = obj.\-Get\-Nth\-Widget (int )} -\/ Get the Nth widget in the set.  
\end{DoxyItemize}\hypertarget{vtkwidgets_vtkxyplotwidget}{}\section{vtk\-X\-Y\-Plot\-Widget}\label{vtkwidgets_vtkxyplotwidget}
Section\-: \hyperlink{sec_vtkwidgets}{Visualization Toolkit Widget Classes} \hypertarget{vtkwidgets_vtkxyplotwidget_Usage}{}\subsection{Usage}\label{vtkwidgets_vtkxyplotwidget_Usage}
This class provides support for interactively manipulating the position, size, and orientation of a X\-Y Plot. It listens to Left mouse events and mouse movement. It will change the cursor shape based on its location. If the cursor is over an edge of thea X\-Y plot it will change the cursor shape to a resize edge shape. If the position of a X\-Y plot is moved to be close to the center of one of the four edges of the viewport, then the X\-Y plot will change its orientation to align with that edge. This orientation is sticky in that it will stay that orientation until the position is moved close to another edge.

To create an instance of class vtk\-X\-Y\-Plot\-Widget, simply invoke its constructor as follows \begin{DoxyVerb}  obj = vtkXYPlotWidget
\end{DoxyVerb}
 \hypertarget{vtkwidgets_vtkxyplotwidget_Methods}{}\subsection{Methods}\label{vtkwidgets_vtkxyplotwidget_Methods}
The class vtk\-X\-Y\-Plot\-Widget has several methods that can be used. They are listed below. Note that the documentation is translated automatically from the V\-T\-K sources, and may not be completely intelligible. When in doubt, consult the V\-T\-K website. In the methods listed below, {\ttfamily obj} is an instance of the vtk\-X\-Y\-Plot\-Widget class. 
\begin{DoxyItemize}
\item {\ttfamily string = obj.\-Get\-Class\-Name ()}  
\item {\ttfamily int = obj.\-Is\-A (string name)}  
\item {\ttfamily vtk\-X\-Y\-Plot\-Widget = obj.\-New\-Instance ()}  
\item {\ttfamily vtk\-X\-Y\-Plot\-Widget = obj.\-Safe\-Down\-Cast (vtk\-Object o)}  
\item {\ttfamily obj.\-Set\-X\-Y\-Plot\-Actor (vtk\-X\-Y\-Plot\-Actor )} -\/ Get the X\-Y plot used by this Widget. One is created automatically.  
\item {\ttfamily vtk\-X\-Y\-Plot\-Actor = obj.\-Get\-X\-Y\-Plot\-Actor ()} -\/ Get the X\-Y plot used by this Widget. One is created automatically.  
\item {\ttfamily obj.\-Set\-Enabled (int )} -\/ Methods for turning the interactor observer on and off.  
\end{DoxyItemize}