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 "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkActor.h"

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