vtkImplicitAnnulusRepresentation.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef vtkImplicitAnnulusRepresentation_h
#define vtkImplicitAnnulusRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkVector.h"                   // For vtkVector3d
#include "vtkWidgetRepresentation.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkPolyDataMapper;
class vtkConeSource;
class vtkLineSource;
class vtkSphereSource;
class vtkTubeFilter;
class vtkAnnulus;
class vtkProperty;
class vtkImageData;
class vtkOutlineFilter;
class vtkPolyData;
class vtkBox;
class vtkCellPicker;
 
#define VTK_MAX_ANNULUS_RESOLUTION 2048
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkImplicitAnnulusRepresentation
  : public vtkWidgetRepresentation
{
public:
  // Manage the state of the widget
  enum InteractionStateType
  {
    Outside = 0,
    Moving, // Generic state set by the widget
    MovingOutline,
    MovingCenter,
    RotatingAxis,
    AdjustingInnerRadius,
    AdjustingOuterRadius,
    Scaling,
    TranslatingCenter
  };
 
  static vtkImplicitAnnulusRepresentation* New();
  vtkTypeMacro(vtkImplicitAnnulusRepresentation, vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetCenter(double x, double y, double z);
  void SetCenter(double x[3]);
  double* GetCenter() const VTK_SIZEHINT(3);
  void GetCenter(double xyz[3]) const;


  void SetAxis(double x, double y, double z);
  void SetAxis(double a[3]);
  double* GetAxis() const VTK_SIZEHINT(3);
  void GetAxis(double a[3]) const;


  void SetInnerRadius(double r);
  double GetInnerRadius() const;


  void SetOuterRadius(double r);
  double GetOuterRadius() const;


  void SetAlongXAxis(bool);
  vtkGetMacro(AlongXAxis, bool);
  vtkBooleanMacro(AlongXAxis, bool);
  void SetAlongYAxis(bool);
  vtkGetMacro(AlongYAxis, bool);
  vtkBooleanMacro(AlongYAxis, bool);
  void SetAlongZAxis(bool);
  vtkGetMacro(AlongZAxis, bool);
  vtkBooleanMacro(AlongZAxis, bool);


  void SetDrawAnnulus(bool draw);
  vtkGetMacro(DrawAnnulus, bool);
  vtkBooleanMacro(DrawAnnulus, bool);


  vtkSetClampMacro(Resolution, int, 8, VTK_MAX_ANNULUS_RESOLUTION);
  vtkGetMacro(Resolution, int);


  vtkSetMacro(Tubing, bool);
  vtkGetMacro(Tubing, bool);
  vtkBooleanMacro(Tubing, bool);


  vtkSetMacro(OutlineTranslation, bool);
  vtkGetMacro(OutlineTranslation, bool);
  vtkBooleanMacro(OutlineTranslation, bool);


  vtkSetMacro(OutsideBounds, bool);
  vtkGetMacro(OutsideBounds, bool);
  vtkBooleanMacro(OutsideBounds, bool);


  vtkSetVector6Macro(WidgetBounds, double);
  double* GetWidgetBounds();


  vtkSetMacro(ConstrainToWidgetBounds, bool);
  vtkGetMacro(ConstrainToWidgetBounds, bool);
  vtkBooleanMacro(ConstrainToWidgetBounds, bool);


  vtkSetMacro(ScaleEnabled, bool);
  vtkGetMacro(ScaleEnabled, bool);
  vtkBooleanMacro(ScaleEnabled, bool);

  void GetPolyData(vtkPolyData* pd);

  void UpdatePlacement();


  vtkGetObjectMacro(AxisProperty, vtkProperty);
  vtkGetObjectMacro(SelectedAxisProperty, vtkProperty);


  vtkGetObjectMacro(AnnulusProperty, vtkProperty);
  vtkGetObjectMacro(SelectedAnnulusProperty, vtkProperty);


  vtkGetObjectMacro(RadiusHandleProperty, vtkProperty);
  vtkGetObjectMacro(SelectedRadiusHandleProperty, vtkProperty);


  vtkGetObjectMacro(OutlineProperty, vtkProperty);
  vtkGetObjectMacro(SelectedOutlineProperty, vtkProperty);


  void SetInteractionColor(double, double, double);
  void SetInteractionColor(double c[3]) { this->SetInteractionColor(c[0], c[1], c[2]); }
  void SetHandleColor(double, double, double);
  void SetHandleColor(double c[3]) { this->SetHandleColor(c[0], c[1], c[2]); }
  void SetForegroundColor(double, double, double);
  void SetForegroundColor(double c[3]) { this->SetForegroundColor(c[0], c[1], c[2]); }


  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;


  double* GetBounds() override;
  void GetActors(vtkPropCollection* pc) override;
  void ReleaseGraphicsResources(vtkWindow*) override;
  int RenderOpaqueGeometry(vtkViewport*) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport*) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;


  vtkSetClampMacro(BumpDistance, double, 0.000001, 1);
  vtkGetMacro(BumpDistance, double);

  void BumpAnnulus(int dir, double factor);

  void PushAnnulus(double distance);

  vtkSetClampMacro(InteractionState, InteractionStateType, InteractionStateType::Outside,
    InteractionStateType::TranslatingCenter);


  virtual void SetRepresentationState(InteractionStateType);
  vtkGetMacro(RepresentationState, InteractionStateType);
 
  /*
   * Register internal Pickers within PickingManager
   */
  void RegisterPickers() override;


  vtkGetMacro(TranslationAxis, int);
  vtkSetClampMacro(TranslationAxis, int, Axis::NONE, Axis::ZAxis);


  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; }
 
  void GetAnnulus(vtkAnnulus* annulus) const;
 
protected:
  vtkImplicitAnnulusRepresentation();
  ~vtkImplicitAnnulusRepresentation() override;
 
private:
  struct AxisHandleRepresentation
  {
    vtkNew<vtkLineSource> LineSource;
    vtkNew<vtkPolyDataMapper> LineMapper;
    vtkNew<vtkActor> LineActor;
 
    vtkNew<vtkConeSource> ArrowSource;
    vtkNew<vtkPolyDataMapper> ArrowMapper;
    vtkNew<vtkActor> ArrowActor;
  };
 
  struct RadiusHandleRepresentation
  {
    vtkNew<vtkPolyData> PolyData;
    vtkNew<vtkTubeFilter> Tuber;
    vtkNew<vtkPolyDataMapper> Mapper;
    vtkNew<vtkActor> Actor;
  };
 
  vtkImplicitAnnulusRepresentation(const vtkImplicitAnnulusRepresentation&) = delete;
  void operator=(const vtkImplicitAnnulusRepresentation&) = delete;
 
  void HighlightAnnulus(bool highlight);
  void HighlightCenterHandle(bool highlight);
  void HighlightAxis(bool highlight);
  void HighlightOutline(bool highlight);
  void HighlightInnerRadiusHandle(bool highlight);
  void HighlightOuterRadiusHandle(bool highlight);
 
  // Methods to manipulate the annulus
  void Rotate(
    double X, double Y, const vtkVector3d& p1, const vtkVector3d& p2, const vtkVector3d& vpn);
  void TranslateAnnulus(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateOutline(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateCenter(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateCenterOnAxis(const vtkVector3d& p1, const vtkVector3d& p2);
  void ScaleRadii(const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustOuterRadius(double X, double Y, const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustInnerRadius(double X, double Y, const vtkVector3d& p1, const vtkVector3d& p2);
  void Scale(const vtkVector3d& p1, const vtkVector3d& p2, double X, double Y);
  void SizeHandles();
 
  // Generate the annulus polydata, cropped by the bounding box
  void BuildAnnulus();
 
  // The actual annulus we're manipulating
  vtkNew<vtkAnnulus> Annulus;
 
  InteractionStateType RepresentationState = InteractionStateType::Outside;
  int TranslationAxis = Axis::NONE;
 
  // Keep track of event positions
  vtkVector3d LastEventPosition;
 
  // Controlling the push operation
  double BumpDistance = 0.01;
 
  // Controlling ivars
  bool AlongXAxis = false;
  bool AlongYAxis = false;
  bool AlongZAxis = false;
 
  // The facet resolution for rendering purposes.
  int Resolution = 128;
 
  // The bounding box is represented by a single voxel image data
  vtkNew<vtkImageData> Box;
  vtkNew<vtkOutlineFilter> Outline;
  vtkNew<vtkPolyDataMapper> OutlineMapper;
  vtkNew<vtkActor> OutlineActor;
  bool OutlineTranslation = true; // whether the outline can be moved
  bool ScaleEnabled = true;       // whether the widget can be scaled
  bool OutsideBounds = true;      // whether the widget can be moved outside input's bounds
  vtkVector<double, 6> WidgetBounds;
  bool ConstrainToWidgetBounds = true;
 
  vtkNew<vtkPolyData> AnnulusPD;
  vtkNew<vtkPolyDataMapper> AnnulusMapper;
  vtkNew<vtkActor> AnnulusActor;
  bool DrawAnnulus = true;
 
  // Optional tubes are represented by extracting boundary edges and tubing
  RadiusHandleRepresentation InnerRadiusRepresentation;
  RadiusHandleRepresentation OuterRadiusRepresentation;
  bool Tubing = true; // control whether tubing is on
 
  // Axis representations
  AxisHandleRepresentation LowerAxisRepresentation;
  AxisHandleRepresentation UpperAxisRepresentation;
 
  // Center positioning handle
  vtkNew<vtkSphereSource> CenterHandleSource;
  vtkNew<vtkPolyDataMapper> CenterHandleMapper;
  vtkNew<vtkActor> CenterHandleActor;
 
  // Do the picking
  vtkNew<vtkCellPicker> Picker;
  vtkNew<vtkCellPicker> AnnulusPicker;
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkNew<vtkProperty> AxisProperty;
  vtkNew<vtkProperty> SelectedAxisProperty;
  vtkNew<vtkProperty> AnnulusProperty;
  vtkNew<vtkProperty> SelectedAnnulusProperty;
  vtkNew<vtkProperty> OutlineProperty;
  vtkNew<vtkProperty> SelectedOutlineProperty;
  vtkNew<vtkProperty> RadiusHandleProperty;
  vtkNew<vtkProperty> SelectedRadiusHandleProperty;
  vtkNew<vtkProperty> CenterHandleProperty;
  vtkNew<vtkProperty> SelectedCenterHandleProperty;
 
  vtkNew<vtkBox> BoundingBox;
};
 
VTK_ABI_NAMESPACE_END
#endif