vtkAxisActor.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 vtkAxisActor_h
#define vtkAxisActor_h
 
#include "vtkActor.h"
#include "vtkNew.h"                       // For vtkNew
#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkSmartPointer.h"              // For vtkSmartPointer
#include "vtkWrappingHints.h"             // For VTK_MARSHALAUTO
 
#include <memory>
#include <string>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAxisFollower;
class vtkCamera;
class vtkCoordinate;
class vtkPoints;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkProp3DAxisFollower;
class vtkStringArray;
class vtkTextActor;
class vtkTextActorInterfaceInternal;
class vtkTextActor3D;
class vtkTextProperty;
class vtkVectorText;
 
class VTKRENDERINGANNOTATION_EXPORT VTK_MARSHALAUTO 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() VTK_SIZEHINT(6) override;
  void GetBounds(double bounds[6]);


  void SetLabelFormat(const char* format);
  vtkGetStringMacro(LabelFormat);


  vtkSetMacro(UseTextActor3D, bool);
  vtkGetMacro(UseTextActor3D, bool);


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


  void SetTitle(const std::string& title);
  vtkGetMacro(Title, std::string);


  void SetExponent(const std::string& exp);
  vtkGetMacro(Exponent, std::string);


  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() { this->SetTickLocation(VTK_TICKS_INSIDE); }
  void SetTickLocationToOutside() { this->SetTickLocation(VTK_TICKS_OUTSIDE); }
  void SetTickLocationToBoth() { this->SetTickLocation(VTK_TICKS_BOTH); }


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


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


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


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


  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);
  vtkTextProperty* GetTitleTextProperty();


  virtual void SetLabelTextProperty(vtkTextProperty* p);
  vtkTextProperty* GetLabelTextProperty();


  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, bool);
  vtkGetMacro(DrawGridlines, bool);
  vtkBooleanMacro(DrawGridlines, bool);


  vtkSetMacro(DrawGridlinesOnly, bool);
  vtkGetMacro(DrawGridlinesOnly, bool);
  vtkBooleanMacro(DrawGridlinesOnly, bool);
 
  vtkSetMacro(DrawGridlinesLocation, int);
  vtkGetMacro(DrawGridlinesLocation, int);


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


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


  vtkSetMacro(DrawGridpolys, bool);
  vtkGetMacro(DrawGridpolys, bool);
  vtkBooleanMacro(DrawGridpolys, bool);
 
  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() { this->SetAxisType(VTK_AXIS_TYPE_X); }
  void SetAxisTypeToY() { this->SetAxisType(VTK_AXIS_TYPE_Y); }
  void SetAxisTypeToZ() { 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() { this->SetAxisPosition(VTK_AXIS_POS_MINMIN); }
  void SetAxisPositionToMinMax() { this->SetAxisPosition(VTK_AXIS_POS_MINMAX); }
  void SetAxisPositionToMaxMax() { this->SetAxisPosition(VTK_AXIS_POS_MAXMAX); }
  void SetAxisPositionToMaxMin() { this->SetAxisPosition(VTK_AXIS_POS_MAXMIN); }


  virtual void SetCamera(vtkCamera*);
  vtkCamera* GetCamera();


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

  double ComputeTitleLength();


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


  double GetMajorStart(int axis);
  void SetMajorStart(int axis, double value);
  double GetDeltaMajor(int axis);
  void SetDeltaMajor(int axis, double value);


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

  vtkAxisFollower* GetTitleActor();

  vtkAxisFollower* GetExponentActor();


  vtkAxisFollower* GetLabelFollower(int index);
  int GetNumberOfLabelFollowers() { return this->GetNumberOfLabelsBuilt(); }


  vtkProp3DAxisFollower* GetTitleProp3D();


  vtkProp3DAxisFollower* GetLabelFollower3D(int index);
  int GetNumberOfLabelFollower3D() { return this->GetNumberOfLabelsBuilt(); }


  vtkProp3DAxisFollower* GetExponentProp3D();


  vtkGetMacro(NumberOfLabelsBuilt, int);


  vtkSetMacro(Use2DMode, bool);
  vtkGetMacro(Use2DMode, bool);


  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, bool);
  vtkGetMacro(AxisOnOrigin, bool);


  vtkSetMacro(ScreenSize, double);
  vtkGetMacro(ScreenSize, double);


  vtkSetMacro(LabelOffset, double);
  vtkGetMacro(LabelOffset, double);


  vtkSetMacro(ExponentOffset, double);
  vtkGetMacro(ExponentOffset, double);


  vtkSetVector2Macro(TitleOffset, double);
  vtkGetVector2Macro(TitleOffset, double);
 
protected:
  vtkAxisActor();
  ~vtkAxisActor() override;
 
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 BuildTitle(bool);

  void BuildExponent(bool force);
 
  void BuildExponent2D(vtkViewport* viewport, bool force);
 
  void BuildTitle2D(vtkViewport* viewport, bool);

  void Get2DPosition(
    vtkViewport* viewport, double multiplier, double scenepos[3], double displayPos[2]);
 
  void SetAxisPointsAndLines();
 
  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();
 
  vtkProperty* NewTitleProperty();
  vtkProperty* NewLabelProperty();
 
  bool BoundsDisplayCoordinateChanged(vtkViewport* viewport);


  vtkProp* GetTitleActorInternal();
  vtkProp* GetLabelActorInternal(int index);
  vtkProp* GetExponentActorInternal();

  void UpdateTitleActorProperty();
  void UpdateLabelActorProperty(int idx);
  void UpdateExponentActorProperty();

  void GetTranslucentProps(vtkPropCollection* collection);
 
  std::string Title;
  std::string Exponent;
  char* LabelFormat = nullptr;
  double Range[2] = { 0.0, 1.0 };
  double LastRange[2] = { -1.0, -1.0 };
  bool UseTextActor3D = false;
  int NumberOfLabelsBuilt = 0;
  bool MinorTicksVisible = true;
  bool LastMinorTicksVisible = true;

  int TickLocation = VTK_TICKS_INSIDE;

  int TitleAlignLocation = VTK_ALIGN_BOTTOM;

  int ExponentLocation = VTK_ALIGN_POINT2;
 
  bool DrawGridlines = false;
  bool DrawGridlinesOnly = false;
  bool LastDrawGridlines = false;
  int DrawGridlinesLocation = 0;     // 0: all | 1: closest | 2: furthest
  int LastDrawGridlinesLocation = 0; // 0: all | 1: closest | 2: furthest
  double GridlineXLength = 1.0;
  double GridlineYLength = 1.0;
  double GridlineZLength = 1.0;
 
  bool DrawInnerGridlines = false;
 
  bool DrawGridpolys = false;
 
  bool AxisVisibility = true;
  bool TickVisibility = true;
  bool LastTickVisibility = true;
  bool LabelVisibility = true;
  bool TitleVisibility = true;
  bool ExponentVisibility = false;
  bool LastMajorTickPointCorrection = false;
 
  bool Log = false;
  int AxisType = VTK_AXIS_TYPE_X;
  int AxisPosition = VTK_AXIS_POS_MINMIN;
 
  // coordinate system for axisAxtor, relative to world coordinates
  double AxisBaseForX[3] = { 1.0, 0.0, 0.0 };
  double AxisBaseForY[3] = { 0.0, 1.0, 0.0 };
  double AxisBaseForZ[3] = { 0.0, 0.0, 1.0 };
 
  vtkNew<vtkCoordinate> Point1Coordinate;
  vtkNew<vtkCoordinate> Point2Coordinate;
 
  double MajorTickSize = 1.0;
  double MinorTickSize = 0.5;
 
  // For each axis (for the inner gridline generation)
  double MajorStart[3] = { 0.0, 0.0, 0.0 };
  double DeltaMajor[3] = { 1.0, 1.0, 1.0 };
 
  // For the ticks, w.r.t to the set range
  double MajorRangeStart = 0.0;
  double MinorRangeStart = 0.0;

  double DeltaRangeMinor = 1.0;

  double DeltaRangeMajor = 1.0;
 
  int LastAxisPosition = -1;
  int LastTickLocation = -1;
 
  vtkNew<vtkPoints> MinorTickPts;
  vtkNew<vtkPoints> MajorTickPts;
  vtkNew<vtkPoints> GridlinePts;
  vtkNew<vtkPoints> InnerGridlinePts;
  vtkNew<vtkPoints> GridpolyPts;
 
  std::unique_ptr<vtkTextActorInterfaceInternal> TitleProp;
  vtkSmartPointer<vtkTextProperty> TitleTextProperty;


  std::unique_ptr<vtkTextActorInterfaceInternal> ExponentProp;
 
  std::vector<std::shared_ptr<vtkTextActorInterfaceInternal>> LabelProps;
  vtkSmartPointer<vtkTextProperty> LabelTextProperty;
 
  // Main line axis
  vtkNew<vtkPolyData> AxisLines;
  vtkNew<vtkActor> AxisLinesActor;
 
  // Ticks of the axis
  vtkNew<vtkPolyData> AxisMajorTicks, AxisMinorTicks;
  vtkNew<vtkActor> AxisMajorTicksActor, AxisMinorTicksActor;
 
  vtkNew<vtkPolyData> Gridlines;
  vtkNew<vtkActor> GridlinesActor;
  vtkNew<vtkPolyData> InnerGridlines;
  vtkNew<vtkActor> InnerGridlinesActor;
  vtkNew<vtkPolyData> Gridpolys;
  vtkNew<vtkActor> GridpolysActor;
 
  vtkSmartPointer<vtkCamera> Camera;
  vtkTimeStamp BuildTime;
  vtkTimeStamp BuildTickPointsTime;
  vtkTimeStamp BoundsTime;
  vtkTimeStamp LabelBuildTime;
  vtkTimeStamp TitleTextTime;
  vtkTimeStamp ExponentTextTime;
 
  bool AxisOnOrigin = false;
 
  bool AxisHasZeroLength = false;

  bool Use2DMode = false;

  double VerticalOffsetXTitle2D = -40;

  double HorizontalOffsetYTitle2D = -50;

  int SaveTitlePosition = 0;

  double TitleConstantPosition[2] = { 0.0, 0.0 };

  bool NeedBuild2D = false;
 
  double LastMinDisplayCoordinate[3] = { 0.0, 0.0, 0.0 };
  double LastMaxDisplayCoordinate[3] = { 0.0, 0.0, 0.0 };
  double TickVector[3] = { 0.0, 0.0, 0.0 };

  double ScreenSize = 10.0;


  double LabelOffset = 30.0;
  double TitleOffset[2] = { 20.0, 20.0 };
  double ExponentOffset = 20.0;
};
 
VTK_ABI_NAMESPACE_END
#endif