VTK  9.0.2
vtkAxis.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkAxis.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 
51 #ifndef vtkAxis_h
52 #define vtkAxis_h
53 
54 #include "vtkChartsCoreModule.h" // For export macro
55 #include "vtkContextItem.h"
56 #include "vtkRect.h" // For bounding rect
57 #include "vtkSmartPointer.h" // For vtkSmartPointer
58 #include "vtkStdString.h" // For vtkStdString ivars
59 #include "vtkVector.h" // For position variables
60 
61 class vtkContext2D;
62 class vtkPen;
63 class vtkFloatArray;
64 class vtkDoubleArray;
65 class vtkStringArray;
66 class vtkTextProperty;
67 
68 class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
69 {
70 public:
71  vtkTypeMacro(vtkAxis, vtkContextItem);
72  void PrintSelf(ostream& os, vtkIndent indent) override;
73 
78  enum Location
79  {
80  LEFT = 0,
83  TOP,
84  PARALLEL
85  };
86 
87  enum
88  {
89  TICK_SIMPLE = 0,
90  TICK_WILKINSON_EXTENDED
91  };
92 
96  static vtkAxis* New();
97 
99 
102  virtual void SetPosition(int position);
103  vtkGetMacro(Position, int);
105 
107 
110  void SetPoint1(const vtkVector2f& pos);
111  void SetPoint1(float x, float y);
113 
115 
118  vtkGetVector2Macro(Point1, float);
121 
123 
126  void SetPoint2(const vtkVector2f& pos);
127  void SetPoint2(float x, float y);
129 
131 
134  vtkGetVector2Macro(Point2, float);
137 
142  virtual void SetNumberOfTicks(int numberOfTicks);
143 
145 
148  vtkGetMacro(NumberOfTicks, int);
150 
152 
155  vtkSetMacro(TickLength, float);
156  vtkGetMacro(TickLength, float);
158 
160 
164  vtkGetObjectMacro(LabelProperties, vtkTextProperty);
166 
172  virtual void SetMinimum(double minimum);
173 
175 
180  vtkGetMacro(Minimum, double);
182 
188  virtual void SetMaximum(double maximum);
189 
191 
196  vtkGetMacro(Maximum, double);
198 
204  virtual void SetUnscaledMinimum(double minimum);
205 
207 
210  vtkGetMacro(UnscaledMinimum, double);
212 
216  virtual void SetUnscaledMaximum(double maximum);
217 
219 
222  vtkGetMacro(UnscaledMaximum, double);
224 
226 
235  virtual void SetRange(double minimum, double maximum);
236  virtual void SetRange(double range[2]);
237  virtual void SetUnscaledRange(double minimum, double maximum);
238  virtual void SetUnscaledRange(double range[2]);
240 
242 
249  virtual void GetRange(double* range);
250  virtual void GetUnscaledRange(double* range);
252 
256  virtual void SetMinimumLimit(double lowest);
257 
259 
262  vtkGetMacro(MinimumLimit, double);
264 
268  virtual void SetMaximumLimit(double highest);
269 
271 
274  vtkGetMacro(MaximumLimit, double);
276 
280  virtual void SetUnscaledMinimumLimit(double lowest);
281 
283 
286  vtkGetMacro(UnscaledMinimumLimit, double);
288 
292  virtual void SetUnscaledMaximumLimit(double highest);
293 
295 
298  vtkGetMacro(UnscaledMaximumLimit, double);
300 
302 
305  vtkGetVector2Macro(Margins, int);
307 
309 
312  vtkSetVector2Macro(Margins, int);
314 
316 
319  virtual void SetTitle(const vtkStdString& title);
322 
324 
327  vtkGetObjectMacro(TitleProperties, vtkTextProperty);
329 
331 
343  vtkGetMacro(LogScaleActive, bool);
345 
347 
353  vtkGetMacro(LogScale, bool);
354  virtual void SetLogScale(bool logScale);
355  vtkBooleanMacro(LogScale, bool);
357 
359 
362  vtkSetMacro(GridVisible, bool);
363  vtkGetMacro(GridVisible, bool);
365 
367 
370  vtkSetMacro(LabelsVisible, bool);
371  vtkGetMacro(LabelsVisible, bool);
373 
375 
378  vtkSetMacro(RangeLabelsVisible, bool);
379  vtkGetMacro(RangeLabelsVisible, bool);
381 
383 
386  vtkSetMacro(LabelOffset, float);
387  vtkGetMacro(LabelOffset, float);
389 
391 
394  vtkSetMacro(TicksVisible, bool);
395  vtkGetMacro(TicksVisible, bool);
397 
399 
402  vtkSetMacro(AxisVisible, bool);
403  vtkGetMacro(AxisVisible, bool);
405 
407 
410  vtkSetMacro(TitleVisible, bool);
411  vtkGetMacro(TitleVisible, bool);
413 
415 
419  virtual void SetPrecision(int precision);
420  vtkGetMacro(Precision, int);
422 
426  enum
427  {
428  STANDARD_NOTATION = 0,
431  PRINTF_NOTATION
432  };
433 
435 
439  virtual void SetLabelFormat(const std::string& fmt);
440  vtkGetMacro(LabelFormat, std::string);
442 
444 
449  vtkSetMacro(RangeLabelFormat, std::string);
450  vtkGetMacro(RangeLabelFormat, std::string);
452 
454 
459  virtual void SetNotation(int notation);
460  vtkGetMacro(Notation, int);
462 
466  enum
467  {
468  AUTO = 0, // Automatically scale the axis to view all data that is visible.
469  FIXED, // Use a fixed axis range and make no attempt to rescale.
470  CUSTOM // Deprecated, use the tick label settings instead.
471  };
472 
474 
477  vtkSetMacro(Behavior, int);
478  vtkGetMacro(Behavior, int);
480 
482 
485  vtkGetObjectMacro(Pen, vtkPen);
487 
489 
492  vtkGetObjectMacro(GridPen, vtkPen);
494 
496 
503  vtkSetMacro(TickLabelAlgorithm, int);
504  vtkGetMacro(TickLabelAlgorithm, int);
506 
508 
512  vtkSetMacro(ScalingFactor, double);
513  vtkGetMacro(ScalingFactor, double);
514  vtkSetMacro(Shift, double);
515  vtkGetMacro(Shift, double);
517 
522  void Update() override;
523 
527  bool Paint(vtkContext2D* painter) override;
528 
535  virtual void AutoScale();
536 
541  virtual void RecalculateTickSpacing();
542 
548 
554 
559 
567  virtual bool SetCustomTickPositions(vtkDoubleArray* positions, vtkStringArray* labels = nullptr);
568 
576 
582  static double NiceNumber(double number, bool roundUp);
583 
588  static double NiceMinMax(double& min, double& max, float pixelRange, float tickPixelSpacing);
589 
594  virtual vtkStdString GenerateSimpleLabel(double val);
595 
596 protected:
598  ~vtkAxis() override;
599 
608  void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
609 
613  virtual void GenerateTickLabels(double min, double max);
614 
618  virtual void GenerateTickLabels();
619 
620  virtual void GenerateLabelFormat(int notation, double n);
621 
625  virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
626 
631  double CalculateNiceMinMax(double& min, double& max);
632 
642  double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
643 
655  virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
656 
668  int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
669 
670  int Position; // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
671  float* Point1; // The position of point 1 (usually the origin)
672  float* Point2; // The position of point 2 (usually the terminus)
673  vtkVector2f Position1, Position2;
674  double TickInterval; // Interval between tick marks in plot space
675  int NumberOfTicks; // The number of tick marks to draw
676  float TickLength; // The length of the tick marks
677  vtkTextProperty* LabelProperties; // Text properties for the labels.
678  double Minimum; // Minimum value of the axis
679  double Maximum; // Maximum values of the axis
680  double MinimumLimit; // Lowest possible value for Minimum
681  double MaximumLimit; // Highest possible value for Maximum
682  double UnscaledMinimum; // UnscaledMinimum value of the axis
683  double UnscaledMaximum; // UnscaledMaximum values of the axis
684  double UnscaledMinimumLimit; // Lowest possible value for UnscaledMinimum
685  double UnscaledMaximumLimit; // Highest possible value for UnscaledMaximum
686  double NonLogUnscaledMinLimit; // Saved UnscaledMinimumLimit (when !LogActive)
687  double NonLogUnscaledMaxLimit; // Saved UnscaledMinimumLimit (when !LogActive)
688  int Margins[2]; // Horizontal/vertical margins for the axis
689  vtkStdString Title; // The text label drawn on the axis
690  vtkTextProperty* TitleProperties; // Text properties for the axis title
691  bool LogScale; // *Should* the axis use a log scale?
692  bool LogScaleActive; // *Is* the axis using a log scale?
693  bool GridVisible; // Whether the grid for the axis should be drawn
694  bool LabelsVisible; // Should the axis labels be visible
695  bool RangeLabelsVisible; // Should range labels be visible?
696  float LabelOffset; // Offset of label from the tick mark
697  bool TicksVisible; // Should the tick marks be visible.
698  bool AxisVisible; // Should the axis line be visible.
699  bool TitleVisible; // Should the title be visible.
700  int Precision; // Numerical precision to use, defaults to 2.
701  int Notation; // The notation to use (standard, scientific, mixed)
702  std::string LabelFormat; // The printf-style format string used for labels.
703  std::string RangeLabelFormat; // The printf-style format string used for range labels.
704  int Behavior; // The behaviour of the axis (auto, fixed, custom).
705  float MaxLabel[2]; // The widest/tallest axis label.
706  bool TitleAppended; // Track if the title is updated when the label formats
707  // are changed in the Extended Axis Labeling algorithm
708 
710 
716  double Shift;
718 
723 
728 
733 
738 
743 
748 
754 
759 
763  bool Resized;
764 
769 
774 
775 private:
776  vtkAxis(const vtkAxis&) = delete;
777  void operator=(const vtkAxis&) = delete;
778 
782  bool InRange(double value);
783 };
784 
785 #endif // vtkAxis_h
takes care of drawing 2D axes
Definition: vtkAxis.h:69
virtual void SetUnscaledMaximumLimit(double highest)
Set the logical highest possible value for Maximum, in plot coordinates.
bool Paint(vtkContext2D *painter) override
Paint event for the axis, called whenever the axis needs to be drawn.
virtual void SetMinimum(double minimum)
Set the logical minimum value of the axis, in plot coordinates.
vtkVector2f Position1
Definition: vtkAxis.h:673
vtkPen * Pen
This object stores the vtkPen that controls how the axis is drawn.
Definition: vtkAxis.h:727
void GenerateLogScaleTickMarks(int order, double min=1.0, double max=9.0, bool detailLabels=true)
Generate tick marks for logarithmic scale for specific order of magnitude.
virtual void SetUnscaledMinimumLimit(double lowest)
Set the logical lowest possible value for Minimum, in plot coordinates.
virtual void GenerateTickLabels()
Generate tick labels from the supplied double array of tick positions.
bool TitleVisible
Definition: vtkAxis.h:699
void SetPoint1(float x, float y)
double UnscaledMaximumLimit
Definition: vtkAxis.h:685
bool TitleAppended
Definition: vtkAxis.h:706
int Behavior
Definition: vtkAxis.h:704
static double NiceNumber(double number, bool roundUp)
Return a "nice number", often defined as 1, 2 or 5.
void SetPoint2(const vtkVector2f &pos)
Set point 2 of the axis (in pixels), this is usually the terminus.
vtkVector2f GetPosition2()
std::string RangeLabelFormat
Definition: vtkAxis.h:703
virtual void SetNotation(int notation)
Get/set the numerical notation, standard, scientific, fixed, or a printf-style format string.
int Precision
Definition: vtkAxis.h:700
void Update() override
Update the geometry of the axis.
vtkRectf GetBoundingRect(vtkContext2D *painter)
Request the space the axes require to be drawn.
double NonLogUnscaledMinLimit
Definition: vtkAxis.h:686
int Position
Definition: vtkAxis.h:670
bool UsingNiceMinMax
Hint as to whether a nice min/max was set, otherwise labels may not be present at the top/bottom of t...
Definition: vtkAxis.h:753
virtual void SetNumberOfTicks(int numberOfTicks)
Set the number of tick marks for this axis.
virtual void SetLabelFormat(const std::string &fmt)
Get/Set the printf-style format string used when TickLabelAlgorithm is TICK_SIMPLE and Notation is PR...
virtual void GenerateLogSpacedLinearTicks(int order, double min, double max)
Generate logarithmically-spaced tick marks with linear-style labels.
double CalculateNiceMinMax(double &min, double &max)
Calculate the next "nicest" numbers above and below the current minimum.
int TickLabelAlgorithm
The algorithm being used to tick label placement.
Definition: vtkAxis.h:768
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
virtual void SetTitle(const vtkStdString &title)
Get/set the title text of the axis.
bool GridVisible
Definition: vtkAxis.h:693
double Shift
Definition: vtkAxis.h:716
double UnscaledMinimumLimit
Definition: vtkAxis.h:684
vtkTextProperty * LabelProperties
Definition: vtkAxis.h:677
static double NiceMinMax(double &min, double &max, float pixelRange, float tickPixelSpacing)
Static function to calculate "nice" minimum, maximum, and tick spacing values.
float * Point2
Definition: vtkAxis.h:672
virtual void SetUnscaledRange(double range[2])
int NumberOfTicks
Definition: vtkAxis.h:675
vtkStdString Title
Definition: vtkAxis.h:689
void SetPoint1(const vtkVector2f &pos)
Set point 1 of the axis (in pixels), this is usually the origin.
@ FIXED
Definition: vtkAxis.h:469
bool Resized
Flag to indicate that the axis has been resized.
Definition: vtkAxis.h:763
double MinimumLimit
Definition: vtkAxis.h:680
virtual void SetPosition(int position)
Get/set the position of the axis (LEFT, BOTTOM, RIGHT, TOP, PARALLEL).
double UnscaledMinimum
Definition: vtkAxis.h:682
float TickLength
Definition: vtkAxis.h:676
virtual void GetRange(double *range)
Get the logical range of the axis, in plot coordinates.
bool RangeLabelsVisible
Definition: vtkAxis.h:695
virtual vtkStringArray * GetTickLabels()
A string array containing the tick labels for the axis.
vtkVector2f GetPosition1()
double TickInterval
Definition: vtkAxis.h:674
virtual void SetMaximumLimit(double highest)
Set the logical highest possible value for Maximum, in plot coordinates.
void SetPoint2(float x, float y)
virtual void SetPrecision(int precision)
Get/set the numerical precision to use, default is 2.
vtkSmartPointer< vtkFloatArray > TickScenePositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:742
virtual void SetMinimumLimit(double lowest)
Set the logical lowest possible value for Minimum, in plot coordinates.
virtual vtkStdString GenerateSprintfLabel(double value, const std::string &format)
Generate label using a printf-style format string.
virtual void RecalculateTickSpacing()
Recalculate the spacing of the tick marks - typically useful to do after scaling the axis.
virtual vtkDoubleArray * GetTickPositions()
An array with the positions of the tick marks along the axis line.
virtual void SetUnscaledMinimum(double minimum)
Set the logical, unscaled minimum value of the axis, in plot coordinates.
virtual void SetRange(double range[2])
bool LabelsVisible
Definition: vtkAxis.h:694
~vtkAxis() override
bool TicksVisible
Definition: vtkAxis.h:697
@ FIXED_NOTATION
Definition: vtkAxis.h:430
@ SCIENTIFIC_NOTATION
Definition: vtkAxis.h:429
Location
Enumeration of the axis locations in a conventional XY chart.
Definition: vtkAxis.h:79
@ TOP
Definition: vtkAxis.h:83
@ BOTTOM
Definition: vtkAxis.h:81
@ RIGHT
Definition: vtkAxis.h:82
double Maximum
Definition: vtkAxis.h:679
virtual vtkStdString GenerateSimpleLabel(double val)
Generate a single label using the current settings when TickLabelAlgorithm is TICK_SIMPLE.
double Minimum
Definition: vtkAxis.h:678
virtual void GenerateTickLabels(double min, double max)
Calculate and assign nice labels/logical label positions.
int Notation
Definition: vtkAxis.h:701
virtual bool SetCustomTickPositions(vtkDoubleArray *positions, vtkStringArray *labels=nullptr)
Set the tick positions, and optionally custom tick labels.
virtual void GenerateLabelFormat(int notation, double n)
virtual void AutoScale()
Use this function to autoscale the axes after setting the minimum and maximum values.
virtual void SetUnscaledMaximum(double maximum)
Set the logical maximum value of the axis, in plot coordinates.
double ScalingFactor
Scaling factor used on this axis, this is used to accurately render very small/large numbers accurate...
Definition: vtkAxis.h:715
double NonLogUnscaledMaxLimit
Definition: vtkAxis.h:687
float * Point1
Definition: vtkAxis.h:671
double MaximumLimit
Definition: vtkAxis.h:681
virtual void GetUnscaledRange(double *range)
vtkTextProperty * TitleProperties
Definition: vtkAxis.h:690
virtual void SetRange(double minimum, double maximum)
Set the logical range of the axis, in plot coordinates.
bool CustomTickLabels
Are we using custom tick labels, or should the axis generate them?
Definition: vtkAxis.h:722
void UpdateLogScaleActive(bool updateMinMaxFromUnscaled)
Update whether log scaling will be used for layout and rendering.
virtual vtkStdString GetTitle()
std::string LabelFormat
Definition: vtkAxis.h:702
static vtkAxis * New()
Creates a 2D Chart object.
double LogScaleTickMark(double number, bool roundUp, bool &niceValue, int &order)
Return a tick mark for a logarithmic axis.
vtkPen * GridPen
This object stores the vtkPen that controls how the grid lines are drawn.
Definition: vtkAxis.h:732
bool TickMarksDirty
Mark the tick labels as dirty when the min/max value is changed.
Definition: vtkAxis.h:758
float LabelOffset
Definition: vtkAxis.h:696
bool AxisVisible
Definition: vtkAxis.h:698
vtkSmartPointer< vtkStringArray > TickLabels
The labels for the tick marks.
Definition: vtkAxis.h:747
virtual void SetUnscaledRange(double minimum, double maximum)
double UnscaledMaximum
Definition: vtkAxis.h:683
bool LogScale
Definition: vtkAxis.h:691
virtual void SetMaximum(double maximum)
Set the logical maximum value of the axis, in plot coordinates.
virtual vtkFloatArray * GetTickScenePositions()
An array with the positions of the tick marks along the axis line.
virtual void SetLogScale(bool logScale)
bool LogScaleActive
Definition: vtkAxis.h:692
vtkTimeStamp BuildTime
The point cache is marked dirty until it has been initialized.
Definition: vtkAxis.h:773
vtkSmartPointer< vtkDoubleArray > TickPositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:737
Class for drawing 2D primitives to a graphical context.
Definition: vtkContext2D.h:53
base class for items that are part of a vtkContextScene.
dynamic, self-adjusting array of double
dynamic, self-adjusting array of float
Definition: vtkFloatArray.h:36
a simple class to control print indentation
Definition: vtkIndent.h:34
provides a pen that draws the outlines of shapes drawn by vtkContext2D.
Definition: vtkPen.h:37
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:35
a vtkAbstractArray subclass for strings
represent text properties.
record modification and/or execution time
Definition: vtkTimeStamp.h:33
@ order
Definition: vtkX3D.h:446
@ value
Definition: vtkX3D.h:226
@ range
Definition: vtkX3D.h:244
@ position
Definition: vtkX3D.h:267
@ title
Definition: vtkX3D.h:506
@ string
Definition: vtkX3D.h:496
#define max(a, b)