Changeset 2194 for trunk/packages/vizservers/vtkvis

Timestamp:

Apr 1, 2011 12:28:21 AM (13 years ago)

Author:

ldelgass

Message:

Fix pan/zoom for VTK contours, add command to control data range mapping for
multiple datasets. Still need to fix 3D panning, allow absolute rotation/
orientation of the camera.

Location:

trunk/packages/vizservers/vtkvis

Files:

• ColorMap.cpp (modified) (7 diffs)
• ColorMap.h (modified) (2 diffs)
• RpContour2D.cpp (modified) (7 diffs)
• RpContour2D.h (modified) (3 diffs)
• RpPseudoColor.cpp (modified) (1 diff)
• RpVtkDataSet.cpp (modified) (3 diffs)
• RpVtkDataSet.h (modified) (3 diffs)
• RpVtkRenderServer.cpp (modified) (3 diffs)
• RpVtkRenderer.cpp (modified) (27 diffs)
• RpVtkRenderer.h (modified) (4 diffs)
• RpVtkRendererCmd.cpp (modified) (2 diffs)
• protocol.txt (modified) (3 diffs)

trunk/packages/vizservers/vtkvis/ColorMap.cpp

@@ -27 +27 @@
 }
 
+/**
+ * \brief Return the name/ID of the ColorMap
+ */
 const std::string& ColorMap::getName()
 {
@@ -32 +35 @@
 }
 
+/**
+ * \brief Build and return the vtkLookupTable from the transfer function
+ */
 vtkLookupTable *ColorMap::getLookupTable()
 {
@@ -39 +45 @@
 }
 
+/**
+ * \brief Insert a new RGB control point into the transfer function
+ */
 void ColorMap::addControlPoint(ControlPoint& cp)
 {
@@ -65 +74 @@
 }
 
+/**
+ * \brief Insert a new opacity/alpha control point into the transfer function
+ */
 void ColorMap::addOpacityControlPoint(OpacityControlPoint& cp)
 {
@@ -109 +121 @@
 }
 
+/**
+ * \brief Build the lookup table from the control points in the transfer 
+ * function
+ */
 void ColorMap::build()
 {
@@ -193 +209 @@
 }
 
+/**
+ * \brief Remove all control points and lookup table
+ */
 void ColorMap::clear()
 {
@@ -200 +219 @@
 }
 
+/**
+ * \brief Create a default ColorMap with a blue-cyan-green-yellow-red ramp
+ */
 ColorMap * ColorMap::createDefault()
 {

trunk/packages/vizservers/vtkvis/ColorMap.h

@@ -27 +27 @@
 public:
     /**
-     * \brief RGBA inflection point in a transfer function
+     * \brief RGB inflection point in a transfer function
      */
     struct ControlPoint {
@@ -52 +52 @@
         double color[3]; ///< RGB color
     };
+
+    /**
+     * \brief Opacity(alpha) inflection point in a transfer function
+     */
     struct OpacityControlPoint {
         OpacityControlPoint() :

trunk/packages/vizservers/vtkvis/RpContour2D.cpp

@@ -21 +21 @@
     _opacity(1.0)
 {
+    _dataRange[0] = 0;
+    _dataRange[1] = 1;
     _edgeColor[0] = 0;
     _edgeColor[1] = 0;
@@ -43 +45 @@
     if (_dataSet != dataSet) {
         _dataSet = dataSet;
+
+        if (_dataSet != NULL) {
+            double dataRange[2];
+            _dataSet->getDataRange(dataRange);
+            _dataRange[0] = dataRange[0];
+            _dataRange[1] = dataRange[1];
+        }
+
         update();
     }
@@ -90 +100 @@
 
     // Contour filter to generate isolines
-    vtkSmartPointer<vtkContourFilter> contourFilter = vtkSmartPointer<vtkContourFilter>::New();
-    contourFilter->SetInput(_dataSet->getVtkDataSet());
-
-    contourFilter->ComputeNormalsOff();
-    contourFilter->ComputeGradientsOff();
+    if (_contourFilter == NULL) {
+        _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
+    }
+
+    _contourFilter->SetInput(_dataSet->getVtkDataSet());
+
+    _contourFilter->ComputeNormalsOff();
+    _contourFilter->ComputeGradientsOff();
 
     // Speed up multiple contour computation at cost of extra memory use
     if (_numContours > 1) {
-        contourFilter->UseScalarTreeOn();
+        _contourFilter->UseScalarTreeOn();
     } else {
-        contourFilter->UseScalarTreeOff();
-    }
+        _contourFilter->UseScalarTreeOff();
+    }
+
+    _contourFilter->SetNumberOfContours(_numContours);
+
     if (_contours.empty()) {
         // Evenly spaced isovalues
-        double dataRange[2];
-        _dataSet->getDataRange(dataRange);
-        contourFilter->GenerateValues(_numContours, dataRange[0], dataRange[1]);
+        _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
     } else {
         // User-supplied isovalues
-        for (int i = 0; i < (int)_contours.size(); i++) {
-            contourFilter->SetValue(i, _contours[i]);
+        for (int i = 0; i < _numContours; i++) {
+            _contourFilter->SetValue(i, _contours[i]);
         }
     }
@@ -117 +131 @@
         _contourMapper->SetResolveCoincidentTopologyToPolygonOffset();
         _contourActor->SetMapper(_contourMapper);
-    }
-
-    _contourMapper->SetInput(contourFilter->GetOutput());
+        _contourMapper->SetInput(_contourFilter->GetOutput());
+    }
 }
 
@@ -132 +145 @@
     _numContours = numContours;
 
+    if (_dataSet != NULL) {
+        double dataRange[2];
+        _dataSet->getDataRange(dataRange);
+        _dataRange[0] = dataRange[0];
+        _dataRange[1] = dataRange[1];
+    }
+
     update();
 }
 
 /**
+ * \brief Specify number of evenly spaced contour lines to render
+ * between the given range (including range endpoints)
+ *
+ * Will override any existing contours
+ */
+void Contour2D::setContours(int numContours, double range[2])
+{
+    _contours.clear();
+    _numContours = numContours;
+
+    _dataRange[0] = range[0];
+    _dataRange[1] = range[1];
+
+    update();
+}
+
+/**
  * \brief Specify an explicit list of contour isovalues
  *
@@ -143 +180 @@
 {
     _contours = contours;
-    _numContours = _contours.size();
+    _numContours = (int)_contours.size();
 
     update();
+}
+
+/**
+ * \brief Get the number of contours
+ */
+int Contour2D::getNumContours() const
+{
+    return _numContours;
+}
+
+/**
+ * \brief Get the contour list (may be empty if number of contours
+ * was specified in place of a list)
+ */
+const std::vector<double>& Contour2D::getContourList() const
+{
+    return _contours;
 }
 
@@ -163 +217 @@
  * \return Is contour set visible?
  */
-bool Contour2D::getVisibility()
+bool Contour2D::getVisibility() const
 {
     if (_contourActor == NULL) {

trunk/packages/vizservers/vtkvis/RpContour2D.h

@@ -10 +10 @@
 
 #include <vtkSmartPointer.h>
+#include <vtkContourFilter.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
@@ -37 +38 @@
     void setContours(int numContours);
 
+    void setContours(int numContours, double range[2]);
+
     void setContourList(const std::vector<double>& contours);
+
+    int getNumContours() const;
+
+    const std::vector<double>& getContourList() const;
 
     void setVisibility(bool state);
 
-    bool getVisibility();
+    bool getVisibility() const;
 
     void setOpacity(double opacity);
@@ -61 +68 @@
     int _numContours;
     std::vector<double> _contours;
+    double _dataRange[2];
 
     float _edgeColor[3];
     float _edgeWidth;
     double _opacity;
+    vtkSmartPointer<vtkContourFilter> _contourFilter;
     vtkSmartPointer<vtkPolyDataMapper> _contourMapper;
     vtkSmartPointer<vtkActor> _contourActor;

trunk/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -144 +144 @@
     }
 
-    double dataRange[2];
-    if (_dataSet != NULL) {
-        _dataSet->getDataRange(dataRange);
-        _lut->SetRange(dataRange);
-#ifdef notdef
-        if (_dataSet->getVtkDataSet()->GetPointData() &&
-            _dataSet->getVtkDataSet()->GetPointData()->GetScalars() &&
-            _dataSet->getVtkDataSet()->GetPointData()->GetScalars()->GetLookupTable()) {
-            TRACE("Change scalar table: %p %p\n", 
-                  _dataSet->getVtkDataSet()->GetPointData()->GetScalars()->GetLookupTable(),
-                  _lut.GetPointer());
-            _dataSet->getVtkDataSet()->GetPointData()->GetScalars()->SetLookupTable(_lut);
-            TRACE("Scalar Table: %p\n", _dataSet->getVtkDataSet()->GetPointData()->GetScalars()->GetLookupTable());
-        }
-#endif
-    }
     if (_dsMapper != NULL) {
         _dsMapper->UseLookupTableScalarRangeOn();

trunk/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -18 +18 @@
 using namespace Rappture::VtkVis;
 
-DataSet::DataSet(const std::string& name)
+DataSet::DataSet(const std::string& name) :
+    _name(name),
+    _visible(true)
 {
     _name = name;
-    _dataRange[0] = 0.0;
-    _dataRange[1] = 1.0;
+    _dataRange[0] = 0;
+    _dataRange[1] = 1;
+    for (int i = 0; i < 6; i++) {
+        _bounds[i] = 0;
+    }
 }
 
 DataSet::~DataSet()
 {
+}
+
+/**
+ * \brief Set visibility flag in DataSet
+ *
+ * This method is used for record-keeping.  The renderer controls
+ * the visibility of related graphics objects.
+ */
+void DataSet::setVisibility(bool state)
+{
+    _visible = state;
+}
+
+/**
+ * \brief Get visibility flag in DataSet
+ *
+ * This method is used for record-keeping.  The renderer controls
+ * the visibility of related graphics objects.
+ */
+bool DataSet::getVisibility() const
+{
+    return _visible;
 }
 
@@ -76 +103 @@
     _dataSet->Update();
     _dataSet->GetScalarRange(_dataRange);
+    _dataSet->GetBounds(_bounds);
 
     TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
@@ -82 +110 @@
 
 /**
+ * \brief Does DataSet lie in the XY plane (z = 0)
+ */
+bool DataSet::is2D() const
+{
+    return (_bounds[4] == 0. && _bounds[4] == _bounds[5]);
+}
+
+/**
  * \brief Get the name/id of this dataset
  */
-const std::string& DataSet::getName()
+const std::string& DataSet::getName() const
 {
     return _name;

trunk/packages/vizservers/vtkvis/RpVtkDataSet.h

@@ -35 +35 @@
     bool setDataFile(const char *filename);
 
-    const std::string& getName();
+    bool is2D() const;
+
+    const std::string& getName() const;
 
     vtkDataSet *getVtkDataSet();
@@ -43 +45 @@
     double getDataValue(double x, double y, double z);
 
+    void setVisibility(bool state);
+
+    bool getVisibility() const;
+
 private:
     DataSet();
@@ -49 +55 @@
     vtkSmartPointer<vtkDataSet> _dataSet;
     double _dataRange[2];
+    double _bounds[6];
+    bool _visible;
 };
 

trunk/packages/vizservers/vtkvis/RpVtkRenderServer.cpp

@@ -9 +9 @@
 #include <cstring>
 #include <cstdlib>
+#include <string>
+#include <sstream>
 #include <unistd.h>
 #include <signal.h>
@@ -32 +34 @@
 {
 #ifdef DEBUG
+    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
+        double xywh[4];
+        g_renderer->getScreenWorldCoords(xywh);
+        TRACE("Image bbox: %g %g %g %g", 
+              xywh[0], 
+              (xywh[1] + xywh[3]), 
+              (xywh[0] + xywh[2]), 
+              xywh[1]);
+    }
+
     writeTGAFile("/tmp/frame.tga",
                  imgData->GetPointer(0),
@@ -37 +49 @@
                  g_renderer->getWindowHeight());
 #else
-    writePPM(fd, "nv>image -type image -bytes",
-             imgData->GetPointer(0),
-             g_renderer->getWindowWidth(),
-             g_renderer->getWindowHeight());
+    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
+        double xywh[4];
+        g_renderer->getScreenWorldCoords(xywh);
+        std::ostringstream oss;
+        oss.precision(12);
+        // Send upper left and lower right corners as bbox
+        oss << "nv>image -type image -bbox {"
+            << std::scientific
+            << xywh[0] << " "
+            << (xywh[1] + xywh[3]) << " "
+            << (xywh[0] + xywh[2]) << " "
+            << xywh[1] << "} -bytes";
+
+        writePPM(fd, oss.str().c_str(),
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight());
+    } else {
+        writePPM(fd, "nv>image -type image -bytes",
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight());
+    }
 #endif
 }

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -7 +7 @@
 
 #include <cfloat>
+#include <cstring>
+#include <cassert>
 
 #include <vtkCamera.h>
@@ -39 +41 @@
     _windowWidth(320),
     _windowHeight(320),
-    _useCumulativeRanges(true)
+    _cameraZoomRatio(1),
+    _useCumulativeRange(true),
+    _cumulativeRangeOnlyVisible(false)
 {
     _bgColor[0] = 0;
     _bgColor[1] = 0;
     _bgColor[2] = 0;
+    _cameraPan[0] = 0;
+    _cameraPan[1] = 0;
     _cumulativeDataRange[0] = 0.0;
     _cumulativeDataRange[1] = 1.0;
@@ -268 +274 @@
         TRACE("After deleting graphics objects");
 
-        // Update cumulative data range
-        collectDataRanges(_cumulativeDataRange);
-
         delete itr->second;
         _dataSets.erase(itr);
     } while (doAll && ++itr != _dataSets.end());
+
+    // Update cumulative data range
+    collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+    updateRanges(_useCumulativeRange);
 
     _needsRedraw = true;
@@ -301 +308 @@
     if (ds) {
         bool ret = ds->setDataFile(filename);
-        collectDataRanges(_cumulativeDataRange);
-        updateRanges(_useCumulativeRanges);
+        collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+        updateRanges(_useCumulativeRange);
         _needsRedraw = true;
         return ret;
@@ -317 +324 @@
     if (ds) {
         bool ret = ds->setData(data, nbytes);
-        collectDataRanges(_cumulativeDataRange);
-        updateRanges(_useCumulativeRanges);
+        collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+        updateRanges(_useCumulativeRange);
         _needsRedraw = true;
         return ret;
     } else
         return false;
+}
+
+/**
+ * \brief Control whether the cumulative data range of datasets is used for 
+ * colormapping and contours
+ */
+void Renderer::setUseCumulativeDataRange(bool state, bool onlyVisible)
+{
+    if (state != _useCumulativeRange) {
+        _useCumulativeRange = state;
+        _cumulativeRangeOnlyVisible = onlyVisible;
+        collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+        updateRanges(_useCumulativeRange);
+        _needsRedraw = true;
+    }
 }
 
@@ -384 +406 @@
     _cubeAxesActor2D->ScalingOff();
     //_cubeAxesActor2D->SetShowActualBounds(0);
-    _cubeAxesActor2D->SetFontFactor(2);
+    _cubeAxesActor2D->SetFontFactor(1.25);
     // Use "nice" range and number of ticks/labels
     _cubeAxesActor2D->GetXAxisActor2D()->AdjustLabelsOn();
@@ -744 +766 @@
         pc->setDataSet(ds);
 
+        // Use the default color map
+        vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
+        ColorMap *cmap = getColorMap("default");
+        lut->DeepCopy(cmap->getLookupTable());
+        if (_useCumulativeRange) {
+            lut->SetRange(_cumulativeDataRange);
+        } else {
+            double range[2];
+            ds->getDataRange(range);
+            lut->SetRange(range);
+        }
+
+        pc->setLookupTable(lut);
+
         _renderer->AddActor(pc->getActor());
     } while (doAll && ++itr != _dataSets.end());
@@ -802 +838 @@
         lut->DeepCopy(cmap->getLookupTable());
 
+        if (_useCumulativeRange) {
+            lut->SetRange(_cumulativeDataRange);
+        } else {
+            if (itr->second->getDataSet() != NULL) {
+                double range[2];
+                itr->second->getDataSet()->getDataRange(range);
+                lut->SetRange(range);
+            }
+        }
+
         itr->second->setLookupTable(lut);
     } while (doAll && ++itr != _pseudoColors.end());
@@ -1068 +1114 @@
 
     do {
-        itr->second->setContours(numContours);
+        if (_useCumulativeRange) {
+            itr->second->setContours(numContours, _cumulativeDataRange);
+        } else {
+            itr->second->setContours(numContours);
+        }
     } while (doAll && ++itr != _contours.end());
 
@@ -1520 +1570 @@
     _windowHeight = height;
     _renderWindow->SetSize(_windowWidth, _windowHeight);
-#ifdef notdef
-    setCameraZoomRegion(_imgWorldOrigin[0], _imgWorldOrigin[1],
-                        _imgWorldDims[0], _imgWorldDims[1]);
-#endif
+    if (_cameraMode == IMAGE) {
+        setCameraZoomRegion(_imgWorldOrigin[0], _imgWorldOrigin[1],
+                            _imgWorldDims[0], _imgWorldDims[1]);
+    }
     _needsRedraw = true;
 }
@@ -1577 +1627 @@
 }
 
+/**
+ * \brief Get the current camera mode
+ */
+Renderer::CameraMode Renderer::getCameraMode() const
+{
+    return _cameraMode;
+}
+
 void Renderer::storeCameraOrientation()
 {
@@ -1614 +1672 @@
         _renderer->ResetCamera();
         _renderer->ResetCameraClippingRange();
-    }
+        computeScreenWorldCoords();
+    }
+    _cameraZoomRatio = 1;
+    _cameraPan[0] = 0;
+    _cameraPan[1] = 0;
     _needsRedraw = true;
 }
@@ -1635 +1697 @@
     _renderer->ResetCameraClippingRange();
     storeCameraOrientation();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Perform a relative 2D translation of the camera
- *
- * \param[in] x World coordinate horizontal panning
- * \param[in] y World coordinate vertical panning
- */
-void Renderer::panCamera(double x, double y)
-{
+    computeScreenWorldCoords();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Perform a 2D translation of the camera
+ *
+ * \param[in] x [0,1] Viewport coordinate horizontal panning
+ * \param[in] y [0,1] Viewport coordinate vertical panning (with origin at top)
+ * \param[in] absolute Control if pan amount is relative to current or absolute
+ */
+void Renderer::panCamera(double x, double y, bool absolute)
+{
+    // Reverse x rather than y, since we are panning the camera, and client
+    // expects to be panning/moving the object
+    x = -x * _screenWorldCoords[2];
+    y = y * _screenWorldCoords[3];
+
+    if (absolute) {
+        double panAbs[2];
+        panAbs[0] = x;
+        panAbs[1] = y;
+        x -= _cameraPan[0];
+        y -= _cameraPan[1];
+        _cameraPan[0] = panAbs[0];
+        _cameraPan[1] = panAbs[1];
+    } else {
+        _cameraPan[0] += x;
+        _cameraPan[1] += y;
+    }
     if (_cameraMode == IMAGE) {
         _imgWorldOrigin[0] += x;
@@ -1651 +1732 @@
         setCameraZoomRegion(_imgWorldOrigin[0], _imgWorldOrigin[1],
                             _imgWorldDims[0], _imgWorldDims[1]);
-        _needsRedraw = true;
-        return;
-    }
-    vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
-    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
-    trans->Translate(x, y, 0);
-    camera->ApplyTransform(trans);
-    _renderer->ResetCameraClippingRange();
-    storeCameraOrientation();
+    } else {
+        vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
+        vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+        trans->Translate(x, y, 0);
+        camera->ApplyTransform(trans);
+        _renderer->ResetCameraClippingRange();
+        storeCameraOrientation();
+        computeScreenWorldCoords();
+    }
     _needsRedraw = true;
 }
@@ -1667 +1748 @@
  *
  * \param[in] z Ratio to change zoom (greater than 1 is zoom in, less than 1 is zoom out)
- */
-void Renderer::zoomCamera(double z)
-{
+ * \param[in] absolute Control if zoom factor is relative to current setting or absolute
+ */
+void Renderer::zoomCamera(double z, bool absolute)
+{
+    if (absolute) {
+        assert(_cameraZoomRatio > 0.0);
+        double zAbs = z;
+        z *= 1.0/_cameraZoomRatio;
+        _cameraZoomRatio = zAbs;
+    } else {
+        _cameraZoomRatio *= z;
+    }
     if (_cameraMode == IMAGE) {
         double dx = _imgWorldDims[0];
@@ -1681 +1771 @@
         setCameraZoomRegion(_imgWorldOrigin[0], _imgWorldOrigin[1],
                             _imgWorldDims[0], _imgWorldDims[1]);
-        _needsRedraw = true;
-        return;
-    }
-    vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
-    camera->Zoom(z); // Change perspective FOV angle or ortho parallel scale
-    //camera->Dolly(z); // Move camera forward/back
-    _renderer->ResetCameraClippingRange();
-    storeCameraOrientation();
+    } else {
+        vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
+        camera->Zoom(z); // Change perspective FOV angle or ortho parallel scale
+        //camera->Dolly(z); // Move camera forward/back
+        _renderer->ResetCameraClippingRange();
+        storeCameraOrientation();
+    }
     _needsRedraw = true;
 }
@@ -1704 +1793 @@
     double camPos[2];
 
-    int pxOffsetX = 75;
+    int pxOffsetX = 85;
     int pxOffsetY = 75;
     int outerGutter = 15;
 
     int imgHeightPx = _windowHeight - pxOffsetY - outerGutter;
-    double pxToWorld = height / imgHeightPx;
+    int imgWidthPx = _windowWidth - pxOffsetX - outerGutter;
+    double pxToWorld;
+    if (height > width) 
+        pxToWorld = height / imgHeightPx;
+    else
+        pxToWorld = width / imgWidthPx;
     double offsetX = pxOffsetX * pxToWorld;
     double offsetY = pxOffsetY * pxToWorld;
@@ -1749 +1843 @@
                                 _imgWorldOrigin[1], _imgWorldOrigin[1] + _imgWorldDims[1], 0, 0);
 
+    // Compute screen world coordinates
+    computeScreenWorldCoords();
+
 #ifdef DEBUG
     printCameraInfo(camera);
@@ -1756 +1853 @@
 }
 
+void Renderer::computeScreenWorldCoords()
+{
+    // Start with viewport coords [-1,1]
+    double x0 = -1;
+    double y0 = -1;
+    double z0 = 0;
+    double x1 = 1;
+    double y1 = 1;
+    double z1 = 0;
+
+    vtkMatrix4x4 *mat = vtkMatrix4x4::New();
+    double result[4];
+
+    // get the perspective transformation from the active camera
+    mat->DeepCopy(_renderer->GetActiveCamera()->
+                  GetCompositeProjectionTransformMatrix(_renderer->GetTiledAspectRatio(),0,1));
+
+    // use the inverse matrix
+    mat->Invert();
+
+    // Transform point to world coordinates
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+    result[3] = 1.0;
+
+    mat->MultiplyPoint(result, result);
+
+    // Get the transformed vector & set WorldPoint
+    // while we are at it try to keep w at one
+    if (result[3]) {
+        x0 = result[0] / result[3];
+        y0 = result[1] / result[3];
+        z0 = result[2] / result[3];
+    }
+
+    result[0] = x1;
+    result[1] = y1;
+    result[2] = z1;
+    result[3] = 1.0;
+
+    mat->MultiplyPoint(result, result);
+
+    if (result[3]) {
+        x1 = result[0] / result[3];
+        y1 = result[1] / result[3];
+        z1 = result[2] / result[3];
+    }
+
+    mat->Delete();
+
+    _screenWorldCoords[0] = x0;
+    _screenWorldCoords[1] = y0;
+    _screenWorldCoords[2] = x1 - x0;
+    _screenWorldCoords[3] = y1 - y0;
+}
+
+/**
+ * \brief Get the world coordinates of the image camera plot area
+ *
+ * \param[out] xywh Array to hold x,y,width,height world coordinates
+ */
+void Renderer::getCameraZoomRegion(double xywh[4]) const
+{
+    xywh[0] = _imgWorldOrigin[0];
+    xywh[1] = _imgWorldOrigin[1];
+    xywh[2] = _imgWorldDims[0];
+    xywh[3] = _imgWorldDims[1];
+}
+
+/**
+ * \brief Get the world origin and dimensions of the screen
+ *
+ * \param[out] xywh Array to hold x,y,width,height world coordinates
+ */
+void Renderer::getScreenWorldCoords(double xywh[4]) const
+{
+    memcpy(xywh, _screenWorldCoords, sizeof(double)*4);
+}
+
+/**
+ * \brief Compute bounding box containing the two input bounding boxes
+ *
+ * \param[out] boundsDest Union of the two input bounding boxes
+ * \param[in] bounds1 Input bounding box
+ * \param[in] bounds2 Input bounding box
+ */
 void Renderer::mergeBounds(double *boundsDest,
                            const double *bounds1, const double *bounds2)
@@ -1809 +1993 @@
 
 /**
- * \brief Update data ranges for color-mapping
+ * \brief Update data ranges for color-mapping and contours
  *
  * \param[in] useCumulative Use cumulative range of all DataSets
@@ -1830 +2014 @@
         }
     }
+    for (Contour2DHashmap::iterator itr = _contours.begin();
+         itr != _contours.end(); ++itr) {
+        // Only need to update range if using evenly spaced contours
+        if (itr->second->getContourList().empty()) {
+            if (useCumulative) {
+                itr->second->setContours(itr->second->getNumContours(), _cumulativeDataRange);
+            } else {
+                itr->second->setContours(itr->second->getNumContours());
+            }
+        }
+    }
 }
 
@@ -1836 +2031 @@
  *
  * \param[inout] range Data range of all DataSets
- */
-void Renderer::collectDataRanges(double *range)
+ * \param[in] onlyVisible Only collect range of visible DataSets
+ */
+void Renderer::collectDataRanges(double *range, bool onlyVisible)
 {
     range[0] = DBL_MAX;
@@ -1844 +2040 @@
     for (DataSetHashmap::iterator itr = _dataSets.begin();
          itr != _dataSets.end(); ++itr) {
-        double r[2];
-        itr->second->getDataRange(r);
-        range[0] = min2(range[0], r[0]);
-        range[1] = max2(range[1], r[1]);
+        if (!onlyVisible || itr->second->getVisibility()) {
+            double r[2];
+            itr->second->getDataRange(r);
+            range[0] = min2(range[0], r[0]);
+            range[1] = max2(range[1], r[1]);
+        }
     }
     if (range[0] == DBL_MAX)
@@ -1875 +2073 @@
     _imgWorldDims[0] = bounds[1] - bounds[0];
     _imgWorldDims[1] = bounds[3] - bounds[2];
+    _cameraPan[0] = 0;
+    _cameraPan[1] = 0;
+    _cameraZoomRatio = 1;
 
     if (_cameraMode == IMAGE) {
@@ -1885 +2086 @@
         resetAxes();
         _renderer->ResetCamera();
+        computeScreenWorldCoords();
     } else if (_cameraMode == PERSPECTIVE) {
         _renderer->GetActiveCamera()->ParallelProjectionOff();
         resetAxes();
         _renderer->ResetCamera();
+        computeScreenWorldCoords();
     }
 }
@@ -1933 +2136 @@
 void Renderer::setVisibility(const DataSetId& id, bool state)
 {
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+        doAll = true;
+    } else {
+        itr = _dataSets.find(id);
+    }
+    if (itr == _dataSets.end()) {
+        ERROR("Unknown dataset %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _dataSets.end());
+
     setPseudoColorVisibility(id, state);
     setContourVisibility(id, state);
@@ -2014 +2236 @@
     double *worldCoords = coord->GetComputedWorldValue(_renderer);
 
-#ifdef DEBUG
     TRACE("Pixel coords: %d, %d\nWorld coords: %.12e, %.12e, %12e", x, y,
           worldCoords[0], 
           worldCoords[1], 
           worldCoords[2]);
-#endif
 
     return getDataValue(id, worldCoords[0], worldCoords[1], worldCoords[2]);

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -84 +84 @@
     void setVisibility(const DataSetId& id, bool state);
 
+    void setUseCumulativeDataRange(bool state, bool onlyVisible = false);
+
     // Render window
 
@@ -96 +98 @@
     void setCameraMode(CameraMode mode);
 
+    CameraMode getCameraMode() const;
+
     void resetCamera(bool resetOrientation = true);
 
     void setCameraZoomRegion(double x, double y, double width, double height);
 
+    void getCameraZoomRegion(double xywh[4]) const;
+
+    void getScreenWorldCoords(double xywh[4]) const;
+
     void rotateCamera(double yaw, double pitch, double roll);
 
-    void panCamera(double x, double y);
-
-    void zoomCamera(double z);
+    void panCamera(double x, double y, bool absolute = true);
+
+    void zoomCamera(double z, bool absolute = true);
 
     // Rendering an image
@@ -228 +236 @@
     void collectBounds(double *bounds, bool onlyVisible);
 
-    void collectDataRanges(double *range);
+    void collectDataRanges(double *range, bool onlyVisible);
 
     void updateRanges(bool useCumulative);
+
+    void computeScreenWorldCoords();
 
     void storeCameraOrientation();
@@ -242 +252 @@
     double _imgWorldOrigin[2];
     double _imgWorldDims[2];
+    double _screenWorldCoords[4];
     double _cameraPos[3];
     double _cameraFocalPoint[3];
     double _cameraUp[3];
+    double _cameraZoomRatio;
+    double _cameraPan[2];
     float _bgColor[3];
-    bool _useCumulativeRanges;
+    bool _useCumulativeRange;
+    bool _cumulativeRangeOnlyVisible;
     double _cumulativeDataRange[2];
 

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -782 +782 @@
 
 static int
+DataSetMapRangeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    const char *value = Tcl_GetString(objv[2]);
+    if (strcmp(value, "all") == 0) {
+        g_renderer->setUseCumulativeDataRange(true);
+    } else if (strcmp(value, "visible") == 0) {
+        g_renderer->setUseCumulativeDataRange(true, true);
+    } else if (strcmp(value, "separate") == 0) {
+        g_renderer->setUseCumulativeDataRange(false);
+    } else {
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
 DataSetVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                  Tcl_Obj *const *objv)
@@ -802 +819 @@
     {"delete", 1, DataSetDeleteOp, 2, 3, "?name?"},
     {"getvalue", 1, DataSetGetValueOp, 6, 7, "oper x y ?z? name"},
+    {"maprange", 1, DataSetMapRangeOp, 3, 3, "value"},
     {"opacity", 1, DataSetOpacityOp, 3, 4, "value ?name?"},
     {"visible", 1, DataSetVisibleOp, 3, 4, "bool ?name?"}

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -44 +44 @@
 dataset getvalue pixel <x> <y> <datasetName>
         Use pixel for image camera mode
+dataset maprange <val>
+        <val> = all|visible|separate
+        Controls if data range for colormapping and contours is based on
+        cumulative range of all datasets ("all"), only visible datasets
+        ("visible") or each individual dataset ("separate").  Defaults to
+        "all"
 dataset opacity <val> <?datasetName?>
 dataset visible <bool> <?datasetName?>
@@ -58 +64 @@
 
 contour2d add numcontours <n> <?datasetName?>
+          Generate evenly spaced contours including range endpoints.  See also
+          'dataset maprange' command.
 contour2d add contourlist <list> <?datasetName?>
           list = {isoval1 isoval2 isoval3...}
@@ -83 +91 @@
 nv>image -type image -bytes <nbytes>
   <binary RGB data>
+nv>image -type image -bbox {x1 y1 x2 y2} -bytes <nbytes>
+  <binary RGB data>
+  Note: in this form, the bbox is the upper left and lower right screen corners
+  in world coordinates.  This form is currently used only if the camera mode is
+  set to 'image'.
 nv>legend <colormapName> <nbytes>
   <binary RGB data>