vtkPolarAxesActor.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 vtkPolarAxesActor_h
#define vtkPolarAxesActor_h
 
#include "vtkActor.h"
#include "vtkAxisActor.h"                 // access to enum values
#include "vtkNew.h"                       // used for vtkNew
#include "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkSmartPointer.h"              // used for vtkSmartPointer
#include "vtkWrappingHints.h"             // For VTK_MARSHALAUTO
#include <list>                           // To process exponent list as reference
#include <string>                         // used for ivar
#include <vector>                         // for ivar
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCamera;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkPropCollection;
class vtkProperty;
class vtkStringArray;
class vtkTextProperty;
 
class VTKRENDERINGANNOTATION_EXPORT VTK_MARSHALAUTO vtkPolarAxesActor : public vtkActor
{
public:
  vtkTypeMacro(vtkPolarAxesActor, vtkActor);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  static vtkPolarAxesActor* New();


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

  void GetRendered3DProps(vtkPropCollection*, bool translucent);


  virtual void SetPole(double[3]);
  virtual void SetPole(double, double, double);
  vtkGetVector3Macro(Pole, double);


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


  vtkSetClampMacro(RequestedNumberOfRadialAxes, vtkIdType, 0, VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES);
  vtkGetMacro(RequestedNumberOfRadialAxes, vtkIdType);


  vtkSetClampMacro(RequestedNumberOfPolarAxes, vtkIdType, 0, VTK_MAXIMUM_NUMBER_OF_POLAR_AXES);
  vtkGetMacro(RequestedNumberOfPolarAxes, vtkIdType);


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


  virtual void SetMinimumRadius(double);
  vtkGetMacro(MinimumRadius, double);


  virtual void SetMaximumRadius(double);
  vtkGetMacro(MaximumRadius, double);


  virtual void SetMinimumAngle(double);
  vtkGetMacro(MinimumAngle, double);


  virtual void SetMaximumAngle(double);
  vtkGetMacro(MaximumAngle, double);


  vtkSetClampMacro(SmallestVisiblePolarAngle, double, 0., 5.);
  vtkGetMacro(SmallestVisiblePolarAngle, double);


  vtkSetClampMacro(TickLocation, int, vtkAxisActor::VTK_TICKS_INSIDE, vtkAxisActor::VTK_TICKS_BOTH);
  vtkGetMacro(TickLocation, int);


  vtkSetMacro(RadialUnits, bool);
  vtkGetMacro(RadialUnits, bool);


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


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


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


  vtkGetMacro(PolarLabelOffset, double);
  vtkSetMacro(PolarLabelOffset, double);


  vtkGetMacro(PolarExponentOffset, double);
  vtkSetMacro(PolarExponentOffset, double);


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


  vtkGetMacro(PolarAxisTitle, std::string);
  vtkSetMacro(PolarAxisTitle, std::string);


  void SetPolarLabelFormat(const char* format);
  vtkGetStringMacro(PolarLabelFormat);
 
  enum ExponentLocation
  {
    VTK_EXPONENT_BOTTOM = 0,
    VTK_EXPONENT_EXTERN = 1,
    VTK_EXPONENT_LABELS = 2
  };


  vtkSetClampMacro(ExponentLocation, int, VTK_EXPONENT_BOTTOM, VTK_EXPONENT_LABELS);
  vtkGetMacro(ExponentLocation, int);


  void SetRadialAngleFormat(const char* format);
  vtkGetStringMacro(RadialAngleFormat);

  void ReleaseGraphicsResources(vtkWindow*) override;


  vtkSetMacro(EnableDistanceLOD, bool);
  vtkGetMacro(EnableDistanceLOD, bool);


  vtkSetClampMacro(DistanceLODThreshold, double, 0.0, 1.0);
  vtkGetMacro(DistanceLODThreshold, double);


  vtkSetMacro(EnableViewAngleLOD, bool);
  vtkGetMacro(EnableViewAngleLOD, bool);


  vtkSetClampMacro(ViewAngleLODThreshold, double, 0., 1.);
  vtkGetMacro(ViewAngleLODThreshold, double);


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


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


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


  vtkSetMacro(PolarTitleVisibility, bool);
  vtkGetMacro(PolarTitleVisibility, bool);
  vtkBooleanMacro(PolarTitleVisibility, bool);
 
  enum TitleLocation
  {
    VTK_TITLE_BOTTOM = 0,
    VTK_TITLE_EXTERN = 1
  };


  vtkSetClampMacro(RadialAxisTitleLocation, int, VTK_TITLE_BOTTOM, VTK_TITLE_EXTERN);
  vtkGetMacro(RadialAxisTitleLocation, int);


  vtkSetClampMacro(PolarAxisTitleLocation, int, VTK_TITLE_BOTTOM, VTK_TITLE_EXTERN);
  vtkGetMacro(PolarAxisTitleLocation, int);


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


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


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


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


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


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


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


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


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


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


  vtkSetMacro(ArcMajorTickSize, double);
  vtkGetMacro(ArcMajorTickSize, double);


  vtkSetMacro(PolarAxisMajorTickSize, double);
  vtkGetMacro(PolarAxisMajorTickSize, double);


  vtkSetMacro(LastRadialAxisMajorTickSize, double);
  vtkGetMacro(LastRadialAxisMajorTickSize, double);


  vtkSetMacro(PolarAxisTickRatioSize, double);
  vtkGetMacro(PolarAxisTickRatioSize, double);


  vtkSetMacro(LastAxisTickRatioSize, double);
  vtkGetMacro(LastAxisTickRatioSize, double);


  vtkSetMacro(ArcTickRatioSize, double);
  vtkGetMacro(ArcTickRatioSize, double);


  vtkSetMacro(TickRatioRadiusSize, double);
  vtkGetMacro(TickRatioRadiusSize, double);


  vtkSetMacro(PolarAxisMajorTickThickness, double);
  vtkGetMacro(PolarAxisMajorTickThickness, double);


  vtkSetMacro(LastRadialAxisMajorTickThickness, double);
  vtkGetMacro(LastRadialAxisMajorTickThickness, double);


  vtkSetMacro(ArcMajorTickThickness, double);
  vtkGetMacro(ArcMajorTickThickness, double);


  vtkSetMacro(PolarAxisTickRatioThickness, double);
  vtkGetMacro(PolarAxisTickRatioThickness, double);


  vtkSetMacro(LastAxisTickRatioThickness, double);
  vtkGetMacro(LastAxisTickRatioThickness, double);


  vtkSetMacro(ArcTickRatioThickness, double);
  vtkGetMacro(ArcTickRatioThickness, double);


  vtkSetMacro(DeltaRangeMajor, double);
  vtkGetMacro(DeltaRangeMajor, double);


  vtkSetMacro(DeltaRangeMinor, double);
  vtkGetMacro(DeltaRangeMinor, double);


  vtkSetMacro(RequestedDeltaRangePolarAxes, double);
  vtkGetMacro(RequestedDeltaRangePolarAxes, double);


  vtkSetMacro(DeltaAngleMajor, double);
  vtkGetMacro(DeltaAngleMajor, double);


  vtkSetMacro(DeltaAngleMinor, double);
  vtkGetMacro(DeltaAngleMinor, double);


  vtkSetMacro(RequestedDeltaAngleRadialAxes, double);
  vtkGetMacro(RequestedDeltaAngleRadialAxes, double);
 
  //------------------------------------------------


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


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


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


  void SetUse2DMode(bool enable);
  bool GetUse2DMode();

  void SetUseTextActor3D(bool enable);


  virtual void SetPolarAxisTitleTextProperty(vtkTextProperty* p);
  vtkTextProperty* GetPolarAxisTitleTextProperty();


  virtual void SetPolarAxisLabelTextProperty(vtkTextProperty* p);
  vtkTextProperty* GetPolarAxisLabelTextProperty();


  virtual void SetLastRadialAxisTextProperty(vtkTextProperty* p);
  vtkTextProperty* GetLastRadialAxisTextProperty();


  virtual void SetSecondaryRadialAxesTextProperty(vtkTextProperty* p);
  vtkTextProperty* GetSecondaryRadialAxesTextProperty();


  virtual void SetPolarAxisProperty(vtkProperty*);
  vtkProperty* GetPolarAxisProperty();


  virtual void SetLastRadialAxisProperty(vtkProperty* p);
  vtkProperty* GetLastRadialAxisProperty();


  virtual void SetSecondaryRadialAxesProperty(vtkProperty* p);
  vtkProperty* GetSecondaryRadialAxesProperty();


  virtual void SetPolarArcsProperty(vtkProperty* p);
  vtkProperty* GetPolarArcsProperty();


  virtual void SetSecondaryPolarArcsProperty(vtkProperty* p);
  vtkProperty* GetSecondaryPolarArcsProperty();


  vtkSetVector6Macro(Bounds, double);
  double* GetBounds() override;
  void GetBounds(
    double& xmin, double& xmax, double& ymin, double& ymax, double& zmin, double& zmax);
  void GetBounds(double bounds[6]);


  vtkSetClampMacro(Ratio, double, 0.001, 100.0);
  vtkGetMacro(Ratio, double);


  vtkSetClampMacro(PolarArcResolutionPerDegree, double, VTK_MINIMUM_POLAR_ARC_RESOLUTION_PER_DEG,
    VTK_MAXIMUM_POLAR_ARC_RESOLUTION_PER_DEG);
  vtkGetMacro(PolarArcResolutionPerDegree, double);
 
protected:
  vtkPolarAxesActor();
  ~vtkPolarAxesActor() override;

  bool CheckMembersConsistency();

  void BuildAxes(vtkViewport*);

  void CalculateBounds();

  void SetCommonAxisAttributes(vtkAxisActor*);

  void SetPolarAxisAttributes(vtkAxisActor*);

  void CreateRadialAxes(int axisCount);

  void BuildRadialAxes(vtkViewport* viewport = nullptr);

  double ComputeIdealStep(int subDivsRequired, double rangeLength, int maxSubDivs = 1000);

  void BuildArcTicks();

  void StoreTicksPtsFromParamEllipse(
    double a, double angleEllipseRad, double tickSize, vtkPoints* tickPts);

  void BuildPolarAxisLabelsArcs();

  void BuildPolarAxisLabelsArcsLog();

  void BuildLabelsLog();
 
  void BuildPolarArcsLog();

  std::string FindExponentAndAdjustValues(std::list<double>& valuesList);

  void GetSignificantPartFromValues(vtkStringArray* valuesStr, std::list<double>& valuesList);


  double FFix(double);
  double FSign(double, double);

  void AutoScale(vtkViewport* viewport);

  static double ComputeEllipseAngle(double angleInDegrees, double ratio);

  virtual void ComputeDeltaRangePolarAxes(vtkIdType);

  virtual void ComputeDeltaAngleRadialAxes(vtkIdType);
 
private:
  double Pole[3] = { 0.0, 0.0, 0.0 };

  int NumberOfRadialAxes = 0;

  int RequestedNumberOfRadialAxes = 0;

  int NumberOfPolarAxes = 5;

  int RequestedNumberOfPolarAxes = 5;

  double Ratio = 1.0;

  double PolarArcResolutionPerDegree = 0.2;

  double Range[2] = { 0.0, 10.0 };

  double DeltaRangeMinor = 0.5;

  double DeltaRangeMajor = 1.0;

  double DeltaRangePolarAxes = 0.0;

  double RequestedDeltaRangePolarAxes = 0.0;

  double DeltaAngleMinor = 22.5;

  double DeltaAngleMajor = 45.0;

  double DeltaAngleRadialAxes = 45.0;

  double RequestedDeltaAngleRadialAxes = 45.0;

  double MinimumRadius = 0.0;

  double MaximumRadius = 1.0;

  bool Log = false;

  double MinimumAngle = 0.0;

  double MaximumAngle = 90.0;

  double SmallestVisiblePolarAngle = 0.5;
 
  // Structures for principal polar arc
  vtkNew<vtkPolyData> PolarArcs;
  vtkNew<vtkPolyDataMapper> PolarArcsMapper;
  vtkNew<vtkActor> PolarArcsActor;


  vtkNew<vtkPolyData> SecondaryPolarArcs;
  vtkNew<vtkPolyDataMapper> SecondaryPolarArcsMapper;
  vtkNew<vtkActor> SecondaryPolarArcsActor;

  vtkSmartPointer<vtkCamera> Camera;

  vtkNew<vtkAxisActor> PolarAxis;

  std::vector<vtkSmartPointer<vtkAxisActor>> RadialAxes;


  std::string PolarAxisTitle = "Radial Distance";
  char* PolarLabelFormat = nullptr;

  char* RadialAngleFormat = nullptr;

  bool RadialUnits = true;

  bool EnableDistanceLOD = true;

  double DistanceLODThreshold = 0.7;

  bool EnableViewAngleLOD = true;

  double ViewAngleLODThreshold = 0.3;


  bool PolarAxisVisibility = true;
  bool PolarTitleVisibility = true;
  bool PolarLabelVisibility = true;

  int TickLocation = vtkAxisActor::VTK_TICKS_BOTH;

  bool PolarTickVisibility = true;

  bool ArcTicksOriginToPolarAxis = true;

  bool RadialAxesOriginToPolarAxis = true;

  bool AxisTickVisibility = true, AxisMinorTickVisibility = false;

  bool AxisTickMatchesPolarAxes = true;

  bool ArcTickVisibility = true, ArcMinorTickVisibility = false;

  bool ArcTickMatchesRadialAxes = true;

  double PolarAxisMajorTickSize = 0.0, LastRadialAxisMajorTickSize = 0.0, ArcMajorTickSize = 0.0;

  double PolarAxisTickRatioSize = 0.3, LastAxisTickRatioSize = 0.3, ArcTickRatioSize = 0.3;

  double TickRatioRadiusSize = 0.02;

  double PolarAxisMajorTickThickness = 1.0, LastRadialAxisMajorTickThickness = 1.0,
         ArcMajorTickThickness = 1.0;

  double PolarAxisTickRatioThickness = 0.5, LastAxisTickRatioThickness = 0.5,
         ArcTickRatioThickness = 0.5;


  bool RadialAxesVisibility = true;
  bool RadialTitleVisibility = true;

  int RadialAxisTitleLocation = VTK_TITLE_BOTTOM;

  int PolarAxisTitleLocation = VTK_TITLE_BOTTOM;

  int ExponentLocation = VTK_EXPONENT_LABELS;

  bool PolarArcsVisibility = true;

  bool DrawRadialGridlines = true;

  bool DrawPolarArcsGridlines = true;

  vtkNew<vtkPoints> ArcMajorTickPts;

  vtkNew<vtkPoints> ArcMinorTickPts;


  vtkNew<vtkPolyData> ArcTickPolyData;
  vtkNew<vtkPolyData> ArcMinorTickPolyData;
  vtkNew<vtkPolyDataMapper> ArcTickPolyDataMapper;
  vtkNew<vtkPolyDataMapper> ArcMinorTickPolyDataMapper;
  vtkNew<vtkActor> ArcTickActor;
  vtkNew<vtkActor> ArcMinorTickActor;


  vtkSmartPointer<vtkTextProperty> PolarAxisTitleTextProperty;
  vtkSmartPointer<vtkTextProperty> PolarAxisLabelTextProperty;

  vtkSmartPointer<vtkTextProperty> LastRadialAxisTextProperty;

  vtkSmartPointer<vtkTextProperty> SecondaryRadialAxesTextProperty;

  vtkSmartPointer<vtkProperty> PolarAxisProperty;

  vtkSmartPointer<vtkProperty> LastRadialAxisProperty;

  vtkSmartPointer<vtkProperty> SecondaryRadialAxesProperty;
 
  vtkTimeStamp BuildTime;

  double ScreenSize = 10.0;


  double PolarTitleOffset[2] = { 20.0, 10.0 }, RadialTitleOffset[2] = { 20.0, 0.0 };
  double PolarLabelOffset = 10.0, PolarExponentOffset = 5.0;
 
  static constexpr int VTK_MAXIMUM_NUMBER_OF_POLAR_AXES = 20;
  static constexpr int VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES = 50;
  static constexpr double VTK_MINIMUM_POLAR_ARC_RESOLUTION_PER_DEG = 0.05;
  static constexpr double VTK_MAXIMUM_POLAR_ARC_RESOLUTION_PER_DEG = 100.0;
 
  vtkPolarAxesActor(const vtkPolarAxesActor&) = delete;
  void operator=(const vtkPolarAxesActor&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif