Changeset 2393 for trunk/packages

Timestamp:

Aug 17, 2011, 12:13:00 AM (13 years ago)

Author:

ldelgass

Message:

• Color mode for streamlines to allow color mapping by scalar or vector data
• Set active scalar/vector arrays on data sets
• Constant color option for glyphs/streamlines
• Fixes for face culling (2 glyph shapes have flipped faces)

Note that these changes will require some fixes for cumulative ranges on multiple data sets as well as legend rendering.

Location:

trunk/packages/vizservers/vtkvis

Files:

• RpGlyphs.cpp (modified) (7 diffs)
• RpGlyphs.h (modified) (2 diffs)
• RpMolecule.cpp (modified) (3 diffs)
• RpPolyData.cpp (modified) (3 diffs)
• RpStreamlines.cpp (modified) (13 diffs)
• RpStreamlines.h (modified) (4 diffs)
• RpVtkDataSet.cpp (modified) (2 diffs)
• RpVtkDataSet.h (modified) (1 diff)
• RpVtkGraphicsObject.h (modified) (10 diffs)
• RpVtkRenderer.cpp (modified) (21 diffs)
• RpVtkRenderer.h (modified) (7 diffs)
• RpVtkRendererCmd.cpp (modified) (10 diffs)
• protocol.txt (modified) (4 diffs)

trunk/packages/vizservers/vtkvis/RpGlyphs.cpp

@@ -29 +29 @@
     VtkGraphicsObject(),
     _glyphShape(ARROW),
-    _scaleFactor(1.0)
-{
-    _backfaceCulling = true;
+    _scaleFactor(1.0),
+    _colorMode(COLOR_BY_SCALAR)
+{
+    _faceCulling = true;
 }
 
@@ -81 +82 @@
         return;
     }
+
+    if (_glyphShape == ICOSAHEDRON ||
+        _glyphShape == TETRAHEDRON) {
+        // These shapes are created with front faces pointing inside
+        setCullFace(CULL_FRONT);
+    } else {
+        setCullFace(CULL_BACK);
+    }
+
     if (_glyphGenerator != NULL) {
         _glyphGenerator->SetSourceConnection(_glyphSource->GetOutputPort());
@@ -96 +106 @@
 
     vtkDataSet *ds = _dataSet->getVtkDataSet();
-    double dataRange[2];
-    _dataSet->getDataRange(dataRange);
 
     if (_glyphGenerator == NULL) {
         _glyphGenerator = vtkSmartPointer<vtkGlyph3D>::New();
     }
+
+    initProp();
 
     setGlyphShape(_glyphShape);
@@ -134 +144 @@
 
     if (ds->GetPointData()->GetScalars() == NULL) {
+        TRACE("Setting color mode to vector magnitude");
         _glyphGenerator->SetColorModeToColorByVector();
-    } else {
+        _colorMode = COLOR_BY_VECTOR;
+    } else {
+        TRACE("Setting color mode to scalar");
         _glyphGenerator->SetColorModeToColorByScalar();
-     }
+        _colorMode = COLOR_BY_SCALAR;
+    }
     if (_glyphShape == SPHERE) {
         _glyphGenerator->OrientOff();
@@ -166 +180 @@
 
     if (ds->GetPointData()->GetScalars() == NULL) {
-        _pdMapper->UseLookupTableScalarRangeOff();
-    } else {
+        double dataRange[2];
+        _dataSet->getVectorMagnitudeRange(dataRange);
         _lut->SetRange(dataRange);
-        _pdMapper->UseLookupTableScalarRangeOn();
-    }
-
+        //_pdMapper->SetScalarModeToUsePointFieldData();
+        //_pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+    } else {
+        double dataRange[2];
+        _dataSet->getDataRange(dataRange);
+        _lut->SetRange(dataRange);
+        //_pdMapper->SetScalarModeToDefault();
+    }
+
+    //_lut->SetVectorModeToMagnitude();
     _pdMapper->SetLookupTable(_lut);
-
-    initProp();
+    _pdMapper->UseLookupTableScalarRangeOn();
 
     getActor()->SetMapper(_pdMapper);
@@ -213 +233 @@
 void Glyphs::setColorMode(ColorMode mode)
 {
+    _colorMode = mode;
     if (_glyphGenerator != NULL) {
         switch (mode) {
         case COLOR_BY_SCALE:
             _glyphGenerator->SetColorModeToColorByScale();
-            break;
-        case COLOR_BY_VECTOR:
+            _pdMapper->ScalarVisibilityOn();
+            break;
+        case COLOR_BY_VECTOR: {
             _glyphGenerator->SetColorModeToColorByVector();
-            break;
-        case COLOR_BY_SCALAR:
+           _pdMapper->ScalarVisibilityOn();
+            double dataRange[2];
+            _dataSet->getVectorMagnitudeRange(dataRange);
+            _lut->SetRange(dataRange);
+        }
+            break;
+        case COLOR_BY_SCALAR: {
+            _glyphGenerator->SetColorModeToColorByScalar();
+           _pdMapper->ScalarVisibilityOn();
+            double dataRange[2];
+            _dataSet->getDataRange(dataRange);
+            _lut->SetRange(dataRange);
+        }
+            break;
+        case COLOR_CONSTANT:
         default:
-            _glyphGenerator->SetColorModeToColorByScalar();
-            break;
+            _pdMapper->ScalarVisibilityOff();
         }
         _pdMapper->Update();
@@ -261 +295 @@
     }
 
+    switch (_colorMode) {
+    case COLOR_BY_VECTOR: {
+        double dataRange[2];
+        _dataSet->getVectorMagnitudeRange(dataRange);
+        _lut->SetRange(dataRange);
+    }
+        break;
+    case COLOR_BY_SCALAR:
+    default: {
+        double dataRange[2];
+        _dataSet->getDataRange(dataRange);
+        _lut->SetRange(dataRange);
+    }
+        break;
+    }
+
     if (_pdMapper != NULL) {
         _pdMapper->SetLookupTable(_lut);

trunk/packages/vizservers/vtkvis/RpGlyphs.h

@@ -52 +52 @@
         COLOR_BY_SCALE,
         COLOR_BY_SCALAR,
-        COLOR_BY_VECTOR
+        COLOR_BY_VECTOR,
+        COLOR_CONSTANT
     };
 
@@ -82 +83 @@
     GlyphShape _glyphShape;
     double _scaleFactor;
+    ColorMode _colorMode;
 
     vtkSmartPointer<vtkLookupTable> _lut;

trunk/packages/vizservers/vtkvis/RpMolecule.cpp

@@ -29 +29 @@
     _atomScaling(NO_ATOM_SCALING)
 {
-    _backfaceCulling = true;
+    _faceCulling = true;
 }
 
@@ -49 +49 @@
     if (_atomProp == NULL) {
         _atomProp = vtkSmartPointer<vtkActor>::New();
-        if (_backfaceCulling && _opacity == 1.0)
-            _atomProp->GetProperty()->BackfaceCullingOn();
+        if (_faceCulling && _opacity == 1.0)
+            setCulling(_atomProp->GetProperty(), true);
         _atomProp->GetProperty()->EdgeVisibilityOff();
         _atomProp->GetProperty()->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
@@ -61 +61 @@
     if (_bondProp == NULL) {
         _bondProp = vtkSmartPointer<vtkActor>::New();
-        if (_backfaceCulling && _opacity == 1.0)
-            _bondProp->GetProperty()->BackfaceCullingOn();
+        if (_faceCulling && _opacity == 1.0)
+            setCulling(_bondProp->GetProperty(), true);
         _bondProp->GetProperty()->EdgeVisibilityOff();
         _bondProp->GetProperty()->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);

trunk/packages/vizservers/vtkvis/RpPolyData.cpp

@@ -91 +91 @@
                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
                 mesher->SetInput(pd);
+                mesher->ReleaseDataFlagOn();
+                _pdMapper->SetInputConnection(mesher->GetOutputPort());
 #if defined(DEBUG) && defined(WANT_TRACE)
                 mesher->Update();
@@ -100 +102 @@
                       outpd->GetNumberOfStrips());
 #endif
-                _pdMapper->SetInputConnection(mesher->GetOutputPort());
             } else {
                 vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
                 mesher->SetInput(pd);
+                mesher->ReleaseDataFlagOn();
                 // Delaunay3D returns an UnstructuredGrid, so feed it through a surface filter
                 // to get the grid boundary as a PolyData
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
                 gf->SetInputConnection(mesher->GetOutputPort());
+                gf->ReleaseDataFlagOn();
                 _pdMapper->SetInputConnection(gf->GetOutputPort());
             }
@@ -116 +119 @@
     } else {
         // DataSet is NOT a vtkPolyData
-        WARN("DataSet is not a PolyData");
+        TRACE("DataSet is not a PolyData");
         vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
         gf->SetInput(ds);
+        gf->ReleaseDataFlagOn();
         _pdMapper->SetInputConnection(gf->GetOutputPort());
     }

trunk/packages/vizservers/vtkvis/RpStreamlines.cpp

@@ -35 +35 @@
     VtkGraphicsObject(),
     _lineType(LINES),
+    _colorMode(COLOR_BY_VECTOR_MAGNITUDE),
     _seedVisible(true)
 {
-    _backfaceCulling = true;
+    _faceCulling = true;
+    _color[0] = 1.0f;
+    _color[1] = 1.0f;
+    _color[2] = 1.0f;
     _seedColor[0] = 1.0f;
     _seedColor[1] = 1.0f;
@@ -56 +60 @@
     if (_linesActor == NULL) {
         _linesActor = vtkSmartPointer<vtkActor>::New();
+        _linesActor->GetProperty()->SetColor(_color[0], _color[1], _color[2]);
         _linesActor->GetProperty()->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
         _linesActor->GetProperty()->SetLineWidth(_edgeWidth);
@@ -64 +69 @@
         switch (_lineType) {
         case LINES:
-            _linesActor->GetProperty()->BackfaceCullingOff();
+            setCulling(_linesActor->GetProperty(), false);
             _linesActor->GetProperty()->SetRepresentationToWireframe();
             _linesActor->GetProperty()->EdgeVisibilityOff();
             break;
         case TUBES:
-            if (_backfaceCulling && _opacity == 1.0)
-                _linesActor->GetProperty()->BackfaceCullingOn();
+            if (_faceCulling && _opacity == 1.0)
+                setCulling(_linesActor->GetProperty(), true);
             _linesActor->GetProperty()->SetRepresentationToSurface();
             _linesActor->GetProperty()->EdgeVisibilityOff();
             break;
         case RIBBONS:
-            _linesActor->GetProperty()->BackfaceCullingOff();
+            setCulling(_linesActor->GetProperty(), false);
             _linesActor->GetProperty()->SetRepresentationToSurface();
             _linesActor->GetProperty()->EdgeVisibilityOff();
@@ -197 +202 @@
     vtkDataSet *ds = _dataSet->getVtkDataSet();
     double dataRange[2];
-    _dataSet->getDataRange(dataRange);
+    _dataSet->getVectorMagnitudeRange(dataRange);
     double bounds[6];
     _dataSet->getBounds(bounds);
@@ -215 +220 @@
     if (ds->GetPointData() == NULL ||
         ds->GetPointData()->GetVectors() == NULL) {
-        WARN("No vector point data found in DataSet %s", _dataSet->getName().c_str());
+        TRACE("No vector point data found in DataSet %s", _dataSet->getName().c_str());
         if (ds->GetCellData() == NULL ||
             ds->GetCellData()->GetVectors() == NULL) {
@@ -290 +295 @@
 
     _lut = vtkSmartPointer<vtkLookupTable>::New();
+    _lut->SetRange(dataRange);
     _lut->SetVectorModeToMagnitude();
 
@@ -299 +305 @@
     }
     _pdMapper->SetColorModeToMapScalars();
-    _pdMapper->UseLookupTableScalarRangeOff();
+    _pdMapper->UseLookupTableScalarRangeOn();
     _pdMapper->SetLookupTable(_lut);
 
@@ -693 +699 @@
         _pdMapper->SetInputConnection(_streamTracer->GetOutputPort());
         _lineFilter = NULL;
-        _linesActor->GetProperty()->BackfaceCullingOff();
+        setCulling(_linesActor->GetProperty(), false);
         _linesActor->GetProperty()->SetRepresentationToWireframe();
         _linesActor->GetProperty()->LightingOff();
@@ -720 +726 @@
         tubeFilter->SetRadius(radius);
         _pdMapper->SetInputConnection(_lineFilter->GetOutputPort());
-        if (_backfaceCulling && _opacity == 1.0)
-            _linesActor->GetProperty()->BackfaceCullingOn();
+        if (_faceCulling && _opacity == 1.0)
+            setCulling(_linesActor->GetProperty(), true);
         _linesActor->GetProperty()->SetRepresentationToSurface();
         _linesActor->GetProperty()->LightingOn();
@@ -747 +753 @@
         ribbonFilter->UseDefaultNormalOn();
         _pdMapper->SetInputConnection(_lineFilter->GetOutputPort());
-        _linesActor->GetProperty()->BackfaceCullingOff();
+        setCulling(_linesActor->GetProperty(), false);
         _linesActor->GetProperty()->SetRepresentationToSurface();
         _linesActor->GetProperty()->LightingOn();
+    }
+}
+
+void Streamlines::setColorMode(ColorMode mode)
+{
+    _colorMode = mode;
+    if (_dataSet == NULL || _pdMapper == NULL)
+        return;
+
+    vtkDataSet *ds = _dataSet->getVtkDataSet();
+
+    switch (mode) {
+    case COLOR_BY_SCALAR: {
+        _pdMapper->ScalarVisibilityOn();
+        _pdMapper->SetScalarModeToDefault();
+        if (_lut != NULL) {
+            double dataRange[2];
+            _dataSet->getDataRange(dataRange);
+            _lut->SetRange(dataRange);
+        }
+    }
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE: {
+        _pdMapper->ScalarVisibilityOn();
+        _pdMapper->SetScalarModeToUsePointFieldData();
+        if (ds->GetPointData() != NULL &&
+            ds->GetPointData()->GetVectors() != NULL) {
+            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        }
+        if (_lut != NULL) {
+            double dataRange[2];
+            _dataSet->getVectorMagnitudeRange(dataRange);
+            TRACE("vmag range: %g %g", dataRange[0], dataRange[1]);
+            _lut->SetRange(dataRange);
+            _lut->SetVectorModeToMagnitude();
+        }
+    }
+        break;
+    case COLOR_BY_VECTOR_X:
+        _pdMapper->ScalarVisibilityOn();
+        _pdMapper->SetScalarModeToUsePointFieldData();
+        if (ds->GetPointData() != NULL &&
+            ds->GetPointData()->GetVectors() != NULL) {
+            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        }
+        if (_lut != NULL) {
+            double dataRange[2];
+            _dataSet->getVectorComponentRange(dataRange, 0);
+            _lut->SetRange(dataRange);
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(0);
+        }
+        break;
+    case COLOR_BY_VECTOR_Y:
+        _pdMapper->ScalarVisibilityOn();
+        _pdMapper->SetScalarModeToUsePointFieldData();
+        if (ds->GetPointData() != NULL &&
+            ds->GetPointData()->GetVectors() != NULL) {
+            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        }
+        if (_lut != NULL) {
+            double dataRange[2];
+            _dataSet->getVectorComponentRange(dataRange, 1);
+            _lut->SetRange(dataRange);
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(1);
+        }
+        break;
+    case COLOR_BY_VECTOR_Z:
+        _pdMapper->ScalarVisibilityOn();
+        _pdMapper->SetScalarModeToUsePointFieldData();
+        if (ds->GetPointData() != NULL &&
+            ds->GetPointData()->GetVectors() != NULL) {
+            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        }
+        if (_lut != NULL) {
+            double dataRange[2];
+            _dataSet->getVectorComponentRange(dataRange, 2);
+            TRACE("vz range: %g %g", dataRange[0], dataRange[1]);
+            _lut->SetRange(dataRange);
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(2);
+        }
+        break;
+    case COLOR_CONSTANT:
+    default:
+        _pdMapper->ScalarVisibilityOff();
+        break;
     }
 }
@@ -772 +866 @@
     }
 
-    _lut->SetVectorModeToMagnitude();
+    switch (_colorMode) {
+    case COLOR_BY_VECTOR_MAGNITUDE: {
+        double dataRange[2];
+        _dataSet->getVectorMagnitudeRange(dataRange);
+        _lut->SetVectorModeToMagnitude();
+        _lut->SetRange(dataRange);
+    }
+        break;
+    case COLOR_BY_VECTOR_X: {
+        double dataRange[2];
+        _dataSet->getVectorComponentRange(dataRange, 0);
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(0);
+        _lut->SetRange(dataRange);
+    }
+        break;
+    case COLOR_BY_VECTOR_Y: {
+        double dataRange[2];
+        _dataSet->getVectorComponentRange(dataRange, 1);
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(1);
+        _lut->SetRange(dataRange);
+    }
+        break;
+    case COLOR_BY_VECTOR_Z: {
+        double dataRange[2];
+        _dataSet->getVectorComponentRange(dataRange, 2);
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(2);
+        _lut->SetRange(dataRange);
+    }
+        break;
+    default:
+         break;
+    }
 
     if (_pdMapper != NULL) {
@@ -798 +926 @@
         _linesActor->GetProperty()->SetOpacity(_opacity);
         if (_opacity < 1.0)
-            _linesActor->GetProperty()->BackfaceCullingOff();
-        else if (_backfaceCulling && _lineType == TUBES)
-            _linesActor->GetProperty()->BackfaceCullingOn();
+            setCulling(_linesActor->GetProperty(), false);
+        else if (_faceCulling && _lineType == TUBES)
+            setCulling(_linesActor->GetProperty(), true);
     }
     if (_seedActor != NULL) {
@@ -860 +988 @@
 /**
  * \brief Set RGB color of stream lines
+ */
+void Streamlines::setColor(float color[3])
+{
+    _color[0] = color[0];
+    _color[1] = color[1];
+    _color[2] = color[2];
+    if (_linesActor != NULL)
+        _linesActor->GetProperty()->SetColor(_color[0], _color[1], _color[2]);
+}
+
+/**
+ * \brief Set RGB color of stream line edges
  */
 void Streamlines::setEdgeColor(float color[3])

trunk/packages/vizservers/vtkvis/RpStreamlines.h

@@ -35 +35 @@
         RIBBONS
     };
+    enum ColorMode {
+        COLOR_BY_SCALAR,
+        COLOR_BY_VECTOR_MAGNITUDE,
+        COLOR_BY_VECTOR_X,
+        COLOR_BY_VECTOR_Y,
+        COLOR_BY_VECTOR_Z,
+        COLOR_CONSTANT
+    };
 
     Streamlines();
@@ -51 +59 @@
 
     virtual bool getVisibility();
+
+    virtual void setColor(float color[3]);
 
     virtual void setEdgeVisibility(bool state);
@@ -83 +93 @@
     void setLineTypeToRibbons(double width, double angle);
 
+    void setColorMode(ColorMode mode);
+
     void setLookupTable(vtkLookupTable *lut);
 
@@ -107 +119 @@
 
     LineType _lineType;
+    ColorMode _colorMode;
+    float _color[3];
     float _seedColor[3];
     bool _seedVisible;

trunk/packages/vizservers/vtkvis/RpVtkDataSet.cpp

@@ -242 +242 @@
  * \brief Set the ative scalar array to the named field
  */
-bool DataSet::setActiveScalar(const char *name)
+bool DataSet::setActiveScalars(const char *name)
 {
     bool found = false;
@@ -261 +261 @@
  * \brief Set the ative vector array to the named field
  */
-bool DataSet::setActiveVector(const char *name)
+bool DataSet::setActiveVectors(const char *name)
 {
     bool found = false;

trunk/packages/vizservers/vtkvis/RpVtkDataSet.h

@@ -45 +45 @@
     const char *getVtkType() const;
 
-    bool setActiveScalar(const char *name);
+    bool setActiveScalars(const char *name);
 
-    bool setActiveVector(const char *name);
+    bool setActiveVectors(const char *name);
 
     void getDataRange(double minmax[2]) const;

trunk/packages/vizservers/vtkvis/RpVtkGraphicsObject.h

@@ -36 +36 @@
 class VtkGraphicsObject {
 public:
+    enum CullFace {
+        CULL_FRONT,
+        CULL_BACK,
+        CULL_FRONT_AND_BACK
+    };
+
     VtkGraphicsObject() :
         _dataSet(NULL),
@@ -41 +47 @@
         _edgeWidth(1.0f),
         _lighting(true),
-        _backfaceCulling(false)
+        _cullFace(CULL_BACK),
+        _faceCulling(false)
     {
         _color[0] = 1.0f;
@@ -139 +146 @@
         if (getProp3D() != NULL) {
             getProp3D()->SetUserMatrix(matrix);
+        }
+    }
+
+    /**
+     * \brief Set the prop center of rotation
+     *
+     * \param[in] origin The point about which the object rotates
+     */
+    virtual void setOrigin(double origin[3])
+    {
+        if (getProp3D() != NULL) {
+            getProp3D()->SetOrigin(origin);
         }
     }
@@ -156 +175 @@
             axis[1] = quat[2] / denom;
             axis[2] = quat[3] / denom;
-            getProp3D()->SetOrientation(0, 0, 0);
-            getProp3D()->RotateWXYZ(angle, axis[0], axis[1], axis[2]);
+            setOrientation(angle, axis);
         }
     }
@@ -231 +249 @@
         if (getActor() != NULL) {
             getActor()->GetProperty()->SetOpacity(opacity);
-            if (_backfaceCulling && _opacity < 1.0) {
-                getActor()->GetProperty()->BackfaceCullingOff();
-                TRACE("Backface culling off");
-            } else if (_backfaceCulling && _opacity == 1.0) {
-                getActor()->GetProperty()->BackfaceCullingOn();
-                TRACE("Backface culling on");
+            if (_faceCulling && _opacity < 1.0) {
+                setCulling(getActor()->GetProperty(), false);
+                TRACE("Culling off");
+            } else if (_faceCulling && _opacity == 1.0) {
+                setCulling(getActor()->GetProperty(), true);
+                TRACE("Culling on");
             }
         } else if (getAssembly() != NULL) {
@@ -245 +263 @@
                 if (vtkActor::SafeDownCast(prop) != NULL) {
                     vtkActor::SafeDownCast(prop)->GetProperty()->SetOpacity(opacity);
-                    if (_backfaceCulling && _opacity < 1.0) {
-                        vtkActor::SafeDownCast(prop)->GetProperty()->BackfaceCullingOff();
-                        TRACE("Backface culling off");
-                    } else if (_backfaceCulling && _opacity == 1.0) {
-                        vtkActor::SafeDownCast(prop)->GetProperty()->BackfaceCullingOn();
-                        TRACE("Backface culling on");
+                    if (_faceCulling && _opacity < 1.0) {
+                        setCulling(vtkActor::SafeDownCast(prop)->GetProperty(), false);
+                        TRACE("Culling off");
+                    } else if (_faceCulling && _opacity == 1.0) {
+                        setCulling(vtkActor::SafeDownCast(prop)->GetProperty(), true);
+                        TRACE("Culling on");
                     }
                 }
@@ -573 +591 @@
 
     /**
-     * \brief Toggle backface culling of prop
-     */
-    virtual void setBackfaceCulling(bool state)
-    {
-        _backfaceCulling = state;
+     * \brief Convenience method to set culling state on a vtkProperty
+     *
+     * Note: Does not change the culling state flag of this VtkGraphicsObject
+     */
+    virtual void setCulling(vtkProperty *property, bool state)
+    {
+        switch (_cullFace) {
+        case CULL_FRONT:
+            property->SetFrontfaceCulling((state ? 1 : 0));
+            property->BackfaceCullingOff();
+            break;
+        case CULL_BACK:
+            property->SetBackfaceCulling((state ? 1 : 0));
+            property->FrontfaceCullingOff();
+            break;
+        case CULL_FRONT_AND_BACK:
+            property->SetBackfaceCulling((state ? 1 : 0));
+            property->SetFrontfaceCulling((state ? 1 : 0));
+            break;
+        }
+    }
+
+    /**
+     * \brief Toggle culling of selected CullFace
+     */
+    virtual void setCulling(bool state)
+    {
+        _faceCulling = state;
         if (state && _opacity < 1.0)
             return;
         if (getActor() != NULL) {
-            getActor()->GetProperty()->SetBackfaceCulling((state ? 1 : 0));
+            setCulling(getActor()->GetProperty(), state);
          } else if (getAssembly() != NULL) {
             vtkProp3DCollection *props = getAssembly()->GetParts();
@@ -588 +629 @@
             while ((prop = props->GetNextProp3D()) != NULL) {
                 if (vtkActor::SafeDownCast(prop) != NULL) {
-                    vtkActor::SafeDownCast(prop)->GetProperty()->SetBackfaceCulling((state ? 1 : 0));
-                }
-            }
-        }
+                    setCulling(vtkActor::SafeDownCast(prop)->GetProperty(), state);
+                }
+            }
+        }
+    }
+
+    virtual void setCullFace(CullFace cull)
+    {
+        _cullFace = cull;
+        setCulling(_faceCulling);
     }
 
@@ -613 +660 @@
             if (!_lighting)
                 property->LightingOff();
-            if (_backfaceCulling && _opacity == 1.0) {
-                property->BackfaceCullingOn();
+            if (_faceCulling && _opacity == 1.0) {
+                setCulling(property, true);
             }
         }
@@ -631 +678 @@
     float _edgeWidth;
     bool _lighting;
-    bool _backfaceCulling;
+    CullFace _cullFace;
+    bool _faceCulling;
 
     vtkSmartPointer<vtkProp> _prop;

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -687 +687 @@
 }
 
+bool Renderer::setDataSetActiveScalars(const DataSetId& id, const char *scalarName)
+{
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+        doAll = true;
+    } else {
+        itr = _dataSets.find(id);
+    }
+    if (itr == _dataSets.end()) {
+        ERROR("DataSet not found: %s", id.c_str());
+        return false;
+    }
+
+    bool ret = true;
+    do {
+        if (!itr->second->setActiveScalars(scalarName)) {
+            ret = false;
+        }
+    } while (doAll && ++itr != _dataSets.end());
+
+    if (ret) {
+        collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+        updateRanges(_useCumulativeRange);
+        _needsRedraw = true;
+    } 
+
+    return ret;
+}
+
+bool Renderer::setDataSetActiveVectors(const DataSetId& id, const char *vectorName)
+{
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+        doAll = true;
+    } else {
+        itr = _dataSets.find(id);
+    }
+    if (itr == _dataSets.end()) {
+        ERROR("DataSet not found: %s", id.c_str());
+        return false;
+    }
+
+    bool ret = true;
+    do {
+        if (!itr->second->setActiveVectors(vectorName)) {
+            ret = false;
+        }
+    } while (doAll && ++itr != _dataSets.end());
+
+    if (ret) {
+        collectDataRanges(_cumulativeDataRange, _cumulativeRangeOnlyVisible);
+        updateRanges(_useCumulativeRange);
+        _needsRedraw = true;
+    } 
+
+    return ret;
+}
+
 /**
  * \brief Control whether the cumulative data range of datasets is used for 
@@ -2383 +2449 @@
 
 /**
+ * \brief Set the RGB polygon color for the specified DataSet
+ */
+void Renderer::setGlyphsColor(const DataSetId& id, float color[3])
+{
+    GlyphsHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _glyphs.begin();
+        doAll = true;
+    } else {
+        itr = _glyphs.find(id);
+    }
+    if (itr == _glyphs.end()) {
+        ERROR("Glyphs not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColor(color);
+    } while (doAll && ++itr != _glyphs.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Associate an existing named color map with a Glyphs for the given DataSet
  */
@@ -5240 +5333 @@
         ColorMap *cmap = getColorMap("default");
         lut->DeepCopy(cmap->getLookupTable());
-#if 0
-        // Currently lookup table/scalar data range not used, colormap is used to
-        // color streamlines by vector magnitude
+
         if (_useCumulativeRange) {
             lut->SetRange(_cumulativeDataRange);
@@ -5250 +5341 @@
             lut->SetRange(range);
         }
-#endif
         streamlines->setLookupTable(lut);
 
@@ -5754 +5844 @@
 
 /**
+ * \brief Set the color mode for the specified DataSet
+ */
+void Renderer::setStreamlinesColorMode(const DataSetId& id, Streamlines::ColorMode mode)
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColorMode(mode);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Associate an existing named color map with a Streamlines for the given DataSet
  */
@@ -5790 +5907 @@
         lut->DeepCopy(cmap->getLookupTable());
 
-#if 0
         if (_useCumulativeRange) {
             lut->SetRange(_cumulativeDataRange);
@@ -5800 +5916 @@
             }
         }
-#endif
 
         itr->second->setLookupTable(lut);
@@ -5863 +5978 @@
 }
 
+/**
+ * \brief Set the RGB color for the specified DataSet
+ */
+void Renderer::setStreamlinesColor(const DataSetId& id, float color[3])
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColor(color);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
 
 /**
@@ -6491 +6632 @@
 }
 
-inline void quaternionToMatrix4x4(double quat[4], vtkMatrix4x4& mat)
+inline void quaternionToMatrix4x4(const double quat[4], vtkMatrix4x4& mat)
 {
     double ww = quat[0]*quat[0];
@@ -6525 +6666 @@
 }
 
-inline void quaternionToTransposeMatrix4x4(double quat[4], vtkMatrix4x4& mat)
+inline void quaternionToTransposeMatrix4x4(const double quat[4], vtkMatrix4x4& mat)
 {
     double ww = quat[0]*quat[0];
@@ -6559 +6700 @@
 }
 
-inline double *quatMult(double q1[4], double q2[4], double result[4])
+inline double *quatMult(const double q1[4], const double q2[4], double result[4])
 {
     double q1w = q1[0];
@@ -6576 +6717 @@
 }
 
-inline double *quatConjugate(double quat[4], double result[4])
+inline double *quatConjugate(const double quat[4], double result[4])
 {
     result[1] = -quat[1];
@@ -6584 +6725 @@
 }
 
-inline double *quatReciprocal(double quat[4], double result[4])
+inline double *quatReciprocal(const double quat[4], double result[4])
 {
     double denom = 
@@ -6603 +6744 @@
 }
 
-inline void copyQuat(double quat[4], double result[4])
+inline void copyQuat(const double quat[4], double result[4])
 {
     memcpy(result, quat, sizeof(double)*4);
@@ -6615 +6756 @@
  * \param[in] absolute Is rotation absolute or relative?
  */
-void Renderer::setCameraOrientation(double quat[4], bool absolute)
+void Renderer::setCameraOrientation(const double quat[4], bool absolute)
 {
     if (_cameraMode == IMAGE)
@@ -6623 +6764 @@
     vtkSmartPointer<vtkMatrix4x4> rotMat = vtkSmartPointer<vtkMatrix4x4>::New();
 
+    double q[4];
+    copyQuat(quat, q);
+
     if (absolute) {
         double abs[4];
         // Save absolute rotation
-        copyQuat(quat, abs);
+        copyQuat(q, abs);
         // Compute relative rotation
-        quatMult(quatReciprocal(_cameraOrientation), quat, quat);
+        quatMult(quatReciprocal(_cameraOrientation), q, q);
         // Store absolute rotation
         copyQuat(abs, _cameraOrientation);
     } else {
         // Compute new absolute rotation
-        quatMult(_cameraOrientation, quat, _cameraOrientation);
-    }
-
-    quaternionToTransposeMatrix4x4(quat, *rotMat);
+        quatMult(_cameraOrientation, q, _cameraOrientation);
+    }
+
+    quaternionToTransposeMatrix4x4(q, *rotMat);
 #ifdef DEBUG
     TRACE("Rotation matrix:\n %g %g %g\n %g %g %g\n %g %g %g",
@@ -6669 +6813 @@
  * \param[in] viewUp x,y,z up vector of camera
  */
-void Renderer::setCameraOrientationAndPosition(double position[3],
-                                               double focalPoint[3],
-                                               double viewUp[3])
+void Renderer::setCameraOrientationAndPosition(const double position[3],
+                                               const double focalPoint[3],
+                                               const double viewUp[3])
 {
     vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
@@ -6735 +6879 @@
 }
 
+void Renderer::resetCameraClippingRange()
+{
+    _renderer->ResetCameraClippingRange();
+}
+
 /**
  * \brief Perform a relative rotation to current camera orientation
@@ -6811 +6960 @@
         }
 
-        vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
-        double viewFocus[4], focalDepth, viewPoint[3];
-        double newPickPoint[4], oldPickPoint[4], motionVector[3];
-
-        camera->GetFocalPoint(viewFocus);
-        computeWorldToDisplay(viewFocus[0], viewFocus[1], viewFocus[2], 
-                              viewFocus);
-        focalDepth = viewFocus[2];
-
-        computeDisplayToWorld(( x * 2. + 1.) * _windowWidth / 2.0,
-                              ( y * 2. + 1.) * _windowHeight / 2.0,
-                              focalDepth, 
-                              newPickPoint);
-
-        computeDisplayToWorld(_windowWidth / 2.0,
-                              _windowHeight / 2.0,
-                              focalDepth, 
-                              oldPickPoint);
-
-        // Camera motion is reversed
-        motionVector[0] = oldPickPoint[0] - newPickPoint[0];
-        motionVector[1] = oldPickPoint[1] - newPickPoint[1];
-        motionVector[2] = oldPickPoint[2] - newPickPoint[2];
-
-        camera->GetFocalPoint(viewFocus);
-        camera->GetPosition(viewPoint);
-        camera->SetFocalPoint(motionVector[0] + viewFocus[0],
-                              motionVector[1] + viewFocus[1],
-                              motionVector[2] + viewFocus[2]);
-
-        camera->SetPosition(motionVector[0] + viewPoint[0],
-                            motionVector[1] + viewPoint[1],
-                            motionVector[2] + viewPoint[2]);
-
-        _renderer->ResetCameraClippingRange();
-        //computeScreenWorldCoords();
+        if (x != 0.0 || y != 0.0) {
+            vtkSmartPointer<vtkCamera> camera = _renderer->GetActiveCamera();
+            double viewFocus[4], focalDepth, viewPoint[3];
+            double newPickPoint[4], oldPickPoint[4], motionVector[3];
+
+            camera->GetFocalPoint(viewFocus);
+            computeWorldToDisplay(viewFocus[0], viewFocus[1], viewFocus[2], 
+                                  viewFocus);
+            focalDepth = viewFocus[2];
+
+            computeDisplayToWorld(( x * 2. + 1.) * _windowWidth / 2.0,
+                                  ( y * 2. + 1.) * _windowHeight / 2.0,
+                                  focalDepth, 
+                                  newPickPoint);
+
+            computeDisplayToWorld(_windowWidth / 2.0,
+                                  _windowHeight / 2.0,
+                                  focalDepth, 
+                                  oldPickPoint);
+
+            // Camera motion is reversed
+            motionVector[0] = oldPickPoint[0] - newPickPoint[0];
+            motionVector[1] = oldPickPoint[1] - newPickPoint[1];
+            motionVector[2] = oldPickPoint[2] - newPickPoint[2];
+
+            camera->GetFocalPoint(viewFocus);
+            camera->GetPosition(viewPoint);
+            camera->SetFocalPoint(motionVector[0] + viewFocus[0],
+                                  motionVector[1] + viewFocus[1],
+                                  motionVector[2] + viewFocus[2]);
+
+            camera->SetPosition(motionVector[0] + viewPoint[0],
+                                motionVector[1] + viewPoint[1],
+                                motionVector[2] + viewPoint[2]);
+
+            _renderer->ResetCameraClippingRange();
+            //computeScreenWorldCoords();
+        }
     }
 
@@ -7294 +7445 @@
         }
     }
-#if 0
-    // Currently lookup table/scalar data range not used, colormap is used to
-    // color streamlines by vector magnitude
     for (StreamlinesHashmap::iterator itr = _streamlines.begin();
          itr != _streamlines.end(); ++itr) {
@@ -7312 +7460 @@
         }
     }
-#endif
     for (VolumeHashmap::iterator itr = _volumes.begin();
          itr != _volumes.end(); ++itr) {

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -108 +108 @@
     bool setDataFile(const DataSetId& id, const char *filename);
 
+    bool setDataSetActiveScalars(const DataSetId& id, const char *scalarName);
+
+    bool setDataSetActiveVectors(const DataSetId& id, const char *vectorName);
+
     double getDataValueAtPixel(const DataSetId& id, int x, int y);
 
@@ -142 +146 @@
     void resetCamera(bool resetOrientation = true);
 
+    void resetCameraClippingRange();
+
     void setCameraZoomRegion(double x, double y, double width, double height);
 
@@ -150 +156 @@
     void rotateCamera(double yaw, double pitch, double roll);
 
-    void setCameraOrientation(double quat[4], bool absolute = true);
+    void setCameraOrientation(const double quat[4], bool absolute = true);
 
     void panCamera(double x, double y, bool absolute = true);
@@ -156 +162 @@
     void zoomCamera(double z, bool absolute = true);
 
-    void setCameraOrientationAndPosition(double position[3],
-                                         double focalPoint[3],
-                                         double viewUp[3]);
+    void setCameraOrientationAndPosition(const double position[3],
+                                         const double focalPoint[3],
+                                         const double viewUp[3]);
 
     void getCameraOrientationAndPosition(double position[3],
@@ -314 +320 @@
     void setGlyphsScale(const DataSetId& id, double scale[3]);
 
+    void setGlyphsColor(const DataSetId& id, float color[3]);
+
     void setGlyphsEdgeVisibility(const DataSetId& id, bool state);
 
@@ -544 +552 @@
 
     void setStreamlinesScale(const DataSetId& id, double scale[3]);
+
+    void setStreamlinesColor(const DataSetId& id, float color[3]);
 
     void setStreamlinesEdgeVisibility(const DataSetId& id, bool state);
@@ -587 +597 @@
 
     void setStreamlinesSeedVisibility(const DataSetId& id, bool state);
+
+    void setStreamlinesColorMode(const DataSetId& id, Streamlines::ColorMode mode);
 
     void setStreamlinesColorMap(const DataSetId& id, const ColorMapId& colorMapId);

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -1157 +1157 @@
 static Rappture::CmdSpec contour3dOps[] = {
     {"add",       1, Contour3DAddOp, 4, 5, "oper value ?dataSetName?"},
-    {"color",     6, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
-    {"colormap",  6, Contour3DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"ccolor",    2, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",  2, Contour3DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"delete",    1, Contour3DDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, Contour3DEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -1188 +1188 @@
 
 static int
+DataSetActiveScalarsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    const char *scalarName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        if (!g_renderer->setDataSetActiveScalars(name, scalarName)) {
+            Tcl_AppendResult(interp, "scalar \"", scalarName,
+                         "\" not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setDataSetActiveScalars("all", scalarName)) {
+            Tcl_AppendResult(interp, "scalar \"", scalarName,
+                         "\" not found in one or more data sets", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    return TCL_OK;
+}
+
+static int
+DataSetActiveVectorsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    const char *vectorName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        if (!g_renderer->setDataSetActiveVectors(name, vectorName)) {
+            Tcl_AppendResult(interp, "vector \"", vectorName,
+                         "\" not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setDataSetActiveVectors("all", vectorName)) {
+            Tcl_AppendResult(interp, "vector \"", vectorName,
+                         "\" not found in one or more data sets", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    return TCL_OK;
+}
+
+static int
 DataSetAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
              Tcl_Obj *const *objv)
@@ -1385 +1429 @@
     {"maprange", 1, DataSetMapRangeOp, 3, 3, "value"},
     {"opacity",  1, DataSetOpacityOp, 3, 4, "value ?name?"},
-    {"visible",  1, DataSetVisibleOp, 3, 4, "bool ?name?"}
+    {"scalar",   1, DataSetActiveScalarsOp, 3, 4, "scalarName ?name?"},
+    {"vector",   2, DataSetActiveVectorsOp, 3, 4, "vectorName ?name?"},
+    {"visible",  2, DataSetVisibleOp, 3, 4, "bool ?name?"}
 };
 static int nDataSetOps = NumCmdSpecs(dataSetOps);
@@ -1446 +1492 @@
 
 static int
+GlyphsColorOp(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->setGlyphsColor(name, color);
+    } else {
+        g_renderer->setGlyphsColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
 GlyphsColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                  Tcl_Obj *const *objv)
@@ -1465 +1530 @@
     Glyphs::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 's' && strcmp(str, "scale") == 0) {
+    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+        mode = Glyphs::COLOR_CONSTANT;
+    } else if (str[0] == 's' && strcmp(str, "scale") == 0) {
         mode = Glyphs::COLOR_BY_SCALE;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -1473 +1540 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scale', 'scalar', 'vector'", (char*)NULL);
+                         "\": should be one of: 'scale', 'scalar', 'vector', 'ccolor'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -1764 +1831 @@
 static Rappture::CmdSpec glyphsOps[] = {
     {"add",       1, GlyphsAddOp, 3, 4, "shape ?dataSetNme?"},
+    {"ccolor",    2, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",  7, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetNme?"},
     {"colormode", 7, GlyphsColorModeOp, 3, 4, "mode ?dataSetNme?"},
@@ -3479 +3547 @@
 
 static int
+StreamlinesColorOp(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->setStreamlinesColor(name, color);
+    } else {
+        g_renderer->setStreamlinesColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
 StreamlinesColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                       Tcl_Obj *const *objv)
@@ -3488 +3575 @@
     } else {
         g_renderer->setStreamlinesColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+StreamlinesColorModeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    Streamlines::ColorMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = Streamlines::COLOR_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
+        mode = Streamlines::COLOR_BY_VECTOR_MAGNITUDE;
+    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
+        mode = Streamlines::COLOR_BY_VECTOR_X;
+    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
+        mode = Streamlines::COLOR_BY_VECTOR_Y;
+    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
+        mode = Streamlines::COLOR_BY_VECTOR_Z;
+    } else if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+        mode = Streamlines::COLOR_CONSTANT;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode option \"", str,
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setStreamlinesColorMode(dataSetName, mode);
+    } else {
+        g_renderer->setStreamlinesColorMode("all", mode);
     }
     return TCL_OK;
@@ -3953 +4072 @@
 static Rappture::CmdSpec streamlinesOps[] = {
     {"add",       1, StreamlinesAddOp, 2, 3, "?dataSetName?"},
-    {"colormap",  1, StreamlinesColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"ccolor",    1, StreamlinesColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",  7, StreamlinesColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"colormode", 7, StreamlinesColorModeOp, 3, 4, "mode ?dataSetNme?"},
     {"delete",    1, StreamlinesDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, StreamlinesEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -85 +85 @@
         "all"
 dataset opacity <val> <?datasetName?>
+dataset scalar <scalarName> <?datasetName?>
+        Set the active scalar field to plot
+dataset vector <vectorName> <?datasetName?>
+        Set the active vector field to plot
 dataset visible <bool> <?datasetName?>
 
@@ -107 +111 @@
 contour3d add contourlist <list> <?datasetName?>
           list = {isoval1 isoval2 isoval3...}
-contour3d color r g b <?datasetName?>
+contour3d ccolor r g b <?datasetName?>
 contour3d colormap <colorMapName> <?dataSetName?>
 contour3d delete <?datasetName?>
@@ -122 +126 @@
 
 glyphs add <?dataSetName?>
+glyphs ccolor r g b <?datasetName?>
 glyphs colormap <colorMapName> <?dataSetName?>
-glyphs colormode <scale|scalar|vector> <?dataSetName?>
+glyphs colormode <scale|scalar|vector|ccolor> <?dataSetName?>
        Set the color mode: color by scale, scalar field or
        vector magnitude -- uses the current color map
@@ -232 +237 @@
 
 streamlines add <?datasetName?>
+streamlines ccolor <r> <g> <b> <?datasetName?>
+            Set the constant color of streamlines used for color mode 'ccolor'
 streamlines colormap <colormapName> <?datasetName?>
             Colormap used to color streamlines/tubes/ribbons by vector magnitude
+streamlines colormode <scalar|vmag|vx|vy|vz|ccolor> <?datasetName?>
+            Set the field used to color the streamlines.  'ccolor' means to use
+            the constant color defined by the ccolor subcommand.  'scalar' uses
+            the active scalar field.  'vmag' uses the magnitude of the current
+            vector field, and 'vx','vy','vz' use the corresponding component of
+            the active vector field.
 streamlines delete <?datasetName?>
 streamlines edges <bool> <?datasetName?>