VTK  9.3.0
vtkPolarAxesActor.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-License-Identifier: BSD-3-Clause
24 #ifndef vtkPolarAxesActor_h
25 #define vtkPolarAxesActor_h
26 
27 #include "vtkActor.h"
28 #include "vtkAxisActor.h" // access to enum values
29 #include "vtkDeprecation.h" // For deprecation macro
30 #include "vtkNew.h" // used for vtkNew
31 #include "vtkRenderingAnnotationModule.h" // For export macro
32 #include "vtkSmartPointer.h" // used for vtkSmartPointer
33 #include <list> // To process exponent list as reference
34 #include <string> // used for ivar
35 
36 VTK_ABI_NAMESPACE_BEGIN
37 class vtkCamera;
38 class vtkPolyData;
39 class vtkPolyDataMapper;
40 class vtkProperty;
41 class vtkStringArray;
42 class vtkTextProperty;
43 
44 class VTKRENDERINGANNOTATION_EXPORT vtkPolarAxesActor : public vtkActor
45 {
46 public:
47  vtkTypeMacro(vtkPolarAxesActor, vtkActor);
48  void PrintSelf(ostream& os, vtkIndent indent) override;
49 
55 
57 
61  int RenderOverlay(vtkViewport*) override;
62  int RenderTranslucentPolygonalGeometry(vtkViewport*) override { return 0; }
64 
66 
69  virtual void SetPole(double[3]);
70  virtual void SetPole(double, double, double);
71  vtkGetVector3Macro(Pole, double);
73 
75 
79  vtkSetMacro(Log, bool);
80  vtkGetMacro(Log, bool);
81  vtkBooleanMacro(Log, bool);
83 
85 
89  vtkSetClampMacro(RequestedNumberOfRadialAxes, vtkIdType, 0, VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES);
90  vtkGetMacro(RequestedNumberOfRadialAxes, vtkIdType);
92 
94 
98  vtkSetClampMacro(RequestedNumberOfPolarAxes, vtkIdType, 0, VTK_MAXIMUM_NUMBER_OF_POLAR_AXES);
99  vtkGetMacro(RequestedNumberOfPolarAxes, vtkIdType);
101 
103 
107  VTK_DEPRECATED_IN_9_3_0("Use SetDeltaRangeMajor instead or enable AxisTickMatchesPolarAxes")
108  vtkSetMacro(AutoSubdividePolarAxis, bool);
109  VTK_DEPRECATED_IN_9_3_0("Use SetDeltaRangeMajor instead or enable AxisTickMatchesPolarAxes")
110  vtkGetMacro(AutoSubdividePolarAxis, bool);
111  void AutoSubdividePolarAxisOn();
112  void AutoSubdividePolarAxisOff();
114 
116 
120  VTK_DEPRECATED_IN_9_3_0("Use SetDeltaRangeMajor instead or enable AxisTickMatchesPolarAxes")
121  virtual void SetNumberOfPolarAxisTicks(int);
122  int GetNumberOfPolarAxisTicks();
124 
126 
130  vtkSetVector2Macro(Range, double);
131  vtkGetVectorMacro(Range, double, 2);
133 
135 
139  virtual void SetMinimumRadius(double);
140  vtkGetMacro(MinimumRadius, double);
142 
144 
148  virtual void SetMaximumRadius(double);
149  vtkGetMacro(MaximumRadius, double);
151 
153 
157  virtual void SetMinimumAngle(double);
158  vtkGetMacro(MinimumAngle, double);
160 
162 
166  virtual void SetMaximumAngle(double);
167  vtkGetMacro(MaximumAngle, double);
169 
171 
176  vtkSetClampMacro(SmallestVisiblePolarAngle, double, 0., 5.);
177  vtkGetMacro(SmallestVisiblePolarAngle, double);
179 
181 
187  vtkSetClampMacro(TickLocation, int, vtkAxisActor::VTK_TICKS_INSIDE, vtkAxisActor::VTK_TICKS_BOTH);
188  vtkGetMacro(TickLocation, int);
190 
192 
195  vtkSetMacro(RadialUnits, bool);
196  vtkGetMacro(RadialUnits, bool);
198 
200 
206  vtkSetMacro(ScreenSize, double);
207  vtkGetMacro(ScreenSize, double);
209 
211 
216  vtkSetVector2Macro(PolarTitleOffset, double);
217  vtkGetVectorMacro(PolarTitleOffset, double, 2);
219 
221 
226  vtkSetVector2Macro(RadialTitleOffset, double);
227  vtkGetVectorMacro(RadialTitleOffset, double, 2);
229 
231 
235  vtkGetMacro(PolarLabelOffset, double);
236  vtkSetMacro(PolarLabelOffset, double);
238 
240 
244  vtkGetMacro(PolarExponentOffset, double);
245  vtkSetMacro(PolarExponentOffset, double);
247 
249 
253  virtual void SetCamera(vtkCamera*);
254  vtkCamera* GetCamera();
256 
258 
262  vtkSetStringMacro(PolarAxisTitle);
263  vtkGetStringMacro(PolarAxisTitle);
265 
267 
270  vtkSetStringMacro(PolarLabelFormat);
271  vtkGetStringMacro(PolarLabelFormat);
273 
275  {
276  VTK_EXPONENT_BOTTOM = 0,
277  VTK_EXPONENT_EXTERN = 1,
278  VTK_EXPONENT_LABELS = 2
279  };
280 
282 
287  vtkSetClampMacro(ExponentLocation, int, VTK_EXPONENT_BOTTOM, VTK_EXPONENT_LABELS);
288  vtkGetMacro(ExponentLocation, int);
290 
292 
295  vtkSetStringMacro(RadialAngleFormat);
296  vtkGetStringMacro(RadialAngleFormat);
298 
305 
307 
311  vtkSetMacro(EnableDistanceLOD, bool);
312  vtkGetMacro(EnableDistanceLOD, bool);
314 
316 
320  vtkSetClampMacro(DistanceLODThreshold, double, 0.0, 1.0);
321  vtkGetMacro(DistanceLODThreshold, double);
323 
325 
329  vtkSetMacro(EnableViewAngleLOD, bool);
330  vtkGetMacro(EnableViewAngleLOD, bool);
332 
334 
338  vtkSetClampMacro(ViewAngleLODThreshold, double, 0., 1.);
339  vtkGetMacro(ViewAngleLODThreshold, double);
341 
343 
347  vtkSetMacro(PolarAxisVisibility, bool);
348  vtkGetMacro(PolarAxisVisibility, bool);
349  vtkBooleanMacro(PolarAxisVisibility, bool);
351 
353 
357  vtkSetMacro(DrawRadialGridlines, bool);
358  vtkGetMacro(DrawRadialGridlines, bool);
359  vtkBooleanMacro(DrawRadialGridlines, bool);
361 
363 
367  vtkSetMacro(DrawPolarArcsGridlines, bool);
368  vtkGetMacro(DrawPolarArcsGridlines, bool);
369  vtkBooleanMacro(DrawPolarArcsGridlines, bool);
371 
373 
377  vtkSetMacro(PolarTitleVisibility, bool);
378  vtkGetMacro(PolarTitleVisibility, bool);
379  vtkBooleanMacro(PolarTitleVisibility, bool);
381 
383  {
384  VTK_TITLE_BOTTOM = 0,
385  VTK_TITLE_EXTERN = 1
386  };
387 
389 
394  vtkSetClampMacro(RadialAxisTitleLocation, int, VTK_TITLE_BOTTOM, VTK_TITLE_EXTERN);
395  vtkGetMacro(RadialAxisTitleLocation, int);
397 
399 
404  vtkSetClampMacro(PolarAxisTitleLocation, int, VTK_TITLE_BOTTOM, VTK_TITLE_EXTERN);
405  vtkGetMacro(PolarAxisTitleLocation, int);
407 
409 
413  vtkSetMacro(PolarLabelVisibility, bool);
414  vtkGetMacro(PolarLabelVisibility, bool);
415  vtkBooleanMacro(PolarLabelVisibility, bool);
417 
419 
425  vtkSetMacro(ArcTicksOriginToPolarAxis, bool);
426  vtkGetMacro(ArcTicksOriginToPolarAxis, bool);
427  vtkBooleanMacro(ArcTicksOriginToPolarAxis, bool);
429 
431 
437  vtkSetMacro(RadialAxesOriginToPolarAxis, bool);
438  vtkGetMacro(RadialAxesOriginToPolarAxis, bool);
439  vtkBooleanMacro(RadialAxesOriginToPolarAxis, bool);
441 
443 
447  vtkSetMacro(PolarTickVisibility, bool);
448  vtkGetMacro(PolarTickVisibility, bool);
449  vtkBooleanMacro(PolarTickVisibility, bool);
451 
453 
457  vtkSetMacro(AxisTickVisibility, bool);
458  vtkGetMacro(AxisTickVisibility, bool);
459  vtkBooleanMacro(AxisTickVisibility, bool);
461 
463 
467  vtkSetMacro(AxisMinorTickVisibility, bool);
468  vtkGetMacro(AxisMinorTickVisibility, bool);
469  vtkBooleanMacro(AxisMinorTickVisibility, bool);
471 
473 
477  vtkSetMacro(AxisTickMatchesPolarAxes, bool);
478  vtkGetMacro(AxisTickMatchesPolarAxes, bool);
479  vtkBooleanMacro(AxisTickMatchesPolarAxes, bool);
481 
483 
487  vtkSetMacro(ArcTickVisibility, bool);
488  vtkGetMacro(ArcTickVisibility, bool);
489  vtkBooleanMacro(ArcTickVisibility, bool);
491 
493 
497  vtkSetMacro(ArcMinorTickVisibility, bool);
498  vtkGetMacro(ArcMinorTickVisibility, bool);
499  vtkBooleanMacro(ArcMinorTickVisibility, bool);
501 
503 
507  vtkSetMacro(ArcTickMatchesRadialAxes, bool);
508  vtkGetMacro(ArcTickMatchesRadialAxes, bool);
509  vtkBooleanMacro(ArcTickMatchesRadialAxes, bool);
511 
513 
518  vtkSetMacro(ArcMajorTickSize, double);
519  vtkGetMacro(ArcMajorTickSize, double);
521 
523 
528  vtkSetMacro(PolarAxisMajorTickSize, double);
529  vtkGetMacro(PolarAxisMajorTickSize, double);
531 
533 
538  vtkSetMacro(LastRadialAxisMajorTickSize, double);
539  vtkGetMacro(LastRadialAxisMajorTickSize, double);
541 
543 
547  vtkSetMacro(PolarAxisTickRatioSize, double);
548  vtkGetMacro(PolarAxisTickRatioSize, double);
550 
552 
556  vtkSetMacro(LastAxisTickRatioSize, double);
557  vtkGetMacro(LastAxisTickRatioSize, double);
559 
561 
565  vtkSetMacro(ArcTickRatioSize, double);
566  vtkGetMacro(ArcTickRatioSize, double);
568 
570 
574  vtkSetMacro(TickRatioRadiusSize, double);
575  vtkGetMacro(TickRatioRadiusSize, double);
577 
579 
583  vtkSetMacro(PolarAxisMajorTickThickness, double);
584  vtkGetMacro(PolarAxisMajorTickThickness, double);
586 
588 
592  vtkSetMacro(LastRadialAxisMajorTickThickness, double);
593  vtkGetMacro(LastRadialAxisMajorTickThickness, double);
595 
597 
601  vtkSetMacro(ArcMajorTickThickness, double);
602  vtkGetMacro(ArcMajorTickThickness, double);
604 
606 
610  vtkSetMacro(PolarAxisTickRatioThickness, double);
611  vtkGetMacro(PolarAxisTickRatioThickness, double);
613 
615 
619  vtkSetMacro(LastAxisTickRatioThickness, double);
620  vtkGetMacro(LastAxisTickRatioThickness, double);
622 
624 
628  vtkSetMacro(ArcTickRatioThickness, double);
629  vtkGetMacro(ArcTickRatioThickness, double);
631 
633 
637  vtkSetMacro(DeltaRangeMajor, double);
638  vtkGetMacro(DeltaRangeMajor, double);
640 
642 
646  vtkSetMacro(DeltaRangeMinor, double);
647  vtkGetMacro(DeltaRangeMinor, double);
649 
651 
656  vtkSetMacro(RequestedDeltaRangePolarAxes, double);
657  vtkGetMacro(RequestedDeltaRangePolarAxes, double);
659 
661 
665  vtkSetMacro(DeltaAngleMajor, double);
666  vtkGetMacro(DeltaAngleMajor, double);
668 
670 
674  vtkSetMacro(DeltaAngleMinor, double);
675  vtkGetMacro(DeltaAngleMinor, double);
677 
679 
684  vtkSetMacro(RequestedDeltaAngleRadialAxes, double);
685  vtkGetMacro(RequestedDeltaAngleRadialAxes, double);
687 
688  //------------------------------------------------
689 
691 
695  vtkSetMacro(RadialAxesVisibility, bool);
696  vtkGetMacro(RadialAxesVisibility, bool);
697  vtkBooleanMacro(RadialAxesVisibility, bool);
699 
701 
705  vtkSetMacro(RadialTitleVisibility, bool);
706  vtkGetMacro(RadialTitleVisibility, bool);
707  vtkBooleanMacro(RadialTitleVisibility, bool);
709 
711 
715  vtkSetMacro(PolarArcsVisibility, bool);
716  vtkGetMacro(PolarArcsVisibility, bool);
717  vtkBooleanMacro(PolarArcsVisibility, bool);
719 
721 
724  void SetUse2DMode(bool enable);
725  bool GetUse2DMode();
727 
729 
735 
737 
743 
745 
751 
753 
759 
761 
767 
769 
775 
777 
783 
785 
791 
793 
799 
801 
808  vtkSetVector6Macro(Bounds, double);
809  double* GetBounds() override;
810  void GetBounds(
811  double& xmin, double& xmax, double& ymin, double& ymax, double& zmin, double& zmax);
812  void GetBounds(double bounds[6]);
814 
816 
820  vtkSetClampMacro(Ratio, double, 0.001, 100.0);
821  vtkGetMacro(Ratio, double);
823 
825 
829  vtkSetClampMacro(PolarArcResolutionPerDegree, double, VTK_MINIMUM_POLAR_ARC_RESOLUTION_PER_DEG,
830  VTK_MAXIMUM_POLAR_ARC_RESOLUTION_PER_DEG);
831  vtkGetMacro(PolarArcResolutionPerDegree, double);
833 
834 protected:
836  ~vtkPolarAxesActor() override;
837 
842 
848 
853 
858 
863 
867  void CreateRadialAxes(int axisCount);
868 
874  void BuildRadialAxes(vtkViewport* viewport = nullptr);
875 
882  VTK_DEPRECATED_IN_9_3_0("Use SetDeltaRangeMajor instead or enable AxisTickMatchesPolarAxes")
883  void AutoComputeTicksProperties();
884 
888  double ComputeIdealStep(int subDivsRequired, double rangeLength, int maxSubDivs = 1000);
889 
893  void BuildArcTicks();
894 
899  void StoreTicksPtsFromParamEllipse(
900  double a, double angleEllipseRad, double tickSize, vtkPoints* tickPts);
901 
905  void BuildPolarAxisLabelsArcs();
906 
910  void BuildPolarAxisLabelsArcsLog();
911 
915  void BuildLabelsLog();
916 
917  void BuildPolarArcsLog();
918 
922  std::string FindExponentAndAdjustValues(std::list<double>& valuesList);
923 
927  void GetSignificantPartFromValues(vtkStringArray* valuesStr, std::list<double>& valuesList);
928 
930 
933  double FFix(double);
934  double FSign(double, double);
936 
941  void AutoScale(vtkViewport* viewport);
942 
947  static double ComputeEllipseAngle(double angleInDegrees, double ratio);
948 
952  virtual void ComputeDeltaRangePolarAxes(vtkIdType);
953 
957  virtual void ComputeDeltaAngleRadialAxes(vtkIdType);
961  double Pole[3] = { 0.0, 0.0, 0.0 };
962 
966  int NumberOfRadialAxes = 0;
967 
972  int RequestedNumberOfRadialAxes = 0;
973 
977  int NumberOfPolarAxes = 5;
978 
983  int RequestedNumberOfPolarAxes = 5;
984 
988  double Ratio = 1.0;
989 
993  double PolarArcResolutionPerDegree = 0.2;
994 
998  double Range[2] = { 0.0, 10.0 };
999 
1003  double DeltaRangeMinor = 0.5;
1004 
1008  double DeltaRangeMajor = 1.0;
1009 
1013  bool AutoSubdividePolarAxis = false;
1014 
1018  double DeltaRangePolarAxes = 0.0;
1019 
1024  double RequestedDeltaRangePolarAxes = 0.0;
1025 
1029  double DeltaAngleMinor = 22.5;
1030 
1034  double DeltaAngleMajor = 45.0;
1035 
1039  double DeltaAngleRadialAxes = 45.0;
1040 
1045  double RequestedDeltaAngleRadialAxes = 45.0;
1046 
1050  double MinimumRadius = 0.0;
1051 
1055  double MaximumRadius = 1.0;
1056 
1060  bool Log = false;
1061 
1065  double MinimumAngle = 0.0;
1066 
1070  double MaximumAngle = 90.0;
1071 
1075  double SmallestVisiblePolarAngle = 0.5;
1076 
1077  // Structures for principal polar arc
1081 
1083 
1090 
1095 
1100 
1104  vtkSmartPointer<vtkAxisActor>* RadialAxes = nullptr;
1105 
1107 
1111  char* PolarAxisTitle = nullptr;
1112  char* PolarLabelFormat = nullptr;
1114 
1118  char* RadialAngleFormat = nullptr;
1119 
1123  bool RadialUnits = true;
1124 
1128  bool EnableDistanceLOD = true;
1129 
1133  double DistanceLODThreshold = 0.7;
1134 
1138  bool EnableViewAngleLOD = true;
1139 
1144  double ViewAngleLODThreshold = 0.3;
1145 
1147 
1150  bool PolarAxisVisibility = true;
1151  bool PolarTitleVisibility = true;
1152  bool PolarLabelVisibility = true;
1154 
1162  int TickLocation = vtkAxisActor::VTK_TICKS_BOTH;
1163 
1167  bool PolarTickVisibility = true;
1168 
1175  bool ArcTicksOriginToPolarAxis = true;
1176 
1183  bool RadialAxesOriginToPolarAxis = true;
1184 
1188  bool AxisTickVisibility = true, AxisMinorTickVisibility = false;
1189 
1193  bool AxisTickMatchesPolarAxes = true;
1194 
1198  bool ArcTickVisibility = true, ArcMinorTickVisibility = false;
1199 
1203  bool ArcTickMatchesRadialAxes = true;
1204 
1208  double PolarAxisMajorTickSize = 0.0, LastRadialAxisMajorTickSize = 0.0, ArcMajorTickSize = 0.0;
1209 
1213  double PolarAxisTickRatioSize = 0.3, LastAxisTickRatioSize = 0.3, ArcTickRatioSize = 0.3;
1214 
1218  double TickRatioRadiusSize = 0.02;
1219 
1223  double PolarAxisMajorTickThickness = 1.0, LastRadialAxisMajorTickThickness = 1.0,
1224  ArcMajorTickThickness = 1.0;
1225 
1229  double PolarAxisTickRatioThickness = 0.5, LastAxisTickRatioThickness = 0.5,
1230  ArcTickRatioThickness = 0.5;
1231 
1233 
1236  bool RadialAxesVisibility = true;
1237  bool RadialTitleVisibility = true;
1239 
1243  int RadialAxisTitleLocation = VTK_TITLE_BOTTOM;
1244 
1248  int PolarAxisTitleLocation = VTK_TITLE_BOTTOM;
1249 
1254  int ExponentLocation = VTK_EXPONENT_LABELS;
1255 
1259  bool PolarArcsVisibility = true;
1260 
1264  bool DrawRadialGridlines = true;
1265 
1269  bool DrawPolarArcsGridlines = true;
1270 
1275 
1280 
1282 
1292 
1294 
1300 
1305 
1310 
1316 
1321 
1326 
1328 
1332  double TitleScale = -1.0;
1333 
1337  double LabelScale = -1.0;
1338 
1342  double ScreenSize = 10.0;
1343 
1345 
1348  double PolarTitleOffset[2] = { 20.0, 10.0 }, RadialTitleOffset[2] = { 20.0, 0.0 };
1349  double PolarLabelOffset = 10.0, PolarExponentOffset = 5.0;
1351 
1352 private:
1353  static constexpr int VTK_MAXIMUM_NUMBER_OF_POLAR_AXES = 20;
1354  static constexpr int VTK_MAXIMUM_NUMBER_OF_RADIAL_AXES = 50;
1355  static constexpr double VTK_MINIMUM_POLAR_ARC_RESOLUTION_PER_DEG = 0.05;
1356  static constexpr double VTK_MAXIMUM_POLAR_ARC_RESOLUTION_PER_DEG = 100.0;
1357 
1358  vtkPolarAxesActor(const vtkPolarAxesActor&) = delete;
1359  void operator=(const vtkPolarAxesActor&) = delete;
1360 };
1361 
1362 VTK_ABI_NAMESPACE_END
1363 #endif
represents an object (geometry & properties) in a rendered scene
Definition: vtkActor.h:41
Create an axis with tick marks and labels.
Definition: vtkAxisActor.h:70
a virtual camera for 3D rendering
Definition: vtkCamera.h:41
a simple class to control print indentation
Definition: vtkIndent.h:29
represent and manipulate 3D points
Definition: vtkPoints.h:29
create an actor of a polar axes -
vtkSmartPointer< vtkCamera > Camera
Camera attached to the polar axes system.
vtkNew< vtkPoints > ArcMinorTickPts
Keep the arc minor ticks vtkPoints instances.
virtual void SetPolarAxisProperty(vtkProperty *)
Get/Set polar axis actor properties.
void CalculateBounds()
Calculate bounds based on maximum radius and angular sector.
vtkSmartPointer< vtkTextProperty > PolarAxisTitleTextProperty
Text properties of polar axis title and labels.
void GetBounds(double bounds[6])
Explicitly specify the region in space around which to draw the bounds.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
vtkProperty * GetPolarAxisProperty()
Get/Set polar axis actor properties.
vtkSmartPointer< vtkProperty > PolarAxisProperty
General properties of polar axis Behavior may be override by polar axis ticks 's actor property.
vtkNew< vtkAxisActor > PolarAxis
Control variables for polar axis.
bool GetUse2DMode()
Enable/Disable labels 2D mode (always facing the camera).
vtkNew< vtkActor > ArcTickActor
vtk object for arc Ticks
virtual void SetLastRadialAxisTextProperty(vtkTextProperty *p)
Set/Get the last radial axis text property.
virtual void SetLastRadialAxisProperty(vtkProperty *p)
Get/Set last radial axis actor properties.
virtual void SetSecondaryPolarArcsProperty(vtkProperty *p)
Get/Set secondary polar arcs actors property.
vtkNew< vtkPolyData > SecondaryPolarArcs
Structures for secondary polar arcs.
virtual void SetSecondaryRadialAxesProperty(vtkProperty *p)
Get/Set secondary radial axes actors properties.
vtkSmartPointer< vtkTextProperty > SecondaryRadialAxesTextProperty
Text properties of secondary radial axes.
vtkProperty * GetPolarArcsProperty()
Get/Set principal polar arc actor property.
void GetBounds(double &xmin, double &xmax, double &ymin, double &ymax, double &zmin, double &zmax)
Explicitly specify the region in space around which to draw the bounds.
vtkProperty * GetSecondaryPolarArcsProperty()
Get/Set secondary polar arcs actors property.
vtkSmartPointer< vtkProperty > LastRadialAxisProperty
General properties of last radial axis.
vtkNew< vtkPolyDataMapper > ArcTickPolyDataMapper
vtk object for arc Ticks
virtual void SetPole(double[3])
Explicitly specify the coordinate of the pole.
vtkNew< vtkActor > PolarArcsActor
vtkNew< vtkPolyData > ArcTickPolyData
vtk object for arc Ticks
void CreateRadialAxes(int axisCount)
Create requested number of type X axes.
vtkProperty * GetSecondaryRadialAxesProperty()
Get/Set secondary radial axes actors properties.
vtkTextProperty * GetPolarAxisTitleTextProperty()
Set/Get the polar axis title text property.
vtkSmartPointer< vtkTextProperty > LastRadialAxisTextProperty
Text properties of last radial axis.
vtkNew< vtkPolyData > PolarArcs
void BuildRadialAxes(vtkViewport *viewport=nullptr)
Build requested number of radial axes with respect to specified pole.
virtual void SetPolarAxisTitleTextProperty(vtkTextProperty *p)
Set/Get the polar axis title text property.
vtkNew< vtkPoints > ArcMajorTickPts
Keep the arc major ticks vtkPoints instances.
bool CheckMembersConsistency()
Check consistency of vtkPolarAxesActor members.
vtkProperty * GetLastRadialAxisProperty()
Get/Set last radial axis actor properties.
vtkTextProperty * GetSecondaryRadialAxesTextProperty()
Set/Get the secondary radial axes text property.
vtkSmartPointer< vtkTextProperty > PolarAxisLabelTextProperty
Text properties of polar axis title and labels.
virtual void SetSecondaryRadialAxesTextProperty(vtkTextProperty *p)
Set/Get the secondary radial axes text property.
int RenderOverlay(vtkViewport *) override
Draw the polar axes.
vtkSmartPointer< vtkProperty > SecondaryRadialAxesProperty
General properties of radial axes.
vtkNew< vtkPolyData > ArcMinorTickPolyData
vtk object for arc Ticks
void SetCommonAxisAttributes(vtkAxisActor *)
Send attributes which are common to all axes, both polar and radial.
double * GetBounds() override
Explicitly specify the region in space around which to draw the bounds.
vtkTextProperty * GetPolarAxisLabelTextProperty()
Set/Get the polar axis labels text property.
static vtkPolarAxesActor * New()
Instantiate object with label format "6.3g" and the number of labels per axis set to 3.
vtkNew< vtkActor > ArcMinorTickActor
vtk object for arc Ticks
virtual void SetPole(double, double, double)
Explicitly specify the coordinate of the pole.
vtkTextProperty * GetLastRadialAxisTextProperty()
Set/Get the last radial axis text property.
void SetUse2DMode(bool enable)
Enable/Disable labels 2D mode (always facing the camera).
int RenderOpaqueGeometry(vtkViewport *) override
Draw the polar axes.
void SetPolarAxisAttributes(vtkAxisActor *)
Set properties specific to PolarAxis.
void ReleaseGraphicsResources(vtkWindow *) override
Release any graphics resources that are being consumed by this actor.
vtkNew< vtkPolyDataMapper > PolarArcsMapper
int RenderTranslucentPolygonalGeometry(vtkViewport *) override
Draw the polar axes.
~vtkPolarAxesActor() override
vtkNew< vtkPolyDataMapper > ArcMinorTickPolyDataMapper
vtk object for arc Ticks
virtual void SetPolarAxisLabelTextProperty(vtkTextProperty *p)
Set/Get the polar axis labels text property.
vtkNew< vtkActor > SecondaryPolarArcsActor
Structures for secondary polar arcs.
vtkNew< vtkPolyDataMapper > SecondaryPolarArcsMapper
Structures for secondary polar arcs.
void BuildAxes(vtkViewport *)
Build the axes.
virtual void SetPolarArcsProperty(vtkProperty *p)
Get/Set principal polar arc actor property.
map vtkPolyData to graphics primitives
concrete dataset represents vertices, lines, polygons, and triangle strips
Definition: vtkPolyData.h:80
represent surface properties of a geometric object
Definition: vtkProperty.h:57
a vtkAbstractArray subclass for strings
represent text properties.
record modification and/or execution time
Definition: vtkTimeStamp.h:25
abstract specification for Viewports
Definition: vtkViewport.h:45
window superclass for vtkRenderWindow
Definition: vtkWindow.h:28
auto Range(IterablePtr iterable, Options &&... opts) -> typename detail::IterableTraits< typename detail::StripPointers< IterablePtr >::type >::RangeType
Generate an iterable STL proxy object for a VTK container.
Definition: vtkRange.h:74
#define VTK_DEPRECATED_IN_9_3_0(reason)
int vtkIdType
Definition: vtkType.h:315