Changeset 3230 for branches

Timestamp:

Jan 3, 2013, 1:32:43 PM (12 years ago)

Author:

ldelgass

Message:

Add commands to set axes ranges explicitly or by scaling the world coordinate
bounds by a fixed factor (ranges can also be set to be computed automatically
based on actor bounds and scaling -- this is the default). Also add command
to set axes origin (in world coordinates within the bounds).

Location:

branches/Rappture 1.2/packages/vizservers/vtkvis

Files:

• RpVtkRenderer.cpp (modified) (25 diffs)
• RpVtkRenderer.h (modified) (8 diffs)
• RpVtkRendererCmd.cpp (modified) (4 diffs)
• protocol.txt (modified) (4 diffs)

branches/Rappture 1.2/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -26 +26 @@
 #ifdef USE_CUSTOM_AXES
 #include "vtkRpCubeAxesActor.h"
-#include "vtkRpCubeAxesActor2D.h"
 #else
 #include <vtkCubeAxesActor.h>
-#include <vtkCubeAxesActor2D.h>
 #endif
 #include <vtkDataSetReader.h>
@@ -423 +421 @@
 {
     TRACE("Resetting axes");
-    if (_cubeAxesActor == NULL
-#ifndef USE_VTK6
-        || _cubeAxesActor2D == NULL
-#endif
-       ) {
+
+    if (_cubeAxesActor == NULL) {
         initAxes();
     }
+
     if (_cameraMode == IMAGE) {
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetUse2DMode(1);
-#else
-        if (_renderer->HasViewProp(_cubeAxesActor)) {
-            TRACE("Removing 3D axes");
-            _renderer->RemoveViewProp(_cubeAxesActor);
-        }
-        if (!_renderer->HasViewProp(_cubeAxesActor2D)) {
-            TRACE("Adding 2D axes");
-            _renderer->AddViewProp(_cubeAxesActor2D);
-        }
-#endif
     } else {
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetUse2DMode(0);
-#else
-        if (_renderer->HasViewProp(_cubeAxesActor2D)) {
-            TRACE("Removing 2D axes");
-            _renderer->RemoveViewProp(_cubeAxesActor2D);
-        }
-        if (!_renderer->HasViewProp(_cubeAxesActor)) {
-            TRACE("Adding 3D axes");
-            _renderer->AddViewProp(_cubeAxesActor);
-        }
-#endif
     }
 
@@ -461 +435 @@
         return;
     }
-
-    double unscaledBounds[6];
-    collectUnscaledBounds(unscaledBounds, false);
 
     if (bounds == NULL) {
@@ -469 +440 @@
         collectBounds(newBounds, false);
 
-        double sx = (newBounds[1] == newBounds[0]) ? 1.0 : (unscaledBounds[1] - unscaledBounds[0]) / (newBounds[1] - newBounds[0]);
-        double sy = (newBounds[3] == newBounds[2]) ? 1.0 : (unscaledBounds[3] - unscaledBounds[2]) / (newBounds[3] - newBounds[2]);
-        double sz = (newBounds[5] == newBounds[4]) ? 1.0 : (unscaledBounds[5] - unscaledBounds[4]) / (newBounds[5] - newBounds[4]);
-
-        setAxisBounds(newBounds);
-        setAxisScale(sx, sy, sz);
+        setAxesBounds(newBounds);
     } else {
-        double sx = (bounds[1] == bounds[0]) ? 1.0 : (unscaledBounds[1] - unscaledBounds[0]) / (bounds[1] - bounds[0]);
-        double sy = (bounds[3] == bounds[2]) ? 1.0 : (unscaledBounds[3] - unscaledBounds[2]) / (bounds[3] - bounds[2]);
-        double sz = (bounds[5] == bounds[4]) ? 1.0 : (unscaledBounds[5] - unscaledBounds[4]) / (bounds[5] - bounds[4]);
-
-        setAxisBounds(bounds);
-        setAxisScale(sx, sy, sz);
-    }
+        setAxesBounds(bounds);
+    }
+
+    setAxesRanges();
 }
 
@@ -491 +454 @@
  * the axes are drawn
  */
-void Renderer::setAxisBounds(double bounds[6])
+void Renderer::setAxesBounds(double bounds[6])
 {
     _cubeAxesActor->SetBounds(bounds);
+
     TRACE("Axis bounds: %g %g %g %g %g %g",
               bounds[0],
@@ -501 +465 @@
               bounds[4],
               bounds[5]);
-}
-
-/**
- * \brief Set scaling factors to convert world coordinates to axis 
- * label values in X, Y, Z
- */
-void Renderer::setAxisScale(double sx, double sy, double sz)
-{
+
+    _needsRedraw = true;
+}
+
+void Renderer::setAxesAutoRange(bool state)
+{
+    _axesRangeMode[X_AXIS] = state ? RANGE_AUTO : RANGE_EXPLICIT;
+    _axesRangeMode[Y_AXIS] = state ? RANGE_AUTO : RANGE_EXPLICIT;
+    _axesRangeMode[Z_AXIS] = state ? RANGE_AUTO : RANGE_EXPLICIT;
+
+    TRACE("Set axes range to %s", (state ? "auto" : "explicit"));
+
+    setAxesRanges();
+
+    _needsRedraw = true;
+}
+
+void Renderer::setAxisAutoRange(Axis axis, bool state)
+{
+    _axesRangeMode[axis] = state ? RANGE_AUTO : RANGE_EXPLICIT;
+
+    TRACE("Set axis %d range to %s", axis, (state ? "auto" : "explicit"));
+
+    setAxesRanges();
+
+    _needsRedraw = true;
+}
+
+void Renderer::setAxesRange(double min, double max)
+{
+    setAxisRange(X_AXIS, min, max);
+    setAxisRange(Y_AXIS, min, max);
+    setAxisRange(Z_AXIS, min, max);
+}
+
+void Renderer::setAxisRange(Axis axis, double min, double max)
+{
+    switch (axis) {
+    case X_AXIS:
+        _axesRangeMode[X_AXIS] = RANGE_EXPLICIT;
+        _cubeAxesActor->SetXAxisRange(min, max);
+        break;
+    case Y_AXIS:
+        _axesRangeMode[Y_AXIS] = RANGE_EXPLICIT;
+        _cubeAxesActor->SetYAxisRange(min, max);
+        break;
+    case Z_AXIS:
+        _axesRangeMode[Z_AXIS] = RANGE_EXPLICIT;
+        _cubeAxesActor->SetZAxisRange(min, max);
+        break;
+    default:
+        break;
+    }
+
+    TRACE("Set axis %d range to: %g, %g", axis, min, max);
+
+     _needsRedraw = true;
+}
+
+void Renderer::setAxesRanges()
+{
+    computeAxesScale();
+
     double bounds[6];
     _cubeAxesActor->GetBounds(bounds);
+
     double ranges[6];
-    ranges[0] = bounds[0] * sx;
-    ranges[1] = bounds[1] * sx;
-    ranges[2] = bounds[2] * sy;
-    ranges[3] = bounds[3] * sy;
-    ranges[4] = bounds[4] * sz;
-    ranges[5] = bounds[5] * sz;
-    _cubeAxesActor->SetXAxisRange(&bounds[0]);
-    _cubeAxesActor->SetYAxisRange(&bounds[2]);
-    _cubeAxesActor->SetZAxisRange(&bounds[4]);
-    TRACE("Setting axis scale to: %g, %g, %g", sx, sy, sz);
+    if (_axesRangeMode[X_AXIS] != RANGE_EXPLICIT) {
+        ranges[0] = bounds[0] * _axesScale[X_AXIS];
+        ranges[1] = bounds[1] * _axesScale[X_AXIS];
+        _cubeAxesActor->SetXAxisRange(&ranges[0]);
+    } else {
+        _cubeAxesActor->GetXAxisRange(&ranges[0]);
+    }
+    if (_axesRangeMode[Y_AXIS] != RANGE_EXPLICIT) {
+        ranges[2] = bounds[2] * _axesScale[Y_AXIS];
+        ranges[3] = bounds[3] * _axesScale[Y_AXIS];
+        _cubeAxesActor->SetYAxisRange(&ranges[2]);
+    } else {
+        _cubeAxesActor->GetYAxisRange(&ranges[2]);
+    }
+
+    if (_axesRangeMode[Z_AXIS] != RANGE_EXPLICIT) {
+        ranges[4] = bounds[4] * _axesScale[Z_AXIS];
+        ranges[5] = bounds[5] * _axesScale[Z_AXIS];
+        _cubeAxesActor->SetZAxisRange(&ranges[4]);
+    } else {
+        _cubeAxesActor->GetZAxisRange(&ranges[4]);
+    }
+
     TRACE("Axis ranges: %g %g %g %g %g %g",
           ranges[0],
@@ -529 +562 @@
           ranges[4],
           ranges[5]);
+
+    _needsRedraw = true;
+}
+
+void Renderer::computeAxesScale()
+{
+    if (_axesRangeMode[X_AXIS] != RANGE_AUTO &&
+        _axesRangeMode[Y_AXIS] != RANGE_AUTO &&
+        _axesRangeMode[Z_AXIS] != RANGE_AUTO)
+        return;
+
+    double bounds[6];
+    if (_cameraMode == IMAGE) {
+        collectBounds(bounds, false);
+    } else
+        _cubeAxesActor->GetBounds(bounds);
+
+    double unscaledBounds[6];
+    collectUnscaledBounds(unscaledBounds, false);
+
+    if (_axesRangeMode[X_AXIS] == RANGE_AUTO) {
+        double sx = (bounds[1] == bounds[0]) ? 1.0 : (unscaledBounds[1] - unscaledBounds[0]) / (bounds[1] - bounds[0]);
+        _axesScale[X_AXIS] = sx;
+        TRACE("Setting X axis scale to: %g", sx);
+    }
+    if (_axesRangeMode[Y_AXIS] == RANGE_AUTO) {
+        double sy = (bounds[3] == bounds[2]) ? 1.0 : (unscaledBounds[3] - unscaledBounds[2]) / (bounds[3] - bounds[2]);
+        _axesScale[Y_AXIS] = sy;
+        TRACE("Setting Y axis scale to: %g", sy);
+    }
+    if (_axesRangeMode[Y_AXIS] == RANGE_AUTO) {
+        double sz = (bounds[5] == bounds[4]) ? 1.0 : (unscaledBounds[5] - unscaledBounds[4]) / (bounds[5] - bounds[4]);
+        _axesScale[Z_AXIS] = sz;
+        TRACE("Setting Z axis scale to: %g", sz);
+    }
+}
+
+/**
+ * \brief Set scaling factor to convert world coordinates to axis 
+ * label values in X, Y, Z
+ */
+void Renderer::setAxesScale(double scale)
+{
+    _axesRangeMode[X_AXIS] = RANGE_SCALE_BOUNDS;
+    _axesRangeMode[Y_AXIS] = RANGE_SCALE_BOUNDS;
+    _axesRangeMode[Z_AXIS] = RANGE_SCALE_BOUNDS;
+
+    _axesScale[X_AXIS] = scale;
+    _axesScale[Y_AXIS] = scale;
+    _axesScale[Z_AXIS] = scale;
+
+    TRACE("Setting axes scale to: %g", scale);
+
+    setAxesRanges();
+}
+
+void Renderer::setAxisScale(Axis axis, double scale)
+{
+    _axesRangeMode[axis] = RANGE_SCALE_BOUNDS;
+    _axesScale[axis] = scale;
+
+    TRACE("Setting axis %d scale to: %g", axis, scale);
+
+    setAxesRanges();
+}
+
+/**
+ * \brief Set an origin point within the axes bounds where the axes will intersect
+ *
+ * \param x X coordinate of origin
+ * \param y Y coordinate of origin
+ * \param z Z coordinate of origin
+ * \param useCustom Flag indicating if custom origin is to be used/enabled
+ */
+void Renderer::setAxesOrigin(double x, double y, double z, bool useCustom)
+{
+    _cubeAxesActor->SetAxisOrigin(x, y, z);
+    _cubeAxesActor->SetUseAxisOrigin((useCustom ? 1 : 0));
+
+    _needsRedraw = true;
 }
 
@@ -549 +662 @@
     _cubeAxesActor->SetCornerOffset(0);
     _cubeAxesActor->SetFlyModeToStaticTriad();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
+
     _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_ALL);
     _cubeAxesActor->SetDrawXInnerGridlines(0);
@@ -568 +681 @@
     // Set font pixel size for 3D
     _cubeAxesActor->SetScreenSize(8.0);
-#endif
+
     _cubeAxesActor->SetBounds(0, 1, 0, 1, 0, 1);
     _cubeAxesActor->SetXAxisRange(0, 1);
     _cubeAxesActor->SetYAxisRange(0, 1);
     _cubeAxesActor->SetZAxisRange(0, 1);
-
-#ifdef USE_CUSTOM_AXES
-    if (_cubeAxesActor2D == NULL)
-        _cubeAxesActor2D = vtkSmartPointer<vtkRpCubeAxesActor2D>::New();
-#elif !defined(USE_VTK6)
-    if (_cubeAxesActor2D == NULL)
-        _cubeAxesActor2D = vtkSmartPointer<vtkCubeAxesActor2D>::New();
-#endif
+    for (int axis = 0; axis < 3; axis++) {
+        _axesAutoBounds[axis] = true;
+        _axesRangeMode[axis] = RANGE_AUTO;
+        _axesScale[axis] = 1.0;
+    }
 
     double axesColor[] = {1,1,1};
     setAxesColor(axesColor);
 
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
     if (!_renderer->HasViewProp(_cubeAxesActor))
         _renderer->AddViewProp(_cubeAxesActor);
@@ -594 +703 @@
         _cubeAxesActor->SetUse2DMode(0);
     }
-#else
-    _cubeAxesActor2D->SetCamera(_renderer->GetActiveCamera());
-    _cubeAxesActor2D->ZAxisVisibilityOff();
-    _cubeAxesActor2D->SetCornerOffset(0);
-    _cubeAxesActor2D->SetFlyModeToClosestTriad();
-
-    _cubeAxesActor2D->ScalingOff();
-    _cubeAxesActor2D->SetShowActualBounds(1);
-    _cubeAxesActor2D->SetFontFactor(1.25);
-    // Use "nice" range and number of ticks/labels
-    _cubeAxesActor2D->GetXAxisActor2D()->AdjustLabelsOn();
-    _cubeAxesActor2D->GetYAxisActor2D()->AdjustLabelsOn();
-    _cubeAxesActor2D->GetZAxisActor2D()->AdjustLabelsOn();
-
-#ifdef USE_CUSTOM_AXES
-    _cubeAxesActor2D->SetAxisTitleTextProperty(NULL);
-    _cubeAxesActor2D->SetAxisLabelTextProperty(NULL);
-    //_cubeAxesActor2D->GetXAxisActor2D()->SizeFontRelativeToAxisOn();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetTitleTextProperty()->BoldOn();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetTitleTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetTitleTextProperty()->ShadowOn();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetLabelTextProperty()->BoldOff();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetLabelTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetXAxisActor2D()->GetLabelTextProperty()->ShadowOff();
-
-    //_cubeAxesActor2D->GetYAxisActor2D()->SizeFontRelativeToAxisOn();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetTitleTextProperty()->BoldOn();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetTitleTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetTitleTextProperty()->ShadowOn();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetLabelTextProperty()->BoldOff();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetLabelTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetYAxisActor2D()->GetLabelTextProperty()->ShadowOff();
-
-    //_cubeAxesActor2D->GetZAxisActor2D()->SizeFontRelativeToAxisOn();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetTitleTextProperty()->BoldOn();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetTitleTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetTitleTextProperty()->ShadowOn();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetLabelTextProperty()->BoldOff();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetLabelTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetZAxisActor2D()->GetLabelTextProperty()->ShadowOff();
-#else
-    _cubeAxesActor2D->GetAxisTitleTextProperty()->BoldOn();
-    _cubeAxesActor2D->GetAxisTitleTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetAxisTitleTextProperty()->ShadowOn();
-    _cubeAxesActor2D->GetAxisLabelTextProperty()->BoldOff();
-    _cubeAxesActor2D->GetAxisLabelTextProperty()->ItalicOff();
-    _cubeAxesActor2D->GetAxisLabelTextProperty()->ShadowOff();
-#endif
-
-    if (_cameraMode == IMAGE) {
-        if (!_renderer->HasViewProp(_cubeAxesActor2D))
-            _renderer->AddViewProp(_cubeAxesActor2D);
-    } else {
-        if (!_renderer->HasViewProp(_cubeAxesActor))
-            _renderer->AddViewProp(_cubeAxesActor);
-    }
-#endif
 }
 
@@ -664 +716 @@
     case FLY_STATIC_EDGES:
         _cubeAxesActor->SetFlyModeToStaticEdges();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_ALL);
-#endif
         break;
     case FLY_STATIC_TRIAD:
         _cubeAxesActor->SetFlyModeToStaticTriad();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_ALL);
-#endif
         break;
     case FLY_OUTER_EDGES:
         _cubeAxesActor->SetFlyModeToOuterEdges();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_ALL);
-#endif
         break;
     case FLY_FURTHEST_TRIAD:
         _cubeAxesActor->SetFlyModeToFurthestTriad();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_FURTHEST);
-#endif
         break;
     case FLY_CLOSEST_TRIAD:
     default:
         _cubeAxesActor->SetFlyModeToClosestTriad();
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         _cubeAxesActor->SetGridLineLocation(VTK_GRID_LINES_CLOSEST);
-#endif
         break;
     }
@@ -704 +746 @@
     if (_cubeAxesActor != NULL) {
         _cubeAxesActor->GetProperty()->SetColor(color);
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
         for (int i = 0; i < 3; i++) {
             _cubeAxesActor->GetTitleTextProperty(i)->SetColor(color);
@@ -713 +754 @@
         _cubeAxesActor->GetXAxesGridlinesProperty()->SetColor(color);
         _cubeAxesActor->GetXAxesInnerGridlinesProperty()->SetColor(color);
+
         _cubeAxesActor->GetYAxesLinesProperty()->SetColor(color);
         _cubeAxesActor->GetYAxesGridlinesProperty()->SetColor(color);
         _cubeAxesActor->GetYAxesInnerGridlinesProperty()->SetColor(color);
+
         _cubeAxesActor->GetZAxesLinesProperty()->SetColor(color);
         _cubeAxesActor->GetZAxesGridlinesProperty()->SetColor(color);
         _cubeAxesActor->GetZAxesInnerGridlinesProperty()->SetColor(color);
-#endif
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        _cubeAxesActor2D->GetProperty()->SetColor(color);
-#ifdef USE_CUSTOM_AXES
-        _cubeAxesActor2D->GetXAxisActor2D()->GetTitleTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetXAxisActor2D()->GetLabelTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetYAxisActor2D()->GetTitleTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetYAxisActor2D()->GetLabelTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetZAxisActor2D()->GetTitleTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetZAxisActor2D()->GetLabelTextProperty()->SetColor(color);
-#else
-        _cubeAxesActor2D->GetAxisTitleTextProperty()->SetColor(color);
-        _cubeAxesActor2D->GetAxisLabelTextProperty()->SetColor(color);
-#endif
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -750 +775 @@
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        _cubeAxesActor2D->SetVisibility((state ? 1 : 0));
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -949 +968 @@
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        if (axis == X_AXIS) {
-            _cubeAxesActor2D->SetXAxisVisibility((state ? 1 : 0));
-        } else if (axis == Y_AXIS) {
-            _cubeAxesActor2D->SetYAxisVisibility((state ? 1 : 0));
-        } else if (axis == Z_AXIS) {
-            _cubeAxesActor2D->SetZAxisVisibility((state ? 1 : 0));
-        }
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -1029 +1036 @@
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        if (axis == X_AXIS) {
-            _cubeAxesActor2D->GetXAxisActor2D()->SetLabelVisibility((state ? 1 : 0));
-        } else if (axis == Y_AXIS) {
-            _cubeAxesActor2D->GetYAxisActor2D()->SetLabelVisibility((state ? 1 : 0));
-        } else if (axis == Z_AXIS) {
-            _cubeAxesActor2D->GetZAxisActor2D()->SetLabelVisibility((state ? 1 : 0));
-        }
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -1058 +1053 @@
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        if (axis == X_AXIS) {
-            _cubeAxesActor2D->GetXAxisActor2D()->SetTickVisibility((state ? 1 : 0));
-        } else if (axis == Y_AXIS) {
-            _cubeAxesActor2D->GetYAxisActor2D()->SetTickVisibility((state ? 1 : 0));
-        } else if (axis == Z_AXIS) {
-            _cubeAxesActor2D->GetZAxisActor2D()->SetTickVisibility((state ? 1 : 0));
-        }
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -1104 +1087 @@
         _needsRedraw = true;
     }
-#if !defined(USE_VTK6) || defined(USE_CUSTOM_AXES)
-    if (_cubeAxesActor2D != NULL) {
-        if (axis == X_AXIS) {
-            _cubeAxesActor2D->SetXLabel(title);
-        } else if (axis == Y_AXIS) {
-            _cubeAxesActor2D->SetYLabel(title);
-        } else if (axis == Z_AXIS) {
-            _cubeAxesActor2D->SetZLabel(title);
-        }
-        _needsRedraw = true;
-    }
-#endif
 }
 
@@ -2071 +2042 @@
 }
 
+/**
+ * \brief Set the camera near/far clipping range based on current scene bounds
+ */
 void Renderer::resetCameraClippingRange()
 {
@@ -2351 +2325 @@
         _cameraClipPlanes[3]->SetOrigin(_imgWorldOrigin[0] + plotWidthWorld, 0, 0);
         _cameraClipPlanes[3]->SetNormal(-1, 0, 0);
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
+
         _cubeAxesActor->SetBounds(_imgWorldOrigin[0], _imgWorldOrigin[0] + plotWidthWorld,
                                   _imgWorldOrigin[1], _imgWorldOrigin[1] + plotHeightWorld,
@@ -2359 +2333 @@
         _cubeAxesActor->YAxisVisibilityOn();
         _cubeAxesActor->ZAxisVisibilityOff();
-#else
-        _cubeAxesActor2D->SetBounds(_imgWorldOrigin[0], _imgWorldOrigin[0] + plotWidthWorld,
-                                    _imgWorldOrigin[1], _imgWorldOrigin[1] + plotHeightWorld,
-                                    _imgCameraOffset, _imgCameraOffset);
-        _cubeAxesActor2D->XAxisVisibilityOn();
-        _cubeAxesActor2D->YAxisVisibilityOn();
-        _cubeAxesActor2D->ZAxisVisibilityOff();
-#endif
     } else if (_imgCameraPlane == PLANE_ZY) {
         // ZY plane
@@ -2384 +2350 @@
         _cameraClipPlanes[3]->SetOrigin(0, 0, _imgWorldOrigin[0] + plotWidthWorld);
         _cameraClipPlanes[3]->SetNormal(0, 0, -1);
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
+
         _cubeAxesActor->SetBounds(_imgCameraOffset, _imgCameraOffset, 
                                   _imgWorldOrigin[1], _imgWorldOrigin[1] + plotHeightWorld,
@@ -2391 +2357 @@
         _cubeAxesActor->YAxisVisibilityOn();
         _cubeAxesActor->ZAxisVisibilityOn();
-#else
-        _cubeAxesActor2D->SetBounds(_imgCameraOffset, _imgCameraOffset, 
-                                    _imgWorldOrigin[1], _imgWorldOrigin[1] + plotHeightWorld,
-                                    _imgWorldOrigin[0], _imgWorldOrigin[0] + plotWidthWorld);
-        _cubeAxesActor2D->XAxisVisibilityOff();
-        _cubeAxesActor2D->YAxisVisibilityOn();
-        _cubeAxesActor2D->ZAxisVisibilityOn();
-#endif
     } else {
         // XZ plane
@@ -2416 +2374 @@
         _cameraClipPlanes[3]->SetOrigin(_imgWorldOrigin[0] + plotWidthWorld, 0, 0);
         _cameraClipPlanes[3]->SetNormal(-1, 0, 0);
-#if defined(USE_VTK6) && !defined(USE_CUSTOM_AXES)
+
         _cubeAxesActor->SetBounds(_imgWorldOrigin[0], _imgWorldOrigin[0] + plotWidthWorld,
                                   _imgCameraOffset, _imgCameraOffset,
@@ -2423 +2381 @@
         _cubeAxesActor->YAxisVisibilityOff();
         _cubeAxesActor->ZAxisVisibilityOn();
-#else
-        _cubeAxesActor2D->SetBounds(_imgWorldOrigin[0], _imgWorldOrigin[0] + plotWidthWorld,
-                                    _imgCameraOffset, _imgCameraOffset,
-                                    _imgWorldOrigin[1], _imgWorldOrigin[1] + plotHeightWorld);
-        _cubeAxesActor2D->XAxisVisibilityOn();
-        _cubeAxesActor2D->YAxisVisibilityOff();
-        _cubeAxesActor2D->ZAxisVisibilityOn();
-#endif
-    }
-
-#if !defined(USE_CUSTOM_AXES)
-    double xmin, xmax, ymin, ymax, zmin, zmax;
-    _cubeAxesActor->GetBounds(xmin, xmax, ymin, ymax, zmin, zmax);
-    _cubeAxesActor->SetXAxisRange(xmin, xmax);
-    _cubeAxesActor->SetYAxisRange(ymin, ymax);
-    _cubeAxesActor->SetZAxisRange(zmin, zmax);
-#endif
+    }
+
+    // Fix up axis ranges based on new bounds
+    setAxesRanges();
 
     // Compute screen world coordinates

branches/Rappture 1.2/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -17 +17 @@
 #ifdef USE_CUSTOM_AXES
 #include "vtkRpCubeAxesActor.h"
-#include "vtkRpCubeAxesActor2D.h"
 #else
 #include <vtkCubeAxesActor.h>
-#include <vtkCubeAxesActor2D.h>
 #endif
 #include <vtkScalarBarActor.h>
@@ -70 +68 @@
     virtual ~Renderer();
 
+    enum AxisRangeMode {
+        RANGE_AUTO = 0,
+        RANGE_SCALE_BOUNDS,
+        RANGE_EXPLICIT
+    };
+
     enum AxesFlyMode {
         FLY_OUTER_EDGES = 0,
@@ -167 +171 @@
     void setViewAngle(int height);
 
+    /// Return the VTK camera object this Renderer uses
     vtkCamera *getVtkCamera()
     {
@@ -225 +230 @@
     // Axes
 
+    void setAxesOrigin(double x, double y, double z, bool useCustom = true);
+
+    void setAxesBounds(double bounds[6]);
+
+    void setAxesAutoRange(bool state);
+
+    void setAxesScale(double scale);
+
+    void setAxesRange(double min, double max);
+
+    void setAxisAutoRange(Axis axis, bool state);
+
+    void setAxisScale(Axis axis, double scale);
+
+    void setAxisRange(Axis axis, double min, double max);
+
     void setAxesFlyMode(AxesFlyMode mode);
 
@@ -294 +315 @@
 
     void setAxisLabelFormat(Axis axis, const char *format);
-
-    void setAxisBounds(double bounds[6]);
-
-    void setAxisScale(double sx, double sy, double sz);
 
     // Colormaps
@@ -777 +794 @@
               double *offset) const;
     void initCamera(bool initCameraMode = false);
+
     void initAxes();
     void resetAxes(double bounds[6] = NULL);
+    void setAxesRanges();
+    void computeAxesScale();
+
     void setCameraClippingPlanes();
 
@@ -802 +823 @@
     FieldRangeHashmap _vectorCellDataRange;
     FieldRangeHashmap _vectorCompCellDataRange[3];
+
+    bool _axesAutoBounds[3];
+    AxisRangeMode _axesRangeMode[3];
+    double _axesScale[3];
 
     ColorMapHashmap _colorMaps;
@@ -832 +857 @@
     vtkSmartPointer<vtkPlaneCollection> _activeClipPlanes;
 #ifdef USE_CUSTOM_AXES
-    vtkSmartPointer<vtkRpCubeAxesActor> _cubeAxesActor; // For 3D view
-    vtkSmartPointer<vtkRpCubeAxesActor2D> _cubeAxesActor2D; // For 2D view
+    vtkSmartPointer<vtkRpCubeAxesActor> _cubeAxesActor;
 #else
-    vtkSmartPointer<vtkCubeAxesActor> _cubeAxesActor; // For 3D view
-#ifndef USE_VTK6
-    vtkSmartPointer<vtkCubeAxesActor2D> _cubeAxesActor2D; // For 2D view
-#endif
+    vtkSmartPointer<vtkCubeAxesActor> _cubeAxesActor;
 #endif
     vtkSmartPointer<vtkScalarBarActor> _scalarBarActor;

branches/Rappture 1.2/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -635 +635 @@
 
 static int
+AxisAutoRangeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    bool enableAuto;
+    if (GetBooleanFromObj(interp, objv[3], &enableAuto) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        g_renderer->setAxisAutoRange(X_AXIS, enableAuto);
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        g_renderer->setAxisAutoRange(Y_AXIS, enableAuto);
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        g_renderer->setAxisAutoRange(Z_AXIS, enableAuto);
+    } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
+        g_renderer->setAxesAutoRange(enableAuto);
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
 AxisColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
             Tcl_Obj *const *objv)
@@ -936 +962 @@
 
 static int
+AxisOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double x, y, z;
+    bool useCustom = true;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &x) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &y) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &z) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc > 5) {
+        if (GetBooleanFromObj(interp, objv[5], &useCustom) != TCL_OK) {
+            return TCL_ERROR;
+        }
+        g_renderer->setAxesOrigin(x, y, z, useCustom);
+    } else {
+        g_renderer->setAxesOrigin(x, y, z);
+    }
+    return TCL_OK;
+}
+
+static int
+AxisRangeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    double min, max;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &min) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &max) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        g_renderer->setAxisRange(X_AXIS, min, max);
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        g_renderer->setAxisRange(Y_AXIS, min, max);
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        g_renderer->setAxisRange(Z_AXIS, min, max);
+    } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
+        g_renderer->setAxesRange(min, max);
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
+AxisScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    double scale;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &scale) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        g_renderer->setAxisScale(X_AXIS, scale);
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        g_renderer->setAxisScale(Y_AXIS, scale);
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        g_renderer->setAxisScale(Z_AXIS, scale);
+    } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
+        g_renderer->setAxesScale(scale);
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
 AxisTicksVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                    Tcl_Obj *const *objv)
@@ -1141 +1242 @@
 
 static Rappture::CmdSpec axisOps[] = {
+    {"autorange",1, AxisAutoRangeOp, 4, 4, "axis bool"},
     {"color",    1, AxisColorOp, 5, 5, "r g b"},
     {"flymode",  2, AxisFlyModeOp, 3, 3, "mode"},
@@ -1155 +1257 @@
     {"minticks", 1, AxisMinorTicksVisibleOp, 4, 4, "axis bool"},
     {"name",     1, AxisNameOp, 4, 4, "axis title"},
+    {"origin",   1, AxisOriginOp, 5, 6, "x y z ?useCustom?"},
+    {"range",    1, AxisRangeOp, 5, 5, "axis min max"},
+    {"scale",    1, AxisScaleOp, 4, 4, "axis scale"},
     {"tfont",    3, AxisTitleFontOp, 4, 4, "axis font"},
     {"tfsize",   3, AxisTitleFontSizeOp, 4, 4, "axis fontSize"},

branches/Rappture 1.2/packages/vizservers/vtkvis/protocol.txt

@@ -42 +42 @@
          Force a new image to be rendered - use for advancing animation
 
+axis autorange <axis> <bool>
+     Toggle between automatic and explicit range settings.  To set an explicit
+     range use the 'axis range...' command.  For scaling based on axis bounds,
+     see 'axis scale...'
+     <axis> = x|y|z|all
 axis color <r> <g> <b>
      Set color of axis lines, labels, titles, ticks
@@ -68 +73 @@
      <formatString> = printf style format string
 axis lfsize <axis> <fontSizePts>
-     Set font size of labels in 2D mode - currently relies on patched VTK in runtime
+     Set font size of labels in 2D mode - currently relies on patched VTK in 
+     runtime
      <axis> = x|y|z|all
      <fontSizePts> = Font size in points
@@ -87 +93 @@
      <axis> = x|y|z|all
      <title> = Title of axis
+axis origin <x> <y> <z> <?useCustom?>
+     <x>,<y>,<z> = point inside world coordinate bounds of axes box where axes 
+     should intersect
+     <useCustom> = Set to false to disable use of custom origin and re-enable 
+     automatic origin
+axis range <axis> <min> <max>
+     Explicitly set min,max range of axis labels.  Note that the min and max 
+     values themselves may not be given labels if they don't fall on tick 
+     divisions -- the min/max determine the value of the axis endpoints.  This
+     setting allows labeling axes independently of the world coordinate bounds.
+     <axis> = x|y|z|all
+     <min> = minimum value of axis for labels
+     <max> = maximum value of axis for labels
+axis scale <axis> <scale>
+     Set axis range to be computed based on scaling the axis bounds by the
+     given scale factor.
+     <axis> = x|y|z|all
+     <scale> = scale factor where range = bounds * scale
 axis tickpos <position>
      Set position of ticks on 3D axes (not implemented for 2D axes)
@@ -98 +122 @@
      <fontName> = Arial|Courier|Times
 axis tfsize <axis> <fontSizePts>
-     Set font size of title in 2D mode - currently relies on patched VTK in runtime
+     Set font size of title in 2D mode - currently relies on patched VTK in 
+     runtime
      <axis> = x|y|z|all
      <fontSizePts> = Font size in points