vtkCubeAxesActor.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCubeAxesActor.h
  Language:  C++
 
Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserve
  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.
=========================================================================*/
#ifndef vtkCubeAxesActor_h
#define vtkCubeAxesActor_h
 
#include "vtkActor.h"
#include "vtkRenderingAnnotationModule.h" // For export macro
 
class vtkAxisActor;
class vtkCamera;
class vtkTextProperty;
class vtkStringArray;
 
class VTKRENDERINGANNOTATION_EXPORT vtkCubeAxesActor : public vtkActor
{
public:
  vtkTypeMacro(vtkCubeAxesActor, vtkActor);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkCubeAxesActor* New();
 
 
  int RenderOpaqueGeometry(vtkViewport*) override;
  virtual int RenderTranslucentGeometry(vtkViewport*);
  int RenderTranslucentPolygonalGeometry(vtkViewport*) override;
  int RenderOverlay(vtkViewport*) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;
 
 
  vtkSetMacro(RebuildAxes, bool);
  vtkGetMacro(RebuildAxes, bool);
 
 
  vtkSetVector6Macro(Bounds, double);
  using Superclass::GetBounds;
  double* GetBounds() VTK_SIZEHINT(6) override { return this->Bounds; }
 
 
  virtual void GetRenderedBounds(double rBounds[6]);
  virtual double* GetRenderedBounds();
 
 
  vtkSetVector2Macro(XAxisRange, double);
  vtkSetVector2Macro(YAxisRange, double);
  vtkSetVector2Macro(ZAxisRange, double);
  vtkGetVector2Macro(XAxisRange, double);
  vtkGetVector2Macro(YAxisRange, double);
 
  vtkStringArray* GetAxisLabels(int axis);
  void SetAxisLabels(int axis, vtkStringArray* value);
 
  vtkGetVector2Macro(ZAxisRange, double);
 
 
  void SetScreenSize(double screenSize);
  vtkGetMacro(ScreenSize, double);
 
 
  void SetLabelOffset(double offset);
  vtkGetMacro(LabelOffset, double);
 
 
  void SetTitleOffset(double offset);
  vtkGetMacro(TitleOffset, double);
 
 
  virtual void SetCamera(vtkCamera*);
  vtkGetObjectMacro(Camera, vtkCamera);
 
  enum FlyMode
  {
    VTK_FLY_OUTER_EDGES = 0,
    VTK_FLY_CLOSEST_TRIAD = 1,
    VTK_FLY_FURTHEST_TRIAD = 2,
    VTK_FLY_STATIC_TRIAD = 3,
    VTK_FLY_STATIC_EDGES = 4
  };
 
 
  vtkSetClampMacro(FlyMode, int, VTK_FLY_OUTER_EDGES, VTK_FLY_STATIC_EDGES);
  vtkGetMacro(FlyMode, int);
  void SetFlyModeToOuterEdges() { this->SetFlyMode(VTK_FLY_OUTER_EDGES); }
  void SetFlyModeToClosestTriad() { this->SetFlyMode(VTK_FLY_CLOSEST_TRIAD); }
  void SetFlyModeToFurthestTriad() { this->SetFlyMode(VTK_FLY_FURTHEST_TRIAD); }
  void SetFlyModeToStaticTriad() { this->SetFlyMode(VTK_FLY_STATIC_TRIAD); }
  void SetFlyModeToStaticEdges() { this->SetFlyMode(VTK_FLY_STATIC_EDGES); }
 
 
  vtkSetStringMacro(XTitle);
  vtkGetStringMacro(XTitle);
  vtkSetStringMacro(XUnits);
  vtkGetStringMacro(XUnits);
  vtkSetStringMacro(YTitle);
  vtkGetStringMacro(YTitle);
  vtkSetStringMacro(YUnits);
  vtkGetStringMacro(YUnits);
  vtkSetStringMacro(ZTitle);
  vtkGetStringMacro(ZTitle);
  vtkSetStringMacro(ZUnits);
  vtkGetStringMacro(ZUnits);
 
 
  vtkSetStringMacro(XLabelFormat);
  vtkGetStringMacro(XLabelFormat);
  vtkSetStringMacro(YLabelFormat);
  vtkGetStringMacro(YLabelFormat);
  vtkSetStringMacro(ZLabelFormat);
  vtkGetStringMacro(ZLabelFormat);
 
 
  vtkSetClampMacro(Inertia, int, 1, VTK_INT_MAX);
  vtkGetMacro(Inertia, int);
 
 
  vtkSetMacro(CornerOffset, double);
  vtkGetMacro(CornerOffset, double);
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
 
  vtkSetMacro(EnableDistanceLOD, int);
  vtkGetMacro(EnableDistanceLOD, int);
 
 
  vtkSetClampMacro(DistanceLODThreshold, double, 0.0, 1.0);
  vtkGetMacro(DistanceLODThreshold, double);
 
 
  vtkSetMacro(EnableViewAngleLOD, int);
  vtkGetMacro(EnableViewAngleLOD, int);
 
 
  vtkSetClampMacro(ViewAngleLODThreshold, double, 0., 1.);
  vtkGetMacro(ViewAngleLODThreshold, double);
 
 
  vtkSetMacro(XAxisVisibility, vtkTypeBool);
  vtkGetMacro(XAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(XAxisVisibility, vtkTypeBool);
  vtkSetMacro(YAxisVisibility, vtkTypeBool);
  vtkGetMacro(YAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(YAxisVisibility, vtkTypeBool);
  vtkSetMacro(ZAxisVisibility, vtkTypeBool);
  vtkGetMacro(ZAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(ZAxisVisibility, vtkTypeBool);
 
 
  vtkSetMacro(XAxisLabelVisibility, vtkTypeBool);
  vtkGetMacro(XAxisLabelVisibility, vtkTypeBool);
  vtkBooleanMacro(XAxisLabelVisibility, vtkTypeBool);
 
  vtkSetMacro(YAxisLabelVisibility, vtkTypeBool);
  vtkGetMacro(YAxisLabelVisibility, vtkTypeBool);
  vtkBooleanMacro(YAxisLabelVisibility, vtkTypeBool);
 
  vtkSetMacro(ZAxisLabelVisibility, vtkTypeBool);
  vtkGetMacro(ZAxisLabelVisibility, vtkTypeBool);
  vtkBooleanMacro(ZAxisLabelVisibility, vtkTypeBool);
 
 
  vtkSetMacro(XAxisTickVisibility, vtkTypeBool);
  vtkGetMacro(XAxisTickVisibility, vtkTypeBool);
  vtkBooleanMacro(XAxisTickVisibility, vtkTypeBool);
 
  vtkSetMacro(YAxisTickVisibility, vtkTypeBool);
  vtkGetMacro(YAxisTickVisibility, vtkTypeBool);
  vtkBooleanMacro(YAxisTickVisibility, vtkTypeBool);
 
  vtkSetMacro(ZAxisTickVisibility, vtkTypeBool);
  vtkGetMacro(ZAxisTickVisibility, vtkTypeBool);
  vtkBooleanMacro(ZAxisTickVisibility, vtkTypeBool);
 
 
  vtkSetMacro(XAxisMinorTickVisibility, vtkTypeBool);
  vtkGetMacro(XAxisMinorTickVisibility, vtkTypeBool);
  vtkBooleanMacro(XAxisMinorTickVisibility, vtkTypeBool);
 
  vtkSetMacro(YAxisMinorTickVisibility, vtkTypeBool);
  vtkGetMacro(YAxisMinorTickVisibility, vtkTypeBool);
  vtkBooleanMacro(YAxisMinorTickVisibility, vtkTypeBool);
 
  vtkSetMacro(ZAxisMinorTickVisibility, vtkTypeBool);
  vtkGetMacro(ZAxisMinorTickVisibility, vtkTypeBool);
  vtkBooleanMacro(ZAxisMinorTickVisibility, vtkTypeBool);
 
  vtkSetMacro(DrawXGridlines, vtkTypeBool);
  vtkGetMacro(DrawXGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawXGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawYGridlines, vtkTypeBool);
  vtkGetMacro(DrawYGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawYGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawZGridlines, vtkTypeBool);
  vtkGetMacro(DrawZGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawZGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawXInnerGridlines, vtkTypeBool);
  vtkGetMacro(DrawXInnerGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawXInnerGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawYInnerGridlines, vtkTypeBool);
  vtkGetMacro(DrawYInnerGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawYInnerGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawZInnerGridlines, vtkTypeBool);
  vtkGetMacro(DrawZInnerGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawZInnerGridlines, vtkTypeBool);
 
  vtkSetMacro(DrawXGridpolys, vtkTypeBool);
  vtkGetMacro(DrawXGridpolys, vtkTypeBool);
  vtkBooleanMacro(DrawXGridpolys, vtkTypeBool);
 
  vtkSetMacro(DrawYGridpolys, vtkTypeBool);
  vtkGetMacro(DrawYGridpolys, vtkTypeBool);
  vtkBooleanMacro(DrawYGridpolys, vtkTypeBool);
 
  vtkSetMacro(DrawZGridpolys, vtkTypeBool);
  vtkGetMacro(DrawZGridpolys, vtkTypeBool);
  vtkBooleanMacro(DrawZGridpolys, vtkTypeBool);
 
  vtkTextProperty* GetTitleTextProperty(int);
 
  vtkTextProperty* GetLabelTextProperty(int);
 
 
  void SetXAxesLinesProperty(vtkProperty*);
  vtkProperty* GetXAxesLinesProperty();
  void SetYAxesLinesProperty(vtkProperty*);
  vtkProperty* GetYAxesLinesProperty();
  void SetZAxesLinesProperty(vtkProperty*);
  vtkProperty* GetZAxesLinesProperty();
 
 
  void SetXAxesGridlinesProperty(vtkProperty*);
  vtkProperty* GetXAxesGridlinesProperty();
  void SetYAxesGridlinesProperty(vtkProperty*);
  vtkProperty* GetYAxesGridlinesProperty();
  void SetZAxesGridlinesProperty(vtkProperty*);
  vtkProperty* GetZAxesGridlinesProperty();
 
 
  void SetXAxesInnerGridlinesProperty(vtkProperty*);
  vtkProperty* GetXAxesInnerGridlinesProperty();
  void SetYAxesInnerGridlinesProperty(vtkProperty*);
  vtkProperty* GetYAxesInnerGridlinesProperty();
  void SetZAxesInnerGridlinesProperty(vtkProperty*);
  vtkProperty* GetZAxesInnerGridlinesProperty();
 
 
  void SetXAxesGridpolysProperty(vtkProperty*);
  vtkProperty* GetXAxesGridpolysProperty();
  void SetYAxesGridpolysProperty(vtkProperty*);
  vtkProperty* GetYAxesGridpolysProperty();
  void SetZAxesGridpolysProperty(vtkProperty*);
  vtkProperty* GetZAxesGridpolysProperty();
 
  enum TickLocation
  {
    VTK_TICKS_INSIDE = 0,
    VTK_TICKS_OUTSIDE = 1,
    VTK_TICKS_BOTH = 2
  };
 
 
  vtkSetClampMacro(TickLocation, int, VTK_TICKS_INSIDE, VTK_TICKS_BOTH);
  vtkGetMacro(TickLocation, int);
 
  void SetTickLocationToInside(void) { this->SetTickLocation(VTK_TICKS_INSIDE); }
  void SetTickLocationToOutside(void) { this->SetTickLocation(VTK_TICKS_OUTSIDE); }
  void SetTickLocationToBoth(void) { this->SetTickLocation(VTK_TICKS_BOTH); }
 
  void SetLabelScaling(bool, int, int, int);
 
 
  void SetUseTextActor3D(int val);
  int GetUseTextActor3D();
 
 
  void SetUse2DMode(int val);
  int GetUse2DMode();
 
  void SetSaveTitlePosition(int val);
 
 
  vtkSetVector6Macro(OrientedBounds, double);
  vtkGetVector6Macro(OrientedBounds, double);
 
 
  vtkSetMacro(UseOrientedBounds, int);
  vtkGetMacro(UseOrientedBounds, int);
 
 
  vtkSetVector3Macro(AxisBaseForX, double);
  vtkGetVector3Macro(AxisBaseForX, double);
 
 
  vtkSetVector3Macro(AxisBaseForY, double);
  vtkGetVector3Macro(AxisBaseForY, double);
 
 
  vtkSetVector3Macro(AxisBaseForZ, double);
  vtkGetVector3Macro(AxisBaseForZ, double);
 
 
  vtkSetVector3Macro(AxisOrigin, double);
  vtkGetVector3Macro(AxisOrigin, double);
 
 
  vtkSetMacro(UseAxisOrigin, int);
  vtkGetMacro(UseAxisOrigin, int);
 
 
  vtkSetMacro(GridLineLocation, int);
  vtkGetMacro(GridLineLocation, int);
 
 
  vtkSetMacro(StickyAxes, vtkTypeBool);
  vtkGetMacro(StickyAxes, vtkTypeBool);
  vtkBooleanMacro(StickyAxes, vtkTypeBool);
 
 
  vtkSetMacro(CenterStickyAxes, vtkTypeBool);
  vtkGetMacro(CenterStickyAxes, vtkTypeBool);
  vtkBooleanMacro(CenterStickyAxes, vtkTypeBool);
 
  enum GridVisibility
  {
    VTK_GRID_LINES_ALL = 0,
    VTK_GRID_LINES_CLOSEST = 1,
    VTK_GRID_LINES_FURTHEST = 2
  };
 
protected:
  vtkCubeAxesActor();
  ~vtkCubeAxesActor() override;
 
  void ComputeStickyAxesBoundingSphere(
    vtkViewport* viewport, const double bounds[6], double sphereCenter[3], double& sphereRadius);
 
  void GetViewportLimitedBounds(vtkViewport* viewport, double bounds[6]);
 
  static void GetBoundsPointBits(
    unsigned int pointIndex, unsigned int& xBit, unsigned int& yBit, unsigned int& zBit);
 
  static void GetBoundsPoint(unsigned int pointIndex, const double bounds[6], double point[3]);
 
  int LabelExponent(double min, double max);
 
  int Digits(double min, double max);
 
  double MaxOf(double, double);
  double MaxOf(double, double, double, double);
 
  double FFix(double);
  double FSign(double, double);
  int FRound(double fnt);
  int GetNumTicks(double range, double fxt);
 
  void UpdateLabels(vtkAxisActor** axis, int index);
 
  vtkCamera* Camera;
 
  int FlyMode;
 
  // Expose internally closest axis index computation
  int FindClosestAxisIndex(double pts[8][3]);
 
  // Expose internally furthest axis index computation
  int FindFurtherstAxisIndex(double pts[8][3]);
 
  // Expose internally the boundary edge fly mode axis index computation
  void FindBoundaryEdge(int& indexOfAxisX, int& indexOfAxisY, int& indexOfAxisZ, double pts[8][3]);
 
  void UpdateGridLineVisibility(int axisIndex);
 
  // VTK_ALL_GRID_LINES      0
  // VTK_CLOSEST_GRID_LINES  1
  // VTK_FURTHEST_GRID_LINES 2
  int GridLineLocation;
 
  vtkTypeBool StickyAxes;
 
  vtkTypeBool CenterStickyAxes;
 
  int EnableDistanceLOD;
 
  double DistanceLODThreshold;
 
  int EnableViewAngleLOD;
 
  double ViewAngleLODThreshold;
 
  enum NumberOfAlignedAxis
  {
    NUMBER_OF_ALIGNED_AXIS = 4
  };
 
 
  vtkAxisActor* XAxes[NUMBER_OF_ALIGNED_AXIS];
  vtkAxisActor* YAxes[NUMBER_OF_ALIGNED_AXIS];
  vtkAxisActor* ZAxes[NUMBER_OF_ALIGNED_AXIS];
 
  bool RebuildAxes;
 
  char* XTitle;
  char* XUnits;
  char* YTitle;
  char* YUnits;
  char* ZTitle;
  char* ZUnits;
 
  char* ActualXLabel;
  char* ActualYLabel;
  char* ActualZLabel;
 
  int TickLocation;
 
  vtkTypeBool XAxisVisibility;
  vtkTypeBool YAxisVisibility;
  vtkTypeBool ZAxisVisibility;
 
  vtkTypeBool XAxisTickVisibility;
  vtkTypeBool YAxisTickVisibility;
  vtkTypeBool ZAxisTickVisibility;
 
  vtkTypeBool XAxisMinorTickVisibility;
  vtkTypeBool YAxisMinorTickVisibility;
  vtkTypeBool ZAxisMinorTickVisibility;
 
  vtkTypeBool XAxisLabelVisibility;
  vtkTypeBool YAxisLabelVisibility;
  vtkTypeBool ZAxisLabelVisibility;
 
  vtkTypeBool DrawXGridlines;
  vtkTypeBool DrawYGridlines;
  vtkTypeBool DrawZGridlines;
 
  vtkTypeBool DrawXInnerGridlines;
  vtkTypeBool DrawYInnerGridlines;
  vtkTypeBool DrawZInnerGridlines;
 
  vtkTypeBool DrawXGridpolys;
  vtkTypeBool DrawYGridpolys;
  vtkTypeBool DrawZGridpolys;
 
  char* XLabelFormat;
  char* YLabelFormat;
  char* ZLabelFormat;
 
  double CornerOffset;
 
  int Inertia;
 
  int RenderCount;
 
  int InertiaLocs[3];
 
  int RenderSomething;
 
  vtkTextProperty* TitleTextProperty[3];
  vtkStringArray* AxisLabels[3];
 
  vtkTextProperty* LabelTextProperty[3];
 
  vtkProperty* XAxesLinesProperty;
  vtkProperty* YAxesLinesProperty;
  vtkProperty* ZAxesLinesProperty;
  vtkProperty* XAxesGridlinesProperty;
  vtkProperty* YAxesGridlinesProperty;
  vtkProperty* ZAxesGridlinesProperty;
  vtkProperty* XAxesInnerGridlinesProperty;
  vtkProperty* YAxesInnerGridlinesProperty;
  vtkProperty* ZAxesInnerGridlinesProperty;
  vtkProperty* XAxesGridpolysProperty;
  vtkProperty* YAxesGridpolysProperty;
  vtkProperty* ZAxesGridpolysProperty;
 
  double RenderedBounds[6];
  double OrientedBounds[6];
  int UseOrientedBounds;
 
  double AxisOrigin[3];
  int UseAxisOrigin;
 
  double AxisBaseForX[3];
  double AxisBaseForY[3];
  double AxisBaseForZ[3];
 
private:
  vtkCubeAxesActor(const vtkCubeAxesActor&) = delete;
  void operator=(const vtkCubeAxesActor&) = delete;
 
  vtkSetStringMacro(ActualXLabel);
  vtkSetStringMacro(ActualYLabel);
  vtkSetStringMacro(ActualZLabel);
 
  vtkTimeStamp BuildTime;
  int LastUseOrientedBounds;
  int LastXPow;
  int LastYPow;
  int LastZPow;
 
  int UserXPow;
  int UserYPow;
  int UserZPow;
 
  bool AutoLabelScaling;
 
  int LastXAxisDigits;
  int LastYAxisDigits;
  int LastZAxisDigits;
 
  double LastXRange[2];
  double LastYRange[2];
  double LastZRange[2];
  double LastBounds[6];
 
  int LastFlyMode;
 
  int RenderAxesX[NUMBER_OF_ALIGNED_AXIS];
  int RenderAxesY[NUMBER_OF_ALIGNED_AXIS];
  int RenderAxesZ[NUMBER_OF_ALIGNED_AXIS];
 
  int NumberOfAxesX;
  int NumberOfAxesY;
  int NumberOfAxesZ;
 
  bool MustAdjustXValue;
  bool MustAdjustYValue;
  bool MustAdjustZValue;
 
  bool ForceXLabelReset;
  bool ForceYLabelReset;
  bool ForceZLabelReset;
 
  double XAxisRange[2];
  double YAxisRange[2];
  double ZAxisRange[2];
 
  double LabelScale;
  double TitleScale;
 
  double ScreenSize;
  double LabelOffset;
  double TitleOffset;
 
 
  double MajorStart[3];
  double DeltaMajor[3];
 
  int RenderGeometry(bool& initialRender, vtkViewport* viewport, bool checkAxisVisibility,
    int (vtkAxisActor::*renderMethod)(vtkViewport*));
 
  void TransformBounds(vtkViewport* viewport, const double bounds[6], double pts[8][3]);
  void AdjustAxes(double bounds[6], double xCoords[NUMBER_OF_ALIGNED_AXIS][6],
    double yCoords[NUMBER_OF_ALIGNED_AXIS][6], double zCoords[NUMBER_OF_ALIGNED_AXIS][6],
    double xRange[2], double yRange[2], double zRange[2]);
 
  bool ComputeTickSize(double bounds[6]);
  void AdjustValues(const double xRange[2], const double yRange[2], const double zRange[2]);
  void AdjustRange(const double bounds[6]);
  void BuildAxes(vtkViewport*);
  void DetermineRenderAxes(vtkViewport*);
  void SetNonDependentAttributes(void);
  void BuildLabels(vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS]);
  void AdjustTicksComputeRange(
    vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS], double rangeMin, double rangeMax);
 
  void AutoScale(vtkViewport* viewport);
  void AutoScale(vtkViewport* viewport, vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS]);
  double AutoScale(vtkViewport* viewport, double screenSize, double position[3]);
};
 
#endif