VTK  9.1.0
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
61class vtkContext2D;
62class vtkPen;
63class vtkFloatArray;
64class vtkDoubleArray;
65class vtkStringArray;
66class vtkTextProperty;
67
68class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
69{
70public:
71 vtkTypeMacro(vtkAxis, vtkContextItem);
72 void PrintSelf(ostream& os, vtkIndent indent) override;
73
79 {
80 LEFT = 0,
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
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
595
599 bool Hit(const vtkContextMouseEvent& mouse) override;
600
601protected:
603 ~vtkAxis() override;
604
613 void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
614
618 virtual void GenerateTickLabels(double min, double max);
619
623 virtual void GenerateTickLabels();
624
625 virtual void GenerateLabelFormat(int notation, double n);
626
630 virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
631
636 double CalculateNiceMinMax(double& min, double& max);
637
647 double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
648
660 virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
661
673 int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
674
679
680 int Position; // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
681 float* Point1; // The position of point 1 (usually the origin)
682 float* Point2; // The position of point 2 (usually the terminus)
684 double TickInterval; // Interval between tick marks in plot space
685 int NumberOfTicks; // The number of tick marks to draw
686 float TickLength; // The length of the tick marks
687 vtkTextProperty* LabelProperties; // Text properties for the labels.
688 double Minimum; // Minimum value of the axis
689 double Maximum; // Maximum values of the axis
690 double MinimumLimit; // Lowest possible value for Minimum
691 double MaximumLimit; // Highest possible value for Maximum
692 double UnscaledMinimum; // UnscaledMinimum value of the axis
693 double UnscaledMaximum; // UnscaledMaximum values of the axis
694 double UnscaledMinimumLimit; // Lowest possible value for UnscaledMinimum
695 double UnscaledMaximumLimit; // Highest possible value for UnscaledMaximum
696 double NonLogUnscaledMinLimit; // Saved UnscaledMinimumLimit (when !LogActive)
697 double NonLogUnscaledMaxLimit; // Saved UnscaledMinimumLimit (when !LogActive)
698 int Margins[2]; // Horizontal/vertical margins for the axis
699 vtkStdString Title; // The text label drawn on the axis
700 vtkTextProperty* TitleProperties; // Text properties for the axis title
701 bool LogScale; // *Should* the axis use a log scale?
702 bool LogScaleActive; // *Is* the axis using a log scale?
703 bool GridVisible; // Whether the grid for the axis should be drawn
704 bool LabelsVisible; // Should the axis labels be visible
705 bool RangeLabelsVisible; // Should range labels be visible?
706 float LabelOffset; // Offset of label from the tick mark
707 bool TicksVisible; // Should the tick marks be visible.
708 bool AxisVisible; // Should the axis line be visible.
709 bool TitleVisible; // Should the title be visible.
710 int Precision; // Numerical precision to use, defaults to 2.
711 int Notation; // The notation to use (standard, scientific, mixed)
712 std::string LabelFormat; // The printf-style format string used for labels.
713 std::string RangeLabelFormat; // The printf-style format string used for range labels.
714 int Behavior; // The behaviour of the axis (auto, fixed, custom).
715 float MaxLabel[2]; // The widest/tallest axis label.
716 bool TitleAppended; // Track if the title is updated when the label formats
717 // are changed in the Extended Axis Labeling algorithm
718
720
726 double Shift;
728
733
738
743
748
753
758
764
769
774
779
784
785private:
786 vtkAxis(const vtkAxis&) = delete;
787 void operator=(const vtkAxis&) = delete;
788
792 bool InRange(double value);
793};
794
795#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:683
vtkPen * Pen
This object stores the vtkPen that controls how the axis is drawn.
Definition: vtkAxis.h:737
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:709
void SetPoint1(float x, float y)
Set point 1 of the axis (in pixels), this is usually the origin.
double UnscaledMaximumLimit
Definition: vtkAxis.h:695
bool TitleAppended
Definition: vtkAxis.h:716
int Behavior
Definition: vtkAxis.h:714
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:713
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:710
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:696
virtual vtkDoubleArray * GetTickPositions()
An array with the positions of the tick marks along the axis line.
int Position
Definition: vtkAxis.h:680
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:763
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:778
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:703
double Shift
Scaling factor used on this axis, this is used to accurately render very small/large numbers accurate...
Definition: vtkAxis.h:726
double UnscaledMinimumLimit
Definition: vtkAxis.h:694
vtkTextProperty * LabelProperties
Definition: vtkAxis.h:687
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:682
virtual void SetUnscaledRange(double range[2])
Set the logical range of the axis, in plot coordinates.
int NumberOfTicks
Definition: vtkAxis.h:685
vtkStdString Title
Definition: vtkAxis.h:699
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:773
double MinimumLimit
Definition: vtkAxis.h:690
virtual void SetPosition(int position)
Get/set the position of the axis (LEFT, BOTTOM, RIGHT, TOP, PARALLEL).
double UnscaledMinimum
Definition: vtkAxis.h:692
float TickLength
Definition: vtkAxis.h:686
virtual void GetRange(double *range)
Get the logical range of the axis, in plot coordinates.
bool RangeLabelsVisible
Definition: vtkAxis.h:705
vtkVector2f GetPosition1()
Get point 1 of the axis (in pixels), this is usually the origin.
double TickInterval
Definition: vtkAxis.h:684
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:752
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 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:704
void CalculateTitlePosition(vtkVector2f &out)
Calculate the position where the title of the axis would be drawn.
~vtkAxis() override
bool TicksVisible
Definition: vtkAxis.h:707
@ 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:689
virtual vtkStdString GenerateSimpleLabel(double val)
Generate a single label using the current settings when TickLabelAlgorithm is TICK_SIMPLE.
double Minimum
Definition: vtkAxis.h:688
virtual void GenerateTickLabels(double min, double max)
Calculate and assign nice labels/logical label positions.
int Notation
Definition: vtkAxis.h:711
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:725
double NonLogUnscaledMaxLimit
Definition: vtkAxis.h:697
float * Point1
Definition: vtkAxis.h:681
double MaximumLimit
Definition: vtkAxis.h:691
virtual void GetUnscaledRange(double *range)
Get the logical range of the axis, in plot coordinates.
vtkTextProperty * TitleProperties
Definition: vtkAxis.h:700
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:732
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:712
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:742
bool TickMarksDirty
Mark the tick labels as dirty when the min/max value is changed.
Definition: vtkAxis.h:768
float LabelOffset
Definition: vtkAxis.h:706
bool AxisVisible
Definition: vtkAxis.h:708
vtkSmartPointer< vtkStringArray > TickLabels
The labels for the tick marks.
Definition: vtkAxis.h:757
virtual void SetUnscaledRange(double minimum, double maximum)
Set the logical range of the axis, in plot coordinates.
double UnscaledMaximum
Definition: vtkAxis.h:693
bool LogScale
Definition: vtkAxis.h:701
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:702
vtkTimeStamp BuildTime
The point cache is marked dirty until it has been initialized.
Definition: vtkAxis.h:783
vtkSmartPointer< vtkDoubleArray > TickPositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:747
Class for drawing 2D primitives to a graphical context.
Definition: vtkContext2D.h:54
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: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:36
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)