Changeset 2260 for trunk/packages/vizservers

Timestamp:

May 24, 2011 5:19:52 PM (13 years ago)

Author:

ldelgass

Message:

New heightmap command/object in vtkvis server - contour plot with vertical
displacement. Also initial work on supporting additional data set types
such as point clouds.

Location:

trunk/packages/vizservers/vtkvis

Files:

• Makefile.in (modified) (4 diffs)
• PPMWriter.cpp (modified) (1 diff)
• RpContour2D.cpp (modified) (5 diffs)
• RpContour2D.h (modified) (1 diff)
• RpHeightMap.cpp (added)
• RpHeightMap.h (added)
• RpPolyData.cpp (modified) (4 diffs)
• RpPolyData.h (modified) (1 diff)
• RpPseudoColor.cpp (modified) (4 diffs)
• RpPseudoColor.h (modified) (1 diff)
• RpVtkDataSet.cpp (modified) (4 diffs)
• RpVtkDataSet.h (modified) (1 diff)
• RpVtkRenderServer.cpp (modified) (4 diffs)
• RpVtkRenderer.cpp (modified) (35 diffs)
• RpVtkRenderer.h (modified) (4 diffs)
• RpVtkRendererCmd.cpp (modified) (3 diffs)
• TGAWriter.cpp (modified) (5 diffs)
• TGAWriter.h (modified) (1 diff)
• protocol.txt (modified) (1 diff)

trunk/packages/vizservers/vtkvis/Makefile.in

@@ -23 +23 @@
 MKDIR_P         = @MKDIR_P@
 
+GL_LIB_SPEC     = -lGL
+
 TCL_LIB_SPEC    = @TCL_LIB_SPEC@
 TCL_INC_SPEC    = @TCL_INC_SPEC@
@@ -33 +35 @@
 
 LIBS            = \
+                $(GL_LIB_SPEC) \
                 $(TCL_LIB_SPEC) \
                 $(VTK_LIB_SPEC) \
@@ -69 +72 @@
                 PPMWriter.cpp \
                 RpContour2D.cpp \
+                RpHeightMap.cpp \
                 RpPolyData.cpp \
                 RpPseudoColor.cpp \
@@ -117 +121 @@
 RpContour2D.o: RpContour2D.h RpVtkDataSet.h Trace.h
 RpPolyData.o: RpPolyData.h RpVtkDataSet.h Trace.h
+RpHeightMap.o: RpHeightMap.h RpVtkDataSet.h Trace.h
 RpPseudoColor.o: RpPseudoColor.h RpVtkDataSet.h Trace.h
 RpVtkDataSet.o: RpVtkDataSet.h Trace.h
 RpVtkRenderer.o: RpVtkRenderer.h RpVtkDataSet.h RpPolyData.h RpPseudoColor.h RpContour2D.h ColorMap.h Trace.h
-RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h ColorMap.h
-RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h
+RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h CmdProc.h ColorMap.h PPMWriter.h TGAWriter.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h PPMWriter.h TGAWriter.h
 Trace.o: Trace.h
 TGAWriter.o: TGAWriter.h Trace.h

trunk/packages/vizservers/vtkvis/PPMWriter.cpp

@@ -31 +31 @@
  * routine could be made even simpler (faster) if the image data had top 
  * to bottom scanlines.
+ *
+ * \param[in] fd File descriptor that will be written to
+ * \param[in] cmdName Command name to send (byte length will be appended)
+ * \param[in] data Image data
+ * \param[in] width Width of image in pixels
+ * \param[in] height Height of image in pixels
  */
 void

trunk/packages/vizservers/vtkvis/RpContour2D.cpp

@@ -6 +6 @@
  */
 
+#include <cassert>
+
 #include <vtkContourFilter.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkUnstructuredGrid.h>
 #include <vtkProperty.h>
+#include <vtkPointData.h>
+#include <vtkDelaunay2D.h>
+#include <vtkDelaunay3D.h>
+#include <vtkDataSetSurfaceFilter.h>
 
 #include "RpContour2D.h"
@@ -68 +75 @@
  * \brief Get the VTK Actor for the contour lines
  */
-vtkActor *Contour2D::getActor()
+vtkProp *Contour2D::getActor()
 {
     return _contourActor;
@@ -96 +103 @@
         return;
     }
+    vtkDataSet *ds = _dataSet->getVtkDataSet();
 
     initActor();
@@ -103 +111 @@
         _contourFilter = vtkSmartPointer<vtkContourFilter>::New();
     }
-
-    _contourFilter->SetInput(_dataSet->getVtkDataSet());
+ 
+    vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
+    if (pd) {
+        // DataSet is a vtkPolyData
+        if (pd->GetNumberOfLines() == 0 &&
+            pd->GetNumberOfPolys() == 0 &&
+            pd->GetNumberOfStrips() == 0) {
+            // DataSet is a point cloud
+            if (_dataSet->is2D()) {
+                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
+                mesher->SetInput(pd);
+                pd = mesher->GetOutput();
+                assert(pd);
+                _contourFilter->SetInput(pd);
+            } else {
+                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
+                mesher->SetInput(pd);
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->SetInput(mesher->GetOutput());
+                gf->Update();
+                pd = gf->GetOutput();
+                assert(pd);
+                _contourFilter->SetInput(pd);
+             }
+        } else {
+            // DataSet is a vtkPolyData with lines and/or polygons
+            _contourFilter->SetInput(ds);
+        }
+    } else {
+        TRACE("Generating surface for data set");
+        // DataSet is NOT a vtkPolyData
+        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+        gf->SetInput(ds);
+        gf->Update();
+        pd = gf->GetOutput();
+        assert(pd);
+        _contourFilter->SetInput(pd);
+    }
 
     _contourFilter->ComputeNormalsOff();
@@ -130 +174 @@
         _contourMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
         _contourMapper->SetResolveCoincidentTopologyToPolygonOffset();
+        _contourMapper->SetInput(_contourFilter->GetOutput());
         _contourActor->SetMapper(_contourMapper);
-        _contourMapper->SetInput(_contourFilter->GetOutput());
     }
 }

trunk/packages/vizservers/vtkvis/RpContour2D.h

@@ -34 +34 @@
     DataSet *getDataSet();
 
-    vtkActor *getActor();
+    vtkProp *getActor();
 
     void setContours(int numContours);

trunk/packages/vizservers/vtkvis/RpPolyData.cpp

@@ -6 +6 @@
  */
 
+#include <cassert>
+
 #include <vtkDataSet.h>
 #include <vtkPolyData.h>
+#include <vtkDataSetMapper.h>
+#include <vtkUnstructuredGrid.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
 #include <vtkProperty.h>
+#include <vtkDelaunay2D.h>
+#include <vtkDelaunay3D.h>
 
 #include "RpPolyData.h"
@@ -44 +50 @@
  * \brief Get the VTK Actor for the mesh
  */
-vtkActor *PolyData::getActor()
+vtkProp *PolyData::getActor()
 {
     return _pdActor;
@@ -78 +84 @@
             ERROR("DataSet is not a PolyData");
             return;
+        } else {
+            TRACE("DataSet is a vtkPolyData");
+            vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
+            assert(pd);
+            TRACE("Verts: %d Lines: %d Polys: %d Strips: %d",
+                  pd->GetNumberOfVerts(),
+                  pd->GetNumberOfLines(),
+                  pd->GetNumberOfPolys(),
+                  pd->GetNumberOfStrips());
         }
-        TRACE("DataSet is a vtkPolyData");
         _dataSet = dataSet;
         update();
@@ -111 +125 @@
     _pdActor->SetMapper(_pdMapper);
 
-    _pdMapper->SetInput(vtkPolyData::SafeDownCast(_dataSet->getVtkDataSet()));
+    vtkPolyData *pd = vtkPolyData::SafeDownCast(_dataSet->getVtkDataSet());
+    assert(pd);
+
+    if (pd->GetNumberOfLines() == 0 &&
+        pd->GetNumberOfPolys() == 0 &&
+        pd->GetNumberOfStrips() == 0) {
+        // Point cloud
+        if (_dataSet->is2D()) {
+            vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
+            mesher->SetInput(pd);
+            _pdMapper->SetInput(mesher->GetOutput());
+        } else {
+            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
+            mesher->SetInput(pd);
+            // Delaunay3D returns an UnstructuredGrid, so feed it through a generic mapper
+            // to get the grid boundary as a PolyData
+            vtkSmartPointer<vtkDataSetMapper> dsMapper =  vtkSmartPointer<vtkDataSetMapper>::New();
+            dsMapper->SetInput(mesher->GetOutput());
+            dsMapper->StaticOn();
+            _pdMapper = dsMapper->GetPolyDataMapper();
+            _pdMapper->SetResolveCoincidentTopologyToPolygonOffset();
+            _pdMapper->ScalarVisibilityOff();
+        }
+    } else {
+        _pdMapper->SetInput(pd);
+        _pdMapper->StaticOn();
+    }
 }
 

trunk/packages/vizservers/vtkvis/RpPolyData.h

@@ -32 +32 @@
     DataSet *getDataSet();
 
-    vtkActor *getActor();
+    vtkProp *getActor();
 
     void setVisibility(bool state);

trunk/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -6 +6 @@
  */
 
+#include <cassert>
+
 #include <vtkDataSet.h>
 #include <vtkDataSetMapper.h>
+#include <vtkUnstructuredGrid.h>
 #include <vtkProperty.h>
 #include <vtkPointData.h>
+#include <vtkImageData.h>
 #include <vtkLookupTable.h>
+#include <vtkDelaunay2D.h>
+#include <vtkDelaunay3D.h>
+#include <vtkGaussianSplatter.h>
+#include <vtkExtractVOI.h>
+#include <vtkDataSetSurfaceFilter.h>
 
 #include "RpPseudoColor.h"
@@ -44 +53 @@
 void PseudoColor::setDataSet(DataSet *dataSet)
 {
-    _dataSet = dataSet;
-    update();
+    if (_dataSet != dataSet) {
+        _dataSet = dataSet;
+        update();
+    }
 }
 
@@ -73 +84 @@
         _dsMapper = vtkSmartPointer<vtkDataSetMapper>::New();
     }
-    _dsMapper->SetInput(ds);
-    _dsMapper->StaticOff();
+
+    vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
+    if (pd) {
+        // DataSet is a vtkPolyData
+        if (pd->GetNumberOfLines() == 0 &&
+            pd->GetNumberOfPolys() == 0 &&
+            pd->GetNumberOfStrips() == 0) {
+            // DataSet is a point cloud
+            if (_dataSet->is2D()) {
+#if 0
+                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
+                mesher->SetInput(pd);
+                pd = mesher->GetOutput();
+#else
+                vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
+                splatter->SetInput(pd);
+                int dims[3];
+                splatter->GetSampleDimensions(dims);
+                TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
+                dims[2] = 3;
+                splatter->SetSampleDimensions(dims);
+                double bounds[6];
+                splatter->Update();
+                splatter->GetModelBounds(bounds);
+                TRACE("Model bounds: %g %g %g %g %g %g",
+                      bounds[0], bounds[1],
+                      bounds[2], bounds[3],
+                      bounds[4], bounds[5]);
+                vtkSmartPointer<vtkExtractVOI> slicer = vtkSmartPointer<vtkExtractVOI>::New();
+                slicer->SetInput(splatter->GetOutput());
+                slicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, 1, 1);
+                slicer->SetSampleRate(1, 1, 1);
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->SetInput(slicer->GetOutput());
+                gf->Update();
+                pd = gf->GetOutput();
+#endif
+                assert(pd);
+                _dsMapper->SetInput(pd);
+            } else {
+                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
+                mesher->SetInput(pd);
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->SetInput(mesher->GetOutput());
+                gf->Update();
+                pd = gf->GetOutput();
+                assert(pd);
+                _dsMapper->SetInput(pd);
+             }
+        } else {
+            // DataSet is a vtkPolyData with lines and/or polygons
+            _dsMapper->SetInput(ds);
+        }
+    } else {
+        TRACE("Generating surface for data set");
+        // DataSet is NOT a vtkPolyData
+        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+        gf->SetInput(ds);
+        gf->Update();
+        pd = gf->GetOutput();
+        assert(pd);
+        _dsMapper->SetInput(pd);
+    }
+
+    //_dsMapper->StaticOn();
 
     if (ds->GetPointData() == NULL ||
@@ -106 +180 @@
  * \brief Get the VTK Actor for the colormapped dataset
  */
-vtkActor *PseudoColor::getActor()
+vtkProp *PseudoColor::getActor()
 {
     return _dsActor;

trunk/packages/vizservers/vtkvis/RpPseudoColor.h

@@ -34 +34 @@
     DataSet *getDataSet();
 
-    vtkActor *getActor();
+    vtkProp *getActor();
 
     void setLookupTable(vtkLookupTable *lut);

trunk/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -91 +91 @@
     _dataSet->GetScalarRange(_dataRange);
 
+    TRACE("DataSet class: %s", _dataSet->GetClassName());
     TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
     return true;
@@ -96 +97 @@
 
 /**
- * \brief Read dataset using supplied reader
+ * \brief Set dataset from existing vtkDataSet object
  */
 bool DataSet::setData(vtkDataSet *ds)
@@ -105 +106 @@
     _dataSet->GetBounds(_bounds);
 
+    TRACE("DataSet class: %s", _dataSet->GetClassName());
     TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
     return true;
@@ -134 +136 @@
 
 /**
+ * \brief Get the underlying VTK DataSet subclass class name
+ */
+const char *DataSet::getVtkType()
+{
+    return _dataSet->GetClassName();
+}
+
+/**
  * \brief Get the range of scalar values in the DataSet
  */

trunk/packages/vizservers/vtkvis/RpVtkDataSet.h

@@ -41 +41 @@
     vtkDataSet *getVtkDataSet();
 
+    const char *getVtkType();
+
     void getDataRange(double minmax[2]);
 

trunk/packages/vizservers/vtkvis/RpVtkRenderServer.cpp

@@ -14 +14 @@
 #include <signal.h>
 
+#ifdef WANT_TRACE
+#include <sys/time.h>
+#endif
+
 #include "Trace.h"
 #include "RpVtkRenderServer.h"
@@ -29 +33 @@
 FILE *Rappture::VtkVis::g_fLog = NULL; ///< Trace logging file handle
 Renderer *Rappture::VtkVis::g_renderer = NULL; ///< Main render worker
+
+#define ELAPSED_TIME(t1, t2) \
+    ((t1).tv_sec == (t2).tv_sec ? (((t2).tv_usec - (t1).tv_usec)/1.0e+3f) : \
+     (((t2).tv_sec - (t1).tv_sec))*1.0e+3f + (float)((t2).tv_usec - (t1).tv_usec)/1.0e+3f)
 
 static void
@@ -44 +52 @@
     }
 
+#ifdef RENDER_TARGA
     writeTGAFile("/tmp/frame.tga",
                  imgData->GetPointer(0),
                  g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight());
+                 g_renderer->getWindowHeight(),
+                 TARGA_BYTES_PER_PIXEL);
+#else
+    writeTGAFile("/tmp/frame.tga",
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight(),
+                 TARGA_BYTES_PER_PIXEL,
+                 true);
+#endif
+
 #else
     if (g_renderer->getCameraMode() == Renderer::IMAGE) {
@@ -62 +81 @@
             << xywh[1] << "} -bytes";
 
+#ifdef RENDER_TARGA
+        writeTGA(fd, oss.str().c_str(),
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight(),
+                 TARGA_BYTES_PER_PIXEL);
+#else
         writePPM(fd, oss.str().c_str(),
                  imgData->GetPointer(0),
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
+#endif
     } else {
+#ifdef RENDER_TARGA
+        writeTGA(fd, "nv>image -type image -bytes",
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight(),
+                 TARGA_BYTES_PER_PIXEL);
+#else
         writePPM(fd, "nv>image -type image -bytes",
                  imgData->GetPointer(0),
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
+#endif
     }
 #endif

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -9 +9 @@
 #include <cstring>
 #include <cassert>
+
+#include <GL/gl.h>
+
+#ifdef WANT_TRACE
+#include <sys/time.h>
+#endif
 
 #include <vtkMath.h>
@@ -31 +37 @@
 #include <vtkLookupTable.h>
 #include <vtkTextProperty.h>
+#include <vtkOpenGLRenderWindow.h>
 
 #include "RpVtkRenderer.h"
 #include "ColorMap.h"
 #include "Trace.h"
+
+#define ELAPSED_TIME(t1, t2) \
+    ((t1).tv_sec == (t2).tv_sec ? (((t2).tv_usec - (t1).tv_usec)/1.0e+3f) : \
+     (((t2).tv_sec - (t1).tv_sec))*1.0e+3f + (float)((t2).tv_usec - (t1).tv_usec)/1.0e+3f)
 
 using namespace Rappture::VtkVis;
@@ -44 +55 @@
     _cameraZoomRatio(1),
     _useCumulativeRange(true),
-    _cumulativeRangeOnlyVisible(false)
+    _cumulativeRangeOnlyVisible(false),
+    _cameraMode(PERSPECTIVE)
 {
     _bgColor[0] = 0;
@@ -77 +89 @@
     _renderer = vtkSmartPointer<vtkRenderer>::New();
     _renderer->LightFollowCameraOn();
-    _cameraMode = PERSPECTIVE;
     initAxes();
     initCamera();
@@ -85 +96 @@
     _renderWindow->DoubleBufferOff();
     _renderWindow->OffScreenRenderingOn();
+#else
+    _renderWindow->SwapBuffersOff();
 #endif
     _renderWindow->SetSize(_windowWidth, _windowHeight);
@@ -108 +121 @@
     }
     _contours.clear();
+    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
+             itr != _heightMaps.end(); ++itr) {
+        delete itr->second;
+    }
+    _heightMaps.clear();
     for (PolyDataHashmap::iterator itr = _polyDatas.begin();
              itr != _polyDatas.end(); ++itr) {
@@ -163 +181 @@
         PseudoColor *ps = itr->second;
         if (ps->getActor())
-            _renderer->RemoveActor(ps->getActor());
+            _renderer->RemoveViewProp(ps->getActor());
         delete ps;
 
@@ -199 +217 @@
         Contour2D *contour = itr->second;
         if (contour->getActor())
-            _renderer->RemoveActor(contour->getActor());
+            _renderer->RemoveViewProp(contour->getActor());
         delete contour;
 
@@ -209 +227 @@
 
 /**
+ * \brief Remove the HeightMap for the specified DataSet
+ *
+ * The underlying HeightMap is deleted, freeing its memory
+ */
+void Renderer::deleteHeightMap(const DataSetId& id)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting HeightMaps for %s", id.c_str());
+
+    do {
+        HeightMap *hmap = itr->second;
+        if (hmap->getActor())
+            _renderer->RemoveViewProp(hmap->getActor());
+        delete hmap;
+
+        _heightMaps.erase(itr);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Remove the PolyData mesh for the specified DataSet
  *
@@ -235 +289 @@
         PolyData *polyData = itr->second;
         if (polyData->getActor())
-            _renderer->RemoveActor(polyData->getActor());
+            _renderer->RemoveViewProp(polyData->getActor());
         delete polyData;
 
@@ -247 +301 @@
  * \brief Remove the specified DataSet and associated rendering objects
  *
- * The underlying DataSet and any associated Contour2D and PseudoColor
+ * The underlying DataSet and any associated graphics 
  * objects are deleted, freeing the memory used.
  */
@@ -272 +326 @@
         deletePseudoColor(itr->second->getName());
         deleteContour2D(itr->second->getName());
+        deleteHeightMap(itr->second->getName());
         deletePolyData(itr->second->getName());
     
@@ -359 +414 @@
         if (_renderer->HasViewProp(_cubeAxesActor)) {
             TRACE("Removing 3D axes");
-            _renderer->RemoveActor(_cubeAxesActor);
+            _renderer->RemoveViewProp(_cubeAxesActor);
         }
         if (!_renderer->HasViewProp(_cubeAxesActor2D)) {
             TRACE("Adding 2D axes");
-            _renderer->AddActor(_cubeAxesActor2D);
+            _renderer->AddViewProp(_cubeAxesActor2D);
         }
     } else {
         if (_renderer->HasViewProp(_cubeAxesActor2D)) {
             TRACE("Removing 2D axes");
-            _renderer->RemoveActor(_cubeAxesActor2D);
+            _renderer->RemoveViewProp(_cubeAxesActor2D);
         }
         if (!_renderer->HasViewProp(_cubeAxesActor)) {
             TRACE("Adding 3D axes");
-            _renderer->AddActor(_cubeAxesActor);
+            _renderer->AddViewProp(_cubeAxesActor);
         }
         double bounds[6];
@@ -442 +497 @@
     if (_cameraMode == IMAGE) {
         if (!_renderer->HasViewProp(_cubeAxesActor2D))
-            _renderer->AddActor(_cubeAxesActor2D);
+            _renderer->AddViewProp(_cubeAxesActor2D);
     } else {
         if (!_renderer->HasViewProp(_cubeAxesActor))
-            _renderer->AddActor(_cubeAxesActor);
+            _renderer->AddViewProp(_cubeAxesActor);
     }
 }
@@ -724 +779 @@
         _scalarBarActor = vtkSmartPointer<vtkScalarBarActor>::New();
         _scalarBarActor->UseOpacityOn();
-        _legendRenderer->AddActor(_scalarBarActor);
+        _legendRenderer->AddViewProp(_scalarBarActor);
     }
 
@@ -762 +817 @@
     _legendRenderWindow->Render();
 
+#ifdef RENDER_TARGA
+    _legendRenderWindow->MakeCurrent();
+    // Must clear previous errors first.
+    while (glGetError() != GL_NO_ERROR){
+        ;
+    }
+    int bytesPerPixel = TARGA_BYTES_PER_PIXEL;
+    int size = bytesPerPixel * width * height;
+
+    if (imgData->GetMaxId() + 1 != size)
+    {
+        imgData->SetNumberOfComponents(bytesPerPixel);
+        imgData->SetNumberOfValues(size);
+    }
+    glDisable(GL_TEXTURE_2D);
+    glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_renderWindow)->GetFrontLeftBuffer()));
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    if (bytesPerPixel == 4) {
+        glReadPixels(0, 0, width, height, GL_BGRA,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    } else {
+        glReadPixels(0, 0, width, height, GL_BGR,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    }
+    if (glGetError() != GL_NO_ERROR) {
+        ERROR("glReadPixels");
+    }
+#else
     _legendRenderWindow->GetPixelData(0, 0, width-1, height-1,
                                       !_legendRenderWindow->GetDoubleBuffer(),
                                       imgData);
+#endif
     return true;
 }
@@ -814 +898 @@
         pc->setLookupTable(lut);
 
-        _renderer->AddActor(pc->getActor());
+        _renderer->AddViewProp(pc->getActor());
     } while (doAll && ++itr != _dataSets.end());
 
@@ -1106 +1190 @@
         contour->setDataSet(ds);
 
-        _renderer->AddActor(contour->getActor());
+        _renderer->AddViewProp(contour->getActor());
     } while (doAll && ++itr != _dataSets.end());
 
@@ -1323 +1407 @@
 
 /**
+ * \brief Create a new HeightMap and associate it with the named DataSet
+ */
+void Renderer::addHeightMap(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 (getHeightMap(dsID)) {
+            WARN("Replacing existing HeightMap %s", dsID.c_str());
+            deleteHeightMap(dsID);
+        }
+
+        HeightMap *hmap = new HeightMap();
+        _heightMaps[dsID] = hmap;
+
+        hmap->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);
+        }
+
+        hmap->setLookupTable(lut);
+
+        _renderer->AddViewProp(hmap->getActor());
+    } while (doAll && ++itr != _dataSets.end());
+
+    initCamera();
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Get the HeightMap associated with a named DataSet
+ */
+HeightMap *Renderer::getHeightMap(const DataSetId& id)
+{
+    HeightMapHashmap::iterator itr = _heightMaps.find(id);
+
+    if (itr == _heightMaps.end()) {
+        TRACE("HeightMap not found: %s", id.c_str());
+        return NULL;
+    } else
+        return itr->second;
+}
+
+/**
+ * \brief Set the volume slice used for mapping volumetric data
+ */
+void Renderer::setHeightMapVolumeSlice(const DataSetId& id, HeightMap::Axis axis, double ratio)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->selectVolumeSlice(axis, ratio);
+     } while (doAll && ++itr != _heightMaps.end());
+
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set amount to scale scalar values when creating elevations
+ * in the height map
+ */
+void Renderer::setHeightMapHeightScale(const DataSetId& id, double scale)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setHeightScale(scale);
+     } while (doAll && ++itr != _heightMaps.end());
+
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Associate an existing named color map with a DataSet
+ */
+void Renderer::setHeightMapColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap 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 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 != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Get the height map's color map (vtkLookupTable) for the given DataSet
+ *
+ * \return The associated lookup table or NULL if not found
+ */
+vtkLookupTable *Renderer::getHeightMapColorMap(const DataSetId& id)
+{
+    HeightMap *hm = getHeightMap(id);
+    if (hm)
+        return hm->getLookupTable();
+    else
+        return NULL;
+}
+
+/**
+ * \brief Set the number of equally spaced contour isolines for the given DataSet
+ */
+void Renderer::setHeightMapContours(const DataSetId& id, int numContours)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        if (_useCumulativeRange) {
+            itr->second->setContours(numContours, _cumulativeDataRange);
+        } else {
+            itr->second->setContours(numContours);
+        }
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set a list of height map contour isovalues for the given DataSet
+ */
+void Renderer::setHeightMapContourList(const DataSetId& id, const std::vector<double>& contours)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourList(contours);
+    } while (doAll && ++itr != _heightMaps.end());
+
+     _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of height map for the given DataSet
+ */
+void Renderer::setHeightMapOpacity(const DataSetId& id, double opacity)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering height map for the given DataSet
+ */
+void Renderer::setHeightMapVisibility(const DataSetId& id, bool state)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering height map mesh edges for the given DataSet
+ */
+void Renderer::setHeightMapEdgeVisibility(const DataSetId& id, bool state)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB height map mesh edge color for the specified DataSet
+ */
+void Renderer::setHeightMapEdgeColor(const DataSetId& id, float color[3])
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the height map mesh 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::setHeightMapEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering height map contour lines for the given DataSet
+ */
+void Renderer::setHeightMapContourVisibility(const DataSetId& id, bool state)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourVisibility(state);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB height map isoline color for the specified DataSet
+ */
+void Renderer::setHeightMapContourEdgeColor(const DataSetId& id, float color[3])
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourEdgeColor(color);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the height map isoline 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::setHeightMapContourEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn height map lighting on/off for the specified DataSet
+ */
+void Renderer::setHeightMapLighting(const DataSetId& id, bool state)
+{
+    HeightMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _heightMaps.begin();
+        doAll = true;
+    } else {
+        itr = _heightMaps.find(id);
+    }
+    if (itr == _heightMaps.end()) {
+        ERROR("HeightMap not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _heightMaps.end());
+    _needsRedraw = true;
+}
+
+/**
  * \brief Create a new PolyData and associate it with the named DataSet
  */
@@ -1355 +1940 @@
         polyData->setDataSet(ds);
 
-        _renderer->AddActor(polyData->getActor());
+        _renderer->AddViewProp(polyData->getActor());
     } while (doAll && ++itr != _dataSets.end());
 
@@ -1601 +2186 @@
 void Renderer::setWindowSize(int width, int height)
 {
+    // FIXME: Fix up panning on aspect change
+#ifdef notdef
+    if (_cameraPan[0] != 0.0) {
+        _cameraPan[0] *= ((double)_windowWidth / width);
+    }
+    if (_cameraPan[1] != 0.0) {
+        _cameraPan[1] *= ((double)_windowHeight / height);
+    }
+#endif
     _windowWidth = width;
     _windowHeight = height;
@@ -1676 +2270 @@
 void Renderer::setCameraOrientation(double quat[4])
 {
+    if (_cameraMode == IMAGE)
+        return;
     vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
@@ -1713 +2309 @@
         panCamera(panx, pany, true);
     }
+    _renderer->ResetCameraClippingRange();
     printCameraInfo(camera);
     _needsRedraw = true;
@@ -1905 +2502 @@
                               focalDepth, 
                               oldPickPoint);
- 
+
         // Camera motion is reversed
         motionVector[0] = oldPickPoint[0] - newPickPoint[0];
@@ -2176 +2773 @@
                            const double *bounds1, const double *bounds2)
 {
+    assert(boundsDest != NULL);
+    assert(bounds1 != NULL);
+    if (bounds2 == NULL) {
+        WARN("NULL bounds2 array");
+        return;
+    }
     for (int i = 0; i < 6; i++) {
         if (i % 2 == 0)
@@ -2206 +2809 @@
     for (Contour2DHashmap::iterator itr = _contours.begin();
              itr != _contours.end(); ++itr) {
+        if (!onlyVisible || itr->second->getVisibility())
+            mergeBounds(bounds, bounds, itr->second->getActor()->GetBounds());
+    }
+    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
+             itr != _heightMaps.end(); ++itr) {
         if (!onlyVisible || itr->second->getVisibility())
             mergeBounds(bounds, bounds, itr->second->getActor()->GetBounds());
@@ -2223 +2831 @@
         }
     }
+    TRACE("Bounds: %g %g %g %g %g %g",
+          bounds[0],
+          bounds[1],
+          bounds[2],
+          bounds[3],
+          bounds[4],
+          bounds[5]);
 }
 
@@ -2258 +2873 @@
         }
     }
+    for (HeightMapHashmap::iterator itr = _heightMaps.begin();
+         itr != _heightMaps.end(); ++itr) {
+        vtkLookupTable *lut = itr->second->getLookupTable();
+        if (lut) {
+            if (useCumulative) {
+                lut->SetRange(_cumulativeDataRange);
+            } else {
+                double range[2];
+                if (itr->second->getDataSet()) {
+                    itr->second->getDataSet()->getDataRange(range);
+                    lut->SetRange(range);
+                }
+            }
+        }
+        // Only need to update contour 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());
+            }
+        }
+    }
 }
 
@@ -2286 +2924 @@
 }
 
-#ifdef notdef
-void Renderer::setPerspectiveCameraByBounds(double bounds[6])
-{
-    vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
-    camera->ParallelProjectionOff();
-    camera->Reset();
-}
+/**
+ * \brief Initialize the camera zoom region to include the bounding volume given
+ */
+void Renderer::initCamera()
+{
+#ifdef WANT_TRACE
+    switch (_cameraMode) {
+    case IMAGE:
+        TRACE("Image camera");
+        break;
+    case ORTHO:
+        TRACE("Ortho camera");
+        break;
+    case PERSPECTIVE:
+        TRACE("Perspective camera");
+        break;
+    default:
+        TRACE("Unknown camera mode");
+    }
 #endif
-
-/**
- * \brief Initialize the camera zoom region to include the bounding volume given
- */
-void Renderer::initCamera()
-{
     double bounds[6];
     collectBounds(bounds, false);
@@ -2310 +2954 @@
     _cameraZoomRatio = 1;
 
-    if (_cameraMode == IMAGE) {
+    switch (_cameraMode) {
+    case IMAGE:
         _renderer->ResetCamera(bounds);
         setCameraZoomRegion(_imgWorldOrigin[0], _imgWorldOrigin[1],
                             _imgWorldDims[0], _imgWorldDims[1]);
         resetAxes();
-    } else if (_cameraMode == ORTHO) {
+        break;
+    case ORTHO:
         _renderer->GetActiveCamera()->ParallelProjectionOn();
         resetAxes();
         _renderer->ResetCamera(bounds);
         computeScreenWorldCoords();
-    } else if (_cameraMode == PERSPECTIVE) {
+        break;
+    case PERSPECTIVE:
         _renderer->GetActiveCamera()->ParallelProjectionOff();
         resetAxes();
         _renderer->ResetCamera(bounds);
         computeScreenWorldCoords();
-    }
+        break;
+    default:
+        ERROR("Unknown camera mode");
+    }
+#ifdef WANT_TRACE
+    printCameraInfo(_renderer->GetActiveCamera());
+#endif
 }
 
@@ -2370 +3023 @@
     if (id.compare("all") == 0 || getContour2D(id) != NULL)
         setContourOpacity(id, opacity);
+    if (id.compare("all") == 0 || getHeightMap(id) != NULL)
+        setHeightMapOpacity(id, opacity);
     if (id.compare("all") == 0 || getPolyData(id) != NULL)
         setPolyDataOpacity(id, opacity);
@@ -2402 +3057 @@
     if (id.compare("all") == 0 || getContour2D(id) != NULL)
         setContourVisibility(id, state);
+    if (id.compare("all") == 0 || getHeightMap(id) != NULL)
+        setHeightMapVisibility(id, state);
     if (id.compare("all") == 0 || getPolyData(id) != NULL)
         setPolyDataVisibility(id, state);
@@ -2422 +3079 @@
             for (Contour2DHashmap::iterator itr = _contours.begin();
                  itr != _contours.end(); ++itr) {
+                itr->second->setClippingPlanes(_clippingPlanes);
+            }
+            for (HeightMapHashmap::iterator itr = _heightMaps.begin();
+                 itr != _heightMaps.end(); ++itr) {
                 itr->second->setClippingPlanes(_clippingPlanes);
             }
@@ -2437 +3098 @@
                 itr->second->setClippingPlanes(NULL);
             }
+            for (HeightMapHashmap::iterator itr = _heightMaps.begin();
+                 itr != _heightMaps.end(); ++itr) {
+                itr->second->setClippingPlanes(NULL);
+            }
             for (PolyDataHashmap::iterator itr = _polyDatas.begin();
                  itr != _polyDatas.end(); ++itr) {
@@ -2466 +3131 @@
 void Renderer::getRenderedFrame(vtkUnsignedCharArray *imgData)
 {
+#ifdef RENDER_TARGA
+    _renderWindow->MakeCurrent();
+    // Must clear previous errors first.
+    while (glGetError() != GL_NO_ERROR){
+        ;
+    }
+    int bytesPerPixel = TARGA_BYTES_PER_PIXEL;
+    int size = bytesPerPixel * _windowWidth * _windowHeight;
+
+    if (imgData->GetMaxId() + 1 != size)
+    {
+        imgData->SetNumberOfComponents(bytesPerPixel);
+        imgData->SetNumberOfValues(size);
+    }
+    glDisable(GL_TEXTURE_2D);
+    if (_renderWindow->GetDoubleBuffer()) {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_renderWindow)->GetBackLeftBuffer()));
+    } else {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_renderWindow)->GetFrontLeftBuffer()));
+    }
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+#ifdef WANT_TRACE
+    struct timeval t1, t2;
+    glFinish();
+    gettimeofday(&t1, 0);
+#endif
+    if (bytesPerPixel == 4) {
+        glReadPixels(0, 0, _windowWidth, _windowHeight, GL_BGRA,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    } else {
+        glReadPixels(0, 0, _windowWidth, _windowHeight, GL_BGR,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    }
+#ifdef WANT_TRACE
+    gettimeofday(&t2, 0);
+    static unsigned int numFrames = 0;
+    static double accum = 0;
+    numFrames++;
+    accum += ELAPSED_TIME(t1, t2);
+#endif
+    TRACE("Readback time: %g ms", ELAPSED_TIME(t1, t2));
+    TRACE("Readback avg: %g ms", accum/numFrames);
+    if (glGetError() != GL_NO_ERROR) {
+        ERROR("glReadPixels");
+    }
+#else
     _renderWindow->GetPixelData(0, 0, _windowWidth-1, _windowHeight-1,
                                 !_renderWindow->GetDoubleBuffer(), imgData);
+#endif
     TRACE("Image data size: %d", imgData->GetSize());
 }

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -30 +30 @@
 #include "RpPseudoColor.h"
 #include "RpContour2D.h"
+#include "RpHeightMap.h"
 #include "RpPolyData.h"
+#include "Trace.h"
+
+// Controls if TGA format is sent to client
+//#define RENDER_TARGA
+#define TARGA_BYTES_PER_PIXEL 3
 
 namespace Rappture {
@@ -70 +76 @@
     typedef std::tr1::unordered_map<DataSetId, PseudoColor *> PseudoColorHashmap;
     typedef std::tr1::unordered_map<DataSetId, Contour2D *> Contour2DHashmap;
+    typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
     typedef std::tr1::unordered_map<DataSetId, PolyData *> PolyDataHashmap;
 
@@ -217 +224 @@
 
     void setContourLighting(const DataSetId& id, bool state);
+
+    // Height maps
+
+    void addHeightMap(const DataSetId& id);
+
+    void deleteHeightMap(const DataSetId& id);
+
+    HeightMap *getHeightMap(const DataSetId& id);
+
+    void setHeightMapVolumeSlice(const DataSetId& id, HeightMap::Axis axis, double ratio);
+
+    void setHeightMapHeightScale(const DataSetId& id, double scale);
+
+    void setHeightMapColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    vtkLookupTable *getHeightMapColorMap(const DataSetId& id);
+
+    void setHeightMapContours(const DataSetId& id, int numContours);
+
+    void setHeightMapContourList(const DataSetId& id, const std::vector<double>& contours);
+
+    void setHeightMapOpacity(const DataSetId& id, double opacity);
+
+    void setHeightMapVisibility(const DataSetId& id, bool state);
+
+    void setHeightMapEdgeVisibility(const DataSetId& id, bool state);
+
+    void setHeightMapEdgeColor(const DataSetId& id, float color[3]);
+
+    void setHeightMapEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setHeightMapContourVisibility(const DataSetId& id, bool state);
+
+    void setHeightMapContourEdgeColor(const DataSetId& id, float color[3]);
+
+    void setHeightMapContourEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setHeightMapLighting(const DataSetId& id, bool state);
 
     // Meshes
@@ -291 +336 @@
     PseudoColorHashmap _pseudoColors;
     Contour2DHashmap _contours;
+    HeightMapHashmap _heightMaps;
     PolyDataHashmap _polyDatas;
 

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -938 +938 @@
 
 static int
+HeightMapAddContourListOp(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->addHeightMap(name);
+        g_renderer->setHeightMapContourList(name, contourList);
+    } else {
+        g_renderer->addHeightMap("all");
+        g_renderer->setHeightMapContourList("all", contourList);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapAddNumContoursOp(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->addHeightMap(name);
+        g_renderer->setHeightMapContours(name, numContours);
+    } else {
+        g_renderer->addHeightMap("all");
+        g_renderer->setHeightMapContours("all", numContours);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec heightmapAddOps[] = {
+    {"contourlist", 1, HeightMapAddContourListOp, 4, 5, "contourList ?dataSetName?"},
+    {"numcontours", 1, HeightMapAddNumContoursOp, 4, 5, "numContours ?dataSetName?"}
+};
+static int nHeightmapAddOps = NumCmdSpecs(heightmapAddOps);
+
+static int
+HeightMapAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nHeightmapAddOps, heightmapAddOps,
+                                  Rappture::CMDSPEC_ARG2, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+HeightMapColorMapOp(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->setHeightMapColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setHeightMapColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapContourLineColorOp(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->setHeightMapContourEdgeColor(name, color);
+    } else {
+        g_renderer->setHeightMapContourEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapContourLineWidthOp(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->setHeightMapContourEdgeWidth(name, width);
+    } else {
+        g_renderer->setHeightMapContourEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapContourVisibleOp(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->setHeightMapContourVisibility(name, state);
+    } else {
+        g_renderer->setHeightMapContourVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteHeightMap(name);
+    } else {
+        g_renderer->deleteHeightMap("all");
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapEdgeVisibilityOp(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->setHeightMapEdgeVisibility(name, state);
+    } else {
+        g_renderer->setHeightMapEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapHeightScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    double scale;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setHeightMapHeightScale(name, scale);
+    } else {
+        g_renderer->setHeightMapHeightScale("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapLightingOp(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->setHeightMapLighting(name, state);
+    } else {
+        g_renderer->setHeightMapLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapLineColorOp(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->setHeightMapEdgeColor(name, color);
+    } else {
+        g_renderer->setHeightMapEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapLineWidthOp(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->setHeightMapEdgeWidth(name, width);
+    } else {
+        g_renderer->setHeightMapEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapOpacityOp(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->setHeightMapOpacity(name, opacity);
+    } else {
+        g_renderer->setHeightMapOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapVisibleOp(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->setHeightMapVisibility(name, state);
+    } else {
+        g_renderer->setHeightMapVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapVolumeSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    double ratio;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &ratio) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    HeightMap::Axis axis;
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        axis = HeightMap::X_AXIS;
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        axis = HeightMap::Y_AXIS;
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        axis = HeightMap::Z_AXIS;
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName ratio", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setHeightMapVolumeSlice(name, axis, ratio);
+    } else {
+        g_renderer->setHeightMapVolumeSlice("all", axis, ratio);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec heightmapOps[] = {
+    {"add",          1, HeightMapAddOp, 4, 5, "oper value ?dataSetName?"},
+    {"colormap",     1, HeightMapColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete",       1, HeightMapDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges",        1, HeightMapEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"heightscale",  1, HeightMapHeightScaleOp, 3, 4, "value ?dataSetName?"},
+    {"isolinecolor", 8, HeightMapContourLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"isolines",     8, HeightMapContourVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"isolinewidth", 8, HeightMapContourLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"lighting",     3, HeightMapLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor",    5, HeightMapLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth",    5, HeightMapLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity",      1, HeightMapOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible",      2, HeightMapVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"volumeslice",  2, HeightMapVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"}
+};
+static int nHeightmapOps = NumCmdSpecs(heightmapOps);
+
+static int
+HeightMapCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nHeightmapOps, heightmapOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 LegendCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
           Tcl_Obj *const *objv)
@@ -974 +1309 @@
 
 #ifdef DEBUG
-    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height);
+    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height,
+                 TARGA_BYTES_PER_PIXEL);
 #else
     char cmd[256];
     snprintf(cmd, sizeof(cmd), "nv>legend %s", name);
+#ifdef RENDER_TARGA
+    writeTGA(g_fdOut, cmd, imgData->GetPointer(0), width, height,
+                 TARGA_BYTES_PER_PIXEL);
+#else
     writePPM(g_fdOut, cmd, imgData->GetPointer(0), width, height);
+#endif
 #endif
 
@@ -1497 +1838 @@
     Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   NULL, NULL);
     Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     NULL, NULL);
+    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   NULL, NULL);
     Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      NULL, NULL);
     Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    NULL, NULL);

trunk/packages/vizservers/vtkvis/TGAWriter.cpp

@@ -21 +21 @@
  * \brief Writes image command + data to supplied file descriptor.
  *
- * The image data must be supplied in BGR order with bottom to 
+ * The image data must be supplied in BGR(A) order with bottom to 
  * top scanline ordering.
+ *
+ * \param[in] fd File descriptor that will be written to
+ * \param[in] cmdName Command name to send (byte length will be appended)
+ * \param[in] data Image data
+ * \param[in] width Width of image in pixels
+ * \param[in] height Height of image in pixels
+ * \param[in] bytesPerPixel Should be 3 or 4, depending on alpha
  */
 void
-Rappture::VtkVis::writeTGA(int fd, const char *cmdName, const unsigned char *data,
-                           int width, int height)
+Rappture::VtkVis::writeTGA(int fd, const char *cmdName,
+                           const unsigned char *data,
+                           int width, int height,
+                           int bytesPerPixel)
 {
     TRACE("(%dx%d)\n", width, height);
@@ -39 +48 @@
     header[14] = (char)height;
     header[15] = (char)(height >> 8);
-    header[16] = (char)24; // bits per pixel
+    header[16] = (char)(bytesPerPixel*8); // bits per pixel
 
-    size_t dataLength = width * height * 3;
+    size_t dataLength = width * height * bytesPerPixel;
 
     char command[200];
-    snprintf(command, sizeof(command), "%simage -type image -bytes %lu\n", cmdName, 
+    snprintf(command, sizeof(command), "%s %lu\n", cmdName, 
              (unsigned long)headerLength + dataLength);
 
@@ -59 +68 @@
     iov[1].iov_base = header;
     iov[1].iov_len = headerLength;
-    // Image data **must be BGR!**
+    // Image data **must be BGR(A)!**
     iov[2].iov_base = const_cast<unsigned char *>(data);
     iov[2].iov_len = dataLength;
@@ -74 +83 @@
  * \brief Writes image data to supplied file name
  *
- * The image data must be supplied in BGR order with bottom to 
- * top scanline ordering.
+ * The image data must be supplied with bottom to top 
+ * scanline ordering.  Source data should have BGR(A) 
+ * ordering, unless srcIsRGB is true, in which case 
+ * the source data will be converted from RGB(A) to 
+ * BGR(A).  Note that this is slow and it is better 
+ * to pass in BGR(A) data.
+ *
+ * \param[in] filename Path to file that will be written
+ * \param[in] imgData Image data
+ * \param[in] width Width of image in pixels
+ * \param[in] height Height of image in pixels
+ * \param[in] bytesPerPixel Should be 3 or 4, depending on alpha
+ * \param[in] srcIsRGB If true source data will be re-ordered
  */
 void
-Rappture::VtkVis::writeTGAFile(const char *filename, const unsigned char *imgData,
-                               int width, int height)
+Rappture::VtkVis::writeTGAFile(const char *filename,
+                               const unsigned char *imgData,
+                               int width, int height,
+                               int bytesPerPixel,
+                               bool srcIsRGB)
 {
     TRACE("%s (%dx%d)\n", filename, width, height);
@@ -91 +114 @@
     header[14] = (char)height;
     header[15] = (char)(height >> 8);
-    header[16] = (char)24; // bits per pixel
+    header[16] = (char)(bytesPerPixel*8); // bits per pixel
 
     outfile.write(header, sizeof(header));
 
-    // RGB -> BGR
-    for (int i = 0; i < width * height; i++) {
-        outfile << imgData[i*3+2]
-                << imgData[i*3+1]
-                << imgData[i*3];
+    if (!srcIsRGB) {
+        outfile.write((const char *)imgData, width * height * bytesPerPixel);
+    } else {
+        // RGB(A) -> BGR(A)
+        for (int i = 0; i < width * height; i++) {
+            outfile << imgData[i*bytesPerPixel+2]
+                    << imgData[i*bytesPerPixel+1]
+                    << imgData[i*bytesPerPixel];
+            if (bytesPerPixel == 4) {
+                outfile << imgData[i*bytesPerPixel+3];
+            }
+        }
     }
 

trunk/packages/vizservers/vtkvis/TGAWriter.h

@@ -13 +13 @@
 
 extern
-void writeTGA(int fd, const char *cmdName, const unsigned char *data, int width, int height);
+void writeTGA(int fd, const char *cmdName, const unsigned char *data,
+              int width, int height, int bytesPerPixel);
 
 extern
-void writeTGAFile(const char *filename, const unsigned char *data, int width, int height);
+void writeTGAFile(const char *filename, const unsigned char *data,
+                  int width, int height, int bytesPerPixel,
+                  bool srcIsRGB = false);
 
 }

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -84 +84 @@
 contour2d visible <bool> <?datasetName?>
 
+heightmap add numcontours <n> <?dataSetName?>
+          Generate evenly spaced contours including range endpoints.  See also
+          'dataset maprange' command.
+heightmap add contourlist <list> <?dataSetName?>
+          list = {isoval1 isoval2 isoval3...}
+heightmap colormap <colorMapName> <?dataSetName?>
+heightmap delete <?dataSetName?>
+heightmap edges <bool> <?dataSetName?>
+heightmap heightscale <value> <?dataSetName?>
+heightmap isolinecolor <r> <g> <b> <?dataSetName?>
+heightmap isolines <bool> <?dataSetName?>
+heightmap isolinewidth <width> <?dataSetName?>
+heightmap lighting <bool> <?dataSetName?>
+heightmap linecolor <r> <g> <b> <?dataSetName?>
+heightmap linewidth <width> <?dataSetName?>
+heightmap opacity <value> <?dataSetName?>
+heightmap visible <bool> <?dataSetName?>
+heightmap volumeslice axis ratio <?dataSetName?>
+          For 3D data, select a slice along a principle axis of the volume. The
+          ratio is [0,1]
+
 polydata add <?datasetName?>
 polydata color <r> <g> <b> <?datasetName?>