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 "vtkRenderingAnnotationModule.h" // For export macro
#include "vtkActor.h"
#include "vtkAxisActor.h" // access to enum values
#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);

  static vtkPolarAxesActor *New();


  virtual int RenderOpaqueGeometry(vtkViewport*);
  virtual int RenderOverlay(vtkViewport*);
  virtual int RenderTranslucentPolygonalGeometry(vtkViewport*) {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);


  virtual void SetNumberOfRadialAxes(vtkIdType);
  vtkGetMacro(NumberOfRadialAxes, 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);


  vtkSetMacro(AutoScaleRadius, bool);
  vtkGetMacro(AutoScaleRadius, bool);


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


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


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


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


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

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


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


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


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


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


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


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


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


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


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


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


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

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

  double Pole[3];

  int NumberOfRadialAxes;

  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;

  double Bounds[6];

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


  int PolarAxisVisibility;
  int PolarTitleVisibility;
  int PolarLabelVisibility;

  int TickLocation;

  int PolarTickVisibility;

  int ArcTicksOriginToPolarAxis;

  int RadialAxesOriginToPolarAxis;

  int AxisTickVisibility, AxisMinorTickVisibility;

  int ArcTickVisibility, ArcMinorTickVisibility;

  double PolarAxisMajorTickSize, LastRadialAxisMajorTickSize, ArcMajorTickSize;

  double PolarAxisTickRatioSize, LastAxisTickRatioSize, ArcTickRatioSize;

  double PolarAxisMajorTickThickness, LastRadialAxisMajorTickThickness, ArcMajorTickThickness;

  double PolarAxisTickRatioThickness, LastAxisTickRatioThickness, ArcTickRatioThickness;


  int RadialAxesVisibility;
  int RadialTitleVisibility;

  int RadialAxisTitleLocation;

  int PolarAxisTitleLocation;

  int ExponentLocation;

  int PolarArcsVisibility;

  int DrawRadialGridlines;

  int 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&) VTK_DELETE_FUNCTION;
  void operator=(const vtkPolarAxesActor&) VTK_DELETE_FUNCTION;
};

#endif