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);
 
 
  vtkSetStringMacro(PolarLabelFormat);
  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);
 
 
  vtkSetStringMacro(RadialAngleFormat);
  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