VTK  9.2.6
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
54#ifndef vtkAxis_h
55#define vtkAxis_h
56
57#include "vtkChartsCoreModule.h" // For export macro
58#include "vtkContextItem.h"
59#include "vtkPen.h" // For vtkPen
60#include "vtkRect.h" // For bounding rect
61#include "vtkSmartPointer.h" // For vtkSmartPointer
62#include "vtkStdString.h" // For vtkStdString ivars
63#include "vtkVector.h" // For position variables
64
65class vtkContext2D;
66class vtkFloatArray;
67class vtkDoubleArray;
68class vtkStringArray;
69class vtkTextProperty;
70
71class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
72{
73public:
74 vtkTypeMacro(vtkAxis, vtkContextItem);
75 void PrintSelf(ostream& os, vtkIndent indent) override;
76
82 {
83 LEFT = 0,
87 PARALLEL
88 };
89
90 enum
91 {
92 TICK_SIMPLE = 0,
93 TICK_WILKINSON_EXTENDED
94 };
95
99 static vtkAxis* New();
100
102
105 virtual void SetPosition(int position);
106 vtkGetMacro(Position, int);
108
110
113 void SetPoint1(const vtkVector2f& pos);
114 void SetPoint1(float x, float y);
116
118
121 vtkGetVector2Macro(Point1, float);
124
126
129 void SetPoint2(const vtkVector2f& pos);
130 void SetPoint2(float x, float y);
132
134
137 vtkGetVector2Macro(Point2, float);
140
145 virtual void SetNumberOfTicks(int numberOfTicks);
146
148
151 vtkGetMacro(NumberOfTicks, int);
153
155
158 vtkSetMacro(TickLength, float);
159 vtkGetMacro(TickLength, float);
161
163
167 vtkGetObjectMacro(LabelProperties, vtkTextProperty);
169
175 virtual void SetMinimum(double minimum);
176
178
183 vtkGetMacro(Minimum, double);
185
191 virtual void SetMaximum(double maximum);
192
194
199 vtkGetMacro(Maximum, double);
201
207 virtual void SetUnscaledMinimum(double minimum);
208
210
213 vtkGetMacro(UnscaledMinimum, double);
215
219 virtual void SetUnscaledMaximum(double maximum);
220
222
225 vtkGetMacro(UnscaledMaximum, double);
227
229
238 virtual void SetRange(double minimum, double maximum);
239 virtual void SetRange(double range[2]);
240 virtual void SetUnscaledRange(double minimum, double maximum);
241 virtual void SetUnscaledRange(double range[2]);
243
245
252 virtual void GetRange(double* range);
253 virtual void GetUnscaledRange(double* range);
255
259 virtual void SetMinimumLimit(double lowest);
260
262
265 vtkGetMacro(MinimumLimit, double);
267
271 virtual void SetMaximumLimit(double highest);
272
274
277 vtkGetMacro(MaximumLimit, double);
279
283 virtual void SetUnscaledMinimumLimit(double lowest);
284
286
289 vtkGetMacro(UnscaledMinimumLimit, double);
291
295 virtual void SetUnscaledMaximumLimit(double highest);
296
298
301 vtkGetMacro(UnscaledMaximumLimit, double);
303
305
308 vtkGetVector2Macro(Margins, int);
310
312
315 vtkSetVector2Macro(Margins, int);
317
319
322 virtual void SetTitle(const vtkStdString& title);
325
327
330 vtkGetObjectMacro(TitleProperties, vtkTextProperty);
332
334
346 vtkGetMacro(LogScaleActive, bool);
348
350
356 vtkGetMacro(LogScale, bool);
357 virtual void SetLogScale(bool logScale);
358 vtkBooleanMacro(LogScale, bool);
360
362
365 vtkSetMacro(GridVisible, bool);
366 vtkGetMacro(GridVisible, bool);
368
370
373 vtkSetMacro(LabelsVisible, bool);
374 vtkGetMacro(LabelsVisible, bool);
376
378
381 vtkSetMacro(RangeLabelsVisible, bool);
382 vtkGetMacro(RangeLabelsVisible, bool);
384
386
389 vtkSetMacro(LabelOffset, float);
390 vtkGetMacro(LabelOffset, float);
392
394
397 vtkSetMacro(TicksVisible, bool);
398 vtkGetMacro(TicksVisible, bool);
400
402
405 vtkSetMacro(AxisVisible, bool);
406 vtkGetMacro(AxisVisible, bool);
408
410
413 vtkSetMacro(TitleVisible, bool);
414 vtkGetMacro(TitleVisible, bool);
416
418
422 virtual void SetPrecision(int precision);
423 vtkGetMacro(Precision, int);
425
429 enum
430 {
431 STANDARD_NOTATION = 0,
434 PRINTF_NOTATION
435 };
436
438
442 virtual void SetLabelFormat(const std::string& fmt);
443 vtkGetMacro(LabelFormat, std::string);
445
447
452 vtkSetMacro(RangeLabelFormat, std::string);
453 vtkGetMacro(RangeLabelFormat, std::string);
455
457
462 virtual void SetNotation(int notation);
463 vtkGetMacro(Notation, int);
465
469 enum
470 {
471 AUTO = 0, // Automatically scale the axis to view all data that is visible.
472 FIXED, // Use a fixed axis range and make no attempt to rescale.
473 CUSTOM // Deprecated, use the tick label settings instead.
474 };
475
477
480 vtkSetMacro(Behavior, int);
481 vtkGetMacro(Behavior, int);
483
485
489 vtkGetObjectMacro(Pen, vtkPen);
491
493
497 vtkGetObjectMacro(GridPen, vtkPen);
499
501
508 vtkSetMacro(TickLabelAlgorithm, int);
509 vtkGetMacro(TickLabelAlgorithm, int);
511
513
517 vtkSetMacro(ScalingFactor, double);
518 vtkGetMacro(ScalingFactor, double);
519 vtkSetMacro(Shift, double);
520 vtkGetMacro(Shift, double);
522
527 void Update() override;
528
532 bool Paint(vtkContext2D* painter) override;
533
540 virtual void AutoScale();
541
547
553
559
564
572 virtual bool SetCustomTickPositions(vtkDoubleArray* positions, vtkStringArray* labels = nullptr);
573
581
587 static double NiceNumber(double number, bool roundUp);
588
593 static double NiceMinMax(double& min, double& max, float pixelRange, float tickPixelSpacing);
594
600
604 bool Hit(const vtkContextMouseEvent& mouse) override;
605
606protected:
608 ~vtkAxis() override;
609
618 void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
619
623 virtual void GenerateTickLabels(double min, double max);
624
628 virtual void GenerateTickLabels();
629
630 virtual void GenerateLabelFormat(int notation, double n);
631
635 virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
636
641 double CalculateNiceMinMax(double& min, double& max);
642
652 double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
653
665 virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
666
678 int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
679
684
685 int Position; // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
686 float* Point1; // The position of point 1 (usually the origin)
687 float* Point2; // The position of point 2 (usually the terminus)
689 double TickInterval; // Interval between tick marks in plot space
690 int NumberOfTicks; // The number of tick marks to draw
691 float TickLength; // The length of the tick marks
692 vtkTextProperty* LabelProperties; // Text properties for the labels.
693 double Minimum; // Minimum value of the axis
694 double Maximum; // Maximum values of the axis
695 double MinimumLimit; // Lowest possible value for Minimum
696 double MaximumLimit; // Highest possible value for Maximum
697 double UnscaledMinimum; // UnscaledMinimum value of the axis
698 double UnscaledMaximum; // UnscaledMaximum values of the axis
699 double UnscaledMinimumLimit; // Lowest possible value for UnscaledMinimum
700 double UnscaledMaximumLimit; // Highest possible value for UnscaledMaximum
701 double NonLogUnscaledMinLimit; // Saved UnscaledMinimumLimit (when !LogActive)
702 double NonLogUnscaledMaxLimit; // Saved UnscaledMinimumLimit (when !LogActive)
703 int Margins[2]; // Horizontal/vertical margins for the axis
704 vtkStdString Title; // The text label drawn on the axis
705 vtkTextProperty* TitleProperties; // Text properties for the axis title
706 bool LogScale; // *Should* the axis use a log scale?
707 bool LogScaleActive; // *Is* the axis using a log scale?
708 bool GridVisible; // Whether the grid for the axis should be drawn
709 bool LabelsVisible; // Should the axis labels be visible
710 bool RangeLabelsVisible; // Should range labels be visible?
711 float LabelOffset; // Offset of label from the tick mark
712 bool TicksVisible; // Should the tick marks be visible.
713 bool AxisVisible; // Should the axis line be visible.
714 bool TitleVisible; // Should the title be visible.
715 int Precision; // Numerical precision to use, defaults to 2.
716 int Notation; // The notation to use (standard, scientific, mixed)
717 std::string LabelFormat; // The printf-style format string used for labels.
718 std::string RangeLabelFormat; // The printf-style format string used for range labels.
719 int Behavior; // The behaviour of the axis (auto, fixed, custom).
720 float MaxLabel[2]; // The widest/tallest axis label.
721 bool TitleAppended; // Track if the title is updated when the label formats
722 // are changed in the Extended Axis Labeling algorithm
723
725
731 double Shift;
733
738
743
748
753
758
763
769
774
779
784
789
790private:
791 vtkAxis(const vtkAxis&) = delete;
792 void operator=(const vtkAxis&) = delete;
793
797 bool InRange(double value);
798};
799
800#endif // vtkAxis_h
takes care of drawing 2D axes
Definition: vtkAxis.h:72
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:688
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:714
void SetPoint1(float x, float y)
Set point 1 of the axis (in pixels), this is usually the origin.
double UnscaledMaximumLimit
Definition: vtkAxis.h:700
bool TitleAppended
Definition: vtkAxis.h:721
int Behavior
Definition: vtkAxis.h:719
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:718
static vtkAxis * New()
Creates a 2D Chart object.
virtual void SetNotation(int notation)
Get/set the numerical notation, standard, scientific, fixed, or a printf-style format string.
int Precision
Definition: vtkAxis.h:715
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:701
virtual vtkDoubleArray * GetTickPositions()
An array with the positions of the tick marks along the axis line.
int Position
Definition: vtkAxis.h:685
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:768
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 vtkStringArray * GetTickLabels()
A string array containing the tick labels for the axis.
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:783
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:708
double Shift
Scaling factor used on this axis, this is used to accurately render very small/large numbers accurate...
Definition: vtkAxis.h:731
double UnscaledMinimumLimit
Definition: vtkAxis.h:699
vtkTextProperty * LabelProperties
Definition: vtkAxis.h:692
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:687
virtual void SetUnscaledRange(double range[2])
Set the logical range of the axis, in plot coordinates.
int NumberOfTicks
Definition: vtkAxis.h:690
vtkStdString Title
Definition: vtkAxis.h:704
void SetPoint1(const vtkVector2f &pos)
Set point 1 of the axis (in pixels), this is usually the origin.
@ FIXED
Definition: vtkAxis.h:472
bool Resized
Flag to indicate that the axis has been resized.
Definition: vtkAxis.h:778
double MinimumLimit
Definition: vtkAxis.h:695
virtual void SetPosition(int position)
Get/set the position of the axis (LEFT, BOTTOM, RIGHT, TOP, PARALLEL).
double UnscaledMinimum
Definition: vtkAxis.h:697
float TickLength
Definition: vtkAxis.h:691
virtual void GetRange(double *range)
Get the logical range of the axis, in plot coordinates.
bool RangeLabelsVisible
Definition: vtkAxis.h:710
vtkSetSmartPointerMacro(Pen, vtkPen)
Set/get the vtkPen object that controls the way this axis is drawn.
vtkVector2f GetPosition1()
Get point 1 of the axis (in pixels), this is usually the origin.
double TickInterval
Definition: vtkAxis.h:689
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:757
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:742
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:709
void CalculateTitlePosition(vtkVector2f &out)
Calculate the position where the title of the axis would be drawn.
~vtkAxis() override
bool TicksVisible
Definition: vtkAxis.h:712
@ FIXED_NOTATION
Definition: vtkAxis.h:433
@ SCIENTIFIC_NOTATION
Definition: vtkAxis.h:432
Location
Enumeration of the axis locations in a conventional XY chart.
Definition: vtkAxis.h:82
@ TOP
Definition: vtkAxis.h:86
@ BOTTOM
Definition: vtkAxis.h:84
@ RIGHT
Definition: vtkAxis.h:85
double Maximum
Definition: vtkAxis.h:694
virtual vtkStdString GenerateSimpleLabel(double val)
Generate a single label using the current settings when TickLabelAlgorithm is TICK_SIMPLE.
double Minimum
Definition: vtkAxis.h:693
virtual void GenerateTickLabels(double min, double max)
Calculate and assign nice labels/logical label positions.
int Notation
Definition: vtkAxis.h:716
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 vtkFloatArray * GetTickScenePositions()
An array with the positions of the tick marks along the axis line.
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:730
vtkSmartPointer< vtkPen > GridPen
This object stores the vtkPen that controls how the grid lines are drawn.
Definition: vtkAxis.h:747
double NonLogUnscaledMaxLimit
Definition: vtkAxis.h:702
float * Point1
Definition: vtkAxis.h:686
double MaximumLimit
Definition: vtkAxis.h:696
virtual void GetUnscaledRange(double *range)
Get the logical range of the axis, in plot coordinates.
vtkTextProperty * TitleProperties
Definition: vtkAxis.h:705
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:737
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:717
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:773
float LabelOffset
Definition: vtkAxis.h:711
bool AxisVisible
Definition: vtkAxis.h:713
vtkSmartPointer< vtkStringArray > TickLabels
The labels for the tick marks.
Definition: vtkAxis.h:762
virtual void SetUnscaledRange(double minimum, double maximum)
Set the logical range of the axis, in plot coordinates.
double UnscaledMaximum
Definition: vtkAxis.h:698
bool LogScale
Definition: vtkAxis.h:706
virtual void SetMaximum(double maximum)
Set the logical maximum value of the axis, in plot coordinates.
virtual void SetLogScale(bool logScale)
Get/set whether the axis should attempt to use a log scale.
bool LogScaleActive
Definition: vtkAxis.h:707
vtkTimeStamp BuildTime
The point cache is marked dirty until it has been initialized.
Definition: vtkAxis.h:788
vtkSmartPointer< vtkDoubleArray > TickPositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:752
Class for drawing 2D primitives to a graphical context.
Definition: vtkContext2D.h:58
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
Definition: vtkFloatArray.h:42
a simple class to control print indentation
Definition: vtkIndent.h:40
provides a pen that draws the outlines of shapes drawn by vtkContext2D.
Definition: vtkPen.h:40
Hold a reference to a vtkObjectBase instance.
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:39
a vtkAbstractArray subclass for strings
represent text properties.
record modification and/or execution time
Definition: vtkTimeStamp.h:36
#define max(a, b)