You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
424 lines
13 KiB
C++
424 lines
13 KiB
C++
/*=========================================================================
|
|
|
|
Program: Visualization Toolkit
|
|
Module: vtkSphereRepresentation.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.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkSphereRepresentation
|
|
* @brief a class defining the representation for the vtkSphereWidget2
|
|
*
|
|
* This class is a concrete representation for the vtkSphereWidget2. It
|
|
* represents a sphere with an optional handle. Through interaction with the
|
|
* widget, the sphere can be arbitrarily positioned and scaled in 3D space;
|
|
* and the handle can be moved on the surface of the sphere. Typically the
|
|
* vtkSphereWidget2/vtkSphereRepresentation 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 PlaceWidget() 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.
|
|
*
|
|
* @warning
|
|
* Note that the representation is overconstrained in that the center and radius
|
|
* of the sphere can be defined, this information plus the handle direction defines
|
|
* the geometry of the representation. Alternatively, the user may specify the center
|
|
* of the sphere plus the handle position.
|
|
*
|
|
* @warning
|
|
* This class, and vtkSphereWidget2, are second generation VTK widgets. An
|
|
* earlier version of this functionality was defined in the class
|
|
* vtkSphereWidget.
|
|
*
|
|
* @sa
|
|
* vtkSphereWidget2 vtkSphereWidget
|
|
*/
|
|
|
|
#ifndef vtkSphereRepresentation_h
|
|
#define vtkSphereRepresentation_h
|
|
|
|
#include "vtkInteractionWidgetsModule.h" // For export macro
|
|
#include "vtkSphereSource.h" // Needed for fast access to the sphere source
|
|
#include "vtkWidgetRepresentation.h"
|
|
|
|
class vtkActor;
|
|
class vtkPolyDataMapper;
|
|
class vtkSphere;
|
|
class vtkSphereSource;
|
|
class vtkCellPicker;
|
|
class vtkProperty;
|
|
class vtkPolyData;
|
|
class vtkPoints;
|
|
class vtkPolyDataAlgorithm;
|
|
class vtkTransform;
|
|
class vtkDoubleArray;
|
|
class vtkMatrix4x4;
|
|
class vtkTextMapper;
|
|
class vtkActor2D;
|
|
class vtkTextProperty;
|
|
class vtkLineSource;
|
|
class vtkCursor3D;
|
|
|
|
#define VTK_SPHERE_OFF 0
|
|
#define VTK_SPHERE_WIREFRAME 1
|
|
#define VTK_SPHERE_SURFACE 2
|
|
|
|
class VTKINTERACTIONWIDGETS_EXPORT vtkSphereRepresentation : public vtkWidgetRepresentation
|
|
{
|
|
public:
|
|
/**
|
|
* Instantiate the class.
|
|
*/
|
|
static vtkSphereRepresentation* New();
|
|
|
|
//@{
|
|
/**
|
|
* Standard methods for type information and to print out the contents of the class.
|
|
*/
|
|
vtkTypeMacro(vtkSphereRepresentation, vtkWidgetRepresentation);
|
|
void PrintSelf(ostream& os, vtkIndent indent) override;
|
|
//@}
|
|
|
|
// Used to manage the state of the widget
|
|
enum
|
|
{
|
|
Outside = 0,
|
|
MovingHandle,
|
|
OnSphere,
|
|
Translating,
|
|
Scaling
|
|
};
|
|
|
|
//@{
|
|
/**
|
|
* Set the representation (i.e., appearance) of the sphere. Different
|
|
* representations are useful depending on the application.
|
|
*/
|
|
vtkSetClampMacro(Representation, int, VTK_SPHERE_OFF, VTK_SPHERE_SURFACE);
|
|
vtkGetMacro(Representation, int);
|
|
void SetRepresentationToOff() { this->SetRepresentation(VTK_SPHERE_OFF); }
|
|
void SetRepresentationToWireframe() { this->SetRepresentation(VTK_SPHERE_WIREFRAME); }
|
|
void SetRepresentationToSurface() { this->SetRepresentation(VTK_SPHERE_SURFACE); }
|
|
//@}
|
|
|
|
/**
|
|
* Set/Get the resolution of the sphere in the theta direction.
|
|
*/
|
|
void SetThetaResolution(int r) { this->SphereSource->SetThetaResolution(r); }
|
|
int GetThetaResolution() { return this->SphereSource->GetThetaResolution(); }
|
|
|
|
/**
|
|
* Set/Get the resolution of the sphere in the phi direction.
|
|
*/
|
|
void SetPhiResolution(int r) { this->SphereSource->SetPhiResolution(r); }
|
|
int GetPhiResolution() { return this->SphereSource->GetPhiResolution(); }
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
void SetCenter(double c[3]);
|
|
void SetCenter(double x, double y, double z)
|
|
{
|
|
double c[3];
|
|
c[0] = x;
|
|
c[1] = y;
|
|
c[2] = z;
|
|
this->SetCenter(c);
|
|
}
|
|
double* GetCenter() VTK_SIZEHINT(3) { return this->SphereSource->GetCenter(); }
|
|
void GetCenter(double xyz[3]) { this->SphereSource->GetCenter(xyz); }
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
void SetRadius(double r);
|
|
double GetRadius() { return this->SphereSource->GetRadius(); }
|
|
|
|
//@{
|
|
/**
|
|
* 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.
|
|
*/
|
|
vtkSetMacro(HandleVisibility, vtkTypeBool);
|
|
vtkGetMacro(HandleVisibility, vtkTypeBool);
|
|
vtkBooleanMacro(HandleVisibility, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the position of the handle. Note that this may adjust the radius
|
|
* of the sphere and the handle direction.
|
|
*/
|
|
void SetHandlePosition(double handle[3]);
|
|
void SetHandlePosition(double x, double y, double z)
|
|
{
|
|
double p[3];
|
|
p[0] = x;
|
|
p[1] = y;
|
|
p[2] = z;
|
|
this->SetHandlePosition(p);
|
|
}
|
|
vtkGetVector3Macro(HandlePosition, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Set/Get the direction vector of the handle relative to the center of
|
|
* the sphere. Setting the direction may affect the position of the handle
|
|
* but will not affect the radius or position of the sphere.
|
|
*/
|
|
void SetHandleDirection(double dir[3]);
|
|
void SetHandleDirection(double dx, double dy, double dz)
|
|
{
|
|
double d[3];
|
|
d[0] = dx;
|
|
d[1] = dy;
|
|
d[2] = dz;
|
|
this->SetHandleDirection(d);
|
|
}
|
|
vtkGetVector3Macro(HandleDirection, double);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* 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.
|
|
*/
|
|
vtkSetMacro(HandleText, vtkTypeBool);
|
|
vtkGetMacro(HandleText, vtkTypeBool);
|
|
vtkBooleanMacro(HandleText, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable a radial line segment that joins the center of the
|
|
* outer sphere and the handle.
|
|
*/
|
|
vtkSetMacro(RadialLine, vtkTypeBool);
|
|
vtkGetMacro(RadialLine, vtkTypeBool);
|
|
vtkBooleanMacro(RadialLine, vtkTypeBool);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Enable/disable a center cursor
|
|
* Default is disabled
|
|
*/
|
|
vtkSetMacro(CenterCursor, bool);
|
|
vtkGetMacro(CenterCursor, bool);
|
|
vtkBooleanMacro(CenterCursor, bool);
|
|
//@}
|
|
|
|
/**
|
|
* 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
|
|
* InteractionEvent or EndInteraction events are invoked. The user provides
|
|
* the vtkPolyData and the points and polysphere are added to it.
|
|
*/
|
|
void GetPolyData(vtkPolyData* pd);
|
|
|
|
/**
|
|
* Get the spherical implicit function defined by this widget. Note that
|
|
* vtkSphere is a subclass of vtkImplicitFunction, meaning that it can be
|
|
* used by a variety of filters to perform clipping, cutting, and selection
|
|
* of data.
|
|
*/
|
|
void GetSphere(vtkSphere* sphere);
|
|
|
|
//@{
|
|
/**
|
|
* Get the sphere properties. The properties of the sphere when selected
|
|
* and unselected can be manipulated.
|
|
*/
|
|
vtkGetObjectMacro(SphereProperty, vtkProperty);
|
|
vtkGetObjectMacro(SelectedSphereProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* 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.
|
|
*/
|
|
vtkGetObjectMacro(HandleProperty, vtkProperty);
|
|
vtkGetObjectMacro(SelectedHandleProperty, vtkProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Get the handle text property. This can be used to control the appearance
|
|
* of the handle text.
|
|
*/
|
|
vtkGetObjectMacro(HandleTextProperty, vtkTextProperty);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* 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.
|
|
*/
|
|
vtkGetObjectMacro(RadialLineProperty, vtkProperty);
|
|
//@}
|
|
|
|
/**
|
|
* The interaction state may be set from a widget (e.g., vtkSphereWidget2) 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 ComputeInteractionState() 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.
|
|
*/
|
|
void SetInteractionState(int state);
|
|
|
|
//@{
|
|
/**
|
|
* These are methods that satisfy vtkWidgetRepresentation's API. Note that a
|
|
* version of place widget is available where the center and handle position
|
|
* are specified.
|
|
*/
|
|
void PlaceWidget(double bounds[6]) override;
|
|
virtual void PlaceWidget(double center[3], double handlePosition[3]);
|
|
void BuildRepresentation() override;
|
|
int ComputeInteractionState(int X, int Y, int modify = 0) override;
|
|
void StartWidgetInteraction(double e[2]) override;
|
|
void WidgetInteraction(double e[2]) override;
|
|
double* GetBounds() override;
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Methods supporting, and required by, the rendering process.
|
|
*/
|
|
void ReleaseGraphicsResources(vtkWindow*) override;
|
|
int RenderOpaqueGeometry(vtkViewport*) override;
|
|
int RenderTranslucentPolygonalGeometry(vtkViewport*) override;
|
|
int RenderOverlay(vtkViewport*) override;
|
|
vtkTypeBool HasTranslucentPolygonalGeometry() override;
|
|
//@}
|
|
|
|
/*
|
|
* Register internal Pickers within PickingManager
|
|
*/
|
|
void RegisterPickers() override;
|
|
|
|
//@{
|
|
/**
|
|
* Gets/Sets the constraint axis for translations. Returns Axis::NONE
|
|
* if none.
|
|
**/
|
|
vtkGetMacro(TranslationAxis, int);
|
|
vtkSetClampMacro(TranslationAxis, int, -1, 2);
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Toggles constraint translation axis on/off.
|
|
*/
|
|
void SetXTranslationAxisOn() { this->TranslationAxis = Axis::XAxis; }
|
|
void SetYTranslationAxisOn() { this->TranslationAxis = Axis::YAxis; }
|
|
void SetZTranslationAxisOn() { this->TranslationAxis = Axis::ZAxis; }
|
|
void SetTranslationAxisOff() { this->TranslationAxis = Axis::NONE; }
|
|
//@}
|
|
|
|
//@{
|
|
/**
|
|
* Returns true if ContrainedAxis
|
|
**/
|
|
bool IsTranslationConstrained() { return this->TranslationAxis != Axis::NONE; }
|
|
//@}
|
|
|
|
protected:
|
|
vtkSphereRepresentation();
|
|
~vtkSphereRepresentation() override;
|
|
|
|
// Manage how the representation appears
|
|
double LastEventPosition[3];
|
|
|
|
int TranslationAxis;
|
|
|
|
// the sphere
|
|
vtkActor* SphereActor;
|
|
vtkPolyDataMapper* SphereMapper;
|
|
vtkSphereSource* SphereSource;
|
|
void HighlightSphere(int highlight);
|
|
|
|
// The representation of the sphere
|
|
int Representation;
|
|
|
|
// Do the picking
|
|
vtkCellPicker* HandlePicker;
|
|
vtkCellPicker* SpherePicker;
|
|
double LastPickPosition[3];
|
|
|
|
// Methods to manipulate the sphere widget
|
|
void Translate(const double* p1, const double* p2);
|
|
void Scale(const double* p1, const double* p2, int X, int Y);
|
|
void PlaceHandle(const double* center, double radius);
|
|
virtual void SizeHandles();
|
|
|
|
// Method to adapt the center cursor bounds
|
|
// so it always have the same pixel size on screen
|
|
virtual void AdaptCenterCursorBounds();
|
|
|
|
// Properties used to control the appearance of selected objects and
|
|
// the manipulator in general.
|
|
vtkProperty* SphereProperty;
|
|
vtkProperty* SelectedSphereProperty;
|
|
vtkProperty* HandleProperty;
|
|
vtkProperty* SelectedHandleProperty;
|
|
void CreateDefaultProperties();
|
|
|
|
// Managing the handle
|
|
vtkActor* HandleActor;
|
|
vtkPolyDataMapper* HandleMapper;
|
|
vtkSphereSource* HandleSource;
|
|
void HighlightHandle(int);
|
|
vtkTypeBool HandleVisibility;
|
|
double HandleDirection[3];
|
|
double HandlePosition[3];
|
|
|
|
// Manage the handle label
|
|
vtkTypeBool HandleText;
|
|
vtkTextProperty* HandleTextProperty;
|
|
vtkTextMapper* HandleTextMapper;
|
|
vtkActor2D* HandleTextActor;
|
|
|
|
// Manage the radial line segment
|
|
vtkTypeBool RadialLine;
|
|
vtkProperty* RadialLineProperty;
|
|
vtkLineSource* RadialLineSource;
|
|
vtkPolyDataMapper* RadialLineMapper;
|
|
vtkActor* RadialLineActor;
|
|
|
|
// Managing the center cursor
|
|
vtkActor* CenterActor;
|
|
vtkPolyDataMapper* CenterMapper;
|
|
vtkCursor3D* CenterCursorSource;
|
|
bool CenterCursor;
|
|
|
|
private:
|
|
vtkSphereRepresentation(const vtkSphereRepresentation&) = delete;
|
|
void operator=(const vtkSphereRepresentation&) = delete;
|
|
};
|
|
|
|
#endif
|