vtkAxis.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkAxis.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef vtkAxis_h
#define vtkAxis_h
 
#include "vtkChartsCoreModule.h" // For export macro
#include "vtkContextItem.h"
#include "vtkPen.h"          // For vtkPen
#include "vtkRect.h"         // For bounding rect
#include "vtkSmartPointer.h" // For vtkSmartPointer
#include "vtkStdString.h"    // For vtkStdString ivars
#include "vtkVector.h"       // For position variables
 
class vtkContext2D;
class vtkFloatArray;
class vtkDoubleArray;
class vtkStringArray;
class vtkTextProperty;
 
class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
{
public:
  vtkTypeMacro(vtkAxis, vtkContextItem);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum Location
  {
    LEFT = 0,
    BOTTOM,
    RIGHT,
    TOP,
    PARALLEL
  };
 
  enum
  {
    TICK_SIMPLE = 0,
    TICK_WILKINSON_EXTENDED
  };
 
  static vtkAxis* New();
 
 
  virtual void SetPosition(int position);
  vtkGetMacro(Position, int);
 
 
  void SetPoint1(const vtkVector2f& pos);
  void SetPoint1(float x, float y);
 
 
  vtkGetVector2Macro(Point1, float);
  vtkVector2f GetPosition1();
 
 
  void SetPoint2(const vtkVector2f& pos);
  void SetPoint2(float x, float y);
 
 
  vtkGetVector2Macro(Point2, float);
  vtkVector2f GetPosition2();
 
  virtual void SetNumberOfTicks(int numberOfTicks);
 
 
  vtkGetMacro(NumberOfTicks, int);
 
 
  vtkSetMacro(TickLength, float);
  vtkGetMacro(TickLength, float);
 
 
  vtkGetObjectMacro(LabelProperties, vtkTextProperty);
 
  virtual void SetMinimum(double minimum);
 
 
  vtkGetMacro(Minimum, double);
 
  virtual void SetMaximum(double maximum);
 
 
  vtkGetMacro(Maximum, double);
 
  virtual void SetUnscaledMinimum(double minimum);
 
 
  vtkGetMacro(UnscaledMinimum, double);
 
  virtual void SetUnscaledMaximum(double maximum);
 
 
  vtkGetMacro(UnscaledMaximum, double);
 
 
  virtual void SetRange(double minimum, double maximum);
  virtual void SetRange(double range[2]);
  virtual void SetUnscaledRange(double minimum, double maximum);
  virtual void SetUnscaledRange(double range[2]);
 
 
  virtual void GetRange(double* range);
  virtual void GetUnscaledRange(double* range);
 
  virtual void SetMinimumLimit(double lowest);
 
 
  vtkGetMacro(MinimumLimit, double);
 
  virtual void SetMaximumLimit(double highest);
 
 
  vtkGetMacro(MaximumLimit, double);
 
  virtual void SetUnscaledMinimumLimit(double lowest);
 
 
  vtkGetMacro(UnscaledMinimumLimit, double);
 
  virtual void SetUnscaledMaximumLimit(double highest);
 
 
  vtkGetMacro(UnscaledMaximumLimit, double);
 
 
  vtkGetVector2Macro(Margins, int);
 
 
  vtkSetVector2Macro(Margins, int);
 
 
  virtual void SetTitle(const vtkStdString& title);
  virtual vtkStdString GetTitle();
 
 
  vtkGetObjectMacro(TitleProperties, vtkTextProperty);
 
 
  vtkGetMacro(LogScaleActive, bool);
 
 
  vtkGetMacro(LogScale, bool);
  virtual void SetLogScale(bool logScale);
  vtkBooleanMacro(LogScale, bool);
 
 
  vtkSetMacro(GridVisible, bool);
  vtkGetMacro(GridVisible, bool);
 
 
  vtkSetMacro(LabelsVisible, bool);
  vtkGetMacro(LabelsVisible, bool);
 
 
  vtkSetMacro(RangeLabelsVisible, bool);
  vtkGetMacro(RangeLabelsVisible, bool);
 
 
  vtkSetMacro(LabelOffset, float);
  vtkGetMacro(LabelOffset, float);
 
 
  vtkSetMacro(TicksVisible, bool);
  vtkGetMacro(TicksVisible, bool);
 
 
  vtkSetMacro(AxisVisible, bool);
  vtkGetMacro(AxisVisible, bool);
 
 
  vtkSetMacro(TitleVisible, bool);
  vtkGetMacro(TitleVisible, bool);
 
 
  virtual void SetPrecision(int precision);
  vtkGetMacro(Precision, int);
 
  enum
  {
    STANDARD_NOTATION = 0,
    SCIENTIFIC_NOTATION,
    FIXED_NOTATION,
    PRINTF_NOTATION
  };
 
 
  virtual void SetLabelFormat(const std::string& fmt);
  vtkGetMacro(LabelFormat, std::string);
 
 
  vtkSetMacro(RangeLabelFormat, std::string);
  vtkGetMacro(RangeLabelFormat, std::string);
 
 
  virtual void SetNotation(int notation);
  vtkGetMacro(Notation, int);
 
  enum
  {
    AUTO = 0, // Automatically scale the axis to view all data that is visible.
    FIXED,    // Use a fixed axis range and make no attempt to rescale.
    CUSTOM    // Deprecated, use the tick label settings instead.
  };
 
 
  vtkSetMacro(Behavior, int);
  vtkGetMacro(Behavior, int);
 
 
  vtkSetSmartPointerMacro(Pen, vtkPen);
  vtkGetObjectMacro(Pen, vtkPen);
 
 
  vtkSetSmartPointerMacro(GridPen, vtkPen);
  vtkGetObjectMacro(GridPen, vtkPen);
 
 
  vtkSetMacro(TickLabelAlgorithm, int);
  vtkGetMacro(TickLabelAlgorithm, int);
 
 
  vtkSetMacro(ScalingFactor, double);
  vtkGetMacro(ScalingFactor, double);
  vtkSetMacro(Shift, double);
  vtkGetMacro(Shift, double);
 
  void Update() override;
 
  bool Paint(vtkContext2D* painter) override;
 
  virtual void AutoScale();
 
  virtual void RecalculateTickSpacing();
 
  virtual vtkDoubleArray* GetTickPositions();
 
  virtual vtkFloatArray* GetTickScenePositions();
 
  virtual vtkStringArray* GetTickLabels();
 
  virtual bool SetCustomTickPositions(vtkDoubleArray* positions, vtkStringArray* labels = nullptr);
 
  vtkRectf GetBoundingRect(vtkContext2D* painter);
 
  static double NiceNumber(double number, bool roundUp);
 
  static double NiceMinMax(double& min, double& max, float pixelRange, float tickPixelSpacing);
 
  virtual vtkStdString GenerateSimpleLabel(double val);
 
  bool Hit(const vtkContextMouseEvent& mouse) override;
 
protected:
  vtkAxis();
  ~vtkAxis() override;
 
  void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);
 
  virtual void GenerateTickLabels(double min, double max);
 
  virtual void GenerateTickLabels();
 
  virtual void GenerateLabelFormat(int notation, double n);
 
  virtual vtkStdString GenerateSprintfLabel(double value, const std::string& format);
 
  double CalculateNiceMinMax(double& min, double& max);
 
  double LogScaleTickMark(double number, bool roundUp, bool& niceValue, int& order);
 
  virtual void GenerateLogSpacedLinearTicks(int order, double min, double max);
 
  void GenerateLogScaleTickMarks(
    int order, double min = 1.0, double max = 9.0, bool detailLabels = true);
 
  void CalculateTitlePosition(vtkVector2f& out);
 
  int Position;  // The position of the axis (LEFT, BOTTOM, RIGHT, TOP)
  float* Point1; // The position of point 1 (usually the origin)
  float* Point2; // The position of point 2 (usually the terminus)
  vtkVector2f Position1, Position2;
  double TickInterval;              // Interval between tick marks in plot space
  int NumberOfTicks;                // The number of tick marks to draw
  float TickLength;                 // The length of the tick marks
  vtkTextProperty* LabelProperties; // Text properties for the labels.
  double Minimum;                   // Minimum value of the axis
  double Maximum;                   // Maximum values of the axis
  double MinimumLimit;              // Lowest possible value for Minimum
  double MaximumLimit;              // Highest possible value for Maximum
  double UnscaledMinimum;           // UnscaledMinimum value of the axis
  double UnscaledMaximum;           // UnscaledMaximum values of the axis
  double UnscaledMinimumLimit;      // Lowest possible value for UnscaledMinimum
  double UnscaledMaximumLimit;      // Highest possible value for UnscaledMaximum
  double NonLogUnscaledMinLimit;    // Saved UnscaledMinimumLimit (when !LogActive)
  double NonLogUnscaledMaxLimit;    // Saved UnscaledMinimumLimit (when !LogActive)
  int Margins[2];                   // Horizontal/vertical margins for the axis
  vtkStdString Title;               // The text label drawn on the axis
  vtkTextProperty* TitleProperties; // Text properties for the axis title
  bool LogScale;                    // *Should* the axis use a log scale?
  bool LogScaleActive;              // *Is* the axis using a log scale?
  bool GridVisible;                 // Whether the grid for the axis should be drawn
  bool LabelsVisible;               // Should the axis labels be visible
  bool RangeLabelsVisible;          // Should range labels be visible?
  float LabelOffset;                // Offset of label from the tick mark
  bool TicksVisible;                // Should the tick marks be visible.
  bool AxisVisible;                 // Should the axis line be visible.
  bool TitleVisible;                // Should the title be visible.
  int Precision;                    // Numerical precision to use, defaults to 2.
  int Notation;                     // The notation to use (standard, scientific, mixed)
  std::string LabelFormat;          // The printf-style format string used for labels.
  std::string RangeLabelFormat;     // The printf-style format string used for range labels.
  int Behavior;                     // The behaviour of the axis (auto, fixed, custom).
  float MaxLabel[2];                // The widest/tallest axis label.
  bool TitleAppended;               // Track if the title is updated when the label formats
                                    // are changed in the Extended Axis Labeling algorithm
 
 
  double ScalingFactor;
  double Shift;
 
  bool CustomTickLabels;
 
  vtkSmartPointer<vtkPen> Pen;
 
  vtkSmartPointer<vtkPen> GridPen;
 
  vtkSmartPointer<vtkDoubleArray> TickPositions;
 
  vtkSmartPointer<vtkFloatArray> TickScenePositions;
 
  vtkSmartPointer<vtkStringArray> TickLabels;
 
  bool UsingNiceMinMax;
 
  bool TickMarksDirty;
 
  bool Resized;
 
  int TickLabelAlgorithm;
 
  vtkTimeStamp BuildTime;
 
private:
  vtkAxis(const vtkAxis&) = delete;
  void operator=(const vtkAxis&) = delete;
 
  bool InRange(double value);
};
 
#endif // vtkAxis_h