doxygen/html/vtkImplicitPlaneRepresentation_8h_source.html

/*=========================================================================


  Program:   Visualization Toolkit

  Module:    vtkImplicitPlaneRepresentation.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 vtkImplicitPlaneRepresentation_h

#define vtkImplicitPlaneRepresentation_h


#include "vtkInteractionWidgetsModule.h" // For export macro

#include "vtkWidgetRepresentation.h"


class vtkActor;

class vtkPolyDataMapper;

class vtkCellPicker;

class vtkConeSource;

class vtkLineSource;

class vtkSphereSource;

class vtkTubeFilter;

class vtkPlane;

class vtkPlaneSource;

class vtkCutter;

class vtkProperty;

class vtkImageData;

class vtkOutlineFilter;

class vtkFeatureEdges;

class vtkPolyData;

class vtkPolyDataAlgorithm;

class vtkTransform;

class vtkBox;

class vtkLookupTable;


class VTKINTERACTIONWIDGETS_EXPORT vtkImplicitPlaneRepresentation : public vtkWidgetRepresentation

{

public:

  static vtkImplicitPlaneRepresentation* New();


  vtkTypeMacro(vtkImplicitPlaneRepresentation, vtkWidgetRepresentation);

  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetOrigin(double x, double y, double z);

  void SetOrigin(double x[3]);

  double* GetOrigin() VTK_SIZEHINT(3);

  void GetOrigin(double xyz[3]);


  void SetNormal(double x, double y, double z);

  void SetNormal(double x[3]);

  void SetNormalToCamera();

  double* GetNormal() VTK_SIZEHINT(3);

  void GetNormal(double xyz[3]);


  void SetNormalToXAxis(vtkTypeBool);

  vtkGetMacro(NormalToXAxis, vtkTypeBool);

  vtkBooleanMacro(NormalToXAxis, vtkTypeBool);

  void SetNormalToYAxis(vtkTypeBool);

  vtkGetMacro(NormalToYAxis, vtkTypeBool);

  vtkBooleanMacro(NormalToYAxis, vtkTypeBool);

  void SetNormalToZAxis(vtkTypeBool);

  vtkGetMacro(NormalToZAxis, vtkTypeBool);

  vtkBooleanMacro(NormalToZAxis, vtkTypeBool);


  virtual void SetLockNormalToCamera(vtkTypeBool);

  vtkGetMacro(LockNormalToCamera, vtkTypeBool);

  vtkBooleanMacro(LockNormalToCamera, vtkTypeBool);


  vtkSetMacro(Tubing, vtkTypeBool);

  vtkGetMacro(Tubing, vtkTypeBool);

  vtkBooleanMacro(Tubing, vtkTypeBool);


  void SetDrawPlane(vtkTypeBool plane);

  vtkGetMacro(DrawPlane, vtkTypeBool);

  vtkBooleanMacro(DrawPlane, vtkTypeBool);


  void SetDrawOutline(vtkTypeBool plane);

  vtkGetMacro(DrawOutline, vtkTypeBool);

  vtkBooleanMacro(DrawOutline, vtkTypeBool);


  vtkSetMacro(OutlineTranslation, vtkTypeBool);

  vtkGetMacro(OutlineTranslation, vtkTypeBool);

  vtkBooleanMacro(OutlineTranslation, vtkTypeBool);


  vtkSetMacro(OutsideBounds, vtkTypeBool);

  vtkGetMacro(OutsideBounds, vtkTypeBool);

  vtkBooleanMacro(OutsideBounds, vtkTypeBool);


  void SetXTranslationAxisOn() { this->TranslationAxis = Axis::XAxis; }

  void SetYTranslationAxisOn() { this->TranslationAxis = Axis::YAxis; }

  void SetZTranslationAxisOn() { this->TranslationAxis = Axis::ZAxis; }

  void SetTranslationAxisOff() { this->TranslationAxis = Axis::NONE; }


  bool IsTranslationConstrained() { return this->TranslationAxis != Axis::NONE; }


  vtkSetVector6Macro(WidgetBounds, double);

  vtkGetVector6Macro(WidgetBounds, double);


  vtkSetMacro(ConstrainToWidgetBounds, vtkTypeBool);

  vtkGetMacro(ConstrainToWidgetBounds, vtkTypeBool);

  vtkBooleanMacro(ConstrainToWidgetBounds, vtkTypeBool);


  vtkSetMacro(ScaleEnabled, vtkTypeBool);

  vtkGetMacro(ScaleEnabled, vtkTypeBool);

  vtkBooleanMacro(ScaleEnabled, vtkTypeBool);


  void GetPolyData(vtkPolyData* pd);


  vtkPolyDataAlgorithm* GetPolyDataAlgorithm();


  void GetPlane(vtkPlane* plane);


  void SetPlane(vtkPlane* plane);


  void UpdatePlacement(void);


  vtkGetObjectMacro(NormalProperty, vtkProperty);

  vtkGetObjectMacro(SelectedNormalProperty, vtkProperty);


  vtkGetObjectMacro(PlaneProperty, vtkProperty);

  vtkGetObjectMacro(SelectedPlaneProperty, vtkProperty);


  vtkGetObjectMacro(OutlineProperty, vtkProperty);

  vtkGetObjectMacro(SelectedOutlineProperty, vtkProperty);


  vtkGetObjectMacro(EdgesProperty, vtkProperty);


  void SetEdgeColor(vtkLookupTable*);

  void SetEdgeColor(double, double, double);

  void SetEdgeColor(double x[3]);


  vtkSetClampMacro(BumpDistance, double, 0.000001, 1);

  vtkGetMacro(BumpDistance, double);


  void BumpPlane(int dir, double factor);


  void PushPlane(double distance);


  int ComputeInteractionState(int X, int Y, int modify = 0) override;

  void PlaceWidget(double bounds[6]) override;

  void BuildRepresentation() override;

  void StartWidgetInteraction(double eventPos[2]) override;

  void WidgetInteraction(double newEventPos[2]) override;

  void EndWidgetInteraction(double newEventPos[2]) override;

  void StartComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;

  void ComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;

  int ComputeComplexInteractionState(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata, int modify = 0) override;

  void EndComplexInteraction(vtkRenderWindowInteractor* iren, vtkAbstractWidget* widget,

    unsigned long event, void* calldata) override;


  double* GetBounds() VTK_SIZEHINT(6) override;

  void GetActors(vtkPropCollection* pc) override;

  void ReleaseGraphicsResources(vtkWindow*) override;

  int RenderOpaqueGeometry(vtkViewport*) override;

  int RenderTranslucentPolygonalGeometry(vtkViewport*) override;

  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  // Manage the state of the widget

  enum _InteractionState

  {

    Outside = 0,

    Moving,

    MovingOutline,

    MovingOrigin,

    Rotating,

    Pushing,

    Scaling

  };


  vtkSetClampMacro(InteractionState, int, Outside, Scaling);


  virtual void SetRepresentationState(int);

  vtkGetMacro(RepresentationState, int);


  // Get the underlying plane object used by this rep

  // this can be used as a cropping plane in vtkMapper

  vtkPlane* GetUnderlyingPlane() { return this->Plane; }


  virtual void SetCropPlaneToBoundingBox(bool);

  vtkGetMacro(CropPlaneToBoundingBox, bool);

  vtkBooleanMacro(CropPlaneToBoundingBox, bool);


  vtkGetMacro(SnapToAxes, bool);

  vtkSetMacro(SnapToAxes, bool);


  vtkGetMacro(AlwaysSnapToNearestAxis, bool);

  virtual void SetAlwaysSnapToNearestAxis(bool snap)

  {

    this->AlwaysSnapToNearestAxis = snap;

    this->SetNormal(this->GetNormal());

  }


protected:

  vtkImplicitPlaneRepresentation();

  ~vtkImplicitPlaneRepresentation() override;


  int RepresentationState;


  // Keep track of event positions

  double LastEventPosition[3];

  double LastEventOrientation[4];

  double StartEventOrientation[4];


  // Controlling ivars

  vtkTypeBool NormalToXAxis;

  vtkTypeBool NormalToYAxis;

  vtkTypeBool NormalToZAxis;


  double SnappedEventOrientation[4];

  bool SnappedOrientation;

  bool SnapToAxes;


  bool AlwaysSnapToNearestAxis;


  // Locking normal to camera

  vtkTypeBool LockNormalToCamera;


  // Controlling the push operation

  double BumpDistance;


  // The actual plane which is being manipulated

  vtkPlane* Plane;


  int TranslationAxis;


  // The bounding box is represented by a single voxel image data

  vtkImageData* Box;

  vtkOutlineFilter* Outline;

  vtkPolyDataMapper* OutlineMapper;

  vtkActor* OutlineActor;

  void HighlightOutline(int highlight);

  vtkTypeBool OutlineTranslation; // whether the outline can be moved

  vtkTypeBool ScaleEnabled;       // whether the widget can be scaled

  vtkTypeBool OutsideBounds;      // whether the widget can be moved outside input's bounds

  double WidgetBounds[6];

  vtkTypeBool ConstrainToWidgetBounds;


  // The cut plane is produced with a vtkCutter

  vtkCutter* Cutter;

  vtkPlaneSource* PlaneSource;

  vtkPolyDataMapper* CutMapper;

  vtkActor* CutActor;

  vtkTypeBool DrawPlane;

  vtkTypeBool DrawOutline;

  void HighlightPlane(int highlight);


  // Optional tubes are represented by extracting boundary edges and tubing

  vtkFeatureEdges* Edges;

  vtkTubeFilter* EdgesTuber;

  vtkPolyDataMapper* EdgesMapper;

  vtkActor* EdgesActor;

  vtkTypeBool Tubing; // control whether tubing is on


  // The + normal cone

  vtkConeSource* ConeSource;

  vtkPolyDataMapper* ConeMapper;

  vtkActor* ConeActor;

  void HighlightNormal(int highlight);


  // The + normal line

  vtkLineSource* LineSource;

  vtkPolyDataMapper* LineMapper;

  vtkActor* LineActor;


  // The - normal cone

  vtkConeSource* ConeSource2;

  vtkPolyDataMapper* ConeMapper2;

  vtkActor* ConeActor2;


  // The - normal line

  vtkLineSource* LineSource2;

  vtkPolyDataMapper* LineMapper2;

  vtkActor* LineActor2;


  // The origin positioning handle

  vtkSphereSource* Sphere;

  vtkPolyDataMapper* SphereMapper;

  vtkActor* SphereActor;


  // Do the picking

  vtkCellPicker* Picker;


  // Register internal Pickers within PickingManager

  void RegisterPickers() override;


  // Transform the normal (used for rotation)

  vtkTransform* Transform;


  // Methods to manipulate the plane

  void Rotate(double X, double Y, double* p1, double* p2, double* vpn);

  void Rotate3D(double* p1, double* p2);

  void TranslatePlane(double* p1, double* p2);

  void TranslateOutline(double* p1, double* p2);

  void TranslateOrigin(double* p1, double* p2);

  void UpdatePose(double* p1, double* d1, double* p2, double* d2);

  void Push(double* p1, double* p2);

  void Scale(double* p1, double* p2, double X, double Y);

  void SizeHandles();


  // Properties used to control the appearance of selected objects and

  // the manipulator in general.

  vtkProperty* NormalProperty;

  vtkProperty* SelectedNormalProperty;

  vtkProperty* PlaneProperty;

  vtkProperty* SelectedPlaneProperty;

  vtkProperty* OutlineProperty;

  vtkProperty* SelectedOutlineProperty;

  vtkProperty* EdgesProperty;

  void CreateDefaultProperties();


  void GeneratePlane();


  bool CropPlaneToBoundingBox;


  // Support GetBounds() method

  vtkBox* BoundingBox;


private:

  vtkImplicitPlaneRepresentation(const vtkImplicitPlaneRepresentation&) = delete;

  void operator=(const vtkImplicitPlaneRepresentation&) = delete;

};


#endif