vtkAxisActor2D.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 vtkAxisActor2D_h
#define vtkAxisActor2D_h
 
#include "vtkActor2D.h"
#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkWrappingHints.h"             // For VTK_MARSHALAUTO
 
#include "vtkNew.h"          // for vtkNew
#include "vtkSmartPointer.h" // for vtkSmartPointer
 
VTK_ABI_NAMESPACE_BEGIN
class vtkPoints;
class vtkPolyData;
class vtkPolyDataMapper2D;
class vtkTextMapper;
class vtkTextProperty;
 
class VTKRENDERINGANNOTATION_EXPORT VTK_MARSHALAUTO vtkAxisActor2D : public vtkActor2D
{
public:
  vtkTypeMacro(vtkAxisActor2D, vtkActor2D);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  static vtkAxisActor2D* New();


  virtual vtkCoordinate* GetPoint1Coordinate() { return this->GetPositionCoordinate(); }
  virtual void SetPoint1(double x[2]) { this->SetPosition(x); }
  virtual void SetPoint1(double x, double y) { this->SetPosition(x, y); }
  virtual double* GetPoint1() { return this->GetPosition(); }


  virtual vtkCoordinate* GetPoint2Coordinate() { return this->GetPosition2Coordinate(); }
  virtual void SetPoint2(double x[2]) { this->SetPosition2(x); }
  virtual void SetPoint2(double x, double y) { this->SetPosition2(x, y); }
  virtual double* GetPoint2() { return this->GetPosition2(); }


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


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


  vtkSetClampMacro(RulerDistance, double, 0, VTK_FLOAT_MAX);
  vtkGetMacro(RulerDistance, double);


  vtkSetMacro(NumberOfLabels, int);
  vtkGetMacro(NumberOfLabels, int);


  vtkSetClampMacro(Precision, int, 0, VTK_INT_MAX);
  vtkGetMacro(Precision, int);


  vtkSetClampMacro(Notation, int, 0, 2);
  vtkGetMacro(Notation, int);


  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);


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


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


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


  virtual double* GetAdjustedRange()
  {
    this->UpdateAdjustedRange();
    return this->AdjustedRange;
  }
  virtual void GetAdjustedRange(double& _arg1, double& _arg2)
  {
    this->UpdateAdjustedRange();
    _arg1 = this->AdjustedRange[0];
    _arg2 = this->AdjustedRange[1];
  }
  virtual void GetAdjustedRange(double _arg[2]) { this->GetAdjustedRange(_arg[0], _arg[1]); }

  virtual int GetAdjustedNumberOfLabels()
  {
    this->UpdateAdjustedRange();
    return this->AdjustedNumberOfLabels;
  }

  vtkPoints* GetTickPositions();


  vtkSetStringMacro(Title);
  vtkGetStringMacro(Title);


  virtual void SetTitleTextProperty(vtkTextProperty*);
  virtual vtkTextProperty* GetTitleTextProperty();


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


  vtkSetClampMacro(TickLength, int, 0, 100);
  vtkGetMacro(TickLength, int);


  vtkSetClampMacro(NumberOfMinorTicks, int, 0, 20);
  vtkGetMacro(NumberOfMinorTicks, int);


  vtkSetClampMacro(MinorTickLength, int, 0, 100);
  vtkGetMacro(MinorTickLength, int);


  vtkSetClampMacro(TickOffset, int, 0, 100);
  vtkGetMacro(TickOffset, int);


  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(TitlePosition, double);
  vtkGetMacro(TitlePosition, double);


  vtkSetClampMacro(FontFactor, double, 0.1, 2.0);
  vtkGetMacro(FontFactor, double);


  vtkSetClampMacro(LabelFactor, double, 0.1, 2.0);
  vtkGetMacro(LabelFactor, double);

  virtual std::vector<vtkSmartPointer<vtkTextMapper>> GetLabelMappers()
  {
    return this->LabelMappers;
  }

  int UpdateGeometryAndRenderOpaqueGeometry(vtkViewport* viewport, bool render);


  int RenderOverlay(vtkViewport* viewport) override;
  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport*) override { return 0; }

  vtkTypeBool HasTranslucentPolygonalGeometry() override;

  void ReleaseGraphicsResources(vtkWindow*) override;

  static void ComputeRange(
    double inRange[2], double outRange[2], int inNumTicks, int& outNumTicks, double& interval);


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


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

  void ShallowCopy(vtkProp* prop) override;
 
protected:
  vtkAxisActor2D();
  ~vtkAxisActor2D() override;
 
  char* Title;
  char* LabelFormat;
  double Range[2] = { 0., 1. };
  double TitlePosition = 0.5;
  vtkTypeBool RulerMode = 0;
  double RulerDistance = 1.;
  int NumberOfLabels = 5;
  vtkTypeBool AdjustLabels = 1;
  double FontFactor = 1.;
  double LabelFactor = 0.75;
  int TickLength = 5;
  int MinorTickLength = 3;
  int TickOffset = 2;
  int NumberOfMinorTicks = 0;
 
  double AdjustedRange[2];
  int AdjustedNumberOfLabels = 5;
  int NumberOfLabelsBuilt = 0;
  vtkNew<vtkPoints> TicksStartPos;
 
  int Notation = 0;
  int Precision = 2;
 
  vtkTypeBool AxisVisibility = 1;
  vtkTypeBool TickVisibility = 1;
  vtkTypeBool LabelVisibility = 1;
  vtkTypeBool TitleVisibility = 1;
 
  int LastPosition[2] = { 0, 0 };
  int LastPosition2[2] = { 0, 0 };
 
  int LastSize[2] = { 0, 0 };
  int LastMaxLabelSize[2] = { 0, 0 };
 
  int SizeFontRelativeToAxis = 0;
  vtkTypeBool UseFontSizeFromProperty = 0;
 
  virtual void BuildAxis(vtkViewport* viewport);
  static double ComputeStringOffset(double width, double height, double theta);

  static void SetOffsetPosition(double xTick[3], double theta, int stringWidth, int stringHeight,
    int offset, vtkActor2D* textActor);

  void ShiftPosition(double start[3], double textAngle, int stringWidth, int stringHeight,
    int offset, int finalPos[2]);
 
  virtual void UpdateAdjustedRange();
 
  vtkTextMapper* TitleMapper;
  vtkActor2D* TitleActor;
 
  vtkNew<vtkPolyData> Axis;
  vtkNew<vtkPolyDataMapper2D> AxisMapper;
  vtkNew<vtkActor2D> AxisActor;
 
  vtkTimeStamp AdjustedRangeBuildTime;
  vtkTimeStamp BuildTime;
 
private:
  vtkAxisActor2D(const vtkAxisActor2D&) = delete;
  void operator=(const vtkAxisActor2D&) = delete;

  bool PositionsChangedOrViewportResized(vtkViewport* viewport);

  bool ShouldRebuild(vtkViewport* viewport);

  void UpdateTicksValueAndPosition(vtkViewport* viewport);

  void BuildTicksPolyData(vtkViewport* viewport);

  void BuildLabels(vtkViewport* viewport);

  void BuildTitle(vtkViewport* viewport);

  double GetAxisAngle(vtkViewport* viewport);

  void UpdateCachedInformations(vtkViewport* viewport);

  double GetViewportRulerDistance(vtkViewport* viewport);

  double GetViewportAxisLength(vtkViewport* viewport);

  void SetTitleFontSize(vtkViewport* viewport, int box[2]);
 
  // tick position in axis, normalized on axis length.
  std::vector<double> NormalizedTickPositions;
  std::vector<double> TickValues;
 
  bool SnapLabelsToGrid = false;
 
  bool SkipFirstTick = false;
 
  std::vector<vtkSmartPointer<vtkTextMapper>> LabelMappers;
  std::vector<vtkSmartPointer<vtkActor2D>> LabelActors;
 
  vtkSmartPointer<vtkTextProperty> TitleTextProperty;
  vtkSmartPointer<vtkTextProperty> LabelTextProperty;
};
 
VTK_ABI_NAMESPACE_END
#endif