/*========================================================================= Program: Visualization Toolkit Module: vtkCubeAxesActor.h Language: C++ Copyright (c) 1993-2001 Ken Martin, Will Schroeder, Bill Lorensen All rights reserve 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. =========================================================================*/ /** * @class vtkCubeAxesActor * @brief create a plot of a bounding box edges - * used for navigation * * vtkCubeAxesActor is a composite actor that draws axes of the * bounding box of an input dataset. The axes include labels and titles * for the x-y-z axes. The algorithm selects which axes to draw based * on the user-defined 'fly' mode. (STATIC is default). * 'STATIC' constructs axes from all edges of the bounding box. * 'CLOSEST_TRIAD' consists of the three axes x-y-z forming a triad that * lies closest to the specified camera. * 'FURTHEST_TRIAD' consists of the three axes x-y-z forming a triad that * lies furthest from the specified camera. * 'OUTER_EDGES' is constructed from edges that are on the "exterior" of the * bounding box, exterior as determined from examining outer edges of the * bounding box in projection (display) space. * * To use this object you must define a bounding box and the camera used * to render the vtkCubeAxesActor. You can optionally turn on/off labels, * ticks, gridlines, and set tick location, number of labels, and text to * use for axis-titles. A 'corner offset' can also be set. This allows * the axes to be set partially away from the actual bounding box to perhaps * prevent overlap of labels between the various axes. * * The Bounds instance variable (an array of six doubles) is used to determine * the bounding box. * * @par Thanks: * This class was written by: * Hank Childs, Kathleen Bonnell, Amy Squillacote, Brad Whitlock, Will Schroeder, * Eric Brugger, Daniel Aguilera, Claire Guilbaud, Nicolas Dolegieviez, * Aashish Chaudhary, Philippe Pebay, David Gobbi, David Partyka, Utkarsh Ayachit * David Cole, Francois Bertel, and Mark Olesen * Part of this work was supported by CEA/DIF - Commissariat a l'Energie Atomique, * Centre DAM Ile-De-France, BP12, F-91297 Arpajon, France. * * @sa * vtkActor vtkAxisActor vtkCubeAxesActor2D */ #ifndef vtkCubeAxesActor_h #define vtkCubeAxesActor_h #include "vtkActor.h" #include "vtkRenderingAnnotationModule.h" // For export macro class vtkAxisActor; class vtkCamera; class vtkTextProperty; class vtkStringArray; class VTKRENDERINGANNOTATION_EXPORT vtkCubeAxesActor : public vtkActor { public: vtkTypeMacro(vtkCubeAxesActor, vtkActor); void PrintSelf(ostream& os, vtkIndent indent) override; /** * Instantiate object with label format "6.3g" and the number of labels * per axis set to 3. */ static vtkCubeAxesActor* New(); //@{ /** * Draw the axes as per the vtkProp superclass' API. */ int RenderOpaqueGeometry(vtkViewport*) override; virtual int RenderTranslucentGeometry(vtkViewport*); int RenderTranslucentPolygonalGeometry(vtkViewport*) override; int RenderOverlay(vtkViewport*) override; vtkTypeBool HasTranslucentPolygonalGeometry() override; //@} //@{ /** * Gets/Sets the RebuildAxes flag */ vtkSetMacro(RebuildAxes, bool); vtkGetMacro(RebuildAxes, bool); //@} //@{ /** * Explicitly specify the region in space around which to draw the bounds. * The bounds is used only when no Input or Prop is specified. The bounds * are specified according to (xmin,xmax, ymin,ymax, zmin,zmax), making * sure that the min's are less than the max's. */ vtkSetVector6Macro(Bounds, double); using Superclass::GetBounds; double* GetBounds() VTK_SIZEHINT(6) override { return this->Bounds; } //@} //@{ /** * Method used to properly return the bounds of the cube axis itself with all * its labels. */ virtual void GetRenderedBounds(double rBounds[6]); virtual double* GetRenderedBounds(); //@} //@{ /** * Explicitly specify the range of each axes that's used to define the prop. * The default, (if you do not use these methods) is to use the bounds * specified, or use the bounds of the Input Prop if one is specified. This * method allows you to separate the notion of extent of the axes in physical * space (bounds) and the extent of the values it represents. In other words, * you can have the ticks and labels show a different range. */ vtkSetVector2Macro(XAxisRange, double); vtkSetVector2Macro(YAxisRange, double); vtkSetVector2Macro(ZAxisRange, double); vtkGetVector2Macro(XAxisRange, double); vtkGetVector2Macro(YAxisRange, double); //@} //@{ /** * Explicitly specify the axis labels along an axis as an array of strings * instead of using the values. */ vtkStringArray* GetAxisLabels(int axis); void SetAxisLabels(int axis, vtkStringArray* value); //@} vtkGetVector2Macro(ZAxisRange, double); //@{ /** * Explicitly specify the screen size of title and label text. * ScreenSize determines the size of the text in terms of screen * pixels. Default is 10.0. */ void SetScreenSize(double screenSize); vtkGetMacro(ScreenSize, double); //@} //@{ /** * Explicitly specify the distance between labels and the axis. * Default is 20.0. */ void SetLabelOffset(double offset); vtkGetMacro(LabelOffset, double); //@} //@{ /** * Explicitly specify the distance between title and labels. * Default is 20.0. */ void SetTitleOffset(double offset); vtkGetMacro(TitleOffset, double); //@} //@{ /** * Set/Get the camera to perform scaling and translation of the * vtkCubeAxesActor. */ virtual void SetCamera(vtkCamera*); vtkGetObjectMacro(Camera, vtkCamera); //@} enum FlyMode { VTK_FLY_OUTER_EDGES = 0, VTK_FLY_CLOSEST_TRIAD = 1, VTK_FLY_FURTHEST_TRIAD = 2, VTK_FLY_STATIC_TRIAD = 3, VTK_FLY_STATIC_EDGES = 4 }; //@{ /** * Specify a mode to control how the axes are drawn: either static, * closest triad, furthest triad or outer edges in relation to the * camera position. */ vtkSetClampMacro(FlyMode, int, VTK_FLY_OUTER_EDGES, VTK_FLY_STATIC_EDGES); vtkGetMacro(FlyMode, int); void SetFlyModeToOuterEdges() { this->SetFlyMode(VTK_FLY_OUTER_EDGES); } void SetFlyModeToClosestTriad() { this->SetFlyMode(VTK_FLY_CLOSEST_TRIAD); } void SetFlyModeToFurthestTriad() { this->SetFlyMode(VTK_FLY_FURTHEST_TRIAD); } void SetFlyModeToStaticTriad() { this->SetFlyMode(VTK_FLY_STATIC_TRIAD); } void SetFlyModeToStaticEdges() { this->SetFlyMode(VTK_FLY_STATIC_EDGES); } //@} //@{ /** * Set/Get the labels for the x, y, and z axes. By default, * use "X-Axis", "Y-Axis" and "Z-Axis". */ vtkSetStringMacro(XTitle); vtkGetStringMacro(XTitle); vtkSetStringMacro(XUnits); vtkGetStringMacro(XUnits); vtkSetStringMacro(YTitle); vtkGetStringMacro(YTitle); vtkSetStringMacro(YUnits); vtkGetStringMacro(YUnits); vtkSetStringMacro(ZTitle); vtkGetStringMacro(ZTitle); vtkSetStringMacro(ZUnits); vtkGetStringMacro(ZUnits); //@} //@{ /** * Set/Get the format with which to print the labels on each of the * x-y-z axes. */ vtkSetStringMacro(XLabelFormat); vtkGetStringMacro(XLabelFormat); vtkSetStringMacro(YLabelFormat); vtkGetStringMacro(YLabelFormat); vtkSetStringMacro(ZLabelFormat); vtkGetStringMacro(ZLabelFormat); //@} //@{ /** * Set/Get the inertial factor that controls how often (i.e, how * many renders) the axes can switch position (jump from one axes * to another). */ vtkSetClampMacro(Inertia, int, 1, VTK_INT_MAX); vtkGetMacro(Inertia, int); //@} //@{ /** * Specify an offset value to "pull back" the axes from the corner at * which they are joined to avoid overlap of axes labels. The * "CornerOffset" is the fraction of the axis length to pull back. */ vtkSetMacro(CornerOffset, double); vtkGetMacro(CornerOffset, double); //@} /** * Release any graphics resources that are being consumed by this actor. * The parameter window could be used to determine which graphic * resources to release. */ void ReleaseGraphicsResources(vtkWindow*) override; //@{ /** * Enable and disable the use of distance based LOD for titles and labels. */ vtkSetMacro(EnableDistanceLOD, int); vtkGetMacro(EnableDistanceLOD, int); //@} //@{ /** * Set distance LOD threshold [0.0 - 1.0] for titles and labels. */ vtkSetClampMacro(DistanceLODThreshold, double, 0.0, 1.0); vtkGetMacro(DistanceLODThreshold, double); //@} //@{ /** * Enable and disable the use of view angle based LOD for titles and labels. */ vtkSetMacro(EnableViewAngleLOD, int); vtkGetMacro(EnableViewAngleLOD, int); //@} //@{ /** * Set view angle LOD threshold [0.0 - 1.0] for titles and labels. */ vtkSetClampMacro(ViewAngleLODThreshold, double, 0., 1.); vtkGetMacro(ViewAngleLODThreshold, double); //@} //@{ /** * Turn on and off the visibility of each axis. */ 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); //@} //@{ /** * Turn on and off the visibility of labels for each axis. */ vtkSetMacro(XAxisLabelVisibility, vtkTypeBool); vtkGetMacro(XAxisLabelVisibility, vtkTypeBool); vtkBooleanMacro(XAxisLabelVisibility, vtkTypeBool); //@} vtkSetMacro(YAxisLabelVisibility, vtkTypeBool); vtkGetMacro(YAxisLabelVisibility, vtkTypeBool); vtkBooleanMacro(YAxisLabelVisibility, vtkTypeBool); vtkSetMacro(ZAxisLabelVisibility, vtkTypeBool); vtkGetMacro(ZAxisLabelVisibility, vtkTypeBool); vtkBooleanMacro(ZAxisLabelVisibility, vtkTypeBool); //@{ /** * Turn on and off the visibility of ticks for each axis. */ vtkSetMacro(XAxisTickVisibility, vtkTypeBool); vtkGetMacro(XAxisTickVisibility, vtkTypeBool); vtkBooleanMacro(XAxisTickVisibility, vtkTypeBool); //@} vtkSetMacro(YAxisTickVisibility, vtkTypeBool); vtkGetMacro(YAxisTickVisibility, vtkTypeBool); vtkBooleanMacro(YAxisTickVisibility, vtkTypeBool); vtkSetMacro(ZAxisTickVisibility, vtkTypeBool); vtkGetMacro(ZAxisTickVisibility, vtkTypeBool); vtkBooleanMacro(ZAxisTickVisibility, vtkTypeBool); //@{ /** * Turn on and off the visibility of minor ticks for each axis. */ vtkSetMacro(XAxisMinorTickVisibility, vtkTypeBool); vtkGetMacro(XAxisMinorTickVisibility, vtkTypeBool); vtkBooleanMacro(XAxisMinorTickVisibility, vtkTypeBool); //@} vtkSetMacro(YAxisMinorTickVisibility, vtkTypeBool); vtkGetMacro(YAxisMinorTickVisibility, vtkTypeBool); vtkBooleanMacro(YAxisMinorTickVisibility, vtkTypeBool); vtkSetMacro(ZAxisMinorTickVisibility, vtkTypeBool); vtkGetMacro(ZAxisMinorTickVisibility, vtkTypeBool); vtkBooleanMacro(ZAxisMinorTickVisibility, vtkTypeBool); vtkSetMacro(DrawXGridlines, vtkTypeBool); vtkGetMacro(DrawXGridlines, vtkTypeBool); vtkBooleanMacro(DrawXGridlines, vtkTypeBool); vtkSetMacro(DrawYGridlines, vtkTypeBool); vtkGetMacro(DrawYGridlines, vtkTypeBool); vtkBooleanMacro(DrawYGridlines, vtkTypeBool); vtkSetMacro(DrawZGridlines, vtkTypeBool); vtkGetMacro(DrawZGridlines, vtkTypeBool); vtkBooleanMacro(DrawZGridlines, vtkTypeBool); vtkSetMacro(DrawXInnerGridlines, vtkTypeBool); vtkGetMacro(DrawXInnerGridlines, vtkTypeBool); vtkBooleanMacro(DrawXInnerGridlines, vtkTypeBool); vtkSetMacro(DrawYInnerGridlines, vtkTypeBool); vtkGetMacro(DrawYInnerGridlines, vtkTypeBool); vtkBooleanMacro(DrawYInnerGridlines, vtkTypeBool); vtkSetMacro(DrawZInnerGridlines, vtkTypeBool); vtkGetMacro(DrawZInnerGridlines, vtkTypeBool); vtkBooleanMacro(DrawZInnerGridlines, vtkTypeBool); vtkSetMacro(DrawXGridpolys, vtkTypeBool); vtkGetMacro(DrawXGridpolys, vtkTypeBool); vtkBooleanMacro(DrawXGridpolys, vtkTypeBool); vtkSetMacro(DrawYGridpolys, vtkTypeBool); vtkGetMacro(DrawYGridpolys, vtkTypeBool); vtkBooleanMacro(DrawYGridpolys, vtkTypeBool); vtkSetMacro(DrawZGridpolys, vtkTypeBool); vtkGetMacro(DrawZGridpolys, vtkTypeBool); vtkBooleanMacro(DrawZGridpolys, vtkTypeBool); /** * Returns the text property for the title on an axis. */ vtkTextProperty* GetTitleTextProperty(int); /** * Returns the text property for the labels on an axis. */ vtkTextProperty* GetLabelTextProperty(int); //@{ /** * Get/Set axes actors properties. */ void SetXAxesLinesProperty(vtkProperty*); vtkProperty* GetXAxesLinesProperty(); void SetYAxesLinesProperty(vtkProperty*); vtkProperty* GetYAxesLinesProperty(); void SetZAxesLinesProperty(vtkProperty*); vtkProperty* GetZAxesLinesProperty(); //@} //@{ /** * Get/Set axes (outer) gridlines actors properties. */ void SetXAxesGridlinesProperty(vtkProperty*); vtkProperty* GetXAxesGridlinesProperty(); void SetYAxesGridlinesProperty(vtkProperty*); vtkProperty* GetYAxesGridlinesProperty(); void SetZAxesGridlinesProperty(vtkProperty*); vtkProperty* GetZAxesGridlinesProperty(); //@} //@{ /** * Get/Set axes inner gridlines actors properties. */ void SetXAxesInnerGridlinesProperty(vtkProperty*); vtkProperty* GetXAxesInnerGridlinesProperty(); void SetYAxesInnerGridlinesProperty(vtkProperty*); vtkProperty* GetYAxesInnerGridlinesProperty(); void SetZAxesInnerGridlinesProperty(vtkProperty*); vtkProperty* GetZAxesInnerGridlinesProperty(); //@} //@{ /** * Get/Set axes gridPolys actors properties. */ void SetXAxesGridpolysProperty(vtkProperty*); vtkProperty* GetXAxesGridpolysProperty(); void SetYAxesGridpolysProperty(vtkProperty*); vtkProperty* GetYAxesGridpolysProperty(); void SetZAxesGridpolysProperty(vtkProperty*); vtkProperty* GetZAxesGridpolysProperty(); //@} enum TickLocation { VTK_TICKS_INSIDE = 0, VTK_TICKS_OUTSIDE = 1, VTK_TICKS_BOTH = 2 }; //@{ /** * Set/Get the location of ticks marks. */ 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); } void SetLabelScaling(bool, int, int, int); //@{ /** * Use or not vtkTextActor3D for titles and labels. * See Also: * vtkAxisActor::SetUseTextActor3D(), vtkAxisActor::GetUseTextActor3D() */ void SetUseTextActor3D(int val); int GetUseTextActor3D(); //@} //@{ /** * Get/Set 2D mode * NB: Use vtkTextActor for titles in 2D instead of vtkAxisFollower */ void SetUse2DMode(int val); int GetUse2DMode(); //@} /** * For 2D mode only: save axis title positions for later use */ void SetSaveTitlePosition(int val); //@{ /** * Provide an oriented bounded box when using AxisBaseFor. */ vtkSetVector6Macro(OrientedBounds, double); vtkGetVector6Macro(OrientedBounds, double); //@} //@{ /** * Enable/Disable the usage of the OrientedBounds */ vtkSetMacro(UseOrientedBounds, int); vtkGetMacro(UseOrientedBounds, int); //@} //@{ /** * Vector that should be use as the base for X */ vtkSetVector3Macro(AxisBaseForX, double); vtkGetVector3Macro(AxisBaseForX, double); //@} //@{ /** * Vector that should be use as the base for Y */ vtkSetVector3Macro(AxisBaseForY, double); vtkGetVector3Macro(AxisBaseForY, double); //@} //@{ /** * Vector that should be use as the base for Z */ vtkSetVector3Macro(AxisBaseForZ, double); vtkGetVector3Macro(AxisBaseForZ, double); //@} //@{ /** * Provide a custom AxisOrigin. This point must be inside the bounding box and * will represent the point where the 3 axes will intersect */ vtkSetVector3Macro(AxisOrigin, double); vtkGetVector3Macro(AxisOrigin, double); //@} //@{ /** * Enable/Disable the usage of the AxisOrigin */ vtkSetMacro(UseAxisOrigin, int); vtkGetMacro(UseAxisOrigin, int); //@} //@{ /** * Specify the mode in which the cube axes should render its gridLines */ vtkSetMacro(GridLineLocation, int); vtkGetMacro(GridLineLocation, int); //@} //@{ /** * Enable/Disable axis stickiness. When on, the axes will be adjusted to always * be visible in the viewport unless the original bounds of the axes are entirely * outside the viewport. Defaults to off. */ vtkSetMacro(StickyAxes, vtkTypeBool); vtkGetMacro(StickyAxes, vtkTypeBool); vtkBooleanMacro(StickyAxes, vtkTypeBool); //@} //@{ /** * Enable/Disable centering of axes when the Sticky option is * on. If on, the axes bounds will be centered in the * viewport. Otherwise, the axes can move about the longer of the * horizontal or verical directions of the viewport to follow the * data. Defaults to on. */ vtkSetMacro(CenterStickyAxes, vtkTypeBool); vtkGetMacro(CenterStickyAxes, vtkTypeBool); vtkBooleanMacro(CenterStickyAxes, vtkTypeBool); //@} enum GridVisibility { VTK_GRID_LINES_ALL = 0, VTK_GRID_LINES_CLOSEST = 1, VTK_GRID_LINES_FURTHEST = 2 }; protected: vtkCubeAxesActor(); ~vtkCubeAxesActor() override; /** * Computes a bounding sphere used to determine the sticky bounding box. * Sphere center and sphere radius are return parameters and can remain uninitialized * prior to calling this method. */ void ComputeStickyAxesBoundingSphere( vtkViewport* viewport, const double bounds[6], double sphereCenter[3], double& sphereRadius); /** * Get bounds such that the axes are entirely within a viewport */ void GetViewportLimitedBounds(vtkViewport* viewport, double bounds[6]); /** * Get the bits for a bounds point. 0 means the lower side for a * coordinate, 1 means the higher side. */ static void GetBoundsPointBits( unsigned int pointIndex, unsigned int& xBit, unsigned int& yBit, unsigned int& zBit); /** * Get a point on the bounding box by point index */ static void GetBoundsPoint(unsigned int pointIndex, const double bounds[6], double point[3]); int LabelExponent(double min, double max); int Digits(double min, double max); double MaxOf(double, double); double MaxOf(double, double, double, double); double FFix(double); double FSign(double, double); int FRound(double fnt); int GetNumTicks(double range, double fxt); void UpdateLabels(vtkAxisActor** axis, int index); vtkCamera* Camera; int FlyMode; // Expose internally closest axis index computation int FindClosestAxisIndex(double pts[8][3]); // Expose internally furthest axis index computation int FindFurtherstAxisIndex(double pts[8][3]); // Expose internally the boundary edge fly mode axis index computation void FindBoundaryEdge(int& indexOfAxisX, int& indexOfAxisY, int& indexOfAxisZ, double pts[8][3]); /** * This will Update AxisActors with GridVisibility when those should be * dynamaic regarding the viewport. * GridLineLocation = [VTK_CLOSEST_GRID_LINES, VTK_FURTHEST_GRID_LINES] */ void UpdateGridLineVisibility(int axisIndex); // VTK_ALL_GRID_LINES 0 // VTK_CLOSEST_GRID_LINES 1 // VTK_FURTHEST_GRID_LINES 2 int GridLineLocation; /** * Flag for axes stickiness */ vtkTypeBool StickyAxes; /** * Flag for centering sticky axes */ vtkTypeBool CenterStickyAxes; /** * If enabled the actor will not be visible at a certain distance from the camera. * Default is true */ int EnableDistanceLOD; /** * Default is 0.80 * This determines at what fraction of camera far clip range, actor is not visible. */ double DistanceLODThreshold; /** * If enabled the actor will not be visible at a certain view angle. * Default is true. */ int EnableViewAngleLOD; /** * This determines at what view angle to geometry will make the geometry not visible. * Default is 0.3. */ double ViewAngleLODThreshold; enum NumberOfAlignedAxis { NUMBER_OF_ALIGNED_AXIS = 4 }; //@{ /** * Control variables for all axes * NB: [0] always for 'Major' axis during non-static fly modes. */ vtkAxisActor* XAxes[NUMBER_OF_ALIGNED_AXIS]; vtkAxisActor* YAxes[NUMBER_OF_ALIGNED_AXIS]; vtkAxisActor* ZAxes[NUMBER_OF_ALIGNED_AXIS]; //@} bool RebuildAxes; char* XTitle; char* XUnits; char* YTitle; char* YUnits; char* ZTitle; char* ZUnits; char* ActualXLabel; char* ActualYLabel; char* ActualZLabel; int TickLocation; vtkTypeBool XAxisVisibility; vtkTypeBool YAxisVisibility; vtkTypeBool ZAxisVisibility; vtkTypeBool XAxisTickVisibility; vtkTypeBool YAxisTickVisibility; vtkTypeBool ZAxisTickVisibility; vtkTypeBool XAxisMinorTickVisibility; vtkTypeBool YAxisMinorTickVisibility; vtkTypeBool ZAxisMinorTickVisibility; vtkTypeBool XAxisLabelVisibility; vtkTypeBool YAxisLabelVisibility; vtkTypeBool ZAxisLabelVisibility; vtkTypeBool DrawXGridlines; vtkTypeBool DrawYGridlines; vtkTypeBool DrawZGridlines; vtkTypeBool DrawXInnerGridlines; vtkTypeBool DrawYInnerGridlines; vtkTypeBool DrawZInnerGridlines; vtkTypeBool DrawXGridpolys; vtkTypeBool DrawYGridpolys; vtkTypeBool DrawZGridpolys; char* XLabelFormat; char* YLabelFormat; char* ZLabelFormat; double CornerOffset; int Inertia; int RenderCount; int InertiaLocs[3]; int RenderSomething; vtkTextProperty* TitleTextProperty[3]; vtkStringArray* AxisLabels[3]; vtkTextProperty* LabelTextProperty[3]; vtkProperty* XAxesLinesProperty; vtkProperty* YAxesLinesProperty; vtkProperty* ZAxesLinesProperty; vtkProperty* XAxesGridlinesProperty; vtkProperty* YAxesGridlinesProperty; vtkProperty* ZAxesGridlinesProperty; vtkProperty* XAxesInnerGridlinesProperty; vtkProperty* YAxesInnerGridlinesProperty; vtkProperty* ZAxesInnerGridlinesProperty; vtkProperty* XAxesGridpolysProperty; vtkProperty* YAxesGridpolysProperty; vtkProperty* ZAxesGridpolysProperty; double RenderedBounds[6]; double OrientedBounds[6]; int UseOrientedBounds; double AxisOrigin[3]; int UseAxisOrigin; double AxisBaseForX[3]; double AxisBaseForY[3]; double AxisBaseForZ[3]; private: vtkCubeAxesActor(const vtkCubeAxesActor&) = delete; void operator=(const vtkCubeAxesActor&) = delete; vtkSetStringMacro(ActualXLabel); vtkSetStringMacro(ActualYLabel); vtkSetStringMacro(ActualZLabel); vtkTimeStamp BuildTime; int LastUseOrientedBounds; int LastXPow; int LastYPow; int LastZPow; int UserXPow; int UserYPow; int UserZPow; bool AutoLabelScaling; int LastXAxisDigits; int LastYAxisDigits; int LastZAxisDigits; double LastXRange[2]; double LastYRange[2]; double LastZRange[2]; double LastBounds[6]; int LastFlyMode; int RenderAxesX[NUMBER_OF_ALIGNED_AXIS]; int RenderAxesY[NUMBER_OF_ALIGNED_AXIS]; int RenderAxesZ[NUMBER_OF_ALIGNED_AXIS]; int NumberOfAxesX; int NumberOfAxesY; int NumberOfAxesZ; bool MustAdjustXValue; bool MustAdjustYValue; bool MustAdjustZValue; bool ForceXLabelReset; bool ForceYLabelReset; bool ForceZLabelReset; double XAxisRange[2]; double YAxisRange[2]; double ZAxisRange[2]; double LabelScale; double TitleScale; double ScreenSize; double LabelOffset; double TitleOffset; //@{ /** * Major start and delta values, in each direction. * These values are needed for inner grid lines generation */ double MajorStart[3]; double DeltaMajor[3]; //@} int RenderGeometry(bool& initialRender, vtkViewport* viewport, bool checkAxisVisibility, int (vtkAxisActor::*renderMethod)(vtkViewport*)); void TransformBounds(vtkViewport* viewport, const double bounds[6], double pts[8][3]); void AdjustAxes(double bounds[6], double xCoords[NUMBER_OF_ALIGNED_AXIS][6], double yCoords[NUMBER_OF_ALIGNED_AXIS][6], double zCoords[NUMBER_OF_ALIGNED_AXIS][6], double xRange[2], double yRange[2], double zRange[2]); bool ComputeTickSize(double bounds[6]); void AdjustValues(const double xRange[2], const double yRange[2], const double zRange[2]); void AdjustRange(const double bounds[6]); void BuildAxes(vtkViewport*); void DetermineRenderAxes(vtkViewport*); void SetNonDependentAttributes(void); void BuildLabels(vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS]); void AdjustTicksComputeRange( vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS], double rangeMin, double rangeMax); void AutoScale(vtkViewport* viewport); void AutoScale(vtkViewport* viewport, vtkAxisActor* axes[NUMBER_OF_ALIGNED_AXIS]); double AutoScale(vtkViewport* viewport, double screenSize, double position[3]); }; #endif