Commit 89d18141 authored by Will Schroeder's avatar Will Schroeder

ENH:Beginning merge process from Widgets-Redesign VTK branch

parent 42a385b3
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 .
/*=========================================================================
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");
}
/*=========================================================================
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
package require vtk
package require vtkinteraction