Changeset 2137 for trunk/packages/vizservers/vtkvis

Timestamp:

Mar 15, 2011 10:58:51 AM (13 years ago)

Author:

ldelgass

Message:

Finish up making dataset name optional (meaning "all") in vtkvis protocol.

Location:

trunk/packages/vizservers/vtkvis

Files:

• RpContour2D.cpp (modified) (1 diff)
• RpContour2D.h (modified) (1 diff)
• RpPolyData.cpp (modified) (1 diff)
• RpPolyData.h (modified) (1 diff)
• RpPseudoColor.cpp (modified) (1 diff)
• RpPseudoColor.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (23 diffs)
• RpVtkRenderer.h (modified) (3 diffs)
• RpVtkRendererCmd.cpp (modified) (27 diffs)
• protocol.txt (modified) (1 diff)

trunk/packages/vizservers/vtkvis/RpContour2D.cpp

@@ -45 +45 @@
         update();
     }
+}
+
+/**
+ * \brief Returns the DataSet this Contour2D renders
+ */
+DataSet *Contour2D::getDataSet()
+{
+    return _dataSet;
 }
 

trunk/packages/vizservers/vtkvis/RpContour2D.h

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

trunk/packages/vizservers/vtkvis/RpPolyData.cpp

@@ -85 +85 @@
 
 /**
+ * \brief Returns the DataSet this PolyData renders
+ */
+DataSet *PolyData::getDataSet()
+{
+    return _dataSet;
+}
+
+/**
  * \brief Internal method to re-compute contours after a state change
  */

trunk/packages/vizservers/vtkvis/RpPolyData.h

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

trunk/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -46 +46 @@
     _dataSet = dataSet;
     update();
+}
+
+/**
+ * \brief Returns the DataSet this PseudoColor renders
+ */
+DataSet *PseudoColor::getDataSet()
+{
+    return _dataSet;
 }
 

trunk/packages/vizservers/vtkvis/RpPseudoColor.h

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

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -697 +697 @@
 void Renderer::addPseudoColor(const 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());
+    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();
@@ -735 +750 @@
 void Renderer::setPseudoColorColorMap(const DataSetId& id, const 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());
-    }
+    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());
+
+        itr->second->setLookupTable(cmap->getLookupTable());
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    _needsRedraw = true;
 }
 
@@ -766 +797 @@
 
 /**
+ * \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(const DataSetId& id, bool state)
 {
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setVisibility(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -782 +857 @@
 void Renderer::setPseudoColorEdgeVisibility(const DataSetId& id, bool state)
 {
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeVisibility(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -794 +885 @@
 void Renderer::setPseudoColorEdgeColor(const DataSetId& id, float color[3])
 {
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -809 +916 @@
 void Renderer::setPseudoColorEdgeWidth(const DataSetId& id, float edgeWidth)
 {
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -821 +944 @@
 void Renderer::setPseudoColorLighting(const DataSetId& id, bool state)
 {
-    PseudoColor *pc = getPseudoColor(id);
-    if (pc) {
-        pc->setLighting(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -833 +972 @@
 void Renderer::addContour2D(const 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());
+    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();
@@ -872 +1026 @@
 void Renderer::setContours(const DataSetId& id, int numContours)
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setContours(numContours);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -884 +1053 @@
 void Renderer::setContourList(const DataSetId& id, const std::vector<double>& contours)
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setContourList(contours);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -896 +1107 @@
 void Renderer::setContourVisibility(const DataSetId& id, bool state)
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setVisibility(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -908 +1134 @@
 void Renderer::setContourEdgeColor(const DataSetId& id, float color[3])
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -923 +1164 @@
 void Renderer::setContourEdgeWidth(const DataSetId& id, float edgeWidth)
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -935 +1191 @@
 void Renderer::setContourLighting(const DataSetId& id, bool state)
 {
-    Contour2D *contour = getContour2D(id);
-    if (contour) {
-        contour->setLighting(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -947 +1217 @@
 void Renderer::addPolyData(const 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());
+    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)
@@ -984 +1269 @@
 
 /**
+ * \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(const DataSetId& id, bool state)
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setVisibility(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1000 +1327 @@
 void Renderer::setPolyDataColor(const DataSetId& id, float color[3])
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setColor(color);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1012 +1353 @@
 void Renderer::setPolyDataEdgeVisibility(const DataSetId& id, bool state)
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeVisibility(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1024 +1380 @@
 void Renderer::setPolyDataEdgeColor(const DataSetId& id, float color[3])
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeColor(color);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1039 +1410 @@
 void Renderer::setPolyDataEdgeWidth(const DataSetId& id, float edgeWidth)
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setEdgeWidth(edgeWidth);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1051 +1437 @@
 void Renderer::setPolyDataWireframe(const DataSetId& id, bool state)
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setWireframe(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1063 +1464 @@
 void Renderer::setPolyDataLighting(const DataSetId& id, bool state)
 {
-    PolyData *polyData = getPolyData(id);
-    if (polyData) {
-        polyData->setLighting(state);
-        _needsRedraw = true;
-    }
+    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;
 }
 
@@ -1457 +1873 @@
 void Renderer::setOpacity(const 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;
-    }
+    setPseudoColorOpacity(id, opacity);
+    setContourOpacity(id, opacity);
+    setPolyDataOpacity(id, opacity);
 }
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -154 +154 @@
     vtkLookupTable *getPseudoColorColorMap(const DataSetId& id);
 
+    void setPseudoColorOpacity(const DataSetId& id, double opacity);
+
     void setPseudoColorVisibility(const DataSetId& id, bool state);
 
@@ -175 +177 @@
 
     void setContourList(const DataSetId& id, const std::vector<double>& contours);
+
+    void setContourOpacity(const DataSetId& id, double opacity);
 
     void setContourVisibility(const DataSetId& id, bool state);
@@ -191 +195 @@
 
     PolyData *getPolyData(const DataSetId& id);
+
+    void setPolyDataOpacity(const DataSetId& id, double opacity);
 
     void setPolyDataVisibility(const DataSetId& id, bool state);

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -433 +433 @@
                           Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[4]);
-    g_renderer->addContour2D(name);
     std::vector<double> contourList;
 
@@ -452 +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;
 }
@@ -460 +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);
@@ -507 +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;
 }
@@ -520 +534 @@
                      Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -527 +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;
 }
@@ -535 +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;
 }
@@ -548 +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"},
+    {"add", 1, Contour2DAddOp, 4, 5, "oper value ?dataSetName?"},
     {"delete", 1, Contour2DDeleteOp, 2, 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"}
+    {"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);
@@ -724 +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;
 }
@@ -737 +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;
 }
@@ -750 +802 @@
     {"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);
@@ -811 +863 @@
                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;
 }
@@ -821 +877 @@
 {
     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;
 }
@@ -840 +900 @@
 
 static int
-PseudoColorVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                     Tcl_Obj *const *objv)
-{
-    const char *name = Tcl_GetString(objv[3]);
+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;
 }
@@ -882 +937 @@
                        Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -889 +943 @@
         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;
 }
@@ -897 +956 @@
                        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"},
+    {"add", 1, PseudoColorAddOp, 2, 3, "?dataSetName?"},
+    {"colormap", 1, PseudoColorColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"delete", 1, PseudoColorDeleteOp, 2, 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"}
+    {"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);
@@ -936 +1034 @@
               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;
 }
@@ -958 +1060 @@
                 Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -965 +1066 @@
         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;
 }
@@ -973 +1079 @@
                          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;
 }
@@ -986 +1096 @@
                    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;
 }
@@ -999 +1113 @@
                     Tcl_Obj *const *objv)
 {
-    const char *name = Tcl_GetString(objv[5]);
     float color[3];
     if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
@@ -1006 +1119 @@
         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;
 }
@@ -1014 +1132 @@
                     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;
 }
@@ -1027 +1166 @@
                   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;
 }
@@ -1040 +1183 @@
                     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"},
+    {"add", 1, PolyDataAddOp, 2, 3, "?dataSetName?"},
+    {"color", 1, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
     {"delete", 1, PolyDataDeleteOp, 2, 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"}
+    {"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);

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -44 +44 @@
 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?>
 
-pseudocolor add <datasetName>
-pseudocolor colormap <colormapName> <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>
+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?>
 
-contour2d add numcontours <n> <datasetName>
-contour2d add contourlist <list> <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>
+contour2d lighting <bool> <?datasetName?>
+contour2d linecolor <r> <g> <b> <?datasetName?>
+contour2d linewidth <val> <?datasetName?>
+contour2d opacity <val> <?datasetName?>
+contour2d visible <bool> <?datasetName?>
 
-polydata add <datasetName>
-polydata color <r> <g> <b> <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 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?>
 
 ================================================================================