dox/Charts/Core/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 "vtkSmartPointer.h" // For vtkSmartPointer
#include "vtkVector.h"       // For position variables
#include "vtkRect.h"         // For bounding rect
#include "vtkStdString.h"    // For vtkStdString ivars

class vtkContext2D;
class vtkPen;
class vtkFloatArray;
class vtkDoubleArray;
class vtkStringArray;
class vtkTextProperty;

class VTKCHARTSCORE_EXPORT vtkAxis : public vtkContextItem
{
public:
  vtkTypeMacro(vtkAxis, vtkContextItem);
  virtual void PrintSelf(ostream &os, vtkIndent indent);


  enum {
    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);


  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(TicksVisible, bool);
  vtkGetMacro(TicksVisible, bool);


  virtual void SetPrecision(int precision);
  vtkGetMacro(Precision, int);


  enum {
    STANDARD_NOTATION = 0,
    SCIENTIFIC_NOTATION,
    FIXED_NOTATION,

#ifndef VTK_LEGACY_REMOVE
    // deprecated, use the *_NOTATION versions above
    STANDARD = STANDARD_NOTATION,
    SCIENTIFIC = SCIENTIFIC_NOTATION,
    MIXED = FIXED_NOTATION
#endif
  };


  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);


  vtkGetObjectMacro(Pen, vtkPen);


  vtkGetObjectMacro(GridPen, vtkPen);


  vtkSetMacro(TickLabelAlgorithm, int)
  vtkGetMacro(TickLabelAlgorithm, int)


  vtkSetMacro(ScalingFactor, double)
  vtkGetMacro(ScalingFactor, double)
  vtkSetMacro(Shift, double)
  vtkGetMacro(Shift, double)

  virtual void Update();

  virtual bool Paint(vtkContext2D *painter);

  virtual void AutoScale();

  virtual void RecalculateTickSpacing();

  virtual vtkDoubleArray* GetTickPositions();

  virtual vtkFloatArray* GetTickScenePositions();

  virtual vtkStringArray* GetTickLabels();


  virtual bool SetCustomTickPositions(vtkDoubleArray* positions,
                                      vtkStringArray* labels = 0);

  VTK_LEGACY(virtual void SetTickPositions(vtkDoubleArray* positions));

  VTK_LEGACY(virtual void SetTickLabels(vtkStringArray* labels));

  vtkRectf GetBoundingRect(vtkContext2D* painter);

  static double NiceNumber(double number, bool roundUp);


  static double NiceMinMax(double &min, double &max, float pixelRange,
                           float tickPixelSpacing);

//BTX
protected:
  vtkAxis();
  ~vtkAxis();

  void UpdateLogScaleActive(bool updateMinMaxFromUnscaled);

  void GenerateTickLabels(double min, double max);

  void GenerateTickLabels();

  void GenerateLabelFormat(int notation, double n);

  double CalculateNiceMinMax(double &min, double &max);


  double LogScaleTickMark(double number,
                          bool roundUp,
                          bool &niceValue,
                          int &order);

  void GenerateLogSpacedLinearTicks(int order, double min, double max);


  void GenerateLogScaleTickMarks(int order,
                                 double min = 1.0,
                                 double max = 9.0,
                                 bool detailLabels = true);

  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
  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 TicksVisible;   // Should the tick marks be visible.
  int Precision;       // Numerical precision to use, defaults to 2.
  int Notation;        // The notation to use (standard, scientific, mixed)
  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;

  vtkPen* Pen;

  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 &); // Not implemented.
  void operator=(const vtkAxis &);   // Not implemented.


  bool InRange(double value);
//ETX
};

#endif //__vtkAxis_h