Index: vtkCubeAxesActor.cxx
===================================================================
RCS file: /cvsroot/VTK/VTK/Hybrid/vtkCubeAxesActor.cxx,v
retrieving revision 1.4
diff -u -r1.4 vtkCubeAxesActor.cxx
--- vtkCubeAxesActor.cxx	7 Dec 2007 18:04:50 -0000	1.4
+++ vtkCubeAxesActor.cxx	10 Sep 2008 22:30:16 -0000
@@ -183,6 +183,17 @@
   this->UserXPow = 0;
   this->UserYPow = 0;
   this->UserZPow = 0;
+
+  this->UseAxisRangeForXLabels = 0;
+  this->UseAxisRangeForYLabels = 0;
+  this->UseAxisRangeForZLabels = 0;
+  
+  this->UserXLabelRange[0] = this->Bounds[0];
+  this->UserXLabelRange[1] = this->Bounds[1];
+  this->UserYLabelRange[0] = this->Bounds[2];
+  this->UserYLabelRange[1] = this->Bounds[3];
+  this->UserZLabelRange[0] = this->Bounds[4];
+  this->UserZLabelRange[1] = this->Bounds[5];
 }
 
 // ****************************************************************************
@@ -222,6 +233,16 @@
   this->ForceXLabelReset = actor->ForceXLabelReset;
   this->ForceYLabelReset = actor->ForceYLabelReset;
   this->ForceZLabelReset = actor->ForceZLabelReset;
+  
+  this->UseAxisRangeForXLabels = actor->UseAxisRangeForXLabels;
+  this->UseAxisRangeForYLabels = actor->UseAxisRangeForYLabels;
+  this->UseAxisRangeForZLabels = actor->UseAxisRangeForZLabels;
+  this->UserXLabelRange[0] = actor->UserXLabelRange[0];
+  this->UserXLabelRange[1] = actor->UserXLabelRange[1];
+  this->UserYLabelRange[0] = actor->UserYLabelRange[0];
+  this->UserYLabelRange[1] = actor->UserYLabelRange[1];
+  this->UserZLabelRange[0] = actor->UserZLabelRange[0];
+  this->UserZLabelRange[1] = actor->UserZLabelRange[1];
 }
 
 // ****************************************************************************
@@ -406,12 +427,11 @@
                                   double xRange[2], double yRange[2], 
                                   double zRange[2])
 {
+
   xRange[0] = bounds[0];
   xRange[1] = bounds[1];
-
   yRange[0] = bounds[2];
   yRange[1] = bounds[3];
-
   zRange[0] = bounds[4];
   zRange[1] = bounds[5];
 
@@ -1255,6 +1275,7 @@
   this->AdjustValues(this->Bounds);
   this->AdjustRange(this->Bounds);
 
+ 
   // Prepare axes for rendering with user-definable options 
   for (i = 0; i < 4; i++)
     {
@@ -1276,11 +1297,9 @@
     this->ZAxes[i]->GetPoint2Coordinate()->SetValue(zCoords[i][3], 
                                                     zCoords[i][4],
                                                     zCoords[i][5]);
-
     this->XAxes[i]->SetRange(xRange[0], xRange[1]);
     this->YAxes[i]->SetRange(yRange[0], yRange[1]);
     this->ZAxes[i]->SetRange(zRange[0], zRange[1]);
-
     this->XAxes[i]->SetTitle(this->ActualXLabel);
     this->YAxes[i]->SetTitle(this->ActualYLabel);
     this->ZAxes[i]->SetTitle(this->ActualZLabel);
@@ -1910,8 +1929,13 @@
   double extents = range[1] - range[0];
   bool mustAdjustValue = 0;
   int lastPow = 0;
+  double userRange[2] = { 0., 1. };
 
   vtkStringArray *labels = vtkStringArray::New();
+  double userExtents = 0;
+  double userSpecifiedDelta = 0;
+  double userSpecifiedStartValue = 0;
+  
   const char *format = "%s";
   switch (axes[0]->GetAxisType())
     {
@@ -1920,18 +1944,36 @@
       format = this->XLabelFormat;
       mustAdjustValue = this->MustAdjustXValue;
       lastPow = this->LastXPow;
+      userExtents = 
+        (this->UseAxisRangeForXLabels)?this->UserXLabelRange[1]-this->UserXLabelRange[0]:extents;
+      userSpecifiedStartValue = 
+        (this->UseAxisRangeForXLabels)?this->UserXLabelRange[0]:majorStart;
+      userRange[0] = this->UserXLabelRange[0];
+      userRange[1] = this->UserXLabelRange[1];
       break;
     case VTK_AXIS_TYPE_Y:
       lastVal = p2[1];
       format = this->YLabelFormat;
       mustAdjustValue = this->MustAdjustYValue;
       lastPow = this->LastYPow;
+      userExtents = 
+        (this->UseAxisRangeForYLabels)?this->UserYLabelRange[1]-this->UserYLabelRange[0]:extents;
+      userSpecifiedStartValue = 
+        (this->UseAxisRangeForYLabels)?this->UserYLabelRange[0]:majorStart;
+      userRange[0] = this->UserYLabelRange[0];
+      userRange[1] = this->UserYLabelRange[1];
       break;
     case VTK_AXIS_TYPE_Z:
       lastVal = p2[2];
       format = this->ZLabelFormat;
       mustAdjustValue = this->MustAdjustZValue;
       lastPow = this->LastZPow;
+      userExtents = 
+        (this->UseAxisRangeForZLabels)?this->UserZLabelRange[1]-this->UserZLabelRange[0]:extents;
+      userSpecifiedStartValue = 
+        (this->UseAxisRangeForZLabels)?this->UserZLabelRange[0]:majorStart;
+      userRange[0] = this->UserZLabelRange[0];
+      userRange[1] = this->UserZLabelRange[1];
       break;
     }
 
@@ -1943,8 +1985,25 @@
     }
 
   labels->SetNumberOfValues(labelCount);
-  val = majorStart;
-
+  
+  // Recalculate start value and delta if user specified ranges for labels
+  if(this->UseAxisRangeForXLabels||
+     this->UseAxisRangeForYLabels||
+     this->UseAxisRangeForZLabels)
+    {
+    double minorDeltaFromUserSpecifiedRange = 0;
+    double minorStartValueFromUserSpecifiedRange = 0;
+    ComputeLabelValuesForSpecifiedRange(userRange,
+                                        userSpecifiedStartValue,
+                                        userSpecifiedDelta,
+                                        minorStartValueFromUserSpecifiedRange,
+                                        minorDeltaFromUserSpecifiedRange);   
+    }
+  else
+    {  
+    userSpecifiedDelta = deltaMajor;     
+    }
+  val = userSpecifiedStartValue;
   double scaleFactor = 1.;
   if (lastPow != 0)
     {
@@ -1953,7 +2012,7 @@
 
   for (i = 0; i < labelCount; i++)
     {
-    if (fabs(val) < 0.01 && extents > 1)
+    if (fabs(val) < 0.01 && userExtents > 1)
       {
       // We just happened to fall at something near zero and the range is
       // large, so set it to zero to avoid ugliness.
@@ -1999,7 +2058,7 @@
         }
       }
     labels->SetValue(i, label);
-    val += deltaMajor;
+    val += userSpecifiedDelta;//deltaMajor;
     }
   for (i = 0; i < 4; i++)
     {
@@ -2025,3 +2084,108 @@
     this->Modified();
     } 
 } 
+// ************************************************************************
+// Set the label range for vtkAxisActor for the X Axis
+// ************************************************************************
+void vtkCubeAxesActor::SetXAxisLabelRange(double minValue, double maxValue)
+{
+  this->UserXLabelRange[0] = minValue;
+  this->UserXLabelRange[1] = maxValue; 
+  this->UseAxisRangeForXLabels = 1;
+  this->Modified();
+}
+// ************************************************************************
+// Set the label range for vtkAxisActor for the X Axis
+// ************************************************************************
+void vtkCubeAxesActor::SetYAxisLabelRange(double minValue, double maxValue)
+{
+  this->UserYLabelRange[0] = minValue;
+  this->UserYLabelRange[1] = maxValue; 
+  this->UseAxisRangeForYLabels = 1;
+  this->Modified();
+}
+// ************************************************************************
+// Set the label range for vtkAxisActor for the X Axis
+// ************************************************************************
+void vtkCubeAxesActor::SetZAxisLabelRange(double minValue, double maxValue)
+{
+  this->UserZLabelRange[0] = minValue;
+  this->UserZLabelRange[1] = maxValue; 
+  this->UseAxisRangeForZLabels = 1;
+  this->Modified();
+}
+// *******************************************************************
+// Compute starting value and delta for user specified range
+// *******************************************************************
+void vtkCubeAxesActor::ComputeLabelValuesForSpecifiedRange(double inRange[2],
+                                                           double& majorStartValue,
+                                                           double& majorDelta,
+                                                           double& minorStartValue,
+                                                           double& minorDelta) 
+{
+  double sortedRange[2], range;
+  double fxt, fnt, frac;
+  double div;
+  int numTicks;
+  
+  sortedRange[0] = (double)(inRange[0] < inRange[1] ? inRange[0] : inRange[1]);
+  sortedRange[1] = (double)(inRange[0] > inRange[1] ? inRange[0] : inRange[1]);
+  
+  range = sortedRange[1] - sortedRange[0];
+  
+  // Find the integral points.
+  double pow10 = log10(range);
+  
+  // Build in numerical tolerance
+  if (pow10 != 0.)
+    {
+      double eps = 10.0e-10;
+      pow10 = this->FSign((fabs(pow10) + eps), pow10);
+    }
+  
+  // FFix move you in the wrong direction if pow10 is negative.
+  if (pow10 < 0.)
+    {
+      pow10 = pow10 - 1.;
+    }
+  
+  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 ? (int)this->FFix(fnt) : ((int)this->FFix(fnt) + 1));
+  
+  div = 1.;
+  if (numTicks < 5)
+    {
+      div = 2.;
+    }
+  if (numTicks <= 2)
+    {
+      div = 5.;
+    }
+  
+  // If there aren't enough major tick points in this decade, use the next
+  // decade.
+  majorDelta = fxt;
+  if (div != 1.)
+    {
+      majorDelta /= div;
+    }
+  minorDelta = (fxt/div) / 10.;
+  
+  // Figure out the first major and minor tick locations, relative to the
+  // start of the axis.
+  if (sortedRange[0] <= 0.)
+    {
+      majorStartValue = majorDelta*(this->FFix(sortedRange[0]*(1./majorDelta)) + 0.);
+      minorStartValue = minorDelta*(this->FFix(sortedRange[0]*(1./minorDelta)) + 0.);
+    }
+  else
+    {
+      majorStartValue = majorDelta*(this->FFix(sortedRange[0]*(1./majorDelta)) + 1.);
+      minorStartValue = minorDelta*(this->FFix(sortedRange[0]*(1./minorDelta)) + 1.);
+    }
+}