Changeset 2290 for trunk/packages/vizservers

Timestamp:

Jun 22, 2011 3:39:41 PM (13 years ago)

Author:

ldelgass

Message:

• Add contour3d (isosurface geometry) command to vtkvis
• Use depth peeling algorithm (order independent transparency) by default, add 'renderer depthpeel' command to toggle.
• Use tri strips in some geometry generators for better performance
• Heightmap: 2D slice resampling of non-image 3D datasets (e.g. points, ugrids) Set a default scaling based on data range. Still some problems where images from resampling have zero values in out-of-bounds pixels (probe filter creates a mask array that could be used). Still need a method/heuristic to select image resolution when resampling.

Location:

trunk/packages/vizservers/vtkvis

Files:

• Makefile.in (modified) (2 diffs)
• RpContour2D.cpp (modified) (2 diffs)
• RpContour3D.cpp (added)
• RpContour3D.h (added)
• RpGlyphs.cpp (modified) (2 diffs)
• RpHeightMap.cpp (modified) (19 diffs)
• RpHeightMap.h (modified) (3 diffs)
• RpPseudoColor.cpp (modified) (4 diffs)
• RpVtkDataSet.cpp (modified) (3 diffs)
• RpVtkDataSet.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (35 diffs)
• RpVtkRenderer.h (modified) (6 diffs)
• RpVtkRendererCmd.cpp (modified) (15 diffs)
• protocol.txt (modified) (2 diffs)

trunk/packages/vizservers/vtkvis/Makefile.in

@@ -76 +76 @@
                 PPMWriter.cpp \
                 RpContour2D.cpp \
+                RpContour3D.cpp \
                 RpGlyphs.cpp \
                 RpHeightMap.cpp \
@@ -126 +127 @@
 PPMWriter.o: PPMWriter.h Trace.h
 RpContour2D.o: RpContour2D.h RpVtkDataSet.h Trace.h
+RpContour3D.o: RpContour3D.h RpVtkDataSet.h Trace.h
 RpPolyData.o: RpPolyData.h RpVtkDataSet.h Trace.h
 RpGlyphs.o: RpGlyphs.h RpVtkDataSet.h ColorMap.h Trace.h

trunk/packages/vizservers/vtkvis/RpContour2D.cpp

@@ -115 +115 @@
     }
 
+    vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
+
     if (ds->GetPointData() == NULL ||
         ds->GetPointData()->GetScalars() == NULL) {
@@ -120 +122 @@
         if (ds->GetCellData() != NULL &&
             ds->GetCellData()->GetScalars() != NULL) {
-            vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
             cellToPtData = 
                 vtkSmartPointer<vtkCellDataToPointData>::New();

trunk/packages/vizservers/vtkvis/RpGlyphs.cpp

@@ -147 +147 @@
     setGlyphShape(_glyphShape);
 
+    vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
+
     if (ds->GetPointData() == NULL ||
         ds->GetPointData()->GetScalars() == NULL) {
@@ -152 +154 @@
         if (ds->GetCellData() != NULL &&
             ds->GetCellData()->GetScalars() != NULL) {
-            vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
             cellToPtData = 
                 vtkSmartPointer<vtkCellDataToPointData>::New();

trunk/packages/vizservers/vtkvis/RpHeightMap.cpp

@@ -20 +20 @@
 #include <vtkDelaunay2D.h>
 #include <vtkDelaunay3D.h>
+#include <vtkProbeFilter.h>
 #include <vtkGaussianSplatter.h>
 #include <vtkExtractVOI.h>
@@ -32 +33 @@
 using namespace Rappture::VtkVis;
 
-//#define MESH_POINTS
+#define MESH_POINT_CLOUDS
 
 HeightMap::HeightMap() :
@@ -41 +42 @@
     _opacity(1.0),
     _warpScale(1.0),
+    _sliceAxis(Z_AXIS),
     _pipelineInitialized(false)
 {
@@ -78 +80 @@
             _dataRange[0] = dataRange[0];
             _dataRange[1] = dataRange[1];
+
+            // Compute a data scaling factor to make maximum
+            // height (at default _warpScale) equivalent to 
+            // largest dimension of data set
+            double bounds[6];
+            double boundsRange = 0.0;
+            _dataSet->getBounds(bounds);
+            for (int i = 0; i < 6; i+=2) {
+                double r = bounds[i+1] - bounds[i];
+                if (r > boundsRange)
+                    boundsRange = r;
+            }
+            double datRange = _dataRange[1] - _dataRange[0];
+            if (datRange < 1.0e-10) {
+                _dataScale = 1.0;
+            } else {
+                _dataScale = boundsRange / datRange;
+            }
+            TRACE("Bounds range: %g data range: %g scaling: %g",
+                  boundsRange, datRange, _dataScale);
         }
 
@@ -115 +137 @@
 
     if (!_pipelineInitialized) {
+        vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
+
         if (ds->GetPointData() == NULL ||
             ds->GetPointData()->GetScalars() == NULL) {
@@ -120 +144 @@
             if (ds->GetCellData() != NULL &&
                 ds->GetCellData()->GetScalars() != NULL) {
-                vtkSmartPointer<vtkCellDataToPointData> cellToPtData;
                 cellToPtData = 
                     vtkSmartPointer<vtkCellDataToPointData>::New();
@@ -141 +164 @@
                 // DataSet is a point cloud
                 if (_dataSet->is2D()) {
-#ifdef MESH_POINTS
+#ifdef MESH_POINT_CLOUDS
+                    // Result of Delaunay2D is a PolyData
                     vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
                     mesher->SetInput(pd);
@@ -169 +193 @@
                     _volumeSlicer->SetSampleRate(1, 1, 1);
                     vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                    gf->UseStripsOn();
                     gf->SetInputConnection(_volumeSlicer->GetOutputPort());
                     vtkAlgorithmOutput *warpOutput = initWarp(gf->GetOutputPort());
@@ -175 +200 @@
 #endif
                 } else {
-#ifdef MESH_POINTS
+#ifdef MESH_POINT_CLOUDS
+                    // Data Set is a 3D point cloud
+                    // Result of Delaunay3D mesher is unstructured grid
                     vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
                     mesher->SetInput(pd);
+                    // Run the mesher
+                    mesher->Update();
+                    // Get bounds of resulting grid
+                    double bounds[6];
+                    mesher->GetOutput()->GetBounds(bounds);
+                    // Sample a plane within the grid bounding box
+                    if (_probeFilter == NULL)
+                        _probeFilter = vtkSmartPointer<vtkProbeFilter>::New();
+                    _probeFilter->SetSourceConnection(mesher->GetOutputPort());
+                    vtkSmartPointer<vtkImageData> imageData = vtkSmartPointer<vtkImageData>::New();
+                    int xdim = 256;
+                    int ydim = 256;
+                    int zdim = 1;
+                    imageData->SetDimensions(xdim, ydim, zdim);
+                    imageData->SetOrigin(bounds[0], bounds[2], bounds[4] + (bounds[5]-bounds[4])/2.);
+                    imageData->SetSpacing((bounds[1]-bounds[0])/((double)(xdim-1)), 
+                                          (bounds[3]-bounds[2])/((double)(ydim-1)),
+                                          0);
+                    _probeFilter->SetInput(imageData);
                     vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
-                    gf->SetInputConnection(mesher->GetOutputPort());
+                    gf->UseStripsOn();
+                    gf->SetInputConnection(_probeFilter->GetOutputPort());
 #else
                     if (_pointSplatter == NULL)
@@ -202 +249 @@
                     _volumeSlicer->SetSampleRate(1, 1, 1);
                     vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                    gf->UseStripsOn();
                     gf->SetInputConnection(_volumeSlicer->GetOutputPort());
 #endif
@@ -223 +271 @@
             // Can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid
             vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+            gf->UseStripsOn();
             vtkImageData *imageData = vtkImageData::SafeDownCast(ds);
             if (!_dataSet->is2D() && imageData != NULL) {
@@ -235 +284 @@
                 _volumeSlicer->SetSampleRate(1, 1, 1);
                 gf->SetInputConnection(_volumeSlicer->GetOutputPort());
+            } else if (imageData == NULL) {
+                // structured grid, unstructured grid, or rectilinear grid
+                double bounds[6];
+                ds->GetBounds(bounds);
+                // Sample a plane within the grid bounding box
+                if (_probeFilter == NULL)
+                    _probeFilter = vtkSmartPointer<vtkProbeFilter>::New();
+                _probeFilter->SetSource(ds);
+                vtkSmartPointer<vtkImageData> imageData = vtkSmartPointer<vtkImageData>::New();
+                int xdim = 256;
+                int ydim = 256;
+                int zdim = 1;
+                imageData->SetDimensions(xdim, ydim, zdim);
+                imageData->SetOrigin(bounds[0], bounds[2], bounds[4] + (bounds[5]-bounds[4])/2.);
+                imageData->SetSpacing((bounds[1]-bounds[0])/((double)(xdim-1)), 
+                                      (bounds[3]-bounds[2])/((double)(ydim-1)),
+                                      0);
+                _probeFilter->SetInput(imageData);
+                gf->SetInputConnection(_probeFilter->GetOutputPort());
             } else {
-                // 2D image data, structured grid, unstructured grid, or rectilinear grid
+                // 2D image data
                 gf->SetInput(ds);
             }
@@ -269 +337 @@
     initProp();
 
+    _dsMapper->SetColorModeToMapScalars();
     _dsMapper->UseLookupTableScalarRangeOn();
     _dsMapper->SetLookupTable(_lut);
@@ -325 +394 @@
         if (_warp == NULL)
             _warp = vtkSmartPointer<vtkWarpScalar>::New();
-        _warp->SetNormal(0, 0, 1);
+        switch (_sliceAxis) {
+        case X_AXIS:
+            _warp->SetNormal(1, 0, 0);
+            break;
+        case Y_AXIS:
+            _warp->SetNormal(0, 1, 0);
+            break;
+        default:
+            _warp->SetNormal(0, 0, 1);
+        }
         _warp->UseNormalOn();
-        _warp->SetScaleFactor(_warpScale);
+        _warp->SetScaleFactor(_warpScale * _dataScale);
         _warp->SetInputConnection(input);
         return _warp->GetOutputPort();
@@ -345 +423 @@
         if (_warp == NULL)
             _warp = vtkSmartPointer<vtkWarpScalar>::New();
-        _warp->SetNormal(0, 0, 1);
+        switch (_sliceAxis) {
+        case X_AXIS:
+            _warp->SetNormal(1, 0, 0);
+            break;
+        case Y_AXIS:
+            _warp->SetNormal(0, 1, 0);
+            break;
+        default:
+            _warp->SetNormal(0, 0, 1);
+        }
         _warp->UseNormalOn();
-        _warp->SetScaleFactor(_warpScale);
+        _warp->SetScaleFactor(_warpScale * _dataScale);
         _warp->SetInput(pdInput);
         return _warp->GetOutputPort();
@@ -369 +456 @@
         _warp = NULL;
     } else {
-        _warp->SetScaleFactor(_warpScale);
+        _warp->SetScaleFactor(_warpScale * _dataScale);
     }
 
@@ -385 +472 @@
     }
 
-    if (_warp == NULL ||
-        _volumeSlicer == NULL) {
+    if (_volumeSlicer == NULL &&
+         _probeFilter == NULL) {
         WARN("Called before update() or DataSet is not a volume");
         return;
@@ -392 +479 @@
 
     int dims[3];
-    int voi[6];
 
     if (_pointSplatter != NULL) {
@@ -399 +485 @@
         vtkImageData *imageData = vtkImageData::SafeDownCast(_dataSet->getVtkDataSet());
         if (imageData == NULL) {
-            ERROR("Not a volume data set");
+            if (_probeFilter != NULL) {
+                imageData = vtkImageData::SafeDownCast(_probeFilter->GetInput());
+                if (imageData == NULL) {
+                    ERROR("Couldn't get probe filter input image");
+                    return;
+                }
+            } else {
+                ERROR("Not a volume data set");
+                return;
+            }
+        }
+        imageData->GetDimensions(dims);
+    }
+
+    _sliceAxis = axis;
+    if (_warp != NULL) {
+        switch (axis) {
+        case X_AXIS:
+            _warp->SetNormal(1, 0, 0);
+            break;
+        case Y_AXIS:
+            _warp->SetNormal(0, 1, 0);
+            break;
+        case Z_AXIS:
+            _warp->SetNormal(0, 0, 1);
+            break;
+        default:
+            ERROR("Invalid Axis");
             return;
         }
-        imageData->GetDimensions(dims);
-    }
-
-    switch (axis) {
-    case X_AXIS:
-        voi[0] = voi[1] = (int)((dims[0]-1) * ratio);
-        voi[2] = 0;
-        voi[3] = dims[1]-1;
-        voi[4] = 0;
-        voi[5] = dims[2]-1;
-        _warp->SetNormal(1, 0, 0);
-        break;
-    case Y_AXIS:
-        voi[2] = voi[3] = (int)((dims[1]-1) * ratio);
-        voi[0] = 0;
-        voi[1] = dims[0]-1;
-        voi[4] = 0;
-        voi[5] = dims[2]-1;
-        _warp->SetNormal(0, 1, 0);
-        break;
-    case Z_AXIS:
-        voi[4] = voi[5] = (int)((dims[2]-1) * ratio);
-        voi[0] = 0;
-        voi[1] = dims[0]-1;
-        voi[2] = 0;
-        voi[3] = dims[1]-1;
-        _warp->SetNormal(0, 0, 1);
-        break;
-    default:
-        ERROR("Invalid Axis");
-        return;
-    }
-
-    _volumeSlicer->SetVOI(voi[0], voi[1], voi[2], voi[3], voi[4], voi[5]);
+    }
+
+    if (_probeFilter != NULL) {
+        vtkImageData *imageData = vtkImageData::SafeDownCast(_probeFilter->GetInput());
+        double bounds[6];
+        assert(vtkDataSet::SafeDownCast(_probeFilter->GetSource()) != NULL);
+        vtkDataSet::SafeDownCast(_probeFilter->GetSource())->GetBounds(bounds);
+        int dim = 256;
+
+        switch (axis) {
+        case X_AXIS:
+            imageData->SetDimensions(1, dim, dim);
+            imageData->SetOrigin(bounds[0] + (bounds[1]-bounds[0])*ratio, bounds[2], bounds[4]);
+            imageData->SetSpacing(0,
+                                  (bounds[3]-bounds[2])/((double)(dim-1)), 
+                                  (bounds[5]-bounds[4])/((double)(dim-1)));
+            break;
+        case Y_AXIS:
+            imageData->SetDimensions(dim, 1, dim);
+            imageData->SetOrigin(bounds[0], bounds[2] + (bounds[3]-bounds[2])*ratio, bounds[4]);
+            imageData->SetSpacing((bounds[1]-bounds[0])/((double)(dim-1)), 
+                                  0,
+                                  (bounds[5]-bounds[4])/((double)(dim-1)));
+            break;
+        case Z_AXIS:
+            imageData->SetDimensions(dim, dim, 1);
+            imageData->SetOrigin(bounds[0], bounds[2], bounds[4] + (bounds[5]-bounds[4])*ratio);
+            imageData->SetSpacing((bounds[1]-bounds[0])/((double)(dim-1)), 
+                                  (bounds[3]-bounds[2])/((double)(dim-1)),
+                                  0);
+            break;
+        default:
+            ERROR("Invalid Axis");
+            return;
+        }
+    } else {
+        int voi[6];
+
+        switch (axis) {
+        case X_AXIS:
+            voi[0] = voi[1] = (int)((dims[0]-1) * ratio);
+            voi[2] = 0;
+            voi[3] = dims[1]-1;
+            voi[4] = 0;
+            voi[5] = dims[2]-1;
+            break;
+        case Y_AXIS:
+            voi[2] = voi[3] = (int)((dims[1]-1) * ratio);
+            voi[0] = 0;
+            voi[1] = dims[0]-1;
+            voi[4] = 0;
+            voi[5] = dims[2]-1;
+            break;
+        case Z_AXIS:
+            voi[4] = voi[5] = (int)((dims[2]-1) * ratio);
+            voi[0] = 0;
+            voi[1] = dims[0]-1;
+            voi[2] = 0;
+            voi[3] = dims[1]-1;
+            break;
+        default:
+            ERROR("Invalid Axis");
+            return;
+        }
+
+        _volumeSlicer->SetVOI(voi[0], voi[1], voi[2], voi[3], voi[4], voi[5]);
+    }
+
     if (_dsMapper != NULL)
         _dsMapper->Update();

trunk/packages/vizservers/vtkvis/RpHeightMap.h

@@ -12 +12 @@
 #include <vtkAlgorithmOutput.h>
 #include <vtkContourFilter.h>
+#include <vtkProbeFilter.h>
 #include <vtkLookupTable.h>
 #include <vtkDataSetMapper.h>
@@ -107 +108 @@
     double _opacity;
     double _warpScale;
+    double _dataScale;
+    Axis _sliceAxis;
     bool _pipelineInitialized;
 
@@ -114 +117 @@
     vtkSmartPointer<vtkPolyDataMapper> _contourMapper;
     vtkSmartPointer<vtkGaussianSplatter> _pointSplatter;
+    vtkSmartPointer<vtkProbeFilter> _probeFilter;
     vtkSmartPointer<vtkExtractVOI> _volumeSlicer;
     vtkSmartPointer<vtkWarpScalar> _warp;

trunk/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -24 +24 @@
 #include "Trace.h"
 
+#define MESH_POINT_CLOUDS
+
 using namespace Rappture::VtkVis;
 
@@ -93 +95 @@
             // DataSet is a point cloud
             if (_dataSet->is2D()) {
-#if 0
+#ifdef MESH_POINT_CLOUDS
                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
                 mesher->SetInput(pd);
-                _dsMapper->SetInputConnection(mesher->GetOutputPort());
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->SetInputConnection(mesher->GetOutputPort());
+                _dsMapper->SetInputConnection(gf->GetOutputPort());
 #else
                 vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
@@ -117 +121 @@
                 slicer->SetSampleRate(1, 1, 1);
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->UseStripsOn();
                 gf->SetInputConnection(slicer->GetOutputPort());
                 _dsMapper->SetInputConnection(gf->GetOutputPort());
@@ -158 +163 @@
     _lut->SetRange(dataRange);
 
+    _dsMapper->SetColorModeToMapScalars();
     _dsMapper->UseLookupTableScalarRangeOn();
     _dsMapper->SetLookupTable(_lut);

trunk/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -124 +124 @@
     TRACE("DataSet class: %s", _dataSet->GetClassName());
     TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
+    TRACE("DataSet bounds: %g %g %g %g %g %g",
+          _bounds[0], _bounds[1],
+          _bounds[2], _bounds[3],
+          _bounds[4], _bounds[5]);
     return true;
 }
@@ -141 +145 @@
     TRACE("DataSet class: %s", _dataSet->GetClassName());
     TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
+    TRACE("DataSet bounds: %g %g %g %g %g %g",
+          _bounds[0], _bounds[1],
+          _bounds[2], _bounds[3],
+          _bounds[4], _bounds[5]);
     return true;
 }
@@ -217 +225 @@
 void DataSet::getDataRange(double minmax[2])
 {
-    minmax[0] = _dataRange[0];
-    minmax[1] = _dataRange[1];
+    memcpy(minmax, _dataRange, sizeof(double)*2);
+}
+
+/**
+ * \brief Get the bounds the DataSet
+ */
+void DataSet::getBounds(double bounds[6])
+{
+    memcpy(bounds, _bounds, sizeof(double)*6);
 }
 

trunk/packages/vizservers/vtkvis/RpVtkDataSet.h

@@ -47 +47 @@
     void getDataRange(double minmax[2]);
 
+    void getBounds(double bounds[6]);
+
     double getDataValue(double x, double y, double z);
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -104 +104 @@
 #endif
     _renderWindow->SetSize(_windowWidth, _windowHeight);
+    // Next 2 options needed to support depth peeling
+    _renderWindow->SetAlphaBitPlanes(1);
+    _renderWindow->SetMultiSamples(0);
+    _renderer->SetMaximumNumberOfPeels(100);
+    _renderer->SetUseDepthPeeling(1);
     _renderWindow->AddRenderer(_renderer);
     addColorMap("default", ColorMap::getDefault());
@@ -112 +117 @@
 {
     TRACE("Enter");
-    TRACE("Deleting Contours");
-    for (Contour2DHashmap::iterator itr = _contours.begin();
-             itr != _contours.end(); ++itr) {
+    TRACE("Deleting Contour2Ds");
+    for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
+             itr != _contour2Ds.end(); ++itr) {
         delete itr->second;
     }
-    _contours.clear();
+    _contour2Ds.clear();
+    TRACE("Deleting Contour3Ds");
+    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
+             itr != _contour3Ds.end(); ++itr) {
+        delete itr->second;
+    }
+    _contour3Ds.clear();
     TRACE("Deleting Glyphs");
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
@@ -169 +180 @@
  *
  * This just adds the DataSet to the Renderer's list of data sets.
- * In order to render the data, a PseudoColor or Contour2D must
- * be added to the Renderer.
+ * In order to render the data, a graphics object using the data
+ * set must be added to the Renderer.
  */
 void Renderer::addDataSet(const DataSetId& id)
@@ -193 +204 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -211 +222 @@
         delete contour;
 
-        itr = _contours.erase(itr);
-    } while (doAll && itr != _contours.end());
+        itr = _contour2Ds.erase(itr);
+    } while (doAll && itr != _contour2Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Remove the Contour3D isosurfaces for the specified DataSet
+ *
+ * The underlying Contour3D is deleted, freeing its memory
+ */
+void Renderer::deleteContour3D(const DataSetId& id)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting Contour3Ds for %s", id.c_str());
+
+    do {
+        Contour3D *contour = itr->second;
+        if (contour->getProp())
+            _renderer->RemoveViewProp(contour->getProp());
+        delete contour;
+
+        itr = _contour3Ds.erase(itr);
+    } while (doAll && itr != _contour3Ds.end());
 
     _needsRedraw = true;
@@ -424 +471 @@
 
         deleteContour2D(itr->second->getName());
+        deleteContour3D(itr->second->getName());
         deleteGlyphs(itr->second->getName());
         deleteHeightMap(itr->second->getName());
@@ -982 +1030 @@
 
         Contour2D *contour = new Contour2D();
-        _contours[dsID] = contour;
+        _contour2Ds[dsID] = contour;
 
         contour->setDataSet(ds);
@@ -998 +1046 @@
 Contour2D *Renderer::getContour2D(const DataSetId& id)
 {
-    Contour2DHashmap::iterator itr = _contours.find(id);
-
-    if (itr == _contours.end()) {
+    Contour2DHashmap::iterator itr = _contour2Ds.find(id);
+
+    if (itr == _contour2Ds.end()) {
         TRACE("Contour2D not found: %s", id.c_str());
         return NULL;
@@ -1010 +1058 @@
  * \brief Set the number of equally spaced contour isolines for the given DataSet
  */
-void Renderer::setContours(const DataSetId& id, int numContours)
+void Renderer::setContour2DContours(const DataSetId& id, int numContours)
 {
     Contour2DHashmap::iterator itr;
@@ -1017 +1065 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1033 +1081 @@
             itr->second->setContours(numContours);
         }
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
     _needsRedraw = true;
@@ -1041 +1089 @@
  * \brief Set a list of isovalues for the given DataSet
  */
-void Renderer::setContourList(const DataSetId& id, const std::vector<double>& contours)
+void Renderer::setContour2DContourList(const DataSetId& id, const std::vector<double>& contours)
 {
     Contour2DHashmap::iterator itr;
@@ -1048 +1096 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1060 +1108 @@
     do {
         itr->second->setContourList(contours);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
      _needsRedraw = true;
@@ -1068 +1116 @@
  * \brief Set opacity of contour lines for the given DataSet
  */
-void Renderer::setContourOpacity(const DataSetId& id, double opacity)
+void Renderer::setContour2DOpacity(const DataSetId& id, double opacity)
 {
     Contour2DHashmap::iterator itr;
@@ -1075 +1123 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1087 +1135 @@
     do {
         itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
     _needsRedraw = true;
@@ -1095 +1143 @@
  * \brief Turn on/off rendering contour lines for the given DataSet
  */
-void Renderer::setContourVisibility(const DataSetId& id, bool state)
+void Renderer::setContour2DVisibility(const DataSetId& id, bool state)
 {
     Contour2DHashmap::iterator itr;
@@ -1102 +1150 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1114 +1162 @@
     do {
         itr->second->setVisibility(state);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
     _needsRedraw = true;
@@ -1122 +1170 @@
  * \brief Set the RGB isoline color for the specified DataSet
  */
-void Renderer::setContourEdgeColor(const DataSetId& id, float color[3])
+void Renderer::setContour2DEdgeColor(const DataSetId& id, float color[3])
 {
     Contour2DHashmap::iterator itr;
@@ -1129 +1177 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1141 +1189 @@
     do {
         itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
     _needsRedraw = true;
@@ -1152 +1200 @@
  * this function may not have an effect.
  */
-void Renderer::setContourEdgeWidth(const DataSetId& id, float edgeWidth)
+void Renderer::setContour2DEdgeWidth(const DataSetId& id, float edgeWidth)
 {
     Contour2DHashmap::iterator itr;
@@ -1159 +1207 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1171 +1219 @@
     do {
         itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
 
     _needsRedraw = true;
@@ -1179 +1227 @@
  * \brief Turn contour lighting on/off for the specified DataSet
  */
-void Renderer::setContourLighting(const DataSetId& id, bool state)
+void Renderer::setContour2DLighting(const DataSetId& id, bool state)
 {
     Contour2DHashmap::iterator itr;
@@ -1186 +1234 @@
 
     if (id.compare("all") == 0) {
-        itr = _contours.begin();
-        doAll = true;
-    } else {
-        itr = _contours.find(id);
-    }
-    if (itr == _contours.end()) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
         return;
@@ -1198 +1246 @@
     do {
         itr->second->setLighting(state);
-    } while (doAll && ++itr != _contours.end());
+    } while (doAll && ++itr != _contour2Ds.end());
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Create a new Contour3D and associate it with the named DataSet
+ */
+void Renderer::addContour3D(const DataSetId& id)
+{
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+    } else {
+        itr = _dataSets.find(id);
+    }
+    if (itr == _dataSets.end()) {
+        ERROR("Unknown dataset %s", id.c_str());
+        return;
+    }
+
+    do {
+        DataSet *ds = itr->second;
+        const DataSetId& dsID = ds->getName();
+
+        if (getContour3D(dsID)) {
+            WARN("Replacing existing contour3d %s", dsID.c_str());
+            deleteContour3D(dsID);
+        }
+
+        Contour3D *contour = new Contour3D();
+        _contour3Ds[dsID] = contour;
+
+        contour->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);
+        }
+
+        contour->setLookupTable(lut);
+
+        _renderer->AddViewProp(contour->getProp());
+    } while (doAll && ++itr != _dataSets.end());
+
+    if (_cameraMode == IMAGE)
+        setCameraMode(PERSPECTIVE);
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Get the Contour3D associated with a named DataSet
+ */
+Contour3D *Renderer::getContour3D(const DataSetId& id)
+{
+    Contour3DHashmap::iterator itr = _contour3Ds.find(id);
+
+    if (itr == _contour3Ds.end()) {
+        TRACE("Contour3D not found: %s", id.c_str());
+        return NULL;
+    } else
+        return itr->second;
+}
+
+/**
+ * \brief Set the number of equally spaced isosurfaces for the given DataSet
+ */
+void Renderer::setContour3DContours(const DataSetId& id, int numContours)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        if (_useCumulativeRange) {
+            itr->second->setContours(numContours, _cumulativeDataRange);
+        } else {
+            itr->second->setContours(numContours);
+        }
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set a list of isovalues for the given DataSet
+ */
+void Renderer::setContour3DContourList(const DataSetId& id, const std::vector<double>& contours)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourList(contours);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    initCamera();
+     _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of isosurfaces for the given DataSet
+ */
+void Renderer::setContour3DOpacity(const DataSetId& id, double opacity)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering isosurfaces for the given DataSet
+ */
+void Renderer::setContour3DVisibility(const DataSetId& id, bool state)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Associate an existing named color map with a Contour3D for the given 
+ * DataSet
+ */
+void Renderer::setContour3DColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    ColorMap *cmap = getColorMap(colorMapId);
+    if (cmap == NULL) {
+        ERROR("Unknown colormap: %s", colorMapId.c_str());
+        return;
+    }
+
+    do {
+        TRACE("Set Contour3D color map: %s for dataset %s", colorMapId.c_str(),
+              itr->second->getDataSet()->getName().c_str());
+
+        // Make a copy of the generic colormap lookup table, so 
+        // data range can be set in the copy table to match the 
+        // dataset being plotted
+        vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
+        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 != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB isosurface color for the specified DataSet
+ */
+void Renderer::setContour3DColor(const DataSetId& id, float color[3])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColor(color);
+    } while (doAll && ++itr != _contour3Ds.end());
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering isosurface edges for the given DataSet
+ */
+void Renderer::setContour3DEdgeVisibility(const DataSetId& id, bool state)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB isosurface edge color for the specified DataSet
+ */
+void Renderer::setContour3DEdgeColor(const DataSetId& id, float color[3])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the isosurface edge width for the specified DataSet (may be a no-op)
+ *
+ * If the OpenGL implementation/hardware does not support wide lines, 
+ * this function may not have an effect.
+ */
+void Renderer::setContour3DEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set wireframe rendering for the specified DataSet
+ */
+void Renderer::setContour3DWireframe(const DataSetId& id, bool state)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setWireframe(state);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn contour lighting on/off for the specified DataSet
+ */
+void Renderer::setContour3DLighting(const DataSetId& id, bool state)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _contour3Ds.end());
     _needsRedraw = true;
 }
@@ -3402 +3851 @@
     bounds[5] = -DBL_MAX;
 
-    for (Contour2DHashmap::iterator itr = _contours.begin();
-             itr != _contours.end(); ++itr) {
+    for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
+             itr != _contour2Ds.end(); ++itr) {
+        if (!onlyVisible || itr->second->getVisibility())
+            mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
+    }
+    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
+             itr != _contour3Ds.end(); ++itr) {
         if (!onlyVisible || itr->second->getVisibility())
             mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
@@ -3457 +3911 @@
 void Renderer::updateRanges(bool useCumulative)
 {
-    for (Contour2DHashmap::iterator itr = _contours.begin();
-         itr != _contours.end(); ++itr) {
+    for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
+         itr != _contour2Ds.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());
+            }
+        }
+    }
+    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
+         itr != _contour3Ds.end(); ++itr) {
         // Only need to update range if using evenly spaced contours
         if (itr->second->getContourList().empty()) {
@@ -3656 +4121 @@
 {
     if (id.compare("all") == 0 || getContour2D(id) != NULL)
-        setContourOpacity(id, opacity);
+        setContour2DOpacity(id, opacity);
+    if (id.compare("all") == 0 || getContour3D(id) != NULL)
+        setContour3DOpacity(id, opacity);
     if (id.compare("all") == 0 || getGlyphs(id) != NULL)
         setGlyphsOpacity(id, opacity);
@@ -3694 +4161 @@
 
     if (id.compare("all") == 0 || getContour2D(id) != NULL)
-        setContourVisibility(id, state);
+        setContour2DVisibility(id, state);
+    if (id.compare("all") == 0 || getContour3D(id) != NULL)
+        setContour3DVisibility(id, state);
     if (id.compare("all") == 0 || getGlyphs(id) != NULL)
         setGlyphsVisibility(id, state);
@@ -3732 +4201 @@
      * Mappers already using the PlaneCollection
      */
-    for (Contour2DHashmap::iterator itr = _contours.begin();
-         itr != _contours.end(); ++itr) {
+    for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
+         itr != _contour2Ds.end(); ++itr) {
+        itr->second->setClippingPlanes(_activeClipPlanes);
+    }
+    for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
+         itr != _contour3Ds.end(); ++itr) {
         itr->second->setClippingPlanes(_activeClipPlanes);
     }
@@ -3756 +4229 @@
         itr->second->setClippingPlanes(_activeClipPlanes);
     }
+}
+
+/**
+ * \brief Control the use of the depth peeling algorithm for transparency
+ */
+void Renderer::setUseDepthPeeling(bool state)
+{
+    _renderer->SetUseDepthPeeling(state ? 1 : 0);
+    _needsRedraw = true;
 }
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -28 +28 @@
 #include "RpVtkDataSet.h"
 #include "RpContour2D.h"
+#include "RpContour3D.h"
 #include "RpGlyphs.h"
 #include "RpHeightMap.h"
@@ -76 +77 @@
     typedef std::tr1::unordered_map<ColorMapId, ColorMap *> ColorMapHashmap;
     typedef std::tr1::unordered_map<DataSetId, Contour2D *> Contour2DHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Contour3D *> Contour3DHashmap;
     typedef std::tr1::unordered_map<DataSetId, Glyphs *> GlyphsHashmap;
     typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
@@ -146 +148 @@
     void setBackgroundColor(float color[3]);
 
+    void setUseDepthPeeling(bool state);
+
     bool render();
 
@@ -182 +186 @@
                         vtkUnsignedCharArray *imgData);
 
-    // Contour plots
+    // 2D Contour plots
 
     void addContour2D(const DataSetId& id);
@@ -190 +194 @@
     Contour2D *getContour2D(const DataSetId& id);
 
-    void setContours(const DataSetId& id, int numContours);
-
-    void setContourList(const DataSetId& id, const std::vector<double>& contours);
-
-    void setContourOpacity(const DataSetId& id, double opacity);
-
-    void setContourVisibility(const DataSetId& id, bool state);
-
-    void setContourEdgeColor(const DataSetId& id, float color[3]);
-
-    void setContourEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setContourLighting(const DataSetId& id, bool state);
+    void setContour2DContours(const DataSetId& id, int numContours);
+
+    void setContour2DContourList(const DataSetId& id, const std::vector<double>& contours);
+
+    void setContour2DOpacity(const DataSetId& id, double opacity);
+
+    void setContour2DVisibility(const DataSetId& id, bool state);
+
+    void setContour2DEdgeColor(const DataSetId& id, float color[3]);
+
+    void setContour2DEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setContour2DLighting(const DataSetId& id, bool state);
+
+    // 3D Contour (isosurface) plots
+
+    void addContour3D(const DataSetId& id);
+
+    void deleteContour3D(const DataSetId& id);
+
+    Contour3D *getContour3D(const DataSetId& id);
+
+    void setContour3DContours(const DataSetId& id, int numContours);
+
+    void setContour3DContourList(const DataSetId& id, const std::vector<double>& contours);
+
+    void setContour3DColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    void setContour3DOpacity(const DataSetId& id, double opacity);
+
+    void setContour3DVisibility(const DataSetId& id, bool state);
+
+    void setContour3DColor(const DataSetId& id, float color[3]);
+
+    void setContour3DEdgeVisibility(const DataSetId& id, bool state);
+
+    void setContour3DEdgeColor(const DataSetId& id, float color[3]);
+
+    void setContour3DEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setContour3DWireframe(const DataSetId& id, bool state);
+
+    void setContour3DLighting(const DataSetId& id, bool state);
 
     // Glyphs
@@ -376 +410 @@
     ColorMapHashmap _colorMaps;
     DataSetHashmap _dataSets;
-    Contour2DHashmap _contours;
+    Contour2DHashmap _contour2Ds;
+    Contour3DHashmap _contour3Ds;
     GlyphsHashmap _glyphs;
     HeightMapHashmap _heightMaps;

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -551 +551 @@
         const char *name = Tcl_GetString(objv[4]);
         g_renderer->addContour2D(name);
-        g_renderer->setContourList(name, contourList);
+        g_renderer->setContour2DContourList(name, contourList);
     } else {
         g_renderer->addContour2D("all");
-        g_renderer->setContourList("all", contourList);
+        g_renderer->setContour2DContourList("all", contourList);
     }
     return TCL_OK;
@@ -570 +570 @@
         const char *name = Tcl_GetString(objv[4]);
         g_renderer->addContour2D(name);
-        g_renderer->setContours(name, numContours);
+        g_renderer->setContour2DContours(name, numContours);
     } else {
         g_renderer->addContour2D("all");
-        g_renderer->setContours("all", numContours);
+        g_renderer->setContour2DContours("all", numContours);
     }
     return TCL_OK;
@@ -621 +621 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContourLighting(name, state);
-    } else {
-        g_renderer->setContourLighting("all", state);
+        g_renderer->setContour2DLighting(name, state);
+    } else {
+        g_renderer->setContour2DLighting("all", state);
     }
     return TCL_OK;
@@ -640 +640 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContourEdgeColor(name, color);
-    } else {
-        g_renderer->setContourEdgeColor("all", color);
+        g_renderer->setContour2DEdgeColor(name, color);
+    } else {
+        g_renderer->setContour2DEdgeColor("all", color);
     }
     return TCL_OK;
@@ -657 +657 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContourEdgeWidth(name, width);
-    } else {
-        g_renderer->setContourEdgeWidth("all", width);
+        g_renderer->setContour2DEdgeWidth(name, width);
+    } else {
+        g_renderer->setContour2DEdgeWidth("all", width);
     }
     return TCL_OK;
@@ -674 +674 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContourOpacity(name, opacity);
-    } else {
-        g_renderer->setContourOpacity("all", opacity);
+        g_renderer->setContour2DOpacity(name, opacity);
+    } else {
+        g_renderer->setContour2DOpacity("all", opacity);
     }
     return TCL_OK;
@@ -691 +691 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContourVisibility(name, state);
-    } else {
-        g_renderer->setContourVisibility("all", state);
+        g_renderer->setContour2DVisibility(name, state);
+    } else {
+        g_renderer->setContour2DVisibility("all", state);
     }
     return TCL_OK;
@@ -724 +724 @@
 
 static int
+Contour3DAddContourListOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    std::vector<double> contourList;
+
+    int clistc;
+    Tcl_Obj **clistv;
+
+    if (Tcl_ListObjGetElements(interp, objv[3], &clistc, &clistv) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    for (int i = 0; i < clistc; i++) {
+        double val;
+        if (Tcl_GetDoubleFromObj(interp, clistv[i], &val) != TCL_OK) {
+            return TCL_ERROR;
+        }
+        contourList.push_back(val);
+    }
+
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->addContour3D(name);
+        g_renderer->setContour3DContourList(name, contourList);
+    } else {
+        g_renderer->addContour3D("all");
+        g_renderer->setContour3DContourList("all", contourList);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DAddNumContoursOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    int numContours;
+    if (Tcl_GetIntFromObj(interp, objv[3], &numContours) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->addContour3D(name);
+        g_renderer->setContour3DContours(name, numContours);
+    } else {
+        g_renderer->addContour3D("all");
+        g_renderer->setContour3DContours("all", numContours);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec contour3dAddOps[] = {
+    {"contourlist", 1, Contour3DAddContourListOp, 4, 5, "contourList ?dataSetName?"},
+    {"numcontours", 1, Contour3DAddNumContoursOp, 4, 5, "numContours ?dataSetName?"}
+};
+static int nContour3dAddOps = NumCmdSpecs(contour3dAddOps);
+
+static int
+Contour3DAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nContour3dAddOps, contour3dAddOps,
+                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+Contour3DColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour3DColor(name, color);
+    } else {
+        g_renderer->setContour3DColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    const char *colorMapName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setContour3DColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteContour3D(name);
+    } else {
+        g_renderer->deleteContour3D("all");
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DEdgeVisibility(name, state);
+    } else {
+        g_renderer->setContour3DEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DLightingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DLighting(name, state);
+    } else {
+        g_renderer->setContour3DLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                     Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour3DEdgeColor(name, color);
+    } else {
+        g_renderer->setContour3DEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                     Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DEdgeWidth(name, width);
+    } else {
+        g_renderer->setContour3DEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    double opacity;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DOpacity(name, opacity);
+    } else {
+        g_renderer->setContour3DOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DVisibility(name, state);
+    } else {
+        g_renderer->setContour3DVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DWireframeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                     Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContour3DWireframe(name, state);
+    } else {
+        g_renderer->setContour3DWireframe("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec contour3dOps[] = {
+    {"add",       1, Contour3DAddOp, 4, 5, "oper value ?dataSetName?"},
+    {"color",     6, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",  6, Contour3DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete",    1, Contour3DDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges",     1, Contour3DEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting",  3, Contour3DLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor", 5, Contour3DLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth", 5, Contour3DLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity",   1, Contour3DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible",   1, Contour3DVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"wireframe", 1, Contour3DWireframeOp, 3, 4, "bool ?dataSetName?"}
+};
+static int nContour3dOps = NumCmdSpecs(contour3dOps);
+
+static int
+Contour3DCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nContour3dOps, contour3dOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 DataSetAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
              Tcl_Obj *const *objv)
@@ -758 +1025 @@
     TRACE("bytesRead: %d", ofs);
     if (bytesRead < 0) {
+        free(data);
         return TCL_ERROR;
     }
@@ -764 +1032 @@
     TRACE("bytesRead: %d '%c'", bytesRead, data[0]);
     if (bytesRead < (size_t)nbytes) {
+        free(data);
         return TCL_ERROR;
     }
@@ -1886 +2155 @@
 
     proc = Rappture::GetOpFromObj(interp, nPolyDataOps, polyDataOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+RendererDepthPeelingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    g_renderer->setUseDepthPeeling(state);
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec rendererOps[] = {
+    {"depthpeel", 1, RendererDepthPeelingOp, 3, 3, "bool"}
+};
+static int nRendererOps = NumCmdSpecs(rendererOps);
+
+static int
+RendererCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nRendererOps, rendererOps,
                                   Rappture::CMDSPEC_ARG1, objc, objv, 0);
     if (proc == NULL) {
@@ -2232 +2532 @@
     Tcl_CreateObjCommand(interp, "colormap",    ColorMapCmd,    NULL, NULL);
     Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   NULL, NULL);
+    Tcl_CreateObjCommand(interp, "contour3d",   Contour3DCmd,   NULL, NULL);
     Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     NULL, NULL);
     Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      NULL, NULL);
@@ -2238 +2539 @@
     Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    NULL, NULL);
     Tcl_CreateObjCommand(interp, "pseudocolor", PseudoColorCmd, NULL, NULL);
+    Tcl_CreateObjCommand(interp, "renderer",    RendererCmd,    NULL, NULL);
     Tcl_CreateObjCommand(interp, "screen",      ScreenCmd,      NULL, NULL);
     Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      NULL, NULL);
@@ -2254 +2556 @@
     Tcl_DeleteCommand(interp, "colormap");
     Tcl_DeleteCommand(interp, "contour2d");
+    Tcl_DeleteCommand(interp, "contour3d");
     Tcl_DeleteCommand(interp, "dataset");
     Tcl_DeleteCommand(interp, "glyphs");
@@ -2260 +2563 @@
     Tcl_DeleteCommand(interp, "polydata");
     Tcl_DeleteCommand(interp, "pseudocolor");
+    Tcl_DeleteCommand(interp, "renderer");
     Tcl_DeleteCommand(interp, "screen");
     Tcl_DeleteCommand(interp, "volume");

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -7 +7 @@
 screen bgcolor <r> <g> <b>
 screen size <width> <height>
+
+renderer depthpeel <bool>
+         Set use of depth peeling algorithm for transparency
 
 axis color <r> <g> <b>
@@ -73 +76 @@
 contour2d opacity <val> <?datasetName?>
 contour2d visible <bool> <?datasetName?>
+
+contour3d add numcontours <n> <?datasetName?>
+          Generate evenly spaced contours including range endpoints.  See also
+          'dataset maprange' command.
+contour3d add contourlist <list> <?datasetName?>
+          list = {isoval1 isoval2 isoval3...}
+contour3d color r g b <?datasetName?>
+contour3d colormap <colorMapName> <?dataSetName?>
+contour3d delete <?datasetName?>
+contour3d edges <bool> <?datasetName?>
+contour3d lighting <bool> <?datasetName?>
+contour3d linecolor <r> <g> <b> <?datasetName?>
+contour3d linewidth <val> <?datasetName?>
+contour3d opacity <val> <?datasetName?>
+contour3d visible <bool> <?datasetName?>
+contour3d wireframe <bool> <?datasetName?>
 
 glyphs add <?dataSetName?>