vtkPlaneWidget.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkPlaneWidget.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.
 
=========================================================================*/
#ifndef vtkPlaneWidget_h
#define vtkPlaneWidget_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkPolyDataSourceWidget.h"
 
class vtkActor;
class vtkCellPicker;
class vtkConeSource;
class vtkLineSource;
class vtkPlaneSource;
class vtkPoints;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkProp;
class vtkProperty;
class vtkSphereSource;
class vtkTransform;
class vtkPlane;
 
#define VTK_PLANE_OFF 0
#define VTK_PLANE_OUTLINE 1
#define VTK_PLANE_WIREFRAME 2
#define VTK_PLANE_SURFACE 3
 
class VTKINTERACTIONWIDGETS_EXPORT vtkPlaneWidget : public vtkPolyDataSourceWidget
{
public:
  static vtkPlaneWidget* New();
 
  vtkTypeMacro(vtkPlaneWidget, vtkPolyDataSourceWidget);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetEnabled(int) override;
  void PlaceWidget(double bounds[6]) override;
  void PlaceWidget() override { this->Superclass::PlaceWidget(); }
  void PlaceWidget(
    double xmin, double xmax, double ymin, double ymax, double zmin, double zmax) override
  {
    this->Superclass::PlaceWidget(xmin, xmax, ymin, ymax, zmin, zmax);
  }
 
 
  void SetResolution(int r);
  int GetResolution();
 
 
  void SetOrigin(double x, double y, double z);
  void SetOrigin(double x[3]);
  double* GetOrigin() VTK_SIZEHINT(3);
  void GetOrigin(double xyz[3]);
 
 
  void SetPoint1(double x, double y, double z);
  void SetPoint1(double x[3]);
  double* GetPoint1() VTK_SIZEHINT(3);
  void GetPoint1(double xyz[3]);
 
 
  void SetPoint2(double x, double y, double z);
  void SetPoint2(double x[3]);
  double* GetPoint2() VTK_SIZEHINT(3);
  void GetPoint2(double xyz[3]);
 
 
  void SetCenter(double x, double y, double z);
  void SetCenter(double x[3]);
  double* GetCenter() VTK_SIZEHINT(3);
  void GetCenter(double xyz[3]);
 
 
  void SetNormal(double x, double y, double z);
  void SetNormal(double x[3]);
  double* GetNormal() VTK_SIZEHINT(3);
  void GetNormal(double xyz[3]);
 
 
  vtkSetClampMacro(Representation, int, VTK_PLANE_OFF, VTK_PLANE_SURFACE);
  vtkGetMacro(Representation, int);
  void SetRepresentationToOff() { this->SetRepresentation(VTK_PLANE_OFF); }
  void SetRepresentationToOutline() { this->SetRepresentation(VTK_PLANE_OUTLINE); }
  void SetRepresentationToWireframe() { this->SetRepresentation(VTK_PLANE_WIREFRAME); }
  void SetRepresentationToSurface() { this->SetRepresentation(VTK_PLANE_SURFACE); }
 
 
  vtkSetMacro(NormalToXAxis, vtkTypeBool);
  vtkGetMacro(NormalToXAxis, vtkTypeBool);
  vtkBooleanMacro(NormalToXAxis, vtkTypeBool);
  vtkSetMacro(NormalToYAxis, vtkTypeBool);
  vtkGetMacro(NormalToYAxis, vtkTypeBool);
  vtkBooleanMacro(NormalToYAxis, vtkTypeBool);
  vtkSetMacro(NormalToZAxis, vtkTypeBool);
  vtkGetMacro(NormalToZAxis, vtkTypeBool);
  vtkBooleanMacro(NormalToZAxis, vtkTypeBool);
 
  void GetPolyData(vtkPolyData* pd);
 
  void GetPlane(vtkPlane* plane);
 
  vtkPolyDataAlgorithm* GetPolyDataAlgorithm() override;
 
  void UpdatePlacement(void) override;
 
 
  vtkGetObjectMacro(HandleProperty, vtkProperty);
  vtkGetObjectMacro(SelectedHandleProperty, vtkProperty);
 
 
  virtual void SetPlaneProperty(vtkProperty*);
  vtkGetObjectMacro(PlaneProperty, vtkProperty);
  vtkGetObjectMacro(SelectedPlaneProperty, vtkProperty);
 
protected:
  vtkPlaneWidget();
  ~vtkPlaneWidget() override;
 
  // Manage the state of the widget
  int State;
  enum WidgetState
  {
    Start = 0,
    Moving,
    Scaling,
    Pushing,
    Rotating,
    Spinning,
    Outside,
    Pinching
  };
 
  // handles the events
  static void ProcessEvents(
    vtkObject* object, unsigned long event, void* clientdata, void* calldata);
 
  // ProcessEvents() dispatches to these methods.
  void OnLeftButtonDown();
  void OnLeftButtonUp();
  void OnMiddleButtonDown();
  void OnMiddleButtonUp();
  void OnRightButtonDown();
  void OnRightButtonUp();
  void OnMouseMove();
  void OnStartPinch();
  void OnPinch();
  void OnEndPinch();
 
  // controlling ivars
  vtkTypeBool NormalToXAxis;
  vtkTypeBool NormalToYAxis;
  vtkTypeBool NormalToZAxis;
  int Representation;
  void SelectRepresentation();
 
  // the plane
  vtkActor* PlaneActor;
  vtkPolyDataMapper* PlaneMapper;
  vtkPlaneSource* PlaneSource;
  vtkPolyData* PlaneOutline;
  void HighlightPlane(int highlight);
 
  // glyphs representing hot spots (e.g., handles)
  vtkActor** Handle;
  vtkPolyDataMapper** HandleMapper;
  vtkSphereSource** HandleGeometry;
  void PositionHandles();
  void HandlesOn(double length);
  void HandlesOff();
  int HighlightHandle(vtkProp* prop); // returns cell id
  void SizeHandles() override;
 
  // the normal cone
  vtkActor* ConeActor;
  vtkPolyDataMapper* ConeMapper;
  vtkConeSource* ConeSource;
  void HighlightNormal(int highlight);
 
  // the normal line
  vtkActor* LineActor;
  vtkPolyDataMapper* LineMapper;
  vtkLineSource* LineSource;
 
  // the normal cone
  vtkActor* ConeActor2;
  vtkPolyDataMapper* ConeMapper2;
  vtkConeSource* ConeSource2;
 
  // the normal line
  vtkActor* LineActor2;
  vtkPolyDataMapper* LineMapper2;
  vtkLineSource* LineSource2;
 
  // Do the picking
  vtkCellPicker* HandlePicker;
  vtkCellPicker* PlanePicker;
  vtkActor* CurrentHandle;
 
  // Register internal Pickers within PickingManager
  void RegisterPickers() override;
 
  // Methods to manipulate the hexahedron.
  void MoveOrigin(double* p1, double* p2);
  void MovePoint1(double* p1, double* p2);
  void MovePoint2(double* p1, double* p2);
  void MovePoint3(double* p1, double* p2);
  void Rotate(int X, int Y, double* p1, double* p2, double* vpn);
  void Spin(double* p1, double* p2);
  void Scale(double* p1, double* p2, int X, int Y);
  void Translate(double* p1, double* p2);
  void Push(double* p1, double* p2);
 
  // Plane normal, normalized
  double Normal[3];
 
  // Transform the hexahedral points (used for rotations)
  vtkTransform* Transform;
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkProperty* HandleProperty;
  vtkProperty* SelectedHandleProperty;
  vtkProperty* PlaneProperty;
  vtkProperty* SelectedPlaneProperty;
  void CreateDefaultProperties();
 
  void GeneratePlane();
 
  int LastPickValid;
  double HandleSizeFactor;
 
private:
  vtkPlaneWidget(const vtkPlaneWidget&) = delete;
  void operator=(const vtkPlaneWidget&) = delete;
};
 
#endif