v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

/*=========================================================================


Program:   Visualization Toolkit

Module:    vtkAxisActor.h

Language:  C++


Copyright (c) 1993-2000 Ken Martin, Will Schroeder, Bill Lorensen

All rights reserved.

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 vtkAxisActor_h

#define vtkAxisActor_h


#include "vtkRenderingAnnotationModule.h" // For export macro

#include "vtkActor.h"


#define VTK_MAX_LABELS    200

#define VTK_MAX_TICKS     1000


#define VTK_AXIS_TYPE_X   0

#define VTK_AXIS_TYPE_Y   1

#define VTK_AXIS_TYPE_Z   2


#define VTK_TICKS_INSIDE  0

#define VTK_TICKS_OUTSIDE 1

#define VTK_TICKS_BOTH    2


#define VTK_AXIS_POS_MINMIN 0

#define VTK_AXIS_POS_MINMAX 1

#define VTK_AXIS_POS_MAXMAX 2

#define VTK_AXIS_POS_MAXMIN 3


class vtkAxisFollower;

class vtkCamera;

class vtkCoordinate;

class vtkFollower;

class vtkPoints;

class vtkPolyData;

class vtkPolyDataMapper;

class vtkProp3DAxisFollower;

class vtkProperty2D;

class vtkStringArray;

class vtkTextActor;

class vtkTextActor3D;

class vtkTextProperty;

class vtkVectorText;


class VTKRENDERINGANNOTATION_EXPORT vtkAxisActor : public vtkActor

{

 public:

  vtkTypeMacro(vtkAxisActor,vtkActor);

  void PrintSelf(ostream& os, vtkIndent indent);


  static vtkAxisActor *New();


  virtual vtkCoordinate *GetPoint1Coordinate();

  virtual void SetPoint1(double x[3])

  { this->SetPoint1(x[0], x[1], x[2]); }

  virtual void SetPoint1(double x, double y, double z);

  virtual double *GetPoint1();


  virtual vtkCoordinate *GetPoint2Coordinate();

  virtual void SetPoint2(double x[3])

  { this->SetPoint2(x[0], x[1], x[2]); }

  virtual void SetPoint2(double x, double y, double z);

  virtual double *GetPoint2();


  vtkSetVector2Macro(Range,double);

  vtkGetVectorMacro(Range,double,2);


  void   SetBounds(const double bounds[6]);

  void   SetBounds(double xmin, double xmax, double ymin, double ymax, double zmin, double zmax);

  double *GetBounds(void);

  void   GetBounds(double bounds[6]);


  vtkSetStringMacro(LabelFormat);

  vtkGetStringMacro(LabelFormat);


  vtkSetMacro(UseTextActor3D, int);

  vtkGetMacro(UseTextActor3D, int);


  vtkSetMacro(MinorTicksVisible, int);

  vtkGetMacro(MinorTicksVisible, int);

  vtkBooleanMacro(MinorTicksVisible, int);


  void SetTitle(const char *t);

  vtkGetStringMacro(Title);


  vtkSetMacro(MajorTickSize, double);

  vtkGetMacro(MajorTickSize, double);


  vtkSetMacro(MinorTickSize, double);

  vtkGetMacro(MinorTickSize, double);


  vtkSetClampMacro(TickLocation, int, VTK_TICKS_INSIDE, VTK_TICKS_BOTH);

  vtkGetMacro(TickLocation, int);


  void SetTickLocationToInside(void)

  { this->SetTickLocation(VTK_TICKS_INSIDE); };

  void SetTickLocationToOutside(void)

  { this->SetTickLocation(VTK_TICKS_OUTSIDE); };

  void SetTickLocationToBoth(void)

  { this->SetTickLocation(VTK_TICKS_BOTH); };


  vtkSetMacro(AxisVisibility, int);

  vtkGetMacro(AxisVisibility, int);

  vtkBooleanMacro(AxisVisibility, int);


  vtkSetMacro(TickVisibility, int);

  vtkGetMacro(TickVisibility, int);

  vtkBooleanMacro(TickVisibility, int);


  vtkSetMacro(LabelVisibility, int);

  vtkGetMacro(LabelVisibility, int);

  vtkBooleanMacro(LabelVisibility, int);


  vtkSetMacro(TitleVisibility, int);

  vtkGetMacro(TitleVisibility, int);

  vtkBooleanMacro(TitleVisibility, int);


  virtual void SetTitleTextProperty(vtkTextProperty *p);

  vtkGetObjectMacro(TitleTextProperty,vtkTextProperty);


  virtual void SetLabelTextProperty(vtkTextProperty *p);

  vtkGetObjectMacro(LabelTextProperty,vtkTextProperty);


  void SetAxisLinesProperty(vtkProperty *);

  vtkProperty* GetAxisLinesProperty();


  void SetGridlinesProperty(vtkProperty *);

  vtkProperty* GetGridlinesProperty();


  void SetInnerGridlinesProperty(vtkProperty *);

  vtkProperty* GetInnerGridlinesProperty();


  void SetGridpolysProperty(vtkProperty *);

  vtkProperty* GetGridpolysProperty();


  vtkSetMacro(DrawGridlines, int);

  vtkGetMacro(DrawGridlines, int);

  vtkBooleanMacro(DrawGridlines, int);


  vtkSetMacro(DrawGridlinesOnly, int);

  vtkGetMacro(DrawGridlinesOnly, int);

  vtkBooleanMacro(DrawGridlinesOnly, int);


  vtkSetMacro(DrawGridlinesLocation, int);

  vtkGetMacro(DrawGridlinesLocation, int);


  vtkSetMacro(DrawInnerGridlines, int);

  vtkGetMacro(DrawInnerGridlines, int);

  vtkBooleanMacro(DrawInnerGridlines, int);


  vtkSetMacro(GridlineXLength, double);

  vtkGetMacro(GridlineXLength, double);

  vtkSetMacro(GridlineYLength, double);

  vtkGetMacro(GridlineYLength, double);

  vtkSetMacro(GridlineZLength, double);

  vtkGetMacro(GridlineZLength, double);


  vtkSetMacro(DrawGridpolys, int);

  vtkGetMacro(DrawGridpolys, int);

  vtkBooleanMacro(DrawGridpolys, int);


  vtkSetClampMacro(AxisType, int, VTK_AXIS_TYPE_X, VTK_AXIS_TYPE_Z);

  vtkGetMacro(AxisType, int);

  void SetAxisTypeToX(void) { this->SetAxisType(VTK_AXIS_TYPE_X); };

  void SetAxisTypeToY(void) { this->SetAxisType(VTK_AXIS_TYPE_Y); };

  void SetAxisTypeToZ(void) { this->SetAxisType(VTK_AXIS_TYPE_Z); };


  vtkSetClampMacro(AxisPosition, int, VTK_AXIS_POS_MINMIN, VTK_AXIS_POS_MAXMIN);

  vtkGetMacro(AxisPosition, int);


  void SetAxisPositionToMinMin(void)

  { this->SetAxisPosition(VTK_AXIS_POS_MINMIN); };

  void SetAxisPositionToMinMax(void)

  { this->SetAxisPosition(VTK_AXIS_POS_MINMAX); };

  void SetAxisPositionToMaxMax(void)

  { this->SetAxisPosition(VTK_AXIS_POS_MAXMAX); };

  void SetAxisPositionToMaxMin(void)

  { this->SetAxisPosition(VTK_AXIS_POS_MAXMIN); };


  virtual void SetCamera(vtkCamera*);

  vtkGetObjectMacro(Camera, vtkCamera);


  virtual int RenderOpaqueGeometry(vtkViewport* viewport);

  virtual int RenderTranslucentGeometry(vtkViewport* viewport);

  virtual int RenderTranslucentPolygonalGeometry(vtkViewport* viewport);

  virtual int RenderOverlay(vtkViewport* viewport);

  int HasTranslucentPolygonalGeometry();


  void ReleaseGraphicsResources(vtkWindow *);


//BTX

  double ComputeMaxLabelLength(const double [3]);

  double ComputeTitleLength(const double [3]);

//ETX

  void SetLabelScale(const double scale);

  void SetLabelScale(int labelIndex, const double scale);

  void SetTitleScale(const double scale);


  vtkSetMacro(MinorStart, double);

  vtkGetMacro(MinorStart, double);

  double GetMajorStart(int axis);

  void SetMajorStart(int axis,double value);

  //vtkSetMacro(MajorStart, double);

  //vtkGetMacro(MajorStart, double);

  vtkSetMacro(DeltaMinor, double);

  vtkGetMacro(DeltaMinor, double);

  double GetDeltaMajor(int axis);

  void SetDeltaMajor(int axis,double value);

  //vtkSetMacro(DeltaMajor, double);

  //vtkGetMacro(DeltaMajor, double);


  vtkSetMacro(MinorRangeStart, double);

  vtkGetMacro(MinorRangeStart, double);

  vtkSetMacro(MajorRangeStart, double);

  vtkGetMacro(MajorRangeStart, double);

  vtkSetMacro(DeltaRangeMinor, double);

  vtkGetMacro(DeltaRangeMinor, double);

  vtkSetMacro(DeltaRangeMajor, double);

  vtkGetMacro(DeltaRangeMajor, double);


//BTX

  void SetLabels(vtkStringArray *labels);

//ETX


  void BuildAxis(vtkViewport *viewport, bool);


//BTX


  vtkGetObjectMacro(TitleActor,  vtkAxisFollower);


  inline vtkAxisFollower** GetLabelActors()

    {

    return this->LabelActors;

    }


  vtkGetObjectMacro(TitleProp3D,  vtkProp3DAxisFollower);


  inline vtkProp3DAxisFollower** GetLabelProps3D()

    {

    return this->LabelProps3D;

    }

//ETX


  vtkGetMacro(NumberOfLabelsBuilt, int);


  vtkSetMacro(CalculateTitleOffset, int);

  vtkGetMacro(CalculateTitleOffset, int);

  vtkBooleanMacro(CalculateTitleOffset, int);


  vtkSetMacro(CalculateLabelOffset, int);

  vtkGetMacro(CalculateLabelOffset, int);

  vtkBooleanMacro(CalculateLabelOffset, int);


  vtkSetMacro(Use2DMode, int);

  vtkGetMacro(Use2DMode, int);


  vtkSetMacro(VerticalOffsetXTitle2D, double);

  vtkGetMacro(VerticalOffsetXTitle2D, double);


  vtkSetMacro(HorizontalOffsetYTitle2D, double);

  vtkGetMacro(HorizontalOffsetYTitle2D, double);


  vtkSetMacro(SaveTitlePosition, int);

  vtkGetMacro(SaveTitlePosition, int);


  vtkSetVector3Macro(AxisBaseForX, double);

  vtkGetVector3Macro(AxisBaseForX, double);


  vtkSetVector3Macro(AxisBaseForY, double);

  vtkGetVector3Macro(AxisBaseForY, double);


  vtkSetVector3Macro(AxisBaseForZ, double);

  vtkGetVector3Macro(AxisBaseForZ, double);


  vtkSetMacro(AxisOnOrigin,int);

  vtkGetMacro(AxisOnOrigin,int);


  vtkSetMacro(LabelOffset, double);

  vtkGetMacro(LabelOffset, double);

  vtkSetMacro(TitleOffset, double);

  vtkGetMacro(TitleOffset, double);

  vtkSetMacro(ScreenSize, double);

  vtkGetMacro(ScreenSize, double);


 protected:

  vtkAxisActor();

  ~vtkAxisActor();


  char  *Title;

  double  Range[2];

  double  LastRange[2];

  char  *LabelFormat;

  int    UseTextActor3D;

  int    NumberOfLabelsBuilt;

  int    MinorTicksVisible;

  int    LastMinorTicksVisible;

  int    TickLocation;


  int    DrawGridlines;

  int    DrawGridlinesOnly;

  int    LastDrawGridlines;

  int    DrawGridlinesLocation; // 0: all | 1: closest | 2: farest

  int    LastDrawGridlinesLocation; // 0: all | 1: closest | 2: farest

  double GridlineXLength;

  double GridlineYLength;

  double GridlineZLength;


  int    DrawInnerGridlines;

  int    LastDrawInnerGridlines;


  int    DrawGridpolys;

  int    LastDrawGridpolys;


  int    AxisVisibility;

  int    TickVisibility;

  int    LastTickVisibility;

  int    LabelVisibility;

  int    TitleVisibility;


  int    AxisType;

  int    AxisPosition;

  double  Bounds[6];


  double AxisBaseForX[3];

  double AxisBaseForY[3];

  double AxisBaseForZ[3];


 private:

  vtkAxisActor(const vtkAxisActor&); // Not implemented

  void operator=(const vtkAxisActor&); // Not implemented


  void TransformBounds(vtkViewport *, double bnds[6]);


  void BuildLabels(vtkViewport *, bool);

  void BuildLabels2D(vtkViewport *, bool);

  void SetLabelPositions(vtkViewport *, bool);

  void SetLabelPositions2D(vtkViewport *, bool);


  void BuildTitle(bool);

  void BuildTitle2D(vtkViewport *viewport, bool);


  void SetAxisPointsAndLines(void);

  bool BuildTickPoints(double p1[3], double p2[3], bool force);


  bool TickVisibilityChanged(void);

  vtkProperty *NewTitleProperty();

  vtkProperty2D *NewTitleProperty2D();

  vtkProperty *NewLabelProperty();


  bool BoundsDisplayCoordinateChanged(vtkViewport *viewport);


  vtkCoordinate *Point1Coordinate;

  vtkCoordinate *Point2Coordinate;


  double  MajorTickSize;

  double  MinorTickSize;


  // For each axis (for the inner gridline generation)

  double  MajorStart[3];

  double  DeltaMajor[3];

  double  MinorStart;

  double  DeltaMinor;


  // For the ticks, w.r.t to the set range

  double  MajorRangeStart;

  double  MinorRangeStart;

  double  DeltaRangeMinor;

  double  DeltaRangeMajor;


  int    LastAxisPosition;

  int    LastAxisType;

  int    LastTickLocation;

  double LastLabelStart;


  vtkPoints         *MinorTickPts;

  vtkPoints         *MajorTickPts;

  vtkPoints         *GridlinePts;

  vtkPoints         *InnerGridlinePts;

  vtkPoints         *GridpolyPts;


  vtkVectorText     *TitleVector;

  vtkPolyDataMapper *TitleMapper;

  vtkAxisFollower   *TitleActor;

  vtkTextActor      *TitleActor2D;

  vtkProp3DAxisFollower *TitleProp3D;

  vtkTextActor3D    *TitleActor3D;

  vtkTextProperty   *TitleTextProperty;


  vtkVectorText     **LabelVectors;

  vtkPolyDataMapper **LabelMappers;

  vtkAxisFollower   **LabelActors;

  vtkProp3DAxisFollower **LabelProps3D;

  vtkTextActor      **LabelActors2D;

  vtkTextActor3D    **LabelActors3D;

  vtkTextProperty    *LabelTextProperty;


  vtkPolyData        *AxisLines;

  vtkPolyDataMapper  *AxisLinesMapper;

  vtkActor           *AxisLinesActor;

  vtkPolyData        *Gridlines;

  vtkPolyDataMapper  *GridlinesMapper;

  vtkActor           *GridlinesActor;

  vtkPolyData        *InnerGridlines;

  vtkPolyDataMapper  *InnerGridlinesMapper;

  vtkActor           *InnerGridlinesActor;

  vtkPolyData        *Gridpolys;

  vtkPolyDataMapper  *GridpolysMapper;

  vtkActor           *GridpolysActor;


  vtkCamera          *Camera;

  vtkTimeStamp        BuildTime;

  vtkTimeStamp        BuildTickPointsTime;

  vtkTimeStamp        BoundsTime;

  vtkTimeStamp        LabelBuildTime;

  vtkTimeStamp        TitleTextTime;


  int                 AxisOnOrigin;


  int                 AxisHasZeroLength;


  int                 CalculateTitleOffset;

  int                 CalculateLabelOffset;


  int                 Use2DMode;


  double              VerticalOffsetXTitle2D;


  double              HorizontalOffsetYTitle2D;


  int          SaveTitlePosition;


  double       TitleConstantPosition[2];


  bool                NeedBuild2D;


  double       LastMinDisplayCoordinate[3];

  double       LastMaxDisplayCoordinate[3];


  double ScreenSize;

  double LabelOffset;

  double TitleOffset;

};


#endif