Changeset 3479

Timestamp:

Mar 9, 2013, 4:26:48 PM (11 years ago)

Author:

ldelgass

Message:

Update custom axes to VTK 6 versions, use local customized classes instead of
patched VTK runtime versions.

Location:

trunk/packages/vizservers/vtkvis

Files:

• Doxyfile.in (modified) (1 diff)
• Makefile.in (modified) (4 diffs)
• RpVtkRenderer.cpp (modified) (2 diffs)
• RpVtkRendererGraphicsObjs.h (modified) (1 diff)
• protocol.txt (modified) (1 diff)
• vtkRpAxisActor.cpp (modified) (46 diffs)
• vtkRpAxisActor.h (modified) (21 diffs)
• vtkRpAxisActor2D.cpp (deleted)
• vtkRpAxisActor2D.h (deleted)
• vtkRpAxisFollower.cpp (added)
• vtkRpAxisFollower.h (added)
• vtkRpCubeAxesActor.cpp (modified) (54 diffs)
• vtkRpCubeAxesActor.h (modified) (14 diffs)

trunk/packages/vizservers/vtkvis/Doxyfile.in

@@ -598 +598 @@
 # subdirectory from a directory tree whose root is specified with the INPUT tag.
 
-EXCLUDE                =
+EXCLUDE                = @srcdir@/vtkRpAxisActor.h @srcdir@/vtkRpAxisActor.cpp @srcdir@/vtkRpAxisFollower.h @srcdir@/vtkRpAxisFollower.cpp
 
 # The EXCLUDE_SYMLINKS tag can be used select whether or not files or

trunk/packages/vizservers/vtkvis/Makefile.in

@@ -1 +1 @@
 DEBUG                   = #yes
 TRACE                   = #yes
-USE_CUSTOM_AXES         = #yes
+USE_CUSTOM_AXES         = yes
 USE_GPU_RAYCASTING      = yes
 USE_OFFSCREEN_RENDERING = yes
@@ -130 +130 @@
 ifdef USE_VTK6
 VTK_MOD_DEFS    = -DvtkRenderingCore_AUTOINIT="4(vtkInteractionStyle,vtkRenderingFreeType,vtkRenderingFreeTypeOpenGL,vtkRenderingOpenGL)" -DvtkRenderingVolume_AUTOINIT"1(vtkRenderingVolumeOpenGL)"
-DEFINES         += -DUSE_VTK6 -DVTK_HYBRID_EXPORT="" -DVTK_RENDERING_EXPORT="" $(VTK_MOD_DEFS)
+DEFINES         += -DUSE_VTK6 $(VTK_MOD_DEFS)
 endif
 
@@ -176 +176 @@
 SERVER_SRCS+= \
         vtkRpAxisActor.cpp \
-        vtkRpAxisActor2D.cpp \
+        vtkRpAxisFollower.cpp \
         vtkRpCubeAxesActor.cpp
 endif
@@ -246 +246 @@
 RpVtkDataSet.o: RpVtkDataSet.h Trace.h
 RpVtkGraphicsObject.o: RpVtkGraphicsObject.h RpVtkRenderer.h RpVtkDataSet.h ColorMap.h Trace.h
-RpVtkRenderer.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisActor.h vtkRpAxisActor2D.h RpMath.h RpVtkDataSet.h RpArc.h RpArrow.h RpBox.h RpCone.h RpContour2D.h RpContour3D.h RpCutplane.h RpCylinder.h RpDisk.h RpGlyphs.h RpGroup.h RpHeightMap.h RpLIC.h RpLine.h RpMolecule.h RpPolyData.h RpPolygon.h RpPseudoColor.h RpSphere.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
-RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisActor.h vtkRpAxisActor2D.h RpVtkDataSet.h RpArc.h RpArrow.h RpBox.h RpCone.h RpContour2D.h RpContour3D.h RpCutplane.h RpCylinder.h RpDisk.h RpGlyphs.h RpGroup.h RpHeightMap.h RpLIC.h RpLine.h RpMolecule.h RpPolyData.h RpPolygon.h RpPseudoColor.h RpSphere.h RpStreamlines.h RpVolume.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RpVtkRenderer.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h RpMath.h RpVtkDataSet.h RpArc.h RpArrow.h RpBox.h RpCone.h RpContour2D.h RpContour3D.h RpCutplane.h RpCylinder.h RpDisk.h RpGlyphs.h RpGroup.h RpHeightMap.h RpLIC.h RpLine.h RpMolecule.h RpPolyData.h RpPolygon.h RpPseudoColor.h RpSphere.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
+RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h RpVtkDataSet.h RpArc.h RpArrow.h RpBox.h RpCone.h RpContour2D.h RpContour3D.h RpCutplane.h RpCylinder.h RpDisk.h RpGlyphs.h RpGroup.h RpHeightMap.h RpLIC.h RpLine.h RpMolecule.h RpPolyData.h RpPolygon.h RpPseudoColor.h RpSphere.h RpStreamlines.h RpVolume.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
 RpVtkRendererGraphicsObjs.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h RpVtkDataSet.h RpArc.h RpArrow.h RpBox.h RpCone.h RpContour2D.h RpContour3D.h RpCutplane.h RpCylinder.h RpDisk.h RpGlyphs.h RpGroup.h RpHeightMap.h RpLIC.h RpLine.h RpMolecule.h RpPolyData.h RpPolygon.h RpPseudoColor.h RpSphere.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
-RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor.h vtkRpAxisActor.h vtkRpAxisActor2D.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
 RpWarp.o: RpWarp.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
 Trace.o: Trace.h
 TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h
 vtkRpAxisActor.o: vtkRpAxisActor.h
-vtkRpAxisActor2D.o: vtkRpAxisActor2D.h
-vtkRpCubeAxesActor.o: vtkRpCubeAxesActor.h vtkRpAxisActor.h vtkRpAxisActor2D.h
+vtkRpAxisFollower.o: vtkRpAxisFollower.h vtkRpAxisActor.h
+vtkRpCubeAxesActor.o: vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h
 md5.o: md5.h

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -23 +23 @@
 #include <vtkTransform.h>
 #include <vtkCharArray.h>
-#include <vtkAxisActor2D.h>
 #ifdef USE_CUSTOM_AXES
 #include "vtkRpCubeAxesActor.h"
@@ -1512 +1511 @@
         if (axis == X_AXIS) {
             _cubeAxesActor->SetXLabelFormat(format);
+            _cubeAxesActor->XAutoLabelFormatOff();
         } else if (axis == Y_AXIS) {
             _cubeAxesActor->SetYLabelFormat(format);
+            _cubeAxesActor->YAutoLabelFormatOff();
         } else if (axis == Z_AXIS) {
             _cubeAxesActor->SetZLabelFormat(format);
+            _cubeAxesActor->ZAutoLabelFormatOff();
         }
         _needsRedraw = true;

trunk/packages/vizservers/vtkvis/RpVtkRendererGraphicsObjs.h

@@ -313 +313 @@
  * \brief Set the prop scaling based on a 2D aspect ratio
  *
- * \param aspectRatio The aspect ratio (width/height), zero means native aspect
+ * \param id The name of the DataSet
+ * \param aspect The aspect ratio (width/height), zero means native aspect
  */
 template<class GraphicsObject>

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -753 +753 @@
 nv>dataset vector world <x> <y> <z> <valueX> <valueY> <valueZ> <dataSetName>
 nv>dataset vector pixel <x> <y> <valueX> <valueY> <valueZ> <dataSetName>
-
+nv>ok -token <seqnum>
+   Reply indicated commands through <seqnum> (numbered beginning at 1) have been
+   processed, but no new image was rendered
 ================================================================================
 Error Replies:

trunk/packages/vizservers/vtkvis/vtkRpAxisActor.cpp

@@ -14 +14 @@
 =========================================================================*/
 #include "vtkRpAxisActor.h"
+
+#include "vtkRpAxisFollower.h"
 #include "vtkCamera.h"
 #include "vtkCellArray.h"
 #include "vtkCoordinate.h"
 #include "vtkFollower.h"
+#include "vtkTextRenderer.h"
+#include "vtkMath.h"
 #include "vtkObjectFactory.h"
 #include "vtkPolyData.h"
 #include "vtkPolyDataMapper.h"
 #include "vtkProperty.h"
+#include "vtkProperty2D.h"
 #include "vtkStringArray.h"
+#include "vtkTextActor.h"
+#include "vtkTextProperty.h"
 #include "vtkVectorText.h"
 #include "vtkViewport.h"
 
-// ****************************************************************
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Replace 'New' method with macro to match VTK 4.0 API.
-// ****************************************************************
-
 vtkStandardNewMacro(vtkRpAxisActor);
 vtkCxxSetObjectMacro(vtkRpAxisActor, Camera, vtkCamera);
+vtkCxxSetObjectMacro(vtkRpAxisActor,LabelTextProperty,vtkTextProperty);
+vtkCxxSetObjectMacro(vtkRpAxisActor,TitleTextProperty,vtkTextProperty);
 
 // ****************************************************************
 // Instantiate this object.
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//   Initialize new members mustAdjustValue and valueScaleFactor.
-//
-//   Kathleen Bonnell, Wed Nov  7 16:19:16 PST 2001
-//   No longer allocate large amounts of memory for labels, instead
-//   allocate dynamically.  Initialize new members:
-//   LastLabelStart; LastAxisPosition; LastTickLocation; LastTickVisibility;
-//   LastDrawGridlines; LastMinorTicksVisible; LastRange; MinorTickPts;
-//   MajorTickPts; GridlinePts.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Initialize new member AxisHasZeroLength.
-//
-//   Kathleen Bonnell, Thu Aug  1 13:44:02 PDT 2002
-//   Initialize new member ForceLabelReset.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Removed mustAdjustValue, valueScaleFator, ForceLabelReset.
-//
-//   Kathleen Bonnell, Thu Apr 29 17:02:10 PDT 2004
-//   Initialize MinorStart, MajorStart, DeltaMinor, DeltaMajor.
-//
 // ****************************************************************
 
@@ -88 +67 @@
   sprintf(this->LabelFormat, "%s", "%-#6.3g");
 
+  this->TitleTextProperty = vtkTextProperty::New();
+  this->TitleTextProperty->SetColor(0.,0.,0.);
+  this->TitleTextProperty->SetFontFamilyToArial();
+  this->TitleTextProperty->SetFontSize(14);
+
   this->TitleVector = vtkVectorText::New();
   this->TitleMapper = vtkPolyDataMapper::New();
-#ifdef USE_VTK6
-  this->TitleMapper->SetInputData(this->TitleVector->GetOutput());
-#else
-  this->TitleMapper->SetInput(this->TitleVector->GetOutput());
-#endif
-  this->TitleActor = vtkFollower::New();
+  this->TitleMapper->SetInputConnection(
+    this->TitleVector->GetOutputPort());
+  this->TitleActor = vtkRpAxisFollower::New();
   this->TitleActor->SetMapper(this->TitleMapper);
-
-  // to avoid deleting/rebuilding create once up front
+  this->TitleActor->SetEnableDistanceLOD(0);
+  this->TitleActor2D = vtkTextActor::New();
+
   this->NumberOfLabelsBuilt = 0;
   this->LabelVectors = NULL;
   this->LabelMappers = NULL;
   this->LabelActors = NULL;
-
-  this->Axis = vtkPolyData::New();
-  this->AxisMapper = vtkPolyDataMapper::New();
-#ifdef USE_VTK6
-  this->AxisMapper->SetInputData(this->Axis);
-#else
-  this->AxisMapper->SetInput(this->Axis);
-#endif
-  this->AxisActor = vtkActor::New();
-  this->AxisActor->SetMapper(this->AxisMapper);
+  this->LabelActors2D = NULL;
+
+  this->LabelTextProperty = vtkTextProperty::New();
+  this->LabelTextProperty->SetColor(0.,0.,0.);
+  this->LabelTextProperty->SetFontFamilyToArial();
+  this->LabelTextProperty->SetFontSize(12);
+
+  this->AxisLines = vtkPolyData::New();
+  this->AxisLinesMapper = vtkPolyDataMapper::New();
+  this->AxisLinesMapper->SetInputData(this->AxisLines);
+  this->AxisLinesActor = vtkActor::New();
+  this->AxisLinesActor->SetMapper(this->AxisLinesMapper);
+  this->Gridlines = vtkPolyData::New();
+  this->GridlinesMapper = vtkPolyDataMapper::New();
+  this->GridlinesMapper->SetInputData(this->Gridlines);
+  this->GridlinesActor = vtkActor::New();
+  this->GridlinesActor->SetMapper(this->GridlinesMapper);
+  this->InnerGridlines = vtkPolyData::New();
+  this->InnerGridlinesMapper = vtkPolyDataMapper::New();
+  this->InnerGridlinesMapper->SetInputData(this->InnerGridlines);
+  this->InnerGridlinesActor = vtkActor::New();
+  this->InnerGridlinesActor->SetMapper(this->InnerGridlinesMapper);
+  this->Gridpolys = vtkPolyData::New();
+  this->GridpolysMapper = vtkPolyDataMapper::New();
+  this->GridpolysMapper->SetInputData(this->Gridpolys);
+  this->GridpolysActor = vtkActor::New();
+  this->GridpolysActor->SetMapper(this->GridpolysMapper);
 
   this->AxisVisibility = 1;
@@ -120 +119 @@
 
   this->DrawGridlines = 0;
+  this->DrawGridlinesOnly = 0;
   this->GridlineXLength = 1.;
   this->GridlineYLength = 1.;
   this->GridlineZLength = 1.;
+
+  this->DrawInnerGridlines = 0;
+
+  this->DrawGridpolys = 0;
 
   this->AxisType = VTK_AXIS_TYPE_X;
@@ -138 +142 @@
   this->LastTickVisibility = -1;
   this->LastDrawGridlines = -1;
+  this->LastDrawInnerGridlines = -1;
+  this->LastDrawGridpolys = -1;
   this->LastMinorTicksVisible = -1;
   this->LastRange[0] = -1.0;
@@ -145 +151 @@
   this->MajorTickPts = vtkPoints::New();
   this->GridlinePts  = vtkPoints::New();
+  this->InnerGridlinePts  = vtkPoints::New();
+  this->GridpolyPts  = vtkPoints::New();
 
   this->AxisHasZeroLength = false;
 
   this->MinorStart = 0.;
-  this->MajorStart = 0.;
+  //this->MajorStart = 0.;
+  for(int i=0;i<3;i++)
+    {
+    this->MajorStart[i] = 0.;
+    }
   this->DeltaMinor = 1.;
-  this->DeltaMajor = 1.;
+  //this->DeltaMajor = 1.;
+  for(int i=0;i<3;i++)
+    {
+    this->DeltaMajor[i] = 1.;
+    }
+
   this->MinorRangeStart = 0.;
   this->MajorRangeStart = 0.;
   this->DeltaRangeMinor = 1.;
   this->DeltaRangeMajor = 1.;
+
+  this->CalculateTitleOffset = 1;
+  this->CalculateLabelOffset = 1;
+
+  // Instance variables specific to 2D mode
+  this->Use2DMode = 0;
+  this->SaveTitlePosition = 0;
+  this->TitleConstantPosition[0] = this->TitleConstantPosition[1] = 0.;
+  this->VerticalOffsetXTitle2D = -40.;
+  this->HorizontalOffsetYTitle2D = -50.;
+  this->LastMinDisplayCoordinate[0] = 0;
+  this->LastMinDisplayCoordinate[1] = 0;
+  this->LastMinDisplayCoordinate[2] = 0;
+  this->LastMaxDisplayCoordinate[0] = 0;
+  this->LastMaxDisplayCoordinate[1] = 0;
+  this->LastMaxDisplayCoordinate[2] = 0;
+
+   // 0: All locations
+  this->DrawGridlinesLocation = this->LastDrawGridlinesLocation = 0;
+
+  // reset the base
+  for(int i=0;i<3;i++)
+    {
+    this->AxisBaseForX[i] = this->AxisBaseForY[i] = this->AxisBaseForZ[i] = 0.0;
+    }
+  this->AxisBaseForX[0] = this->AxisBaseForY[1] = this->AxisBaseForZ[2] = 1.0;
+  this->AxisOnOrigin = 0;
 }
 
 // ****************************************************************
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Added call to set camera to null.
-// ****************************************************************
-
 vtkRpAxisActor::~vtkRpAxisActor()
 {
@@ -201 +240 @@
     this->TitleActor = NULL;
     }
+  if (this->TitleActor2D)
+    {
+    this->TitleActor2D->Delete();
+    this->TitleActor2D = NULL;
+    }
 
   if (this->Title)
@@ -206 +250 @@
     delete [] this->Title;
     this->Title = NULL;
+    }
+
+  if (this->TitleTextProperty)
+    {
+    this->TitleTextProperty->Delete();
+    this->TitleTextProperty = NULL;
     }
 
@@ -215 +265 @@
       this->LabelMappers[i]->Delete();
       this->LabelActors[i]->Delete();
+      this->LabelActors2D[i]->Delete();
       }
     this->NumberOfLabelsBuilt = 0;
@@ -220 +271 @@
     delete [] this->LabelMappers;
     delete [] this->LabelActors;
+    delete [] this->LabelActors2D;
     this->LabelVectors = NULL;
     this->LabelMappers = NULL;
     this->LabelActors = NULL;
-    }
-
-  if (this->Axis)
-    {
-    this->Axis->Delete();
-    this->Axis = NULL;
-    }
-  if (this->AxisMapper)
-    {
-    this->AxisMapper->Delete();
-    this->AxisMapper = NULL;
-    }
-  if (this->AxisActor)
-    {
-    this->AxisActor->Delete();
-    this->AxisActor = NULL;
+    this->LabelActors2D = NULL;
+    }
+  if (this->LabelTextProperty)
+    {
+    this->LabelTextProperty->Delete();
+    this->LabelTextProperty = NULL;
+    }
+
+  if (this->AxisLines)
+    {
+    this->AxisLines->Delete();
+    this->AxisLines = NULL;
+    }
+  if (this->AxisLinesMapper)
+    {
+    this->AxisLinesMapper->Delete();
+    this->AxisLinesMapper = NULL;
+    }
+  if (this->AxisLinesActor)
+    {
+    this->AxisLinesActor->Delete();
+    this->AxisLinesActor = NULL;
+    }
+
+  if (this->Gridlines)
+    {
+    this->Gridlines->Delete();
+    this->Gridlines = NULL;
+    }
+  if (this->GridlinesMapper)
+    {
+    this->GridlinesMapper->Delete();
+    this->GridlinesMapper = NULL;
+    }
+  if (this->GridlinesActor)
+    {
+    this->GridlinesActor->Delete();
+    this->GridlinesActor = NULL;
+    }
+
+  if (this->InnerGridlines)
+    {
+    this->InnerGridlines->Delete();
+    this->InnerGridlines = NULL;
+    }
+  if (this->InnerGridlinesMapper)
+    {
+    this->InnerGridlinesMapper->Delete();
+    this->InnerGridlinesMapper = NULL;
+    }
+  if (this->InnerGridlinesActor)
+    {
+    this->InnerGridlinesActor->Delete();
+    this->InnerGridlinesActor = NULL;
+    }
+
+  if (this->Gridpolys)
+    {
+    this->Gridpolys->Delete();
+    this->Gridpolys = NULL;
+    }
+  if (this->GridpolysMapper)
+    {
+    this->GridpolysMapper->Delete();
+    this->GridpolysMapper = NULL;
+    }
+  if (this->GridpolysActor)
+    {
+    this->GridpolysActor->Delete();
+    this->GridpolysActor = NULL;
     }
 
@@ -256 +362 @@
     this->GridlinePts = NULL;
     }
-}
-
-// Release any graphics resources that are being consumed by this actor.
-// The parameter window could be used to determine which graphic
-// resources to release.
+  if (this->InnerGridlinePts)
+    {
+    this->InnerGridlinePts->Delete();
+    this->InnerGridlinePts = NULL;
+    }
+  if (this->GridpolyPts)
+    {
+    this->GridpolyPts->Delete();
+    this->GridpolyPts = NULL;
+    }
+}
+
+// ****************************************************************
 void vtkRpAxisActor::ReleaseGraphicsResources(vtkWindow *win)
 {
   this->TitleActor->ReleaseGraphicsResources(win);
+  this->TitleActor2D->ReleaseGraphicsResources(win);
   for (int i=0; i < this->NumberOfLabelsBuilt; i++)
     {
     this->LabelActors[i]->ReleaseGraphicsResources(win);
-    }
-  this->AxisActor->ReleaseGraphicsResources(win);
+    this->LabelActors2D[i]->ReleaseGraphicsResources(win);
+    }
+  this->AxisLinesActor->ReleaseGraphicsResources(win);
+  this->GridlinesActor->ReleaseGraphicsResources(win);
+  this->InnerGridlinesActor->ReleaseGraphicsResources(win);
+  this->GridpolysActor->ReleaseGraphicsResources(win);
 }
 
 // ****************************************************************
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//   Copy over mustAdjustValue and valueScaleFactor.
-//
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Call superclass's method in new VTK 4.0 way.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Removed mustAdjustValue, valueScaleFator.
-//
-// ****************************************************************
-
-void vtkRpAxisActor::ShallowCopy(vtkProp *prop)
-{
-  vtkRpAxisActor *a = vtkRpAxisActor::SafeDownCast(prop);
-  if (a != NULL)
-    {
-    this->SetPoint1(a->GetPoint1());
-    this->SetPoint2(a->GetPoint2());
-    this->SetCamera(a->GetCamera());
-    this->SetRange(a->GetRange());
-    this->SetLabelFormat(a->GetLabelFormat());
-    this->SetTitle(a->GetTitle());
-    this->SetAxisVisibility(a->GetAxisVisibility());
-    this->SetTickVisibility(a->GetTickVisibility());
-    this->SetLabelVisibility(a->GetLabelVisibility());
-    this->SetTitleVisibility(a->GetTitleVisibility());
-    }
-
-  // Now do superclass
-  this->Superclass::ShallowCopy(prop);
-}
-
-// ****************************************************************
-// Build the axis, ticks, title, and labels and render.
-//
-// Modifications:
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Don't render a zero-length axis.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Added bool argument to BuildAxis.
-//
-// ****************************************************************
-
 int vtkRpAxisActor::RenderOpaqueGeometry(vtkViewport *viewport)
 {
@@ -328 +401 @@
   if (!this->AxisHasZeroLength)
     {
+    if(this->DrawGridlinesOnly && this->DrawGridlines)
+      {
+      // Exit !!!!
+      return this->GridlinesActor->RenderOpaqueGeometry(viewport);
+      }
     if (this->Title != NULL && this->Title[0] != 0 && this->TitleVisibility)
       {
-      renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
-      }
-
+      if (this->Use2DMode == 0)
+        {
+        renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
+        }
+      else
+        {
+        renderedSomething += this->TitleActor2D->RenderOpaqueGeometry(viewport);
+        }
+      }
     if (this->AxisVisibility || this->TickVisibility)
       {
-      renderedSomething += this->AxisActor->RenderOpaqueGeometry(viewport);
-      }
-
+      renderedSomething += this->AxisLinesActor->RenderOpaqueGeometry(viewport);
+      }
+    if(this->DrawGridlines)
+      {
+      renderedSomething += this->GridlinesActor->RenderOpaqueGeometry(viewport);
+      }
+    if(this->DrawInnerGridlines)
+      {
+      renderedSomething += this->InnerGridlinesActor->RenderOpaqueGeometry(viewport);
+      }
     if (this->LabelVisibility)
       {
       for (i=0; i<this->NumberOfLabelsBuilt; i++)
         {
-        renderedSomething +=
-          this->LabelActors[i]->RenderOpaqueGeometry(viewport);
+        if (this->Use2DMode == 0)
+          {
+          renderedSomething +=
+            this->LabelActors[i]->RenderOpaqueGeometry(viewport);
+          }
+        else
+          {
+          renderedSomething +=
+            this->LabelActors2D[i]->RenderOpaqueGeometry(viewport);
+          }
         }
       }
@@ -349 +448 @@
 
   return renderedSomething;
+}
+
+// ****************************************************************
+// Build the translucent poly actors and render.
+// ****************************************************************
+int vtkRpAxisActor::RenderTranslucentGeometry(vtkViewport *viewport)
+{
+  return this->RenderTranslucentPolygonalGeometry(viewport);
+}
+
+// ****************************************************************
+// Build the translucent poly actors and render.
+// ****************************************************************
+int vtkRpAxisActor::RenderTranslucentPolygonalGeometry(vtkViewport *viewport)
+{
+
+  int renderedSomething=0;
+
+  this->BuildAxis(viewport, false);
+
+  // Everything is built, just have to render
+
+  if (!this->AxisHasZeroLength && !this->DrawGridlinesOnly)
+    {
+    if(this->DrawGridpolys)
+      {
+      renderedSomething += this->GridpolysActor->RenderTranslucentPolygonalGeometry(viewport);
+      }
+    }
+
+  return renderedSomething;
+}
+
+// ****************************************************************
+// Render the 2d annotations.
+// ****************************************************************
+int vtkRpAxisActor::RenderOverlay(vtkViewport *viewport)
+{
+  int i, renderedSomething=0;
+
+  // Everything is built, just have to render
+  if (!this->AxisHasZeroLength && !this->DrawGridlinesOnly)
+    {
+    if( this->Use2DMode == 1 )
+      {
+      renderedSomething += this->TitleActor2D->RenderOverlay(viewport);
+      }
+    if (this->LabelVisibility)
+      {
+      for (i=0; i<this->NumberOfLabelsBuilt; i++)
+        {
+        if (this->Use2DMode == 1)
+          {
+          renderedSomething += this->LabelActors2D[i]->RenderOverlay(viewport);
+          }
+        }
+      }
+    }
+
+  return renderedSomething;
+}
+
+// **************************************************************************
+int vtkRpAxisActor::HasTranslucentPolygonalGeometry()
+{
+  if (this->Visibility && !this->AxisHasZeroLength)
+    {
+
+    if (this->TitleVisibility)
+      {
+      if (this->Use2DMode)
+        {
+        if (this->TitleActor2D->HasTranslucentPolygonalGeometry())
+          {
+          return 1;
+          }
+        }
+      else
+        {
+        if (this->TitleActor->HasTranslucentPolygonalGeometry())
+          {
+          return 1;
+          }
+        }
+      }
+
+    if (this->LabelVisibility)
+      {
+      if (this->Use2DMode)
+        {
+        for (int i = 0; i < this->NumberOfLabelsBuilt; ++i)
+          {
+          if (this->LabelActors2D[i]->HasTranslucentPolygonalGeometry())
+            {
+            return 1;
+            } // end if
+          } // end for
+        } // end 2D
+      else
+        {
+        for (int i = 0; i < this->NumberOfLabelsBuilt; ++i)
+          {
+          if (this->LabelActors[i]->HasTranslucentPolygonalGeometry())
+            {
+            return 1;
+            } // end if
+          } // end for
+        } // end 3D
+      } // end label vis
+
+    if (this->AxisLinesActor->HasTranslucentPolygonalGeometry())
+      {
+      return 1;
+      }
+
+    if (this->DrawGridlines &&
+        this->GridlinesActor->HasTranslucentPolygonalGeometry())
+      {
+      return 1;
+      }
+
+    if (this->DrawInnerGridlines &&
+        this->InnerGridlinesActor->HasTranslucentPolygonalGeometry())
+      {
+      return 1;
+      }
+
+    if (this->DrawGridpolys &&
+        this-GridpolysActor->HasTranslucentPolygonalGeometry())
+      {
+      return 1;
+      }
+
+    return this->Superclass::HasTranslucentPolygonalGeometry();
+
+    } // end this vis
+
+  return 0;
 }
 
 // **************************************************************************
 // Perform some initialization, determine which Axis type we are
-// and call the appropriate build method.
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Nov  7 17:45:20 PST 2001
-//   Added logic to only rebuild sub-parts if necessary.
-//
-//   Kathleen Bonnell, Fri Nov 30 17:02:41 PST 2001
-//   Moved setting values for LastRange to end of method, so they
-//   can be used in comparisons elsewhere.
-//
-//   Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//   Compare vtkTimeStamps correctly.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Test for zero length axis.
-//
-//   Kathleen Bonnell,  Fri Jul 25 14:37:32 PDT 2003
-//   Added bool argument that will allow all axis components to be built
-//   if set to true.  Removed call to AdjustTicksComputeRange (handled by
-//   vtkCubeAxesActor.  Remvoed call to Build?TypeAxis, added calls
-//   to BuildLabels, SetAxisPointsAndLines and BuildTitle, (which used to
-//   be handled in Build?TypeAxis). .
-//
 // **************************************************************************
-
 void vtkRpAxisActor::BuildAxis(vtkViewport *viewport, bool force)
 {
@@ -409 +622 @@
   if (force || this->GetProperty()->GetMTime() > this->BuildTime.GetMTime())
     {
-    this->AxisActor->SetProperty(this->GetProperty());
+      //this->AxisLinesActor->SetProperty(this->GetProperty());
     this->TitleActor->SetProperty(this->GetProperty());
+    this->TitleActor->GetProperty()->SetColor(this->TitleTextProperty->GetColor());
     }
 
@@ -417 +631 @@
   //
   bool ticksRebuilt;
-  if (this->AxisType == VTK_AXIS_TYPE_X)
-    {
-    ticksRebuilt = this->BuildTickPointsForXType(p1, p2, force);
-    }
-  else if (this->AxisType == VTK_AXIS_TYPE_Y)
-    {
-    ticksRebuilt = this->BuildTickPointsForYType(p1, p2, force);
-    }
-  else
-    {
-    ticksRebuilt = this->BuildTickPointsForZType(p1, p2, force);
-    }
+  ticksRebuilt = this->BuildTickPoints(p1, p2, force);
 
   bool tickVisChanged = this->TickVisibilityChanged();
 
-  if (force || ticksRebuilt || tickVisChanged)
-   {
-   this->SetAxisPointsAndLines();
-   }
-
-  this->BuildLabels(viewport, force);
+  if (force || ticksRebuilt || tickVisChanged || this->LastDrawGridlinesLocation != this->DrawGridlinesLocation)
+    {
+    this->LastDrawGridlinesLocation = this->DrawGridlinesLocation;
+    this->SetAxisPointsAndLines();
+    }
+
+  // If the ticks have been rebuilt it is more than likely
+  // that the labels should follow...
+  this->BuildLabels(viewport, force || ticksRebuilt);
+  if (this->Use2DMode == 1)
+    {
+    this->BuildLabels2D(viewport, force || ticksRebuilt);
+    }
 
   if (this->Title != NULL && this->Title[0] != 0)
     {
-    this->BuildTitle(force);
+    this->BuildTitle(force || ticksRebuilt);
+    if( this->Use2DMode == 1 )
+      {
+      this->BuildTitle2D(viewport, force || ticksRebuilt);
+      }
     }
 
   this->LastAxisPosition = this->AxisPosition;
-  this->LastTickLocation = this->TickLocation;
 
   this->LastRange[0] = this->Range[0];
@@ -453 +666 @@
 
 // ****************************************************************
-//
 //  Set label values and properties.
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//   Use valueScaleFactor to scale value if necessary.
-//
-//   Kathleen Bonnell, Wed Nov  7 17:45:20 PST 2001
-//   Added code for early termination.  Added call to SetNumberOfLabels
-//   for dynamic memory allocation. Number of labels limited to 200.
-//
-//   Kathleen Bonnell, Fri Nov 30 17:02:41 PST 2001
-//   Added test for modified range to determine if labels really need to
-//   be built.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Use defined constant to limit number of labels.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Remvoed determination of label text, added call to
-//   SetLabelPositions.
-//
 // ****************************************************************
-
 void
 vtkRpAxisActor::BuildLabels(vtkViewport *viewport, bool force)
@@ -489 +680 @@
     this->LabelActors[i]->SetCamera(this->Camera);
     this->LabelActors[i]->SetProperty(this->GetProperty());
+    this->LabelActors[i]->GetProperty()->SetColor(this->LabelTextProperty->GetColor());
+    this->LabelActors[i]->SetOrientation(0., 0., this->LabelTextProperty->GetOrientation());
+
+    if(!this->GetCalculateLabelOffset())
+      {
+      this->LabelActors[i]->SetAutoCenter(1);
+      }
     }
 
@@ -505 +703 @@
 // *******************************************************************
 // Determine and set scale factor and position for labels.
-//
-// Modifications:
-//   Kathleen Bonnell, Fri Nov 30 17:02:41 PST 2001
-//   Reset labels scale to 1. before testing length, in order to
-//   ensure proper scaling.  Use Bounds[1] and Bounds[0] for bWidth
-//   instead of Bounds[5] and Bounds[4].
-//
-//   Kathleen Bonnell, Tue Dec  4 09:55:03 PST 2001
-//   Ensure that scale does not go below MinScale.
-//
-//   Kathleen Bonnell, Tue Apr  9 14:41:08 PDT 2002
-//   Removed MinScale as it allowed axes with very small ranges
-//   to have labels scaled too large for the dataset.
-//
-//   Kathleen Bonnell, Fri Jul 18 09:09:31 PDT 2003
-//   Renamed to SetLabelPosition.  Removed calculation of label
-//   scale factor, added check for no labels to early return test.
-//
-//   Eric Brugger, Tue Jul 29 14:42:44 PDT 2003
-//   Corrected the test that causes the routine to exit early when
-//   no work needs to be done.
-//
-//   David Gobbi, Fri Apr 8 16:50:00 MST 2011
-//   Use mapper bounds, not actor bounds.
-//
 // *******************************************************************
-
 void vtkRpAxisActor::SetLabelPositions(vtkViewport *viewport, bool force)
 {
@@ -580 +752 @@
     this->LabelActors[i]->GetScale(scale);
 
-    double halfWidth  = (bounds[1] - bounds[0]) * 0.5 * scale[0];
-    double halfHeight = (bounds[3] - bounds[2]) * 0.5 * scale[1];
-
-    center[0] = tick[0] + xmult * (halfWidth  + this->MinorTickSize);
-    center[1] = tick[1] + ymult * (halfHeight + this->MinorTickSize);
-    pos[0] = (center[0] - xadjust *halfWidth);
-    pos[1] = (center[1] - yadjust *halfHeight);
-    pos[2] = tick[2];
+    if(this->CalculateLabelOffset)
+      {
+      double halfWidth  = (bounds[1] - bounds[0]) * 0.5 * scale[0];
+      double halfHeight = (bounds[3] - bounds[2]) * 0.5 * scale[1];
+
+      center[0] = tick[0] + xmult * (halfWidth  + this->MinorTickSize);
+      center[1] = tick[1] + ymult * (halfHeight + this->MinorTickSize);
+      center[2] = tick[2];
+
+      pos[0] = (center[0] - xadjust *halfWidth);
+      pos[1] = (center[1] - yadjust *halfHeight);
+      pos[2] =  center[2];
+      }
+    else
+      {
+      center[0] = tick[0] ;
+      center[1] = tick[1];
+      center[2] = tick[2];
+
+      pos[0] = center[0];
+      pos[1] = center[1];
+      pos[2] = center[2];
+      }
+
     this->LabelActors[i]->SetPosition(pos[0], pos[1], pos[2]);
     }
 }
+
+// *******************************************************************
+//  Set 2D label values and properties.
+// *******************************************************************
+void
+vtkRpAxisActor::BuildLabels2D(vtkViewport *viewport, bool force)
+{
+  if (!force && (!this->LabelVisibility || this->NumberOfLabelsBuilt == 0))
+    return;
+
+  for (int i = 0; i < this->NumberOfLabelsBuilt; i++)
+    {
+    this->LabelActors2D[i]->GetProperty()->SetColor(this->LabelTextProperty->GetColor());
+    this->LabelActors2D[i]->GetProperty()->SetOpacity(1);
+    this->LabelActors2D[i]->GetTextProperty()->SetFontSize(this->LabelTextProperty->GetFontSize());
+    this->LabelActors2D[i]->GetTextProperty()->SetVerticalJustificationToBottom();
+    this->LabelActors2D[i]->GetTextProperty()->SetJustificationToLeft();
+    }
+
+  this->NeedBuild2D = this->BoundsDisplayCoordinateChanged(viewport);
+  if (force || this->NeedBuild2D)
+    {
+    this->SetLabelPositions2D(viewport, force);
+    }
+}
+
+
+// *******************************************************************
+// Determine and set scale factor and position for 2D labels.
+// *******************************************************************
+void
+vtkRpAxisActor::SetLabelPositions2D(vtkViewport *viewport, bool force)
+{
+  if (!force && (!this->LabelVisibility || this->NumberOfLabelsBuilt == 0) )
+    return;
+
+  int xmult = 0;
+  int ymult = 0;
+  double xcoeff = 0.;
+  double ycoeff = 0.;
+
+  // we are in 2D mode, so no Z axis
+  switch (this->AxisType)
+    {
+    case VTK_AXIS_TYPE_X :
+      xmult = 0;
+      ymult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
+      xcoeff = 0.5;
+      ycoeff = 1.0;
+      break;
+    case VTK_AXIS_TYPE_Y :
+      xmult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
+      ymult = 0;
+      xcoeff = 1.0;
+      ycoeff = 0.5;
+      break;
+    }
+
+
+  int ptIdx;
+  //
+  // xadjust & yadjust are used for positioning the label correctly
+  // depending upon the 'orientation' of the axis as determined
+  // by its position in view space (via transformed bounds).
+  //
+  double displayBounds[6] = { 0., 0., 0., 0., 0., 0.};
+  this->TransformBounds(viewport, displayBounds);
+  double xadjust = (displayBounds[0] > displayBounds[1] ? -1 : 1);
+  double yadjust = (displayBounds[2] > displayBounds[3] ? -1 : 1);
+  double transpos[3] = {0., 0., 0.};
+  double center[3], tick[3], pos[2];
+
+  vtkTextRenderer *tren = vtkTextRenderer::GetInstance();
+  if (!tren)
+    {
+    vtkErrorMacro(<< "Unable to obtain the vtkTextRenderer instance!");
+    return;
+    }
+
+  for (int i = 0; i < this->NumberOfLabelsBuilt; i++)
+    {
+    ptIdx = 4*i + 1;
+
+    this->MajorTickPts->GetPoint(ptIdx, tick);
+
+    center[0] = tick[0] + xmult * this->MinorTickSize;
+    center[1] = tick[1] + ymult * this->MinorTickSize;
+    center[2] = tick[2];
+
+    viewport->SetWorldPoint(center[0], center[1], center[2], 1.0);
+    viewport->WorldToDisplay();
+    viewport->GetDisplayPoint(transpos);
+
+    int bbox[4];
+    if (!tren->GetBoundingBox(this->LabelActors2D[i]->GetTextProperty(),
+                              this->LabelActors2D[i]->GetInput(), bbox))
+      {
+      vtkErrorMacro(<< "Unable to calculate bounding box for label "
+                    << this->LabelActors2D[i]->GetInput());
+      continue;
+      }
+
+    double width  = (bbox[1]-bbox[0]);
+    double height = (bbox[3]-bbox[2]);
+
+    pos[0] = (transpos[0] - xadjust*width*xcoeff);
+    pos[1] = (transpos[1] - yadjust*height*ycoeff);
+    this->LabelActors2D[i]->SetPosition( pos[0], pos[1] );
+    }
+}
+
 
 // **********************************************************************
 //  Determines scale and position for the Title.  Currently,
 //  title can only be centered with respect to its axis.
-//
-//  Modifications:
-//    Kathleen Bonnell, Wed Nov  7 17:45:20 PST 2001
-//    Added logic for early-termination.
-//
-//    Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//    Test for modified bounds before early termination, use
-//    MinScale, modified target so title size is a bit more reasonable.
-//
-//    Kathleen Bonnell, Tue Apr  9 14:41:08 PDT 2002
-//    Removed MinScale as it allowed axes with very small ranges
-//    to have labels scaled too large for the dataset.
-//
-//    Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//    Added bool argument that allow the build to be forced, even if
-//    the title won't be visible.
-//
-//    Kathleen Bonnell, Tue Aug 31 16:17:43 PDT 2004
-//    Added TitleTime test so that the title can be rebuilt when its
-//    text has changed.
-//
-//    Hank Childs, Sun May 13 11:06:12 PDT 2007
-//    Fix bug with positioning of titles (the titles were being placed
-//    far away from the bounding box in some cases).
-//
-//    David Gobbi, Fri Apr 8 16:50:00 MST 2011
-//    Use mapper bounds, not actor bounds.
-//
 // **********************************************************************
-
 void vtkRpAxisActor::BuildTitle(bool force)
 {
+  this->NeedBuild2D = false;
   if (!force && !this->TitleVisibility)
     {
@@ -648 +919 @@
     }
 
+  this->NeedBuild2D = true;
   switch (this->AxisType)
     {
@@ -676 +948 @@
     maxHeight = (labHeight > maxHeight ? labHeight : maxHeight);
     }
+
   this->TitleVector->SetText(this->Title);
+
+  this->TitleActor->GetProperty()->SetColor(this->TitleTextProperty->GetColor());
   this->TitleActor->SetCamera(this->Camera);
   this->TitleActor->SetPosition(p2[0], p2[1], p2[2]);
   this->TitleActor->GetMapper()->GetBounds(titleBounds);
   this->TitleActor->GetScale(scale);
-  halfTitleWidth  = (titleBounds[1] - titleBounds[0]) * 0.5 * scale[0];
-  halfTitleHeight = (titleBounds[3] - titleBounds[2]) * 0.5 * scale[1];
+  if(!this->GetCalculateTitleOffset())
+    {
+    this->TitleActor->SetAutoCenter(1);
+    }
 
   center[0] = p1[0] + (p2[0] - p1[0]) / 2.0;
@@ -688 +965 @@
   center[2] = p1[2] + (p2[2] - p1[2]) / 2.0;
 
-  center[0] += xmult * (halfTitleWidth + maxWidth);
-  center[1] += ymult * (halfTitleHeight + 2*maxHeight);
-
-  pos[0] = center[0] - xmult*halfTitleWidth;
-  pos[1] = center[1] - ymult*halfTitleHeight;
+  if(this->CalculateTitleOffset)
+    {
+    halfTitleWidth  = (titleBounds[1] - titleBounds[0]) * 0.5 * scale[0];
+    halfTitleHeight = (titleBounds[3] - titleBounds[2]) * 0.5 * scale[1];
+    center[0] += xmult * (halfTitleWidth + maxWidth);
+    center[1] += ymult * (halfTitleHeight + 2*maxHeight);
+    }
+
+  pos[0] = center[0];
+  pos[1] = center[1];
   pos[2] = center[2];
+
   this->TitleActor->SetPosition(pos[0], pos[1], pos[2]);
+}
+
+// **********************************************************************
+//  Determines scale and position for the 2D Title.  Currently,
+//  title can only be centered with respect to its axis.
+// **********************************************************************
+void
+vtkRpAxisActor::BuildTitle2D(vtkViewport *viewport, bool force)
+{
+  if (!this->NeedBuild2D && !force && !this->TitleVisibility)
+    {
+    return;
+    }
+
+  // for textactor instead of follower
+  this->TitleActor2D->SetInput( this->TitleVector->GetText() );
+  this->TitleActor2D->GetProperty()->SetColor( this->TitleTextProperty->GetColor() );
+  this->TitleActor2D->GetProperty()->SetOpacity(1);
+  this->TitleActor2D->GetTextProperty()->SetFontSize( this->TitleTextProperty->GetFontSize() );
+  this->TitleActor2D->GetTextProperty()->SetVerticalJustificationToCentered();
+  this->TitleActor2D->GetTextProperty()->SetJustificationToCentered();
+
+  if (this->AxisType == VTK_AXIS_TYPE_Y)
+    {
+    if (strlen(this->TitleActor2D->GetInput()) > 2)
+      {
+      // warning : orientation have to be set on vtkTextActor and not on the vtkTextActor's vtkTextProperty
+      // otherwise there is a strange effect (first letter is not align with the others)
+      this->TitleActor2D->SetOrientation(90);
+      }
+    else
+      {
+      // if in the previous rendering, the orientation was set.
+      this->TitleActor2D->SetOrientation(0);
+      }
+    }
+
+  // stuff for 2D axis with TextActor
+  double transpos[3];
+  double* pos = this->TitleActor->GetPosition();
+  viewport->SetWorldPoint(pos[0], pos[1],  pos[2], 1.0);
+  viewport->WorldToDisplay();
+  viewport->GetDisplayPoint(transpos);
+  if (this->AxisType == VTK_AXIS_TYPE_X)
+    {
+    transpos[1] += this->VerticalOffsetXTitle2D;
+    }
+  else if (this->AxisType == VTK_AXIS_TYPE_Y)
+    {
+    transpos[0] += this->HorizontalOffsetYTitle2D;
+    }
+  if (transpos[1] < 10.) transpos[1] = 10.;
+  if (transpos[0] < 10.) transpos[0] = 10.;
+  if (this->SaveTitlePosition == 0)
+    {
+    this->TitleActor2D->SetPosition(transpos[0], transpos[1]);
+    }
+  else
+    {
+    if (this->SaveTitlePosition == 1)
+      {
+      TitleConstantPosition[0] = transpos[0];
+      TitleConstantPosition[1] = transpos[1];
+      this->SaveTitlePosition = 2;
+      }
+    this->TitleActor2D->SetPosition(TitleConstantPosition[0], TitleConstantPosition[1]);
+    }
 }
 
@@ -743 +1093 @@
 
 // ****************************************************************
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Call superclass's method in new VTK 4.0 way.
-// ****************************************************************
-
 void vtkRpAxisActor::PrintSelf(ostream& os, vtkIndent indent)
 {
@@ -755 +1100 @@
   os << indent << "Number Of Labels Built: "
      << this->NumberOfLabelsBuilt << "\n";
-  os << indent << "Range: (" << this->Range[0]
-     << ", " << this->Range[1] << ")\n";
+  os << indent << "Range: ("
+     << this->Range[0] << ", "
+     << this->Range[1] << ")\n";
 
   os << indent << "Label Format: " << this->LabelFormat << "\n";
@@ -795 +1141 @@
     }
 
-  os << indent << "DeltaMajor: " << this->DeltaMajor << endl;
+  os << indent << "DeltaMajor: "
+     << this->DeltaMajor[0] << ","
+     << this->DeltaMajor[1] << ","
+     << this->DeltaMajor[2] << endl;
   os << indent << "DeltaMinor: " << this->DeltaMinor << endl;
   os << indent << "DeltaRangeMajor: " << this->DeltaRangeMajor << endl;
@@ -804 +1153 @@
   os << indent << "MinorTicksVisible: " << this->MinorTicksVisible << endl;
 
+  os << indent << "TitleActor: ";
+  if(this->TitleActor)
+    {
+    os << indent << "TitleActor: (" << this->TitleActor << ")\n";
+    }
+  else
+    {
+    os << "(none)" << endl;
+    }
+
   os << indent << "Camera: ";
   if (this->Camera)
@@ -819 +1178 @@
   os << indent << "DrawGridlines: " << this->DrawGridlines << endl;
 
-  os << indent << "MajorStart: " << this->MajorStart << endl;
-  os << indent << "MinorStart: " << this->MinorStart << endl;
+  os << indent << "MajorStart: "
+     << this->MajorStart[0] << ","
+     << this->MajorStart[1] << ","
+     << this->MajorStart[2] << endl;
 
   os << indent << "AxisPosition: " << this->AxisPosition << endl;
@@ -828 +1189 @@
   os << indent << "GridlineZLength: " << this->GridlineZLength << endl;
 
+  os << indent << "DrawInnerGridpolys: " << this->DrawGridpolys << endl;
+  os << indent << "DrawInnerGridlines: " << this->DrawInnerGridlines << endl;
+
   os << indent << "TickLocation: " << this->TickLocation << endl;
-}
+
+  os << indent << "CalculateLabelOffset: " << this->CalculateLabelOffset << std::endl;
+  os << indent << "CalculateTitleOffset: " << this->CalculateTitleOffset << std::endl;
+
+  os << indent << "LabelTextProperty: " << this->LabelTextProperty << endl;
+  os << indent << "TitleTextProperty: " << this->TitleTextProperty << endl;
+
+  os << indent << "Use2DMode: " << this->Use2DMode << endl;
+  os << indent << "SaveTitlePosition: " << this->SaveTitlePosition << endl;
+  os << indent << "VerticalOffsetXTitle2D" << this->VerticalOffsetXTitle2D << endl;
+  os << indent << "HorizontalOffsetYTitle2D" << this->HorizontalOffsetYTitle2D << endl;
+  os << indent << "LastMinDisplayCoordinates: ("
+     << this->LastMinDisplayCoordinate[0] << ", "
+     << this->LastMinDisplayCoordinate[1] << ", "
+     << this->LastMinDisplayCoordinate[2] << ")" << endl;
+  os << indent << "LastMaxDisplayCoordinates: ("
+     << this->LastMaxDisplayCoordinate[0] << ", "
+     << this->LastMaxDisplayCoordinate[1] << ", "
+     << this->LastMaxDisplayCoordinate[2] << ")" << endl;
+  }
 
 // **************************************************************************
 // Sets text string for label vectors.  Allocates memory if necessary.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    July 18, 2003
 // **************************************************************************
 void vtkRpAxisActor::SetLabels(vtkStringArray *labels)
@@ -853 +1233 @@
         this->LabelMappers[i]->Delete();
         this->LabelActors[i]->Delete();
+        this->LabelActors2D[i]->Delete();
         }
       delete [] this->LabelVectors;
       delete [] this->LabelMappers;
       delete [] this->LabelActors;
+      delete [] this->LabelActors2D;
       }
 
     this->LabelVectors = new vtkVectorText * [numLabels];
     this->LabelMappers = new vtkPolyDataMapper * [numLabels];
-    this->LabelActors = new vtkFollower * [numLabels];
+    this->LabelActors  = new vtkRpAxisFollower * [numLabels];
+    this->LabelActors2D = new vtkTextActor * [numLabels];
 
     for (i = 0; i < numLabels; i++)
@@ -867 +1250 @@
       this->LabelVectors[i] = vtkVectorText::New();
       this->LabelMappers[i] = vtkPolyDataMapper::New();
-#ifdef USE_VTK6
-      this->LabelMappers[i]->SetInputData(this->LabelVectors[i]->GetOutput());
-#else
-      this->LabelMappers[i]->SetInput(this->LabelVectors[i]->GetOutput());
-#endif
-      this->LabelActors[i] = vtkFollower::New();
+      this->LabelMappers[i]->SetInputConnection(
+        this->LabelVectors[i]->GetOutputPort());
+      this->LabelActors[i] = vtkRpAxisFollower::New();
       this->LabelActors[i]->SetMapper(this->LabelMappers[i]);
+      this->LabelActors[i]->SetEnableDistanceLOD(0);
+      this->LabelActors[i]->GetProperty()->SetAmbient(1.);
+      this->LabelActors[i]->GetProperty()->SetDiffuse(0.);
+      this->LabelActors[i]->GetProperty()->SetColor(this->LabelTextProperty->GetColor());
+      this->LabelActors2D[i] = vtkTextActor::New();
       }
     }
@@ -883 +1268 @@
     {
     this->LabelVectors[i]->SetText(labels->GetValue(i).c_str());
+    this->LabelActors2D[i]->SetInput(this->LabelVectors[i]->GetText());
     }
   this->NumberOfLabelsBuilt = numLabels;
@@ -889 +1275 @@
 
 // **************************************************************************
-// Creates points for ticks (minor, major, gridlines) in correct position
-// for X-type axsis.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//   Compare vtkTimeStamps correctly.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Use defined constant VTK_MAX_TICKS to prevent infinite loops.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Allow a forced build, despite previous build time.
-//
-// **************************************************************************
-bool vtkRpAxisActor::BuildTickPointsForXType(double p1[3], double p2[3],
-                                           bool force)
-{
-  if (!force && (this->AxisPosition == this->LastAxisPosition) &&
-      (this->TickLocation == this->LastTickLocation ) &&
-      (this->BoundsTime.GetMTime() < this->BuildTime.GetMTime()))
-    {
-    return false;
-    }
-
-  double xPoint1[3], xPoint2[3], yPoint[3], zPoint[3], x;
-  int numTicks;
-
-  this->MinorTickPts->Reset();
-  this->MajorTickPts->Reset();
-  this->GridlinePts->Reset();
-
-  //
-  // Ymult & Zmult control adjustments to tick position based
-  // upon "where" this axis is located in relation to the underlying
-  // assumed bounding box.
-  //
-  int yMult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
-  int zMult = vtkRpAxisActorMultiplierTable2[this->AxisPosition];
-
-  //
-  // Build Minor Ticks
-  //
-  if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    xPoint1[1] = xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = xPoint2[2] = yPoint[2] = p1[2];
-    yPoint[1] = p1[1] + yMult * this->MinorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MinorTickSize;
-    }
-  else if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    yPoint[1] = xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = yPoint[2] = zPoint[2] = p1[2];
-    xPoint1[1] = p1[1] - yMult * this->MinorTickSize;
-    xPoint2[2] = p1[2] - zMult * this->MinorTickSize;
-    }
-  else // both sides
-    {
-    xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = yPoint[2] = p1[2];
-    yPoint[1] = p1[1] + yMult * this->MinorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MinorTickSize;
-    xPoint1[1] = p1[1] - yMult * this->MinorTickSize;
-    xPoint2[2] = p1[2] - zMult * this->MinorTickSize;
-    }
-  x = this->MinorStart;
-  numTicks = 0;
-  while (x <= p2[0] && numTicks < VTK_MAX_TICKS)
-    {
-    xPoint1[0] = xPoint2[0] = yPoint[0] = zPoint[0] = x;
-    // xy-portion
-    this->MinorTickPts->InsertNextPoint(xPoint1);
-    this->MinorTickPts->InsertNextPoint(yPoint);
-    // xz-portion
-    this->MinorTickPts->InsertNextPoint(xPoint2);
-    this->MinorTickPts->InsertNextPoint(zPoint);
-    x+= this->DeltaMinor;
-    numTicks++;
-    }
-
-  //
-  // Gridline points
-  //
-  yPoint[1] = xPoint2[1] = zPoint[1] = p1[1];
-  xPoint1[1] = p1[1] - yMult * this->GridlineYLength;
-  xPoint1[2] = yPoint[2] = zPoint[2] = p1[2];
-  xPoint2[2] = p1[2] - zMult * this->GridlineZLength;
-
-  x = this->MajorStart;
-  numTicks = 0;
-  while (x <= p2[0] && numTicks < VTK_MAX_TICKS)
-    {
-    xPoint1[0] = xPoint2[0] = yPoint[0] = zPoint[0] = x;
-    // xy-portion
-    this->GridlinePts->InsertNextPoint(xPoint1);
-    this->GridlinePts->InsertNextPoint(yPoint);
-    // xz-portion
-    this->GridlinePts->InsertNextPoint(xPoint2);
-    this->GridlinePts->InsertNextPoint(zPoint);
-    x += this->DeltaMajor;
-    numTicks++;
-    }
-
-  //
-  // Major ticks
-  //
-  if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    xPoint1[1] = xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = xPoint2[2] = yPoint[2] = p1[2];
-    yPoint[1] = p1[1] + yMult * this->MajorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MajorTickSize;
-    }
-  else if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    yPoint[1] = xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = yPoint[2] = zPoint[2] = p1[2];
-    xPoint1[1] = p1[1] - yMult * this->MajorTickSize;
-    xPoint2[2] = p1[2] - zMult * this->MajorTickSize;
-    }
-  else // both sides
-    {
-    xPoint2[1] = zPoint[1] = p1[1];
-    xPoint1[2] = yPoint[2] = p1[2];
-    yPoint[1] = p1[1] + yMult * this->MajorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MajorTickSize;
-    xPoint1[1] = p1[1] - yMult * this->MajorTickSize;
-    xPoint2[2] = p1[2] - zMult * this->MajorTickSize;
-    }
-  x = this->MajorStart;
-  numTicks = 0;
-  while (x <= p2[0] && numTicks < VTK_MAX_TICKS)
-    {
-    xPoint1[0] = xPoint2[0] = yPoint[0] = zPoint[0] = x;
-    // xy-portion
-    this->MajorTickPts->InsertNextPoint(xPoint1);
-    this->MajorTickPts->InsertNextPoint(yPoint);
-    // xz-portion
-    this->MajorTickPts->InsertNextPoint(xPoint2);
-    this->MajorTickPts->InsertNextPoint(zPoint);
-    x += this->DeltaMajor;
-    numTicks++;
-    }
-
-  return true;
-}
-
-// **************************************************************************
-// Creates points for ticks (minor, major, gridlines) in correct position
-// for Y-type axis.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//   Compare vtkTimeStamps correctly.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Use defined constant VTK_MAX_TICKS to prevent infinite loops.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Allow a forced build, despite previous build time.
-//
-// **************************************************************************
-bool vtkRpAxisActor::BuildTickPointsForYType(double p1[3], double p2[3],
-                                           bool force)
-{
-  if (!force && (this->AxisPosition  == this->LastAxisPosition) &&
-      (this->TickLocation == this->LastTickLocation) &&
-      (this->BoundsTime.GetMTime() < this->BuildTime.GetMTime()))
-    {
-    return false;
-    }
-
-  double yPoint1[3], yPoint2[3], xPoint[3], zPoint[3], y;
-  int numTicks;
-
-  this->MinorTickPts->Reset();
-  this->MajorTickPts->Reset();
-  this->GridlinePts->Reset();
-  //
-  // xMult & zMult control adjustments to tick position based
-  // upon "where" this axis is located in relation to the underlying
-  // assumed bounding box.
-  //
-
-  int xMult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
-  int zMult = vtkRpAxisActorMultiplierTable2[this->AxisPosition];
-
-  //
-  // The ordering of the tick endpoints is important because
-  // label position is defined by them.
-  //
-
-  //
-  // minor ticks
-  //
-  if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    yPoint1[2] = xPoint[2] = zPoint[2] = p1[2];
-    yPoint2[0] = xPoint[0] = zPoint[0] = p1[0];
-    yPoint1[0] = p1[0] - xMult * this->MinorTickSize;
-    yPoint2[2] = p1[2] - zMult * this->MinorTickSize;
-    }
-  else if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    yPoint1[0] = yPoint2[0] = zPoint[0] = p1[0];
-    yPoint1[2] = yPoint2[2] = xPoint[2] = p1[2];
-    xPoint[0] = p1[0] + xMult * this->MinorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MinorTickSize;
-    }
-  else                              // both sides
-    {
-    yPoint1[2] = xPoint[2] = p1[2];
-    yPoint2[0] = zPoint[0] = p1[0];
-    yPoint1[0] = p1[0] - xMult * this->MinorTickSize;
-    yPoint2[2] = p1[2] + zMult * this->MinorTickSize;
-    xPoint[0]  = p1[0] + xMult * this->MinorTickSize;
-    zPoint[2]  = p1[2] - zMult * this->MinorTickSize;
-    }
-  y = this->MinorStart;
-  numTicks = 0;
-  while (y < p2[1] && numTicks < VTK_MAX_TICKS)
-    {
-    yPoint1[1] = xPoint[1] = yPoint2[1] = zPoint[1] = y;
-    // yx portion
-    this->MinorTickPts->InsertNextPoint(yPoint1);
-    this->MinorTickPts->InsertNextPoint(xPoint);
-    // yz portion
-    this->MinorTickPts->InsertNextPoint(yPoint2);
-    this->MinorTickPts->InsertNextPoint(zPoint);
-    y += this->DeltaMinor;
-    numTicks++;
-    }
-
-  //
-  // gridlines
-  //
-  yPoint1[0] = p1[0] - xMult * this->GridlineXLength;
-  yPoint2[2] = p1[2] - zMult * this->GridlineZLength;
-  yPoint2[0] = xPoint[0] = zPoint[0]  = p1[0];
-  yPoint1[2] = xPoint[2] = zPoint[2]  = p1[2];
-
-  y = this->MajorStart;
-  numTicks = 0;
-  while (y <= p2[1] && numTicks < VTK_MAX_TICKS)
-    {
-    yPoint1[1] = xPoint[1] = yPoint2[1] = zPoint[1] = y;
-    // yx portion
-    this->GridlinePts->InsertNextPoint(yPoint1);
-    this->GridlinePts->InsertNextPoint(xPoint);
-    // yz portion
-    this->GridlinePts->InsertNextPoint(yPoint2);
-    this->GridlinePts->InsertNextPoint(zPoint);
-    y += this->DeltaMajor;
-    numTicks++;
-    }
-
-  //
-  // major ticks
-  //
-  if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    yPoint1[2] = xPoint[2] = zPoint[2] = p1[2];
-    yPoint2[0] = xPoint[0] = zPoint[0] = p1[0];
-    yPoint1[0] = p1[0] - xMult * this->MajorTickSize;
-    yPoint2[2] = p1[2] - zMult * this->MajorTickSize;
-    }
-  else if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    yPoint1[0] = yPoint2[0] = zPoint[0] = p1[0];
-    yPoint1[2] = yPoint2[2] = xPoint[2] = p1[2];
-    xPoint[0] = p1[0] + xMult * this->MajorTickSize;
-    zPoint[2] = p1[2] + zMult * this->MajorTickSize;
-    }
-  else                              // both sides
-    {
-    yPoint1[2] = xPoint[2] = p1[2];
-    yPoint2[0] = zPoint[0] = p1[0];
-    yPoint1[0] = p1[0] - xMult * this->MajorTickSize;
-    yPoint2[2] = p1[2] + zMult * this->MajorTickSize;
-    xPoint[0]  = p1[0] + xMult * this->MajorTickSize;
-    zPoint[2]  = p1[2] - zMult * this->MajorTickSize;
-    }
-  y = this->MajorStart;
-  numTicks = 0;
-  while (y <= p2[1] && numTicks < VTK_MAX_TICKS)
-    {
-    yPoint1[1] = xPoint[1] = yPoint2[1] = zPoint[1] = y;
-    // yx portion
-    this->MajorTickPts->InsertNextPoint(yPoint1);
-    this->MajorTickPts->InsertNextPoint(xPoint);
-    // yz portion
-    this->MajorTickPts->InsertNextPoint(yPoint2);
-    this->MajorTickPts->InsertNextPoint(zPoint);
-    y += this->DeltaMajor;
-    numTicks++;
-    }
-  return true;
-}
-
-// **************************************************************************
-// Creates points for ticks (minor, major, gridlines) in correct position
-// for Z-type axis.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//   Compare vtkTimeStamps correctly.
-//
-//   Kathleen Bonnell, Thu May 16 10:13:56 PDT 2002
-//   Use defined constant VTK_MAX_TICKS to prevent infinite loops.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Allow a forced build, despite previous build time.
-//
-// **************************************************************************
-
-bool vtkRpAxisActor::BuildTickPointsForZType(double p1[3], double p2[3],
-                                           bool force)
-{
-  if (!force && (this->AxisPosition  == this->LastAxisPosition) &&
-      (this->TickLocation == this->LastTickLocation) &&
-      (this->BoundsTime.GetMTime() < this->BuildTime.GetMTime()))
-    {
-    return false;
-    }
-
-  this->MinorTickPts->Reset();
-  this->MajorTickPts->Reset();
-  this->GridlinePts->Reset();
-
-  //
-  // xMult & yMult control adjustments to tick position based
-  // upon "where" this axis is located in relation to the underlying
-  // assumed bounding box.
-  //
-  int xMult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
-  int yMult = vtkRpAxisActorMultiplierTable2[this->AxisPosition];
-
-  double zPoint1[3], zPoint2[3], xPoint[3], yPoint[3], z;
-  int numTicks;
-
-  //
-  // The ordering of the tick endpoints is important because
-  // label position is defined by them.
-  //
-
-  //
-  // minor ticks
-  //
-  if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    zPoint1[0] = p1[0] - xMult * this->MinorTickSize;
-    zPoint2[1] = p1[1] - yMult * this->MinorTickSize;
-    zPoint2[0] = xPoint[0] = yPoint[0]  = p1[0];
-    zPoint1[1] = xPoint[1] = yPoint[1]  = p1[1];
-    }
-  else if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    xPoint[0]  = p1[0] + xMult * this->MinorTickSize;
-    yPoint[1]  = p1[1] +yMult * this->MinorTickSize;
-    zPoint1[0] = zPoint2[0] = yPoint[0] = p1[0];
-    zPoint1[1] = zPoint2[1] = xPoint[1] = p1[1];
-    }
-  else                              // both sides
-    {
-    zPoint1[0] = p1[0] - xMult * this->MinorTickSize;
-    xPoint[0]  = p1[0] + xMult * this->MinorTickSize;
-    zPoint2[1] = p1[1] - yMult * this->MinorTickSize;
-    yPoint[1]  = p1[1] + yMult * this->MinorTickSize;
-    zPoint1[1] = xPoint[1] = p1[1];
-    zPoint2[0] = yPoint[0] = p1[0];
-    }
-  z = this->MinorStart;
-  numTicks = 0;
-  while (z < p2[2] && numTicks < VTK_MAX_TICKS)
-    {
-    zPoint1[2] = zPoint2[2] = xPoint[2] = yPoint[2] = z;
-    // zx-portion
-    this->MinorTickPts->InsertNextPoint(zPoint1);
-    this->MinorTickPts->InsertNextPoint(xPoint);
-    // zy-portion
-    this->MinorTickPts->InsertNextPoint(zPoint2);
-    this->MinorTickPts->InsertNextPoint(yPoint);
-    z += this->DeltaMinor;
-    numTicks++;
-    }
-
-  //
-  // gridlines
-  //
-  zPoint1[0] = p1[0] - xMult * this->GridlineXLength;
-  zPoint2[1] = p1[1] - yMult * this->GridlineYLength;
-  zPoint1[1] = xPoint[1] = yPoint[1] = p1[1];
-  zPoint2[0] = xPoint[0] = yPoint[0] = p1[0];
-
-  z = this->MajorStart;
-  numTicks = 0;
-  while (z <= p2[2] && numTicks < VTK_MAX_TICKS)
-    {
-    zPoint1[2] = zPoint2[2] = xPoint[2] = yPoint[2] = z;
-    // zx-portion
-    this->GridlinePts->InsertNextPoint(zPoint1);
-    this->GridlinePts->InsertNextPoint(xPoint);
-    // zy-portion
-    this->GridlinePts->InsertNextPoint(zPoint2);
-    this->GridlinePts->InsertNextPoint(yPoint);
-    z += this->DeltaMajor;
-    numTicks++;
-    }
-
-  //
-  // major ticks
-  //
-
-  if (this->TickLocation == VTK_TICKS_INSIDE)
-    {
-    zPoint1[0] = p1[0] - xMult * this->MajorTickSize;
-    zPoint2[1] = p1[1] - yMult * this->MajorTickSize;
-    zPoint2[0] = xPoint[0] = yPoint[0]  = p1[0];
-    zPoint1[1] = xPoint[1] = yPoint[1]  = p1[1];
-    }
-  else if (this->TickLocation == VTK_TICKS_OUTSIDE)
-    {
-    xPoint[0]  = p1[0] + xMult * this->MajorTickSize;
-    yPoint[2]  = p1[1] + yMult * this->MajorTickSize;
-    zPoint1[0] = zPoint2[0] = yPoint[0] = p1[0];
-    zPoint1[1] = zPoint2[1] = xPoint[1] = p1[1];
-    }
-  else                              // both sides
-    {
-    zPoint1[0] = p1[0] - xMult * this->MajorTickSize;
-    xPoint[0]  = p1[0] + xMult * this->MajorTickSize;
-    zPoint2[1] = p1[1] - yMult * this->MajorTickSize;
-    yPoint[1]  = p1[1] + yMult * this->MajorTickSize;
-    zPoint1[1] = xPoint[1] = p1[1];
-    zPoint2[0] = yPoint[0] = p1[0];
-    }
-  z = this->MajorStart;
-  numTicks = 0;
-  while (z <= p2[2] && numTicks < VTK_MAX_TICKS)
-    {
-    zPoint1[2] = zPoint2[2] = xPoint[2] = yPoint[2] = z;
-    // zx-portion
-    this->MajorTickPts->InsertNextPoint(zPoint1);
-    this->MajorTickPts->InsertNextPoint(xPoint);
-    // zy-portion
-    this->MajorTickPts->InsertNextPoint(zPoint2);
-    this->MajorTickPts->InsertNextPoint(yPoint);
-    z += this->DeltaMajor;
-    numTicks++;
-    }
-  return true;
-}
-
-// **************************************************************************
 // Creates Poly data (lines) from tickmarks (minor/major), gridlines, and axis.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Thu Nov 15 13:20:44 PST 2001
-//   Make ptIds of type vtkIdType to match VTK 4.0 API.
-//
-//   Kathleen Bonnell, Thu Jul 18 13:24:03 PDT 2002
-//   Allow gridlines to be drawn when enabled, even if ticks are disabled.
-//
-//   Kathleen Bonnell, Fri Jul 25 15:10:24 PDT 2003
-//   Removed arguments.
-//
 // **************************************************************************
 void vtkRpAxisActor::SetAxisPointsAndLines()
@@ -1372 +1281 @@
   vtkPoints *pts = vtkPoints::New();
   vtkCellArray *lines = vtkCellArray::New();
-  this->Axis->SetPoints(pts);
-  this->Axis->SetLines(lines);
+  vtkCellArray *gridlines = vtkCellArray::New();
+  vtkCellArray *innerGridlines = vtkCellArray::New();
+  vtkCellArray *polys = vtkCellArray::New();
+  this->AxisLines->SetPoints(pts);
+  this->AxisLines->SetLines(lines);
+  this->Gridlines->SetPoints(this->GridlinePts);
+  this->Gridlines->SetLines(gridlines);
+  this->InnerGridlines->SetPoints(this->InnerGridlinePts);
+  this->InnerGridlines->SetLines(innerGridlines);
+  this->Gridpolys->SetPoints(this->GridpolyPts);
+  this->Gridpolys->SetPolys(polys);
   pts->Delete();
   lines->Delete();
-  int i, numPts, numLines;
+  gridlines->Delete();
+  innerGridlines->Delete();
+  polys->Delete();
+  int i, numMinorTickPts, numGridlines, numInnerGridlines, numMajorTickPts, numGridpolys, numLines;
   vtkIdType ptIds[2];
+  vtkIdType polyPtIds[4];
 
   if (this->TickVisibility)
@@ -1383 +1305 @@
     if (this->MinorTicksVisible)
       {
-      numPts = this->MinorTickPts->GetNumberOfPoints();
-      for (i = 0; i < numPts; i++)
+      // In 2D mode, the minorTickPts for yz portion or xz portion have been removed.
+      numMinorTickPts = this->MinorTickPts->GetNumberOfPoints();
+      for (i = 0; i < numMinorTickPts; i++)
         {
         pts->InsertNextPoint(this->MinorTickPts->GetPoint(i));
         }
       }
-
-    if (this->DrawGridlines)
-      {
-      numPts = this->GridlinePts->GetNumberOfPoints();
-      for (i = 0; i < numPts; i++)
-        {
-        pts->InsertNextPoint(this->GridlinePts->GetPoint(i));
-        }
-      }
-    else  // major tick points
-      {
-      numPts = this->MajorTickPts->GetNumberOfPoints();
-      for (i = 0; i < numPts; i++)
+    numMajorTickPts = this->MajorTickPts->GetNumberOfPoints();
+    if (this->Use2DMode == 0)
+      {
+      for (i = 0; i < numMajorTickPts; i++)
         {
         pts->InsertNextPoint(this->MajorTickPts->GetPoint(i));
         }
       }
-    }
-  else if (this->DrawGridlines) // grids are enabled but ticks are off
-    {
-    numPts = this->GridlinePts->GetNumberOfPoints();
-    for (i = 0; i < numPts; i++)
-      {
-      pts->InsertNextPoint(this->GridlinePts->GetPoint(i));
+    else
+      {
+      // In 2D mode, we don't need the pts for the xz portion or yz portion of the major tickmarks
+      // majorTickPts not modified because all points are used for labels' positions.
+      for (i = 0; i < numMajorTickPts; i+=4)
+        {
+        pts->InsertNextPoint(this->MajorTickPts->GetPoint(i));
+        pts->InsertNextPoint(this->MajorTickPts->GetPoint(i+1));
+        }
       }
     }
@@ -1433 +1349 @@
     lines->InsertNextCell(2, ptIds);
     }
+  // create grid lines
+  if (this->DrawGridlines && this->AxisOnOrigin == 0)
+    {
+    numGridlines = this->GridlinePts->GetNumberOfPoints()/2;
+    int start =
+        (this->DrawGridlinesLocation == 0 || this->DrawGridlinesLocation == 1)
+        ? 0 : 1;
+    int increment = (this->DrawGridlinesLocation == 0) ? 1 : 2;
+    for (i = start; i < numGridlines; i+=increment)
+      {
+      ptIds[0] = 2*i;
+      ptIds[1] = 2*i + 1;
+      gridlines->InsertNextCell(2, ptIds);
+      }
+    }
+
+  // create inner grid lines
+  if (this->DrawInnerGridlines && this->AxisOnOrigin == 0)
+    {
+    numInnerGridlines = this->InnerGridlinePts->GetNumberOfPoints()/2;
+    for (i=0; i < numInnerGridlines; i++)
+      {
+      ptIds[0] = 2*i;
+      ptIds[1] = 2*i + 1;
+      innerGridlines->InsertNextCell(2, ptIds);
+      }
+    }
+
+  // create polys (grid polys)
+  if (this->DrawGridpolys && this->AxisOnOrigin == 0)
+    {
+    numGridpolys = this->GridpolyPts->GetNumberOfPoints()/4;
+    for (i = 0; i < numGridpolys; i++)
+      {
+      polyPtIds[0] = 4*i;
+      polyPtIds[1] = 4*i + 1;
+      polyPtIds[2] = 4*i + 2;
+      polyPtIds[3] = 4*i + 3;
+      polys->InsertNextCell(4,polyPtIds);
+      }
+    }
 }
 
 // *********************************************************************
 // Returns true if any tick vis attribute has changed since last check.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
 // *********************************************************************
 bool vtkRpAxisActor::TickVisibilityChanged()
@@ -1456 +1410 @@
 // *********************************************************************
 // Set the bounds for this actor to use.  Sets timestamp BoundsModified.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
 // *********************************************************************
 void
@@ -1480 +1431 @@
 // *********************************************************************
 // Retrieves the bounds of this actor.
-// Set the bounds for this actor to use.  Sets timestamp BoundsModified.
-//
-// Programmer:  Will Schroeder
-// Creation:    December 8, 2010
 // *********************************************************************
 void vtkRpAxisActor::
@@ -1508 +1455 @@
 // *********************************************************************
 // Retrieves the bounds of this actor.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
 // *********************************************************************
 double* vtkRpAxisActor::GetBounds()
@@ -1519 +1463 @@
 // *********************************************************************
 // Retrieves the bounds of this actor.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
 // *********************************************************************
 
@@ -1534 +1475 @@
 // *********************************************************************
 // Method:  vtkRpAxisActor::ComputeMaxLabelLength
-//
-// Purpose: Determines the maximum length that a label will occupy
-//          if placed at point 'center' and with a scale of 1.
-//
-// Arguments:
-//   center    The position to use for the label actor
-//
-// Returns:
-//   the maximum length of all the labels, 0 if there are no labels.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    July 18, 2003
-//
-// Modifications:
-//   Kathleen Bonnell, Tue Dec 16 11:06:21 PST 2003
-//   Reset the actor's position and scale.
-//
-// Modifications:
-//   David Gobbi, Fri Apr 8 16:50:00 MST 2011
-//   Use mapper bounds, not actor bounds, so centering is not necessary.
-//
 // *********************************************************************
-
 double vtkRpAxisActor::ComputeMaxLabelLength(const double vtkNotUsed(center)[3])
 {
-  double length, maxLength = 0.;
   double bounds[6];
   double xsize, ysize;
+  vtkProperty *newProp = this->NewLabelProperty();
+  double maxXSize = 0;
+  double maxYSize = 0;
   for (int i = 0; i < this->NumberOfLabelsBuilt; i++)
     {
     this->LabelActors[i]->SetCamera(this->Camera);
-    this->LabelActors[i]->SetProperty(this->GetProperty());
+    this->LabelActors[i]->SetProperty(newProp);
     this->LabelActors[i]->GetMapper()->GetBounds(bounds);
+    this->LabelActors[i]->GetProperty()->SetColor(this->LabelTextProperty->GetColor());
     xsize = bounds[1] - bounds[0];
     ysize = bounds[3] - bounds[2];
-    length = sqrt(xsize*xsize + ysize*ysize);
-    maxLength = (length > maxLength ? length : maxLength);
-    }
-  return maxLength;
+    maxXSize = (xsize > maxXSize ? xsize : maxXSize);
+    maxYSize = (ysize > maxYSize ? ysize : maxYSize);
+    }
+  newProp->Delete();
+  return sqrt(maxXSize*maxXSize + maxYSize*maxYSize);
 }
 
 // *********************************************************************
 // Method:  vtkRpAxisActor::ComputeTitleLength
-//
-// Purpose: Determines the length that the title will occupy
-//          if placed at point 'center' and with a scale of 1.
-//
-// Arguments:
-//   center    The position to use for the title actor
-//
-// Returns:
-//   the length of all the title,
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    July 25, 2003
-//
-// Modifications:
-//   Kathleen Bonnell, Tue Dec 16 11:06:21 PST 2003
-//   Reset the actor's position and scale.
-//
-// Modifications:
-//   David Gobbi, Fri Apr 8 16:50:00 MST 2011
-//   Use mapper bounds, not actor bounds, so centering is not necessary.
-//
 // *********************************************************************
-
 double vtkRpAxisActor::ComputeTitleLength(const double vtkNotUsed(center)[3])
 {
@@ -1608 +1509 @@
   this->TitleVector->SetText(this->Title);
   this->TitleActor->SetCamera(this->Camera);
-  this->TitleActor->SetProperty(this->GetProperty());
+  vtkProperty * newProp = this->NewTitleProperty();
+  this->TitleActor->SetProperty(newProp);
+  newProp->Delete();
   this->TitleActor->GetMapper()->GetBounds(bounds);
+  this->TitleActor->GetProperty()->SetColor(this->TitleTextProperty->GetColor());
   xsize = bounds[1] - bounds[0];
   ysize = bounds[3] - bounds[2];
   length = sqrt(xsize*xsize + ysize*ysize);
+
   return length;
 }
 
 // *********************************************************************
-// Method:  vtkRpAxisActor::SetLabelScale
-//
-// Purpose: Sets the scaling factor for label actors.
-//
-// Arguments:
-//   s      The scale factor to use.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    July 18, 2003
-//
+void vtkRpAxisActor::SetLabelScale(const double s)
+{
+  for (int i=0; i < this->NumberOfLabelsBuilt; i++)
+    {
+    this->LabelActors[i]->SetScale(s);
+    }
+}
+
 // *********************************************************************
-
-void vtkRpAxisActor::SetLabelScale(const double s)
-{
-  for (int i=0; i < this->NumberOfLabelsBuilt; i++)
-    {
-    this->LabelActors[i]->SetScale(s);
-    }
+void vtkRpAxisActor::SetTitleScale(const double s)
+{
+  this->TitleActor->SetScale(s);
 }
 
 // *********************************************************************
-// Method:  vtkRpAxisActor::SetTitleScale
-//
-// Purpose: Sets the scaling factor for the title actor.
-//
-// Arguments:
-//   s      The scale factor to use.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    July 18, 2003
-//
-// *********************************************************************
-
-void vtkRpAxisActor::SetTitleScale(const double s)
-{
-  this->TitleActor->SetScale(s);
-}
-
-// *********************************************************************
-// Method:  vtkRpAxisActor::SetTitle
-//
-// Purpose: Sets the text for the title.
-//
-// Notes:   Not using vtkSetStringMacro so that the modification time of
-//          the text can be kept (so the title will be updated as
-//          appropriate when the text changes.)
-//
-// Arguments:
-//   t          The text to use.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    August 31, 2004
-//
-// *********************************************************************
-
 void vtkRpAxisActor::SetTitle(const char *t)
 {
@@ -1699 +1564 @@
 }
 
+// ****************************************************************************
+void vtkRpAxisActor::SetAxisLinesProperty(vtkProperty *prop)
+{
+  this->AxisLinesActor->SetProperty(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::GetAxisLinesProperty()
+{
+  return this->AxisLinesActor->GetProperty();
+}
+
+// ****************************************************************************
+void vtkRpAxisActor::SetGridlinesProperty(vtkProperty *prop)
+{
+  this->GridlinesActor->SetProperty(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::GetGridlinesProperty()
+{
+  return this->GridlinesActor->GetProperty();
+}
+
+// ****************************************************************************
+void vtkRpAxisActor::SetInnerGridlinesProperty(vtkProperty *prop)
+{
+  this->InnerGridlinesActor->SetProperty(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::GetInnerGridlinesProperty()
+{
+  return this->InnerGridlinesActor->GetProperty();
+}
+
+// ****************************************************************************
+void vtkRpAxisActor::SetGridpolysProperty(vtkProperty *prop)
+{
+  this->GridpolysActor->SetProperty(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::GetGridpolysProperty()
+{
+  return this->GridpolysActor->GetProperty();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::NewTitleProperty()
+{
+  vtkProperty *newProp = vtkProperty::New();
+  newProp->DeepCopy(this->GetProperty());
+  newProp->SetColor(this->TitleTextProperty->GetColor());
+  // We pass the opacity in the line offset.
+  //newProp->SetOpacity(this->TitleTextProperty->GetLineOffset());
+  return newProp;
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpAxisActor::NewLabelProperty()
+{
+  vtkProperty *newProp = vtkProperty::New();
+  newProp->DeepCopy(this->GetProperty());
+  newProp->SetColor(this->LabelTextProperty->GetColor());
+  // We pass the opacity in the line offset.
+  //newProp->SetOpacity(this->LabelTextProperty->GetLineOffset());
+  return newProp;
+}
+
+
+// ****************************************************************************
+double vtkRpAxisActor::GetDeltaMajor(int axis){
+  if(axis>=0 && axis<=2)
+    {
+    return (this->DeltaMajor[axis]);
+    }
+  return 0;
+}
+
+void vtkRpAxisActor::SetDeltaMajor(int axis, double value){
+  if(axis>=0 && axis<=2)
+    {
+    this->DeltaMajor[axis] = value;
+    }
+}
+
+// ****************************************************************************
+double vtkRpAxisActor::GetMajorStart(int axis){
+  if(axis>=0 && axis<=2)
+    {
+    return (this->MajorStart[axis]);
+    }
+  return 0;
+}
+
+// ****************************************************************************
+void vtkRpAxisActor::SetMajorStart(int axis, double value){
+  if(axis>=0 && axis<=2)
+    {
+    this->MajorStart[axis] = value;
+    }
+}
+
+// ****************************************************************************
+bool vtkRpAxisActor::BoundsDisplayCoordinateChanged(vtkViewport *viewport)
+{
+  double transMinPt[3], transMaxPt[3];
+  viewport->SetWorldPoint(this->Bounds[0], this->Bounds[2], this->Bounds[4], 1.0);
+  viewport->WorldToDisplay();
+  viewport->GetDisplayPoint(transMinPt);
+  viewport->SetWorldPoint(this->Bounds[1], this->Bounds[3], this->Bounds[5], 1.0);
+  viewport->WorldToDisplay();
+  viewport->GetDisplayPoint(transMaxPt);
+
+  if( this->LastMinDisplayCoordinate[0] != transMinPt[0]
+      || this->LastMinDisplayCoordinate[1] != transMinPt[1]
+      || this->LastMinDisplayCoordinate[2] != transMinPt[2]
+      || this->LastMaxDisplayCoordinate[0] != transMaxPt[0]
+      || this->LastMaxDisplayCoordinate[1] != transMaxPt[1]
+      || this->LastMaxDisplayCoordinate[2] != transMaxPt[2] )
+    {
+    int i = 0;
+    for( i=0 ; i<3 ; ++i )
+      {
+      this->LastMinDisplayCoordinate[i] = transMinPt[i];
+      this->LastMaxDisplayCoordinate[i] = transMaxPt[i];
+      }
+    return true;
+    }
+
+  return false;
+}
 //---------------------------------------------------------------------------
 // endpoint-related methods
@@ -1709 +1711 @@
 }
 
+//---------------------------------------------------------------------------
 vtkCoordinate* vtkRpAxisActor::GetPoint2Coordinate()
 {
@@ -1717 +1720 @@
 }
 
+//---------------------------------------------------------------------------
 void vtkRpAxisActor::SetPoint1(double x, double y, double z)
 {
@@ -1722 +1726 @@
 }
 
+//---------------------------------------------------------------------------
 void vtkRpAxisActor::SetPoint2(double x, double y, double z)
 {
@@ -1727 +1732 @@
 }
 
+//---------------------------------------------------------------------------
 double* vtkRpAxisActor::GetPoint1()
 {
@@ -1732 +1738 @@
 }
 
+//---------------------------------------------------------------------------
 double* vtkRpAxisActor::GetPoint2()
 {
   return this->Point2Coordinate->GetValue();
 }
+// **************************************************************************
+// Creates points for ticks (minor, major, gridlines) in correct position
+// for a generic axis.
+// **************************************************************************
+bool vtkRpAxisActor::BuildTickPoints(double p1[3], double p2[3], bool force)
+{
+  // Prevent any unwanted computation
+  if (!force && (this->AxisPosition == this->LastAxisPosition) &&
+      (this->TickLocation == this->LastTickLocation ) &&
+      (this->BoundsTime.GetMTime() < this->BuildTime.GetMTime()) &&
+      (this->Point1Coordinate->GetMTime() < this->BuildTickPointsTime.GetMTime()) &&
+      (this->Point2Coordinate->GetMTime() < this->BuildTickPointsTime.GetMTime()) &&
+      (this->Range[0] == this->LastRange[0]) &&
+      (this->Range[1] == this->LastRange[1]))
+    {
+    return false;
+    }
+
+  // Local tmp vars
+  double uPointInside[3], vPointInside[3], uPointOutside[3], vPointOutside[3];
+  double gridPointClosest[3], gridPointFarest[3], gridPointU[3], gridPointV[3];
+  double innerGridPointClosestU[3], innerGridPointClosestV[3];
+  double innerGridPointFarestU[3], innerGridPointFarestV[3];
+  double deltaVector[3];
+  double axisLength, axisShift, rangeScale, nbIterationAsDouble;
+  int nbTicks, i, nbIteration, uIndex, vIndex;
+  uIndex = vIndex = 0;
+  bool hasOrthogonalVectorBase =
+      (this->AxisBaseForX[0] == 1 && this->AxisBaseForX[1] == 0 && this->AxisBaseForX[2] == 0
+       && this->AxisBaseForY[0] == 0 && this->AxisBaseForY[1] == 1 && this->AxisBaseForY[2] == 0
+       && this->AxisBaseForZ[0] == 0 && this->AxisBaseForZ[1] == 0 && this->AxisBaseForZ[2] == 1);
+
+  // Reset previous objects
+  this->MinorTickPts->Reset();
+  this->MajorTickPts->Reset();
+  this->GridlinePts->Reset();
+  this->InnerGridlinePts->Reset();
+  this->GridpolyPts->Reset();
+
+  // As we assume that the Axis is not necessery alined to the absolute X/Y/Z
+  // axis, we will convert the absolut XYZ information to relative one
+  // using a base composed as follow (axis, u, v)
+  double uGridLength, vGridLength;
+  uGridLength = vGridLength = 0;
+  double *axisVector, *uVector, *vVector;
+  axisVector = uVector = vVector = NULL;
+  int uMult = vtkRpAxisActorMultiplierTable1[this->AxisPosition];
+  int vMult = vtkRpAxisActorMultiplierTable2[this->AxisPosition];
+
+  switch(this->AxisType)
+    {
+  case VTK_AXIS_TYPE_X:
+    uGridLength = this->GridlineYLength;
+    vGridLength = this->GridlineZLength;
+    axisVector = this->AxisBaseForX;
+    uVector = this->AxisBaseForY;
+    vVector = this->AxisBaseForZ;
+    uIndex = 1; vIndex = 2;
+    break;
+  case VTK_AXIS_TYPE_Y:
+    uGridLength = this->GridlineXLength;
+    vGridLength = this->GridlineZLength;
+    uVector = this->AxisBaseForX;
+    axisVector = this->AxisBaseForY;
+    vVector = this->AxisBaseForZ;
+    uIndex = 0; vIndex = 2;
+    break;
+  case VTK_AXIS_TYPE_Z:
+    uGridLength = this->GridlineXLength;
+    vGridLength = this->GridlineYLength;
+    uVector = this->AxisBaseForX;
+    vVector = this->AxisBaseForY;
+    axisVector = this->AxisBaseForZ;
+    uIndex = 0; vIndex = 1;
+    break;
+    }
+
+  // **************************************************************************
+  // Build Minor Ticks
+  // **************************************************************************
+  {
+  // - Initialize all points to be on the axis
+  for(i=0;i<3;i++)
+    {
+    uPointInside[i] = vPointInside[i] = uPointOutside[i] = vPointOutside[i] = p1[i];
+    deltaVector[i] = (p2[i] - p1[i]);
+    }
+  axisLength = vtkMath::Norm(deltaVector);
+  rangeScale = axisLength/(this->Range[1] - this->Range[0]);
+
+  // - Reduce the deltaVector to correspond to a tick step
+  vtkMath::Normalize(deltaVector);
+  for(i=0;i<3;i++)
+    {
+    deltaVector[i] *= this->DeltaMinor;
+    }
+
+  // - Move outside points if needed (Axis -> Outside)
+  if (this->TickLocation == VTK_TICKS_OUTSIDE || this->TickLocation == VTK_TICKS_BOTH)
+    {
+    for(i=0;i<3;i++)
+      {
+      uPointOutside[i] += uVector[i] * uMult * this->MinorTickSize;
+      vPointOutside[i] += vVector[i] * vMult * this->MinorTickSize;
+      }
+    }
+
+  // - Move inside points if needed (Axis -> Inside)
+  if (this->TickLocation == VTK_TICKS_INSIDE || this->TickLocation == VTK_TICKS_BOTH)
+    {
+    for(i=0;i<3;i++)
+      {
+      uPointInside[i] -= uVector[i] * uMult * this->MinorTickSize;
+      vPointInside[i] -= vVector[i] * vMult * this->MinorTickSize;
+      }
+    }
+
+  // - Add the initial shift if any
+  axisShift = (this->MinorRangeStart - this->Range[0])*rangeScale;
+  for(i=0;i<3;i++)
+    {
+    uPointInside[i] += axisVector[i] * axisShift;
+    vPointInside[i] += axisVector[i] * axisShift;
+    uPointOutside[i] += axisVector[i] * axisShift;
+    vPointOutside[i] += axisVector[i] * axisShift;
+    }
+
+  // - Insert tick points along the axis using the deltaVector
+  nbIterationAsDouble = axisLength / vtkMath::Norm(deltaVector);
+  nbIteration = vtkMath::Floor(nbIterationAsDouble+2*DBL_EPSILON);
+  nbIteration = (nbIteration < VTK_MAX_TICKS) ? nbIteration : VTK_MAX_TICKS;
+  for (nbTicks = 0; nbTicks < nbIteration; nbTicks++)
+    {
+    // axis/u side
+    this->MinorTickPts->InsertNextPoint(uPointInside);
+    this->MinorTickPts->InsertNextPoint(uPointOutside);
+    vtkMath::Add(deltaVector, uPointInside, uPointInside);
+    vtkMath::Add(deltaVector, uPointOutside, uPointOutside);
+    if( this->Use2DMode == 0 )
+      {
+      // axis/v side
+      this->MinorTickPts->InsertNextPoint(vPointInside);
+      this->MinorTickPts->InsertNextPoint(vPointOutside);
+      vtkMath::Add(deltaVector, vPointInside, vPointInside);
+      vtkMath::Add(deltaVector, vPointOutside, vPointOutside);
+      }
+    }
+  }
+  // **************************************************************************
+  // Build Gridline + GridPoly points + InnerGrid (Only for Orthonormal base)
+  // **************************************************************************
+  {
+  // - Initialize all points to be on the axis
+  for(i=0;i<3;i++)
+    {
+    gridPointClosest[i] = gridPointFarest[i] = gridPointU[i] = gridPointV[i] = p1[i];
+    deltaVector[i] = (p2[i] - p1[i]);
+    }
+
+  // - Reduce the deltaVector to correspond to a major tick step
+  vtkMath::Normalize(deltaVector);
+  for(i=0;i<3;i++)
+    {
+    deltaVector[i] *= this->DeltaMajor[this->AxisType];
+    }
+
+  // - Move base points
+  for(i=0;i<3;i++)
+    {
+    gridPointU[i] -= uVector[i] * uMult * uGridLength;
+    gridPointV[i] -= vVector[i] * vMult * vGridLength;
+    gridPointFarest[i] -= uVector[i] * uMult * uGridLength + vVector[i] * vMult * vGridLength;
+    }
+
+  // - Add the initial shift if any
+  axisShift = (this->MajorRangeStart - this->Range[0])*rangeScale;
+  for(i=0;i<3;i++)
+    {
+    gridPointU[i] += axisVector[i] * axisShift;
+    gridPointV[i] += axisVector[i] * axisShift;
+    gridPointFarest[i] += axisVector[i] * axisShift;
+    gridPointClosest[i] += axisVector[i] * axisShift;
+    }
+
+  // - Insert Gridlines points along the axis using the DeltaMajor vector
+  nbIterationAsDouble = (axisLength - axisShift) / vtkMath::Norm(deltaVector);
+  nbIteration = vtkMath::Floor(nbIterationAsDouble+2*FLT_EPSILON) + 1;
+  nbIteration = (nbIteration < VTK_MAX_TICKS) ? nbIteration : VTK_MAX_TICKS;
+  for (nbTicks = 0; nbTicks < nbIteration; nbTicks++)
+    {
+    // Closest U
+    this->GridlinePts->InsertNextPoint(gridPointClosest);
+    this->GridlinePts->InsertNextPoint(gridPointU);
+
+    // Farest U
+    this->GridlinePts->InsertNextPoint(gridPointFarest);
+    this->GridlinePts->InsertNextPoint(gridPointU);
+
+    // Closest V
+    this->GridlinePts->InsertNextPoint(gridPointClosest);
+    this->GridlinePts->InsertNextPoint(gridPointV);
+
+    // Farest V
+    this->GridlinePts->InsertNextPoint(gridPointFarest);
+    this->GridlinePts->InsertNextPoint(gridPointV);
+
+    // PolyPoints
+    this->GridpolyPts->InsertNextPoint(gridPointClosest);
+    this->GridpolyPts->InsertNextPoint(gridPointU);
+    this->GridpolyPts->InsertNextPoint(gridPointFarest);
+    this->GridpolyPts->InsertNextPoint(gridPointV);
+
+    // Move forward along the axis
+    for(i=0;i<3;i++)
+      {
+      gridPointClosest[i] += deltaVector[i];
+      gridPointU[i] += deltaVector[i];
+      gridPointFarest[i] += deltaVector[i];
+      gridPointV[i] += deltaVector[i];
+      }
+    }
+
+  // - Insert InnerGridLines points
+
+  // We can only handle inner grid line with orthonormal base, otherwise
+  // we would need to change the API of AxisActor which we don't want for
+  // backward compatibility.
+  if(hasOrthogonalVectorBase)
+    {
+    double axis, u, v;
+    axis = this->MajorStart[this->AxisType];
+    innerGridPointClosestU[vIndex] = this->GetBounds()[vIndex*2];
+    innerGridPointFarestU[vIndex] = this->GetBounds()[vIndex*2+1];
+    innerGridPointClosestV[uIndex] = this->GetBounds()[uIndex*2];
+    innerGridPointFarestV[uIndex] = this->GetBounds()[uIndex*2+1];
+    while (axis <= p2[this->AxisType])
+        {
+        innerGridPointClosestU[this->AxisType]
+            = innerGridPointClosestV[this->AxisType]
+            = innerGridPointFarestU[this->AxisType]
+            = innerGridPointFarestV[this->AxisType]
+            = axis;
+
+        // u lines
+        u = this->MajorStart[uIndex];
+        while (u <= p2[uIndex] && this->DeltaMajor[uIndex] > 0)
+          {
+          innerGridPointClosestU[uIndex]
+              = innerGridPointFarestU[uIndex]
+              = u;
+          this->InnerGridlinePts->InsertNextPoint(innerGridPointClosestU);
+          this->InnerGridlinePts->InsertNextPoint(innerGridPointFarestU);
+          u += this->DeltaMajor[uIndex];
+          }
+
+        // v lines
+        v = this->MajorStart[vIndex];
+        while (v <= p2[vIndex] && this->DeltaMajor[vIndex] > 0)
+          {
+          innerGridPointClosestV[vIndex]
+              = innerGridPointFarestV[vIndex]
+              = v;
+          this->InnerGridlinePts->InsertNextPoint(innerGridPointClosestV);
+          this->InnerGridlinePts->InsertNextPoint(innerGridPointFarestV);
+          v += this->DeltaMajor[vIndex];
+          }
+
+        axis += this->DeltaMajor[this->AxisType];
+        }
+    }
+  }
+  // **************************************************************************
+  // Build Major ticks
+  // **************************************************************************
+  {
+  // Delta vector is already initialized with the Major tick scale
+  // - Initialize all points to be on the axis
+  for(i=0;i<3;i++)
+    {
+    uPointInside[i] = vPointInside[i] = uPointOutside[i] = vPointOutside[i] = p1[i];
+    }
+
+  // - Move outside points if needed (Axis -> Outside)
+  if (this->TickLocation == VTK_TICKS_OUTSIDE || this->TickLocation == VTK_TICKS_BOTH)
+    {
+    for(i=0;i<3;i++)
+      {
+      uPointOutside[i] += uVector[i] * uMult * this->MajorTickSize;
+      vPointOutside[i] += vVector[i] * vMult * this->MajorTickSize;
+      }
+    }
+
+  // - Move inside points if needed (Axis -> Inside)
+  if (this->TickLocation == VTK_TICKS_INSIDE || this->TickLocation == VTK_TICKS_BOTH)
+    {
+    for(i=0;i<3;i++)
+      {
+      uPointInside[i] -= uVector[i] * uMult * this->MajorTickSize;
+      vPointInside[i] -= vVector[i] * vMult * this->MajorTickSize;
+      }
+    }
+
+  // - Add the initial shift if any
+  for(i=0;i<3;i++)
+    {
+    uPointInside[i] += axisVector[i] * axisShift;
+    vPointInside[i] += axisVector[i] * axisShift;
+    uPointOutside[i] += axisVector[i] * axisShift;
+    vPointOutside[i] += axisVector[i] * axisShift;
+    }
+
+  // - Insert tick points along the axis using the deltaVector
+  for (nbTicks = 0; nbTicks < nbIteration; nbTicks++)
+    {
+    // axis/u side
+    this->MajorTickPts->InsertNextPoint(uPointInside);
+    this->MajorTickPts->InsertNextPoint(uPointOutside);
+    vtkMath::Add(deltaVector, uPointInside, uPointInside);
+    vtkMath::Add(deltaVector, uPointOutside, uPointOutside);
+
+    // axis/v side
+    this->MajorTickPts->InsertNextPoint(vPointInside);
+    this->MajorTickPts->InsertNextPoint(vPointOutside);
+    vtkMath::Add(deltaVector, vPointInside, vPointInside);
+    vtkMath::Add(deltaVector, vPointOutside, vPointOutside);
+    }
+  }
+
+  this->BuildTickPointsTime.Modified();
+  this->LastTickLocation = this->TickLocation;
+  return true;
+}

trunk/packages/vizservers/vtkvis/vtkRpAxisActor.h

@@ -1 +1 @@
 /*=========================================================================
 
-  Program:   Visualization Toolkit
-  Module:    vtkRpAxisActor.h
-  Language:  C++
-  Date:      $Date$
-  Version:   $Revision$
-  Thanks:    Kathleen Bonnell, B Division, Lawrence Livermore Nat'l Laboratory
+Program:   Visualization Toolkit
+Module:    vtkRpAxisActor.h
+Language:  C++
+Date:      $Date$
+Version:   $Revision$
+Thanks:    Kathleen Bonnell, B Division, Lawrence Livermore Nat'l Laboratory
 
 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.
+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.
 =========================================================================*/
 // .NAME vtkRpAxisActor - Create an axis with tick marks and labels
@@ -37 +37 @@
 // All calculations and references are in World Coordinates.
 //
-// .SECTION Notes
-// This class was adapted from a 2D version created by Hank Childs called
-// vtkHankAxisActor2D.
+// .SECTION Thanks
+// This class was written by:
+// Hank Childs, Kathleen Bonnell, Amy Squillacote, Brad Whitlock,
+// Eric Brugger, Claire Guilbaud, Nicolas Dolegieviez, Will Schroeder,
+// Karthik Krishnan, 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.
 //
 // .SECTION See Also
@@ -47 +52 @@
 #define __vtkRpAxisActor_h
 
+#include "vtkRenderingAnnotationModule.h" // For export macro
 #include "vtkActor.h"
 
@@ -65 +71 @@
 #define VTK_AXIS_POS_MAXMIN 3
 
-// ****************************************************************************
-//  Modifications:
-//    Kathleen Bonnell, Tue Aug 31 16:17:43 PDT 2004
-//    Added TitleTextTime timestamp, so that title can be updated appropriately
-//    when its text changes.  Changed Titles Set macro for a user-defined
-//    set so TitleTextTime can be updated.
-//
-// ****************************************************************************
-
+class vtkRpAxisFollower;
 class vtkCamera;
 class vtkCoordinate;
@@ -80 +78 @@
 class vtkPolyData;
 class vtkPolyDataMapper;
+class vtkProperty2D;
 class vtkStringArray;
+class vtkTextActor;
+class vtkTextProperty;
 class vtkVectorText;
 
-class VTK_HYBRID_EXPORT vtkRpAxisActor : public vtkActor
+class VTKRENDERINGANNOTATION_EXPORT vtkRpAxisActor : public vtkActor
 {
-public:
+ public:
   vtkTypeMacro(vtkRpAxisActor,vtkActor);
   void PrintSelf(ostream& os, vtkIndent indent);
@@ -97 +98 @@
   virtual vtkCoordinate *GetPoint1Coordinate();
   virtual void SetPoint1(double x[3])
-    { this->SetPoint1(x[0], x[1], x[2]); }
+  { this->SetPoint1(x[0], x[1], x[2]); }
   virtual void SetPoint1(double x, double y, double z);
   virtual double *GetPoint1();
@@ -105 +106 @@
   virtual vtkCoordinate *GetPoint2Coordinate();
   virtual void SetPoint2(double x[3])
-    { this->SetPoint2(x[0], x[1], x[2]); }
+  { this->SetPoint2(x[0], x[1], x[2]); }
   virtual void SetPoint2(double x, double y, double z);
   virtual double *GetPoint2();
@@ -155 +156 @@
 
   void SetTickLocationToInside(void)
-    { this->SetTickLocation(VTK_TICKS_INSIDE); };
+  { this->SetTickLocation(VTK_TICKS_INSIDE); };
   void SetTickLocationToOutside(void)
-    { this->SetTickLocation(VTK_TICKS_OUTSIDE); };
+  { this->SetTickLocation(VTK_TICKS_OUTSIDE); };
   void SetTickLocationToBoth(void)
-    { this->SetTickLocation(VTK_TICKS_BOTH); };
+  { this->SetTickLocation(VTK_TICKS_BOTH); };
 
   // Description:
@@ -186 +187 @@
 
   // Description:
+  // Set/Get the axis title text property.
+  virtual void SetTitleTextProperty(vtkTextProperty *p);
+  vtkGetObjectMacro(TitleTextProperty,vtkTextProperty);
+
+  // Description:
+  // Set/Get the axis labels text property.
+  virtual void SetLabelTextProperty(vtkTextProperty *p);
+  vtkGetObjectMacro(LabelTextProperty,vtkTextProperty);
+
+  // Description:
+  // Get/Set axis actor property (axis and its ticks)
+  void SetAxisLinesProperty(vtkProperty *);
+  vtkProperty* GetAxisLinesProperty();
+
+  // Description:
+  // Get/Set gridlines actor property (outer grid lines)
+  void SetGridlinesProperty(vtkProperty *);
+  vtkProperty* GetGridlinesProperty();
+
+  // Description:
+  // Get/Set inner gridlines actor property
+  void SetInnerGridlinesProperty(vtkProperty *);
+  vtkProperty* GetInnerGridlinesProperty();
+
+  // Description:
+  // Get/Set gridPolys actor property (grid quads)
+  void SetGridpolysProperty(vtkProperty *);
+  vtkProperty* GetGridpolysProperty();
+
+  // Description:
   // Set/Get whether gridlines should be drawn.
   vtkSetMacro(DrawGridlines, int);
   vtkGetMacro(DrawGridlines, int);
   vtkBooleanMacro(DrawGridlines, int);
+
+  // Description:
+  // Set/Get whether ONLY the gridlines should be drawn.
+  // This will only draw GridLines and will skip any other part of the rendering
+  // such as Axis/Tick/Title/...
+  vtkSetMacro(DrawGridlinesOnly, int);
+  vtkGetMacro(DrawGridlinesOnly, int);
+  vtkBooleanMacro(DrawGridlinesOnly, int);
+
+  vtkSetMacro(DrawGridlinesLocation, int);
+  vtkGetMacro(DrawGridlinesLocation, int);
+
+  // Description:
+  // Set/Get whether inner gridlines should be drawn.
+  vtkSetMacro(DrawInnerGridlines, int);
+  vtkGetMacro(DrawInnerGridlines, int);
+  vtkBooleanMacro(DrawInnerGridlines, int);
 
   // Description:
@@ -199 +247 @@
   vtkSetMacro(GridlineZLength, double);
   vtkGetMacro(GridlineZLength, double);
+
+  // Description:
+  // Set/Get whether gridpolys should be drawn.
+  vtkSetMacro(DrawGridpolys, int);
+  vtkGetMacro(DrawGridpolys, int);
+  vtkBooleanMacro(DrawGridpolys, int);
 
   // Description:
@@ -219 +273 @@
 
   void SetAxisPositionToMinMin(void)
-      { this->SetAxisPosition(VTK_AXIS_POS_MINMIN); };
+  { this->SetAxisPosition(VTK_AXIS_POS_MINMIN); };
   void SetAxisPositionToMinMax(void)
-      { this->SetAxisPosition(VTK_AXIS_POS_MINMAX); };
+  { this->SetAxisPosition(VTK_AXIS_POS_MINMAX); };
   void SetAxisPositionToMaxMax(void)
-      { this->SetAxisPosition(VTK_AXIS_POS_MAXMAX); };
+  { this->SetAxisPosition(VTK_AXIS_POS_MAXMAX); };
   void SetAxisPositionToMaxMin(void)
-      { this->SetAxisPosition(VTK_AXIS_POS_MAXMIN); };
+  { this->SetAxisPosition(VTK_AXIS_POS_MAXMIN); };
 
   // Description:
@@ -236 +290 @@
   // Draw the axis.
   virtual int RenderOpaqueGeometry(vtkViewport* viewport);
-  virtual int RenderTranslucentGeometry(vtkViewport *) {return 0;}
+  virtual int RenderTranslucentGeometry(vtkViewport* viewport);
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport* viewport);
+  virtual int RenderOverlay(vtkViewport* viewport);
+  int HasTranslucentPolygonalGeometry();
 
   // Description:
@@ -243 +300 @@
   // resources to release.
   void ReleaseGraphicsResources(vtkWindow *);
-
-  // Description:
-  // Shallow copy of an axis actor. Overloads the virtual vtkProp method.
-  void ShallowCopy(vtkProp *prop);
 
 //BTX
@@ -255 +308 @@
   void SetTitleScale(const double);
 
-
   // Description:
   // Set/Get the starting position for minor and major tick points,
@@ -261 +313 @@
   vtkSetMacro(MinorStart, double);
   vtkGetMacro(MinorStart, double);
-  vtkSetMacro(MajorStart, double);
-  vtkGetMacro(MajorStart, double);
+  double GetMajorStart(int axis);
+  void SetMajorStart(int axis,double value);
+  //vtkSetMacro(MajorStart, double);
+  //vtkGetMacro(MajorStart, double);
   vtkSetMacro(DeltaMinor, double);
   vtkGetMacro(DeltaMinor, double);
-  vtkSetMacro(DeltaMajor, double);
-  vtkGetMacro(DeltaMajor, double);
+  double GetDeltaMajor(int axis);
+  void SetDeltaMajor(int axis,double value);
+  //vtkSetMacro(DeltaMajor, double);
+  //vtkGetMacro(DeltaMajor, double);
 
   // Description:
@@ -288 +344 @@
   void BuildAxis(vtkViewport *viewport, bool);
 
-protected:
+//BTX
+  // Description:
+  // Get title actor and it is responsible for drawing
+  // title text.
+  vtkGetObjectMacro(TitleActor,  vtkRpAxisFollower);
+
+  // Description:
+  // Get label actors responsigle for drawing label text.
+  inline vtkRpAxisFollower** GetLabelActors()
+    {
+    return this->LabelActors;
+    }
+//ETX
+
+  // Description:
+  // Get total number of labels built. Once built
+  // this count does not change.
+  vtkGetMacro(NumberOfLabelsBuilt, int);
+
+  // Description:
+  // Set/Get flag whether to calculate title offset.
+  // Default is true.
+  vtkSetMacro(CalculateTitleOffset, int);
+  vtkGetMacro(CalculateTitleOffset, int);
+  vtkBooleanMacro(CalculateTitleOffset, int);
+
+  // Description:
+  // Set/Get flag whether to calculate label offset.
+  // Default is true.
+  vtkSetMacro(CalculateLabelOffset, int);
+  vtkGetMacro(CalculateLabelOffset, int);
+  vtkBooleanMacro(CalculateLabelOffset, int);
+
+  // Description:
+  // Set/Get the 2D mode
+  vtkSetMacro(Use2DMode, int);
+  vtkGetMacro(Use2DMode, int);
+
+  // Description:
+  // Set/Get the 2D mode the vertical offset for X title in 2D mode
+  vtkSetMacro(VerticalOffsetXTitle2D, double);
+  vtkGetMacro(VerticalOffsetXTitle2D, double);
+
+  // Description:
+  // Set/Get the 2D mode the horizontal offset for Y title in 2D mode
+  vtkSetMacro(HorizontalOffsetYTitle2D, double);
+  vtkGetMacro(HorizontalOffsetYTitle2D, double);
+
+  // Description:
+  // Set/Get whether title position must be saved in 2D mode
+  vtkSetMacro(SaveTitlePosition, int);
+  vtkGetMacro(SaveTitlePosition, int);
+
+  // Description:
+  // Provide real vector for non aligned axis
+  vtkSetVector3Macro(AxisBaseForX, double);
+  vtkGetVector3Macro(AxisBaseForX, double);
+
+  // Description:
+  // Provide real vector for non aligned axis
+  vtkSetVector3Macro(AxisBaseForY, double);
+  vtkGetVector3Macro(AxisBaseForY, double);
+
+  // Description:
+  // Provide real vector for non aligned axis
+  vtkSetVector3Macro(AxisBaseForZ, double);
+  vtkGetVector3Macro(AxisBaseForZ, double);
+
+  // Description:
+  // Notify the axes that is not part of a cube anymore
+  vtkSetMacro(AxisOnOrigin,int);
+  vtkGetMacro(AxisOnOrigin,int);
+
+
+ protected:
   vtkRpAxisActor();
   ~vtkRpAxisActor();
@@ -302 +432 @@
 
   int    DrawGridlines;
+  int    DrawGridlinesOnly;
   int    LastDrawGridlines;
-  double  GridlineXLength;
-  double  GridlineYLength;
-  double  GridlineZLength;
+  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;
@@ -317 +456 @@
   double  Bounds[6];
 
-private:
+  double AxisBaseForX[3];
+  double AxisBaseForY[3];
+  double AxisBaseForZ[3];
+
+ private:
   vtkRpAxisActor(const vtkRpAxisActor&); // Not implemented
   void operator=(const vtkRpAxisActor&); // Not implemented
@@ -324 +467 @@
 
   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 BuildTickPointsForXType(double p1[3], double p2[3], bool);
-  bool BuildTickPointsForYType(double p1[3], double p2[3], bool);
-  bool BuildTickPointsForZType(double p1[3], double p2[3], bool);
+  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;
@@ -341 +490 @@
   double  MinorTickSize;
 
-  // for the positions
-  double  MajorStart;
+  // For each axis (for the inner gridline generation)
+  double  MajorStart[3];
+  double  DeltaMajor[3];
   double  MinorStart;
-
   double  DeltaMinor;
-  double  DeltaMajor;
 
   // For the ticks, w.r.t to the set range
@@ -357 +505 @@
   int    LastAxisType;
   int    LastTickLocation;
-  double  LastLabelStart;
+  double LastLabelStart;
 
   vtkPoints         *MinorTickPts;
   vtkPoints         *MajorTickPts;
   vtkPoints         *GridlinePts;
+  vtkPoints         *InnerGridlinePts;
+  vtkPoints         *GridpolyPts;
 
   vtkVectorText     *TitleVector;
   vtkPolyDataMapper *TitleMapper;
-  vtkFollower       *TitleActor;
+  vtkRpAxisFollower *TitleActor;
+  vtkTextActor      *TitleActor2D;
+  vtkTextProperty   *TitleTextProperty;
 
   vtkVectorText     **LabelVectors;
   vtkPolyDataMapper **LabelMappers;
-  vtkFollower       **LabelActors;
-
-  vtkPolyData        *Axis;
-  vtkPolyDataMapper  *AxisMapper;
-  vtkActor           *AxisActor;
+  vtkRpAxisFollower **LabelActors;
+  vtkTextActor      **LabelActors2D;
+  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;
+
+  // Description:
+  // Use xy-axis only when Use2DMode=1:
+  int                 Use2DMode;
+
+  // Description:
+  // Vertical offset in display coordinates for X axis title (used in 2D mode only)
+  // Default: -40
+  double              VerticalOffsetXTitle2D;
+
+  // Description:
+  // Vertical offset in display coordinates for X axis title (used in 2D mode only)
+  // Default: -50
+  double              HorizontalOffsetYTitle2D;
+
+  // Description:
+  // Save title position (used in 2D mode only):
+  // val = 0 : no need to save position (doesn't stick actors in a position)
+  // val = 1 : positions have to be saved during the next render pass
+  // val = 2 : positions are saved; use them
+  int                 SaveTitlePosition;
+
+  // Description:
+  // Constant position for the title (used in 2D mode only)
+  double              TitleConstantPosition[2];
+
+  // Description:
+  // True if the 2D title has to be built, false otherwise
+  bool                NeedBuild2D;
+
+  double              LastMinDisplayCoordinate[3];
+  double              LastMaxDisplayCoordinate[3];
 };
 

trunk/packages/vizservers/vtkvis/vtkRpCubeAxesActor.cpp

@@ -16 +16 @@
 #include "vtkRpCubeAxesActor.h"
 
+#include "vtkRpAxisActor.h"
+#include "vtkRpAxisFollower.h"
+#include "vtkBoundingBox.h"
 #include "vtkCamera.h"
 #include "vtkCoordinate.h"
-#include "vtkRpAxisActor.h"
+#include "vtkFollower.h"
 #include "vtkMath.h"
 #include "vtkObjectFactory.h"
 #include "vtkProperty.h"
 #include "vtkStringArray.h"
+#include "vtkTextProperty.h"
 #include "vtkViewport.h"
 
-// *************************************************************************
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Replace 'New' method with Macro to match VTK 4.0 API.
-//
-// *************************************************************************
 
 vtkStandardNewMacro(vtkRpCubeAxesActor);
 vtkCxxSetObjectMacro(vtkRpCubeAxesActor, Camera,vtkCamera);
-
 // *************************************************************************
 // Instantiate this object.
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//   Intialize new members lastPow, last*AxisDigits.
-//
-//   Kathleen Bonnell, Wed Nov  7 16:19:16 PST 2001
-//   Intialize new members:  Last*Extent, LastFlyMode,
-//   renderAxes*, numAxes*.
-//
-//   Hank Childs, Fri Sep 27 17:15:07 PDT 2002
-//   Initialize new members for units.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Remove 'Input' and 'Prop' members, initialize new members
-//   valueScaleFactor, mustAdjustValue, ForceLabelReset.
-//
-//   Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//   Remove valueScaleFactor, replace mustAdjustValue and ForceLabelReset
-//   with one for each axis type.
-//
-//   Kathleen Bonnell, Tue Dec 16 11:27:30 PST 2003
-//   Replace Last*Extent with Last*Range.  (* = X, Y, Z)
-//   Add AutoLabelScaling, UserXPow, UserYPow, UserZPow.
-//
-//   Brad Whitlock, Fri Jul 23 18:18:41 PST 2004
-//   Added ActualXLabel et al so we can keep title separate from what's
-//   actually displayed so information is not lost.
-//
 // *************************************************************************
-
-vtkRpCubeAxesActor::vtkRpCubeAxesActor()
+vtkRpCubeAxesActor::vtkRpCubeAxesActor() : vtkActor()
 {
   this->Bounds[0] = -1.0; this->Bounds[1] = 1.0;
   this->Bounds[2] = -1.0; this->Bounds[3] = 1.0;
   this->Bounds[4] = -1.0; this->Bounds[5] = 1.0;
-
-  this->TickLocation = VTK_TICKS_INSIDE;
+  for(int i=0; i < 6; ++i)
+    {
+    this->RenderedBounds[i] = this->Bounds[i];
+    }
+
+  this->OrientedBounds[0] = -1.0; this->OrientedBounds[1] = 1.0;
+  this->OrientedBounds[2] = -1.0; this->OrientedBounds[3] = 1.0;
+  this->OrientedBounds[4] = -1.0; this->OrientedBounds[5] = 1.0;
+
+  // Disable oriented bounds and Axis origin
+  this->UseOrientedBounds = this->UseAxisOrigin = 0;
+
+  // Init default axis origin
+  this->AxisOrigin[0] = this->AxisOrigin[1] = this->AxisOrigin[2] = 0.0;
+
+  // Init default axis base
+  this->AxisBaseForX[0] = this->AxisBaseForX[1] = this->AxisBaseForX[2] = 0;
+  this->AxisBaseForY[0] = this->AxisBaseForY[1] = this->AxisBaseForY[2] = 0;
+  this->AxisBaseForZ[0] = this->AxisBaseForZ[1] = this->AxisBaseForZ[2] = 0;
+  this->AxisBaseForX[0] = this->AxisBaseForY[1] = this->AxisBaseForZ[2] = 1.0;
+
+  this->RebuildAxes = false;
+
   this->Camera = NULL;
+
   this->FlyMode = VTK_FLY_CLOSEST_TRIAD;
-  int i;
-  for (i = 0; i < 4; i++)
+  this->GridLineLocation = VTK_GRID_LINES_ALL;
+
+  // By default enable distance based LOD
+  this->EnableDistanceLOD = 1;
+  this->DistanceLODThreshold = .8;
+
+  // By default enable view angle based LOD
+  this->EnableViewAngleLOD = 1;
+  this->ViewAngleLODThreshold = .2;
+
+  // Title and label text properties
+  for (int i = 0; i < 3; i++)
+    {
+    this->TitleTextProperty[i] = vtkTextProperty::New();
+    this->TitleTextProperty[i]->SetColor(1.,1.,1.);
+    this->TitleTextProperty[i]->SetFontFamilyToArial();
+    this->TitleTextProperty[i]->SetFontSize(14);
+
+    this->LabelTextProperty[i] = vtkTextProperty::New();
+    this->LabelTextProperty[i]->SetColor(1.,1.,1.);
+    this->LabelTextProperty[i]->SetFontFamilyToArial();
+    this->LabelTextProperty[i]->SetFontSize(12);
+    }
+
+  // Axis lines
+  this->XAxesLinesProperty = vtkProperty::New();
+  this->YAxesLinesProperty = vtkProperty::New();
+  this->ZAxesLinesProperty = vtkProperty::New();
+
+  // Outer grid lines
+  this->XAxesGridlinesProperty = vtkProperty::New();
+  this->YAxesGridlinesProperty = vtkProperty::New();
+  this->ZAxesGridlinesProperty = vtkProperty::New();
+
+  // Inner grid lines
+  this->XAxesInnerGridlinesProperty = vtkProperty::New();
+  this->YAxesInnerGridlinesProperty = vtkProperty::New();
+  this->ZAxesInnerGridlinesProperty = vtkProperty::New();
+  this->XAxesInnerGridlinesProperty->SetColor(.3,.6,.1);
+  this->YAxesInnerGridlinesProperty->SetColor(.3,.6,.1);
+  this->ZAxesInnerGridlinesProperty->SetColor(.3,.6,.1);
+
+  this->XAxesGridpolysProperty = vtkProperty::New();
+  this->YAxesGridpolysProperty = vtkProperty::New();
+  this->ZAxesGridpolysProperty = vtkProperty::New();
+  this->XAxesGridpolysProperty->SetOpacity(.6);     // Default grid polys opacity
+  this->YAxesGridpolysProperty->SetOpacity(.6);     // Default grid polys opacity
+  this->ZAxesGridpolysProperty->SetOpacity(.6);     // Default grid polys opacity
+  //this->XAxesGridpolysProperty->LightingOff();       // To be able to see the polys from high camera angles
+  //this->YAxesGridpolysProperty->LightingOff();       // To be able to see the polys from high camera angles
+  //this->ZAxesGridpolysProperty->LightingOff();       // To be able to see the polys from high camera angles
+
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     this->XAxes[i] = vtkRpAxisActor::New();
@@ -86 +127 @@
     this->XAxes[i]->SetAxisTypeToX();
     this->XAxes[i]->SetAxisPosition(i);
+    this->XAxes[i]->SetAxisLinesProperty(this->XAxesLinesProperty);
+    this->XAxes[i]->SetGridlinesProperty(this->XAxesGridlinesProperty);
+    this->XAxes[i]->SetInnerGridlinesProperty(this->XAxesInnerGridlinesProperty);
+    this->XAxes[i]->SetGridpolysProperty(this->XAxesGridpolysProperty);
+    this->XAxes[i]->SetCalculateTitleOffset(0);
+    this->XAxes[i]->SetCalculateLabelOffset(0);
 
     this->YAxes[i] = vtkRpAxisActor::New();
@@ -94 +141 @@
     this->YAxes[i]->SetAxisTypeToY();
     this->YAxes[i]->SetAxisPosition(i);
+    this->YAxes[i]->SetAxisLinesProperty(this->YAxesLinesProperty);
+    this->YAxes[i]->SetGridlinesProperty(this->YAxesGridlinesProperty);
+    this->YAxes[i]->SetInnerGridlinesProperty(this->YAxesInnerGridlinesProperty);
+    this->YAxes[i]->SetGridpolysProperty(this->YAxesGridpolysProperty);
+    this->YAxes[i]->SetCalculateTitleOffset(0);
+    this->YAxes[i]->SetCalculateLabelOffset(0);
 
     this->ZAxes[i] = vtkRpAxisActor::New();
@@ -102 +155 @@
     this->ZAxes[i]->SetAxisTypeToZ();
     this->ZAxes[i]->SetAxisPosition(i);
-    }
-
-  this->XLabelFormat = new char[8];
-  sprintf(this->XLabelFormat, "%s", "%-#6.3g");
-  this->YLabelFormat = new char[8];
-  sprintf(this->YLabelFormat, "%s", "%-#6.3g");
-  this->ZLabelFormat = new char[8];
-  sprintf(this->ZLabelFormat, "%s", "%-#6.3g");
-  this->CornerOffset = 0.0;
-  this->Inertia = 1;
-  this->RenderCount = 0;
-
-  this->XAxisVisibility = 1;
-  this->YAxisVisibility = 1;
-  this->ZAxisVisibility = 1;
-
-  this->XAxisTickVisibility = 1;
-  this->YAxisTickVisibility = 1;
-  this->ZAxisTickVisibility = 1;
-
-  this->XAxisMinorTickVisibility = 1;
-  this->YAxisMinorTickVisibility = 1;
-  this->ZAxisMinorTickVisibility = 1;
-
-  this->XAxisLabelVisibility = 1;
-  this->YAxisLabelVisibility = 1;
-  this->ZAxisLabelVisibility = 1;
-
-  this->DrawXGridlines = 0;
-  this->DrawYGridlines = 0;
-  this->DrawZGridlines = 0;
+    this->ZAxes[i]->SetAxisLinesProperty(this->ZAxesLinesProperty);
+    this->ZAxes[i]->SetGridlinesProperty(this->ZAxesGridlinesProperty);
+    this->ZAxes[i]->SetInnerGridlinesProperty(this->ZAxesInnerGridlinesProperty);
+    this->ZAxes[i]->SetGridpolysProperty(this->ZAxesGridpolysProperty);
+    this->ZAxes[i]->SetCalculateTitleOffset(0);
+    this->ZAxes[i]->SetCalculateLabelOffset(0);
+
+    this->ScreenSize = 10.0;
+
+    this->LabelScreenOffset = 20.0 + this->ScreenSize * 0.5;
+    this->TitleScreenOffset =
+      this->LabelScreenOffset * 2.0 + this->ScreenSize * 0.5;
+
+    // Pass information to axes followers.
+    vtkRpAxisFollower* follower = this->XAxes[i]->GetTitleActor();
+    follower->SetAxis(this->XAxes[i]);
+    follower->SetScreenOffset(this->TitleScreenOffset);
+    follower->SetEnableDistanceLOD( this->EnableDistanceLOD );
+    follower->SetDistanceLODThreshold( this->DistanceLODThreshold );
+    follower->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
+    follower->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
+
+    follower = this->YAxes[i]->GetTitleActor();
+    follower->SetAxis(this->YAxes[i]);
+    follower->SetScreenOffset(this->TitleScreenOffset);
+    follower->SetEnableDistanceLOD( this->EnableDistanceLOD );
+    follower->SetDistanceLODThreshold( this->DistanceLODThreshold );
+    follower->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
+    follower->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
+
+    follower = this->ZAxes[i]->GetTitleActor();
+    follower->SetAxis(this->ZAxes[i]);
+    follower->SetScreenOffset(this->TitleScreenOffset);
+    follower->SetEnableDistanceLOD( this->EnableDistanceLOD );
+    follower->SetDistanceLODThreshold( this->DistanceLODThreshold );
+    follower->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
+    follower->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
+    }
 
   this->XTitle = new char[7];
@@ -148 +208 @@
   this->ActualZLabel = 0;
 
+  this->TickLocation = VTK_TICKS_INSIDE;
+
+  this->XAxisVisibility = 1;
+  this->YAxisVisibility = 1;
+  this->ZAxisVisibility = 1;
+
+  this->XAxisTickVisibility = 1;
+  this->YAxisTickVisibility = 1;
+  this->ZAxisTickVisibility = 1;
+
+  this->XAxisMinorTickVisibility = 1;
+  this->YAxisMinorTickVisibility = 1;
+  this->ZAxisMinorTickVisibility = 1;
+
+  this->XAxisLabelVisibility = 1;
+  this->YAxisLabelVisibility = 1;
+  this->ZAxisLabelVisibility = 1;
+
+  this->DrawXGridlines = 0;
+  this->DrawYGridlines = 0;
+  this->DrawZGridlines = 0;
+
+  this->DrawXInnerGridlines = 0;
+  this->DrawYInnerGridlines = 0;
+  this->DrawZInnerGridlines = 0;
+
+  this->DrawXGridpolys = 0;
+  this->DrawYGridpolys = 0;
+  this->DrawZGridpolys = 0;
+
+  this->XLabelFormat = new char[8];
+  sprintf(this->XLabelFormat, "%s", "%-#6.3g");
+  this->YLabelFormat = new char[8];
+  sprintf(this->YLabelFormat, "%s", "%-#6.3g");
+  this->ZLabelFormat = new char[8];
+  sprintf(this->ZLabelFormat, "%s", "%-#6.3g");
+
+  this->XAutoLabelFormat = 1;
+  this->YAutoLabelFormat = 1;
+  this->ZAutoLabelFormat = 1;
+
+  this->CornerOffset = 0.0;
+
+  this->Inertia = 1;
+
+  this->RenderCount = 0;
+
+  this->InertiaLocs[0] = this->InertiaLocs[1] = this->InertiaLocs[2] = -1;
+
+  this->RenderSomething = 0;
+
+  this->LastUseOrientedBounds = 0;
+
   this->LastXPow = 0;
   this->LastYPow = 0;
   this->LastZPow = 0;
+
+  this->UserXPow = 0;
+  this->UserYPow = 0;
+  this->UserZPow = 0;
+
+  this->AutoLabelScaling = true;
+
   this->LastXAxisDigits = 3;
   this->LastYAxisDigits = 3;
@@ -162 +282 @@
   this->LastZRange[1] = VTK_FLOAT_MAX;
 
+  this->LastBounds[0] = VTK_DOUBLE_MAX;
+  this->LastBounds[1] = VTK_DOUBLE_MAX;
+  this->LastBounds[2] = VTK_DOUBLE_MAX;
+  this->LastBounds[3] = VTK_DOUBLE_MAX;
+  this->LastBounds[4] = VTK_DOUBLE_MAX;
+  this->LastBounds[5] = VTK_DOUBLE_MAX;
+
   this->LastFlyMode = -1;
-  for (i = 0; i < 4; i++)
+
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     this->RenderAxesX[i] = i;
@@ -178 +306 @@
   this->ForceYLabelReset = false;
   this->ForceZLabelReset = false;
-
-  this->AutoLabelScaling = true;
-  this->UserXPow = 0;
-  this->UserYPow = 0;
-  this->UserZPow = 0;
 
   this->XAxisRange[0] = VTK_DOUBLE_MAX;
@@ -190 +313 @@
   this->ZAxisRange[0] = VTK_DOUBLE_MAX;
   this->ZAxisRange[1] = VTK_DOUBLE_MAX;
+
+  for (int i = 0; i < 3; ++i)
+    {
+    this->AxisLabels[i] = NULL;
+    }
+  this->LabelScale = -1.0;
+  this->TitleScale = -1.0;
+}
+
+void vtkRpCubeAxesActor::SetUse2DMode( int val )
+{
+  for( int i = 0 ; i < NUMBER_OF_ALIGNED_AXIS ; ++ i )
+    {
+    this->XAxes[i]->SetUse2DMode( val );
+    this->YAxes[i]->SetUse2DMode( val );
+    this->ZAxes[i]->SetUse2DMode( val );
+    }
+  if( ! val )
+    {
+    this->SetZAxisVisibility( 1 );
+    }
+  else
+    {
+    this->SetZAxisVisibility( 0 );
+    }
+}
+
+int vtkRpCubeAxesActor::GetUse2DMode()
+{
+  // It is assumed that all axes have the same value
+  return this->XAxes[0]->GetUse2DMode();
+}
+
+void vtkRpCubeAxesActor::SetSaveTitlePosition( int val )
+{
+  // For 2D mode only :
+  //   val = 0: no need to save position (3D axis)
+  //   val = 1: positions have to be saved during the next render pass
+  //   val = 2: positions are saved -> use them
+  for( int i = 0 ; i < NUMBER_OF_ALIGNED_AXIS ; ++ i )
+    {
+    this->XAxes[i]->SetSaveTitlePosition( val );
+    this->YAxes[i]->SetSaveTitlePosition( val );
+    }
 }
 
 // ****************************************************************************
-// Shallow copy of an actor.
-//
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Call superclass method the new VTK 4.0 way.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Remove 'Input' and 'Prop' members, added new members
-//   valueScaleFactor, mustAdjustValue, ForceLabelReset.
-//
-//   Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//   Remove valueScaleFactor, replace mustAdjustValue and ForceLabelReset
-//   with one for each axis type.
-//
-// ****************************************************************************
-
-void vtkRpCubeAxesActor::ShallowCopy(vtkRpCubeAxesActor *actor)
-{
-  this->Superclass::ShallowCopy(actor);
-  this->SetXLabelFormat(actor->GetXLabelFormat());
-  this->SetYLabelFormat(actor->GetYLabelFormat());
-  this->SetZLabelFormat(actor->GetZLabelFormat());
-  this->SetCornerOffset(actor->GetCornerOffset());
-  this->SetInertia(actor->GetInertia());
-  this->SetXTitle(actor->GetXTitle());
-  this->SetYTitle(actor->GetYTitle());
-  this->SetZTitle(actor->GetZTitle());
-  this->SetFlyMode(actor->GetFlyMode());
-  this->SetCamera(actor->GetCamera());
-  this->SetBounds(actor->GetBounds());
-  this->MustAdjustXValue = actor->MustAdjustXValue;
-  this->MustAdjustYValue = actor->MustAdjustYValue;
-  this->MustAdjustZValue = actor->MustAdjustZValue;
-  this->ForceXLabelReset = actor->ForceXLabelReset;
-  this->ForceYLabelReset = actor->ForceYLabelReset;
-  this->ForceZLabelReset = actor->ForceZLabelReset;
-}
-
-// ****************************************************************************
-//  Modifications:
-//
-//    Hank Childs, Fri Sep 27 17:15:07 PDT 2002
-//    Destruct new data members for units.
-//
-//    Brad Whitlock, Fri Jul 23 18:21:16 PST 2004
-//    Added more items and fixed a small memory leak.
-//
-// ****************************************************************************
-
 vtkRpCubeAxesActor::~vtkRpCubeAxesActor()
 {
   this->SetCamera(NULL);
 
-  for (int i = 0; i < 4; i++)
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     if (this->XAxes[i])
@@ -263 +381 @@
       this->ZAxes[i] = NULL;
       }
+    }
+
+  if (this->XAxesLinesProperty)
+    {
+    this->XAxesLinesProperty->Delete();
+    }
+  if (this->XAxesGridlinesProperty)
+    {
+    this->XAxesGridlinesProperty->Delete();
+    }
+  if (this->XAxesInnerGridlinesProperty)
+    {
+    this->XAxesInnerGridlinesProperty->Delete();
+    }
+  if (this->XAxesGridpolysProperty)
+    {
+    this->XAxesGridpolysProperty->Delete();
+    }
+  if (this->YAxesLinesProperty)
+    {
+    this->YAxesLinesProperty->Delete();
+    }
+  if (this->YAxesGridlinesProperty)
+    {
+    this->YAxesGridlinesProperty->Delete();
+    }
+  if (this->YAxesInnerGridlinesProperty)
+    {
+    this->YAxesInnerGridlinesProperty->Delete();
+    }
+  if (this->YAxesGridpolysProperty)
+    {
+    this->YAxesGridpolysProperty->Delete();
+    }
+  if (this->ZAxesLinesProperty)
+    {
+    this->ZAxesLinesProperty->Delete();
+    }
+  if (this->ZAxesGridlinesProperty)
+    {
+    this->ZAxesGridlinesProperty->Delete();
+    }
+  if (this->ZAxesInnerGridlinesProperty)
+    {
+    this->ZAxesInnerGridlinesProperty->Delete();
+    }
+  if (this->ZAxesGridpolysProperty)
+    {
+    this->ZAxesGridpolysProperty->Delete();
+    }
+
+  for (int i = 0; i < 3; i++)
+    {
+    if(this->TitleTextProperty[i] != NULL)
+      {
+      this->TitleTextProperty[i]->Delete();
+      }
+    this->TitleTextProperty[i] = NULL;
+
+    if(this->LabelTextProperty[i] != NULL)
+      {
+      this->LabelTextProperty[i]->Delete();
+      }
+    this->LabelTextProperty[i] = NULL;
     }
 
@@ -336 +518 @@
 // cube. Determine which parts of the edges are visible via intersection
 // with the boundary of the viewport (minus borders).
-//
-//  Modifications:
-//    Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//    Added calls to AdjustValues, AdjustRange.
-//
-//   Kathleen Bonnell, Wed Nov  7 16:19:16 PST 2001
-//   Only render those axes needed for current FlyMode.
-//   Moved bulk of 'build' code to BuildAxes method, added calls to
-//   BuildAxes and DetermineRenderAxes methods.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Added initial build of each axis.
 // *************************************************************************
-
 int vtkRpCubeAxesActor::RenderOpaqueGeometry(vtkViewport *viewport)
 {
-  int i, renderedSomething=0;
   static bool initialRender = true;
-  // Initialization
-  if (!this->Camera)
-    {
-    vtkErrorMacro(<<"No camera!");
-    this->RenderSomething = 0;
-    return 0;
-    }
-
-  this->BuildAxes(viewport);
-
-  if (initialRender)
-    {
-    for (i = 0; i < 4; i++)
-      {
-      this->XAxes[i]->BuildAxis(viewport, true);
-      this->YAxes[i]->BuildAxis(viewport, true);
-      this->ZAxes[i]->BuildAxis(viewport, true);
-      }
-    }
-  initialRender = false;
-
-  this->DetermineRenderAxes(viewport);
-
-  //Render the axes
-  if (this->XAxisVisibility)
-    {
-    for (i = 0; i < this->NumberOfAxesX; i++)
-      {
-      renderedSomething +=
-        this->XAxes[this->RenderAxesX[i]]->RenderOpaqueGeometry(viewport);
-      }
-    }
-
-  if (this->YAxisVisibility)
-    {
-    for (i = 0; i < this->NumberOfAxesY; i++)
-      {
-      renderedSomething +=
-        this->YAxes[this->RenderAxesY[i]]->RenderOpaqueGeometry(viewport);
-      }
-    }
-
-  if (this->ZAxisVisibility)
-    {
-    for (i = 0; i < this->NumberOfAxesZ; i++)
-      {
-      renderedSomething +=
-        this->ZAxes[this->RenderAxesZ[i]]->RenderOpaqueGeometry(viewport);
-      }
-    }
-  return renderedSomething;
-}
-
+  return this->RenderGeometry(
+        initialRender, viewport, true,
+        &vtkRpAxisActor::RenderOpaqueGeometry);
+}
+
+// *************************************************************************
+// Project the bounding box and compute edges on the border of the bounding
+// cube. Determine which parts of the edges are visible via intersection
+// with the boundary of the viewport (minus borders).
+// *************************************************************************
+int vtkRpCubeAxesActor::RenderTranslucentGeometry(vtkViewport *viewport)
+{
+  static bool initialRender = true;
+  return this->RenderGeometry(
+        initialRender, viewport, true,
+        &vtkRpAxisActor::RenderTranslucentGeometry);
+}
+
+// *************************************************************************
+// Project the bounding box and compute edges on the border of the bounding
+// cube. Determine which parts of the edges are visible via intersection
+// with the boundary of the viewport (minus borders).
+// *************************************************************************
+int vtkRpCubeAxesActor::RenderTranslucentPolygonalGeometry(vtkViewport *viewport)
+{
+  static bool initialRender = true;
+  return this->RenderGeometry(
+        initialRender, viewport, true,
+        &vtkRpAxisActor::RenderTranslucentPolygonalGeometry);
+}
+
+// *************************************************************************
+// RenderOverlay : render 2D annotations.
+// *************************************************************************
+int vtkRpCubeAxesActor::RenderOverlay(vtkViewport *viewport)
+{
+  static bool initialRender = true;
+  return this->RenderGeometry(
+        initialRender, viewport, false,
+        &vtkRpAxisActor::RenderOverlay);
+}
+
+// --------------------------------------------------------------------------
+int vtkRpCubeAxesActor::HasTranslucentPolygonalGeometry()
+{
+  if ((this->NumberOfAxesX > 0 &&
+       this->XAxes[0]->HasTranslucentPolygonalGeometry()) ||
+      (this->NumberOfAxesY > 0 &&
+       this->YAxes[0]->HasTranslucentPolygonalGeometry()) ||
+      (this->NumberOfAxesZ > 0 &&
+       this->ZAxes[0]->HasTranslucentPolygonalGeometry()))
+    {
+    return 1;
+    }
+
+  return 0;
+}
+
+// --------------------------------------------------------------------------
 // Do final adjustment of axes to control offset, etc.
-void vtkRpCubeAxesActor::AdjustAxes(double bounds[6], double xCoords[4][6],
-                                  double yCoords[4][6], double zCoords[4][6],
+void vtkRpCubeAxesActor::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])
@@ -433 +609 @@
   if (this->CornerOffset > 0.0)
     {
-    for (int i = 0; i < 4; i++)
+    for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
       {
       double ave;
@@ -491 +667 @@
 }
 
+// *************************************************************************
+// Screen size affects the screen offset as well.
+// *************************************************************************
+void vtkRpCubeAxesActor::SetScreenSize(double screenSize)
+{
+  this->ScreenSize = screenSize;
+// Considering pivot point at center of the geometry hence (this->ScreenSize * 0.5).
+  this->LabelScreenOffset = 20.0 + this->ScreenSize * 0.5;
+  this->TitleScreenOffset = this->LabelScreenOffset * 2.0 +
+    this->ScreenSize * 0.5;
+
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+    {
+    this->XAxes[i]->GetTitleActor()->SetScreenOffset(this->TitleScreenOffset);
+    this->YAxes[i]->GetTitleActor()->SetScreenOffset(this->TitleScreenOffset);
+    this->ZAxes[i]->GetTitleActor()->SetScreenOffset(this->TitleScreenOffset);
+
+    int numberOfLabelsBuild = this->XAxes[i]->GetNumberOfLabelsBuilt();
+    vtkRpAxisFollower **labelActors = this->XAxes[i]->GetLabelActors();
+    for(int k=0; k < numberOfLabelsBuild; ++k)
+      {
+      labelActors[k]->SetScreenOffset(this->LabelScreenOffset);
+      }
+
+    numberOfLabelsBuild = this->YAxes[i]->GetNumberOfLabelsBuilt();
+    labelActors = this->YAxes[i]->GetLabelActors();
+    for(int k=0; k < numberOfLabelsBuild; ++k)
+      {
+      labelActors[k]->SetScreenOffset(this->LabelScreenOffset);
+      }
+
+    numberOfLabelsBuild = this->ZAxes[i]->GetNumberOfLabelsBuilt();
+    labelActors = this->ZAxes[i]->GetLabelActors();
+    for(int k=0; k < numberOfLabelsBuild; ++k)
+      {
+      labelActors[k]->SetScreenOffset(this->LabelScreenOffset);
+      }
+    }
+
+  this->Modified();
+}
+
+// *************************************************************************
 // 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 vtkRpCubeAxesActor::ReleaseGraphicsResources(vtkWindow *win)
 {
-  for (int i = 0; i < 4; i++)
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     this->XAxes[i]->ReleaseGraphicsResources(win);
@@ -504 +724 @@
 }
 
-// *************************************************************************
-// Compute the bounds
-//
-// Modifications:
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Removed support for Prop and Input.
-// *************************************************************************
-void vtkRpCubeAxesActor::GetBounds(double bounds[6])
-{
-  for (int i=0; i< 6; i++)
-    {
-    bounds[i] = this->Bounds[i];
-    }
-}
-
-// Compute the bounds
-void vtkRpCubeAxesActor::GetBounds(double& xmin, double& xmax,
-                                 double& ymin, double& ymax,
-                                 double& zmin, double& zmax)
-{
-  xmin = this->Bounds[0];
-  xmax = this->Bounds[1];
-  ymin = this->Bounds[2];
-  ymax = this->Bounds[3];
-  zmin = this->Bounds[4];
-  zmax = this->Bounds[5];
-}
-
-// Compute the bounds
-double *vtkRpCubeAxesActor::GetBounds()
-{
-  return this->Bounds;
-}
-
 // ******************************************************************
-// Modifications:
-//   Kathleen Bonnell, Wed Mar  6 13:48:48 PST 2002
-//   Call superclass method the new VTK 4.0 way.
-//
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Removed Input and Prop.
-//
-// ******************************************************************
-
 void vtkRpCubeAxesActor::PrintSelf(ostream& os, vtkIndent indent)
 {
@@ -554 +731 @@
   os << indent << "Bounds: \n";
   os << indent << "  Xmin,Xmax: (" << this->Bounds[0] << ", "
-     << this->Bounds[1] << ")\n";
+     << this->Bounds[1] << ")" << endl;
   os << indent << "  Ymin,Ymax: (" << this->Bounds[2] << ", "
-     << this->Bounds[3] << ")\n";
+     << this->Bounds[3] << ")" << endl;
   os << indent << "  Zmin,Zmax: (" << this->Bounds[4] << ", "
-     << this->Bounds[5] << ")\n";
+     << this->Bounds[5] << ")" << endl;
 
 
@@ -568 +745 @@
     << this->ZAxisRange[1] << "] " << endl;
 
+  os << indent << "ScreenSize: (" << this->ScreenSize << ")" << endl;
+
   if (this->Camera)
     {
@@ -578 +757 @@
     }
 
+  os << indent << "RebuildAxes: " << this->RebuildAxes << endl;
+
   if (this->FlyMode == VTK_FLY_CLOSEST_TRIAD)
     {
-    os << indent << "Fly Mode: CLOSEST_TRIAD\n";
+    os << indent << "Fly Mode: CLOSEST_TRIAD"<< endl;
     }
   else if (this->FlyMode == VTK_FLY_FURTHEST_TRIAD)
     {
-    os << indent << "Fly Mode: FURTHEST_TRIAD\n";
+    os << indent << "Fly Mode: FURTHEST_TRIAD"<< endl;
     }
   else if (this->FlyMode == VTK_FLY_STATIC_TRIAD)
     {
-    os << indent << "Fly Mode: STATIC_TRIAD\n";
+    os << indent << "Fly Mode: STATIC_TRIAD"<< endl;
     }
   else if (this->FlyMode == VTK_FLY_STATIC_EDGES)
     {
-    os << indent << "Fly Mode: STATIC_EDGES\n";
+    os << indent << "Fly Mode: STATIC_EDGES"<< endl;
     }
   else
     {
-    os << indent << "Fly Mode: OUTER_EDGES\n";
-    }
-
-  os << indent << "X Axis Title: " << this->XTitle << "\n";
-  os << indent << "Y Axis Title: " << this->YTitle << "\n";
-  os << indent << "Z Axis Title: " << this->ZTitle << "\n";
+    os << indent << "Fly Mode: OUTER_EDGES"<< endl;
+    }
+
+  os << indent << "EnableDistanceLOD: "
+     << ( this->EnableDistanceLOD ? "On" : "Off" ) << endl;
+  os << indent << "DistanceLODThreshold: "   << this->DistanceLODThreshold << endl;
+
+  os << indent << "EnableViewAngleLOD: "
+     << ( this->EnableViewAngleLOD ? "On" : "Off" ) << endl;
+  os << indent << "ViewAngleLODThreshold: "   << this->ViewAngleLODThreshold << endl;
+
+  os << indent << "X Axis Title: " << this->XTitle << endl;
+  os << indent << "Y Axis Title: " << this->YTitle << endl;
+  os << indent << "Z Axis Title: " << this->ZTitle << endl;
 
   os << indent << "X Axis Visibility: "
@@ -610 +799 @@
      << (this->ZAxisVisibility ? "On\n" : "Off\n");
 
-  os << indent << "X Axis Label Format: " << this->XLabelFormat << "\n";
-  os << indent << "Y Axis Label Format: " << this->YLabelFormat << "\n";
-  os << indent << "Z Axis Label Format: " << this->ZLabelFormat << "\n";
-  os << indent << "Inertia: " << this->Inertia << "\n";
-  os << indent << "Corner Offset: " << this->CornerOffset << "\n";
+  os << indent << "X Axis Label Format: " << this->XLabelFormat << endl;
+  os << indent << "Y Axis Label Format: " << this->YLabelFormat << endl;
+  os << indent << "Z Axis Label Format: " << this->ZLabelFormat << endl;
+
+  os << indent << "XAutoLabelFormat: "
+     << (this->XAutoLabelFormat ? "On" : "Off") << endl;
+  os << indent << "YAutoLabelFormat: "
+     << (this->YAutoLabelFormat ? "On" : "Off") << endl;
+  os << indent << "ZAutoLabelFormat: "
+     << (this->ZAutoLabelFormat ? "On" : "Off") << endl;
+
+  os << indent << "Inertia: " << this->Inertia << endl;
+  os << indent << "Corner Offset: " << this->CornerOffset << endl;
 
   os << indent << "XAxisTickVisibility: "
@@ -649 +846 @@
   os << indent << "DrawYGridlines: " << this->DrawYGridlines << endl;
   os << indent << "DrawZGridlines: " << this->DrawZGridlines << endl;
-}
-
+
+  switch(this->GridLineLocation)
+    {
+  case VTK_GRID_LINES_ALL:
+    os << indent << "GridLineLocation: VTK_GRID_LINES_ALL (0)" << endl;
+    break;
+  case VTK_GRID_LINES_CLOSEST:
+    os << indent << "GridLineLocation: VTK_GRID_LINES_CLOSEST (1)" << endl;
+    break;
+  case VTK_GRID_LINES_FURTHEST:
+    os << indent << "GridLineLocation: VTK_GRID_LINES_FURTHEST (2)" << endl;
+    break;
+    }
+
+  os << indent << "DrawXInnerGridlines: " << this->DrawXInnerGridlines << endl;
+  os << indent << "DrawYInnerGridlines: " << this->DrawYInnerGridlines << endl;
+  os << indent << "DrawZInnerGridlines: " << this->DrawZInnerGridlines << endl;
+
+  os << indent << "DrawXGridpolys: " << this->DrawXGridpolys << endl;
+  os << indent << "DrawYGridpolys: " << this->DrawYGridpolys << endl;
+  os << indent << "DrawZGridpolys: " << this->DrawZGridpolys << endl;
+
+
+  os << indent << "UseOrientedBounds: " << this->UseOrientedBounds << endl;
+  if(this->UseOrientedBounds)
+    {
+    os << indent << "OrientedBounds: \n";
+    os << indent << "  Xmin,Xmax: (" << this->OrientedBounds[0] << ", "
+       << this->OrientedBounds[1] << ")" << endl;
+    os << indent << "  Ymin,Ymax: (" << this->OrientedBounds[2] << ", "
+       << this->OrientedBounds[3] << ")" << endl;
+    os << indent << "  Zmin,Zmax: (" << this->OrientedBounds[4] << ", "
+       << this->OrientedBounds[5] << ")" << endl;
+    }
+
+  os << indent << "Base: \n";
+  os << indent << "  For X: (" << this->AxisBaseForX[0] << ", "
+     << this->AxisBaseForX[1] << ", " << this->AxisBaseForX[2] << ")" << endl;
+  os << indent << "  For Y: (" << this->AxisBaseForY[0] << ", "
+     << this->AxisBaseForY[1] << ", " << this->AxisBaseForY[2] << ")" << endl;
+  os << indent << "  For Z: (" << this->AxisBaseForZ[0] << ", "
+     << this->AxisBaseForZ[1] << ", " << this->AxisBaseForZ[2] << ")" << endl;
+
+  os << indent << "UseAxisOrigin: " << this->UseAxisOrigin << endl;
+  if(this->UseAxisOrigin)
+    {
+    os << indent << "AxisOrigin: (" << this->AxisOrigin[0] << ", "
+       << this->AxisOrigin[1] << ", " << this->AxisOrigin[2] << ")" << endl;
+    }
+}
+
+// --------------------------------------------------------------------------
 void vtkRpCubeAxesActor::TransformBounds(vtkViewport *viewport,
                                        const double bounds[6],
                                        double pts[8][3])
 {
-  int i, j, k, idx;
   double x[3];
 
   //loop over verts of bounding box
-  for (k=0; k<2; k++)
-    {
-    x[2] = bounds[4+k];
-    for (j=0; j<2; j++)
-      {
-      x[1] = bounds[2+j];
-      for (i=0; i<2; i++)
+  for ( int k = 0; k < 2; ++ k )
+    {
+    x[2] = bounds[4 + k];
+    for ( int j = 0; j < 2; ++ j )
+      {
+      x[1] = bounds[2 + j];
+      for ( int i = 0; i < 2; ++ i )
         {
-        idx = i + 2*j + 4*k;
+        int idx = i + 2 * j + 4 * k;
         x[0] = bounds[i];
-        viewport->SetWorldPoint(x[0],x[1],x[2],1.0);
+        viewport->SetWorldPoint( x[0], x[1], x[2], 1. );
         viewport->WorldToDisplay();
-        viewport->GetDisplayPoint(pts[idx]);
+        viewport->GetDisplayPoint( pts[idx] );
         }
       }
@@ -678 +924 @@
 
 // ***********************************************************************
-//
 //  Calculate the size (length) of major and minor ticks,
 //  based on an average of the coordinate direction ranges.
@@ -684 +929 @@
 //
 //  Returns:  false if tick size not recomputed, true otherwise.
-//
-//  Modifications:
-//    Kathleen Bonnell, Wed Nov  7 16:19:16 PST 2001
-//    Added logic for early-termination.
-//
-//    Kathleen Bonnell, Fri Jul 18 09:09:31 PDT 2003
-//    Added return value, added calls to AdjustTicksComputeRange and
-//    BuildLabels.
-//
-//    Kathleen Bonnell, Mon Dec 15 14:59:26 PST 2003
-//    Use the actual range values instead of range-extents to determine
-//    if tick size needs to be recomputed.
-//
 // ***********************************************************************
-
 bool vtkRpCubeAxesActor::ComputeTickSize(double bounds[6])
 {
-  bool xRangeChanged = this->LastXRange[0] != bounds[0] ||
-                       this->LastXRange[1] != bounds[1];
-
-  bool yRangeChanged = this->LastYRange[0] != bounds[2] ||
-                       this->LastYRange[1] != bounds[3];
-
-  bool zRangeChanged = this->LastZRange[0] != bounds[4] ||
-                       this->LastZRange[1] != bounds[5];
-
-  if (!(xRangeChanged || yRangeChanged || zRangeChanged))
+  bool xPropsChanged = this->LabelTextProperty[0]->GetMTime() > this->BuildTime.GetMTime();
+  bool yPropsChanged = this->LabelTextProperty[1]->GetMTime() > this->BuildTime.GetMTime();
+  bool zPropsChanged = this->LabelTextProperty[2]->GetMTime() > this->BuildTime.GetMTime();
+
+  bool xRangeChanged = this->LastXRange[0] != this->XAxisRange[0] ||
+                       this->LastXRange[1] != this->XAxisRange[1];
+
+  bool yRangeChanged = this->LastYRange[0] != this->YAxisRange[0] ||
+                       this->LastYRange[1] != this->YAxisRange[1];
+
+  bool zRangeChanged = this->LastZRange[0] != this->ZAxisRange[0] ||
+                       this->LastZRange[1] != this->ZAxisRange[1];
+
+  bool boundsChanged = this->LastBounds[0] != bounds[0] ||
+                       this->LastBounds[1] != bounds[1] ||
+                       this->LastBounds[2] != bounds[2] ||
+                       this->LastBounds[3] != bounds[3] ||
+                       this->LastBounds[4] != bounds[4] ||
+                       this->LastBounds[5] != bounds[5];
+
+  if (!(xRangeChanged || yRangeChanged || zRangeChanged) &&
+      !(xPropsChanged || yPropsChanged || zPropsChanged || boundsChanged))
     {
     // no need to re-compute ticksize.
@@ -716 +959 @@
     }
 
-  int i;
   double xExt = bounds[1] - bounds[0];
   double yExt = bounds[3] - bounds[2];
   double zExt = bounds[5] - bounds[4];
 
-  if (xRangeChanged)
+  if (xRangeChanged || boundsChanged)
     {
     this->AdjustTicksComputeRange(this->XAxes, bounds[0], bounds[1]);
     this->BuildLabels(this->XAxes);
-    }
-  if (yRangeChanged)
+    this->UpdateLabels(this->XAxes, 0);
+    }
+  if (yRangeChanged || boundsChanged)
     {
     this->AdjustTicksComputeRange(this->YAxes, bounds[2], bounds[3]);
     this->BuildLabels(this->YAxes);
-    }
-  if (zRangeChanged)
+    this->UpdateLabels(this->YAxes, 1);
+    }
+  if (zRangeChanged || boundsChanged)
     {
     this->AdjustTicksComputeRange(this->ZAxes, bounds[4], bounds[5]);
     this->BuildLabels(this->ZAxes);
+    this->UpdateLabels(this->ZAxes, 2);
+    }
+
+  // We give information on deltas for the inner grid lines generation
+  for(int i = 0 ; i < NUMBER_OF_ALIGNED_AXIS ; i++)
+    {
+    for(int j = 0 ; j < 3 ; j++)
+      {
+      this->XAxes[i]->SetMajorStart(j,this->MajorStart[j]);
+      this->XAxes[i]->SetDeltaMajor(j,this->DeltaMajor[j]);
+      this->YAxes[i]->SetMajorStart(j,this->MajorStart[j]);
+      this->YAxes[i]->SetDeltaMajor(j,this->DeltaMajor[j]);
+      this->ZAxes[i]->SetMajorStart(j,this->MajorStart[j]);
+      this->ZAxes[i]->SetDeltaMajor(j,this->DeltaMajor[j]);
+      }
     }
 
@@ -749 +1008 @@
   this->LastZRange[1] = (this->ZAxisRange[1] == VTK_DOUBLE_MAX ?
                                   bounds[5] : this->ZAxisRange[1]);
+  for(int i=0; i < 6; i++)
+    {
+    this->LastBounds[i] = bounds[i];
+    }
 
   double major = 0.02 * (xExt + yExt + zExt) / 3.;
   double minor = 0.5 * major;
-  for (i = 0; i < 4; i++)
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     this->XAxes[i]->SetMajorTickSize(major);
@@ -792 +1055 @@
 //              /meshtvx/toolkit/plotgrid.c, axlab[x|y].
 //
-//  Programmer: Hank Childs
-//  Creation:   July 11, 2000
-//
-//  Modifications:
-//    Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//    Regardless of individual ranges, if any coord direction has too
-//    small/large a range, all will have a scale factor set for scaling their
-//    label values, and their titles adjusted accordingly.
-//
-//    Kathleen Bonnell, Thu Sep  5 17:32:16 PDT 2002
-//    Only use dimensions with range > 0 for determining scale factor.
-//
-//    Hank Childs, Fri Sep 27 17:15:07 PDT 2002
-//    Account for units.
-//
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Each axis type now has its own 'mustAdjustValue' and 'lastPow'.
-//
-//    Kathleen Bonnell, Tue Dec 16 11:23:31 PST 2003
-//    Allow the LabelExponent to be user-settable (autLabelScaling is off).
-//    For title use '10e' instead of just 'e' to designate that exponent
-//    has been used.
-//
-//    Kathleen Bonnell, Tue Jul 20 11:41:45 PDT 2004
-//    For title use 'x10^' instead of '10e' to designate that exponent.
-//
-//    Brad Whitlock, Fri Jul 23 18:27:30 PST 2004
-//    Added support for using user-defined titles for axes.
-//
 // ****************************************************************************
-
 void vtkRpCubeAxesActor::AdjustValues(const double xRange[2],
                                     const double yRange[2],
@@ -833 +1066 @@
   if (AutoLabelScaling)
     {
-    xPow = this->LabelExponent(xRange[0], xRange[1]);
-    yPow = this->LabelExponent(yRange[0], yRange[1]);
-    zPow = this->LabelExponent(zRange[0], zRange[1]);
+    if (this->AxisLabels[0] == NULL)
+      {
+      xPow = this->LabelExponent(xRange[0], xRange[1]);
+      }
+    else
+      {
+      xPow = 0;
+      }
+    if (this->AxisLabels[1] == NULL)
+      {
+      yPow = this->LabelExponent(yRange[0], yRange[1]);
+      }
+    else
+      {
+      yPow = 0;
+      }
+    if (this->AxisLabels[2] == NULL)
+      {
+      zPow = this->LabelExponent(zRange[0], zRange[1]);
+      }
+    else
+      {
+      zPow = 0;
+      }
     }
   else
@@ -994 +1248 @@
 //    bnds    The minimum and maximum values in each coordinate direction
 //            (min_x, max_x, min_y, max_y, min_z, max_z).
-//
-//  Programmer: Hank Childs
-//  Creation:   July 11, 2000
-//
-//  Modifications:
-//    Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//    Moved from VisWinAxes3D.
-//
-//    Kathleen Bonnell, Thu Aug  1 14:05:05 PDT 2002
-//    Send lastPos as argument to Digits.
-//
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Adjust the range values using LastXPow, LastYPow, LastZPow.
-//
 // ****************************************************************************
-
 void vtkRpCubeAxesActor::AdjustRange(const double bnds[6])
 {
-  double xrange[2], yrange[2], zrange[2];
-
-  xrange[0] = (this->XAxisRange[0] == VTK_DOUBLE_MAX ?
-                                  bnds[0] : this->XAxisRange[0]);
-  xrange[1] = (this->XAxisRange[1] == VTK_DOUBLE_MAX ?
-                                  bnds[1] : this->XAxisRange[1]);
-  yrange[0] = (this->YAxisRange[0] == VTK_DOUBLE_MAX ?
-                                  bnds[2] : this->YAxisRange[0]);
-  yrange[1] = (this->YAxisRange[1] == VTK_DOUBLE_MAX ?
-                                  bnds[3] : this->YAxisRange[1]);
-  zrange[0] = (this->ZAxisRange[0] == VTK_DOUBLE_MAX ?
-                                  bnds[4] : this->ZAxisRange[0]);
-  zrange[1] = (this->ZAxisRange[1] == VTK_DOUBLE_MAX ?
-                                  bnds[5] : this->ZAxisRange[1]);
-
-  if (this->LastXPow != 0)
-    {
-    xrange[0] /= pow(10., this->LastXPow);
-    xrange[1] /= pow(10., this->LastXPow);
-    }
-  if (this->LastYPow != 0)
-    {
-    yrange[0] /= pow(10., this->LastYPow);
-    yrange[1] /= pow(10., this->LastYPow);
-    }
-  if (this->LastZPow != 0)
-    {
-    zrange[0] /= pow(10., this->LastZPow);
-    zrange[1] /= pow(10., this->LastZPow);
-    }
-
-  int xAxisDigits = this->Digits(xrange[0], xrange[1]);
-  if (xAxisDigits != this->LastXAxisDigits)
-    {
-    char  format[16];
-    sprintf(format, "%%.%df", xAxisDigits);
-    this->SetXLabelFormat(format);
-    this->LastXAxisDigits = xAxisDigits;
-    }
-
-  int yAxisDigits = this->Digits(yrange[0], yrange[1]);
-  if (yAxisDigits != this->LastYAxisDigits)
-    {
-    char  format[16];
-    sprintf(format, "%%.%df", yAxisDigits);
-    this->SetYLabelFormat(format);
-    this->LastYAxisDigits = yAxisDigits;
-    }
-
-  int zAxisDigits = this->Digits(zrange[0], zrange[1]);
-  if (zAxisDigits != this->LastZAxisDigits)
-    {
-    char  format[16];
-    sprintf(format, "%%.%df", zAxisDigits);
-    this->SetZLabelFormat(format);
-    this->LastZAxisDigits = zAxisDigits;
+  if (this->XAutoLabelFormat)
+    {
+    double xrange[2];
+
+    xrange[0] = (this->XAxisRange[0] == VTK_DOUBLE_MAX ?
+                                    bnds[0] : this->XAxisRange[0]);
+    xrange[1] = (this->XAxisRange[1] == VTK_DOUBLE_MAX ?
+                                    bnds[1] : this->XAxisRange[1]);
+    if (this->LastXPow != 0)
+      {
+      xrange[0] /= pow(10., this->LastXPow);
+      xrange[1] /= pow(10., this->LastXPow);
+      }
+
+    int xAxisDigits = this->Digits(xrange[0], xrange[1]);
+    if (xAxisDigits != this->LastXAxisDigits)
+      {
+      char  format[16];
+      sprintf(format, "%%.%df", xAxisDigits);
+      this->SetXLabelFormat(format);
+      this->LastXAxisDigits = xAxisDigits;
+      }
+    }
+  if (this->YAutoLabelFormat)
+    {
+    double yrange[2];
+
+    yrange[0] = (this->YAxisRange[0] == VTK_DOUBLE_MAX ?
+                                    bnds[2] : this->YAxisRange[0]);
+    yrange[1] = (this->YAxisRange[1] == VTK_DOUBLE_MAX ?
+                                    bnds[3] : this->YAxisRange[1]);
+
+    if (this->LastYPow != 0)
+      {
+      yrange[0] /= pow(10., this->LastYPow);
+      yrange[1] /= pow(10., this->LastYPow);
+      }
+
+    int yAxisDigits = this->Digits(yrange[0], yrange[1]);
+    if (yAxisDigits != this->LastYAxisDigits)
+      {
+      char  format[16];
+      sprintf(format, "%%.%df", yAxisDigits);
+      this->SetYLabelFormat(format);
+      this->LastYAxisDigits = yAxisDigits;
+      }
+    }
+  if (this->ZAutoLabelFormat)
+    {
+    double zrange[2];
+
+    zrange[0] = (this->ZAxisRange[0] == VTK_DOUBLE_MAX ?
+                                    bnds[4] : this->ZAxisRange[0]);
+    zrange[1] = (this->ZAxisRange[1] == VTK_DOUBLE_MAX ?
+                                    bnds[5] : this->ZAxisRange[1]);
+
+    if (this->LastZPow != 0)
+      {
+      zrange[0] /= pow(10., this->LastZPow);
+      zrange[1] /= pow(10., this->LastZPow);
+      }
+ 
+    int zAxisDigits = this->Digits(zrange[0], zrange[1]);
+    if (zAxisDigits != this->LastZAxisDigits)
+      {
+      char  format[16];
+      sprintf(format, "%%.%df", zAxisDigits);
+      this->SetZLabelFormat(format);
+      this->LastZAxisDigits = zAxisDigits;
+      }
     }
 }
@@ -1082 +1335 @@
 //
 //  Returns:   The appropriate number of digits.
-//
-//  Programmer: Hank Childs
-//  Creation:   July 11, 2000
-//
-//  Modifications:
-//
-//    Hank Childs, Tue Sep 18 11:58:33 PDT 2001
-//    Cast ipow10 to get rid of compiler warning.
-//
-//    Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//    Moved from VisWinAxes3D.
-//
-//    Kathleen Bonnell, Thu Aug  1 13:44:02 PDT 2002
-//    Added lastPow argument, it specifies whether or not scientific notation
-//    is being used on the labels.
-//
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Removed lastPow argment, as the adjustment necessary is now taking
-//    place in AdjustRange.
-//
 // ****************************************************************************
-
 int vtkRpCubeAxesActor::Digits(double min, double max )
 {
@@ -1152 +1384 @@
 //  Note:       This code is mostly stolen from old MeshTV code,
 //              /meshtvx/toolkit/plotgrid.c, axlab_format.
-//
-//  Programmer: Hank Childs
-//  Creation:   July 11, 2000
-//
-//  Modifications:
-//    Eric Brugger, Tue Sep 18 09:18:17 PDT 2001
-//    Change a few static local variables to be non-static to get around a
-//    compiler bug with the MIPSpro 7.2.1.3 compiler.
-//
-//    Hank Childs, Tue Sep 18 11:58:33 PDT 2001
-//    Cast return value to get rid of compiler warning.
-//
-//    Kathleen Bonnell, Wed Oct 31 07:57:49 PST 2001
-//    Moved from VisWinAxes3D.
-//
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Added test for min==max.
-//
 // ****************************************************************************
 
@@ -1213 +1427 @@
 // *************************************************************************
 //  Build the axes. Determine coordinates, position, etc.
-//
-//  Note:  Bulk of code moved here from RenderOpaqueGeomtry.
-//         Early-termination test added.
-//
-//  Programmer:  Kathleen Bonnell
-//  Creation:    November 7, 2001
-//
-//  Modifications:
-//    Kathleen Bonnell, Mon Dec  3 16:49:01 PST 2001
-//    Compare vtkTimeStamps correctly.
-//
-//    Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//    Added logic to compute and set for each axis the labels and title
-//    scale size.
-//
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Indivdual axes now have their own ForceLabelReset.
-//
 // *************************************************************************
-
 void vtkRpCubeAxesActor::BuildAxes(vtkViewport *viewport)
 {
+  if ((this->GetMTime() < this->BuildTime.GetMTime()))
+    {
+    this->AutoScale(viewport);
+    return;
+    }
+
+  this->SetNonDependentAttributes();
+
+  // Reset range in case of bounds type changed
+  if(this->LastUseOrientedBounds != this->UseOrientedBounds)
+    {
+    this->XAxisRange[0] = this->XAxisRange[1] = VTK_DOUBLE_MAX;
+    this->YAxisRange[0] = this->YAxisRange[1] = VTK_DOUBLE_MAX;
+    this->ZAxisRange[0] = this->ZAxisRange[1] = VTK_DOUBLE_MAX;
+    this->LastUseOrientedBounds = this->UseOrientedBounds;
+    }
+
+  // determine the bounds to use (input, prop, or user-defined)
   double bounds[6];
-  double pts[8][3];
-  int i;
-
-  if ((this->GetMTime() < this->BuildTime.GetMTime()))
-    {
-    return;
-    }
-
-  this->SetNonDependentAttributes();
-  // determine the bounds to use (input, prop, or user-defined)
-  this->GetBounds(bounds);
-
-  // Build the axes (almost always needed so we don't check mtime)
-  // Transform all points into display coordinates (to determine which closest
-  // to camera).
-  this->TransformBounds(viewport, bounds, pts);
+  if(this->UseOrientedBounds != 0)
+    {
+    this->GetOrientedBounds(bounds);
+    }
+  else
+    {
+    this->GetBounds(bounds);
+    }
 
   // Setup the axes for plotting
-  double xCoords[4][6], yCoords[4][6], zCoords[4][6];
+  double xCoords[NUMBER_OF_ALIGNED_AXIS][6];
+  double yCoords[NUMBER_OF_ALIGNED_AXIS][6];
+  double zCoords[NUMBER_OF_ALIGNED_AXIS][6];
 
   // these arrays are accessed by 'location':  mm, mX, XX, or Xm.
@@ -1260 +1467 @@
   int mm2[4] = { 0, 1, 1, 0 };
 
-  for (i = 0; i < 4; i++)
-    {
-    this->XAxes[i]->SetAxisPosition(i);
-    xCoords[i][0] = bounds[0];
-    xCoords[i][3] = bounds[1];
-    xCoords[i][1] = xCoords[i][4] = bounds[2+mm1[i]];
-    xCoords[i][2] = xCoords[i][5] = bounds[4+mm2[i]];
-
-    this->YAxes[i]->SetAxisPosition(i);
-    yCoords[i][0] = yCoords[i][3] = bounds[0+mm1[i]];
-    yCoords[i][1] = bounds[2];
-    yCoords[i][4] = bounds[3];
-    yCoords[i][2] = yCoords[i][5] = bounds[4+mm2[i]];
-
-    this->ZAxes[i]->SetAxisPosition(i);
-    zCoords[i][0] = zCoords[i][3] = bounds[0+mm1[i]];
-    zCoords[i][1] = zCoords[i][4] = bounds[2+mm2[i]];
-    zCoords[i][2] = bounds[4];
-    zCoords[i][5] = bounds[5];
+  // Compute axes end-points
+  int i;
+  for (i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+    {
+    if(this->UseAxisOrigin == 0)
+      {
+      xCoords[i][0] = bounds[0]*this->AxisBaseForX[0] + bounds[2+mm1[i]]*this->AxisBaseForY[0] + bounds[4+mm2[i]]*this->AxisBaseForZ[0];
+      xCoords[i][1] = bounds[0]*this->AxisBaseForX[1] + bounds[2+mm1[i]]*this->AxisBaseForY[1] + bounds[4+mm2[i]]*this->AxisBaseForZ[1];
+      xCoords[i][2] = bounds[0]*this->AxisBaseForX[2] + bounds[2+mm1[i]]*this->AxisBaseForY[2] + bounds[4+mm2[i]]*this->AxisBaseForZ[2];
+      xCoords[i][3] = bounds[1]*this->AxisBaseForX[0] + bounds[2+mm1[i]]*this->AxisBaseForY[0] + bounds[4+mm2[i]]*this->AxisBaseForZ[0];
+      xCoords[i][4] = bounds[1]*this->AxisBaseForX[1] + bounds[2+mm1[i]]*this->AxisBaseForY[1] + bounds[4+mm2[i]]*this->AxisBaseForZ[1];
+      xCoords[i][5] = bounds[1]*this->AxisBaseForX[2] + bounds[2+mm1[i]]*this->AxisBaseForY[2] + bounds[4+mm2[i]]*this->AxisBaseForZ[2];
+      }
+    else
+      {
+      xCoords[i][0] = bounds[0]*this->AxisBaseForX[0] + this->AxisOrigin[1]*this->AxisBaseForY[0] + this->AxisOrigin[2]*this->AxisBaseForZ[0];
+      xCoords[i][1] = bounds[0]*this->AxisBaseForX[1] + this->AxisOrigin[1]*this->AxisBaseForY[1] + this->AxisOrigin[2]*this->AxisBaseForZ[1];
+      xCoords[i][2] = bounds[0]*this->AxisBaseForX[2] + this->AxisOrigin[1]*this->AxisBaseForY[2] + this->AxisOrigin[2]*this->AxisBaseForZ[2];
+      xCoords[i][3] = bounds[1]*this->AxisBaseForX[0] + this->AxisOrigin[1]*this->AxisBaseForY[0] + this->AxisOrigin[2]*this->AxisBaseForZ[0];
+      xCoords[i][4] = bounds[1]*this->AxisBaseForX[1] + this->AxisOrigin[1]*this->AxisBaseForY[1] + this->AxisOrigin[2]*this->AxisBaseForZ[1];
+      xCoords[i][5] = bounds[1]*this->AxisBaseForX[2] + this->AxisOrigin[1]*this->AxisBaseForY[2] + this->AxisOrigin[2]*this->AxisBaseForZ[2];
+      }
+
+    if(this->UseAxisOrigin == 0)
+      {
+      yCoords[i][0] = bounds[2]*this->AxisBaseForY[0] + bounds[0+mm1[i]]*this->AxisBaseForX[0] + bounds[4+mm2[i]]*this->AxisBaseForZ[0];
+      yCoords[i][1] = bounds[2]*this->AxisBaseForY[1] + bounds[0+mm1[i]]*this->AxisBaseForX[1] + bounds[4+mm2[i]]*this->AxisBaseForZ[1];
+      yCoords[i][2] = bounds[2]*this->AxisBaseForY[2] + bounds[0+mm1[i]]*this->AxisBaseForX[2] + bounds[4+mm2[i]]*this->AxisBaseForZ[2];
+      yCoords[i][3] = bounds[3]*this->AxisBaseForY[0] + bounds[0+mm1[i]]*this->AxisBaseForX[0] + bounds[4+mm2[i]]*this->AxisBaseForZ[0];
+      yCoords[i][4] = bounds[3]*this->AxisBaseForY[1] + bounds[0+mm1[i]]*this->AxisBaseForX[1] + bounds[4+mm2[i]]*this->AxisBaseForZ[1];
+      yCoords[i][5] = bounds[3]*this->AxisBaseForY[2] + bounds[0+mm1[i]]*this->AxisBaseForX[2] + bounds[4+mm2[i]]*this->AxisBaseForZ[2];
+      }
+    else
+      {
+      yCoords[i][0] = bounds[2]*this->AxisBaseForY[0] + this->AxisOrigin[0]*this->AxisBaseForX[0] + this->AxisOrigin[2]*this->AxisBaseForZ[0];
+      yCoords[i][1] = bounds[2]*this->AxisBaseForY[1] + this->AxisOrigin[0]*this->AxisBaseForX[1] + this->AxisOrigin[2]*this->AxisBaseForZ[1];
+      yCoords[i][2] = bounds[2]*this->AxisBaseForY[2] + this->AxisOrigin[0]*this->AxisBaseForX[2] + this->AxisOrigin[2]*this->AxisBaseForZ[2];
+      yCoords[i][3] = bounds[3]*this->AxisBaseForY[0] + this->AxisOrigin[0]*this->AxisBaseForX[0] + this->AxisOrigin[2]*this->AxisBaseForZ[0];
+      yCoords[i][4] = bounds[3]*this->AxisBaseForY[1] + this->AxisOrigin[0]*this->AxisBaseForX[1] + this->AxisOrigin[2]*this->AxisBaseForZ[1];
+      yCoords[i][5] = bounds[3]*this->AxisBaseForY[2] + this->AxisOrigin[0]*this->AxisBaseForX[2] + this->AxisOrigin[2]*this->AxisBaseForZ[2];
+      }
+
+    if(this->UseAxisOrigin == 0)
+      {
+      zCoords[i][0] = bounds[4]*this->AxisBaseForZ[0] + bounds[0+mm1[i]]*this->AxisBaseForX[0] + bounds[2+mm2[i]]*this->AxisBaseForY[0];
+      zCoords[i][1] = bounds[4]*this->AxisBaseForZ[1] + bounds[0+mm1[i]]*this->AxisBaseForX[1] + bounds[2+mm2[i]]*this->AxisBaseForY[1];
+      zCoords[i][2] = bounds[4]*this->AxisBaseForZ[2] + bounds[0+mm1[i]]*this->AxisBaseForX[2] + bounds[2+mm2[i]]*this->AxisBaseForY[2];
+      zCoords[i][3] = bounds[5]*this->AxisBaseForZ[0] + bounds[0+mm1[i]]*this->AxisBaseForX[0] + bounds[2+mm2[i]]*this->AxisBaseForY[0];
+      zCoords[i][4] = bounds[5]*this->AxisBaseForZ[1] + bounds[0+mm1[i]]*this->AxisBaseForX[1] + bounds[2+mm2[i]]*this->AxisBaseForY[1];
+      zCoords[i][5] = bounds[5]*this->AxisBaseForZ[2] + bounds[0+mm1[i]]*this->AxisBaseForX[2] + bounds[2+mm2[i]]*this->AxisBaseForY[2];
+      }
+    else
+      {
+      zCoords[i][0] = bounds[4]*this->AxisBaseForZ[0] + this->AxisOrigin[0]*this->AxisBaseForX[0] + this->AxisOrigin[1]*this->AxisBaseForY[0];
+      zCoords[i][1] = bounds[4]*this->AxisBaseForZ[1] + this->AxisOrigin[0]*this->AxisBaseForX[1] + this->AxisOrigin[1]*this->AxisBaseForY[1];
+      zCoords[i][2] = bounds[4]*this->AxisBaseForZ[2] + this->AxisOrigin[0]*this->AxisBaseForX[2] + this->AxisOrigin[1]*this->AxisBaseForY[2];
+      zCoords[i][3] = bounds[5]*this->AxisBaseForZ[0] + this->AxisOrigin[0]*this->AxisBaseForX[0] + this->AxisOrigin[1]*this->AxisBaseForY[0];
+      zCoords[i][4] = bounds[5]*this->AxisBaseForZ[1] + this->AxisOrigin[0]*this->AxisBaseForX[1] + this->AxisOrigin[1]*this->AxisBaseForY[1];
+      zCoords[i][5] = bounds[5]*this->AxisBaseForZ[2] + this->AxisOrigin[0]*this->AxisBaseForX[2] + this->AxisOrigin[1]*this->AxisBaseForY[2];
+      }
     }
 
@@ -1290 +1538 @@
   // be scaled, may change title of each axis, may change label format.
   this->AdjustValues(xRange, yRange, zRange);
-  this->AdjustRange(this->Bounds);
+  this->AdjustRange(bounds);
 
   // Prepare axes for rendering with user-definable options
-  for (i = 0; i < 4; i++)
-    {
+  for (i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+    {
+    this->XAxes[i]->SetAxisOnOrigin(this->UseAxisOrigin);
     this->XAxes[i]->GetPoint1Coordinate()->SetValue(xCoords[i][0],
                                                     xCoords[i][1],
@@ -1301 +1550 @@
                                                     xCoords[i][4],
                                                     xCoords[i][5]);
+    this->YAxes[i]->SetAxisOnOrigin(this->UseAxisOrigin);
     this->YAxes[i]->GetPoint1Coordinate()->SetValue(yCoords[i][0],
                                                     yCoords[i][1],
@@ -1307 +1557 @@
                                                     yCoords[i][4],
                                                     yCoords[i][5]);
+    this->ZAxes[i]->SetAxisOnOrigin(this->UseAxisOrigin);
     this->ZAxes[i]->GetPoint1Coordinate()->SetValue(zCoords[i][0],
                                                     zCoords[i][1],
@@ -1335 +1586 @@
       {
       this->BuildLabels(this->XAxes);
+      this->UpdateLabels(this->XAxes, 0);
       }
     if (this->ForceYLabelReset)
       {
       this->BuildLabels(this->YAxes);
+      this->UpdateLabels(this->YAxes, 1);
       }
     if (this->ForceZLabelReset)
       {
       this->BuildLabels(this->ZAxes);
+      this->UpdateLabels(this->ZAxes, 2);
       }
     }
@@ -1370 +1624 @@
 
     double target = bLength *0.04;
-    double labelscale = 1.;
+    this->LabelScale = 1.;
     if (maxLabelLength != 0.)
       {
-      labelscale = target / maxLabelLength;
+      this->LabelScale = target / maxLabelLength;
       }
     target = bLength *0.10;
-    double titlescale = 1.;
+    this->TitleScale = 1.;
     if (maxTitleLength != 0.)
       {
-      titlescale = target / maxTitleLength;
+      this->TitleScale = target / maxTitleLength;
       }
 
@@ -1388 +1642 @@
     if (XUnits != NULL && XUnits[0] != '\0')
       {
-      titlescale *= 2;
-      }
-
-    for (i = 0; i < 4; i++)
-      {
-      this->XAxes[i]->SetLabelScale(labelscale);
-      this->YAxes[i]->SetLabelScale(labelscale);
-      this->ZAxes[i]->SetLabelScale(labelscale);
-      this->XAxes[i]->SetTitleScale(titlescale);
-      this->YAxes[i]->SetTitleScale(titlescale);
-      this->ZAxes[i]->SetTitleScale(titlescale);
-      }
-    }
+      this->TitleScale *= 2;
+      }
+
+    for (i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+      {
+      this->XAxes[i]->SetLabelScale(this->LabelScale);
+      this->YAxes[i]->SetLabelScale(this->LabelScale);
+      this->ZAxes[i]->SetLabelScale(this->LabelScale);
+      this->XAxes[i]->SetTitleScale(this->TitleScale);
+      this->YAxes[i]->SetTitleScale(this->TitleScale);
+      this->ZAxes[i]->SetTitleScale(this->TitleScale);
+      }
+    }
+
+  // Scale appropriately.
+  this->AutoScale(viewport);
+
   this->RenderSomething = 1;
   this->BuildTime.Modified();
@@ -1410 +1668 @@
 //  not dependent upon viewport changes, and thus do not need to be set
 //  very often.
-//
-//  Programmer:  Kathleen Bonnell
-//  Creation:    November 7, 2001
-//
-//  Modifications:
-//    Kathleen Bonnell, Thu Oct  3 14:33:15 PDT 2002
-//    Disable lighting for the axes by setting the ambient coefficient to 1
-//    and the diffuse coeeficient to 0.
 // *************************************************************************
-
 void vtkRpCubeAxesActor::SetNonDependentAttributes()
 {
@@ -1425 +1674 @@
   prop->SetAmbient(1.0);
   prop->SetDiffuse(0.0);
-  for (int i = 0; i < 4; i++)
-    {
+
+  // Make sure our Axis Base is normalized
+  vtkMath::Normalize(this->AxisBaseForX);
+  vtkMath::Normalize(this->AxisBaseForY);
+  vtkMath::Normalize(this->AxisBaseForZ);
+
+  // Manage custome grid visibility location if FLY and STATIC axis
+  int gridLocationBasedOnAxis = (this->GridLineLocation == VTK_GRID_LINES_ALL)
+      ? VTK_GRID_LINES_ALL : VTK_GRID_LINES_CLOSEST;
+
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+    {
+    this->XAxes[i]->SetAxisPosition(i);
+    this->XAxes[i]->SetAxisBaseForX(this->AxisBaseForX);
+    this->XAxes[i]->SetAxisBaseForY(this->AxisBaseForY);
+    this->XAxes[i]->SetAxisBaseForZ(this->AxisBaseForZ);
     this->XAxes[i]->SetCamera(this->Camera);
     this->XAxes[i]->SetProperty(prop);
+    this->XAxes[i]->SetTitleTextProperty(this->TitleTextProperty[0]);
+    this->XAxes[i]->SetLabelTextProperty(this->LabelTextProperty[0]);
+    this->XAxes[i]->SetAxisLinesProperty(this->XAxesLinesProperty);
+    this->XAxes[i]->SetGridlinesProperty(this->XAxesGridlinesProperty);
+    this->XAxes[i]->SetGridpolysProperty(this->XAxesGridpolysProperty);
     this->XAxes[i]->SetTickLocation(this->TickLocation);
     this->XAxes[i]->SetDrawGridlines(this->DrawXGridlines);
+    this->XAxes[i]->SetDrawGridlinesLocation(gridLocationBasedOnAxis);
+    this->XAxes[i]->SetDrawInnerGridlines(this->DrawXInnerGridlines);
+    this->XAxes[i]->SetDrawGridpolys(this->DrawXGridpolys);
     this->XAxes[i]->SetBounds(this->Bounds);
-    this->XAxes[i]->AxisVisibilityOn();
+    this->XAxes[i]->SetAxisVisibility(this->XAxisVisibility);
     this->XAxes[i]->SetLabelVisibility(this->XAxisLabelVisibility);
     this->XAxes[i]->SetTitleVisibility(this->XAxisLabelVisibility);
@@ -1438 +1709 @@
     this->XAxes[i]->SetMinorTicksVisible(this->XAxisMinorTickVisibility);
 
+    this->YAxes[i]->SetAxisPosition(i);
+    this->YAxes[i]->SetAxisBaseForX(this->AxisBaseForX);
+    this->YAxes[i]->SetAxisBaseForY(this->AxisBaseForY);
+    this->YAxes[i]->SetAxisBaseForZ(this->AxisBaseForZ);
     this->YAxes[i]->SetCamera(this->Camera);
     this->YAxes[i]->SetProperty(prop);
+    this->YAxes[i]->SetTitleTextProperty(this->TitleTextProperty[1]);
+    this->YAxes[i]->SetLabelTextProperty(this->LabelTextProperty[1]);
+    this->YAxes[i]->SetAxisLinesProperty(this->YAxesLinesProperty);
+    this->YAxes[i]->SetGridlinesProperty(this->YAxesGridlinesProperty);
+    this->YAxes[i]->SetGridpolysProperty(this->YAxesGridpolysProperty);
     this->YAxes[i]->SetTickLocation(this->TickLocation);
     this->YAxes[i]->SetDrawGridlines(this->DrawYGridlines);
+    this->YAxes[i]->SetDrawGridlinesLocation(gridLocationBasedOnAxis);
+    this->YAxes[i]->SetDrawInnerGridlines(this->DrawYInnerGridlines);
+    this->YAxes[i]->SetDrawGridpolys(this->DrawYGridpolys);
     this->YAxes[i]->SetBounds(this->Bounds);
-    this->YAxes[i]->AxisVisibilityOn();
+    this->YAxes[i]->SetAxisVisibility(this->YAxisVisibility);
     this->YAxes[i]->SetLabelVisibility(this->YAxisLabelVisibility);
     this->YAxes[i]->SetTitleVisibility(this->YAxisLabelVisibility);
@@ -1449 +1732 @@
     this->YAxes[i]->SetMinorTicksVisible(this->YAxisMinorTickVisibility);
 
+    this->ZAxes[i]->SetAxisPosition(i);
+    this->ZAxes[i]->SetAxisBaseForX(this->AxisBaseForX);
+    this->ZAxes[i]->SetAxisBaseForY(this->AxisBaseForY);
+    this->ZAxes[i]->SetAxisBaseForZ(this->AxisBaseForZ);
     this->ZAxes[i]->SetCamera(this->Camera);
     this->ZAxes[i]->SetProperty(prop);
+    this->ZAxes[i]->SetTitleTextProperty(this->TitleTextProperty[2]);
+    this->ZAxes[i]->SetLabelTextProperty(this->LabelTextProperty[2]);
+    this->ZAxes[i]->SetAxisLinesProperty(this->ZAxesLinesProperty);
+    this->ZAxes[i]->SetGridlinesProperty(this->ZAxesGridlinesProperty);
+    this->ZAxes[i]->SetGridpolysProperty(this->ZAxesGridpolysProperty);
     this->ZAxes[i]->SetTickLocation(this->TickLocation);
     this->ZAxes[i]->SetDrawGridlines(this->DrawZGridlines);
+    this->ZAxes[i]->SetDrawGridlinesLocation(gridLocationBasedOnAxis);
+    this->ZAxes[i]->SetDrawInnerGridlines(this->DrawZInnerGridlines);
+    this->ZAxes[i]->SetDrawGridpolys(this->DrawZGridpolys);
     this->ZAxes[i]->SetBounds(this->Bounds);
-    this->ZAxes[i]->AxisVisibilityOn();
+    this->ZAxes[i]->SetAxisVisibility(this->ZAxisVisibility);
     this->ZAxes[i]->SetLabelVisibility(this->ZAxisLabelVisibility);
     this->ZAxes[i]->SetTitleVisibility(this->ZAxisLabelVisibility);
@@ -1481 +1776 @@
 // be rendered.  For STATIC FlyMode, all axes are rendered.  For other
 // FlyModes, either 1 or 2 per coordinate direction are rendered.
-//
-// Programmer:  Kathleen Bonnell
-// Creation:    November 7, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Thu Jul 18 10:33:07 PDT 2002
-//   Ensure that primary axes visibility flags are set properly, and
-//   that secondary axes visibility flags are turned off.
 // *************************************************************************
 void vtkRpCubeAxesActor::DetermineRenderAxes(vtkViewport *viewport)
 {
-  double bounds[6], slope = 0.0, minSlope, num, den;
-  double pts[8][3], d2, d2Min, min, max;
-  int i = 0, idx = 0;
-  int xIdx = 0, yIdx = 0, zIdx = 0, zIdx2 = 0;
-  int xAxes = 0, yAxes = 0, zAxes = 0, xloc = 0, yloc = 0, zloc = 0;
-
-  if (this->FlyMode == VTK_FLY_STATIC_EDGES)
-    {
-    for (i = 0; i < 4; i++)
-      {
-      this->RenderAxesX[i] = i;
-      this->RenderAxesY[i] = i;
-      this->RenderAxesZ[i] = i;
-      }
-    this->NumberOfAxesX = this->NumberOfAxesY = this->NumberOfAxesZ = 4;
+  double bounds[6];
+  double pts[8][3];
+  int i = 0, closestIdx = -1, furtherstIdx = -1;
+  int xloc = 0, yloc = 0, zloc = 0;
+
+  // Make sure we start with only one axis by default, then we might extend it
+  this->NumberOfAxesX = this->NumberOfAxesY = this->NumberOfAxesZ = 1;
+
+  // Compute relevant axis points only if a axis/grid visibility change based
+  // on the viewpoint
+  if( !( this->GridLineLocation == VTK_GRID_LINES_ALL
+         && ( this->FlyMode == VTK_FLY_STATIC_EDGES
+              || this->FlyMode == VTK_FLY_STATIC_TRIAD)))
+    {
+    // determine the bounds to use (input, prop, or user-defined)
+    this->GetBounds(bounds);
+    this->TransformBounds(viewport, bounds, pts);
+    }
+
+  // Check closest point if needed
+  if( this->GridLineLocation == VTK_GRID_LINES_CLOSEST
+      || this->FlyMode == VTK_FLY_CLOSEST_TRIAD )
+    {
+    closestIdx = this->FindClosestAxisIndex(pts);
+    }
+
+  // Check furtherst point if needed
+  if( this->GridLineLocation == VTK_GRID_LINES_FURTHEST
+      || this->FlyMode == VTK_FLY_FURTHEST_TRIAD )
+    {
+    furtherstIdx = this->FindFurtherstAxisIndex(pts);
+    }
+
+  // Manage fast static axis visibility
+  if (this->FlyMode == VTK_FLY_STATIC_EDGES || this->FlyMode == VTK_FLY_STATIC_TRIAD)
+    {
+    if(this->FlyMode == VTK_FLY_STATIC_EDGES)
+      {
+      this->NumberOfAxesX = this->NumberOfAxesY = this->NumberOfAxesZ
+          = NUMBER_OF_ALIGNED_AXIS;
+      }
+
+    for (i = 0; i < this->NumberOfAxesX; i++)
+      {
+      this->RenderAxesX[i] = this->RenderAxesY[i] = this->RenderAxesZ[i] = i;
+      }
+
+    this->UpdateGridLineVisibility(
+          (this->GridLineLocation == VTK_GRID_LINES_CLOSEST)
+          ? closestIdx : furtherstIdx);
     return;
     }
-  if (this->FlyMode == VTK_FLY_STATIC_TRIAD)
-    {
-    this->RenderAxesX[0] = 0;
-    this->RenderAxesY[0] = 0;
-    this->RenderAxesZ[0] = 0;
-    if (this->DrawXGridlines && 0)
-      {
-      this->RenderAxesX[1] = 2;
-      this->NumberOfAxesX = 2;
-      this->XAxes[RenderAxesX[1]]->SetTickVisibility(0);
-      this->XAxes[RenderAxesX[1]]->SetLabelVisibility(0);
-      this->XAxes[RenderAxesX[1]]->SetTitleVisibility(0);
-      this->XAxes[RenderAxesX[1]]->SetMinorTicksVisible(0);
-      }
-    else
-      {
-      this->NumberOfAxesX = 1;
-      }
-    if (this->DrawYGridlines && 0)
-      {
-      this->RenderAxesY[1] = 2;
-      this->NumberOfAxesY = 2;
-      this->YAxes[RenderAxesY[1]]->SetTickVisibility(0);
-      this->YAxes[RenderAxesY[1]]->SetLabelVisibility(0);
-      this->YAxes[RenderAxesY[1]]->SetTitleVisibility(0);
-      this->YAxes[RenderAxesY[1]]->SetMinorTicksVisible(0);
-      }
-    else
-      {
-      this->NumberOfAxesY = 1;
-      }
-    if (this->DrawZGridlines && 0)
-      {
-      this->RenderAxesZ[1] = 2;
-      this->NumberOfAxesZ = 2;
-      this->ZAxes[RenderAxesZ[1]]->SetTickVisibility(0);
-      this->ZAxes[RenderAxesZ[1]]->SetLabelVisibility(0);
-      this->ZAxes[RenderAxesZ[1]]->SetTitleVisibility(0);
-      this->ZAxes[RenderAxesZ[1]]->SetMinorTicksVisible(0);
-      }
-    else
-      {
-      this->NumberOfAxesZ = 1;
-      }
-    return;
-    }
-
-  // determine the bounds to use (input, prop, or user-defined)
-  this->GetBounds(bounds);
-  this->TransformBounds(viewport, bounds, pts);
+
 
   // Take into account the inertia. Process only so often.
@@ -1565 +1838 @@
     if (this->FlyMode == VTK_FLY_CLOSEST_TRIAD)
       {
-      // Loop over points and find the closest point to the camera
-      min = VTK_LARGE_FLOAT;
-      for (i=0; i < 8; i++)
-        {
-        if (pts[i][2] < min)
-          {
-          idx = i;
-          min = pts[i][2];
-          }
-        }
-      xloc = vtkRpCubeAxesActorTriads[idx][0];
-      yloc = vtkRpCubeAxesActorTriads[idx][1];
-      zloc = vtkRpCubeAxesActorTriads[idx][2];
-
-      } // closest-triad
+      xloc = vtkRpCubeAxesActorTriads[closestIdx][0];
+      yloc = vtkRpCubeAxesActorTriads[closestIdx][1];
+      zloc = vtkRpCubeAxesActorTriads[closestIdx][2];
+      }
     else if (this->FlyMode == VTK_FLY_FURTHEST_TRIAD)
       {
-      // Loop over points and find the furthest point from the camera
-      max = -VTK_LARGE_FLOAT;
-      for (i=0; i < 8; i++)
-        {
-        if (pts[i][2] > max)
-          {
-          idx = i;
-          max = pts[i][2];
-          }
-        }
-      xloc = vtkRpCubeAxesActorTriads[idx][0];
-      yloc = vtkRpCubeAxesActorTriads[idx][1];
-      zloc = vtkRpCubeAxesActorTriads[idx][2];
-
-      } // furthest-triad
-    else
-      {
-      double e1[3], e2[3], e3[3];
-
-      // Find distance to origin
-      d2Min = VTK_LARGE_FLOAT;
-      for (i=0; i < 8; i++)
-        {
-        d2 = pts[i][0]*pts[i][0] + pts[i][1]*pts[i][1];
-        if (d2 < d2Min)
-          {
-          d2Min = d2;
-          idx = i;
-          }
-        }
-
-      // find minimum slope point connected to closest point and on
-      // right side (in projected coordinates). This is the first edge.
-      minSlope = VTK_LARGE_FLOAT;
-      for (xIdx=0, i=0; i<3; i++)
-        {
-        num = (pts[vtkRpCubeAxesActorConn[idx][i]][1] - pts[idx][1]);
-        den = (pts[vtkRpCubeAxesActorConn[idx][i]][0] - pts[idx][0]);
-        if (den != 0.0)
-          {
-          slope = num / den;
-          }
-        if (slope < minSlope && den > 0)
-          {
-          xIdx = vtkRpCubeAxesActorConn[idx][i];
-          yIdx = vtkRpCubeAxesActorConn[idx][(i+1)%3];
-          zIdx = vtkRpCubeAxesActorConn[idx][(i+2)%3];
-          xAxes = i;
-          minSlope = slope;
-          }
-        }
-
-      // find edge (connected to closest point) on opposite side
-      for ( i=0; i<3; i++)
-        {
-        e1[i] = (pts[xIdx][i] - pts[idx][i]);
-        e2[i] = (pts[yIdx][i] - pts[idx][i]);
-        e3[i] = (pts[zIdx][i] - pts[idx][i]);
-        }
-      vtkMath::Normalize(e1);
-      vtkMath::Normalize(e2);
-      vtkMath::Normalize(e3);
-
-      if (vtkMath::Dot(e1,e2) < vtkMath::Dot(e1,e3))
-        {
-        yAxes = (xAxes + 1) % 3;
-        }
-      else
-        {
-        yIdx = zIdx;
-        yAxes = (xAxes + 2) % 3;
-        }
-
-      // Find the final point by determining which global x-y-z axes have not
-      // been represented, and then determine the point closest to the viewer.
-      zAxes = (xAxes != 0 && yAxes != 0 ? 0 :
-              (xAxes != 1 && yAxes != 1 ? 1 : 2));
-      if (pts[vtkRpCubeAxesActorConn[xIdx][zAxes]][2] <
-          pts[vtkRpCubeAxesActorConn[yIdx][zAxes]][2])
-        {
-        zIdx = xIdx;
-        zIdx2 = vtkRpCubeAxesActorConn[xIdx][zAxes];
-        }
-      else
-        {
-        zIdx = yIdx;
-        zIdx2 = vtkRpCubeAxesActorConn[yIdx][zAxes];
-        }
-
-      int mini = (idx < xIdx ? idx : xIdx);
-      switch (xAxes)
-        {
-        case 0:
-          xloc = vtkRpCubeAxesActorTriads[mini][0];
-          break;
-        case 1:
-          yloc = vtkRpCubeAxesActorTriads[mini][1];
-          break;
-        case 2:
-          zloc = vtkRpCubeAxesActorTriads[mini][2];
-          break;
-        }
-      mini = (idx < yIdx ? idx : yIdx);
-      switch (yAxes)
-        {
-        case 0:
-          xloc = vtkRpCubeAxesActorTriads[mini][0];
-          break;
-        case 1:
-          yloc =vtkRpCubeAxesActorTriads[mini][1];
-          break;
-        case 2:
-          zloc = vtkRpCubeAxesActorTriads[mini][2];
-          break;
-        }
-      mini = (zIdx < zIdx2 ? zIdx : zIdx2);
-      switch (zAxes)
-        {
-        case 0:
-          xloc = vtkRpCubeAxesActorTriads[mini][0];
-          break;
-        case 1:
-          yloc = vtkRpCubeAxesActorTriads[mini][1];
-          break;
-        case 2:
-          zloc = vtkRpCubeAxesActorTriads[mini][2];
-          break;
-        }
-
-      }//else boundary edges fly mode
+      xloc = vtkRpCubeAxesActorTriads[furtherstIdx][0];
+      yloc = vtkRpCubeAxesActorTriads[furtherstIdx][1];
+      zloc = vtkRpCubeAxesActorTriads[furtherstIdx][2];
+      }
+    else // else boundary edges fly mode
+      {
+      this->FindBoundaryEdge(xloc, yloc, zloc, pts);
+      }
 
     this->InertiaLocs[0] = xloc;
     this->InertiaLocs[1] = yloc;
     this->InertiaLocs[2] = zloc;
-    } //inertia
+    } // inertia
   else
     {
-    // don't change anything, use locations from last render
+    // Do not change anything, use locations from last render
     xloc = this->InertiaLocs[0];
     yloc = this->InertiaLocs[1];
@@ -1725 +1865 @@
     }
 
-  this->RenderAxesX[0] = xloc % 4;
-  if (this->DrawXGridlines && 0)
-    {
-    this->RenderAxesX[1] = (xloc + 2) % 4;
-    this->NumberOfAxesX = 2;
-    this->XAxes[RenderAxesX[1]]->SetTickVisibility(0);
-    this->XAxes[RenderAxesX[1]]->SetLabelVisibility(0);
-    this->XAxes[RenderAxesX[1]]->SetTitleVisibility(0);
-    this->XAxes[RenderAxesX[1]]->SetMinorTicksVisible(0);
-    }
-  else
-    {
-    this->NumberOfAxesX = 1;
-    }
-
-  this->RenderAxesY[0] = yloc % 4;
-  if (this->DrawYGridlines && 0)
-    {
-    this->RenderAxesY[1] = (yloc + 2) % 4;
-    this->NumberOfAxesY = 2;
-    this->YAxes[RenderAxesY[1]]->SetTickVisibility(0);
-    this->YAxes[RenderAxesY[1]]->SetLabelVisibility(0);
-    this->YAxes[RenderAxesY[1]]->SetTitleVisibility(0);
-    this->YAxes[RenderAxesY[1]]->SetMinorTicksVisible(0);
-    }
-  else
-    {
-    this->NumberOfAxesY = 1;
-    }
-
-  this->RenderAxesZ[0] = zloc % 4;
-  if (this->DrawZGridlines && 0)
-    {
-    this->RenderAxesZ[1] = (zloc + 2) % 4;
-    this->NumberOfAxesZ = 2;
-    this->ZAxes[RenderAxesZ[1]]->SetTickVisibility(0);
-    this->ZAxes[RenderAxesZ[1]]->SetLabelVisibility(0);
-    this->ZAxes[RenderAxesZ[1]]->SetTitleVisibility(0);
-    this->ZAxes[RenderAxesZ[1]]->SetMinorTicksVisible(0);
-    }
-  else
-    {
-    this->NumberOfAxesZ = 1;
-    }
-  //
-  //  Make sure that the primary axis visibility flags are set correctly.
-  //
-  this->XAxes[RenderAxesX[0]]->SetLabelVisibility(this->XAxisLabelVisibility);
-  this->XAxes[RenderAxesX[0]]->SetTitleVisibility(this->XAxisLabelVisibility);
-  this->XAxes[RenderAxesX[0]]->SetTickVisibility(this->XAxisTickVisibility);
-  this->XAxes[RenderAxesX[0]]->SetMinorTicksVisible(
-    this->XAxisMinorTickVisibility);
-  this->XAxes[RenderAxesX[0]]->SetDrawGridlines(this->DrawXGridlines);
-
-  this->YAxes[RenderAxesY[0]]->SetLabelVisibility(this->YAxisLabelVisibility);
-  this->YAxes[RenderAxesY[0]]->SetTitleVisibility(this->YAxisLabelVisibility);
-  this->YAxes[RenderAxesY[0]]->SetTickVisibility(this->YAxisTickVisibility);
-  this->YAxes[RenderAxesY[0]]->SetMinorTicksVisible(
-    this->YAxisMinorTickVisibility);
-  this->YAxes[RenderAxesY[0]]->SetDrawGridlines(this->DrawYGridlines);
-
-  this->ZAxes[RenderAxesZ[0]]->SetLabelVisibility(this->ZAxisLabelVisibility);
-  this->ZAxes[RenderAxesZ[0]]->SetTitleVisibility(this->ZAxisLabelVisibility);
-  this->ZAxes[RenderAxesZ[0]]->SetTickVisibility(this->ZAxisTickVisibility);
-  this->ZAxes[RenderAxesZ[0]]->SetMinorTicksVisible(
-    this->ZAxisMinorTickVisibility);
-  this->ZAxes[RenderAxesZ[0]]->SetDrawGridlines(this->DrawZGridlines);
-}
-
+  // Set axes to be rendered
+  this->RenderAxesX[0] = xloc % NUMBER_OF_ALIGNED_AXIS;
+  this->RenderAxesY[0] = yloc % NUMBER_OF_ALIGNED_AXIS;
+  this->RenderAxesZ[0] = zloc % NUMBER_OF_ALIGNED_AXIS;
+
+  // Manage grid visibility (can increase the number of axis to render)
+  this->UpdateGridLineVisibility(
+        (this->GridLineLocation == VTK_GRID_LINES_CLOSEST)
+        ? closestIdx : furtherstIdx);
+}
+
+// --------------------------------------------------------------------------
 double vtkRpCubeAxesActor::MaxOf(double a, double b)
 {
@@ -1799 +1882 @@
 }
 
+// --------------------------------------------------------------------------
 double vtkRpCubeAxesActor::MaxOf(double a, double b, double c, double d)
 {
@@ -1804 +1888 @@
 }
 
+// --------------------------------------------------------------------------
 inline double vtkRpCubeAxesActor::FFix(double value)
 {
@@ -1810 +1895 @@
 }
 
+inline int vtkRpCubeAxesActor::FRound(double value)
+{
+  return value <= 0.5 ? static_cast<int>(this->FFix(value)) : static_cast<int>(this->FFix(value) + 1);
+}
+
+inline int vtkRpCubeAxesActor::GetNumTicks(double range, double fxt)
+{
+  // Find the number of integral points in the interval.
+  double fnt  = range/fxt;
+  fnt  = this->FFix(fnt);
+  return this->FRound(fnt);
+}
+
+// --------------------------------------------------------------------------
 inline double vtkRpCubeAxesActor::FSign(double value, double sign)
 {
@@ -1828 +1927 @@
 // Arguments:
 //   inRange   The range for this axis.
-//
-// Note:    The bulk of this method was taken from vtkHankAxisActor.C
-//          The original method was reduced to serve the purposes
-//          of this class.
-//
-// Programmer: Kathleen Bonnell
-// Creation:   29 August, 2001
-//
-// Modifications:
-//   Kathleen Bonnell, Fri Jul 25 14:37:32 PDT 2003
-//   Moved from vtkRpAxisActor. Added calls to set inividual axis'
-//   MajorStart, MinorStart, deltaMajor, deltaMinor.
-//
 // *******************************************************************
 
-void vtkRpCubeAxesActor::AdjustTicksComputeRange(vtkRpAxisActor *axes[4],
+void vtkRpCubeAxesActor::AdjustTicksComputeRange(vtkRpAxisActor *axes[NUMBER_OF_ALIGNED_AXIS],
     double boundsMin, double boundsMax)
 {
   double sortedRange[2], range;
-  double fxt, fnt, frac;
+  double fxt;
   double div, major, minor;
   double majorStart, minorStart;
   int numTicks;
   double *inRange = axes[0]->GetRange();
+  vtkStringArray* customizedLabels = NULL;
 
   sortedRange[0] = inRange[0] < inRange[1] ? inRange[0] : inRange[1];
@@ -1876 +1963 @@
   fxt = pow(10., this->FFix(pow10));
 
-  // Find the number of integral points in the interval.
-  fnt  = range/fxt;
-  fnt  = this->FFix(fnt);
-  frac = fnt;
-  numTicks = frac <= 0.5 ? static_cast<int>(this->FFix(fnt)) : static_cast<int>(this->FFix(fnt) + 1);
+  numTicks = this->GetNumTicks(range, fxt);
 
   div = 1.;
@@ -1899 +1982 @@
     major /= div;
     }
-  minor = (fxt/div) / 10.;
-
-  // Figure out the first major and minor tick locations, relative to the
+
+  int axis = 0;
+  switch(axes[0]->GetAxisType())
+  {
+  case VTK_AXIS_TYPE_X:
+    axis = 0;
+    break;
+  case VTK_AXIS_TYPE_Y:
+    axis = 1;
+    break;
+  case VTK_AXIS_TYPE_Z:
+    axis = 2;
+    break;
+  }
+  customizedLabels = this->AxisLabels[axis];
+
+  if (customizedLabels == NULL)
+    {
+    // Figure out the first major tick locations, relative to the
+    // start of the axis.
+    if (sortedRange[0] <= 0.)
+      {
+      majorStart = major*(this->FFix(sortedRange[0]*(1./major)) + 0.);
+      }
+    else
+      {
+      majorStart = major*(this->FFix(sortedRange[0]*(1./major)) + 1.);
+      }
+    }
+  else
+    {
+      // If we have custom labels, they are supposed to be uniformly distributed
+      // inside the values range.
+      majorStart = sortedRange[0];
+      numTicks = this->GetNumTicks(range, major);
+      int labelsCount = customizedLabels->GetNumberOfValues();
+      if (numTicks > labelsCount)
+        {
+        major = range / (labelsCount - 1.);
+        }
+    }
+
+  minor = major / 10.;
+  // Figure out the first minor tick locations, relative to the
   // start of the axis.
   if (sortedRange[0] <= 0.)
     {
-    majorStart = major*(this->FFix(sortedRange[0]*(1./major)) + 0.);
     minorStart = minor*(this->FFix(sortedRange[0]*(1./minor)) + 0.);
     }
   else
     {
-    majorStart = major*(this->FFix(sortedRange[0]*(1./major)) + 1.);
     minorStart = minor*(this->FFix(sortedRange[0]*(1./minor)) + 1.);
     }
 
-  for (int i = 0; i < 4; i++)
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     axes[i]->SetMinorRangeStart(minorStart);
@@ -1931 +2053 @@
   major *= scale;
 
-  for (int i = 0; i < 4; i++)
+  // Set major start and delta for the corresponding cube axis
+  switch(axes[0]->GetAxisType())
+    {
+    case VTK_AXIS_TYPE_X:
+      this->MajorStart[0] = majorStart;
+      this->DeltaMajor[0] = major;
+      break;
+    case VTK_AXIS_TYPE_Y:
+      this->MajorStart[1] = majorStart;
+      this->DeltaMajor[1] = major;
+      break;
+    case VTK_AXIS_TYPE_Z:
+      this->MajorStart[2] = majorStart;
+      this->DeltaMajor[2] = major;
+      break;
+    }
+
+  // Set major and minor starts and deltas for all underlying axes
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     axes[i]->SetMinorStart(minorStart);
-    axes[i]->SetMajorStart(majorStart);
+    axes[i]->SetMajorStart(axes[0]->GetAxisType(), majorStart);
 
     axes[i]->SetDeltaMinor(minor);
-    axes[i]->SetDeltaMajor(major);
-    }
+    axes[i]->SetDeltaMajor(axes[0]->GetAxisType(), major);
+    }
+}
+
+// ****************************************************************
+void vtkRpCubeAxesActor::AutoScale(vtkViewport *viewport)
+{
+  // Current implementation only for perspective projections.
+  this->AutoScale(viewport, this->XAxes);
+  this->AutoScale(viewport, this->YAxes);
+  this->AutoScale(viewport, this->ZAxes);
+}
+
+// ****************************************************************
+void vtkRpCubeAxesActor::AutoScale(vtkViewport *viewport, vtkRpAxisActor *axis[NUMBER_OF_ALIGNED_AXIS])
+{
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; ++i)
+    {
+    double newTitleScale
+      = this->AutoScale(viewport,
+                        this->ScreenSize,
+                        axis[i]->GetTitleActor()->GetPosition());
+
+    axis[i]->SetTitleScale(newTitleScale);
+
+    // Now labels.
+    vtkRpAxisFollower** labelActors = axis[i]->GetLabelActors();
+
+    for(int j = 0; j < axis[i]->GetNumberOfLabelsBuilt(); ++j)
+      {
+      double newLabelScale
+        = this->AutoScale(viewport,
+                          this->ScreenSize,
+                          labelActors[j]->GetPosition());
+
+      labelActors[j]->SetScale(newLabelScale);
+      }
+    }
+}
+
+// ****************************************************************
+double vtkRpCubeAxesActor::AutoScale(vtkViewport *viewport, double screenSize,
+                                   double position[3])
+{
+  double factor = 1;
+  if (viewport->GetSize()[1] > 0)
+    {
+    factor = 2.0 * screenSize
+      * tan(vtkMath::RadiansFromDegrees(this->Camera->GetViewAngle()/2.0))
+      / viewport->GetSize()[1];
+    }
+
+    double dist = sqrt(
+          vtkMath::Distance2BetweenPoints(position,
+                                          this->Camera->GetPosition()));
+    double newScale = factor * dist;
+
+    return newScale;
 }
 
 // ****************************************************************
 //  Determine what the labels should be and set them in each axis.
-//
-//  Modification:
-//    Kathleen Bonnell, Wed Aug  6 13:59:15 PDT 2003
-//    Each axis type now has it's own 'mustAdjustValue' and 'pow'.
-//
-//    Kathleen Bonnell, Tue Jul 20 14:29:10 PDT 2004
-//    Ensure that '-0.0' is never used as a label.
-//
-//    Eric Brugger, Mon Jul 26 16:09:26 PDT 2004
-//    Correct a bug with a misplaced closing parenthesis.
-//
 // ****************************************************************
-
-void vtkRpCubeAxesActor::BuildLabels(vtkRpAxisActor *axes[4])
+void vtkRpCubeAxesActor::BuildLabels(vtkRpAxisActor *axes[NUMBER_OF_ALIGNED_AXIS])
 {
   char label[64];
-  int i, labelCount = 0;
-  double deltaMajor = axes[0]->GetDeltaMajor();
-  const double *p2  = axes[0]->GetPoint2Coordinate()->GetValue();
-  double *range     = axes[0]->GetRange();
-  double lastVal = 0, val = axes[0]->GetMajorStart();
+  int labelCount = 0;
+  double deltaMajor = axes[0]->GetDeltaMajor(axes[0]->GetAxisType());
+  double val = axes[0]->GetMajorRangeStart();
+  double p2[3], p1[3];
+  axes[0]->GetPoint1Coordinate()->GetValue(p1);
+  axes[0]->GetPoint2Coordinate()->GetValue(p2);
+  double *range = axes[0]->GetRange();
+  double axis[3] = { p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2] };
+  double axisLength = vtkMath::Norm(axis);
   double extents = range[1] - range[0];
+  double rangeScale = axisLength / extents;
+  double labelCountAsDouble = (axisLength - (val-range[0])*rangeScale) / deltaMajor;
   bool mustAdjustValue = 0;
   int lastPow = 0;
+  int axisIndex = 0;
+  vtkStringArray* customizedLabels = NULL;
 
   vtkStringArray *labels = vtkStringArray::New();
@@ -1973 +2165 @@
     {
     case VTK_AXIS_TYPE_X:
-      lastVal = p2[0];
+      axisIndex = 0;
       format = this->XLabelFormat;
       mustAdjustValue = this->MustAdjustXValue;
@@ -1979 +2171 @@
       break;
     case VTK_AXIS_TYPE_Y:
-      lastVal = p2[1];
+      axisIndex = 1;
       format = this->YLabelFormat;
       mustAdjustValue = this->MustAdjustYValue;
@@ -1985 +2177 @@
       break;
     case VTK_AXIS_TYPE_Z:
-      lastVal = p2[2];
+      axisIndex = 2;
       format = this->ZLabelFormat;
       mustAdjustValue = this->MustAdjustZValue;
@@ -1991 +2183 @@
       break;
     }
-
+  customizedLabels = this->AxisLabels[axisIndex];
   // figure out how many labels we need:
-  while (val <= lastVal && labelCount < VTK_MAX_LABELS)
-    {
-    labelCount++;
-    val += deltaMajor;
+  if(extents == 0 || vtkMath::IsNan(labelCountAsDouble))
+    {
+    labelCount = 0;
+    }
+  else
+    {
+    labelCount = vtkMath::Floor(labelCountAsDouble+2*FLT_EPSILON) + 1;
     }
 
   labels->SetNumberOfValues(labelCount);
 
-  val = axes[0]->GetMajorRangeStart();
-  deltaMajor = axes[0]->GetDeltaRangeMajor();
-
-  double scaleFactor = 1.;
-  if (lastPow != 0)
-    {
-    scaleFactor = 1.0/pow(10., lastPow);
-    }
-
-  for (i = 0; i < labelCount; i++)
-    {
-    if (fabs(val) < 0.01 && extents > 1)
-      {
-      // We just happened to fall at something near zero and the range is
-      // large, so set it to zero to avoid ugliness.
-      val = 0.;
-      }
-    if (mustAdjustValue)
-      {
-      sprintf(label, format, val*scaleFactor);
-      }
-    else
-      {
-      sprintf(label, format, val);
-      }
-    if (fabs(val) < 0.01)
-      {
-      //
-      // Ensure that -0.0 is never a label
-      // The maximum number of digits that we allow past the decimal is 5.
-      //
-      if (strcmp(label, "-0") == 0)
+  if (customizedLabels == NULL)
+    {
+    // Convert deltaMajor from world coord to range scale
+    deltaMajor = extents * deltaMajor/axisLength;
+
+    double scaleFactor = 1.;
+    if (lastPow != 0)
+      {
+      scaleFactor = 1.0/pow(10., lastPow);
+      }
+
+    for (int i = 0; i < labelCount; i++)
+      {
+      if (fabs(val) < 0.01 && extents > 1)
         {
-        sprintf(label, "0");
+        // We just happened to fall at something near zero and the range is
+        // large, so set it to zero to avoid ugliness.
+        val = 0.;
         }
-      else if (strcmp(label, "-0.0") == 0)
+      if (mustAdjustValue)
         {
-        sprintf(label, "0.0");
+        sprintf(label, format, val*scaleFactor);
         }
-      else if (strcmp(label, "-0.00") == 0)
+      else
         {
-        sprintf(label, "0.00");
+        sprintf(label, format, val);
         }
-      else if (strcmp(label, "-0.000") == 0)
+      if (fabs(val) < 0.01)
         {
-        sprintf(label, "0.000");
+        //
+        // Ensure that -0.0 is never a label
+        // The maximum number of digits that we allow past the decimal is 5.
+        //
+        if (strcmp(label, "-0") == 0)
+          {
+          sprintf(label, "0");
+          }
+        else if (strcmp(label, "-0.0") == 0)
+          {
+          sprintf(label, "0.0");
+          }
+        else if (strcmp(label, "-0.00") == 0)
+          {
+          sprintf(label, "0.00");
+          }
+        else if (strcmp(label, "-0.000") == 0)
+          {
+          sprintf(label, "0.000");
+          }
+        else if (strcmp(label, "-0.0000") == 0)
+          {
+          sprintf(label, "0.0000");
+          }
+        else if (strcmp(label, "-0.00000") == 0)
+          {
+          sprintf(label, "0.00000");
+          }
         }
-      else if (strcmp(label, "-0.0000") == 0)
+      labels->SetValue(i, label);
+      val += deltaMajor;
+      }
+    }
+  else
+    {
+    if (labelCount > 0)
+      {
+      double delta = customizedLabels->GetNumberOfValues() / labelCount;
+      for (int i = 0; i < labelCount; ++i)
         {
-        sprintf(label, "0.0000");
+        labels->SetValue(i, customizedLabels->GetValue(i * delta));
         }
-      else if (strcmp(label, "-0.00000") == 0)
-        {
-        sprintf(label, "0.00000");
-        }
-      }
-    labels->SetValue(i, label);
-    val += deltaMajor;
-    }
-  for (i = 0; i < 4; i++)
+      }
+    }
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
     {
     axes[i]->SetLabels(labels);
     }
   labels->Delete();
+}
+
+vtkStringArray* vtkRpCubeAxesActor::GetAxisLabels(int axis)
+{
+  return (axis >= 0 && axis < 3) ? this->AxisLabels[axis] : NULL;
+}
+
+void vtkRpCubeAxesActor::SetAxisLabels(int axis, vtkStringArray* value)
+{
+  if (axis >= 0 && axis < 3 && value != this->AxisLabels[axis])
+    {
+    vtkStringArray* previous = this->AxisLabels[axis];
+    if (value != NULL)
+      {
+      value->Register(this);
+      }
+    this->AxisLabels[axis] = value;
+    if (previous != NULL)
+      {
+      previous->UnRegister(this);
+      }
+    this->Modified();
+    }
 }
 
 // ****************************************************************************
 //  Set automatic label scaling mode, set exponents for each axis type.
-//
 // ****************************************************************************
 void vtkRpCubeAxesActor::SetLabelScaling(bool autoscale, int upowX, int upowY,
@@ -2084 +2315 @@
     }
 }
+
+// ****************************************************************************
+// Set the i-th title text property.
+// ****************************************************************************
+
+vtkTextProperty* vtkRpCubeAxesActor::GetTitleTextProperty(int axis)
+{
+  return (axis >= 0 && axis < 3) ? this->TitleTextProperty[axis] : NULL;
+}
+
+// ****************************************************************************
+// Get the i-th label text property.
+// ****************************************************************************
+
+vtkTextProperty* vtkRpCubeAxesActor::GetLabelTextProperty(int axis)
+{
+  return (axis >= 0 && axis < 3) ? this->LabelTextProperty[axis] : NULL;
+}
+
+// ****************************************************************************
+//  Set axes and screen size of the labels.
+// ****************************************************************************
+void vtkRpCubeAxesActor::UpdateLabels(vtkRpAxisActor **axis, int index)
+  {
+  for (int i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+    {
+    int numberOfLabelsBuild = axis[i]->GetNumberOfLabelsBuilt();
+    vtkRpAxisFollower **labelActors = axis[i]->GetLabelActors();
+    for(int k=0; k < numberOfLabelsBuild; ++k)
+      {
+      if(index == 0)
+        {
+        labelActors[k]->SetAxis(this->XAxes[i]);
+        }
+      else if(index == 1)
+        {
+        labelActors[k]->SetAxis(this->YAxes[i]);
+        }
+      else if(index == 2)
+        {
+        labelActors[k]->SetAxis(this->ZAxes[i]);
+        }
+      else
+        {
+        // Do nothing.
+        }
+
+      labelActors[k]->SetScreenOffset(this->LabelScreenOffset);
+      labelActors[k]->SetEnableDistanceLOD( this->EnableDistanceLOD );
+      labelActors[k]->SetDistanceLODThreshold( this->DistanceLODThreshold );
+      labelActors[k]->SetEnableViewAngleLOD( this->EnableViewAngleLOD );
+      labelActors[k]->SetViewAngleLODThreshold( this->ViewAngleLODThreshold );
+      }
+    }
+  }
+// ****************************************************************************
+void vtkRpCubeAxesActor::SetXAxesLinesProperty(vtkProperty *prop)
+{
+  this->XAxesLinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetYAxesLinesProperty(vtkProperty *prop)
+{
+  this->YAxesLinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetZAxesLinesProperty(vtkProperty *prop)
+{
+  this->ZAxesLinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpCubeAxesActor::GetXAxesLinesProperty()
+{
+  return this->XAxesLinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetYAxesLinesProperty()
+{
+  return this->YAxesLinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetZAxesLinesProperty()
+{
+  return this->ZAxesLinesProperty;
+}
+
+// ****************************************************************************
+void vtkRpCubeAxesActor::SetXAxesGridlinesProperty(vtkProperty *prop)
+{
+  this->XAxesGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetYAxesGridlinesProperty(vtkProperty *prop)
+{
+  this->YAxesGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetZAxesGridlinesProperty(vtkProperty *prop)
+{
+  this->ZAxesGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpCubeAxesActor::GetXAxesGridlinesProperty()
+{
+  return this->XAxesGridlinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetYAxesGridlinesProperty()
+{
+  return this->YAxesGridlinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetZAxesGridlinesProperty()
+{
+  return this->ZAxesGridlinesProperty;
+}
+
+// ****************************************************************************
+void vtkRpCubeAxesActor::SetXAxesInnerGridlinesProperty(vtkProperty *prop)
+{
+  this->XAxesInnerGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetYAxesInnerGridlinesProperty(vtkProperty *prop)
+{
+  this->YAxesInnerGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetZAxesInnerGridlinesProperty(vtkProperty *prop)
+{
+  this->ZAxesInnerGridlinesProperty->DeepCopy(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpCubeAxesActor::GetXAxesInnerGridlinesProperty()
+{
+  return this->XAxesInnerGridlinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetYAxesInnerGridlinesProperty()
+{
+  return this->YAxesInnerGridlinesProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetZAxesInnerGridlinesProperty()
+{
+  return this->ZAxesInnerGridlinesProperty;
+}
+
+// ****************************************************************************
+void vtkRpCubeAxesActor::SetXAxesGridpolysProperty(vtkProperty *prop)
+{
+  this->XAxesGridpolysProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetYAxesGridpolysProperty(vtkProperty *prop)
+{
+  this->YAxesGridpolysProperty->DeepCopy(prop);
+  this->Modified();
+}
+void vtkRpCubeAxesActor::SetZAxesGridpolysProperty(vtkProperty *prop)
+{
+  this->ZAxesGridpolysProperty->DeepCopy(prop);
+  this->Modified();
+}
+
+// ****************************************************************************
+vtkProperty* vtkRpCubeAxesActor::GetXAxesGridpolysProperty()
+{
+  return this->XAxesGridpolysProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetYAxesGridpolysProperty()
+{
+  return this->YAxesGridpolysProperty;
+}
+vtkProperty* vtkRpCubeAxesActor::GetZAxesGridpolysProperty()
+{
+  return this->ZAxesGridpolysProperty;
+}
+// --------------------------------------------------------------------------
+void vtkRpCubeAxesActor::UpdateGridLineVisibility(int idx)
+{
+  if( this->GridLineLocation != VTK_GRID_LINES_ALL &&
+      (this->DrawXGridlines || this->DrawYGridlines || this->DrawZGridlines) )
+    {
+    for(int i=0; i < NUMBER_OF_ALIGNED_AXIS; ++i)
+      {
+      this->XAxes[i]->SetDrawGridlines(0);
+      this->YAxes[i]->SetDrawGridlines(0);
+      this->ZAxes[i]->SetDrawGridlines(0);
+      this->XAxes[i]->SetDrawGridlinesOnly(0);
+      this->YAxes[i]->SetDrawGridlinesOnly(0);
+      this->ZAxes[i]->SetDrawGridlinesOnly(0);
+      }
+
+    this->XAxes[vtkRpCubeAxesActorTriads[idx][0]]->SetDrawGridlines(this->DrawXGridlines);
+    this->YAxes[vtkRpCubeAxesActorTriads[idx][1]]->SetDrawGridlines(this->DrawYGridlines);
+    this->ZAxes[vtkRpCubeAxesActorTriads[idx][2]]->SetDrawGridlines(this->DrawZGridlines);
+
+    // Update axis render list
+    int id = 0;
+    if(this->NumberOfAxesX == 1)
+      {
+      id = this->RenderAxesX[this->NumberOfAxesX] = vtkRpCubeAxesActorTriads[idx][0];
+      this->XAxes[id]->SetDrawGridlinesOnly((this->RenderAxesX[0] != id) ? 1 : 0);
+      this->NumberOfAxesX += (this->RenderAxesX[0] != id) ? 1 : 0;
+      }
+    if(this->NumberOfAxesY == 1)
+      {
+      id = this->RenderAxesY[this->NumberOfAxesY] = vtkRpCubeAxesActorTriads[idx][1];
+      this->YAxes[id]->SetDrawGridlinesOnly((this->RenderAxesY[0] != id) ? 1 : 0);
+      this->NumberOfAxesY += (this->RenderAxesY[0] != id) ? 1 : 0;
+      }
+    if(this->NumberOfAxesZ == 1)
+      {
+      id = this->RenderAxesZ[this->NumberOfAxesZ] = vtkRpCubeAxesActorTriads[idx][2];
+      this->ZAxes[id]->SetDrawGridlinesOnly((this->RenderAxesZ[0] != id) ? 1 : 0);
+      this->NumberOfAxesZ += (this->RenderAxesZ[0] != id) ? 1 : 0;
+      }
+    }
+}
+// --------------------------------------------------------------------------
+int vtkRpCubeAxesActor::FindClosestAxisIndex(double pts[8][3])
+{
+  // Loop over points and find the closest point to the camera
+  double min = VTK_LARGE_FLOAT;
+  int idx = 0;
+  for (int i=0; i < 8; i++)
+    {
+    if (pts[i][2] < min)
+      {
+      idx = i;
+      min = pts[i][2];
+      }
+    }
+  return idx;
+}
+
+// --------------------------------------------------------------------------
+int vtkRpCubeAxesActor::FindFurtherstAxisIndex(double pts[8][3])
+{
+  // Loop over points and find the furthest point from the camera
+  double max = -VTK_LARGE_FLOAT;
+  int idx = 0;
+  for (int i=0; i < 8; i++)
+    {
+    if (pts[i][2] > max)
+      {
+      idx = i;
+      max = pts[i][2];
+      }
+    }
+  return idx;
+}
+// --------------------------------------------------------------------------
+ void vtkRpCubeAxesActor::FindBoundaryEdge( int &xloc, int &yloc,
+                                          int &zloc, double pts[8][3])
+ {
+   // boundary edges fly mode
+   xloc = yloc = zloc = 1;
+   int i, xIdx = 0, yIdx = 0, zIdx = 0, zIdx2 = 0;
+   int xAxes = 0, yAxes = 0, zAxes = 0;
+   double slope = 0.0, minSlope, num, den, d2;
+   double e1[3], e2[3], e3[3];
+   int idx = 0;
+
+   // Find distance to origin
+   double d2Min = VTK_LARGE_FLOAT;
+   for (i=0; i < 8; i++)
+     {
+     d2 = pts[i][0]*pts[i][0] + pts[i][1]*pts[i][1];
+     if (d2 < d2Min)
+       {
+       d2Min = d2;
+       idx = i;
+       }
+     }
+
+   // find minimum slope point connected to closest point and on
+   // right side (in projected coordinates). This is the first edge.
+   minSlope = VTK_LARGE_FLOAT;
+   for (xIdx=0, i=0; i<3; i++)
+     {
+     num = (pts[vtkRpCubeAxesActorConn[idx][i]][1] - pts[idx][1]);
+     den = (pts[vtkRpCubeAxesActorConn[idx][i]][0] - pts[idx][0]);
+     if (den != 0.0)
+       {
+       slope = num / den;
+       }
+     if (slope < minSlope && den > 0)
+       {
+       xIdx = vtkRpCubeAxesActorConn[idx][i];
+       yIdx = vtkRpCubeAxesActorConn[idx][(i+1)%3];
+       zIdx = vtkRpCubeAxesActorConn[idx][(i+2)%3];
+       xAxes = i;
+       minSlope = slope;
+       }
+     }
+
+   // find edge (connected to closest point) on opposite side
+   for ( i=0; i<3; i++)
+     {
+     e1[i] = (pts[xIdx][i] - pts[idx][i]);
+     e2[i] = (pts[yIdx][i] - pts[idx][i]);
+     e3[i] = (pts[zIdx][i] - pts[idx][i]);
+     }
+   vtkMath::Normalize(e1);
+   vtkMath::Normalize(e2);
+   vtkMath::Normalize(e3);
+
+   if (vtkMath::Dot(e1,e2) < vtkMath::Dot(e1,e3))
+     {
+     yAxes = (xAxes + 1) % 3;
+     }
+   else
+     {
+     yIdx = zIdx;
+     yAxes = (xAxes + 2) % 3;
+     }
+
+   // Find the final point by determining which global x-y-z axes have not
+   // been represented, and then determine the point closest to the viewer.
+   zAxes = (xAxes != 0 && yAxes != 0 ? 0 :
+           (xAxes != 1 && yAxes != 1 ? 1 : 2));
+   if (pts[vtkRpCubeAxesActorConn[xIdx][zAxes]][2] <
+       pts[vtkRpCubeAxesActorConn[yIdx][zAxes]][2])
+     {
+     zIdx = xIdx;
+     zIdx2 = vtkRpCubeAxesActorConn[xIdx][zAxes];
+     }
+   else
+     {
+     zIdx = yIdx;
+     zIdx2 = vtkRpCubeAxesActorConn[yIdx][zAxes];
+     }
+
+   int mini = (idx < xIdx ? idx : xIdx);
+   switch (xAxes)
+     {
+     case 0:
+       xloc = vtkRpCubeAxesActorTriads[mini][0];
+       break;
+     case 1:
+       yloc = vtkRpCubeAxesActorTriads[mini][1];
+       break;
+     case 2:
+       zloc = vtkRpCubeAxesActorTriads[mini][2];
+       break;
+     }
+   mini = (idx < yIdx ? idx : yIdx);
+   switch (yAxes)
+     {
+     case 0:
+       xloc = vtkRpCubeAxesActorTriads[mini][0];
+       break;
+     case 1:
+       yloc =vtkRpCubeAxesActorTriads[mini][1];
+       break;
+     case 2:
+       zloc = vtkRpCubeAxesActorTriads[mini][2];
+       break;
+     }
+   mini = (zIdx < zIdx2 ? zIdx : zIdx2);
+   switch (zAxes)
+     {
+     case 0:
+       xloc = vtkRpCubeAxesActorTriads[mini][0];
+       break;
+     case 1:
+       yloc = vtkRpCubeAxesActorTriads[mini][1];
+       break;
+     case 2:
+       zloc = vtkRpCubeAxesActorTriads[mini][2];
+       break;
+     }
+ }
+
+// --------------------------------------------------------------------------
+int vtkRpCubeAxesActor::RenderGeometry(
+    bool &initialRender, vtkViewport *viewport, bool checkAxisVisibility,
+    int (vtkRpAxisActor::*renderMethod)(vtkViewport*))
+{
+  int i, renderedSomething = 0;
+
+  // Make sure axes are initialized and visibility is properly set
+  if(checkAxisVisibility)
+    {
+    // Initialization
+    if (!this->Camera)
+      {
+      vtkErrorMacro(<<"No camera!");
+      this->RenderSomething = 0;
+      return 0;
+      }
+
+    this->BuildAxes(viewport);
+
+    if (initialRender)
+      {
+      for (i = 0; i < NUMBER_OF_ALIGNED_AXIS; i++)
+        {
+        this->XAxes[i]->BuildAxis(viewport, true);
+        this->YAxes[i]->BuildAxis(viewport, true);
+        this->ZAxes[i]->BuildAxis(viewport, true);
+        }
+      }
+    initialRender = false;
+
+    this->DetermineRenderAxes(viewport);
+    }
+
+  // Render the axes
+  for (i = 0; i < this->NumberOfAxesX; i++)
+    {
+    renderedSomething +=
+        (this->XAxes[this->RenderAxesX[i]]->*renderMethod)(viewport);
+    }
+
+  for (i = 0; i < this->NumberOfAxesY; i++)
+    {
+    renderedSomething +=
+        (this->YAxes[this->RenderAxesY[i]]->*renderMethod)(viewport);
+    }
+
+  for (i = 0; i < this->NumberOfAxesZ; i++)
+    {
+    renderedSomething +=
+        (this->ZAxes[this->RenderAxesZ[i]]->*renderMethod)(viewport);
+    }
+  return renderedSomething;
+}
+
+// --------------------------------------------------------------------------
+void vtkRpCubeAxesActor::GetRenderedBounds(double *b)
+{
+  vtkBoundingBox bbox(this->GetBounds()); // Data bounds
+
+  // Make a heuristic on the final bounds that embed test labels
+  // Just inflate the box based on its max length
+  bbox.Inflate(bbox.GetMaxLength());
+
+  bbox.GetBounds(b);
+}
+
+// --------------------------------------------------------------------------
+double* vtkRpCubeAxesActor::GetRenderedBounds()
+{
+  this->GetRenderedBounds(this->RenderedBounds);
+  // Return our data holder
+  return this->RenderedBounds;
+}

trunk/packages/vizservers/vtkvis/vtkRpCubeAxesActor.h

@@ -42 +42 @@
 // the bounding box.
 //
-// .SECTION See Also
-// vtkActor vtkRpAxisActor vtkRpCubeAxesActor2D
+// .SECTION 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.
+//
+// .section See Also
+// vtkActor vtkAxisActor vtkCubeAxesActor2D
 
 #ifndef __vtkRpCubeAxesActor_h
@@ -58 +67 @@
 #define VTK_TICKS_BOTH          2
 
+#define VTK_GRID_LINES_ALL      0
+#define VTK_GRID_LINES_CLOSEST  1
+#define VTK_GRID_LINES_FURTHEST 2
+
+#define NUMBER_OF_ALIGNED_AXIS 4
+
+#include "vtkRenderingAnnotationModule.h" // For export macro
 #include "vtkActor.h"
 
 class vtkRpAxisActor;
 class vtkCamera;
-
-class VTK_HYBRID_EXPORT vtkRpCubeAxesActor : public vtkActor
+class vtkTextProperty;
+class vtkStringArray;
+
+class VTKRENDERINGANNOTATION_EXPORT vtkRpCubeAxesActor : public vtkActor
 {
 public:
@@ -77 +95 @@
   // Draw the axes as per the vtkProp superclass' API.
   virtual int RenderOpaqueGeometry(vtkViewport*);
-  virtual int RenderTranslucentGeometry(vtkViewport *) {return 0;}
+  virtual int RenderTranslucentGeometry(vtkViewport*);
+  virtual int RenderTranslucentPolygonalGeometry(vtkViewport*);
+  virtual int RenderOverlay(vtkViewport*);
+  int HasTranslucentPolygonalGeometry();
+
+  // Description:
+  // Gets/Sets the RebuildAxes flag
+  vtkSetMacro( RebuildAxes, bool );
+  vtkGetMacro( RebuildAxes, bool );
 
   // Description:
@@ -85 +111 @@
   // sure that the min's are less than the max's.
   vtkSetVector6Macro(Bounds,double);
-  double *GetBounds();
-  void GetBounds(double& xmin, double& xmax, double& ymin, double& ymax,
-                 double& zmin, double& zmax);
-  void GetBounds(double bounds[6]);
+  vtkGetVector6Macro(Bounds,double);
+
+  // Description:
+  // 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();
 
   // Description:
@@ -102 +131 @@
   vtkGetVector2Macro( XAxisRange, double );
   vtkGetVector2Macro( YAxisRange, double );
+  // Description
+  // 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 );
+
+  // Description:
+  // Explicitly specify the screen size of title and label text.
+  // ScreenSize detemines the size of the text in terms of screen
+  // pixels. Default is 10.0.
+  void SetScreenSize(double screenSize);
+  vtkGetMacro(ScreenSize, double);
 
   // Description:
@@ -174 +216 @@
 
   // Description:
+  // Enable and disable the use of distance based LOD for titles and labels.
+  vtkSetMacro( EnableDistanceLOD, int );
+  vtkGetMacro( EnableDistanceLOD, int );
+
+  // Description:a
+  // Set distance LOD threshold [0.0 - 1.0] for titles and labels.
+  vtkSetClampMacro( DistanceLODThreshold, double, 0.0, 1.0 );
+  vtkGetMacro( DistanceLODThreshold, double);
+
+  // Description:
+  // Enable and disable the use of view angle based LOD for titles and labels.
+  vtkSetMacro( EnableViewAngleLOD, int );
+  vtkGetMacro( EnableViewAngleLOD, int );
+
+  // Description:
+  // Set view angle LOD threshold [0.0 - 1.0] for titles and labels.
+  vtkSetClampMacro( ViewAngleLODThreshold, double, 0., 1. );
+  vtkGetMacro( ViewAngleLODThreshold, double );
+
+  // Description:
   // Turn on and off the visibility of each axis.
   vtkSetMacro(XAxisVisibility,int);
@@ -239 +301 @@
   vtkBooleanMacro(DrawZGridlines,int);
 
+  vtkSetMacro(DrawXInnerGridlines,int);
+  vtkGetMacro(DrawXInnerGridlines,int);
+  vtkBooleanMacro(DrawXInnerGridlines,int);
+
+  vtkSetMacro(DrawYInnerGridlines,int);
+  vtkGetMacro(DrawYInnerGridlines,int);
+  vtkBooleanMacro(DrawYInnerGridlines,int);
+
+  vtkSetMacro(DrawZInnerGridlines,int);
+  vtkGetMacro(DrawZInnerGridlines,int);
+  vtkBooleanMacro(DrawZInnerGridlines,int);
+
+  vtkSetMacro(DrawXGridpolys,int);
+  vtkGetMacro(DrawXGridpolys,int);
+  vtkBooleanMacro(DrawXGridpolys,int);
+
+  vtkSetMacro(DrawYGridpolys,int);
+  vtkGetMacro(DrawYGridpolys,int);
+  vtkBooleanMacro(DrawYGridpolys,int);
+
+  vtkSetMacro(DrawZGridpolys,int);
+  vtkGetMacro(DrawZGridpolys,int);
+  vtkBooleanMacro(DrawZGridpolys,int);
+
+  // Description:
+  // Returns the text property for the title on an axis.
+  vtkTextProperty *GetTitleTextProperty(int);
+
+  // Description:
+  // Returns the text property for the labels on an axis.
+  vtkTextProperty *GetLabelTextProperty(int);
+
+  // Description:
+  // Get/Set axes actors properties.
+  void SetXAxesLinesProperty(vtkProperty *);
+  vtkProperty* GetXAxesLinesProperty();
+  void SetYAxesLinesProperty(vtkProperty *);
+  vtkProperty* GetYAxesLinesProperty();
+  void SetZAxesLinesProperty(vtkProperty *);
+  vtkProperty* GetZAxesLinesProperty();
+
+  // Description:
+  // Get/Set axes (outer) gridlines actors properties.
+  void SetXAxesGridlinesProperty(vtkProperty *);
+  vtkProperty* GetXAxesGridlinesProperty();
+  void SetYAxesGridlinesProperty(vtkProperty *);
+  vtkProperty* GetYAxesGridlinesProperty();
+  void SetZAxesGridlinesProperty(vtkProperty *);
+  vtkProperty* GetZAxesGridlinesProperty();
+
+  // Description:
+  // Get/Set axes inner gridlines actors properties.
+  void SetXAxesInnerGridlinesProperty(vtkProperty *);
+  vtkProperty* GetXAxesInnerGridlinesProperty();
+  void SetYAxesInnerGridlinesProperty(vtkProperty *);
+  vtkProperty* GetYAxesInnerGridlinesProperty();
+  void SetZAxesInnerGridlinesProperty(vtkProperty *);
+  vtkProperty* GetZAxesInnerGridlinesProperty();
+
+  // Description:
+  // Get/Set axes gridPolys actors properties.
+  void SetXAxesGridpolysProperty(vtkProperty *);
+  vtkProperty* GetXAxesGridpolysProperty();
+  void SetYAxesGridpolysProperty(vtkProperty *);
+  vtkProperty* GetYAxesGridpolysProperty();
+  void SetZAxesGridpolysProperty(vtkProperty *);
+  vtkProperty* GetZAxesGridpolysProperty();
+
   // Description:
   // Set/Get the location of ticks marks.
@@ -252 +382 @@
 
   void SetLabelScaling(bool, int, int, int);
-  // Description:
-  // Shallow copy of a KatCubeAxesActor.
-  void ShallowCopy(vtkRpCubeAxesActor *actor);
+
+  // Description:
+  // Get/Set 2D mode
+  // NB: Use vtkTextActor for titles in 2D instead of vtkRpAxisFollower
+  void SetUse2DMode( int val );
+  int GetUse2DMode();
+
+  // Description:
+  // For 2D mode only: save axis title positions for later use
+  void SetSaveTitlePosition( int val );
+
+  // Description:
+  // Provide an oriented bounded box when using AxisBaseFor.
+  vtkSetVector6Macro(OrientedBounds,double);
+  vtkGetVector6Macro(OrientedBounds, double);
+
+  // Description:
+  // Enable/Disable the usage of the OrientedBounds
+  vtkSetMacro(UseOrientedBounds, int);
+  vtkGetMacro(UseOrientedBounds, int);
+
+  // Description:
+  // Vector that should be use as the base for X
+  vtkSetVector3Macro(AxisBaseForX,double);
+  vtkGetVector3Macro(AxisBaseForX, double);
+
+  // Description:
+  // Vector that should be use as the base for Y
+  vtkSetVector3Macro(AxisBaseForY,double);
+  vtkGetVector3Macro(AxisBaseForY, double);
+
+  // Description:
+  // Vector that should be use as the base for Z
+  vtkSetVector3Macro(AxisBaseForZ,double);
+  vtkGetVector3Macro(AxisBaseForZ, double);
+
+  // Description:
+  // Provide a custom AxisOrigin. This point must be inside the bouding box and
+  // will represent the point where the 3 axes will interesect
+  vtkSetVector3Macro(AxisOrigin,double);
+  vtkGetVector3Macro(AxisOrigin, double);
+
+  // Description:
+  // Enable/Disable the usage of the AxisOrigin
+  vtkSetMacro(UseAxisOrigin, int);
+  vtkGetMacro(UseAxisOrigin, int);
+
+  // Description:
+  // Specify the mode in which the cube axes should render its gridLines
+  vtkSetMacro(GridLineLocation,int);
+  vtkGetMacro(GridLineLocation,int);
+
+  vtkSetMacro(XAutoLabelFormat,int);
+  vtkGetMacro(XAutoLabelFormat,int);
+  vtkBooleanMacro(XAutoLabelFormat,int);
+  vtkSetMacro(YAutoLabelFormat,int);
+  vtkGetMacro(YAutoLabelFormat,int);
+  vtkBooleanMacro(YAutoLabelFormat,int);
+  vtkSetMacro(ZAutoLabelFormat,int);
+  vtkGetMacro(ZAutoLabelFormat,int);
+  vtkBooleanMacro(ZAutoLabelFormat,int);
 
 protected:
@@ -261 +449 @@
 
   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);
-
-  double       Bounds[6]; //Define bounds explicitly
+  int FRound( double fnt );
+  int GetNumTicks( double range, double fxt);
+
+  void UpdateLabels(vtkRpAxisActor **axis, int index);
+
+  double Bounds[6]; //Define bounds explicitly
 
   vtkCamera *Camera;
+
   int FlyMode;
 
-  // to control all axes
-  // [0] always for 'Major' axis during non-static fly modes.
-  vtkRpAxisActor *XAxes[4];
-  vtkRpAxisActor *YAxes[4];
-  vtkRpAxisActor *ZAxes[4];
+  // 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]);
+
+  // Description:
+  // 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;
+
+  // Description:
+  // If enabled the actor will not be visible at a certain distance from the camera.
+  // Default is true
+  int EnableDistanceLOD;
+
+  // Description:
+  // Default is 0.80
+  // This determines at what fraction of camera far clip range, actor is not visible.
+  double DistanceLODThreshold;
+
+  // Description:
+  // If enabled the actor will not be visible at a certain view angle.
+  // Default is true.
+  int EnableViewAngleLOD;
+
+  // Description:
+  // This determines at what view angle to geometry will make the geometry not visibile.
+  // Default is 0.3.
+  double ViewAngleLODThreshold;
+
+  // Description:
+  // Control variables for all axes
+  // NB: [0] always for 'Major' axis during non-static fly modes.
+  vtkRpAxisActor *XAxes[NUMBER_OF_ALIGNED_AXIS];
+  vtkRpAxisActor *YAxes[NUMBER_OF_ALIGNED_AXIS];
+  vtkRpAxisActor *ZAxes[NUMBER_OF_ALIGNED_AXIS];
+
+  bool RebuildAxes;
 
   char *XTitle;
@@ -311 +551 @@
   int DrawZGridlines;
 
+  int DrawXInnerGridlines;
+  int DrawYInnerGridlines;
+  int DrawZInnerGridlines;
+
+  int DrawXGridpolys;
+  int DrawYGridpolys;
+  int DrawZGridpolys;
+
   char  *XLabelFormat;
   char  *YLabelFormat;
   char  *ZLabelFormat;
+
   double CornerOffset;
+
   int   Inertia;
+
   int   RenderCount;
+
   int   InertiaLocs[3];
 
   int RenderSomething;
+
+  double LabelScreenOffset;
+  double TitleScreenOffset;
+
+  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:
@@ -330 +614 @@
 
   vtkTimeStamp BuildTime;
+  int LastUseOrientedBounds;
   int LastXPow;
   int LastYPow;
   int LastZPow;
+
   int UserXPow;
   int UserYPow;
   int UserZPow;
+
   bool AutoLabelScaling;
+  int XAutoLabelFormat;
+  int YAutoLabelFormat;
+  int ZAutoLabelFormat;
+
   int LastXAxisDigits;
   int LastYAxisDigits;
   int LastZAxisDigits;
+
   double LastXRange[2];
   double LastYRange[2];
   double LastZRange[2];
-  int   LastFlyMode;
-
-  int   RenderAxesX[4];
-  int   RenderAxesY[4];
-  int   RenderAxesZ[4];
+  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;
@@ -355 +650 @@
   bool MustAdjustYValue;
   bool MustAdjustZValue;
+
   bool ForceXLabelReset;
   bool ForceYLabelReset;
@@ -363 +659 @@
   double ZAxisRange[2];
 
-  // various helper methods
+  double LabelScale;
+  double TitleScale;
+
+  double ScreenSize;
+
+  // Description:
+  // 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 (vtkRpAxisActor::*renderMethod)(vtkViewport*));
+
   void  TransformBounds(vtkViewport *viewport, const double bounds[6],
                         double pts[8][3]);
   void  AdjustAxes(double bounds[6],
-                   double xCoords[4][6], double yCoords[4][6],
-                   double zCoords[4][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]);
 
@@ -379 +688 @@
   void  DetermineRenderAxes(vtkViewport *);
   void  SetNonDependentAttributes(void);
-  void  BuildLabels(vtkRpAxisActor *axes[4]);
-  void  AdjustTicksComputeRange(vtkRpAxisActor *axes[4],
+  void  BuildLabels(vtkRpAxisActor *axes[NUMBER_OF_ALIGNED_AXIS]);
+  void  AdjustTicksComputeRange(vtkRpAxisActor *axes[NUMBER_OF_ALIGNED_AXIS],
       double rangeMin, double rangeMax);
 
-  // hide the superclass' ShallowCopy() from the user and the compiler.
-  void ShallowCopy(vtkProp *prop) { this->vtkProp::ShallowCopy( prop ); };
+  void    AutoScale(vtkViewport *viewport);
+  void    AutoScale(vtkViewport *viewport, vtkRpAxisActor *axes[NUMBER_OF_ALIGNED_AXIS]);
+  double  AutoScale(vtkViewport *viewport, double screenSize, double position[3]);
 };