Changeset 2170 for branches/blt4/packages/vizservers

Timestamp:

Mar 30, 2011, 12:34:02 PM (13 years ago)

Author:

gah

Message:

 

Location:

branches/blt4/packages/vizservers

Files:

• configure.in (modified) (1 diff)
• nanovis/scripts/.capture.swp (deleted)
• nanovis/socket/Makefile (deleted)
• vtkvis/CmdProc.cpp (modified) (5 diffs)
• vtkvis/CmdProc.h (modified) (1 diff)
• vtkvis/RpContour2D.cpp (modified) (6 diffs)
• vtkvis/RpContour2D.h (modified) (1 diff)
• vtkvis/RpPolyData.cpp (modified) (3 diffs)
• vtkvis/RpPolyData.h (modified) (1 diff)
• vtkvis/RpPseudoColor.cpp (modified) (5 diffs)
• vtkvis/RpPseudoColor.h (modified) (1 diff)
• vtkvis/RpVtkDataSet.cpp (modified) (3 diffs)
• vtkvis/RpVtkDataSet.h (modified) (2 diffs)
• vtkvis/RpVtkRenderer.cpp (modified) (54 diffs)
• vtkvis/RpVtkRenderer.h (modified) (5 diffs)
• vtkvis/RpVtkRendererCmd.cpp (modified) (36 diffs)
• vtkvis/protocol.txt (modified) (1 diff)

branches/blt4/packages/vizservers/configure.in

@@ -315 +315 @@
   LD_RPATH="$loader_run_path:${CG_DIR}/lib"
 fi
-AC_SUBST(LIBS)
+
 AC_SUBST(CG_DIR)
 AC_MSG_RESULT([${CG_DIR}])

branches/blt4/packages/vizservers/vtkvis/CmdProc.cpp

@@ -22 +22 @@
  */
 static int
-BinaryOpSearch(
-    Rappture::CmdSpec *specs, 
-    int nSpecs, 
-    char *string)       /* Name of minor operation to search for */
+BinaryOpSearch(Rappture::CmdSpec *specs, 
+               int nSpecs, 
+               char *string)       /* Name of minor operation to search for */
 {
     char c;
@@ -77 +76 @@
  */
 static int
-LinearOpSearch(
-    Rappture::CmdSpec *specs,
-    int nSpecs,
-    char *string)       /* Name of minor operation to search for */
+LinearOpSearch(Rappture::CmdSpec *specs,
+               int nSpecs,
+               char *string)       /* Name of minor operation to search for */
 {
     Rappture::CmdSpec *specPtr;
@@ -93 +91 @@
     last = -1;
     for (specPtr = specs, i = 0; i < nSpecs; i++, specPtr++) {
-    if ((c == specPtr->name[0]) && 
-        (strncmp(string, specPtr->name, length) == 0)) {
-        last = i;
-        nMatches++;
-        if ((int)length == specPtr->minChars) {
-        break;
-        }
-    }
+        if ((c == specPtr->name[0]) && 
+            (strncmp(string, specPtr->name, length) == 0)) {
+            last = i;
+            nMatches++;
+            if ((int)length == specPtr->minChars) {
+                break;
+            }
+        }
     }
     if (nMatches > 1) {
-    return -2;      /* Ambiguous operation name */
+        return -2;      /* Ambiguous operation name */
     } 
     if (nMatches == 0) {
-    return -1;      /* Can't find operation */
+        return -1;      /* Can't find operation */
     } 
     return last;        /* Op found. */
@@ -122 +120 @@
  */
 Tcl_ObjCmdProc *
-Rappture::GetOpFromObj(
-    Tcl_Interp *interp,                 /* Interpreter to report errors to */
-    int nSpecs,                         /* Number of specifications in array */
-    Rappture::CmdSpec *specs,           /* Op specification array */
-    int operPos,                        /* Position of operation in argument
-                                         * list. */
-    int objc,                           /* Number of arguments in the argument
-                                         * vector.  This includes any prefixed
-                                         * arguments */ 
-    Tcl_Obj *const *objv,               /* Argument vector */
-    int flags)
+Rappture::GetOpFromObj(Tcl_Interp *interp,              /* Interpreter to report errors to */
+                       int nSpecs,                      /* Number of specifications in array */
+                       Rappture::CmdSpec *specs,        /* Op specification array */
+                       int operPos,                     /* Position of operation in argument
+                                                         * list. */
+                       int objc,                        /* Number of arguments in the argument
+                                                         * vector.  This includes any prefixed
+                                                         * arguments */ 
+                       Tcl_Obj *const *objv,            /* Argument vector */
+                       int flags)
 {
     CmdSpec *specPtr;
@@ -139 +136 @@
 
     if (objc <= operPos) {  /* No operation argument */
-    Tcl_AppendResult(interp, "wrong # args: ", (char *)NULL);
-      usage:
-    Tcl_AppendResult(interp, "should be one of...", (char *)NULL);
-    for (n = 0; n < nSpecs; n++) {
-        int i;
-
-        Tcl_AppendResult(interp, "\n  ", (char *)NULL);
-        for (i = 0; i < operPos; i++) {
-        Tcl_AppendResult(interp, Tcl_GetString(objv[i]), " ", 
-             (char *)NULL);
-        }
-        specPtr = specs + n;
-        Tcl_AppendResult(interp, specPtr->name, " ", specPtr->usage,
-        (char *)NULL);
-    }
-    return NULL;
+        Tcl_AppendResult(interp, "wrong # args: ", (char *)NULL);
+usage:
+        Tcl_AppendResult(interp, "should be one of...", (char *)NULL);
+        for (n = 0; n < nSpecs; n++) {
+            int i;
+
+            Tcl_AppendResult(interp, "\n  ", (char *)NULL);
+            for (i = 0; i < operPos; i++) {
+                Tcl_AppendResult(interp, Tcl_GetString(objv[i]), " ", 
+                                 (char *)NULL);
+            }
+            specPtr = specs + n;
+            Tcl_AppendResult(interp, specPtr->name, " ", specPtr->usage,
+                             (char *)NULL);
+        }
+        return NULL;
     }
     string = Tcl_GetString(objv[operPos]);
     if (flags & CMDSPEC_LINEAR_SEARCH) {
-    n = LinearOpSearch(specs, nSpecs, string);
+        n = LinearOpSearch(specs, nSpecs, string);
     } else {
-    n = BinaryOpSearch(specs, nSpecs, string);
+        n = BinaryOpSearch(specs, nSpecs, string);
     }
     if (n == -2) {
-    char c;
-    size_t length;
-
-    Tcl_AppendResult(interp, "ambiguous", (char *)NULL);
-    if (operPos > 2) {
-        Tcl_AppendResult(interp, " ", Tcl_GetString(objv[operPos - 1]), 
-        (char *)NULL);
-    }
-    Tcl_AppendResult(interp, " operation \"", string, "\" matches: ",
-        (char *)NULL);
-
-    c = string[0];
-    length = strlen(string);
-    for (n = 0; n < nSpecs; n++) {
-        specPtr = specs + n;
-        if ((c == specPtr->name[0]) &&
-        (strncmp(string, specPtr->name, length) == 0)) {
-        Tcl_AppendResult(interp, " ", specPtr->name, (char *)NULL);
-        }
-    }
-    return NULL;
+        char c;
+        size_t length;
+
+        Tcl_AppendResult(interp, "ambiguous", (char *)NULL);
+        if (operPos > 2) {
+            Tcl_AppendResult(interp, " ", Tcl_GetString(objv[operPos - 1]), 
+                             (char *)NULL);
+        }
+        Tcl_AppendResult(interp, " operation \"", string, "\" matches: ",
+                         (char *)NULL);
+
+        c = string[0];
+        length = strlen(string);
+        for (n = 0; n < nSpecs; n++) {
+            specPtr = specs + n;
+            if ((c == specPtr->name[0]) &&
+                (strncmp(string, specPtr->name, length) == 0)) {
+                Tcl_AppendResult(interp, " ", specPtr->name, (char *)NULL);
+            }
+        }
+        return NULL;
 
     } else if (n == -1) {   /* Can't find operation, display help */
-    Tcl_AppendResult(interp, "bad", (char *)NULL);
-    if (operPos > 2) {
-        Tcl_AppendResult(interp, " ", Tcl_GetString(objv[operPos - 1]), 
-        (char *)NULL);
-    }
-    Tcl_AppendResult(interp, " operation \"", string, "\": ", (char *)NULL);
-    goto usage;
+        Tcl_AppendResult(interp, "bad", (char *)NULL);
+        if (operPos > 2) {
+            Tcl_AppendResult(interp, " ", Tcl_GetString(objv[operPos - 1]), 
+                             (char *)NULL);
+        }
+        Tcl_AppendResult(interp, " operation \"", string, "\": ", (char *)NULL);
+        goto usage;
     }
     specPtr = specs + n;
     if ((objc < specPtr->minArgs) || 
-    ((specPtr->maxArgs > 0) && (objc > specPtr->maxArgs))) {
-    int i;
-
-    Tcl_AppendResult(interp, "wrong # args: should be \"", (char *)NULL);
-    for (i = 0; i < operPos; i++) {
-        Tcl_AppendResult(interp, Tcl_GetString(objv[i]), " ", 
-        (char *)NULL);
-    }
-    Tcl_AppendResult(interp, specPtr->name, " ", specPtr->usage, "\"",
-        (char *)NULL);
-    return NULL;
+        ((specPtr->maxArgs > 0) && (objc > specPtr->maxArgs))) {
+        int i;
+
+        Tcl_AppendResult(interp, "wrong # args: should be \"", (char *)NULL);
+        for (i = 0; i < operPos; i++) {
+            Tcl_AppendResult(interp, Tcl_GetString(objv[i]), " ", 
+                             (char *)NULL);
+        }
+        Tcl_AppendResult(interp, specPtr->name, " ", specPtr->usage, "\"",
+                         (char *)NULL);
+        return NULL;
     }
     return specPtr->proc;

branches/blt4/packages/vizservers/vtkvis/CmdProc.h

@@ -20 +20 @@
  */
 typedef struct {
-    const char *name;           /* Name of operation */
-    int minChars;               /* Minimum # characters to disambiguate */
+    const char *name;           /**< Name of operation */
+    int minChars;               /**< Minimum # characters to disambiguate */
     Tcl_ObjCmdProc *proc;
-    int minArgs;                /* Minimum # args required */
-    int maxArgs;                /* Maximum # args required */
-    const char *usage;          /* Usage message */
+    int minArgs;                /**< Minimum # args required */
+    int maxArgs;                /**< Maximum # args required */
+    const char *usage;          /**< Usage message */
 } CmdSpec;
 
 typedef enum {
-    CMDSPEC_ARG0,               /* Op is the first argument. */
-    CMDSPEC_ARG1,               /* Op is the second argument. */
-    CMDSPEC_ARG2,               /* Op is the third argument. */
-    CMDSPEC_ARG3,               /* Op is the fourth argument. */
-    CMDSPEC_ARG4                /* Op is the fifth argument. */
+    CMDSPEC_ARG0,               /**< Op is the first argument. */
+    CMDSPEC_ARG1,               /**< Op is the second argument. */
+    CMDSPEC_ARG2,               /**< Op is the third argument. */
+    CMDSPEC_ARG3,               /**< Op is the fourth argument. */
+    CMDSPEC_ARG4                /**< Op is the fifth argument. */
 } CmdSpecIndex;
 

branches/blt4/packages/vizservers/vtkvis/RpContour2D.cpp

@@ -11 +11 @@
 
 #include "RpContour2D.h"
+#include "Trace.h"
 
 using namespace Rappture::VtkVis;
@@ -27 +28 @@
 Contour2D::~Contour2D()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting Contour2D for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting Contour2D with NULL DataSet");
+#endif
 }
 
@@ -38 +45 @@
         update();
     }
+}
+
+/**
+ * \brief Returns the DataSet this Contour2D renders
+ */
+DataSet *Contour2D::getDataSet()
+{
+    return _dataSet;
 }
 
@@ -59 +74 @@
         _contourActor->GetProperty()->SetLineWidth(_edgeWidth);
         _contourActor->GetProperty()->SetOpacity(_opacity);
+        _contourActor->GetProperty()->LightingOff();
     }
 }
@@ -76 +92 @@
     vtkSmartPointer<vtkContourFilter> contourFilter = vtkSmartPointer<vtkContourFilter>::New();
     contourFilter->SetInput(_dataSet->getVtkDataSet());
+
+    contourFilter->ComputeNormalsOff();
+    contourFilter->ComputeGradientsOff();
 
     // Speed up multiple contour computation at cost of extra memory use
@@ -193 +212 @@
 {
     if (_contourMapper != NULL) {
-        if (planes == NULL)
-            _contourMapper->RemoveAllClippingPlanes();
-        else
-            _contourMapper->SetClippingPlanes(planes);
+        _contourMapper->SetClippingPlanes(planes);
     }
 }

branches/blt4/packages/vizservers/vtkvis/RpContour2D.h

@@ -30 +30 @@
 
     void setDataSet(DataSet *dataset);
+
+    DataSet *getDataSet();
 
     vtkActor *getActor();

branches/blt4/packages/vizservers/vtkvis/RpPolyData.cpp

@@ -32 +32 @@
 PolyData::~PolyData()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting PolyData for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting PolyData with NULL DataSet");
+#endif
 }
 
@@ -79 +85 @@
 
 /**
+ * \brief Returns the DataSet this PolyData renders
+ */
+DataSet *PolyData::getDataSet()
+{
+    return _dataSet;
+}
+
+/**
  * \brief Internal method to re-compute contours after a state change
  */
@@ -201 +215 @@
 {
     if (_pdMapper != NULL) {
-        if (planes == NULL)
-            _pdMapper->RemoveAllClippingPlanes();
-        else
-            _pdMapper->SetClippingPlanes(planes);
+        _pdMapper->SetClippingPlanes(planes);
     }
 }

branches/blt4/packages/vizservers/vtkvis/RpPolyData.h

@@ -29 +29 @@
 
     void setDataSet(DataSet *dataset);
+
+    DataSet *getDataSet();
 
     vtkActor *getActor();

branches/blt4/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -29 +29 @@
 PseudoColor::~PseudoColor()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting PseudoColor for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting PseudoColor with NULL DataSet");
+#endif
 }
 
@@ -40 +46 @@
     _dataSet = dataSet;
     update();
+}
+
+/**
+ * \brief Returns the DataSet this PseudoColor renders
+ */
+DataSet *PseudoColor::getDataSet()
+{
+    return _dataSet;
 }
 
@@ -81 +95 @@
     _lut->SetRange(dataRange);
 
+    _dsMapper->UseLookupTableScalarRangeOn();
     _dsMapper->SetLookupTable(_lut);
-    _dsMapper->SetScalarRange(dataRange);
-    //_dsMapper->GetLookupTable()->SetRange(dataRange);
     //_dsMapper->InterpolateScalarsBeforeMappingOn();
 
     initActor();
     _dsActor->SetMapper(_dsMapper);
-    //_dsActor->GetProperty()->SetRepresentationToWireframe();
 }
 
@@ -149 +161 @@
     }
     if (_dsMapper != NULL) {
+        _dsMapper->UseLookupTableScalarRangeOn();
         _dsMapper->SetLookupTable(_lut);
-        if (_dataSet != NULL) {
-            _dsMapper->SetScalarRange(dataRange);
-        }
     }
 }
@@ -230 +240 @@
 {
     if (_dsMapper != NULL) {
-        if (planes == NULL)
-            _dsMapper->RemoveAllClippingPlanes();
-        else
-            _dsMapper->SetClippingPlanes(planes);
+        _dsMapper->SetClippingPlanes(planes);
     }
 }

branches/blt4/packages/vizservers/vtkvis/RpPseudoColor.h

@@ -31 +31 @@
 
     void setDataSet(DataSet *dataset);
+
+    DataSet *getDataSet();
 
     vtkActor *getActor();

branches/blt4/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -69 +69 @@
 
 /**
+ * \brief Read dataset using supplied reader
+ */
+bool DataSet::setData(vtkDataSet *ds)
+{
+    _dataSet = ds;
+    _dataSet->Update();
+    _dataSet->GetScalarRange(_dataRange);
+
+    TRACE("Scalar Range: %.12e, %.12e", _dataRange[0], _dataRange[1]);
+    return true;
+}
+
+/**
  * \brief Get the name/id of this dataset
  */
@@ -97 +110 @@
  *
  * Note: no interpolation is performed on data
+ *
+ * \return the value of the nearest point or 0 if no scalar data available
  */
 double DataSet::getDataValue(double x, double y, double z)
@@ -102 +117 @@
     if (_dataSet == NULL)
         return 0;
+    if (_dataSet->GetPointData() == NULL ||
+        _dataSet->GetPointData()->GetScalars() == NULL) {
+        return 0.0;
+    }
     vtkIdType pt = _dataSet->FindPoint(x, y, z);
     return _dataSet->GetPointData()->GetScalars()->GetComponent(pt, 0);

branches/blt4/packages/vizservers/vtkvis/RpVtkDataSet.h

@@ -29 +29 @@
     bool setData(char *data, int nbytes);
 
+    bool setData(vtkDataSet *ds);
+
+    bool setData(vtkDataSetReader *reader);
+
     bool setDataFile(const char *filename);
 
@@ -42 +46 @@
     DataSet();
 
-    bool setData(vtkDataSetReader *reader);
-
     std::string _name;
     vtkSmartPointer<vtkDataSet> _dataSet;

branches/blt4/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -30 +30 @@
 
 #include "RpVtkRenderer.h"
+#include "ColorMap.h"
 #include "Trace.h"
 
@@ -37 +38 @@
     _needsRedraw(true),
     _windowWidth(320),
-    _windowHeight(320)
+    _windowHeight(320),
+    _useCumulativeRanges(true)
 {
     _bgColor[0] = 0;
     _bgColor[1] = 0;
     _bgColor[2] = 0;
+    _cumulativeDataRange[0] = 0.0;
+    _cumulativeDataRange[1] = 1.0;
     // clipping planes to prevent overdrawing axes
     _clippingPlanes = vtkSmartPointer<vtkPlaneCollection>::New();
     // bottom
-    vtkPlane *plane0 = vtkPlane::New();
+    vtkSmartPointer<vtkPlane> plane0 = vtkSmartPointer<vtkPlane>::New();
     plane0->SetNormal(0, 1, 0);
     plane0->SetOrigin(0, 0, 0);
     _clippingPlanes->AddItem(plane0);
     // left
-    vtkPlane *plane1 = vtkPlane::New();
+    vtkSmartPointer<vtkPlane> plane1 = vtkSmartPointer<vtkPlane>::New();
     plane1->SetNormal(1, 0, 0);
     plane1->SetOrigin(0, 0, 0);
     _clippingPlanes->AddItem(plane1);
    // top
-    vtkPlane *plane2 = vtkPlane::New();
+    vtkSmartPointer<vtkPlane> plane2 = vtkSmartPointer<vtkPlane>::New();
     plane2->SetNormal(0, -1, 0);
     plane2->SetOrigin(0, 1, 0);
     _clippingPlanes->AddItem(plane2);
     // right
-    vtkPlane *plane3 = vtkPlane::New();
+    vtkSmartPointer<vtkPlane> plane3 = vtkSmartPointer<vtkPlane>::New();
     plane3->SetNormal(-1, 0, 0);
     plane3->SetOrigin(1, 0, 0);
@@ -86 +90 @@
     }
     _colorMaps.clear();
-    for (DataSetHashmap::iterator itr = _dataSets.begin();
-             itr != _dataSets.end(); ++itr) {
-        delete itr->second;
-    }
-    _dataSets.clear();
     for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
              itr != _pseudoColors.end(); ++itr) {
@@ -106 +105 @@
     }
     _polyDatas.clear();
+    for (DataSetHashmap::iterator itr = _dataSets.begin();
+             itr != _dataSets.end(); ++itr) {
+        delete itr->second;
+    }
+    _dataSets.clear();
 }
 
@@ -115 +119 @@
  * be added to the Renderer.
  */
-void Renderer::addDataSet(DataSetId id)
+void Renderer::addDataSet(const DataSetId& id)
 {
     if (getDataSet(id) != NULL) {
@@ -129 +133 @@
  * The underlying PseudoColor object is deleted, freeing its memory
  */
-void Renderer::deletePseudoColor(DataSetId id)
-{
-    PseudoColorHashmap::iterator itr = _pseudoColors.find(id);
+void Renderer::deletePseudoColor(const DataSetId& id)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
     if (itr == _pseudoColors.end()) {
         ERROR("PseudoColor not found: %s", id.c_str());
@@ -139 +152 @@
     TRACE("Deleting PseudoColors for %s", id.c_str());
 
-    PseudoColor *ps = itr->second;
-    if (ps->getActor())
-        _renderer->RemoveActor(ps->getActor());
-    delete ps;
-
-    _pseudoColors.erase(itr);
+    do  {
+        PseudoColor *ps = itr->second;
+        if (ps->getActor())
+            _renderer->RemoveActor(ps->getActor());
+        delete ps;
+
+        _pseudoColors.erase(itr);
+    } while (doAll && ++itr != _pseudoColors.end());
+
     _needsRedraw = true;
 }
@@ -153 +169 @@
  * The underlying Contour2D is deleted, freeing its memory
  */
-void Renderer::deleteContour2D(DataSetId id)
-{
-    Contour2DHashmap::iterator itr = _contours.find(id);
+void Renderer::deleteContour2D(const DataSetId& id)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
     if (itr == _contours.end()) {
         ERROR("Contour2D not found: %s", id.c_str());
@@ -163 +188 @@
     TRACE("Deleting Contour2Ds for %s", id.c_str());
 
-    Contour2D *contour = itr->second;
-    if (contour->getActor())
-        _renderer->RemoveActor(contour->getActor());
-    delete contour;
-
-    _contours.erase(itr);
+    do {
+        Contour2D *contour = itr->second;
+        if (contour->getActor())
+            _renderer->RemoveActor(contour->getActor());
+        delete contour;
+
+        _contours.erase(itr);
+    } while (doAll && ++itr != _contours.end());
+
     _needsRedraw = true;
 }
@@ -177 +205 @@
  * The underlying PolyData is deleted, freeing its memory
  */
-void Renderer::deletePolyData(DataSetId id)
-{
-    PolyDataHashmap::iterator itr = _polyDatas.find(id);
+void Renderer::deletePolyData(const DataSetId& id)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
     if (itr == _polyDatas.end()) {
         ERROR("PolyData not found: %s", id.c_str());
@@ -187 +224 @@
     TRACE("Deleting PolyDatas for %s", id.c_str());
 
-    PolyData *polyData = itr->second;
-    if (polyData->getActor())
-        _renderer->RemoveActor(polyData->getActor());
-    delete polyData;
-
-    _polyDatas.erase(itr);
+    do {
+        PolyData *polyData = itr->second;
+        if (polyData->getActor())
+            _renderer->RemoveActor(polyData->getActor());
+        delete polyData;
+
+        _polyDatas.erase(itr);
+    } while (doAll && ++itr != _polyDatas.end());
+
     _needsRedraw = true;
 }
@@ -202 +242 @@
  * objects are deleted, freeing the memory used.
  */
-void Renderer::deleteDataSet(DataSetId id)
-{
-    DataSetHashmap::iterator itr = _dataSets.find(id);
+void Renderer::deleteDataSet(const DataSetId& id)
+{
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+        doAll = true;
+    } else {
+        itr = _dataSets.find(id);
+    }
     if (itr == _dataSets.end()) {
         ERROR("Unknown dataset %s", id.c_str());
         return;
-    } else {
-        TRACE("Deleting dataset %s", id.c_str());
-
-        deletePseudoColor(id);
-        deleteContour2D(id);
-        deletePolyData(id);
-        
+    }
+
+    do {
+        TRACE("Deleting dataset %s", itr->second->getName().c_str());
+
+        deletePseudoColor(itr->second->getName());
+        deleteContour2D(itr->second->getName());
+        deletePolyData(itr->second->getName());
+    
         TRACE("After deleting graphics objects");
+
+        // Update cumulative data range
+        collectDataRanges(_cumulativeDataRange);
 
         delete itr->second;
         _dataSets.erase(itr);
-         _needsRedraw = true;
-    }
+    } while (doAll && ++itr != _dataSets.end());
+
+    _needsRedraw = true;
 }
 
@@ -228 +283 @@
  * \return A pointer to the DataSet, or NULL if not found
  */
-DataSet *Renderer::getDataSet(DataSetId id)
+DataSet *Renderer::getDataSet(const DataSetId& id)
 {
     DataSetHashmap::iterator itr = _dataSets.find(id);
@@ -241 +296 @@
  * \brief (Re-)load the data for the specified DataSet key from a file
  */
-bool Renderer::setDataFile(DataSetId id, const char *filename)
+bool Renderer::setDataFile(const DataSetId& id, const char *filename)
 {
     DataSet *ds = getDataSet(id);
     if (ds) {
         bool ret = ds->setDataFile(filename);
-        PseudoColor *ps = getPseudoColor(id);
-        if (ps) {
-            ps->setDataSet(ds);
-        }
+        collectDataRanges(_cumulativeDataRange);
+        updateRanges(_useCumulativeRanges);
         _needsRedraw = true;
         return ret;
@@ -259 +312 @@
  * \brief (Re-)load the data for the specified DataSet key from a memory buffer
  */
-bool Renderer::setData(DataSetId id, char *data, int nbytes)
+bool Renderer::setData(const DataSetId& id, char *data, int nbytes)
 {
     DataSet *ds = getDataSet(id);
     if (ds) {
+        bool ret = ds->setData(data, nbytes);
+        collectDataRanges(_cumulativeDataRange);
+        updateRanges(_useCumulativeRanges);
         _needsRedraw = true;
-        return ds->setData(data, nbytes);
+        return ret;
     } else
         return false;
@@ -521 +577 @@
  * \brief Add a color map for use in the Renderer
  */
-void Renderer::addColorMap(ColorMapId id, ColorMap *colorMap)
+void Renderer::addColorMap(const ColorMapId& id, ColorMap *colorMap)
 {
     if (colorMap != NULL) {
@@ -538 +594 @@
  * \brief Return the ColorMap associated with the colormap key given
  */
-ColorMap *Renderer::getColorMap(ColorMapId id)
+ColorMap *Renderer::getColorMap(const ColorMapId& id)
 {
     ColorMapHashmap::iterator itr = _colorMaps.find(id);
@@ -554 +610 @@
  * by any other objects
  */
-void Renderer::deleteColorMap(ColorMapId id)
-{
-    ColorMapHashmap::iterator itr = _colorMaps.find(id);
-    if (itr == _colorMaps.end())
-        return;
-
-    // TODO: Check if color map is used in PseudoColors?
-    delete itr->second;
-    _colorMaps.erase(itr);
+void Renderer::deleteColorMap(const ColorMapId& id)
+{
+    ColorMapHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _colorMaps.begin();
+        doAll = true;
+    } else {
+        itr = _colorMaps.find(id);
+    }
+
+    if (itr == _colorMaps.end()) {
+        ERROR("Unknown ColorMap %s", id.c_str());
+        return;
+    }
+
+    do {
+        TRACE("Deleting ColorMap %s", itr->second->getName().c_str());
+
+        // TODO: Check if color map is used in PseudoColors?
+        delete itr->second;
+        _colorMaps.erase(itr);
+    } while (doAll && ++itr != _colorMaps.end());
 }
 
@@ -568 +640 @@
  * \brief Render a labelled legend image for the given colormap
  *
- * \return The image is rendered into the supplied array
- */
-void Renderer::renderColorMap(ColorMapId id, const char *title,
+ * \return The image is rendered into the supplied array, false is 
+ * returned if the color map is not found
+ */
+bool Renderer::renderColorMap(const ColorMapId& id, 
+                              const DataSetId& dataSetID,
+                              const char *title,
                               int width, int height,
                               vtkUnsignedCharArray *imgData)
 {
+    ColorMap *colorMap = getColorMap(id);
+    if (colorMap == NULL)
+        return false;
+
     if (_legendRenderWindow == NULL) {
         _legendRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
@@ -593 +672 @@
         _legendRenderer->AddActor(_scalarBarActor);
     }
-    _scalarBarActor->SetLookupTable(getColorMap(id)->getLookupTable());
+
+    vtkSmartPointer<vtkLookupTable> lut = colorMap->getLookupTable();
+    if (dataSetID.compare("all") == 0) {
+        lut->SetRange(_cumulativeDataRange);
+    } else {
+        DataSet *dataSet = getDataSet(dataSetID);
+        if (dataSet == NULL) {
+            lut->SetRange(_cumulativeDataRange);
+        } else {
+            double range[2];
+            dataSet->getDataRange(range);
+            lut->SetRange(range);
+        }
+    }
+    _scalarBarActor->SetLookupTable(lut);
+
     // Set viewport-relative width/height/pos
     if (width > height) {
@@ -615 +709 @@
 
     _legendRenderWindow->GetPixelData(0, 0, width-1, height-1, 1, imgData);
+    return true;
 }
 
@@ -620 +715 @@
  * \brief Create a new PseudoColor rendering for the specified DataSet
  */
-void Renderer::addPseudoColor(DataSetId id)
-{
-    DataSet *ds = getDataSet(id);
-    if (ds == NULL)
-        return;
-
-    if (getPseudoColor(id)) {
-        WARN("Replacing existing pseudocolor %s", id.c_str());
-        deletePseudoColor(id);
-    }
-    PseudoColor *pc = new PseudoColor();
-    _pseudoColors[id] = pc;
-
-    pc->setDataSet(ds);
-
-    _renderer->AddActor(pc->getActor());
+void Renderer::addPseudoColor(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 (getPseudoColor(dsID)) {
+            WARN("Replacing existing pseudocolor %s", dsID.c_str());
+            deletePseudoColor(dsID);
+        }
+        PseudoColor *pc = new PseudoColor();
+        _pseudoColors[dsID] = pc;
+
+        pc->setDataSet(ds);
+
+        _renderer->AddActor(pc->getActor());
+    } while (doAll && ++itr != _dataSets.end());
 
     initCamera();
@@ -644 +754 @@
  * \brief Get the PseudoColor associated with the specified DataSet
  */
-PseudoColor *Renderer::getPseudoColor(DataSetId id)
+PseudoColor *Renderer::getPseudoColor(const DataSetId& id)
 {
     PseudoColorHashmap::iterator itr = _pseudoColors.find(id);
@@ -658 +768 @@
  * \brief Associate an existing named color map with a DataSet
  */
-void Renderer::setPseudoColorColorMap(DataSetId id, ColorMapId colorMapId)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        ColorMap *cmap = getColorMap(colorMapId);
-        if (cmap) {
-            TRACE("Set color map: %s for dataset %s", colorMapId.c_str(),
-                  id.c_str());
-            pc->setLookupTable(cmap->getLookupTable());
-             _needsRedraw = true;
-        } else {
-            ERROR("Unknown colormap: %s", colorMapId.c_str());
-        }
-    } else {
-        ERROR("No pseudocolor for dataset %s", id.c_str());
-    }
+void Renderer::setPseudoColorColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor 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());
+
+        itr->second->setLookupTable(lut);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -681 +813 @@
  * \return The associated lookup table or NULL if not found
  */
-vtkLookupTable *Renderer::getPseudoColorColorMap(DataSetId id)
+vtkLookupTable *Renderer::getPseudoColorColorMap(const DataSetId& id)
 {
     PseudoColor *pc = getPseudoColor(id);
@@ -691 +823 @@
 
 /**
+ * \brief Set opacity of the PseudoColor for the given DataSet
+ */
+void Renderer::setPseudoColorOpacity(const DataSetId& id, double opacity)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Turn on/off rendering of the PseudoColor mapper for the given DataSet
  */
-void Renderer::setPseudoColorVisibility(DataSetId id, bool state)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setVisibility(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPseudoColorVisibility(const DataSetId& id, bool state)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -705 +881 @@
  * \brief Set the visibility of polygon edges for the specified DataSet
  */
-void Renderer::setPseudoColorEdgeVisibility(DataSetId id, bool state)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeVisibility(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPseudoColorEdgeVisibility(const DataSetId& id, bool state)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -717 +909 @@
  * \brief Set the RGB polygon edge color for the specified DataSet
  */
-void Renderer::setPseudoColorEdgeColor(DataSetId id, float color[3])
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+void Renderer::setPseudoColorEdgeColor(const DataSetId& id, float color[3])
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -732 +940 @@
  * this function may not have an effect.
  */
-void Renderer::setPseudoColorEdgeWidth(DataSetId id, float edgeWidth)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+void Renderer::setPseudoColorEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -744 +968 @@
  * \brief Turn mesh lighting on/off for the specified DataSet
  */
-void Renderer::setPseudoColorLighting(DataSetId id, bool state)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setLighting(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPseudoColorLighting(const DataSetId& id, bool state)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -756 +996 @@
  * \brief Create a new Contour2D and associate it with the named DataSet
  */
-void Renderer::addContour2D(DataSetId id)
-{
-    DataSet *ds = getDataSet(id);
-    if (ds == NULL)
-        return;
-
-    if (getContour2D(id)) {
-        WARN("Replacing existing contour2d %s", id.c_str());
-        deleteContour2D(id);
-    }
-
-    Contour2D *contour = new Contour2D();
-    _contours[id] = contour;
-
-    contour->setDataSet(ds);
-
-    _renderer->AddActor(contour->getActor());
+void Renderer::addContour2D(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 (getContour2D(dsID)) {
+            WARN("Replacing existing contour2d %s", dsID.c_str());
+            deleteContour2D(dsID);
+        }
+
+        Contour2D *contour = new Contour2D();
+        _contours[dsID] = contour;
+
+        contour->setDataSet(ds);
+
+        _renderer->AddActor(contour->getActor());
+    } while (doAll && ++itr != _dataSets.end());
 
     initCamera();
@@ -781 +1036 @@
  * \brief Get the Contour2D associated with a named DataSet
  */
-Contour2D *Renderer::getContour2D(DataSetId id)
+Contour2D *Renderer::getContour2D(const DataSetId& id)
 {
     Contour2DHashmap::iterator itr = _contours.find(id);
@@ -795 +1050 @@
  * \brief Set the number of equally spaced contour isolines for the given DataSet
  */
-void Renderer::setContours(DataSetId id, int numContours)
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setContours(numContours);
-        _needsRedraw = true;
-    }
+void Renderer::setContours(const DataSetId& id, int numContours)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContours(numContours);
+    } while (doAll && ++itr != _contours.end());
+
+    _needsRedraw = true;
 }
 
@@ -807 +1077 @@
  * \brief Set a list of isovalues for the given DataSet
  */
-void Renderer::setContourList(DataSetId id, const std::vector<double>& contours)
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setContourList(contours);
-        _needsRedraw = true;
-    }
+void Renderer::setContourList(const DataSetId& id, const std::vector<double>& contours)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setContourList(contours);
+    } while (doAll && ++itr != _contours.end());
+
+     _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of contour lines for the given DataSet
+ */
+void Renderer::setContourOpacity(const DataSetId& id, double opacity)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _contours.end());
+
+    _needsRedraw = true;
 }
 
@@ -819 +1131 @@
  * \brief Turn on/off rendering contour lines for the given DataSet
  */
-void Renderer::setContourVisibility(DataSetId id, bool state)
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setVisibility(state);
-        _needsRedraw = true;
-    }
+void Renderer::setContourVisibility(const DataSetId& id, bool state)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _contours.end());
+
+    _needsRedraw = true;
 }
 
@@ -831 +1158 @@
  * \brief Set the RGB isoline color for the specified DataSet
  */
-void Renderer::setContourEdgeColor(DataSetId id, float color[3])
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+void Renderer::setContourEdgeColor(const DataSetId& id, float color[3])
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _contours.end());
+
+    _needsRedraw = true;
 }
 
@@ -846 +1188 @@
  * this function may not have an effect.
  */
-void Renderer::setContourEdgeWidth(DataSetId id, float edgeWidth)
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+void Renderer::setContourEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _contours.end());
+
+    _needsRedraw = true;
 }
 
@@ -858 +1215 @@
  * \brief Turn contour lighting on/off for the specified DataSet
  */
-void Renderer::setContourLighting(DataSetId id, bool state)
-{
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setLighting(state);
-        _needsRedraw = true;
-    }
+void Renderer::setContourLighting(const DataSetId& id, bool state)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contours.begin();
+        doAll = true;
+    } else {
+        itr = _contours.find(id);
+    }
+    if (itr == _contours.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _contours.end());
+    _needsRedraw = true;
 }
 
@@ -870 +1241 @@
  * \brief Create a new PolyData and associate it with the named DataSet
  */
-void Renderer::addPolyData(DataSetId id)
-{
-    DataSet *ds = getDataSet(id);
-    if (ds == NULL)
-        return;
-
-    if (getPolyData(id)) {
-        WARN("Replacing existing polydata %s", id.c_str());
-        deletePolyData(id);
-    }
-
-    PolyData *polyData = new PolyData();
-    _polyDatas[id] = polyData;
-
-    polyData->setDataSet(ds);
-
-    _renderer->AddActor(polyData->getActor());
+void Renderer::addPolyData(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 (getPolyData(dsID)) {
+            WARN("Replacing existing polydata %s", dsID.c_str());
+            deletePolyData(dsID);
+        }
+
+        PolyData *polyData = new PolyData();
+        _polyDatas[dsID] = polyData;
+
+        polyData->setDataSet(ds);
+
+        _renderer->AddActor(polyData->getActor());
+    } while (doAll && ++itr != _dataSets.end());
 
     if (_cameraMode == IMAGE)
@@ -897 +1283 @@
  * \brief Get the PolyData associated with a named DataSet
  */
-PolyData *Renderer::getPolyData(DataSetId id)
+PolyData *Renderer::getPolyData(const DataSetId& id)
 {
     PolyDataHashmap::iterator itr = _polyDatas.find(id);
@@ -909 +1295 @@
 
 /**
+ * \brief Set opacity of the PolyData for the given DataSet
+ */
+void Renderer::setPolyDataOpacity(const DataSetId& id, double opacity)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Turn on/off rendering of the PolyData mapper for the given DataSet
  */
-void Renderer::setPolyDataVisibility(DataSetId id, bool state)
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setVisibility(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataVisibility(const DataSetId& id, bool state)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -923 +1351 @@
  * \brief Set the RGB polygon face color for the specified DataSet
  */
-void Renderer::setPolyDataColor(DataSetId id, float color[3])
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setColor(color);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataColor(const DataSetId& id, float color[3])
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColor(color);
+    } while (doAll && ++itr != _polyDatas.end());
+    _needsRedraw = true;
 }
 
@@ -935 +1377 @@
  * \brief Set the visibility of polygon edges for the specified DataSet
  */
-void Renderer::setPolyDataEdgeVisibility(DataSetId id, bool state)
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeVisibility(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataEdgeVisibility(const DataSetId& id, bool state)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -947 +1404 @@
  * \brief Set the RGB polygon edge color for the specified DataSet
  */
-void Renderer::setPolyDataEdgeColor(DataSetId id, float color[3])
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataEdgeColor(const DataSetId& id, float color[3])
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -962 +1434 @@
  * this function may not have an effect.
  */
-void Renderer::setPolyDataEdgeWidth(DataSetId id, float edgeWidth)
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -974 +1461 @@
  * \brief Set wireframe rendering for the specified DataSet
  */
-void Renderer::setPolyDataWireframe(DataSetId id, bool state)
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setWireframe(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataWireframe(const DataSetId& id, bool state)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setWireframe(state);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -986 +1488 @@
  * \brief Turn mesh lighting on/off for the specified DataSet
  */
-void Renderer::setPolyDataLighting(DataSetId id, bool state)
-{
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setLighting(state);
-        _needsRedraw = true;
-    }
+void Renderer::setPolyDataLighting(const DataSetId& id, bool state)
+{
+    PolyDataHashmap::iterator itr;
+    
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
 }
 
@@ -1289 +1806 @@
         }
     }
+}
+
+/**
+ * \brief Update data ranges for color-mapping
+ *
+ * \param[in] useCumulative Use cumulative range of all DataSets
+ */
+void Renderer::updateRanges(bool useCumulative)
+{
+    for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
+         itr != _pseudoColors.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);
+                }
+            }
+        }
+    }
+}
+
+/**
+ * \brief Collect cumulative data range of all DataSets
+ *
+ * \param[inout] range Data range of all DataSets
+ */
+void Renderer::collectDataRanges(double *range)
+{
+    range[0] = DBL_MAX;
+    range[1] = -DBL_MAX;
+
+    for (DataSetHashmap::iterator itr = _dataSets.begin();
+         itr != _dataSets.end(); ++itr) {
+        double r[2];
+        itr->second->getDataRange(r);
+        range[0] = min2(range[0], r[0]);
+        range[1] = max2(range[1], r[1]);
+    }
+    if (range[0] == DBL_MAX)
+        range[0] = 0;
+    if (range[1] == -DBL_MAX)
+        range[1] = 1;
 }
 
@@ -1357 +1921 @@
  * \brief Set the opacity of the specified DataSet's associated graphics objects
  */
-void Renderer::setOpacity(DataSetId id, double opacity)
-{
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setOpacity(opacity);
-        _needsRedraw = true;
-    }
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setOpacity(opacity);
-        _needsRedraw = true;
-    }
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setOpacity(opacity);
-        _needsRedraw = true;
-    }
+void Renderer::setOpacity(const DataSetId& id, double opacity)
+{
+    setPseudoColorOpacity(id, opacity);
+    setContourOpacity(id, opacity);
+    setPolyDataOpacity(id, opacity);
 }
 
@@ -1379 +1931 @@
  * \brief Turn on/off rendering of the specified DataSet's associated graphics objects
  */
-void Renderer::setVisibility(DataSetId id, bool state)
+void Renderer::setVisibility(const DataSetId& id, bool state)
 {
     setPseudoColorVisibility(id, state);
@@ -1402 +1954 @@
             for (Contour2DHashmap::iterator itr = _contours.begin();
                  itr != _contours.end(); ++itr) {
+                itr->second->setClippingPlanes(_clippingPlanes);
+            }
+            for (PolyDataHashmap::iterator itr = _polyDatas.begin();
+                 itr != _polyDatas.end(); ++itr) {
                 itr->second->setClippingPlanes(_clippingPlanes);
             }
@@ -1413 +1969 @@
                 itr->second->setClippingPlanes(NULL);
             }
+            for (PolyDataHashmap::iterator itr = _polyDatas.begin();
+                 itr != _polyDatas.end(); ++itr) {
+                itr->second->setClippingPlanes(NULL);
+            }
         }
         _renderWindow->Render();
@@ -1447 +2007 @@
  * Note: no interpolation is performed on data
  */
-double Renderer::getDataValueAtPixel(DataSetId id, int x, int y)
+double Renderer::getDataValueAtPixel(const DataSetId& id, int x, int y)
 {
     vtkSmartPointer<vtkCoordinate> coord = vtkSmartPointer<vtkCoordinate>::New();
@@ -1469 +2029 @@
  * Note: no interpolation is performed on data
  */
-double Renderer::getDataValue(DataSetId id, double x, double y, double z)
+double Renderer::getDataValue(const DataSetId& id, double x, double y, double z)
 {
     DataSet *ds = getDataSet(id);

branches/blt4/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -66 +66 @@
     // Data sets
 
-    void addDataSet(DataSetId id);
-
-    void deleteDataSet(DataSetId id);
-
-    DataSet *getDataSet(DataSetId id);
-
-    bool setData(DataSetId id, char *data, int nbytes);
-
-    bool setDataFile(DataSetId id, const char *filename);
-
-    double getDataValueAtPixel(DataSetId id, int x, int y);
-
-    double getDataValue(DataSetId id, double x, double y, double z);
-
-    void setOpacity(DataSetId id, double opacity);
-
-    void setVisibility(DataSetId id, bool state);
+    void addDataSet(const DataSetId& id);
+
+    void deleteDataSet(const DataSetId& id);
+
+    DataSet *getDataSet(const DataSetId& id);
+
+    bool setData(const DataSetId& id, char *data, int nbytes);
+
+    bool setDataFile(const DataSetId& id, const char *filename);
+
+    double getDataValueAtPixel(const DataSetId& id, int x, int y);
+
+    double getDataValue(const DataSetId& id, double x, double y, double z);
+
+    void setOpacity(const DataSetId& id, double opacity);
+
+    void setVisibility(const DataSetId& id, bool state);
 
     // Render window
@@ -132 +132 @@
     // Colormaps
 
-    void addColorMap(ColorMapId id, ColorMap *colorMap);
-
-    void deleteColorMap(ColorMapId id);
-
-    ColorMap *getColorMap(ColorMapId id);
-
-    void renderColorMap(ColorMapId id, const char *title,
+    void addColorMap(const ColorMapId& id, ColorMap *colorMap);
+
+    void deleteColorMap(const ColorMapId& id);
+
+    ColorMap *getColorMap(const ColorMapId& id);
+
+    bool renderColorMap(const ColorMapId& id, 
+                        const DataSetId& dataSetID,
+                        const char *title,
                         int width, int height,
                         vtkUnsignedCharArray *imgData);
@@ -144 +146 @@
     // Color-mapped surfaces
 
-    void addPseudoColor(DataSetId id);
-
-    void deletePseudoColor(DataSetId id);
-
-    PseudoColor *getPseudoColor(DataSetId id);
-
-    void setPseudoColorColorMap(DataSetId id, ColorMapId colorMapId);
-
-    vtkLookupTable *getPseudoColorColorMap(DataSetId id);
-
-    void setPseudoColorVisibility(DataSetId id, bool state);
-
-    void setPseudoColorEdgeVisibility(DataSetId id, bool state);
-
-    void setPseudoColorEdgeColor(DataSetId id, float color[3]);
-
-    void setPseudoColorEdgeWidth(DataSetId id, float edgeWidth);
-
-    void setPseudoColorLighting(DataSetId id, bool state);
+    void addPseudoColor(const DataSetId& id);
+
+    void deletePseudoColor(const DataSetId& id);
+
+    PseudoColor *getPseudoColor(const DataSetId& id);
+
+    void setPseudoColorColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    vtkLookupTable *getPseudoColorColorMap(const DataSetId& id);
+
+    void setPseudoColorOpacity(const DataSetId& id, double opacity);
+
+    void setPseudoColorVisibility(const DataSetId& id, bool state);
+
+    void setPseudoColorEdgeVisibility(const DataSetId& id, bool state);
+
+    void setPseudoColorEdgeColor(const DataSetId& id, float color[3]);
+
+    void setPseudoColorEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setPseudoColorLighting(const DataSetId& id, bool state);
 
     // Contour plots
 
-    void addContour2D(DataSetId id);
-
-    void deleteContour2D(DataSetId id);
-
-    Contour2D *getContour2D(DataSetId id);
-
-    void setContours(DataSetId id, int numContours);
-
-    void setContourList(DataSetId id, const std::vector<double>& contours);
-
-    void setContourVisibility(DataSetId id, bool state);
-
-    void setContourEdgeColor(DataSetId id, float color[3]);
-
-    void setContourEdgeWidth(DataSetId id, float edgeWidth);
-
-    void setContourLighting(DataSetId id, bool state);
+    void addContour2D(const DataSetId& id);
+
+    void deleteContour2D(const DataSetId& id);
+
+    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);
 
     // Meshes
 
-    void addPolyData(DataSetId id);
+    void addPolyData(const DataSetId& id);
     
-    void deletePolyData(DataSetId id);
-
-    PolyData *getPolyData(DataSetId id);
-
-    void setPolyDataVisibility(DataSetId id, bool state);
-
-    void setPolyDataColor(DataSetId id, float color[3]);
-
-    void setPolyDataEdgeVisibility(DataSetId id, bool state);
-
-    void setPolyDataEdgeColor(DataSetId id, float color[3]);
-
-    void setPolyDataEdgeWidth(DataSetId id, float edgeWidth);
-
-    void setPolyDataWireframe(DataSetId id, bool state);
-
-    void setPolyDataLighting(DataSetId id, bool state);
+    void deletePolyData(const DataSetId& id);
+
+    PolyData *getPolyData(const DataSetId& id);
+
+    void setPolyDataOpacity(const DataSetId& id, double opacity);
+
+    void setPolyDataVisibility(const DataSetId& id, bool state);
+
+    void setPolyDataColor(const DataSetId& id, float color[3]);
+
+    void setPolyDataEdgeVisibility(const DataSetId& id, bool state);
+
+    void setPolyDataEdgeColor(const DataSetId& id, float color[3]);
+
+    void setPolyDataEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setPolyDataWireframe(const DataSetId& id, bool state);
+
+    void setPolyDataLighting(const DataSetId& id, bool state);
 
 private:
@@ -220 +228 @@
     void collectBounds(double *bounds, bool onlyVisible);
 
+    void collectDataRanges(double *range);
+
+    void updateRanges(bool useCumulative);
+
     void storeCameraOrientation();
     void restoreCameraOrientation();
@@ -234 +246 @@
     double _cameraUp[3];
     float _bgColor[3];
+    bool _useCumulativeRanges;
+    double _cumulativeDataRange[2];
 
     ColorMapHashmap _colorMaps;

branches/blt4/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -172 +172 @@
     {"name", 1, AxisNameOp, 4, 4, "axis title"},
     {"units", 1, AxisUnitsOp, 4, 4, "axis units"},
-    {"visible", 1, AxisVisibleOp, 4, 4, "axis bool"},
+    {"visible", 1, AxisVisibleOp, 4, 4, "axis bool"}
 };
 static int nAxisOps = NumCmdSpecs(axisOps);
@@ -298 +298 @@
     {"reset", 2, CameraResetOp, 2, 3, "?all?"},
     {"rotate", 2, CameraRotateOp, 5, 5, "angle angle angle"},
-    {"zoom", 1, CameraZoomOp, 3, 3, "zoomAmount"},
+    {"zoom", 1, CameraZoomOp, 3, 3, "zoomAmount"}
 };
 static int nCameraOps = NumCmdSpecs(cameraOps);
@@ -400 +400 @@
                  Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->deleteColorMap(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteColorMap(name);
+    } else {
+        g_renderer->deleteColorMap("all");
+    }
     return TCL_OK;
 }
@@ -407 +411 @@
 static Rappture::CmdSpec colorMapOps[] = {
     {"add", 1, ColorMapAddOp, 5, 5, "colorMapName colormap alphamap"},
-    {"delete", 1, ColorMapDeleteOp, 3, 3, "colorMapName"}
+    {"delete", 1, ColorMapDeleteOp, 2, 3, "?colorMapName?"}
 };
 static int nColorMapOps = NumCmdSpecs(colorMapOps);
@@ -429 +433 @@
                           Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[4]);
-    g_renderer->addContour2D(name);
     std::vector<double> contourList;
 
@@ -448 +450 @@
     }
 
-    g_renderer->setContourList(name, contourList);
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->addContour2D(name);
+        g_renderer->setContourList(name, contourList);
+    } else {
+        g_renderer->addContour2D("all");
+        g_renderer->setContourList("all", contourList);
+    }
     return TCL_OK;
 }
@@ -456 +465 @@
                           Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[4]);
-    g_renderer->addContour2D(name);
     int numContours;
     if (Tcl_GetIntFromObj(interp, objv[3], &numContours) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setContours(name, numContours);
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->addContour2D(name);
+        g_renderer->setContours(name, numContours);
+    } else {
+        g_renderer->addContour2D("all");
+        g_renderer->setContours("all", numContours);
+    }
     return TCL_OK;
 }
 
 static Rappture::CmdSpec contour2dAddOps[] = {
-    {"contourlist", 1, Contour2DAddContourListOp, 5, 5, "contourList dataSetName"},
-    {"numcontours", 1, Contour2DAddNumContoursOp, 5, 5, "numContours dataSetName"}
+    {"contourlist", 1, Contour2DAddContourListOp, 4, 5, "contourList ?dataSetName?"},
+    {"numcontours", 1, Contour2DAddNumContoursOp, 4, 5, "numContours ?dataSetName?"}
 };
 static int nContour2dAddOps = NumCmdSpecs(contour2dAddOps);
@@ -490 +504 @@
                   Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->deleteContour2D(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteContour2D(name);
+    } else {
+        g_renderer->deleteContour2D("all");
+    }
     return TCL_OK;
 }
@@ -499 +517 @@
                     Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setContourLighting(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContourLighting(name, state);
+    } else {
+        g_renderer->setContourLighting("all", state);
+    }
     return TCL_OK;
 }
@@ -512 +534 @@
                      Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -519 +540 @@
         return TCL_ERROR;
     }
-    g_renderer->setContourEdgeColor(name, color);
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContourEdgeColor(name, color);
+    } else {
+        g_renderer->setContourEdgeColor("all", color);
+    }
     return TCL_OK;
 }
@@ -527 +553 @@
                      Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     float width;
     if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setContourEdgeWidth(name, width);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContourEdgeWidth(name, width);
+    } else {
+        g_renderer->setContourEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour2DOpacityOp(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->setContourOpacity(name, opacity);
+    } else {
+        g_renderer->setContourOpacity("all", opacity);
+    }
     return TCL_OK;
 }
@@ -540 +587 @@
                    Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setContourVisibility(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setContourVisibility(name, state);
+    } else {
+        g_renderer->setContourVisibility("all", state);
+    }
     return TCL_OK;
 }
 
 static Rappture::CmdSpec contour2dOps[] = {
-    {"add", 1, Contour2DAddOp, 5, 5, "oper value dataSetName"},
-    {"delete", 1, Contour2DDeleteOp, 3, 3, "dataSetName"},
-    {"lighting", 3, Contour2DLightingOp, 4, 4, "bool dataSetName"},
-    {"linecolor", 5, Contour2DLineColorOp, 6, 6, "r g b dataSetName"},
-    {"linewidth", 5, Contour2DLineWidthOp, 4, 4, "width dataSetName"},
-    {"visible", 1, Contour2DVisibleOp, 4, 4, "bool dataSetName"},
+    {"add", 1, Contour2DAddOp, 4, 5, "oper value ?dataSetName?"},
+    {"delete", 1, Contour2DDeleteOp, 2, 3, "?dataSetName?"},
+    {"lighting", 3, Contour2DLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor", 5, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth", 5, Contour2DLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity", 1, Contour2DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible", 1, Contour2DVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
 static int nContour2dOps = NumCmdSpecs(contour2dOps);
@@ -627 +679 @@
                 Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    TRACE("Deleting dataset %s", name);
-    g_renderer->deleteDataSet(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        TRACE("Deleting dataset %s", name);
+        g_renderer->deleteDataSet(name);
+    } else {
+        g_renderer->deleteDataSet("all");
+    }
     return TCL_OK;
 }
@@ -712 +768 @@
                  Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     double opacity;
     if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setOpacity(name, opacity);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setOpacity(name, opacity);
+    } else {
+        g_renderer->setOpacity("all", opacity);
+    }
     return TCL_OK;
 }
@@ -725 +785 @@
                  Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setVisibility(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setVisibility(name, state);
+    } else {
+        g_renderer->setVisibility("all", state);
+    }
     return TCL_OK;
 }
@@ -736 +800 @@
 static Rappture::CmdSpec dataSetOps[] = {
     {"add", 1, DataSetAddOp, 6, 6, "name data follows nBytes"},
-    {"delete", 1, DataSetDeleteOp, 3, 3, "name"},
+    {"delete", 1, DataSetDeleteOp, 2, 3, "?name?"},
     {"getvalue", 1, DataSetGetValueOp, 6, 7, "oper x y ?z? name"},
-    {"opacity", 1, DataSetOpacityOp, 4, 4, "value name"},
-    {"visible", 1, DataSetVisibleOp, 4, 4, "bool name"}
+    {"opacity", 1, DataSetOpacityOp, 3, 4, "value ?name?"},
+    {"visible", 1, DataSetVisibleOp, 3, 4, "bool ?name?"}
 };
 static int nDataSetOps = NumCmdSpecs(dataSetOps);
@@ -763 +827 @@
     if (objc < 4) {
         Tcl_AppendResult(interp, "wrong # args: should be \"",
-                Tcl_GetString(objv[0]), " colormapName title width height\"", (char*)NULL);
+                Tcl_GetString(objv[0]), " colormapName title width height ?dataSetName?\"", (char*)NULL);
         return TCL_ERROR;
     }
@@ -778 +842 @@
         vtkSmartPointer<vtkUnsignedCharArray>::New();
 
-    g_renderer->renderColorMap(name, title, width, height, imgData);
+    if (objc == 6) {
+        const char *dataSetName = Tcl_GetString(objv[5]);
+        if (!g_renderer->renderColorMap(name, dataSetName, title, width, height, imgData)) {
+            Tcl_AppendResult(interp, "Color map \"",
+                             name, "\" was not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->renderColorMap(name, "all", title, width, height, imgData)) {
+            Tcl_AppendResult(interp, "Color map \"",
+                             name, "\" was not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
 
 #ifdef DEBUG
@@ -795 +872 @@
                Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->addPseudoColor(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->addPseudoColor(name);
+    } else {
+        g_renderer->addPseudoColor("all");
+    }
     return TCL_OK;
 }
@@ -805 +886 @@
 {
     const char *colorMapName = Tcl_GetString(objv[2]);
-    const char *dataSetName = Tcl_GetString(objv[3]);
-    g_renderer->setPseudoColorColorMap(dataSetName, colorMapName);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setPseudoColorColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setPseudoColorColorMap("all", colorMapName);
+    }
     return TCL_OK;
 }
@@ -814 +899 @@
                   Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->deletePseudoColor(name);
-    return TCL_OK;
-}
-
-static int
-PseudoColorVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                     Tcl_Obj *const *objv)
-{
-    const char *name = Tcl_GetString(objv[3]);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deletePseudoColor(name);
+    } else {
+        g_renderer->deletePseudoColor("all");
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorEdgeVisibilityOp(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->setPseudoColorVisibility(name, state);
-    return TCL_OK;
-}
-
-static int
-PseudoColorEdgeVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                            Tcl_Obj *const *objv)
-{
-    const char *name = Tcl_GetString(objv[3]);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPseudoColorEdgeVisibility(name, state);
+    } else {
+        g_renderer->setPseudoColorEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorLightingOp(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->setPseudoColorEdgeVisibility(name, state);
-    return TCL_OK;
-}
-
-static int
-PseudoColorLightingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                      Tcl_Obj *const *objv)
-{
-    const char *name = Tcl_GetString(objv[3]);
-    bool state;
-    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    g_renderer->setPseudoColorLighting(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPseudoColorLighting(name, state);
+    } else {
+        g_renderer->setPseudoColorLighting("all", state);
+    }
     return TCL_OK;
 }
@@ -862 +946 @@
                        Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -869 +952 @@
         return TCL_ERROR;
     }
-    g_renderer->setPseudoColorEdgeColor(name, color);
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPseudoColorEdgeColor(name, color);
+    } else {
+        g_renderer->setPseudoColorEdgeColor("all", color);
+    }
     return TCL_OK;
 }
@@ -877 +965 @@
                        Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     float width;
     if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPseudoColorEdgeWidth(name, width);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPseudoColorEdgeWidth(name, width);
+    } else {
+        g_renderer->setPseudoColorEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorOpacityOp(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->setPseudoColorOpacity(name, opacity);
+    } else {
+        g_renderer->setPseudoColorOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorVisibleOp(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->setPseudoColorVisibility(name, state);
+    } else {
+        g_renderer->setPseudoColorVisibility("all", state);
+    }
     return TCL_OK;
 }
 
 static Rappture::CmdSpec pseudoColorOps[] = {
-    {"add", 1, PseudoColorAddOp, 3, 3, "dataSetName"},
-    {"colormap", 1, PseudoColorColorMapOp, 4, 4, "colorMapName dataSetName"},
-    {"delete", 1, PseudoColorDeleteOp, 3, 3, "dataSetName"},
-    {"edges", 1, PseudoColorEdgeVisibilityOp, 4, 4, "bool dataSetName"},
-    {"lighting", 3, PseudoColorLightingOp, 4, 4, "bool dataSetName"},
-    {"linecolor", 5, PseudoColorLineColorOp, 6, 6, "r g b dataSetName"},
-    {"linewidth", 5, PseudoColorLineWidthOp, 4, 4, "width dataSetName"},
-    {"visible", 1, PseudoColorVisibleOp, 4, 4, "bool dataSetName"}
+    {"add", 1, PseudoColorAddOp, 2, 3, "?dataSetName?"},
+    {"colormap", 1, PseudoColorColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete", 1, PseudoColorDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges", 1, PseudoColorEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting", 3, PseudoColorLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor", 5, PseudoColorLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth", 5, PseudoColorLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity", 1, PseudoColorOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible", 1, PseudoColorVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
 static int nPseudoColorOps = NumCmdSpecs(pseudoColorOps);
@@ -916 +1043 @@
               Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->addPolyData(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->addPolyData(name);
+    } else {
+        g_renderer->addPolyData("all");
+    }
     return TCL_OK;
 }
@@ -925 +1056 @@
                  Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[2]);
-    g_renderer->deletePolyData(name);
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deletePolyData(name);
+    } else {
+        g_renderer->deletePolyData("all");
+    }
     return TCL_OK;
 }
@@ -934 +1069 @@
                 Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -941 +1075 @@
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataColor(name, color);
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPolyDataColor(name, color);
+    } else {
+        g_renderer->setPolyDataColor("all", color);
+    }
     return TCL_OK;
 }
@@ -949 +1088 @@
                          Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataEdgeVisibility(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPolyDataEdgeVisibility(name, state);
+    } else {
+        g_renderer->setPolyDataEdgeVisibility("all", state);
+    }
     return TCL_OK;
 }
@@ -962 +1105 @@
                    Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataLighting(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPolyDataLighting(name, state);
+    } else {
+        g_renderer->setPolyDataLighting("all", state);
+    }
     return TCL_OK;
 }
@@ -975 +1122 @@
                     Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -982 +1128 @@
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataEdgeColor(name, color);
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPolyDataEdgeColor(name, color);
+    } else {
+        g_renderer->setPolyDataEdgeColor("all", color);
+    }
     return TCL_OK;
 }
@@ -990 +1141 @@
                     Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     float width;
     if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataEdgeWidth(name, width);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPolyDataEdgeWidth(name, width);
+    } else {
+        g_renderer->setPolyDataEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataOpacityOp(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->setPolyDataOpacity(name, opacity);
+    } else {
+        g_renderer->setPolyDataOpacity("all", opacity);
+    }
     return TCL_OK;
 }
@@ -1003 +1175 @@
                   Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataVisibility(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPolyDataVisibility(name, state);
+    } else {
+        g_renderer->setPolyDataVisibility("all", state);
+    }
     return TCL_OK;
 }
@@ -1016 +1192 @@
                     Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[3]);
     bool state;
     if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
         return TCL_ERROR;
     }
-    g_renderer->setPolyDataWireframe(name, state);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setPolyDataWireframe(name, state);
+    } else {
+        g_renderer->setPolyDataWireframe("all", state);
+    }
     return TCL_OK;
 }
 
 static Rappture::CmdSpec polyDataOps[] = {
-    {"add", 1, PolyDataAddOp, 3, 3, "dataSetName"},
-    {"color", 1, PolyDataColorOp, 6, 6, "r g b dataSetName"},
-    {"delete", 1, PolyDataDeleteOp, 3, 3, "dataSetName"},
-    {"edges", 1, PolyDataEdgeVisibilityOp, 4, 4, "bool dataSetName"},
-    {"lighting", 3, PolyDataLightingOp, 4, 4, "bool dataSetName"},
-    {"linecolor", 5, PolyDataLineColorOp, 6, 6, "r g b dataSetName"},
-    {"linewidth", 5, PolyDataLineWidthOp, 4, 4, "width dataSetName"},
-    {"visible", 1, PolyDataVisibleOp, 4, 4, "bool dataSetName"},
-    {"wireframe", 1, PolyDataWireframeOp, 4, 4, "bool dataSetName"}
+    {"add", 1, PolyDataAddOp, 2, 3, "?dataSetName?"},
+    {"color", 1, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"delete", 1, PolyDataDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges", 1, PolyDataEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting", 3, PolyDataLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor", 5, PolyDataLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth", 5, PolyDataLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity", 1, PolyDataOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible", 1, PolyDataVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"wireframe", 1, PolyDataWireframeOp, 3, 4, "bool ?dataSetName?"}
 };
 static int nPolyDataOps = NumCmdSpecs(polyDataOps);

branches/blt4/packages/vizservers/vtkvis/protocol.txt

@@ -31 +31 @@
        Specify zoom ratio
 
+colormap add <colorMapName> <colorMap> <opacityMap>
+         colorMap = Tcl list of {value r g b} control points
+         opacityMap = Tcl list of {value alpha} control points
+colormap delete <?colorMapName?>
+
+legend <colormapName> <legendTitle> <width> <height> <?datasetName?>
+       Causes legend to be rendered and written back with labels and title
+
 dataset add <datasetName> data follows <nbytes>
-dataset delete <datasetName>
+dataset delete <?datasetName?>
 dataset getvalue world <x> <y> <z> <datasetName>
 dataset getvalue pixel <x> <y> <datasetName>
         Use pixel for image camera mode
-dataset opacity <val> <datasetName>
-dataset visible <bool> <datasetName>
+dataset opacity <val> <?datasetName?>
+dataset visible <bool> <?datasetName?>
 
-colormap add <colorMapName> <colorMap> <opacityMap>
-         colorMap = Tcl list of {value r g b} control points
-         opacityMap = Tcl list of {value alpha} control points
-colormap delete <colorMapName>
+pseudocolor add <?datasetName?>
+pseudocolor colormap <colormapName> <?datasetName?>
+pseudocolor delete <?datasetName?>
+pseudocolor edges <bool> <?datasetName?>
+pseudocolor lighting <bool> <?datasetName?>
+pseudocolor linecolor <r> <g> <b> <?datasetName?>
+pseudocolor linewidth <val> <?datasetName?>
+pseudocolor opacity <val> <?datasetName?>
+pseudocolor visible <bool> <?datasetName?>
 
-legend <colormapName> <legendTitle> <width> <height>
-       Causes legend to be rendered and written back with labels and title
+contour2d add numcontours <n> <?datasetName?>
+contour2d add contourlist <list> <?datasetName?>
+          list = {isoval1 isoval2 isoval3...}
+contour2d delete <?datasetName?>
+contour2d lighting <bool> <?datasetName?>
+contour2d linecolor <r> <g> <b> <?datasetName?>
+contour2d linewidth <val> <?datasetName?>
+contour2d opacity <val> <?datasetName?>
+contour2d visible <bool> <?datasetName?>
 
-pseudocolor add <datasetName>
-pseudocolor colormap <colormapName> <datasetName>
-pseudocolor delete <datasetName>
-pseudocolor edges <bool> <datasetName>
-pseudocolor linecolor <r> <g> <b> <datasetName>
-pseudocolor linewidth <val> <datasetName>
-pseudocolor visible <bool> <datasetName>
-
-contour2d add numcontours <n> <datasetName>
-contour2d add contourlist <list> <datasetName>
-          list = {isoval1 isoval2 isoval3...}
-contour2d delete <datasetName>
-contour2d linecolor <r> <g> <b> <datasetName>
-contour2d linewidth <val> <datasetName>
-contour2d visible <bool> <datasetName>
-
-polydata add <datasetName>
-polydata color <r> <g> <b> <datasetName>
-polydata delete <datasetName>
-polydata edges <bool> <datasetName>
-polydata linecolor <r> <g> <b> <datasetName>
-polydata linewidth <val> <datasetName>
-polydata visible <bool> <datasetName>
-polydata wireframe <bool> <datasetName>
+polydata add <?datasetName?>
+polydata color <r> <g> <b> <?datasetName?>
+polydata delete <?datasetName?>
+polydata edges <bool> <?datasetName?>
+polydata lighting <bool> <?datasetName?>
+polydata linecolor <r> <g> <b> <?datasetName?>
+polydata linewidth <val> <?datasetName?>
+polydata opacity <val> <?datasetName?>
+polydata visible <bool> <?datasetName?>
+polydata wireframe <bool> <?datasetName?>
 
 ================================================================================