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
160#ifndef vtkAxis_h
161#define vtkAxis_h
162
163#include "vtkChartsCoreModule.h" // For export macro
164#include "vtkContextItem.h"
165#include "vtkRect.h" // For bounding rect
166#include "vtkSmartPointer.h" // For vtkSmartPointer
167#include "vtkStdString.h" // For vtkStdString ivars
168#include "vtkVector.h" // For position variables
169
170class vtkContext2D;
171class vtkPen;
172class vtkFloatArray;
173class vtkDoubleArray;
174class vtkStringArray;
175class vtkTextProperty;
176
177class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
178{
179public:
180 vtkTypeMacro(vtkAxis, vtkContextItem);
181 void PrintSelf(ostream& os, vtkIndent indent) override;
182
188 {
189 LEFT = 0,
193 PARALLEL
194 };
195
196 enum
197 {
198 TICK_SIMPLE = 0,
199 TICK_WILKINSON_EXTENDED
200 };
201
205 static vtkAxis* New();
206
208
211 virtual void SetPosition(int position);
212 vtkGetMacro(Position, int);
214
216
219 void SetPoint1(const vtkVector2f& pos);
220 void SetPoint1(float x, float y);
222
224
227 vtkGetVector2Macro(Point1, float);
230
232
235 void SetPoint2(const vtkVector2f& pos);
236 void SetPoint2(float x, float y);
238
240
243 vtkGetVector2Macro(Point2, float);
246
251 virtual void SetNumberOfTicks(int numberOfTicks);
252
254
257 vtkGetMacro(NumberOfTicks, int);
259
261
264 vtkSetMacro(TickLength, float);
265 vtkGetMacro(TickLength, float);
267
269
273 vtkGetObjectMacro(LabelProperties, vtkTextProperty);
275
281 virtual void SetMinimum(double minimum);
282
284
289 vtkGetMacro(Minimum, double);
291
297 virtual void SetMaximum(double maximum);
298
300
305 vtkGetMacro(Maximum, double);
307
313 virtual void SetUnscaledMinimum(double minimum);
314
316
319 vtkGetMacro(UnscaledMinimum, double);
321
325 virtual void SetUnscaledMaximum(double maximum);
326
328
331 vtkGetMacro(UnscaledMaximum, double);
333
335
344 virtual void SetRange(double minimum, double maximum);
345 virtual void SetRange(double range[2]);
346 virtual void SetUnscaledRange(double minimum, double maximum);
347 virtual void SetUnscaledRange(double range[2]);
349
351
358 virtual void GetRange(double* range);
359 virtual void GetUnscaledRange(double* range);
361
365 virtual void SetMinimumLimit(double lowest);
366
368
371 vtkGetMacro(MinimumLimit, double);
373
377 virtual void SetMaximumLimit(double highest);
378
380
383 vtkGetMacro(MaximumLimit, double);
385
389 virtual void SetUnscaledMinimumLimit(double lowest);
390
392
395 vtkGetMacro(UnscaledMinimumLimit, double);
397
401 virtual void SetUnscaledMaximumLimit(double highest);
402
404
407 vtkGetMacro(UnscaledMaximumLimit, double);
409
411
414 vtkGetVector2Macro(Margins, int);
416
418
421 vtkSetVector2Macro(Margins, int);
423
425
428 virtual void SetTitle(const vtkStdString& title);
431
433
436 vtkGetObjectMacro(TitleProperties, vtkTextProperty);
438
440
452 vtkGetMacro(LogScaleActive, bool);
454
456
462 vtkGetMacro(LogScale, bool);
463 virtual void SetLogScale(bool logScale);
464 vtkBooleanMacro(LogScale, bool);
466
468
471 vtkSetMacro(GridVisible, bool);
472 vtkGetMacro(GridVisible, bool);
474
476
479 vtkSetMacro(LabelsVisible, bool);
480 vtkGetMacro(LabelsVisible, bool);
482
484
487 vtkSetMacro(RangeLabelsVisible, bool);
488 vtkGetMacro(RangeLabelsVisible, bool);
490
492
495 vtkSetMacro(LabelOffset, float);
496 vtkGetMacro(LabelOffset, float);
498
500
503 vtkSetMacro(TicksVisible, bool);
504 vtkGetMacro(TicksVisible, bool);
506
508
511 vtkSetMacro(AxisVisible, bool);
512 vtkGetMacro(AxisVisible, bool);
514
516
519 vtkSetMacro(TitleVisible, bool);
520 vtkGetMacro(TitleVisible, bool);
522
524
528 virtual void SetPrecision(int precision);
529 vtkGetMacro(Precision, int);
531
535 enum
536 {
537 STANDARD_NOTATION = 0,
540 PRINTF_NOTATION
541 };
542
544
548 virtual void SetLabelFormat(const std::string& fmt);
549 vtkGetMacro(LabelFormat, std::string);
551
553
558 vtkSetMacro(RangeLabelFormat, std::string);
559 vtkGetMacro(RangeLabelFormat, std::string);
561
563
568 virtual void SetNotation(int notation);
569 vtkGetMacro(Notation, int);
571
575 enum
576 {
577 AUTO = 0, // Automatically scale the axis to view all data that is visible.
578 FIXED, // Use a fixed axis range and make no attempt to rescale.
579 CUSTOM // Deprecated, use the tick label settings instead.
580 };
581
583
586 vtkSetMacro(Behavior, int);
587 vtkGetMacro(Behavior, int);
589
591
594 vtkGetObjectMacro(Pen, vtkPen);
596
598
601 vtkGetObjectMacro(GridPen, vtkPen);
603
605
612 vtkSetMacro(TickLabelAlgorithm, int);
613 vtkGetMacro(TickLabelAlgorithm, int);
615
617
621 vtkSetMacro(ScalingFactor, double);
622 vtkGetMacro(ScalingFactor, double);
623 vtkSetMacro(Shift, double);
624 vtkGetMacro(Shift, double);
626
631 void Update() override;
632
636 bool Paint(vtkContext2D* painter) override;
637
644 virtual void AutoScale();
645
651
657
663
668
676 virtual bool SetCustomTickPositions(vtkDoubleArray* positions, vtkStringArray* labels = nullptr);
677
685
691 static double NiceNumber(double number, bool roundUp);
692
697 static double NiceMinMax(double& min, double& max, float pixelRange, float tickPixelSpacing);
698
704
708 bool Hit(const vtkContextMouseEvent& mouse) override;
709
710protected:
712 ~vtkAxis() override;
713
722 void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
723
727 virtual void GenerateTickLabels(double min, double max);
728
732 virtual void GenerateTickLabels();
733
734 virtual void GenerateLabelFormat(int notation, double n);
735
739 virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
740
745 double CalculateNiceMinMax(double& min, double& max);
746
756 double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
757
769 virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
770
782 int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
783
788
789 int Position; // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
790 float* Point1; // The position of point 1 (usually the origin)
791 float* Point2; // The position of point 2 (usually the terminus)
793 double TickInterval; // Interval between tick marks in plot space
794 int NumberOfTicks; // The number of tick marks to draw
795 float TickLength; // The length of the tick marks
796 vtkTextProperty* LabelProperties; // Text properties for the labels.
797 double Minimum; // Minimum value of the axis
798 double Maximum; // Maximum values of the axis
799 double MinimumLimit; // Lowest possible value for Minimum
800 double MaximumLimit; // Highest possible value for Maximum
801 double UnscaledMinimum; // UnscaledMinimum value of the axis
802 double UnscaledMaximum; // UnscaledMaximum values of the axis
803 double UnscaledMinimumLimit; // Lowest possible value for UnscaledMinimum
804 double UnscaledMaximumLimit; // Highest possible value for UnscaledMaximum
805 double NonLogUnscaledMinLimit; // Saved UnscaledMinimumLimit (when !LogActive)
806 double NonLogUnscaledMaxLimit; // Saved UnscaledMinimumLimit (when !LogActive)
807 int Margins[2]; // Horizontal/vertical margins for the axis
808 vtkStdString Title; // The text label drawn on the axis
809 vtkTextProperty* TitleProperties; // Text properties for the axis title
810 bool LogScale; // *Should* the axis use a log scale?
811 bool LogScaleActive; // *Is* the axis using a log scale?
812 bool GridVisible; // Whether the grid for the axis should be drawn
813 bool LabelsVisible; // Should the axis labels be visible
814 bool RangeLabelsVisible; // Should range labels be visible?
815 float LabelOffset; // Offset of label from the tick mark
816 bool TicksVisible; // Should the tick marks be visible.
817 bool AxisVisible; // Should the axis line be visible.
818 bool TitleVisible; // Should the title be visible.
819 int Precision; // Numerical precision to use, defaults to 2.
820 int Notation; // The notation to use (standard, scientific, mixed)
821 std::string LabelFormat; // The printf-style format string used for labels.
822 std::string RangeLabelFormat; // The printf-style format string used for range labels.
823 int Behavior; // The behaviour of the axis (auto, fixed, custom).
824 float MaxLabel[2]; // The widest/tallest axis label.
825 bool TitleAppended; // Track if the title is updated when the label formats
826 // are changed in the Extended Axis Labeling algorithm
827
829
835 double Shift;
837
842
847
852
857
862
867
873
878
883
888
893
894private:
895 vtkAxis(const vtkAxis&) = delete;
896 void operator=(const vtkAxis&) = delete;
897
901 bool InRange(double value);
902};
903
904#endif // vtkAxis_h
takes care of drawing 2D axes
Definition: vtkAxis.h:178
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:792
vtkPen * Pen
This object stores the vtkPen that controls how the axis is drawn.
Definition: vtkAxis.h:846
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:818
void SetPoint1(float x, float y)
Set point 1 of the axis (in pixels), this is usually the origin.
double UnscaledMaximumLimit
Definition: vtkAxis.h:804
bool TitleAppended
Definition: vtkAxis.h:825
int Behavior
Definition: vtkAxis.h:823
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:822
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:819
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:805
virtual vtkDoubleArray * GetTickPositions()
An array with the positions of the tick marks along the axis line.
int Position
Definition: vtkAxis.h:789
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:872
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:887
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:812
double Shift
Scaling factor used on this axis, this is used to accurately render very small/large numbers accurate...
Definition: vtkAxis.h:835
double UnscaledMinimumLimit
Definition: vtkAxis.h:803
vtkTextProperty * LabelProperties
Definition: vtkAxis.h:796
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:791
virtual void SetUnscaledRange(double range[2])
Set the logical range of the axis, in plot coordinates.
int NumberOfTicks
Definition: vtkAxis.h:794
vtkStdString Title
Definition: vtkAxis.h:808
void SetPoint1(const vtkVector2f &pos)
Set point 1 of the axis (in pixels), this is usually the origin.
@ FIXED
Definition: vtkAxis.h:578
bool Resized
Flag to indicate that the axis has been resized.
Definition: vtkAxis.h:882
double MinimumLimit
Definition: vtkAxis.h:799
virtual void SetPosition(int position)
Get/set the position of the axis (LEFT, BOTTOM, RIGHT, TOP, PARALLEL).
double UnscaledMinimum
Definition: vtkAxis.h:801
float TickLength
Definition: vtkAxis.h:795
virtual void GetRange(double *range)
Get the logical range of the axis, in plot coordinates.
bool RangeLabelsVisible
Definition: vtkAxis.h:814
vtkVector2f GetPosition1()
Get point 1 of the axis (in pixels), this is usually the origin.
double TickInterval
Definition: vtkAxis.h:793
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:861
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:813
void CalculateTitlePosition(vtkVector2f &out)
Calculate the position where the title of the axis would be drawn.
~vtkAxis() override
bool TicksVisible
Definition: vtkAxis.h:816
@ FIXED_NOTATION
Definition: vtkAxis.h:539
@ SCIENTIFIC_NOTATION
Definition: vtkAxis.h:538
Location
Enumeration of the axis locations in a conventional XY chart.
Definition: vtkAxis.h:188
@ TOP
Definition: vtkAxis.h:192
@ BOTTOM
Definition: vtkAxis.h:190
@ RIGHT
Definition: vtkAxis.h:191
double Maximum
Definition: vtkAxis.h:798
virtual vtkStdString GenerateSimpleLabel(double val)
Generate a single label using the current settings when TickLabelAlgorithm is TICK_SIMPLE.
double Minimum
Definition: vtkAxis.h:797
virtual void GenerateTickLabels(double min, double max)
Calculate and assign nice labels/logical label positions.
int Notation
Definition: vtkAxis.h:820
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:834
double NonLogUnscaledMaxLimit
Definition: vtkAxis.h:806
float * Point1
Definition: vtkAxis.h:790
double MaximumLimit
Definition: vtkAxis.h:800
virtual void GetUnscaledRange(double *range)
Get the logical range of the axis, in plot coordinates.
vtkTextProperty * TitleProperties
Definition: vtkAxis.h:809
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:841
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:821
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:851
bool TickMarksDirty
Mark the tick labels as dirty when the min/max value is changed.
Definition: vtkAxis.h:877
float LabelOffset
Definition: vtkAxis.h:815
bool AxisVisible
Definition: vtkAxis.h:817
vtkSmartPointer< vtkStringArray > TickLabels
The labels for the tick marks.
Definition: vtkAxis.h:866
virtual void SetUnscaledRange(double minimum, double maximum)
Set the logical range of the axis, in plot coordinates.
double UnscaledMaximum
Definition: vtkAxis.h:802
bool LogScale
Definition: vtkAxis.h:810
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:811
vtkTimeStamp BuildTime
The point cache is marked dirty until it has been initialized.
Definition: vtkAxis.h:892
vtkSmartPointer< vtkDoubleArray > TickPositions
Position of tick marks in screen coordinates.
Definition: vtkAxis.h:856
Class for drawing 2D primitives to a graphical context.
Definition: vtkContext2D.h:73
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:113
provides a pen that draws the outlines of shapes drawn by vtkContext2D.
Definition: vtkPen.h:136
Hold a reference to a vtkObjectBase instance.
Wrapper around std::string to keep symbols short.
Definition: vtkStdString.h:105
a vtkAbstractArray subclass for strings
represent text properties.
record modification and/or execution time
Definition: vtkTimeStamp.h:52
#define max(a, b)