vtkImplicitConeRepresentation.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 vtkImplicitConeRepresentation_h
#define vtkImplicitConeRepresentation_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 vtkCone;
class vtkProperty;
class vtkImageData;
class vtkOutlineFilter;
class vtkPolyData;
class vtkBox;
class vtkCellPicker;
 
#define VTK_MAX_CONE_RESOLUTION 2048
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkImplicitConeRepresentation
  : public vtkWidgetRepresentation
{
public:
  // Manage the state of the widget
  enum InteractionStateType
  {
    Outside = 0,
    Moving, // Generic state set by the widget
    MovingOutline,
    MovingOrigin,
    RotatingAxis,
    AdjustingAngle,
    Scaling,
    TranslatingOrigin
  };
 
  static vtkImplicitConeRepresentation* New();
  vtkTypeMacro(vtkImplicitConeRepresentation, 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 SetAxis(double x, double y, double z);
  void SetAxis(double a[3]);
  double* GetAxis() VTK_SIZEHINT(3);
  void GetAxis(double a[3]);
 
 
  void SetAngle(double r);
  double GetAngle();
 
 
  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 SetDrawCone(bool draw);
  vtkGetMacro(DrawCone, bool);
  vtkBooleanMacro(DrawCone, bool);
 
 
  vtkSetClampMacro(Resolution, int, 8, VTK_MAX_CONE_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);
  vtkGetVector6Macro(WidgetBounds, double);
 
 
  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(ConeProperty, vtkProperty);
  vtkGetObjectMacro(SelectedConeProperty, vtkProperty);
 
 
  vtkGetObjectMacro(OutlineProperty, vtkProperty);
  vtkGetObjectMacro(SelectedOutlineProperty, vtkProperty);
 
 
  vtkGetObjectMacro(EdgesProperty, 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 BumpCone(int dir, double factor);
 
  void PushCone(double distance);
 
  vtkSetClampMacro(InteractionState, InteractionStateType, InteractionStateType::Outside,
    InteractionStateType::TranslatingOrigin);
 
 
  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 GetCone(vtkCone* cone) const;
 
protected:
  vtkImplicitConeRepresentation();
  ~vtkImplicitConeRepresentation() override;
 
  // The actual cone we're manipulating
  vtkNew<vtkCone> Cone;
 
  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
  double WidgetBounds[6];
  bool ConstrainToWidgetBounds = true;
 
  vtkNew<vtkPolyData> ConePD;
  vtkNew<vtkPolyDataMapper> ConePDMapper;
  vtkNew<vtkActor> ConePDActor;
  bool DrawCone = true;
 
  // Optional tubes are represented by extracting boundary edges and tubing
  vtkNew<vtkPolyData> EdgesPD;
  vtkNew<vtkTubeFilter> EdgesTuber;
  vtkNew<vtkPolyDataMapper> EdgesMapper;
  vtkNew<vtkActor> EdgesActor;
  bool Tubing = true; // control whether tubing is on
 
  // The axis line
  vtkNew<vtkLineSource> AxisLineSource;
  vtkNew<vtkPolyDataMapper> AxisLineMapper;
  vtkNew<vtkActor> AxisLineActor;
 
  // Axis line arrow
  vtkNew<vtkConeSource> AxisArrowSource;
  vtkNew<vtkPolyDataMapper> AxisArrowMapper;
  vtkNew<vtkActor> AxisArrowActor;
 
  // The origin positioning handle
  vtkNew<vtkSphereSource> OriginHandleSource;
  vtkNew<vtkPolyDataMapper> OriginHandleMapper;
  vtkNew<vtkActor> OriginHandleActor;
 
  // Do the picking
  vtkNew<vtkCellPicker> Picker;
  vtkNew<vtkCellPicker> ConePicker;
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkNew<vtkProperty> AxisProperty;
  vtkNew<vtkProperty> SelectedAxisProperty;
  vtkNew<vtkProperty> ConeProperty;
  vtkNew<vtkProperty> SelectedConeProperty;
  vtkNew<vtkProperty> OutlineProperty;
  vtkNew<vtkProperty> SelectedOutlineProperty;
  vtkNew<vtkProperty> EdgesProperty;
  vtkNew<vtkProperty> OriginHandleProperty;
  vtkNew<vtkProperty> SelectedOriginHandleProperty;
 
  // Support GetBounds() method
  vtkNew<vtkBox> BoundingBox;
 
  void HighlightCone(bool highlight);
  void HighlightOriginHandle(bool highlight);
  void HighlightAxis(bool highlight);
  void HighlightOutline(bool highlight);
 
  // Methods to manipulate the cone
  void Rotate(
    double X, double Y, const vtkVector3d& p1, const vtkVector3d& p2, const vtkVector3d& vpn);
  void TranslateCone(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateOutline(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateOrigin(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateOriginOnAxis(const vtkVector3d& p1, const vtkVector3d& p2);
  void ScaleAngle(const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustAngle(double X, double Y, const vtkVector3d& p1, const vtkVector3d& p2);
  void Scale(const vtkVector3d& p1, const vtkVector3d& p2, double X, double Y);
  void SizeHandles();
 
  // Intersect oriented infinite cone against bounding box
  void BuildCone();
 
  vtkImplicitConeRepresentation(const vtkImplicitConeRepresentation&) = delete;
  void operator=(const vtkImplicitConeRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif