ENH:Beginning merge process from Widgets-Redesign VTK branch

Graphics/Testing/Tcl/cursor2D.tcl

+package require vtk
+package require vtkinteraction
+
+  # create four cursors configured differently
+vtkCursor2D cursor
+  eval cursor SetModelBounds 15 45 15 45 0 0
+  eval cursor SetFocalPoint 30 30 0
+  cursor AllOff
+  cursor AxesOn
+  cursor OutlineOn
+vtkPolyDataMapper2D cursorMapper
+  cursorMapper SetInputConnection [cursor GetOutputPort]
+vtkActor2D cursorActor
+  cursorActor SetMapper cursorMapper
+  [cursorActor GetProperty] SetColor 1 0 0
+
+vtkCursor2D cursor2
+  eval cursor2 SetModelBounds 75 105 15 45 0 0
+  eval cursor2 SetFocalPoint 90 30 0
+  cursor2 AllOff
+  cursor2 AxesOn
+  cursor2 OutlineOn
+  cursor2 PointOn
+vtkPolyDataMapper2D cursor2Mapper
+  cursor2Mapper SetInputConnection [cursor2 GetOutputPort]
+vtkActor2D cursor2Actor
+  cursor2Actor SetMapper cursor2Mapper
+  [cursor2Actor GetProperty] SetColor 0 1 0
+
+vtkCursor2D cursor3
+  eval cursor3 SetModelBounds 15 45 75 105 0 0
+  eval cursor3 SetFocalPoint 30 90 0
+  cursor3 AllOff
+  cursor3 AxesOn
+  cursor3 OutlineOff
+  cursor3 PointOn
+  cursor3 SetRadius 3
+vtkPolyDataMapper2D cursor3Mapper
+  cursor3Mapper SetInputConnection [cursor3 GetOutputPort]
+vtkActor2D cursor3Actor
+  cursor3Actor SetMapper cursor3Mapper
+  [cursor3Actor GetProperty] SetColor 0 1 0
+
+vtkCursor2D cursor4
+  eval cursor4 SetModelBounds 75 105 75 105 0 0
+  eval cursor4 SetFocalPoint 90 90 0
+  cursor4 AllOff
+  cursor4 AxesOn
+  cursor4 SetRadius 0.0
+vtkPolyDataMapper2D cursor4Mapper
+  cursor4Mapper SetInputConnection [cursor4 GetOutputPort]
+vtkActor2D cursor4Actor
+  cursor4Actor SetMapper cursor4Mapper
+  [cursor4Actor GetProperty] SetColor 1 0 0
+
+  # rendering support
+vtkRenderer ren1
+vtkRenderWindow renWin
+  renWin AddRenderer ren1
+vtkRenderWindowInteractor iren
+  iren SetRenderWindow renWin
+
+  # read data
+ren1 AddActor cursorActor
+ren1 AddActor cursor2Actor
+ren1 AddActor cursor3Actor
+ren1 AddActor cursor4Actor
+
+ren1 SetBackground 0 0 0
+renWin SetSize 120 120
+renWin Render
+
+iren AddObserver UserEvent {wm deiconify .vtkInteract}
+iren Initialize
+
+# prevent the tk window from showing up then start the event loop
+wm withdraw .

Graphics/vtkCursor2D.cxx

+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    vtkCursor2D.cxx
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+#include "vtkCursor2D.h"
+#include "vtkCellArray.h"
+#include "vtkInformation.h"
+#include "vtkInformationVector.h"
+#include "vtkObjectFactory.h"
+#include "vtkPolyData.h"
+#include <math.h>
+
+vtkCxxRevisionMacro(vtkCursor2D, "1.2");
+vtkStandardNewMacro(vtkCursor2D);
+
+//---------------------------------------------------------------------------
+// Construct with model bounds = (-10,10,-10,10, 0,0), focal point = (0,0,0),
+// radius=2, all parts of cursor visible, and wrapping off.
+vtkCursor2D::vtkCursor2D()
+{
+  this->ModelBounds[0] = -10.0;
+  this->ModelBounds[1] = 10.0;
+  this->ModelBounds[2] = -10.0;
+  this->ModelBounds[3] = 10.0;
+  this->ModelBounds[4] = 0.0;
+  this->ModelBounds[5] = 0.0;
+
+  this->FocalPoint[0] = 0.0;  
+  this->FocalPoint[1] = 0.0;  
+  this->FocalPoint[2] = 0.0;
+
+  this->Outline = 1;
+  this->Axes = 1;
+  this->Point = 1;
+  this->Radius = 2;
+  this->Wrap = 0;
+  this->TranslationMode = 0;
+
+  this->SetNumberOfInputPorts(0);
+}
+
+//---------------------------------------------------------------------------
+int vtkCursor2D::RequestData(
+  vtkInformation *vtkNotUsed(request),
+  vtkInformationVector **vtkNotUsed(inputVector),
+  vtkInformationVector *outputVector)
+{
+  // get the info object
+  vtkInformation *outInfo = outputVector->GetInformationObject(0);
+
+  // get the ouptut
+  vtkPolyData *output = vtkPolyData::SafeDownCast(
+    outInfo->Get(vtkDataObject::DATA_OBJECT()));
+
+  int i;
+  int numPts=0, numVerts=0, numLines=0;
+  vtkPoints *newPts;
+  vtkCellArray *newLines=NULL, *newVerts=NULL;
+  double x[3];
+  vtkIdType ptIds[5];
+
+  // Check bounding box and origin
+  //
+  if ( this->Wrap ) 
+    {
+    for (i=0; i<2; i++)
+      {
+      this->FocalPoint[i] = this->ModelBounds[2*i] + 
+             fmod((double)(this->FocalPoint[i]-this->ModelBounds[2*i]), 
+                  (double)(this->ModelBounds[2*i+1]-this->ModelBounds[2*i]));
+      }
+    } 
+  else 
+    {
+    for (i=0; i<2; i++)
+      {
+      if ( this->FocalPoint[i] < this->ModelBounds[2*i] )
+        {
+        this->FocalPoint[i] = this->ModelBounds[2*i];
+        }
+      if ( this->FocalPoint[i] > this->ModelBounds[2*i+1] )
+        {
+        this->FocalPoint[i] = this->ModelBounds[2*i+1];
+        }
+      }
+    }
+
+  // Allocate storage
+  //
+  if (this->Point)
+    {
+    numPts += 1;
+    numVerts += 1;
+    }
+  
+  if (this->Axes) 
+    {
+    numPts += 8;
+    numLines += 3;
+    }
+
+  if (this->Outline) 
+    {
+    numPts += 8;
+    numLines += 12;
+    }
+
+  if ( numPts ) 
+    {
+    newPts = vtkPoints::New();
+    newPts->Allocate(numPts);
+    newLines = vtkCellArray::New();
+    newLines->Allocate(newLines->EstimateSize(numLines,2));
+    }
+  else
+    {
+    return 1;
+    }
+
+  if ( numVerts )
+    {
+    newVerts = vtkCellArray::New();
+    newVerts->Allocate(newLines->EstimateSize(1,1));
+    }
+
+  // Now create the representation. First the point (if requested).
+  //
+  if ( this->Point ) 
+    {
+    x[0] = this->FocalPoint[0];
+    x[1] = this->FocalPoint[1];
+    x[2] = 0.0;
+    ptIds[0] = newPts->InsertNextPoint(x);
+    newVerts->InsertNextCell(1,ptIds);
+    output->SetVerts(newVerts);
+    newVerts->Delete();
+    }
+
+  // Create axes
+  //
+  if ( this->Axes ) 
+    {
+    // The lines making up the x axis
+    x[0] = this->ModelBounds[0]; 
+    x[1] = this->FocalPoint[1]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[0] = newPts->InsertNextPoint(x);
+
+    x[0] = this->FocalPoint[0] - this->Radius; 
+    x[1] = this->FocalPoint[1]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[1] = newPts->InsertNextPoint(x);
+    newLines->InsertNextCell(2,ptIds);
+
+    x[0] = this->FocalPoint[0] + this->Radius; 
+    x[1] = this->FocalPoint[1]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[0] = newPts->InsertNextPoint(x);
+
+    x[0] = this->ModelBounds[1]; 
+    x[1] = this->FocalPoint[1]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[1] = newPts->InsertNextPoint(x);
+    newLines->InsertNextCell(2,ptIds);
+
+    // The lines making up the y axis
+    x[0] = this->FocalPoint[0]; 
+    x[1] = this->ModelBounds[2]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[0] = newPts->InsertNextPoint(x);
+
+    x[0] = this->FocalPoint[0]; 
+    x[1] = this->FocalPoint[1] - this->Radius;
+    x[2] = this->ModelBounds[4];
+    ptIds[1] = newPts->InsertNextPoint(x);
+    newLines->InsertNextCell(2,ptIds);
+
+    x[0] = this->FocalPoint[0];
+    x[1] = this->FocalPoint[1] + this->Radius; 
+    x[2] = this->ModelBounds[4];
+    ptIds[0] = newPts->InsertNextPoint(x);
+
+    x[0] = this->FocalPoint[0];
+    x[1] = this->ModelBounds[3]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[1] = newPts->InsertNextPoint(x);
+    newLines->InsertNextCell(2,ptIds);
+    }
+
+  // Create outline
+  //
+  if ( this->Outline ) 
+    {
+    x[0] = this->ModelBounds[0]; 
+    x[1] = this->ModelBounds[2]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[0] = newPts->InsertNextPoint(x);
+
+    x[0] = this->ModelBounds[1]; 
+    x[1] = this->ModelBounds[2]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[1] = newPts->InsertNextPoint(x);
+
+    x[0] = this->ModelBounds[1]; 
+    x[1] = this->ModelBounds[3]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[2] = newPts->InsertNextPoint(x);
+
+    x[0] = this->ModelBounds[0]; 
+    x[1] = this->ModelBounds[3]; 
+    x[2] = this->ModelBounds[4];
+    ptIds[3] = newPts->InsertNextPoint(x);
+    ptIds[4] = ptIds[0];
+    newLines->InsertNextCell(5,ptIds);
+    }
+
+  // Update ourselves and release memory
+  //
+  output->SetPoints(newPts);
+  newPts->Delete();
+
+  if ( newLines )
+    {
+    output->SetLines(newLines);
+    newLines->Delete();
+    }
+
+  return 1;
+}
+
+//---------------------------------------------------------------------------
+// Set the boundary of the 3D cursor.
+void vtkCursor2D::SetModelBounds(double xmin, double xmax, double ymin, double ymax,
+                                 double zmin, double zmax)
+{
+  if ( xmin != this->ModelBounds[0] || xmax != this->ModelBounds[1] ||
+       ymin != this->ModelBounds[2] || ymax != this->ModelBounds[3] ||
+       zmin != this->ModelBounds[4] || zmax != this->ModelBounds[5] )
+    {
+    this->Modified();
+
+    this->ModelBounds[0] = xmin; this->ModelBounds[1] = xmax; 
+    this->ModelBounds[2] = ymin; this->ModelBounds[3] = ymax; 
+    this->ModelBounds[4] = ymin; this->ModelBounds[5] = ymax; 
+
+    for (int i=0; i<3; i++)
+      {
+      if ( this->ModelBounds[2*i] > this->ModelBounds[2*i+1] )
+        {
+        this->ModelBounds[2*i] = this->ModelBounds[2*i+1];
+        }
+      }
+    }
+}
+
+//---------------------------------------------------------------------------
+void vtkCursor2D::SetFocalPoint(double x[3])
+{
+  if ( x[0] == this->FocalPoint[0] && x[1] == this->FocalPoint[1] )
+    {
+    return;
+    }
+  
+  this->Modified();
+
+  double v[3];
+  for (int i=0; i<2; i++)
+    {
+    v[i] = x[i] - this->FocalPoint[i];
+    this->FocalPoint[i] = x[i];
+  
+    if ( this->TranslationMode )
+      {
+      this->ModelBounds[2*i] += v[i];
+      this->ModelBounds[2*i+1] += v[i];
+      }
+    else if ( this->Wrap ) //wrap
+      {
+      this->FocalPoint[i] = this->ModelBounds[2*i] + 
+             fmod((double)(this->FocalPoint[i]-this->ModelBounds[2*i]), 
+                  (double)(this->ModelBounds[2*i+1]-this->ModelBounds[2*i]));
+      }
+    else //clamp
+      {
+      if ( x[i] < this->ModelBounds[2*i] ) 
+        { 
+        this->FocalPoint[i] = this->ModelBounds[2*i];
+        }
+      if ( x[i] > this->ModelBounds[2*i+1] ) 
+        { 
+        this->FocalPoint[i] = this->ModelBounds[2*i+1];
+        }
+      }
+    }
+}
+
+//---------------------------------------------------------------------------
+void vtkCursor2D::SetModelBounds(double bounds[6])
+{
+  this->SetModelBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[6], bounds[5]);
+}
+
+//---------------------------------------------------------------------------
+// Turn every part of the 3D cursor on.
+void vtkCursor2D::AllOn()
+{
+  this->OutlineOn();
+  this->AxesOn();
+  this->PointOn();
+}
+
+//---------------------------------------------------------------------------
+// Turn every part of the 3D cursor off.
+void vtkCursor2D::AllOff()
+{
+  this->OutlineOff();
+  this->AxesOff();
+  this->PointOff();
+}
+
+//---------------------------------------------------------------------------
+void vtkCursor2D::PrintSelf(ostream& os, vtkIndent indent)
+{
+  this->Superclass::PrintSelf(os,indent);
+
+  os << indent << "ModelBounds: \n";
+  os << indent << "  Xmin,Xmax: (" << this->ModelBounds[0] << ", " << this->ModelBounds[1] << ")\n";
+  os << indent << "  Ymin,Ymax: (" << this->ModelBounds[2] << ", " << this->ModelBounds[3] << ")\n";
+  os << indent << "  Zmin,Zmax: (" << this->ModelBounds[4] << ", " << this->ModelBounds[5] << ")\n";
+
+  os << indent << "Focal Point: (" << this->FocalPoint[0] << ", "
+               << this->FocalPoint[1] << ", "
+               << this->FocalPoint[2] << ")\n";
+
+  os << indent << "Outline: " << (this->Outline ? "On\n" : "Off\n");
+  os << indent << "Axes: " << (this->Axes ? "On\n" : "Off\n");
+  os << indent << "Point: " << (this->Point ? "On\n" : "Off\n");
+  os << indent << "Radius: " << this->Radius << "\n";
+  os << indent << "Wrap: " << (this->Wrap ? "On\n" : "Off\n");
+  os << indent << "Translation Mode: " 
+     << (this->TranslationMode ? "On\n" : "Off\n");
+}

Graphics/vtkCursor2D.h

+/*=========================================================================
+
+  Program:   Visualization Toolkit
+  Module:    vtkCursor2D.h
+
+  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+  All rights reserved.
+  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
+
+     This software is distributed WITHOUT ANY WARRANTY; without even
+     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+     PURPOSE.  See the above copyright notice for more information.
+
+=========================================================================*/
+// .NAME vtkCursor2D - generate a 2D cursor representation
+// .SECTION Description
+// vtkCursor2D is a class that generates a 2D cursor representation.
+// The cursor consists of two intersection axes lines that meet at the
+// cursor focus. Several optional features are available as well. An 
+// optional 2D bounding box may be enabled. An inner radius, centered at
+// the focal point, can be set that erases the intersecting lines (e.g.,
+// it leaves a clear area under the focal point so you can see
+// what you are selecting). And finally, an optional point can be
+// enabled located at the focal point. All of these features can be turned
+// on and off independently.
+//
+
+#ifndef __vtkCursor2D_h
+#define __vtkCursor2D_h
+
+#include "vtkPolyDataAlgorithm.h"
+
+class VTK_GRAPHICS_EXPORT vtkCursor2D : public vtkPolyDataAlgorithm 
+{
+public:
+  vtkTypeRevisionMacro(vtkCursor2D,vtkPolyDataAlgorithm);
+  void PrintSelf(ostream& os, vtkIndent indent);
+
+  // Description:
+  // Construct with model bounds = (-10,10,-10,10), focal point = (0,0),
+  // radius=2, all parts of cursor visible, and wrapping off.
+  static vtkCursor2D *New();
+
+  // Description:
+  // Set / get the bounding box of the 2D cursor. This defines the outline
+  // of the cursor, and where the focal point should lie.
+  void SetModelBounds(double xmin, double xmax, double ymin, double ymax,
+                      double zmin, double zmax);
+  void SetModelBounds(double bounds[6]);
+  vtkGetVectorMacro(ModelBounds,double,6);
+
+  // Description:
+  // Set/Get the position of cursor focus. If translation mode is on,
+  // then the entire cursor (including bounding box, cursor, and shadows)
+  // is translated. Otherwise, the focal point will either be clamped to the
+  // bounding box, or wrapped, if Wrap is on. (Note: this behavior requires
+  // that the bounding box is set prior to the focal point.) Note that the 
+  // method takes a 3D point but ignores the z-coordinate value.
+  void SetFocalPoint(double x[3]);
+  void SetFocalPoint(double x, double y, double z)
+    {
+      double xyz[3];
+      xyz[0] = x; xyz[1] = y; xyz[2] = z;
+      this->SetFocalPoint(xyz);
+    }
+  vtkGetVectorMacro(FocalPoint,double,3);
+
+  // Description:
+  // Turn on/off the wireframe bounding box.
+  vtkSetMacro(Outline,int);
+  vtkGetMacro(Outline,int);
+  vtkBooleanMacro(Outline,int);
+
+  // Description:
+  // Turn on/off the wireframe axes.
+  vtkSetMacro(Axes,int);
+  vtkGetMacro(Axes,int);
+  vtkBooleanMacro(Axes,int);
+
+  // Description:
+  // Specify a radius for a circle. This erases the cursor
+  // lines around the focal point.
+  vtkSetClampMacro(Radius,double,0.0,VTK_LARGE_FLOAT);
+  vtkGetMacro(Radius,double);
+
+  // Description:
+  // Turn on/off the point located at the cursor focus.
+  vtkSetMacro(Point,int);
+  vtkGetMacro(Point,int);
+  vtkBooleanMacro(Point,int);
+
+  // Description:
+  // Enable/disable the translation mode. If on, changes in cursor position
+  // cause the entire widget to translate along with the cursor.
+  // By default, translation mode is off.
+  vtkSetMacro(TranslationMode,int);
+  vtkGetMacro(TranslationMode,int);
+  vtkBooleanMacro(TranslationMode,int);
+
+  // Description:
+  // Turn on/off cursor wrapping. If the cursor focus moves outside the
+  // specified bounds, the cursor will either be restrained against the
+  // nearest "wall" (Wrap=off), or it will wrap around (Wrap=on).
+  vtkSetMacro(Wrap,int);
+  vtkGetMacro(Wrap,int);
+  vtkBooleanMacro(Wrap,int);
+
+  // Description:
+  // Turn every part of the cursor on or off.
+  void AllOn();
+  void AllOff();
+
+protected:
+  vtkCursor2D();
+  ~vtkCursor2D() {}
+
+  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*);
+
+  double ModelBounds[6];
+  double FocalPoint[3];
+  int    Outline;
+  int    Axes;
+  int    Point;
+  double Radius;
+  int    TranslationMode;
+  int    Wrap;
+  
+private:
+  vtkCursor2D(const vtkCursor2D&);  // Not implemented.
+  void operator=(const vtkCursor2D&);  // Not implemented.
+};
+
+#endif

Rendering/Testing/Tcl/TestLeaderActor2D.tcl

+package require vtk
+package require vtkinteraction
+