/*========================================================================= Program: Visualization Toolkit Module: vtkCameraOrientationRepresentation.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. =========================================================================*/ /** * @class vtkCameraOrientationRepresentation * @brief A 3D representation for vtkCameraOrientationWidget. * * Hover over the representation and drag with LMB to orbit around the view. * Clicking on one of the axis labels will snap to that view. * Click again on the same axis to switch to the opposite view of that same axis. * * The representation anchors itself to a corner of the renderer's * viewport. See AnchorType. * * @sa * vtkCameraOrientationWidget * */ #ifndef vtkCameraOrientationRepresentation_h #define vtkCameraOrientationRepresentation_h #include "vtkInteractionWidgetsModule.h" // needed for export macro #include "vtkWidgetRepresentation.h" class vtkActor; class vtkDiskSource; class vtkDoubleArray; class vtkEllipticalButtonSource; class vtkImageData; class vtkPoints; class vtkPolyData; class vtkPropCollection; class vtkProperty; class vtkPropPicker; class vtkTextProperty; class vtkTexture; class vtkTubeFilter; class VTKINTERACTIONWIDGETS_EXPORT vtkCameraOrientationRepresentation : public vtkWidgetRepresentation { public: static vtkCameraOrientationRepresentation* New(); vtkTypeMacro(vtkCameraOrientationRepresentation, vtkWidgetRepresentation); void PrintSelf(ostream& os, vtkIndent indent) override; enum class InteractionStateType : int { Outside = 0, // corresponds to vtkCameraOrientationWidget::Inactive Hovering, // corresponds to vtkCameraOrientationWidget::Hot Rotating // corresponds to vtkCameraOrientationWidget::Active }; /** * The interaction state may be set from a widget (e.g., vtkCameraOrientationWidget) or * other object. This call updates the representation to match the interaction state. */ void ApplyInteractionState(const InteractionStateType& state); void ApplyInteractionState(const int& state); /** * Convenient method to get InteractionState as enum. * This method clamps the interaction state to possible values. * Hence, it does not raise any exceptions. */ InteractionStateType GetInteractionStateAsEnum() noexcept { // clamp to 0-2 this->InteractionState = this->InteractionState < 0 ? 0 : (this->InteractionState > 2 ? 2 : this->InteractionState); // convert return static_cast(this->InteractionState); } ///@{ /** * Get/Set the widget size in display coordinates. */ vtkSetVector2Macro(Size, int); vtkGetVector2Macro(Size, int); ///@} ///@{ /** * Get/Set the widget padding in display coordinates. */ vtkSetVector2Macro(Padding, int); vtkGetVector2Macro(Padding, int); ///@} enum class AnchorType : int { LowerLeft = 0, UpperLeft, LowerRight, UpperRight }; ///@{ /** * Get/Set the widget anchor type */ AnchorType GetAnchorPosition() { return this->AnchorPosition; } void AnchorToLowerLeft() { this->AnchorPosition = AnchorType::LowerLeft; this->Modified(); } void AnchorToUpperLeft() { this->AnchorPosition = AnchorType::UpperLeft; this->Modified(); } void AnchorToLowerRight() { this->AnchorPosition = AnchorType::LowerRight; this->Modified(); } void AnchorToUpperRight() { this->AnchorPosition = AnchorType::UpperRight; this->Modified(); } ///@} ///@{ /** * Set the total length of the axes in 3 dimensions. * This is basis of normalization. Default value: 1. */ vtkSetMacro(TotalLength, double); vtkGetMacro(TotalLength, double); ///@} ///@{ /** * Set the normalized (0-1) diameter of the Handle. * Default value: 0.4 */ vtkSetMacro(NormalizedHandleDia, double); vtkGetMacro(NormalizedHandleDia, double); ///@} ///@{ /** * Orientation properties. (read only) */ vtkGetMacro(Azimuth, double); vtkGetVector3Macro(Back, double); vtkGetMacro(Elevation, double); vtkGetVector3Macro(Up, double); ///@} ///@{ /** * Set shaft's resolution. */ vtkSetClampMacro(ShaftResolution, int, 3, 256); vtkGetMacro(ShaftResolution, int); ///@} ///@{ /** * Set Handle's circumferential resolution. */ vtkSetClampMacro(HandleCircumferentialResolution, int, 3, 256); vtkGetMacro(HandleCircumferentialResolution, int); ///@} ///@{ /** * Set container's circumferential resolution. */ vtkSetClampMacro(ContainerCircumferentialResolution, int, 3, 256); vtkGetMacro(ContainerCircumferentialResolution, int); ///@} ///@{ /** * Set container's radial resolution. */ vtkSetClampMacro(ContainerRadialResolution, int, 3, 256); vtkGetMacro(ContainerRadialResolution, int); ///@} ///@{ /** * Get picked axis, direction */ vtkGetMacro(PickedAxis, int); vtkGetMacro(PickedDir, int); ///@} ///@{ /** * Get the '+' axis label properties. */ vtkTextProperty* GetXPlusLabelProperty(); vtkTextProperty* GetYPlusLabelProperty(); vtkTextProperty* GetZPlusLabelProperty(); ///@} ///@{ /** * Get the '-' axis label properties. */ vtkTextProperty* GetXMinusLabelProperty(); vtkTextProperty* GetYMinusLabelProperty(); vtkTextProperty* GetZMinusLabelProperty(); ///@} /** * Get the container property. */ vtkProperty* GetContainerProperty(); ///@{ /** * Show container to indicate mouse presence. */ void SetContainerVisibility(bool state); vtkBooleanMacro(ContainerVisibility, bool); bool GetContainerVisibility(); ///@} /** * For some exporters and other other operations we must be * able to collect all the actors or volumes. These methods * are used in that process. */ void GetActors(vtkPropCollection*) override; /** * Retrieve internal transform of this widget representation. */ vtkTransform* GetTransform(); ///@{ /** * These are methods that satisfy vtkWidgetRepresentation's API. */ void PlaceWidget(double*) override{}; // this representation is an overlay. Doesn't need this. void BuildRepresentation() override; void StartWidgetInteraction(double eventPos[2]) override; void WidgetInteraction(double newEventPos[2]) override; void EndWidgetInteraction(double newEventPos[2]) override; int ComputeInteractionState(int X, int Y, int modify = 0) override; double* GetBounds() VTK_SIZEHINT(6) override; ///@} ///@{ /** * Methods supporting, and required by, the rendering process. */ void ReleaseGraphicsResources(vtkWindow*) override; int RenderOpaqueGeometry(vtkViewport*) override; int RenderTranslucentPolygonalGeometry(vtkViewport*) override; vtkTypeBool HasTranslucentPolygonalGeometry() override; ///@} /** * Shallow copy of an axes actor. Overloads the virtual vtkProp method. */ void ShallowCopy(vtkProp* prop) override; /** * Is a grabber button picked. */ bool IsAnyHandleSelected() { return (this->PickedAxis != -1) && (this->PickedDir != -1); } protected: vtkCameraOrientationRepresentation(); ~vtkCameraOrientationRepresentation() override; virtual void CreateDefaultGeometry(); virtual void CreateDefaultProperties(); virtual void PositionHandles(); virtual void HighlightHandle(); virtual void Rotate(double newEventPos[2]); void RegisterPickers() override; void FinalizeHandlePicks(); // description of source shapes. vtkNew ContainerSource; vtkNew HandleSources[3][2]; vtkNew ShaftGlyphs; // geometries of handles and shafts. (position, color info) vtkNew Skeleton; vtkNew Points; // used to store handle positions, also used by shafts // defaults are slight variations of r, y, g vtkNew AxesColors; // props vtkNew Container; vtkNew Handles[3][2]; vtkNew Shafts; // font-sz, font-type, frame color of the labels. vtkNew AxisVectorTextProperties[3][2]; vtkNew LabelImages[3][2]; vtkNew LabelTextures[3][2]; vtkNew HandlePicker; // Store rotation of gizmo. vtkNew Transform; // Positioning of the representation within a parent renderer. AnchorType AnchorPosition = AnchorType::UpperRight; int Padding[2] = { 10, 10 }; // In display coords. int Size[2] = { 120, 120 }; // In display coords. // Geometrical, textual, interaction description of the representation. const char* AxisLabelsText[3][2] = { { "X", "-X" }, { "Y", "-Y" }, { "Z", "-Z" } }; double Azimuth = 0.; double Back[3] = { 0., 0., -1. }; double Bounds[6] = {}; double Elevation = 0.; double MotionFactor = 1.; double NormalizedHandleDia = 0.4; double TotalLength = 1.; double Up[3] = { 0., 1., 0. }; int ContainerCircumferentialResolution = 32; int ContainerRadialResolution = 1; int HandleCircumferentialResolution = 32; int ShaftResolution = 10; // Picking information. int PickedAxis = -1; int LastPickedAx = -1; int PickedDir = -1; int LastPickedDir = -1; // Event tracking double LastEventPosition[3] = {}; private: vtkCameraOrientationRepresentation(const vtkCameraOrientationRepresentation&) = delete; void operator=(const vtkCameraOrientationRepresentation&) = delete; }; #endif