vtkAxisActor.h

Go to the documentation of this file.

/*=========================================================================
Program:   Visualization Toolkit
Module:    vtkAxisActor.h
Language:  C++

Copyright (c) 1993-2000 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
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 vtkAxisActor_h
#define vtkAxisActor_h

#include "vtkActor.h"
#include "vtkRenderingAnnotationModule.h" // For export macro

class vtkAxisFollower;
class vtkCamera;
class vtkCoordinate;
class vtkFollower;
class vtkPoints;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkProp3DAxisFollower;
class vtkProperty2D;
class vtkStringArray;
class vtkTextActor;
class vtkTextActor3D;
class vtkTextProperty;
class vtkVectorText;

class VTKRENDERINGANNOTATION_EXPORT vtkAxisActor : public vtkActor
{
public:
  vtkTypeMacro(vtkAxisActor, vtkActor);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkAxisActor* New();


  virtual vtkCoordinate* GetPoint1Coordinate();
  virtual void SetPoint1(double x[3]) { this->SetPoint1(x[0], x[1], x[2]); }
  virtual void SetPoint1(double x, double y, double z);
  virtual double* GetPoint1();


  virtual vtkCoordinate* GetPoint2Coordinate();
  virtual void SetPoint2(double x[3]) { this->SetPoint2(x[0], x[1], x[2]); }
  virtual void SetPoint2(double x, double y, double z);
  virtual double* GetPoint2();


  vtkSetVector2Macro(Range, double);
  vtkGetVectorMacro(Range, double, 2);


  void SetBounds(const double bounds[6]);
  void SetBounds(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);
  double* GetBounds(void) VTK_SIZEHINT(6) override;
  void GetBounds(double bounds[6]);


  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);


  vtkSetMacro(UseTextActor3D, int);
  vtkGetMacro(UseTextActor3D, int);


  vtkSetMacro(MinorTicksVisible, vtkTypeBool);
  vtkGetMacro(MinorTicksVisible, vtkTypeBool);
  vtkBooleanMacro(MinorTicksVisible, vtkTypeBool);


  void SetTitle(const char* t);
  vtkGetStringMacro(Title);


  void SetExponent(const char* t);
  vtkGetStringMacro(Exponent);


  vtkSetMacro(MajorTickSize, double);
  vtkGetMacro(MajorTickSize, double);


  vtkSetMacro(MinorTickSize, double);
  vtkGetMacro(MinorTickSize, double);

  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); };


  vtkSetMacro(AxisVisibility, vtkTypeBool);
  vtkGetMacro(AxisVisibility, vtkTypeBool);
  vtkBooleanMacro(AxisVisibility, vtkTypeBool);


  vtkSetMacro(TickVisibility, vtkTypeBool);
  vtkGetMacro(TickVisibility, vtkTypeBool);
  vtkBooleanMacro(TickVisibility, vtkTypeBool);


  vtkSetMacro(LabelVisibility, vtkTypeBool);
  vtkGetMacro(LabelVisibility, vtkTypeBool);
  vtkBooleanMacro(LabelVisibility, vtkTypeBool);


  vtkSetMacro(TitleVisibility, vtkTypeBool);
  vtkGetMacro(TitleVisibility, vtkTypeBool);
  vtkBooleanMacro(TitleVisibility, vtkTypeBool);


  vtkSetMacro(ExponentVisibility, bool);
  vtkGetMacro(ExponentVisibility, bool);
  vtkBooleanMacro(ExponentVisibility, bool);


  vtkSetMacro(LastMajorTickPointCorrection, bool);
  vtkGetMacro(LastMajorTickPointCorrection, bool);
  vtkBooleanMacro(LastMajorTickPointCorrection, bool);

  enum AlignLocation
  {
    VTK_ALIGN_TOP = 0,
    VTK_ALIGN_BOTTOM = 1,
    VTK_ALIGN_POINT1 = 2,
    VTK_ALIGN_POINT2 = 3
  };


  virtual void SetTitleAlignLocation(int location);
  vtkGetMacro(TitleAlignLocation, int);


  virtual void SetExponentLocation(int location);
  vtkGetMacro(ExponentLocation, int);


  virtual void SetTitleTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(TitleTextProperty, vtkTextProperty);


  virtual void SetLabelTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(LabelTextProperty, vtkTextProperty);


  void SetAxisLinesProperty(vtkProperty*);
  vtkProperty* GetAxisLinesProperty();


  void SetAxisMainLineProperty(vtkProperty*);
  vtkProperty* GetAxisMainLineProperty();


  void SetAxisMajorTicksProperty(vtkProperty*);
  vtkProperty* GetAxisMajorTicksProperty();


  void SetAxisMinorTicksProperty(vtkProperty*);
  vtkProperty* GetAxisMinorTicksProperty();


  void SetGridlinesProperty(vtkProperty*);
  vtkProperty* GetGridlinesProperty();


  void SetInnerGridlinesProperty(vtkProperty*);
  vtkProperty* GetInnerGridlinesProperty();


  void SetGridpolysProperty(vtkProperty*);
  vtkProperty* GetGridpolysProperty();


  vtkSetMacro(DrawGridlines, vtkTypeBool);
  vtkGetMacro(DrawGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawGridlines, vtkTypeBool);


  vtkSetMacro(DrawGridlinesOnly, vtkTypeBool);
  vtkGetMacro(DrawGridlinesOnly, vtkTypeBool);
  vtkBooleanMacro(DrawGridlinesOnly, vtkTypeBool);

  vtkSetMacro(DrawGridlinesLocation, int);
  vtkGetMacro(DrawGridlinesLocation, int);


  vtkSetMacro(DrawInnerGridlines, vtkTypeBool);
  vtkGetMacro(DrawInnerGridlines, vtkTypeBool);
  vtkBooleanMacro(DrawInnerGridlines, vtkTypeBool);


  vtkSetMacro(GridlineXLength, double);
  vtkGetMacro(GridlineXLength, double);
  vtkSetMacro(GridlineYLength, double);
  vtkGetMacro(GridlineYLength, double);
  vtkSetMacro(GridlineZLength, double);
  vtkGetMacro(GridlineZLength, double);


  vtkSetMacro(DrawGridpolys, vtkTypeBool);
  vtkGetMacro(DrawGridpolys, vtkTypeBool);
  vtkBooleanMacro(DrawGridpolys, vtkTypeBool);

  enum AxisType
  {
    VTK_AXIS_TYPE_X = 0,
    VTK_AXIS_TYPE_Y = 1,
    VTK_AXIS_TYPE_Z = 2
  };


  vtkSetClampMacro(AxisType, int, VTK_AXIS_TYPE_X, VTK_AXIS_TYPE_Z);
  vtkGetMacro(AxisType, int);
  void SetAxisTypeToX(void) { this->SetAxisType(VTK_AXIS_TYPE_X); };
  void SetAxisTypeToY(void) { this->SetAxisType(VTK_AXIS_TYPE_Y); };
  void SetAxisTypeToZ(void) { this->SetAxisType(VTK_AXIS_TYPE_Z); };

  enum AxisPosition
  {
    VTK_AXIS_POS_MINMIN = 0,
    VTK_AXIS_POS_MINMAX = 1,
    VTK_AXIS_POS_MAXMAX = 2,
    VTK_AXIS_POS_MAXMIN = 3
  };


  vtkSetMacro(Log, bool);
  vtkGetMacro(Log, bool);
  vtkBooleanMacro(Log, bool);


  vtkSetClampMacro(AxisPosition, int, VTK_AXIS_POS_MINMIN, VTK_AXIS_POS_MAXMIN);
  vtkGetMacro(AxisPosition, int);

  void SetAxisPositionToMinMin(void) { this->SetAxisPosition(VTK_AXIS_POS_MINMIN); };
  void SetAxisPositionToMinMax(void) { this->SetAxisPosition(VTK_AXIS_POS_MINMAX); };
  void SetAxisPositionToMaxMax(void) { this->SetAxisPosition(VTK_AXIS_POS_MAXMAX); };
  void SetAxisPositionToMaxMin(void) { this->SetAxisPosition(VTK_AXIS_POS_MAXMIN); };


  virtual void SetCamera(vtkCamera*);
  vtkGetObjectMacro(Camera, vtkCamera);


  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  virtual int RenderTranslucentGeometry(vtkViewport* viewport);
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
  int RenderOverlay(vtkViewport* viewport) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;

  void ReleaseGraphicsResources(vtkWindow*) override;

  double ComputeMaxLabelLength(const double[3]);
  double ComputeTitleLength(const double[3]);

  void SetLabelScale(const double scale);
  void SetLabelScale(int labelIndex, const double scale);
  void SetTitleScale(const double scale);


  vtkSetMacro(MinorStart, double);
  vtkGetMacro(MinorStart, double);
  double GetMajorStart(int axis);
  void SetMajorStart(int axis, double value);
  // vtkSetMacro(MajorStart, double);
  // vtkGetMacro(MajorStart, double);
  vtkSetMacro(DeltaMinor, double);
  vtkGetMacro(DeltaMinor, double);
  double GetDeltaMajor(int axis);
  void SetDeltaMajor(int axis, double value);
  // vtkSetMacro(DeltaMajor, double);
  // vtkGetMacro(DeltaMajor, double);


  vtkSetMacro(MinorRangeStart, double);
  vtkGetMacro(MinorRangeStart, double);
  vtkSetMacro(MajorRangeStart, double);
  vtkGetMacro(MajorRangeStart, double);
  vtkSetMacro(DeltaRangeMinor, double);
  vtkGetMacro(DeltaRangeMinor, double);
  vtkSetMacro(DeltaRangeMajor, double);
  vtkGetMacro(DeltaRangeMajor, double);

  void SetLabels(vtkStringArray* labels);

  void BuildAxis(vtkViewport* viewport, bool);


  vtkGetObjectMacro(TitleActor, vtkAxisFollower);


  vtkGetObjectMacro(ExponentActor, vtkAxisFollower);

  inline vtkAxisFollower** GetLabelActors() { return this->LabelActors; }


  vtkGetObjectMacro(TitleProp3D, vtkProp3DAxisFollower);

  inline vtkProp3DAxisFollower** GetLabelProps3D() { return this->LabelProps3D; }


  vtkGetObjectMacro(ExponentProp3D, vtkProp3DAxisFollower);


  vtkGetMacro(NumberOfLabelsBuilt, int);


  vtkSetMacro(CalculateTitleOffset, vtkTypeBool);
  vtkGetMacro(CalculateTitleOffset, vtkTypeBool);
  vtkBooleanMacro(CalculateTitleOffset, vtkTypeBool);


  vtkSetMacro(CalculateLabelOffset, vtkTypeBool);
  vtkGetMacro(CalculateLabelOffset, vtkTypeBool);
  vtkBooleanMacro(CalculateLabelOffset, vtkTypeBool);


  vtkSetMacro(Use2DMode, int);
  vtkGetMacro(Use2DMode, int);


  vtkSetMacro(VerticalOffsetXTitle2D, double);
  vtkGetMacro(VerticalOffsetXTitle2D, double);


  vtkSetMacro(HorizontalOffsetYTitle2D, double);
  vtkGetMacro(HorizontalOffsetYTitle2D, double);


  vtkSetMacro(SaveTitlePosition, int);
  vtkGetMacro(SaveTitlePosition, int);


  vtkSetVector3Macro(AxisBaseForX, double);
  vtkGetVector3Macro(AxisBaseForX, double);


  vtkSetVector3Macro(AxisBaseForY, double);
  vtkGetVector3Macro(AxisBaseForY, double);


  vtkSetVector3Macro(AxisBaseForZ, double);
  vtkGetVector3Macro(AxisBaseForZ, double);


  vtkSetMacro(AxisOnOrigin, int);
  vtkGetMacro(AxisOnOrigin, int);


  vtkSetMacro(LabelOffset, double);
  vtkGetMacro(LabelOffset, double);
  vtkSetMacro(TitleOffset, double);
  vtkGetMacro(TitleOffset, double);
  vtkSetMacro(ExponentOffset, double);
  vtkGetMacro(ExponentOffset, double);
  vtkSetMacro(ScreenSize, double);
  vtkGetMacro(ScreenSize, double);

protected:
  vtkAxisActor();
  ~vtkAxisActor() override;

  char* Title;
  char* Exponent;
  double Range[2];
  double LastRange[2];
  char* LabelFormat;
  int UseTextActor3D;
  int NumberOfLabelsBuilt;
  vtkTypeBool MinorTicksVisible;
  int LastMinorTicksVisible;

  int TickLocation;

  int TitleAlignLocation;

  int ExponentLocation;

  vtkTypeBool DrawGridlines;
  vtkTypeBool DrawGridlinesOnly;
  int LastDrawGridlines;
  int DrawGridlinesLocation;     // 0: all | 1: closest | 2: farest
  int LastDrawGridlinesLocation; // 0: all | 1: closest | 2: farest
  double GridlineXLength;
  double GridlineYLength;
  double GridlineZLength;

  vtkTypeBool DrawInnerGridlines;
  int LastDrawInnerGridlines;

  vtkTypeBool DrawGridpolys;
  int LastDrawGridpolys;

  vtkTypeBool AxisVisibility;
  vtkTypeBool TickVisibility;
  int LastTickVisibility;
  vtkTypeBool LabelVisibility;
  vtkTypeBool TitleVisibility;
  bool ExponentVisibility;
  bool LastMajorTickPointCorrection;

  bool Log;
  int AxisType;
  int AxisPosition;

  // coordinate system for axisAxtor, relative to world coordinates
  double AxisBaseForX[3];
  double AxisBaseForY[3];
  double AxisBaseForZ[3];

private:
  vtkAxisActor(const vtkAxisActor&) = delete;
  void operator=(const vtkAxisActor&) = delete;

  void TransformBounds(vtkViewport*, double bnds[6]);

  void BuildLabels(vtkViewport*, bool);
  void BuildLabels2D(vtkViewport*, bool);
  void SetLabelPositions(vtkViewport*, bool);
  void SetLabelPositions2D(vtkViewport*, bool);

  void RotateActor2DFromAxisProjection(vtkTextActor* pActor2D);

  void InitTitle();

  void InitExponent();

  void BuildTitle(bool);

  void BuildExponent(bool force);

  void BuildExponent2D(vtkViewport* viewport, bool force);

  void BuildTitle2D(vtkViewport* viewport, bool);

  void SetAxisPointsAndLines(void);

  bool BuildTickPoints(double p1[3], double p2[3], bool force);

  // Build major ticks for linear scale.
  void BuildMajorTicks(double p1[3], double p2[3], double localCoordSys[3][3]);

  // Build major ticks for logarithmic scale.
  void BuildMajorTicksLog(double p1[3], double p2[3], double localCoordSys[3][3]);

  // Build minor ticks for linear scale.
  void BuildMinorTicks(double p1[3], double p2[3], double localCoordSys[3][3]);

  // Build minor ticks for logarithmic scale enabled
  void BuildMinorTicksLog(double p1[3], double p2[3], double localCoordSys[3][3]);

  void BuildAxisGridLines(double p1[3], double p2[3], double localCoordSys[3][3]);

  bool TickVisibilityChanged(void);
  vtkProperty* NewTitleProperty();
  vtkProperty2D* NewTitleProperty2D();
  vtkProperty* NewLabelProperty();

  bool BoundsDisplayCoordinateChanged(vtkViewport* viewport);

  vtkCoordinate* Point1Coordinate;
  vtkCoordinate* Point2Coordinate;

  double MajorTickSize;
  double MinorTickSize;

  // For each axis (for the inner gridline generation)
  double MajorStart[3];
  double DeltaMajor[3];
  double MinorStart;
  double DeltaMinor;

  // For the ticks, w.r.t to the set range
  double MajorRangeStart;
  double MinorRangeStart;

  double DeltaRangeMinor;

  double DeltaRangeMajor;

  int LastAxisPosition;
  int LastAxisType;
  int LastTickLocation;
  double LastLabelStart;

  vtkPoints* MinorTickPts;
  vtkPoints* MajorTickPts;
  vtkPoints* GridlinePts;
  vtkPoints* InnerGridlinePts;
  vtkPoints* GridpolyPts;

  vtkVectorText* TitleVector;
  vtkPolyDataMapper* TitleMapper;
  vtkAxisFollower* TitleActor;
  vtkTextActor* TitleActor2D;
  vtkProp3DAxisFollower* TitleProp3D;
  vtkTextActor3D* TitleActor3D;
  vtkTextProperty* TitleTextProperty;


  vtkVectorText* ExponentVector;
  vtkPolyDataMapper* ExponentMapper;
  vtkAxisFollower* ExponentActor;
  vtkTextActor* ExponentActor2D;
  vtkProp3DAxisFollower* ExponentProp3D;
  vtkTextActor3D* ExponentActor3D;

  vtkVectorText** LabelVectors;
  vtkPolyDataMapper** LabelMappers;
  vtkAxisFollower** LabelActors;
  vtkProp3DAxisFollower** LabelProps3D;
  vtkTextActor** LabelActors2D;
  vtkTextActor3D** LabelActors3D;
  vtkTextProperty* LabelTextProperty;

  // Main line axis
  vtkPolyData* AxisLines;
  vtkPolyDataMapper* AxisLinesMapper;
  vtkActor* AxisLinesActor;

  // Ticks of the axis
  vtkPolyData *AxisMajorTicks, *AxisMinorTicks;
  vtkPolyDataMapper *AxisMajorTicksMapper, *AxisMinorTicksMapper;
  vtkActor *AxisMajorTicksActor, *AxisMinorTicksActor;

  vtkPolyData* Gridlines;
  vtkPolyDataMapper* GridlinesMapper;
  vtkActor* GridlinesActor;
  vtkPolyData* InnerGridlines;
  vtkPolyDataMapper* InnerGridlinesMapper;
  vtkActor* InnerGridlinesActor;
  vtkPolyData* Gridpolys;
  vtkPolyDataMapper* GridpolysMapper;
  vtkActor* GridpolysActor;

  vtkCamera* Camera;
  vtkTimeStamp BuildTime;
  vtkTimeStamp BuildTickPointsTime;
  vtkTimeStamp BoundsTime;
  vtkTimeStamp LabelBuildTime;
  vtkTimeStamp TitleTextTime;
  vtkTimeStamp ExponentTextTime;

  int AxisOnOrigin;

  int AxisHasZeroLength;

  vtkTypeBool CalculateTitleOffset;
  vtkTypeBool CalculateLabelOffset;

  int Use2DMode;

  double VerticalOffsetXTitle2D;

  double HorizontalOffsetYTitle2D;

  int SaveTitlePosition;

  double TitleConstantPosition[2];

  bool NeedBuild2D;

  double LastMinDisplayCoordinate[3];
  double LastMaxDisplayCoordinate[3];
  double TickVector[3];


  double ScreenSize;
  double LabelOffset;
  double TitleOffset;
  double ExponentOffset;
};

#endif