vtkImplicitFrustumRepresentation.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 vtkImplicitFrustumRepresentation_h
#define vtkImplicitFrustumRepresentation_h

#include "vtkBoundedWidgetRepresentation.h"
#include "vtkEllipseArcSource.h"
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkVector.h"                   // For vtkVector3d
#include "vtkWrappingHints.h"            // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkBox;
class vtkConeSource;
class vtkCellPicker;
class vtkEllipseArcSource;
class vtkFrustum;
class vtkLineSource;
class vtkProperty;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkSphereSource;
class vtkTransform;
class vtkTubeFilter;

class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkImplicitFrustumRepresentation
  : public vtkBoundedWidgetRepresentation
{
public:
  // Manage the state of the widget
  enum InteractionStateType
  {
    Outside = 0,
    Moving, // Generic state set by the widget
    MovingOrigin,
    AdjustingHorizontalAngle,
    AdjustingVerticalAngle,
    AdjustingNearPlaneDistance,
    AdjustingYaw,
    AdjustingPitch,
    AdjustingRoll,
    TranslatingOriginOnAxis
  };

  static vtkImplicitFrustumRepresentation* New();
  vtkTypeMacro(vtkImplicitFrustumRepresentation, vtkBoundedWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetOrigin(double x, double y, double z);
  void SetOrigin(double x[3]);
  void SetOrigin(const vtkVector3d& xyz);
  double* GetOrigin() VTK_SIZEHINT(3);
  void GetOrigin(double xyz[3]) const;


  void SetOrientation(double x, double y, double z);
  void SetOrientation(const double xyz[3]);
  void SetOrientation(const vtkVector3d& xyz);
  double* GetOrientation() VTK_SIZEHINT(3);
  void GetOrientation(double& x, double& y, double& z);
  void GetOrientation(double xyz[3]);


  double GetHorizontalAngle() const;
  void SetHorizontalAngle(double angle);


  double GetVerticalAngle() const;
  void SetVerticalAngle(double angle);


  double GetNearPlaneDistance() const;
  void SetNearPlaneDistance(double angle);


  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 SetDrawFrustum(bool draw);
  vtkGetMacro(DrawFrustum, bool);
  vtkBooleanMacro(DrawFrustum, bool);

  void GetPolyData(vtkPolyData* pd);

  void UpdatePlacement();

  vtkGetObjectMacro(FrustumProperty, vtkProperty);


  vtkGetObjectMacro(EdgeHandleProperty, vtkProperty);
  vtkGetObjectMacro(SelectedEdgeHandleProperty, 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(InteractionState, InteractionStateType, InteractionStateType::Outside,
    InteractionStateType::TranslatingOriginOnAxis);


  virtual void SetRepresentationState(InteractionStateType);
  vtkGetMacro(RepresentationState, InteractionStateType);

  /*
   * Register internal Pickers within PickingManager
   */
  void RegisterPickers() override;

  void GetFrustum(vtkFrustum* frustum) const;

protected:
  vtkImplicitFrustumRepresentation();
  ~vtkImplicitFrustumRepresentation() override;

private:
  enum class FrustumFace
  {
    None = -1,
    Right = 0,
    Left = 1,
    Top = 2,
    Bottom = 3,
    Near = 4
  };

  struct SphereHandle
  {
    vtkNew<vtkSphereSource> Source;
    vtkNew<vtkPolyDataMapper> Mapper;
    vtkNew<vtkActor> Actor;

    SphereHandle();
  };

  struct EdgeHandle
  {
    vtkNew<vtkPolyData> PolyData;
    vtkNew<vtkTubeFilter> Tuber;
    vtkNew<vtkPolyDataMapper> Mapper;
    vtkNew<vtkActor> Actor;

    EdgeHandle();
  };

  struct EllipseHandle
  {
    vtkNew<vtkEllipseArcSource> Source;
    vtkNew<vtkTubeFilter> Tuber;
    vtkNew<vtkPolyDataMapper> Mapper;
    vtkNew<vtkActor> Actor;

    EllipseHandle();
  };

  vtkImplicitFrustumRepresentation(const vtkImplicitFrustumRepresentation&) = delete;
  void operator=(const vtkImplicitFrustumRepresentation&) = delete;

  // Helpers to get the frustum basis
  vtkVector3d GetForwardAxis();
  vtkVector3d GetUpAxis();
  vtkVector3d GetRightAxis();

  void HighlightOriginHandle(bool highlight);
  void HighlightFarPlaneVerticalHandle(bool highlight);
  void HighlightFarPlaneHorizontalHandle(bool highlight);
  void HighlightNearPlaneHandle(bool highlight);
  void HighlightRollHandle(bool highlight);
  void HighlightYawHandle(bool highlight);
  void HighlightPitchHandle(bool highlight);

  // Methods to manipulate the frustum
  void TranslateOrigin(const vtkVector3d& p1, const vtkVector3d& p2);
  void TranslateOriginOnAxis(const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustHorizontalAngle(const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustVerticalAngle(const vtkVector3d& p1, const vtkVector3d& p2);
  void AdjustNearPlaneDistance(
    const vtkVector2d& eventPosition, const vtkVector3d& p1, const vtkVector3d& p2);
  void Rotate(
    const vtkVector3d& prevPickPoint, const vtkVector3d& pickPoint, const vtkVector3d& axis);

  // Set the frustum transform according to the representation's orientation and position
  void UpdateFrustumTransform();

  // Re-compute the widget handles' sizes
  void SizeHandles();

  // Generate the frustum polydata, cropped by the bounding box
  void BuildFrustum();

  // The actual frustum we're manipulating
  vtkNew<vtkFrustum> Frustum;

  InteractionStateType RepresentationState = InteractionStateType::Outside;

  // Keep track of event positions
  vtkVector3d LastEventPosition = { 0., 0., 0. };

  bool AlongXAxis = false;
  bool AlongYAxis = false;
  bool AlongZAxis = false;

  double Length = 1;

  vtkVector3d Origin = { 0, 0, 0 };
  vtkNew<vtkTransform> OrientationTransform;

  vtkNew<vtkPolyData> FrustumPD;
  vtkNew<vtkPolyDataMapper> FrustumMapper;
  vtkNew<vtkActor> FrustumActor;
  bool DrawFrustum = true;

  std::array<EdgeHandle, 4> FarPlaneHandles;
  EdgeHandle NearPlaneEdgesHandle;
  SphereHandle NearPlaneCenterHandle;
  EllipseHandle RollHandle;
  EllipseHandle YawHandle;
  EllipseHandle PitchHandle;
  SphereHandle OriginHandle;

  FrustumFace ActiveEdgeHandle = FrustumFace::None;

  vtkNew<vtkCellPicker> Picker;
  vtkNew<vtkCellPicker> FrustumPicker;

  // Properties used to control the appearance of selected objects and the manipulator in general.
  vtkNew<vtkProperty> FrustumProperty;
  vtkNew<vtkProperty> EdgeHandleProperty;
  vtkNew<vtkProperty> SelectedEdgeHandleProperty;
  vtkNew<vtkProperty> OriginHandleProperty;
  vtkNew<vtkProperty> SelectedOriginHandleProperty;

  vtkNew<vtkBox> BoundingBox;
};

VTK_ABI_NAMESPACE_END
#endif