vtkPolarAxesActor.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkCubeAxesActor.h
  Language:  C++

Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen
All rights reserve
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     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 vtkPolarAxesActor_h
#define vtkPolarAxesActor_h

#define VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES 50
#define VTK_DEFAULT_NUMBER_OF_RADIAL_AXES 5
#define VTK_MAXIMUM_NUMBER_OF_POLAR_AXIS_TICKS 200
#define VTK_MAXIMUM_RATIO 1000.0
#define VTK_POLAR_ARC_RESOLUTION_PER_DEG 0.2

#include "vtkActor.h"
#include "vtkAxisActor.h"                 // access to enum values
#include "vtkRenderingAnnotationModule.h" // For export macro
#include <list>                           // To process exponent list as reference

class vtkCamera;
class vtkPolyData;
class vtkPolyDataMapper;
class vtkProperty;
class vtkStringArray;
class vtkTextProperty;

class VTKRENDERINGANNOTATION_EXPORT 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;
  int RenderTranslucentPolygonalGeometry(vtkViewport*) override { return 0; };


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


  virtual void SetNumberOfPolarAxisTicks(int);
  int GetNumberOfPolarAxisTicks();


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


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


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


  vtkSetStringMacro(PolarAxisTitle);
  vtkGetStringMacro(PolarAxisTitle);


  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, int);
  vtkGetMacro(EnableDistanceLOD, int);


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


  vtkSetMacro(EnableViewAngleLOD, int);
  vtkGetMacro(EnableViewAngleLOD, int);


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


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


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


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


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

  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, vtkTypeBool);
  vtkGetMacro(PolarLabelVisibility, vtkTypeBool);
  vtkBooleanMacro(PolarLabelVisibility, vtkTypeBool);


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


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


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


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


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


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


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


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


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


  vtkSetMacro(DeltaAngleRadialAxes, double);
  vtkGetMacro(DeltaAngleRadialAxes, double);

  //------------------------------------------------


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


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


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


  void SetUse2DMode(int val);
  int GetUse2DMode();


  virtual void SetPolarAxisTitleTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(PolarAxisTitleTextProperty, vtkTextProperty);


  virtual void SetPolarAxisLabelTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(PolarAxisLabelTextProperty, vtkTextProperty);


  virtual void SetLastRadialAxisTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(LastRadialAxisTextProperty, vtkTextProperty);


  virtual void SetSecondaryRadialAxesTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(SecondaryRadialAxesTextProperty, vtkTextProperty);


  virtual void SetPolarAxisProperty(vtkProperty*);
  vtkGetObjectMacro(PolarAxisProperty, vtkProperty);


  virtual void SetLastRadialAxisProperty(vtkProperty* p);
  vtkGetObjectMacro(LastRadialAxisProperty, vtkProperty);


  virtual void SetSecondaryRadialAxesProperty(vtkProperty* p);
  vtkGetObjectMacro(SecondaryRadialAxesProperty, vtkProperty);


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

protected:
  vtkPolarAxesActor();
  ~vtkPolarAxesActor() override;

  bool CheckMembersConsistency();

  void BuildAxes(vtkViewport*);

  void CalculateBounds();

  void SetCommonAxisAttributes(vtkAxisActor*);

  void SetPolarAxisAttributes(vtkAxisActor*);

  void CreateRadialAxes(int axisCount);

  void BuildRadialAxes();

  void AutoComputeTicksProperties();

  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 ComputeDeltaAngleRadialAxes(vtkIdType);
  double Pole[3];

  int NumberOfRadialAxes;

  int RequestedNumberOfRadialAxes;

  bool AutoSubdividePolarAxis;

  double Ratio;

  double Range[2];

  double DeltaRangeMinor;

  double DeltaRangeMajor;

  double DeltaAngleMinor;

  double DeltaAngleMajor;

  double DeltaAngleRadialAxes;

  double MinimumRadius;

  double MaximumRadius;

  bool Log;

  bool AutoScaleRadius;

  double MinimumAngle;

  double MaximumAngle;

  double SmallestVisiblePolarAngle;

  // Structures for principal polar arc
  vtkPolyData* PolarArcs;
  vtkPolyDataMapper* PolarArcsMapper;
  vtkActor* PolarArcsActor;


  vtkPolyData* SecondaryPolarArcs;
  vtkPolyDataMapper* SecondaryPolarArcsMapper;
  vtkActor* SecondaryPolarArcsActor;

  vtkCamera* Camera;

  vtkAxisActor* PolarAxis;

  vtkAxisActor** RadialAxes;


  char* PolarAxisTitle;
  char* PolarLabelFormat;

  char* RadialAngleFormat;

  bool RadialUnits;

  int EnableDistanceLOD;

  double DistanceLODThreshold;

  int EnableViewAngleLOD;

  double ViewAngleLODThreshold;


  vtkTypeBool PolarAxisVisibility;
  vtkTypeBool PolarTitleVisibility;
  vtkTypeBool PolarLabelVisibility;

  int TickLocation;

  vtkTypeBool PolarTickVisibility;

  int ArcTicksOriginToPolarAxis;

  int RadialAxesOriginToPolarAxis;

  vtkTypeBool AxisTickVisibility, AxisMinorTickVisibility;

  vtkTypeBool ArcTickVisibility, ArcMinorTickVisibility;

  double PolarAxisMajorTickSize, LastRadialAxisMajorTickSize, ArcMajorTickSize;

  double PolarAxisTickRatioSize, LastAxisTickRatioSize, ArcTickRatioSize;

  double PolarAxisMajorTickThickness, LastRadialAxisMajorTickThickness, ArcMajorTickThickness;

  double PolarAxisTickRatioThickness, LastAxisTickRatioThickness, ArcTickRatioThickness;


  vtkTypeBool RadialAxesVisibility;
  vtkTypeBool RadialTitleVisibility;

  int RadialAxisTitleLocation;

  int PolarAxisTitleLocation;

  int ExponentLocation;

  vtkTypeBool PolarArcsVisibility;

  vtkTypeBool DrawRadialGridlines;

  vtkTypeBool DrawPolarArcsGridlines;

  vtkPoints* ArcMajorTickPts;

  vtkPoints* ArcMinorTickPts;


  vtkPolyData* ArcTickPolyData;
  vtkPolyData* ArcMinorTickPolyData;
  vtkPolyDataMapper* ArcTickPolyDataMapper;
  vtkPolyDataMapper* ArcMinorTickPolyDataMapper;
  vtkActor* ArcTickActor;
  vtkActor* ArcMinorTickActor;


  vtkTextProperty* PolarAxisTitleTextProperty;
  vtkTextProperty* PolarAxisLabelTextProperty;

  vtkTextProperty* LastRadialAxisTextProperty;

  vtkTextProperty* SecondaryRadialAxesTextProperty;

  vtkProperty* PolarAxisProperty;

  vtkProperty* LastRadialAxisProperty;

  vtkProperty* SecondaryRadialAxesProperty;

  vtkTimeStamp BuildTime;

  double TitleScale;

  double LabelScale;

  double ScreenSize;

private:
  vtkPolarAxesActor(const vtkPolarAxesActor&) = delete;
  void operator=(const vtkPolarAxesActor&) = delete;
};

#endif