vtkCoordinateFrameRepresentation.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 vtkCoordinateFrameRepresentation_h
#define vtkCoordinateFrameRepresentation_h
 
#include "vtkInteractionWidgetsModule.h" // For export macro
#include "vtkNew.h"                      // For vtkNew command
#include "vtkWidgetRepresentation.h"
#include "vtkWrappingHints.h" // For VTK_MARSHALAUTO
 
VTK_ABI_NAMESPACE_BEGIN
class vtkActor;
class vtkBox;
class vtkCellPicker;
class vtkConeSource;
class vtkFeatureEdges;
class vtkGenericCell;
class vtkHardwarePicker;
class vtkLineSource;
class vtkPlane;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkProperty;
class vtkSphereSource;
class vtkTransform;
 
class VTKINTERACTIONWIDGETS_EXPORT VTK_MARSHALAUTO vtkCoordinateFrameRepresentation
  : public vtkWidgetRepresentation
{
public:
  static vtkCoordinateFrameRepresentation* New();
 
 
  vtkTypeMacro(vtkCoordinateFrameRepresentation, vtkWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  void SetOrigin(double x, double y, double z);
  void SetOrigin(double x[3]);
  vtkGetVector3Macro(Origin, double);
 
 
  void SetNormal(double x, double y, double z);
  void SetNormal(double n[3]);
  void SetNormalToCamera();
  vtkGetVector3Macro(XVectorNormal, double);
  vtkGetVector3Macro(YVectorNormal, double);
  vtkGetVector3Macro(ZVectorNormal, double);
 
 
  void SetDirection(double x, double y, double z);
  void SetDirection(double d[3]);
 
 
  void SetXAxisVector(const double v[3]);
  void SetXAxisVector(double x, double y, double z);
  void SetYAxisVector(const double v[3]);
  void SetYAxisVector(double x, double y, double z);
  void SetZAxisVector(const double v[3]);
  void SetZAxisVector(double x, double y, double z);
 
 
  virtual void SetLockNormalToCamera(vtkTypeBool);
  vtkGetMacro(LockNormalToCamera, vtkTypeBool);
  vtkBooleanMacro(LockNormalToCamera, 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; }
 
  void UpdatePlacement();
 
  void Reset();
 
  void ResetAxes();
 
 
  vtkGetObjectMacro(OriginProperty, vtkProperty);
  vtkGetObjectMacro(SelectedOriginProperty, vtkProperty);
 
 
  vtkGetObjectMacro(XVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedXVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(LockedXVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedLockedXVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(UnlockedXVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedUnlockedXVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(YVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedYVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(LockedYVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedLockedYVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(UnlockedYVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedUnlockedYVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(ZVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedZVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(LockedZVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedLockedZVectorProperty, vtkProperty);
 
 
  vtkGetObjectMacro(UnlockedZVectorProperty, vtkProperty);
  vtkGetObjectMacro(SelectedUnlockedZVectorProperty, vtkProperty);
 
 
  vtkGetMacro(PickCameraFocalInfo, bool);
  vtkSetMacro(PickCameraFocalInfo, bool);
  vtkBooleanMacro(PickCameraFocalInfo, bool);
 
  bool PickOrigin(int X, int Y, bool snapToMeshPoint = false);
 
  bool PickNormal(int X, int Y, bool snapToMeshPoint = false);
 
  bool PickDirectionPoint(int X, int Y, bool snapToMeshPoint = false);
 
  int GetLockedAxis() const;
  void SetLockedAxis(int axis);
 
 
  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() 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 InteractionStateType
  {
    Outside = 0,
    Moving,
    MovingOrigin,
    RotatingXVector,
    RotatingYVector,
    RotatingZVector,
    ModifyingLockerXVector,
    ModifyingLockerYVector,
    ModifyingLockerZVector
  };
 
 
  vtkSetClampMacro(InteractionState, int, Outside, ModifyingLockerZVector);
 
 
  virtual void SetRepresentationState(int);
  vtkGetMacro(RepresentationState, int);
 
 
  vtkSetClampMacro(LengthFactor, double, 0, 1);
  vtkGetMacro(LengthFactor, double);
 
protected:
  vtkCoordinateFrameRepresentation();
  ~vtkCoordinateFrameRepresentation() override;
 
  int RepresentationState = Outside;
 
  // Keep track of event positions
  double LastEventPosition[3];
 
  bool PickCameraFocalInfo = false;
 
  // Locking normal to camera
  vtkTypeBool LockNormalToCamera = false;
 
  int TranslationAxis = Axis::NONE;
 
  double Origin[3] = { 0, 0, 0 };
  double XVectorNormal[3] = { 1, 0, 0 };
  double YVectorNormal[3] = { 0, 1, 0 };
  double ZVectorNormal[3] = { 0, 0, 1 };
  vtkSetVector3Macro(XVectorNormal, double);
  vtkSetVector3Macro(YVectorNormal, double);
  vtkSetVector3Macro(ZVectorNormal, double);
 
  // The origin positioning handle
  vtkNew<vtkSphereSource> OriginSphereSource;
  vtkNew<vtkPolyDataMapper> OriginSphereMapper;
  vtkNew<vtkActor> OriginSphereActor;
  void HighlightOrigin(int highlight);
 
  // The XVector line source
  vtkNew<vtkLineSource> XVectorLineSource;
  vtkNew<vtkPolyDataMapper> XVectorLineMapper;
  vtkNew<vtkActor> XVectorLineActor;
  // The XVector cone source
  vtkNew<vtkConeSource> XVectorConeSource;
  vtkNew<vtkPolyDataMapper> XVectorConeMapper;
  vtkNew<vtkActor> XVectorConeActor;
  void HighlightXVector(int highlight);
  // The lock XVector cone source
  bool XVectorIsLocked = false;
  vtkNew<vtkConeSource> LockerXVectorConeSource;
  vtkNew<vtkPolyDataMapper> LockerXVectorConeMapper;
  vtkNew<vtkActor> LockerXVectorConeActor;
  void HighlightLockerXVector(int highlight);
 
  // The YVector line source
  vtkNew<vtkLineSource> YVectorLineSource;
  vtkNew<vtkPolyDataMapper> YVectorLineMapper;
  vtkNew<vtkActor> YVectorLineActor;
  // The YVector cone source
  vtkNew<vtkConeSource> YVectorConeSource;
  vtkNew<vtkPolyDataMapper> YVectorConeMapper;
  vtkNew<vtkActor> YVectorConeActor;
  void HighlightYVector(int highlight);
  // The lock YVector cone source
  bool YVectorIsLocked = false;
  vtkNew<vtkConeSource> LockerYVectorConeSource;
  vtkNew<vtkPolyDataMapper> LockerYVectorConeMapper;
  vtkNew<vtkActor> LockerYVectorConeActor;
  void HighlightLockerYVector(int highlight);
 
  // The Vector Z line source
  vtkNew<vtkLineSource> ZVectorLineSource;
  vtkNew<vtkPolyDataMapper> ZVectorLineMapper;
  vtkNew<vtkActor> ZVectorLineActor;
  // The Vector Z cone source
  vtkNew<vtkConeSource> ZVectorConeSource;
  vtkNew<vtkPolyDataMapper> ZVectorConeMapper;
  vtkNew<vtkActor> ZVectorConeActor;
  void HighlightZVector(int highlight);
  // The lock Vector Z cone source
  bool ZVectorIsLocked = false;
  vtkNew<vtkConeSource> LockerZVectorConeSource;
  vtkNew<vtkPolyDataMapper> LockerZVectorConeMapper;
  vtkNew<vtkActor> LockerZVectorConeActor;
  void HighlightLockerZVector(int highlight);
 
  // Do the picking
  vtkNew<vtkHardwarePicker> HardwarePicker; // Used for picking rendered props
  vtkNew<vtkCellPicker> CellPicker;         // Used for picking widget props
  // Compute Picker tolerance
  void ComputeAdaptivePickerTolerance();
 
  // Register internal Pickers within PickingManager
  void RegisterPickers() override;
 
  // Transform the normal (used for rotation)
  vtkNew<vtkTransform> Transform;
 
  // Methods to manipulate the plane
  void Rotate(double X, double Y, double* p1, double* p2, double* vpn);
  void ModifyingLocker(int axis);
  void TranslateOrigin(double* p1, double* p2);
  void SizeHandles();
 
  // Properties used to control the appearance of selected objects and
  // the manipulator in general.
  vtkNew<vtkProperty> OriginProperty;
  vtkNew<vtkProperty> SelectedOriginProperty;
  vtkNew<vtkProperty> XVectorProperty;
  vtkNew<vtkProperty> SelectedXVectorProperty;
  vtkNew<vtkProperty> LockedXVectorProperty;
  vtkNew<vtkProperty> SelectedLockedXVectorProperty;
  vtkNew<vtkProperty> UnlockedXVectorProperty;
  vtkNew<vtkProperty> SelectedUnlockedXVectorProperty;
  vtkNew<vtkProperty> YVectorProperty;
  vtkNew<vtkProperty> SelectedYVectorProperty;
  vtkNew<vtkProperty> LockedYVectorProperty;
  vtkNew<vtkProperty> SelectedLockedYVectorProperty;
  vtkNew<vtkProperty> UnlockedYVectorProperty;
  vtkNew<vtkProperty> SelectedUnlockedYVectorProperty;
  vtkNew<vtkProperty> ZVectorProperty;
  vtkNew<vtkProperty> SelectedZVectorProperty;
  vtkNew<vtkProperty> LockedZVectorProperty;
  vtkNew<vtkProperty> SelectedLockedZVectorProperty;
  vtkNew<vtkProperty> UnlockedZVectorProperty;
  vtkNew<vtkProperty> SelectedUnlockedZVectorProperty;
  virtual void CreateDefaultProperties();
 
  // Support GetBounds() method
  vtkNew<vtkBox> BoundingBox;
  vtkNew<vtkGenericCell> Cell;
 
  double LengthFactor = 0.04;
 
private:
  vtkCoordinateFrameRepresentation(const vtkCoordinateFrameRepresentation&) = delete;
  void operator=(const vtkCoordinateFrameRepresentation&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif