VTK  9.2.5
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 
163 #ifndef vtkAxis_h
164 #define vtkAxis_h
165 
166 #include "vtkChartsCoreModule.h" // For export macro
167 #include "vtkContextItem.h"
168 #include "vtkPen.h" // For vtkPen
169 #include "vtkRect.h" // For bounding rect
170 #include "vtkSmartPointer.h" // For vtkSmartPointer
171 #include "vtkStdString.h" // For vtkStdString ivars
172 #include "vtkVector.h" // For position variables
173 
174 class vtkContext2D;
175 class vtkFloatArray;
176 class vtkDoubleArray;
177 class vtkStringArray;
178 class vtkTextProperty;
179 
180 class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
181 {
182 public:
183  vtkTypeMacro(vtkAxis, vtkContextItem);
184  void PrintSelf(ostream& os, vtkIndent indent) override;
185 
190  enum Location
191  {
192  LEFT = 0,
196  PARALLEL
197  };
198 
199  enum
200  {
201  TICK_SIMPLE = 0,
202  TICK_WILKINSON_EXTENDED
203  };
204 
208  static vtkAxis* New();
209 
211 
214  virtual void SetPosition(int position);
215  vtkGetMacro(Position, int);
217 
219 
222  void SetPoint1(const vtkVector2f& pos);
223  void SetPoint1(float x, float y);
225 
227 
230  vtkGetVector2Macro(Point1, float);
233 
235 
238  void SetPoint2(const vtkVector2f& pos);
239  void SetPoint2(float x, float y);
241 
243 
246  vtkGetVector2Macro(Point2, float);
249 
254  virtual void SetNumberOfTicks(int numberOfTicks);
255 
257 
260  vtkGetMacro(NumberOfTicks, int);
262 
264 
267  vtkSetMacro(TickLength, float);
268  vtkGetMacro(TickLength, float);
270 
272 
276  vtkGetObjectMacro(LabelProperties, vtkTextProperty);
278 
284  virtual void SetMinimum(double minimum);
285 
287 
292  vtkGetMacro(Minimum, double);
294 
300  virtual void SetMaximum(double maximum);
301 
303 
308  vtkGetMacro(Maximum, double);
310 
316  virtual void SetUnscaledMinimum(double minimum);
317 
319 
322  vtkGetMacro(UnscaledMinimum, double);
324 
328  virtual void SetUnscaledMaximum(double maximum);
329 
331 
334  vtkGetMacro(UnscaledMaximum, double);
336 
338 
347  virtual void SetRange(double minimum, double maximum);
348  virtual void SetRange(double range[2]);
349  virtual void SetUnscaledRange(double minimum, double maximum);
350  virtual void SetUnscaledRange(double range[2]);
352 
354 
361  virtual void GetRange(double* range);
362  virtual void GetUnscaledRange(double* range);
364 
368  virtual void SetMinimumLimit(double lowest);
369 
371 
374  vtkGetMacro(MinimumLimit, double);
376 
380  virtual void SetMaximumLimit(double highest);
381 
383 
386  vtkGetMacro(MaximumLimit, double);
388 
392  virtual void SetUnscaledMinimumLimit(double lowest);
393 
395 
398  vtkGetMacro(UnscaledMinimumLimit, double);
400 
404  virtual void SetUnscaledMaximumLimit(double highest);
405 
407 
410  vtkGetMacro(UnscaledMaximumLimit, double);
412 
414 
417  vtkGetVector2Macro(Margins, int);
419 
421 
424  vtkSetVector2Macro(Margins, int);
426 
428 
431  virtual void SetTitle(const vtkStdString& title);
434 
436 
439  vtkGetObjectMacro(TitleProperties, vtkTextProperty);
441 
443 
455  vtkGetMacro(LogScaleActive, bool);
457 
459 
465  vtkGetMacro(LogScale, bool);
466  virtual void SetLogScale(bool logScale);
467  vtkBooleanMacro(LogScale, bool);
469 
471 
474  vtkSetMacro(GridVisible, bool);
475  vtkGetMacro(GridVisible, bool);
477 
479 
482  vtkSetMacro(LabelsVisible, bool);
483  vtkGetMacro(LabelsVisible, bool);
485 
487 
490  vtkSetMacro(RangeLabelsVisible, bool);
491  vtkGetMacro(RangeLabelsVisible, bool);
493 
495 
498  vtkSetMacro(LabelOffset, float);
499  vtkGetMacro(LabelOffset, float);
501 
503 
506  vtkSetMacro(TicksVisible, bool);
507  vtkGetMacro(TicksVisible, bool);
509 
511 
514  vtkSetMacro(AxisVisible, bool);
515  vtkGetMacro(AxisVisible, bool);
517 
519 
522  vtkSetMacro(TitleVisible, bool);
523  vtkGetMacro(TitleVisible, bool);
525 
527 
531  virtual void SetPrecision(int precision);
532  vtkGetMacro(Precision, int);
534 
538  enum
539  {
540  STANDARD_NOTATION = 0,
543  PRINTF_NOTATION
544  };
545 
547 
551  virtual void SetLabelFormat(const std::string& fmt);
552  vtkGetMacro(LabelFormat, std::string);
554 
556 
561  vtkSetMacro(RangeLabelFormat, std::string);
562  vtkGetMacro(RangeLabelFormat, std::string);
564 
566 
571  virtual void SetNotation(int notation);
572  vtkGetMacro(Notation, int);
574 
578  enum
579  {
580  AUTO = 0, // Automatically scale the axis to view all data that is visible.
581  FIXED, // Use a fixed axis range and make no attempt to rescale.
582  CUSTOM // Deprecated, use the tick label settings instead.
583  };
584 
586 
589  vtkSetMacro(Behavior, int);
590  vtkGetMacro(Behavior, int);
592 
594 
598  vtkGetObjectMacro(Pen, vtkPen);
600 
602 
606  vtkGetObjectMacro(GridPen, vtkPen);
608 
610 
617  vtkSetMacro(TickLabelAlgorithm, int);
618  vtkGetMacro(TickLabelAlgorithm, int);
620 
622 
626  vtkSetMacro(ScalingFactor, double);
627  vtkGetMacro(ScalingFactor, double);
628  vtkSetMacro(Shift, double);
629  vtkGetMacro(Shift, double);
631 
636  void Update() override;
637 
641  bool Paint(vtkContext2D* painter) override;
642 
649  virtual void AutoScale();
650 
655  virtual void RecalculateTickSpacing();
656 
662 
668 
673 
681  virtual bool SetCustomTickPositions(vtkDoubleArray* positions, vtkStringArray* labels = nullptr);
682 
690 
696  static double NiceNumber(double number, bool roundUp);
697 
702  static double NiceMinMax(double& min, double& max, float pixelRange, float tickPixelSpacing);
703 
708  virtual vtkStdString GenerateSimpleLabel(double val);
709 
713  bool Hit(const vtkContextMouseEvent& mouse) override;
714 
715 protected:
717  ~vtkAxis() override;
718 
727  void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
728 
732  virtual void GenerateTickLabels(double min, double max);
733 
737  virtual void GenerateTickLabels();
738 
739  virtual void GenerateLabelFormat(int notation, double n);
740 
744  virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
745 
750  double CalculateNiceMinMax(double& min, double& max);
751 
761  double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
762 
774  virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
775 
787  int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
788 
793 
794  int Position; // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
795  float* Point1; // The position of point 1 (usually the origin)
796  float* Point2; // The position of point 2 (usually the terminus)
797  vtkVector2f Position1, Position2;
798  double TickInterval; // Interval between tick marks in plot space
799  int NumberOfTicks; // The number of tick marks to draw
800  float TickLength; // The length of the tick marks
801  vtkTextProperty* LabelProperties; // Text properties for the labels.
802  double Minimum; // Minimum value of the axis
803  double Maximum; // Maximum values of the axis
804  double MinimumLimit; // Lowest possible value for Minimum
805  double MaximumLimit; // Highest possible value for Maximum
806  double UnscaledMinimum; // UnscaledMinimum value of the axis
807  double UnscaledMaximum; // UnscaledMaximum values of the axis
808  double UnscaledMinimumLimit; // Lowest possible value for UnscaledMinimum
809  double UnscaledMaximumLimit; // Highest possible value for UnscaledMaximum
810  double NonLogUnscaledMinLimit; // Saved UnscaledMinimumLimit (when !LogActive)
811  double NonLogUnscaledMaxLimit; // Saved UnscaledMinimumLimit (when !LogActive)
812  int Margins[2]; // Horizontal/vertical margins for the axis
813  vtkStdString Title; // The text label drawn on the axis
814  vtkTextProperty* TitleProperties; // Text properties for the axis title
815  bool LogScale; // *Should* the axis use a log scale?
816  bool LogScaleActive; // *Is* the axis using a log scale?
817  bool GridVisible; // Whether the grid for the axis should be drawn
818  bool LabelsVisible; // Should the axis labels be visible
819  bool RangeLabelsVisible; // Should range labels be visible?
820  float LabelOffset; // Offset of label from the tick mark
821  bool TicksVisible; // Should the tick marks be visible.
822  bool AxisVisible; // Should the axis line be visible.
823  bool TitleVisible; // Should the title be visible.
824  int Precision; // Numerical precision to use, defaults to 2.
825  int Notation; // The notation to use (standard, scientific, mixed)
826  std::string LabelFormat; // The printf-style format string used for labels.
827  std::string RangeLabelFormat; // The printf-style format string used for range labels.
828  int Behavior; // The behaviour of the axis (auto, fixed, custom).
829  float MaxLabel[2]; // The widest/tallest axis label.
830  bool TitleAppended; // Track if the title is updated when the label formats
831  // are changed in the Extended Axis Labeling algorithm
832 
834 
840  double Shift;
842 
847 
852 
857 
862 
867 
872 
878 
883 
887  bool Resized;
888 
893 
898 
899 private:
900  vtkAxis(const vtkAxis&) = delete;
901  void operator=(const vtkAxis&) = delete;
902 
906  bool InRange(double value);
907 };
908 
909 #endif // vtkAxis_h
takes care of drawing 2D axes
Definition: vtkAxis.h:181
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:797
vtkSetSmartPointerMacro(GridPen, vtkPen)
Set/get the vtkPen object that controls the way this axis is drawn.
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:823
void SetPoint1(float x, float y)
Set point 1 of the axis (in pixels), this is usually the origin.
double UnscaledMaximumLimit
Definition: vtkAxis.h:809
bool TitleAppended
Definition: vtkAxis.h:830
int Behavior
Definition: vtkAxis.h:828
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()
Get point 2 of the axis (in pixels), this is usually the terminus.
std::string RangeLabelFormat
Definition: vtkAxis.h:827
virtual void SetNotation(int notation)
Get/set the numerical notation, standard, scientific, fixed, or a printf-style format string.
int Precision
Definition: vtkAxis.h:824
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:810
int Position
Definition: vtkAxis.h:794
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:877
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.
bool Hit(const vtkContextMouseEvent &mouse) override
Return true if the supplied x, y coordinate is inside the item.
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:892
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:817
double Shift
Scaling factor used on this axis, this is used to accurately render very small/large numbers accurate...
Definition: vtkAxis.h:840
double UnscaledMinimumLimit
Definition: vtkAxis.h:808
vtkTextProperty * LabelProperties
Definition: vtkAxis.h:801
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:796
virtual void SetUnscaledRange(double range[2])
Set the logical range of the axis, in plot coordinates.
int NumberOfTicks
Definition: vtkAxis.h:799
vtkStdString Title
Definition: vtkAxis.h:813
void SetPoint1(const vtkVector2f &pos)
Set point 1 of the axis (in pixels), this is usually the origin.
@ FIXED
Definition: vtkAxis.h:581
bool Resized
Flag to indicate that the axis has been resized.
Definition: vtkAxis.h:887
double MinimumLimit
Definition: vtkAxis.h:804
virtual void SetPosition(int position)
Get/set the position of the axis (LEFT, BOTTOM, RIGHT, TOP, PARALLEL).
double UnscaledMinimum
Definition: vtkAxis.h:806
float TickLength
Definition: vtkAxis.h:800
virtual void GetRange(double *range)
Get the logical range of the axis, in plot coordinates.
bool RangeLabelsVisible
Definition: vtkAxis.h:819
vtkSetSmartPointerMacro(Pen, vtkPen)
Set/get the vtkPen object that controls the way this axis is drawn.
virtual vtkStringArray * GetTickLabels()
A string array containing the tick labels for the axis.
vtkVector2f GetPosition1()
Get point 1 of the axis (in pixels), this is usually the origin.
double TickInterval
Definition: vtkAxis.h:798
virtual void SetMaximumLimit(double highest)
Set the logical highest possible value for Maximum, in plot coordinates.
void SetPoint2(float x, float y)
Set point 2 of the axis (in pixels), this is usually the terminus.
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:866
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.
vtkSmartPointer< vtkPen > Pen
This object stores the vtkPen that controls how the axis is drawn.
Definition: vtkAxis.h:851
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])
Set the logical range of the axis, in plot coordinates.
bool LabelsVisible
Definition: vtkAxis.h:818
void CalculateTitlePosition(vtkVector2f &out)
Calculate the position where the title of the axis would be drawn.
~vtkAxis() override
bool TicksVisible
Definition: vtkAxis.h:821
@ FIXED_NOTATION
Definition: vtkAxis.h:542
@ SCIENTIFIC_NOTATION
Definition: vtkAxis.h:541
Location
Enumeration of the axis locations in a conventional XY chart.
Definition: vtkAxis.h:191
@ TOP
Definition: vtkAxis.h:195
@ BOTTOM
Definition: vtkAxis.h:193
@ RIGHT
Definition: vtkAxis.h:194
double Maximum
Definition: vtkAxis.h:803
virtual vtkStdString GenerateSimpleLabel(double val)
Generate a single label using the current settings when TickLabelAlgorithm is TICK_SIMPLE.
double Minimum
Definition: vtkAxis.h:802
virtual void GenerateTickLabels(double min, double max)
Calculate and assign nice labels/logical label positions.
int Notation
Definition: vtkAxis.h:825
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:839
vtkSmartPointer< vtkPen > GridPen
This object stores the vtkPen that controls how the grid lines are drawn.
Definition: vtkAxis.h:856
double NonLogUnscaledMaxLimit
Definition: vtkAxis.h:811
float * Point1
Definition: vtkAxis.h:795
double MaximumLimit
Definition: vtkAxis.h:805
virtual void GetUnscaledRange(double *range)
Get the logical range of the axis, in plot coordinates.
vtkTextProperty * TitleProperties
Definition: vtkAxis.h:814
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:846
void UpdateLogScaleActive(bool updateMinMaxFromUnscaled)
Update whether log scaling will be used for layout and rendering.
virtual vtkStdString GetTitle()
Get/set the title text of the axis.
std::string LabelFormat
Definition: vtkAxis.h:826
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.
bool TickMarksDirty
Mark the tick labels as dirty when the min/max value is changed.
Definition: vtkAxis.h:882
float LabelOffset
Definition: vtkAxis.h:820
bool AxisVisible
Definition: vtkAxis.h:822
vtkSmartPointer< vtkStringArray > TickLabels
The labels for the tick marks.
Definition: vtkAxis.h:871
virtual void SetUnscaledRange(double minimum, double maximum)
Set the logical range of the axis, in plot coordinates.
double UnscaledMaximum
Definition: vtkAxis.h:807
bool LogScale
Definition: vtkAxis.h:815
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)
Get/set whether the axis should attempt to use a log scale.
bool LogScaleActive
Definition: vtkAxis.h:816
vtkTimeStamp BuildTime
The point cache is marked dirty until it has been initialized.
Definition: vtkAxis.h:897
vtkSmartPointer< vtkDoubleArray > TickPositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:861
Class for drawing 2D primitives to a graphical context.
Definition: vtkContext2D.h:77
base class for items that are part of a vtkContextScene.
data structure to represent mouse events.
dynamic, self-adjusting array of double
dynamic, self-adjusting array of float
a simple class to control print indentation
Definition: vtkIndent.h:119
provides a pen that draws the outlines of shapes drawn by vtkContext2D.
Definition: vtkPen.h:139
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:108
a vtkAbstractArray subclass for strings
represent text properties.
record modification and/or execution time
Definition: vtkTimeStamp.h:55
@ 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)