Changeset 2194 for trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

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.

File:

• trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp (modified) (27 diffs)

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]);