
 Usage

The vtkContourWidget 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 VTK events). The vtkContourRepresentation is
responsible for all placement of the points, calculation of
the lines, and contour manipulation. This is done through
two main helper classes: vtkPointPlacer and
vtkContourLineInterpolator. The representation is also
responsible for drawing the points and lines.
.SECTION Event Bindings By default, the widget responds to
the following VTK events (i.e., it watches the
vtkRenderWindowInteractor for these events):

     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

Note that the event bindings described above can be changed
using this class's vtkWidgetEventTranslator. This class
translates VTK events into the vtkContourWidget's widget
events:

     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.


     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.


     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.


     vtkWidgetEvent::EndSelect
          widget state is:
              Start or
              Define: Do nothing.
              Manipulate: If our operation is not Inactive,
  set it to
                    Inactive.


     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.


     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.

This widget invokes the following VTK events on itself
(which observers can listen for):

     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. )

To create an instance of class vtkContourWidget, simply
invoke its constructor as follows

    obj = vtkContourWidget



 Methods

The class vtkContourWidget has several methods that can be
used. They are listed below. Note that the documentation is
translated automatically from the VTK sources, and may not
be completely intelligible. When in doubt, consult the VTK
website. In the methods listed below, obj is an instance of
the vtkContourWidget class.

* string = obj.GetClassName () - Standard methods for a VTK
  class.
* int = obj.IsA (string name) - Standard methods for a VTK
  class.
* vtkContourWidget = obj.NewInstance () - Standard methods
  for a VTK class.
* vtkContourWidget = obj.SafeDownCast (vtkObject o) -
  Standard methods for a VTK class.
* obj.SetEnabled (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' vtkAbstractWidget::SetEnabled() method.
* obj.SetRepresentation (vtkContourRepresentation r) -
  Create the default widget representation if one is not
  set.
* obj.CreateDefaultRepresentation () - Create the default
  widget representation if one is not set.
* obj.CloseLoop () - Convenient method to close the contour
  loop.
* obj.SetAllowNodePicking (int ) - Set / Get the
  AllowNodePicking value. This ivar indicates whether the
  nodes and points between nodes can be picked/un-picked by
  Ctrl+Click on the node.
* int = obj.GetAllowNodePicking () - Set / Get the
  AllowNodePicking value. This ivar indicates whether the
  nodes and points between nodes can be picked/un-picked by
  Ctrl+Click on the node.
* obj.AllowNodePickingOn () - Set / Get the AllowNodePicking
  value. This ivar indicates whether the nodes and points
  between nodes can be picked/un-picked by Ctrl+Click on the
  node.
* obj.AllowNodePickingOff () - Set / Get the
  AllowNodePicking value. This ivar indicates whether the
  nodes and points between nodes can be picked/un-picked by
  Ctrl+Click on the node.
* obj.SetFollowCursor (int ) - Follow the cursor ? If this
  is ON, 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.
* int = obj.GetFollowCursor () - Follow the cursor ? If this
  is ON, 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.
* obj.FollowCursorOn () - Follow the cursor ? If this is ON,
  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.
* obj.FollowCursorOff () - Follow the cursor ? If this is
  ON, 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.
* obj.SetContinuousDraw (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.
* int = obj.GetContinuousDraw () - 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.
* obj.ContinuousDrawOn () - 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.
* obj.ContinuousDrawOff () - 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.
* obj.Initialize (vtkPolyData 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.
* obj.Initialize ()


* FreeMat_Documentation
* Visualization_Toolkit_Widget_Classes
* Generated on Thu Jul 25 2013 17:18:36 for FreeMat by
  doxygen_ 1.8.1.1

