vtkChartXYZ.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkChartXYZ.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 vtkChartXYZ_h
#define vtkChartXYZ_h
 
#include "vtkChartsCoreModule.h" // For export macro
#include "vtkColor.h"            // For vtkColor4ub
#include "vtkContextItem.h"
#include "vtkNew.h"          // For ivars
#include "vtkRect.h"         // For vtkRectf ivars
#include "vtkSmartPointer.h" // For ivars
#include "vtkStdString.h"    // For vtkStdString
#include "vtkTextProperty.h" // For axes text properties
#include <vector>            // For ivars
 
class vtkAnnotationLink;
class vtkAxis;
class vtkContext3D;
class vtkContextMouseEvent;
class vtkPen;
class vtkPlaneCollection;
class vtkPlot3D;
class vtkTable;
class vtkTransform;
class vtkUnsignedCharArray;
 
class VTKCHARTSCORE_EXPORT vtkChartXYZ : public vtkContextItem
{
public:
  vtkTypeMacro(vtkChartXYZ, vtkContextItem);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkChartXYZ* New();
 
  void SetGeometry(const vtkRectf& bounds);
 
  void SetMargins(const vtkVector4i& margins);
 
  vtkSetMacro(Angle, double);
 
  void SetAroundX(bool isX);
 
  virtual void SetAnnotationLink(vtkAnnotationLink* link);
 
  vtkAxis* GetAxis(int axis);
 
  virtual void SetAxis(int axisIndex, vtkAxis* axis);
 
 
  void SetAxisColor(const vtkColor4ub& color);
  vtkColor4ub GetAxisColor();
 
  vtkTextProperty* GetAxesTextProperty();
 
  vtkSetMacro(XAxisLabel, vtkStdString);
 
  vtkSetMacro(YAxisLabel, vtkStdString);
 
  vtkSetMacro(ZAxisLabel, vtkStdString);
 
  vtkSetMacro(EnsureOuterEdgeAxisLabelling, bool);
 
  vtkSetMacro(AutoRotate, bool);
 
  void SetDecorateAxes(bool b);
 
  void SetFitToScene(bool b);
 
  void Update() override;
 
  bool Paint(vtkContext2D* painter) override;
 
  virtual vtkIdType AddPlot(vtkPlot3D* plot);
 
  virtual bool RemovePlot(vtkPlot3D* plot);
 
  void ClearPlots();
 
  void RecalculateBounds();
 
  void RecalculateTransform();
 
  bool Hit(const vtkContextMouseEvent& mouse) override;
 
  bool MouseButtonPressEvent(const vtkContextMouseEvent& mouse) override;
 
  bool MouseMoveEvent(const vtkContextMouseEvent& mouse) override;
 
  bool MouseWheelEvent(const vtkContextMouseEvent& mouse, int delta) override;
 
  bool KeyPressEvent(const vtkContextKeyEvent& key) override;
 
  void SetClippingPlanesEnabled(bool);
 
  vtkGetMacro(ClippingPlanesEnabled, bool);
 
  vtkSetMacro(ScaleBoxWithPlot, bool);
 
  vtkGetMacro(ScaleBoxWithPlot, bool);
 
protected:
  vtkChartXYZ();
  ~vtkChartXYZ() override;
 
  enum RotateDirection
  {
    LEFT,
    RIGHT,
    UP,
    DOWN
  };
 
  enum AxisState
  {
    VERTICAL,
    VERTICAL_2,
    HORIZONTAL,
    HORIZONTAL_2,
    DO_NOT_LABEL,
    STANDARD
  };
 
  enum Direction
  {
    NORTH,
    NORTH_EAST,
    EAST,
    SOUTH_EAST,
    SOUTH,
    SOUTH_WEST,
    WEST,
    NORTH_WEST
  };
 
  virtual void CalculateTransforms();
 
  bool CalculatePlotTransform(vtkAxis* x, vtkAxis* y, vtkAxis* z, vtkTransform* transform);
 
  bool Rotate(const vtkContextMouseEvent& mouse);
 
  bool Rotate(const RotateDirection rotateDirection);
 
  bool Pan(const vtkContextMouseEvent& mouse);
 
  bool Zoom(const vtkContextMouseEvent& mouse);
 
  bool Spin(const vtkContextMouseEvent& mouse);
 
  void LookDownX();
 
  void LookDownY();
 
  void LookDownZ();
 
  void LookUpX();
 
  void LookUpY();
 
  void LookUpZ();
 
  bool CheckForSceneResize();
 
  void RescaleAxes();
 
  void ScaleUpAxes();
 
  void ScaleDownAxes();
 
  void ZoomAxes(int delta);
 
  void InitializeAxesBoundaryPoints();
 
  void InitializeFutureBox();
 
  void ComputeDataBounds();
 
  void DrawAxes(vtkContext3D* context);
 
  void DetermineWhichAxesToLabel();
 
  void NewDetermineWhichAxesToLabel();
 
  void LegacyDetermineWhichAxesToLabel();
  void DrawTickMarks(vtkContext2D* painter);
 
  void DrawAxesLabels(vtkContext2D* painter);
 
  void GetOffsetForAxisLabel(int axis, float* bounds, float* offset);
 
  double CalculateNiceMinMax(double& min, double& max, int axis);
 
  void GetClippingPlaneEquation(int i, double* planeEquation);
 
  std::size_t GetMarginLeft() const;
 
  std::size_t GetMarginBottom() const;
 
  std::size_t GetPlotWidth() const;
 
  std::size_t GetPlotHeight() const;
 
  enum
  {
    USE_MARGINS_AND_SCENE_SIZE,
    USE_GEOMETRY
  } SizeStrategy = USE_GEOMETRY;
 
  vtkVector4i Margins = vtkVector4i(40, 40, 40, 40);
 
  vtkRectf Geometry = vtkRectf(40, 40, 120, 120);
 
  std::vector<vtkSmartPointer<vtkAxis>> Axes;
 
  bool AutoRotate = false;
 
  bool IsX = false;
 
  double Angle = 0;
 
  bool DrawAxesDecoration = true;
 
  bool FitToScene = true;
 
  vtkNew<vtkTransform> ContextTransform;
 
  vtkNew<vtkTransform> PlotTransform;
 
  vtkNew<vtkTransform> Box;
 
  vtkNew<vtkTransform> Rotation;
 
  vtkNew<vtkTransform> Translation;
 
  vtkNew<vtkTransform> Scale;
 
  vtkNew<vtkTransform> BoxScale;
 
  vtkNew<vtkTransform> FutureBox;
 
  vtkNew<vtkTransform> FutureBoxScale;
 
  vtkNew<vtkPen> Pen;
 
  vtkNew<vtkPen> AxisPen;
 
  vtkSmartPointer<vtkAnnotationLink> Link;
 
  std::vector<vtkPlot3D*> Plots;
 
  std::vector<vtkIdType> FreePlaces;
 
  vtkNew<vtkTextProperty> AxesTextProperty;
 
  std::string XAxisLabel;
 
  std::string YAxisLabel;
 
  std::string ZAxisLabel;
 
  bool EnsureOuterEdgeAxisLabelling = false;
  vtkNew<vtkPlaneCollection> BoundingCube;
 
  float AxesBoundaryPoints[8][3];
 
  float TickLabelOffset[3][2];
 
  int SceneHeight;
 
  int SceneWidth;
 
 
  int XAxisToLabel[3];
  int YAxisToLabel[3];
  int ZAxisToLabel[3];
 
  int DirectionToData[3];
 
  double DataBounds[4];
 
  bool ClippingPlanesEnabled = true;
 
  bool ScaleBoxWithPlot = true;
 
private:
  vtkChartXYZ(const vtkChartXYZ&) = delete;
  void operator=(const vtkChartXYZ&) = delete;
};
 
#endif