Changeset 2320 for trunk/packages

Timestamp:

Jul 28, 2011, 1:31:48 PM (13 years ago)

Author:

ldelgass

Message:

Add Molecule (ball-and-stick) and Line Integral Convolution (LIC) rendering to
vtkvis. LIC is a work in progress, and rendering LIC textures on PolyDatas?
conflicts with offscreen rendering in the main render window. However, LIC
textures on other data sets work, as the vtkImageDataLIC2D class will create
it's own render window/context for its FBOs.

Location:

trunk/packages/vizservers/vtkvis

Files:

• ColorMap.cpp (modified) (5 diffs)
• ColorMap.h (modified) (1 diff)
• Makefile.in (modified) (2 diffs)
• RpHeightMap.cpp (modified) (3 diffs)
• RpLIC.cpp (added)
• RpLIC.h (added)
• RpMolecule.cpp (added)
• RpMolecule.h (added)
• RpPolyData.cpp (modified) (1 diff)
• RpPolyData.h (modified) (1 diff)
• RpPseudoColor.cpp (modified) (1 diff)
• RpPseudoColor.h (modified) (1 diff)
• RpVolume.cpp (modified) (2 diffs)
• RpVtkDataSet.cpp (modified) (2 diffs)
• RpVtkRenderer.cpp (modified) (19 diffs)
• RpVtkRenderer.h (modified) (5 diffs)
• RpVtkRendererCmd.cpp (modified) (4 diffs)
• protocol.txt (modified) (1 diff)
• vtkRpCubeAxesActor2D.h (modified) (1 diff)

trunk/packages/vizservers/vtkvis/ColorMap.cpp

@@ -15 +15 @@
 
 #include "ColorMap.h"
+#include "RpMolecule.h"
 #include "Trace.h"
 
@@ -21 +22 @@
 ColorMap *ColorMap::_default = NULL;
 ColorMap *ColorMap::_volumeDefault = NULL;
+ColorMap *ColorMap::_elementDefault = NULL;
 
 ColorMap::ColorMap(const std::string& name) :
@@ -278 +280 @@
  * \brief Create a default ColorMap with a blue-cyan-green-yellow-red ramp
  */
-ColorMap * ColorMap::getDefault()
+ColorMap *ColorMap::getDefault()
 {
     if (_default != NULL) {
@@ -324 +326 @@
  * and transparent to opaque ramp
  */
-ColorMap * ColorMap::getVolumeDefault()
+ColorMap *ColorMap::getVolumeDefault()
 {
     if (_volumeDefault != NULL) {
@@ -365 +367 @@
     return _volumeDefault;
 }
+
+/**
+ * \brief Create a default ColorMap for coloring by atomic
+ * number in Molecules
+ */
+ColorMap *ColorMap::getElementDefault()
+{
+    if (_elementDefault != NULL) {
+        return _elementDefault;
+    }
+
+    _elementDefault = Molecule::createElementColorMap();
+    return _elementDefault;
+}

trunk/packages/vizservers/vtkvis/ColorMap.h

@@ -105 +105 @@
     static ColorMap *getDefault();
     static ColorMap *getVolumeDefault();
+    static ColorMap *getElementDefault();
 
 private:
     static ColorMap *_default;
     static ColorMap *_volumeDefault;
+    static ColorMap *_elementDefault;
 
     ColorMap();

trunk/packages/vizservers/vtkvis/Makefile.in

@@ -79 +79 @@
                 RpGlyphs.cpp \
                 RpHeightMap.cpp \
+                RpLIC.cpp \
+                RpMolecule.cpp \
                 RpPolyData.cpp \
                 RpPseudoColor.cpp \
@@ -125 +127 @@
 
 CmdProc.o: CmdProc.h
-ColorMap.o: ColorMap.h Trace.h
+ColorMap.o: ColorMap.h RpMolecule.h Trace.h
 PPMWriter.o: PPMWriter.h Trace.h
 RpContour2D.o: RpContour2D.h RpVtkDataSet.h Trace.h
 RpContour3D.o: RpContour3D.h RpVtkDataSet.h Trace.h
-RpPolyData.o: RpPolyData.h RpVtkDataSet.h Trace.h
 RpGlyphs.o: RpGlyphs.h RpVtkDataSet.h ColorMap.h Trace.h
 RpHeightMap.o: RpHeightMap.h RpVtkDataSet.h Trace.h
+RpLIC.o: RpLIC.h RpVtkDataSet.h Trace.h RpVtkRenderServer.h
+RpMolecule.o: RpMolecule.h RpMoleculeData.h RpVtkDataSet.h ColorMap.h Trace.h
+RpPolyData.o: RpPolyData.h RpVtkDataSet.h Trace.h
 RpPseudoColor.o: RpPseudoColor.h RpVtkDataSet.h Trace.h
 RpStreamlines.o: RpStreamlines.h RpVtkDataSet.h Trace.h
 RpVolume.o: RpVolume.h RpVtkDataSet.h ColorMap.h Trace.h
 RpVtkDataSet.o: RpVtkDataSet.h Trace.h
-RpVtkRenderer.o: RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpPolyData.h RpGlyphs.h RpHeightMap.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
-RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h CmdProc.h ColorMap.h PPMWriter.h TGAWriter.h
-RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRenderer.h RpVtkDataSet.h RpPseudoColor.h RpContour2D.h Trace.h PPMWriter.h TGAWriter.h
+RpVtkRenderer.o: RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
+RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h Trace.h PPMWriter.h TGAWriter.h
 Trace.o: Trace.h
 TGAWriter.o: TGAWriter.h Trace.h

trunk/packages/vizservers/vtkvis/RpHeightMap.cpp

@@ -115 +115 @@
 
 /**
- * \brief Internal method to set up color mapper after a state change
+ * \brief Internal method to set up pipeline after a state change
  */
 void HeightMap::update()
@@ -482 +482 @@
 
     if (_volumeSlicer == NULL &&
-         _probeFilter == NULL) {
+        _probeFilter == NULL) {
         WARN("Called before update() or DataSet is not a volume");
         return;
@@ -589 +589 @@
         }
 
-        _volumeSlicer->SetVOI(voi[0], voi[1], voi[2], voi[3], voi[4], voi[5]);
+        _volumeSlicer->SetVOI(voi);
     }
 

trunk/packages/vizservers/vtkvis/RpPolyData.cpp

@@ -95 +95 @@
 
 /**
- * \brief Internal method to re-compute contours after a state change
+ * \brief Internal method to set up pipeline after a state change
  */
 void PolyData::update()

trunk/packages/vizservers/vtkvis/RpPolyData.h

@@ -12 +12 @@
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
-
-#include <vector>
 
 #include "RpVtkDataSet.h"

trunk/packages/vizservers/vtkvis/RpPseudoColor.cpp

@@ -71 +71 @@
 
 /**
- * \brief Internal method to set up color mapper after a state change
+ * \brief Internal method to set up pipeline after a state change
  */
 void PseudoColor::update()

trunk/packages/vizservers/vtkvis/RpPseudoColor.h

@@ -14 +14 @@
 #include <vtkActor.h>
 #include <vtkPlaneCollection.h>
-
-#include <vector>
 
 #include "RpVtkDataSet.h"

trunk/packages/vizservers/vtkvis/RpVolume.cpp

@@ -46 +46 @@
  * \brief Specify input DataSet with scalars
  *
- * Currently the DataSet must be image data (2D uniform grid),
+ * Currently the DataSet must be image data (3D uniform grid),
  * or an UnstructuredGrid
  */
@@ -66 +66 @@
 
 /**
- * \brief Internal method to set up volume mapper after a state change
+ * \brief Internal method to set up pipeline after a state change
  */
 void Volume::update()

trunk/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -75 +75 @@
     reader->ReadAllScalarsOn();
     reader->ReadAllVectorsOn();
+    reader->ReadAllFieldsOn();
     return setData(reader);
 }
@@ -98 +99 @@
     reader->ReadAllScalarsOn();
     reader->ReadAllVectorsOn();
+    reader->ReadAllFieldsOn();
 
     bool status = setData(reader);

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -128 +128 @@
     addColorMap("default", ColorMap::getDefault());
     addColorMap("volumeDefault", ColorMap::getVolumeDefault());
+    addColorMap("elementDefault", ColorMap::getElementDefault());
 }
 
@@ -157 +158 @@
     }
     _heightMaps.clear();
+    TRACE("Deleting LICs");
+    for (LICHashmap::iterator itr = _lics.begin();
+             itr != _lics.end(); ++itr) {
+        delete itr->second;
+    }
+    _lics.clear();
+    TRACE("Deleting Molecules");
+    for (MoleculeHashmap::iterator itr = _molecules.begin();
+             itr != _molecules.end(); ++itr) {
+        delete itr->second;
+    }
+    _molecules.clear();
     TRACE("Deleting PolyDatas");
     for (PolyDataHashmap::iterator itr = _polyDatas.begin();
@@ -208 +221 @@
 {
     if (getDataSet(id) != NULL) {
-        WARN("Replacing existing dataset %s", id.c_str());
+        WARN("Replacing existing DataSet %s", id.c_str());
         deleteDataSet(id);
     }
@@ -354 +367 @@
         itr = _heightMaps.erase(itr);
     } while (doAll && itr != _heightMaps.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Remove the LIC for the specified DataSet
+ *
+ * The underlying LIC is deleted, freeing its memory
+ */
+void Renderer::deleteLIC(const DataSetId& id)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting LICs for %s", id.c_str());
+
+    do {
+        LIC *lic = itr->second;
+        if (lic->getProp())
+            _renderer->RemoveViewProp(lic->getProp());
+        delete lic;
+
+        itr = _lics.erase(itr);
+    } while (doAll && itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Remove the Molecule for the specified DataSet
+ *
+ * The underlying Molecule is deleted, freeing its memory
+ */
+void Renderer::deleteMolecule(const DataSetId& id)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting Molecules for %s", id.c_str());
+
+    do {
+        Molecule *molecule = itr->second;
+        if (molecule->getProp())
+            _renderer->RemoveViewProp(molecule->getProp());
+        delete molecule;
+
+        itr = _molecules.erase(itr);
+    } while (doAll && itr != _molecules.end());
 
     _needsRedraw = true;
@@ -532 +617 @@
         deleteGlyphs(itr->second->getName());
         deleteHeightMap(itr->second->getName());
+        deleteLIC(itr->second->getName());
+        deleteMolecule(itr->second->getName());
         deletePolyData(itr->second->getName());
         deletePseudoColor(itr->second->getName());
@@ -898 +985 @@
         colorMap->build();
         if (getColorMap(id) != NULL) {
-            WARN("Replacing existing colormap %s", id.c_str());
+            WARN("Replacing existing ColorMap %s", id.c_str());
             deleteColorMap(id);
         }
@@ -1085 +1172 @@
 
         if (getContour2D(dsID)) {
-            WARN("Replacing existing contour2d %s", dsID.c_str());
+            WARN("Replacing existing Contour2D %s", dsID.c_str());
             deleteContour2D(dsID);
         }
@@ -1334 +1421 @@
 
         if (getContour3D(dsID)) {
-            WARN("Replacing existing contour3d %s", dsID.c_str());
+            WARN("Replacing existing Contour3D %s", dsID.c_str());
             deleteContour3D(dsID);
         }
@@ -2461 +2548 @@
 
 /**
- * \brief Create a new PolyData and associate it with the named DataSet
- */
-void Renderer::addPolyData(const DataSetId& id)
+ * \brief Create a new LIC and associate it with the named DataSet
+ */
+void Renderer::addLIC(const DataSetId& id)
 {
     DataSetHashmap::iterator itr;
@@ -2483 +2570 @@
         const DataSetId& dsID = ds->getName();
 
+        if (getLIC(dsID)) {
+            WARN("Replacing existing LIC %s", dsID.c_str());
+            deleteLIC(dsID);
+        }
+
+        LIC *lic = new LIC();
+        _lics[dsID] = lic;
+
+        lic->setDataSet(ds);
+
+        _renderer->AddViewProp(lic->getProp());
+    } while (doAll && ++itr != _dataSets.end());
+
+    if (_cameraMode == IMAGE)
+        setCameraMode(PERSPECTIVE);
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Get the LIC associated with a named DataSet
+ */
+LIC *Renderer::getLIC(const DataSetId& id)
+{
+    LICHashmap::iterator itr = _lics.find(id);
+
+    if (itr == _lics.end()) {
+        TRACE("LIC not found: %s", id.c_str());
+        return NULL;
+    } else
+        return itr->second;
+}
+
+/**
+ * \brief Set the volume slice used for mapping volumetric data
+ */
+void Renderer::setLICVolumeSlice(const DataSetId& id, LIC::Axis axis, double ratio)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->selectVolumeSlice(axis, ratio);
+     } while (doAll && ++itr != _lics.end());
+
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Associate an existing named color map with an LIC for the given DataSet
+ */
+void Renderer::setLICColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+
+    if (itr == _lics.end()) {
+        ERROR("LIC 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 LIC color map: %s for dataset %s", colorMapId.c_str(),
+              itr->second->getDataSet()->getName().c_str());
+
+        // Make a copy of the generic colormap lookup table, so 
+        // data range can be set in the copy table to match the 
+        // dataset being plotted
+        vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
+        lut->DeepCopy(cmap->getLookupTable());
+
+        if (_useCumulativeRange) {
+            lut->SetRange(_cumulativeDataRange);
+        } else {
+            if (itr->second->getDataSet() != NULL) {
+                double range[2];
+                itr->second->getDataSet()->getDataRange(range);
+                lut->SetRange(range);
+            }
+        }
+
+        itr->second->setLookupTable(lut);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of the LIC for the given DataSet
+ */
+void Renderer::setLICOpacity(const DataSetId& id, double opacity)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering of the LIC for the given DataSet
+ */
+void Renderer::setLICVisibility(const DataSetId& id, bool state)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the visibility of polygon edges for the specified DataSet
+ */
+void Renderer::setLICEdgeVisibility(const DataSetId& id, bool state)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB polygon edge color for the specified DataSet
+ */
+void Renderer::setLICEdgeColor(const DataSetId& id, float color[3])
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the polygon edge width for the specified DataSet (may be a no-op)
+ *
+ * If the OpenGL implementation/hardware does not support wide lines, 
+ * this function may not have an effect.
+ */
+void Renderer::setLICEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn LIC lighting on/off for the specified DataSet
+ */
+void Renderer::setLICLighting(const DataSetId& id, bool state)
+{
+    LICHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _lics.begin();
+        doAll = true;
+    } else {
+        itr = _lics.find(id);
+    }
+    if (itr == _lics.end()) {
+        ERROR("LIC not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _lics.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Create a new Molecule and associate it with the named DataSet
+ */
+void Renderer::addMolecule(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 (getMolecule(dsID)) {
+            WARN("Replacing existing Molecule %s", dsID.c_str());
+            deleteMolecule(dsID);
+        }
+
+        Molecule *molecule = new Molecule();
+        _molecules[dsID] = molecule;
+
+        molecule->setDataSet(ds);
+
+        _renderer->AddViewProp(molecule->getProp());
+    } while (doAll && ++itr != _dataSets.end());
+
+    if (_cameraMode == IMAGE)
+        setCameraMode(PERSPECTIVE);
+    initCamera();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Get the Molecule associated with a named DataSet
+ */
+Molecule *Renderer::getMolecule(const DataSetId& id)
+{
+    MoleculeHashmap::iterator itr = _molecules.find(id);
+
+    if (itr == _molecules.end()) {
+        TRACE("Molecule not found: %s", id.c_str());
+        return NULL;
+    } else
+        return itr->second;
+}
+
+/**
+ * \brief Associate an existing named color map with a Molecule for the given DataSet
+ */
+void Renderer::setMoleculeColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+
+    if (itr == _molecules.end()) {
+        ERROR("Molecule 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 Molecule color map: %s for dataset %s", colorMapId.c_str(),
+              itr->second->getDataSet()->getName().c_str());
+
+        // Make a copy of the generic colormap lookup table, so 
+        // data range can be set in the copy table to match the 
+        // dataset being plotted
+        vtkSmartPointer<vtkLookupTable> lut = vtkSmartPointer<vtkLookupTable>::New();
+        lut->DeepCopy(cmap->getLookupTable());
+
+        if (_useCumulativeRange) {
+            lut->SetRange(_cumulativeDataRange);
+        } else {
+            if (itr->second->getDataSet() != NULL) {
+                double range[2];
+                itr->second->getDataSet()->getDataRange(range);
+                lut->SetRange(range);
+            }
+        }
+
+        itr->second->setLookupTable(lut);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of the Molecule for the given DataSet
+ */
+void Renderer::setMoleculeOpacity(const DataSetId& id, double opacity)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set radius standard for scaling atoms
+ */
+void Renderer::setMoleculeAtomScaling(const DataSetId& id, Molecule::AtomScaling scaling)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setAtomScaling(scaling);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering of the Molecule atoms for the given DataSet
+ */
+void Renderer::setMoleculeAtomVisibility(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setAtomVisibility(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering of the Molecule bonds for the given DataSet
+ */
+void Renderer::setMoleculeBondVisibility(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setBondVisibility(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering of the Molecule for the given DataSet
+ */
+void Renderer::setMoleculeVisibility(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the visibility of polygon edges for the specified DataSet
+ */
+void Renderer::setMoleculeEdgeVisibility(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB polygon edge color for the specified DataSet
+ */
+void Renderer::setMoleculeEdgeColor(const DataSetId& id, float color[3])
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the polygon edge width for the specified DataSet (may be a no-op)
+ *
+ * If the OpenGL implementation/hardware does not support wide lines, 
+ * this function may not have an effect.
+ */
+void Renderer::setMoleculeEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set wireframe rendering for the specified DataSet
+ */
+void Renderer::setMoleculeWireframe(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setWireframe(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn Molecule lighting on/off for the specified DataSet
+ */
+void Renderer::setMoleculeLighting(const DataSetId& id, bool state)
+{
+    MoleculeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _molecules.begin();
+        doAll = true;
+    } else {
+        itr = _molecules.find(id);
+    }
+    if (itr == _molecules.end()) {
+        ERROR("Molecule not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _molecules.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Create a new PolyData and associate it with the named DataSet
+ */
+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());
+            WARN("Replacing existing PolyData %s", dsID.c_str());
             deletePolyData(dsID);
         }
@@ -2758 +3530 @@
 
         if (getPseudoColor(dsID)) {
-            WARN("Replacing existing pseudocolor %s", dsID.c_str());
+            WARN("Replacing existing PseudoColor %s", dsID.c_str());
             deletePseudoColor(dsID);
         }
@@ -3615 +4387 @@
 
         if (getVolume(dsID)) {
-            WARN("Replacing existing volume %s", dsID.c_str());
+            WARN("Replacing existing Volume %s", dsID.c_str());
             deleteVolume(dsID);
         }
@@ -3855 +4627 @@
 }
 
+/**
+ * \brief Set camera FOV based on render window height
+ * 
+ * Computes a field-of-view angle based on some assumptions about
+ * viewer's distance to screen and pixel density
+ */
 void Renderer::setViewAngle(int height)
 {
     // Distance of eyes from screen in inches
     double d = 20.0;
-    // Assume 72 dpi screen
+    // Assume 72 ppi screen
     double h = (double)height / 72.0;
 
@@ -4220 +4998 @@
 
 /**
- * \brief Change the FOV of the camera
+ * \brief Dolly camera or set orthographic scaling based on camera type
  *
  * \param[in] z Ratio to change zoom (greater than 1 is zoom in, less than 1 is zoom out)
@@ -4515 +5293 @@
             mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
     }
+    for (LICHashmap::iterator itr = _lics.begin();
+             itr != _lics.end(); ++itr) {
+        if (!onlyVisible || itr->second->getVisibility())
+            mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
+    }
+    for (MoleculeHashmap::iterator itr = _molecules.begin();
+             itr != _molecules.end(); ++itr) {
+        if (!onlyVisible || itr->second->getVisibility())
+            mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
+    }
     for (PolyDataHashmap::iterator itr = _polyDatas.begin();
              itr != _polyDatas.end(); ++itr) {
@@ -4617 +5405 @@
             } else {
                 itr->second->setContours(itr->second->getNumContours());
+            }
+        }
+    }
+    for (LICHashmap::iterator itr = _lics.begin();
+         itr != _lics.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);
+                }
             }
         }
@@ -4796 +5599 @@
     if (id.compare("all") == 0 || getHeightMap(id) != NULL)
         setHeightMapOpacity(id, opacity);
+    if (id.compare("all") == 0 || getLIC(id) != NULL)
+        setLICOpacity(id, opacity);
+    if (id.compare("all") == 0 || getMolecule(id) != NULL)
+        setMoleculeOpacity(id, opacity);
     if (id.compare("all") == 0 || getPolyData(id) != NULL)
         setPolyDataOpacity(id, opacity);
@@ -4838 +5645 @@
     if (id.compare("all") == 0 || getHeightMap(id) != NULL)
         setHeightMapVisibility(id, state);
+    if (id.compare("all") == 0 || getLIC(id) != NULL)
+        setLICVisibility(id, state);
+    if (id.compare("all") == 0 || getMolecule(id) != NULL)
+        setMoleculeVisibility(id, state);
     if (id.compare("all") == 0 || getPolyData(id) != NULL)
         setPolyDataVisibility(id, state);
@@ -4993 +5804 @@
         itr->second->setClippingPlanes(_activeClipPlanes);
     }
+    for (LICHashmap::iterator itr = _lics.begin();
+         itr != _lics.end(); ++itr) {
+        itr->second->setClippingPlanes(_activeClipPlanes);
+    }
+    for (MoleculeHashmap::iterator itr = _molecules.begin();
+         itr != _molecules.end(); ++itr) {
+        itr->second->setClippingPlanes(_activeClipPlanes);
+    }
     for (PolyDataHashmap::iterator itr = _polyDatas.begin();
          itr != _polyDatas.end(); ++itr) {

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -31 +31 @@
 #include "RpGlyphs.h"
 #include "RpHeightMap.h"
+#include "RpLIC.h"
+#include "RpMolecule.h"
 #include "RpPolyData.h"
 #include "RpPseudoColor.h"
@@ -81 +83 @@
     typedef std::tr1::unordered_map<DataSetId, Glyphs *> GlyphsHashmap;
     typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
+    typedef std::tr1::unordered_map<DataSetId, LIC *> LICHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Molecule *> MoleculeHashmap;
     typedef std::tr1::unordered_map<DataSetId, PolyData *> PolyDataHashmap;
     typedef std::tr1::unordered_map<DataSetId, PseudoColor *> PseudoColorHashmap;
@@ -109 +113 @@
 
     // Render window
+
+    vtkRenderWindow *getRenderWindow()
+    {
+        return _renderWindow;
+    }
 
     void setWindowSize(int width, int height);
@@ -302 +311 @@
     void setHeightMapLighting(const DataSetId& id, bool state);
 
-    // Meshes
+    // LIC plots
+
+    void addLIC(const DataSetId& id);
+    
+    void deleteLIC(const DataSetId& id);
+
+    LIC *getLIC(const DataSetId& id);
+
+    void setLICVolumeSlice(const DataSetId& id, LIC::Axis axis, double ratio);
+
+    void setLICColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    void setLICOpacity(const DataSetId& id, double opacity);
+
+    void setLICVisibility(const DataSetId& id, bool state);
+
+    void setLICEdgeVisibility(const DataSetId& id, bool state);
+
+    void setLICEdgeColor(const DataSetId& id, float color[3]);
+
+    void setLICEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setLICLighting(const DataSetId& id, bool state);
+
+    // Molecules
+
+    void addMolecule(const DataSetId& id);
+    
+    void deleteMolecule(const DataSetId& id);
+
+    Molecule *getMolecule(const DataSetId& id);
+
+    void setMoleculeColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    void setMoleculeOpacity(const DataSetId& id, double opacity);
+
+    void setMoleculeAtomScaling(const DataSetId& id, Molecule::AtomScaling scaling);
+
+    void setMoleculeAtomVisibility(const DataSetId& id, bool state);
+
+    void setMoleculeBondVisibility(const DataSetId& id, bool state);
+
+    void setMoleculeVisibility(const DataSetId& id, bool state);
+
+    void setMoleculeEdgeVisibility(const DataSetId& id, bool state);
+
+    void setMoleculeEdgeColor(const DataSetId& id, float color[3]);
+
+    void setMoleculeEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setMoleculeWireframe(const DataSetId& id, bool state);
+
+    void setMoleculeLighting(const DataSetId& id, bool state);
+
+    // PolyData Meshes
 
     void addPolyData(const DataSetId& id);
@@ -465 +528 @@
     GlyphsHashmap _glyphs;
     HeightMapHashmap _heightMaps;
+    LICHashmap _lics;
+    MoleculeHashmap _molecules;
     PolyDataHashmap _polyDatas;
     PseudoColorHashmap _pseudoColors;

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -1798 +1798 @@
 
 static int
+LICAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+         Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->addLIC(name);
+    } else {
+        g_renderer->addLIC("all");
+    }
+    return TCL_OK;
+}
+
+static int
+LICColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    const char *colorMapName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setLICColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setLICColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+LICDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteLIC(name);
+    } else {
+        g_renderer->deleteLIC("all");
+    }
+    return TCL_OK;
+}
+
+static int
+LICEdgeVisibilityOp(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->setLICEdgeVisibility(name, state);
+    } else {
+        g_renderer->setLICEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+LICLightingOp(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->setLICLighting(name, state);
+    } else {
+        g_renderer->setLICLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+LICLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setLICEdgeColor(name, color);
+    } else {
+        g_renderer->setLICEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+LICLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setLICEdgeWidth(name, width);
+    } else {
+        g_renderer->setLICEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+LICOpacityOp(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->setLICOpacity(name, opacity);
+    } else {
+        g_renderer->setLICOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+LICVisibleOp(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->setLICVisibility(name, state);
+    } else {
+        g_renderer->setLICVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+LICVolumeSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double ratio;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &ratio) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    LIC::Axis axis;
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        axis = LIC::X_AXIS;
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        axis = LIC::Y_AXIS;
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        axis = LIC::Z_AXIS;
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName ratio", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setLICVolumeSlice(name, axis, ratio);
+    } else {
+        g_renderer->setLICVolumeSlice("all", axis, ratio);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec licOps[] = {
+    {"add",         1, LICAddOp, 2, 3, "?dataSetName?"},
+    {"colormap",    1, LICColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete",      1, LICDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges",       1, LICEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting",    3, LICLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor",   5, LICLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth",   5, LICLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity",     1, LICOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"visible",     2, LICVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"volumeslice", 2, LICVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"}
+};
+static int nLICOps = NumCmdSpecs(licOps);
+
+static int
+LICCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+       Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nLICOps, licOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+MoleculeAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->addMolecule(name);
+    } else {
+        g_renderer->addMolecule("all");
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeAtomVisibilityOp(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->setMoleculeAtomVisibility(name, state);
+    } else {
+        g_renderer->setMoleculeAtomVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeAtomScalingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    Molecule::AtomScaling scaling;
+    const char *scalingOpt = Tcl_GetString(objv[2]);
+    if (scalingOpt[0] == 'v' && strcmp(scalingOpt, "van_der_waals") == 0) {
+        scaling = Molecule::VAN_DER_WAALS_RADIUS;
+    } else if (scalingOpt[0] == 'c' && strcmp(scalingOpt, "covalent") == 0) {
+        scaling = Molecule::COVALENT_RADIUS;
+    } else if (scalingOpt[0] == 'a' && strcmp(scalingOpt, "atomic") == 0) {
+        scaling = Molecule::ATOMIC_RADIUS;
+    } else if (scalingOpt[0] == 'n' && strcmp(scalingOpt, "none") == 0) {
+        scaling = Molecule::NO_ATOM_SCALING;
+    } else {
+        Tcl_AppendResult(interp, "bad atomscale option \"", scalingOpt,
+                         "\": should be van_der_waals, covalent, atomic, or none", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setMoleculeAtomScaling(name, scaling);
+    } else {
+        g_renderer->setMoleculeAtomScaling("all", scaling);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeBondVisibilityOp(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->setMoleculeBondVisibility(name, state);
+    } else {
+        g_renderer->setMoleculeBondVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    const char *colorMapName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setMoleculeColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setMoleculeColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteMolecule(name);
+    } else {
+        g_renderer->deleteMolecule("all");
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeEdgeVisibilityOp(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->setMoleculeEdgeVisibility(name, state);
+    } else {
+        g_renderer->setMoleculeEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeLightingOp(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->setMoleculeLighting(name, state);
+    } else {
+        g_renderer->setMoleculeLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setMoleculeEdgeColor(name, color);
+    } else {
+        g_renderer->setMoleculeEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setMoleculeEdgeWidth(name, width);
+    } else {
+        g_renderer->setMoleculeEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeOpacityOp(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->setMoleculeOpacity(name, opacity);
+    } else {
+        g_renderer->setMoleculeOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeVisibleOp(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->setMoleculeVisibility(name, state);
+    } else {
+        g_renderer->setMoleculeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeWireframeOp(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->setMoleculeWireframe(name, state);
+    } else {
+        g_renderer->setMoleculeWireframe("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec moleculeOps[] = {
+    {"add",        2, MoleculeAddOp, 2, 3, "?dataSetName?"},
+    {"atoms",      2, MoleculeAtomVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"bonds",      2, MoleculeBondVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"colormap",   1, MoleculeColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete",     1, MoleculeDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges",      1, MoleculeEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting",   3, MoleculeLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor",  5, MoleculeLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth",  5, MoleculeLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity",    1, MoleculeOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"scaleatoms", 1, MoleculeAtomScalingOp, 3, 4, "scaling ?dataSetName?"},
+    {"visible",    1, MoleculeVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"wireframe",  1, MoleculeWireframeOp, 3, 4, "bool ?dataSetName?"}
+};
+static int nMoleculeOps = NumCmdSpecs(moleculeOps);
+
+static int
+MoleculeCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nMoleculeOps, moleculeOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
+PolyDataAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->addPolyData(name);
+    } else {
+        g_renderer->addPolyData("all");
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deletePolyData(name);
+    } else {
+        g_renderer->deletePolyData("all");
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPolyDataColor(name, color);
+    } else {
+        g_renderer->setPolyDataColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataEdgeVisibilityOp(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->setPolyDataEdgeVisibility(name, state);
+    } else {
+        g_renderer->setPolyDataEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataLightingOp(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->setPolyDataLighting(name, state);
+    } else {
+        g_renderer->setPolyDataLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPolyDataEdgeColor(name, color);
+    } else {
+        g_renderer->setPolyDataEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->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;
+}
+
+static int
+PolyDataVisibleOp(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->setPolyDataVisibility(name, state);
+    } else {
+        g_renderer->setPolyDataVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataWireframeOp(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->setPolyDataWireframe(name, state);
+    } else {
+        g_renderer->setPolyDataWireframe("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec polyDataOps[] = {
+    {"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);
+
+static int
+PolyDataCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nPolyDataOps, polyDataOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 PseudoColorAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -1979 +2630 @@
 
     proc = Rappture::GetOpFromObj(interp, nPseudoColorOps, pseudoColorOps,
-                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
-    if (proc == NULL) {
-        return TCL_ERROR;
-    }
-    return (*proc) (clientData, interp, objc, objv);
-}
-
-static int
-PolyDataAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-              Tcl_Obj *const *objv)
-{
-    if (objc == 3) {
-        const char *name = Tcl_GetString(objv[2]);
-        g_renderer->addPolyData(name);
-    } else {
-        g_renderer->addPolyData("all");
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                 Tcl_Obj *const *objv)
-{
-    if (objc == 3) {
-        const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deletePolyData(name);
-    } else {
-        g_renderer->deletePolyData("all");
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                Tcl_Obj *const *objv)
-{
-    float color[3];
-    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
-        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
-        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    if (objc == 6) {
-        const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataColor(name, color);
-    } else {
-        g_renderer->setPolyDataColor("all", color);
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataEdgeVisibilityOp(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->setPolyDataEdgeVisibility(name, state);
-    } else {
-        g_renderer->setPolyDataEdgeVisibility("all", state);
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataLightingOp(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->setPolyDataLighting(name, state);
-    } else {
-        g_renderer->setPolyDataLighting("all", state);
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                    Tcl_Obj *const *objv)
-{
-    float color[3];
-    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
-        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
-        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    if (objc == 6) {
-        const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataEdgeColor(name, color);
-    } else {
-        g_renderer->setPolyDataEdgeColor("all", color);
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                    Tcl_Obj *const *objv)
-{
-    float width;
-    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->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;
-}
-
-static int
-PolyDataVisibleOp(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->setPolyDataVisibility(name, state);
-    } else {
-        g_renderer->setPolyDataVisibility("all", state);
-    }
-    return TCL_OK;
-}
-
-static int
-PolyDataWireframeOp(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->setPolyDataWireframe(name, state);
-    } else {
-        g_renderer->setPolyDataWireframe("all", state);
-    }
-    return TCL_OK;
-}
-
-static Rappture::CmdSpec polyDataOps[] = {
-    {"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);
-
-static int
-PolyDataCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
-            Tcl_Obj *const *objv)
-{
-    Tcl_ObjCmdProc *proc;
-
-    proc = Rappture::GetOpFromObj(interp, nPolyDataOps, polyDataOps,
                                   Rappture::CMDSPEC_ARG1, objc, objv, 0);
     if (proc == NULL) {
@@ -2964 +3421 @@
     Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   NULL, NULL);
     Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      NULL, NULL);
+    Tcl_CreateObjCommand(interp, "lic",         LICCmd,         NULL, NULL);
+    Tcl_CreateObjCommand(interp, "molecule",    MoleculeCmd,    NULL, NULL);
     Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    NULL, NULL);
     Tcl_CreateObjCommand(interp, "pseudocolor", PseudoColorCmd, NULL, NULL);
@@ -2989 +3448 @@
     Tcl_DeleteCommand(interp, "heightmap");
     Tcl_DeleteCommand(interp, "legend");
+    Tcl_DeleteCommand(interp, "lic");
+    Tcl_DeleteCommand(interp, "molecule");
     Tcl_DeleteCommand(interp, "polydata");
     Tcl_DeleteCommand(interp, "pseudocolor");

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -127 +127 @@
           For 3D data, select a slice along a principle axis of the volume. The
           ratio is [0,1]
+
+lic add <?datasetName?>
+lic colormap <colormapName> <?datasetName?>
+lic delete <?datasetName?>
+lic edges <bool> <?datasetName?>
+lic lighting <bool> <?datasetName?>
+lic linecolor <r> <g> <b> <?datasetName?>
+lic linewidth <val> <?datasetName?>
+lic opacity <val> <?datasetName?>
+lic visible <bool> <?datasetName?>
+lic volumeslice <axis> <ratio> <?datasetName?>
+
+molecule add <?datasetName?>
+molecule atoms <bool> <?datasetName?>
+         Toggle rendering of atoms
+molecule bonds <bool> <?datasetName?>
+         Toggle rendering of bonds
+molecule colormap <colormapName> <?datasetName?>
+molecule delete <?datasetName?>
+molecule edges <bool> <?datasetName?>
+molecule lighting <bool> <?datasetName?>
+molecule linecolor <r> <g> <b> <?datasetName?>
+molecule linewidth <val> <?datasetName?>
+molecule opacity <val> <?datasetName?>
+molecule scaleatoms <val> <?dataSetName?>
+         val = van_der_walls|covalent|atomic|none
+molecule visible <bool> <?datasetName?>
+molecule wireframe <bool> <?datasetName?>
 
 polydata add <?datasetName?>

trunk/packages/vizservers/vtkvis/vtkRpCubeAxesActor2D.h

@@ -41 +41 @@
 // vtkActor2D vtkAxisActor2D vtkXYPlotActor vtkTextProperty
 
-#ifndef __vtkCubeAxesActor2D_h
-#define __vtkCubeAxesActor2D_h
+#ifndef __vtkRpCubeAxesActor2D_h
+#define __vtkRpCubeAxesActor2D_h
 
 #include "vtkActor2D.h"