vtkChartXYZ.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause

#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 "vtkWrappingHints.h" // For VTK_MARSHALAUTO
#include <vector>             // For ivars

VTK_ABI_NAMESPACE_BEGIN
class vtkAnnotationLink;
class vtkAxis;
class vtkContext3D;
class vtkContextMouseEvent;
class vtkPen;
class vtkPlaneCollection;
class vtkPlot3D;
class vtkTable;
class vtkTransform;
class vtkUnsignedCharArray;

class VTKCHARTSCORE_EXPORT VTK_MARSHALAUTO 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(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;
};

VTK_ABI_NAMESPACE_END
#endif