vtkCubeAxesActor2D.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkCubeAxesActor2D.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 vtkCubeAxesActor2D_h
#define vtkCubeAxesActor2D_h
 
#include "vtkActor2D.h"
#include "vtkRenderingAnnotationModule.h" // For export macro
 
class vtkAlgorithmOutput;
class vtkAxisActor2D;
class vtkCamera;
class vtkCubeAxesActor2DConnection;
class vtkDataSet;
class vtkTextProperty;
 
class VTKRENDERINGANNOTATION_EXPORT vtkCubeAxesActor2D : public vtkActor2D
{
public:
  vtkTypeMacro(vtkCubeAxesActor2D, vtkActor2D);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkCubeAxesActor2D* New();
 
 
  int RenderOverlay(vtkViewport*) override;
  int RenderOpaqueGeometry(vtkViewport*) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport*) override { return 0; }
 
  vtkTypeBool HasTranslucentPolygonalGeometry() override;
 
 
  virtual void SetInputConnection(vtkAlgorithmOutput*);
  virtual void SetInputData(vtkDataSet*);
  virtual vtkDataSet* GetInput();
 
 
  void SetViewProp(vtkProp* prop);
  vtkGetObjectMacro(ViewProp, vtkProp);
 
 
  vtkSetVector6Macro(Bounds, double);
  double* GetBounds() VTK_SIZEHINT(6) override;
  void GetBounds(
    double& xmin, double& xmax, double& ymin, double& ymax, double& zmin, double& zmax);
  void GetBounds(double bounds[6]);
 
 
  vtkSetVector6Macro(Ranges, double);
  double* GetRanges() VTK_SIZEHINT(6);
  void GetRanges(
    double& xmin, double& xmax, double& ymin, double& ymax, double& zmin, double& zmax);
  void GetRanges(double ranges[6]);
 
 
  vtkSetMacro(XOrigin, double);
  vtkSetMacro(YOrigin, double);
  vtkSetMacro(ZOrigin, double);
 
 
  vtkSetMacro(UseRanges, vtkTypeBool);
  vtkGetMacro(UseRanges, vtkTypeBool);
  vtkBooleanMacro(UseRanges, vtkTypeBool);
 
 
  virtual void SetCamera(vtkCamera*);
  vtkGetObjectMacro(Camera, vtkCamera);
 
  enum FlyMode
  {
    VTK_FLY_OUTER_EDGES = 0,
    VTK_FLY_CLOSEST_TRIAD = 1,
    VTK_FLY_NONE = 2
  };
 
 
  vtkSetClampMacro(FlyMode, int, VTK_FLY_OUTER_EDGES, VTK_FLY_NONE);
  vtkGetMacro(FlyMode, int);
  void SetFlyModeToOuterEdges() { this->SetFlyMode(VTK_FLY_OUTER_EDGES); }
  void SetFlyModeToClosestTriad() { this->SetFlyMode(VTK_FLY_CLOSEST_TRIAD); }
  void SetFlyModeToNone() { this->SetFlyMode(VTK_FLY_NONE); }
 
 
  vtkSetMacro(Scaling, vtkTypeBool);
  vtkGetMacro(Scaling, vtkTypeBool);
  vtkBooleanMacro(Scaling, vtkTypeBool);
 
 
  vtkSetClampMacro(NumberOfLabels, int, 0, 50);
  vtkGetMacro(NumberOfLabels, int);
 
 
  vtkSetStringMacro(XLabel);
  vtkGetStringMacro(XLabel);
  vtkSetStringMacro(YLabel);
  vtkGetStringMacro(YLabel);
  vtkSetStringMacro(ZLabel);
  vtkGetStringMacro(ZLabel);
 
  vtkAxisActor2D* GetXAxisActor2D() { return this->XAxis; }
  vtkAxisActor2D* GetYAxisActor2D() { return this->YAxis; }
  vtkAxisActor2D* GetZAxisActor2D() { return this->ZAxis; }
 
 
  virtual void SetAxisTitleTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(AxisTitleTextProperty, vtkTextProperty);
 
 
  virtual void SetAxisLabelTextProperty(vtkTextProperty* p);
  vtkGetObjectMacro(AxisLabelTextProperty, vtkTextProperty);
 
 
  vtkSetStringMacro(LabelFormat);
  vtkGetStringMacro(LabelFormat);
 
 
  vtkSetClampMacro(FontFactor, double, 0.1, 2.0);
  vtkGetMacro(FontFactor, double);
 
 
  vtkSetClampMacro(Inertia, int, 1, VTK_INT_MAX);
  vtkGetMacro(Inertia, int);
 
 
  vtkSetClampMacro(ShowActualBounds, int, 0, 1);
  vtkGetMacro(ShowActualBounds, int);
 
 
  vtkSetMacro(CornerOffset, double);
  vtkGetMacro(CornerOffset, double);
 
  void ReleaseGraphicsResources(vtkWindow*) override;
 
 
  vtkSetMacro(XAxisVisibility, vtkTypeBool);
  vtkGetMacro(XAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(XAxisVisibility, vtkTypeBool);
  vtkSetMacro(YAxisVisibility, vtkTypeBool);
  vtkGetMacro(YAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(YAxisVisibility, vtkTypeBool);
  vtkSetMacro(ZAxisVisibility, vtkTypeBool);
  vtkGetMacro(ZAxisVisibility, vtkTypeBool);
  vtkBooleanMacro(ZAxisVisibility, vtkTypeBool);
 
  void ShallowCopy(vtkCubeAxesActor2D* actor);
 
protected:
  vtkCubeAxesActor2D();
  ~vtkCubeAxesActor2D() override;
 
  vtkCubeAxesActor2DConnection* ConnectionHolder;
 
  vtkProp* ViewProp;     // Define bounds from actor/assembly, or
  double Bounds[6];      // Define bounds explicitly
  double Ranges[6];      // Define ranges explicitly
  vtkTypeBool UseRanges; // Flag to use ranges or not
 
  vtkCamera* Camera;
  int FlyMode;
  vtkTypeBool Scaling;
 
  vtkAxisActor2D* XAxis;
  vtkAxisActor2D* YAxis;
  vtkAxisActor2D* ZAxis;
 
  vtkTextProperty* AxisTitleTextProperty;
  vtkTextProperty* AxisLabelTextProperty;
 
  vtkTimeStamp BuildTime;
 
  int NumberOfLabels;
  char* XLabel;
  char* YLabel;
  char* ZLabel;
  char* Labels[3];
 
  vtkTypeBool XAxisVisibility;
  vtkTypeBool YAxisVisibility;
  vtkTypeBool ZAxisVisibility;
 
  char* LabelFormat;
  double FontFactor;
  double CornerOffset;
  int Inertia;
  int RenderCount;
  int InertiaAxes[8];
 
  int RenderSomething;
 
  // Always show the actual bounds of the object
  int ShowActualBounds;
 
  double XOrigin;
  double YOrigin;
  double ZOrigin;
 
  // various helper methods
  void TransformBounds(vtkViewport* viewport, double bounds[6], double pts[8][3]);
  int ClipBounds(vtkViewport* viewport, double pts[8][3], double bounds[6]);
  double EvaluatePoint(double planes[24], double x[3]);
  double EvaluateBounds(double planes[24], double bounds[6]);
  void AdjustAxes(double pts[8][3], double bounds[6], int idx, int xIdx, int yIdx, int zIdx,
    int zIdx2, int xAxes, int yAxes, int zAxes, double xCoords[4], double yCoords[4],
    double zCoords[4], double xRange[2], double yRange[2], double zRange[2]);
 
private:
  // hide the superclass' ShallowCopy() from the user and the compiler.
  void ShallowCopy(vtkProp* prop) override { this->vtkProp::ShallowCopy(prop); }
 
private:
  vtkCubeAxesActor2D(const vtkCubeAxesActor2D&) = delete;
  void operator=(const vtkCubeAxesActor2D&) = delete;
};
 
#endif