Changeset 2335

Timestamp:

Aug 8, 2011 9:34:06 AM (13 years ago)

Author:

ldelgass

Message:

• Add protocol for setting glyph scaling and color modes
• Finish adding protocol for setting scale, position, orientation of all graphics object types

Location:

trunk/packages/vizservers/vtkvis

Files:

• RpGlyphs.cpp (modified) (1 diff)
• RpGlyphs.h (modified) (2 diffs)
• RpVtkRenderer.cpp (modified) (8 diffs)
• RpVtkRenderer.h (modified) (8 diffs)
• RpVtkRendererCmd.cpp (modified) (23 diffs)
• protocol.txt (modified) (7 diffs)

trunk/packages/vizservers/vtkvis/RpGlyphs.cpp

@@ -181 +181 @@
 
 /**
+ * \brief Control how glyphs are scaled
+ */
+void Glyphs::setScalingMode(ScalingMode mode)
+{
+    if (_glyphGenerator != NULL) {
+        switch (mode) {
+        case SCALE_BY_SCALAR:
+            _glyphGenerator->SetScaleModeToScaleByScalar();
+            _glyphGenerator->ScalingOn();
+            break;
+        case SCALE_BY_VECTOR:
+            _glyphGenerator->SetScaleModeToScaleByVector();
+            _glyphGenerator->ScalingOn();
+            break;
+        case SCALE_BY_VECTOR_COMPONENTS:
+            _glyphGenerator->SetScaleModeToScaleByVectorComponents();
+            _glyphGenerator->ScalingOn();
+            break;
+        case SCALING_OFF:
+        default:
+            _glyphGenerator->SetScaleModeToDataScalingOff();
+            _glyphGenerator->ScalingOff();
+        }
+        _pdMapper->Update();
+    }
+}
+
+/**
+ * \brief Control how glyphs are colored
+ */
+void Glyphs::setColorMode(ColorMode mode)
+{
+    if (_glyphGenerator != NULL) {
+        switch (mode) {
+        case COLOR_BY_SCALE:
+            _glyphGenerator->SetColorModeToColorByScale();
+            break;
+        case COLOR_BY_VECTOR:
+            _glyphGenerator->SetColorModeToColorByVector();
+            break;
+        case COLOR_BY_SCALAR:
+        default:
+            _glyphGenerator->SetColorModeToColorByScalar();
+            break;
+        }
+        _pdMapper->Update();
+    }
+}
+
+/**
  * \brief Controls relative scaling of glyphs
  */

trunk/packages/vizservers/vtkvis/RpGlyphs.h

@@ -43 +43 @@
         TETRAHEDRON
     };
+    enum ScalingMode {
+        SCALE_BY_SCALAR,
+        SCALE_BY_VECTOR,
+        SCALE_BY_VECTOR_COMPONENTS,
+        SCALING_OFF
+    };
+    enum ColorMode {
+        COLOR_BY_SCALE,
+        COLOR_BY_SCALAR,
+        COLOR_BY_VECTOR
+    };
 
     Glyphs();
@@ -53 +64 @@
 
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
+
+    void setScalingMode(ScalingMode mode);
+
+    void setColorMode(ColorMode mode);
 
     void setGlyphShape(GlyphShape shape);

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -1293 +1293 @@
 
 /**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setContour2DTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setTransform(trans);
+    } while (doAll && ++itr != _contour2Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setContour2DOrientation(const DataSetId& id, double quat[4])
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(quat);
+    } while (doAll && ++itr != _contour2Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setContour2DOrientation(const DataSetId& id, double angle, double axis[3])
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(angle, axis);
+    } while (doAll && ++itr != _contour2Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setContour2DPosition(const DataSetId& id, double pos[3])
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setPosition(pos);
+    } while (doAll && ++itr != _contour2Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setContour2DScale(const DataSetId& id, double scale[3])
+{
+    Contour2DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour2Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour2Ds.find(id);
+    }
+    if (itr == _contour2Ds.end()) {
+        ERROR("Contour2D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setScale(scale);
+    } while (doAll && ++itr != _contour2Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the number of equally spaced contour isolines for the given DataSet
  */
@@ -1558 +1698 @@
 
 /**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setContour3DTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setTransform(trans);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setContour3DOrientation(const DataSetId& id, double quat[4])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(quat);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setContour3DOrientation(const DataSetId& id, double angle, double axis[3])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(angle, axis);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setContour3DPosition(const DataSetId& id, double pos[3])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setPosition(pos);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setContour3DScale(const DataSetId& id, double scale[3])
+{
+    Contour3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _contour3Ds.begin();
+        doAll = true;
+    } else {
+        itr = _contour3Ds.find(id);
+    }
+    if (itr == _contour3Ds.end()) {
+        ERROR("Contour3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setScale(scale);
+    } while (doAll && ++itr != _contour3Ds.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the number of equally spaced isosurfaces for the given DataSet
  */
@@ -1960 +2240 @@
 
 /**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setGlyphsTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    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->setTransform(trans);
+    } while (doAll && ++itr != _glyphs.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setGlyphsOrientation(const DataSetId& id, double quat[4])
+{
+    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->setOrientation(quat);
+    } while (doAll && ++itr != _glyphs.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setGlyphsOrientation(const DataSetId& id, double angle, double axis[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->setOrientation(angle, axis);
+    } while (doAll && ++itr != _glyphs.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setGlyphsPosition(const DataSetId& id, double pos[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->setPosition(pos);
+    } while (doAll && ++itr != _glyphs.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setGlyphsScale(const DataSetId& id, double scale[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->setScale(scale);
+    } while (doAll && ++itr != _glyphs.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Associate an existing named color map with a Glyphs for the given DataSet
  */
@@ -2009 +2429 @@
     } while (doAll && ++itr != _glyphs.end());
 
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Controls the array used to color glyphs for the given DataSet
+ */
+void Renderer::setGlyphsColorMode(const DataSetId& id, Glyphs::ColorMode mode)
+{
+    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->setColorMode(mode);
+    } while (doAll && ++itr != _glyphs.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Controls the array used to scale glyphs for the given DataSet
+ */
+void Renderer::setGlyphsScalingMode(const DataSetId& id, Glyphs::ScalingMode mode)
+{
+    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->setScalingMode(mode);
+    } while (doAll && ++itr != _glyphs.end());
+
+    _renderer->ResetCameraClippingRange();
     _needsRedraw = true;
 }
@@ -2945 +3420 @@
 
 /**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setLICTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    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->setTransform(trans);
+    } while (doAll && ++itr != _lics.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setLICOrientation(const DataSetId& id, double quat[4])
+{
+    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->setOrientation(quat);
+    } while (doAll && ++itr != _lics.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setLICOrientation(const DataSetId& id, double angle, double axis[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->setOrientation(angle, axis);
+    } while (doAll && ++itr != _lics.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setLICPosition(const DataSetId& id, double pos[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->setPosition(pos);
+    } while (doAll && ++itr != _lics.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setLICScale(const DataSetId& id, double scale[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->setScale(scale);
+    } while (doAll && ++itr != _lics.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the volume slice used for mapping volumetric data
  */
@@ -4192 +4807 @@
     } else
         return itr->second;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setPseudoColorTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setTransform(trans);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setPseudoColorOrientation(const DataSetId& id, double quat[4])
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(quat);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setPseudoColorOrientation(const DataSetId& id, double angle, double axis[3])
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(angle, axis);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setPseudoColorPosition(const DataSetId& id, double pos[3])
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setPosition(pos);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setPseudoColorScale(const DataSetId& id, double scale[3])
+{
+    PseudoColorHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _pseudoColors.begin();
+        doAll = true;
+    } else {
+        itr = _pseudoColors.find(id);
+    }
+    if (itr == _pseudoColors.end()) {
+        ERROR("PseudoColor not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setScale(scale);
+    } while (doAll && ++itr != _pseudoColors.end());
+
+    resetAxes();
+    _needsRedraw = true;
 }
 
@@ -4517 +5272 @@
 
 /**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setStreamlinesTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    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->setTransform(trans);
+    } while (doAll && ++itr != _streamlines.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setStreamlinesOrientation(const DataSetId& id, double quat[4])
+{
+    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->setOrientation(quat);
+    } while (doAll && ++itr != _streamlines.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setStreamlinesOrientation(const DataSetId& id, double angle, double axis[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->setOrientation(angle, axis);
+    } while (doAll && ++itr != _streamlines.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setStreamlinesPosition(const DataSetId& id, double pos[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->setPosition(pos);
+    } while (doAll && ++itr != _streamlines.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setStreamlinesScale(const DataSetId& id, double scale[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->setScale(scale);
+    } while (doAll && ++itr != _streamlines.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the streamlines seed to points distributed randomly inside
  * cells of DataSet
@@ -5043 +5938 @@
     } else
         return itr->second;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setVolumeTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    VolumeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _volumes.begin();
+        doAll = true;
+    } else {
+        itr = _volumes.find(id);
+    }
+    if (itr == _volumes.end()) {
+        ERROR("Volume not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setTransform(trans);
+    } while (doAll && ++itr != _volumes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setVolumeOrientation(const DataSetId& id, double quat[4])
+{
+    VolumeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _volumes.begin();
+        doAll = true;
+    } else {
+        itr = _volumes.find(id);
+    }
+    if (itr == _volumes.end()) {
+        ERROR("Volume not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(quat);
+    } while (doAll && ++itr != _volumes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setVolumeOrientation(const DataSetId& id, double angle, double axis[3])
+{
+    VolumeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _volumes.begin();
+        doAll = true;
+    } else {
+        itr = _volumes.find(id);
+    }
+    if (itr == _volumes.end()) {
+        ERROR("Volume not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(angle, axis);
+    } while (doAll && ++itr != _volumes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setVolumePosition(const DataSetId& id, double pos[3])
+{
+    VolumeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _volumes.begin();
+        doAll = true;
+    } else {
+        itr = _volumes.find(id);
+    }
+    if (itr == _volumes.end()) {
+        ERROR("Volume not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setPosition(pos);
+    } while (doAll && ++itr != _volumes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setVolumeScale(const DataSetId& id, double scale[3])
+{
+    VolumeHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _volumes.begin();
+        doAll = true;
+    } else {
+        itr = _volumes.find(id);
+    }
+    if (itr == _volumes.end()) {
+        ERROR("Volume not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setScale(scale);
+    } while (doAll && ++itr != _volumes.end());
+
+    resetAxes();
+    _needsRedraw = true;
 }
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -232 +232 @@
     Contour2D *getContour2D(const DataSetId& id);
 
+    void setContour2DTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setContour2DOrientation(const DataSetId& id, double quat[4]);
+
+    void setContour2DOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setContour2DPosition(const DataSetId& id, double pos[3]);
+
+    void setContour2DScale(const DataSetId& id, double scale[3]);
+
     void setContour2DEdgeColor(const DataSetId& id, float color[3]);
 
@@ -254 +264 @@
     Contour3D *getContour3D(const DataSetId& id);
 
+    void setContour3DTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setContour3DOrientation(const DataSetId& id, double quat[4]);
+
+    void setContour3DOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setContour3DPosition(const DataSetId& id, double pos[3]);
+
+    void setContour3DScale(const DataSetId& id, double scale[3]);
+
     void setContour3DColor(const DataSetId& id, float color[3]);
 
@@ -284 +304 @@
     Glyphs *getGlyphs(const DataSetId& id);
 
+    void setGlyphsTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setGlyphsOrientation(const DataSetId& id, double quat[4]);
+
+    void setGlyphsOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setGlyphsPosition(const DataSetId& id, double pos[3]);
+
+    void setGlyphsScale(const DataSetId& id, double scale[3]);
+
     void setGlyphsEdgeVisibility(const DataSetId& id, bool state);
 
@@ -302 +332 @@
     void setGlyphsShape(const DataSetId& id, Glyphs::GlyphShape shape);
 
+    void setGlyphsColorMode(const DataSetId& id, Glyphs::ColorMode mode);
+
+    void setGlyphsScalingMode(const DataSetId& id, Glyphs::ScalingMode mode);
+
     void setGlyphsScaleFactor(const DataSetId& id, double scale);
 
@@ -358 +392 @@
     LIC *getLIC(const DataSetId& id);
 
+    void setLICTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setLICOrientation(const DataSetId& id, double quat[4]);
+
+    void setLICOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setLICPosition(const DataSetId& id, double pos[3]);
+
+    void setLICScale(const DataSetId& id, double scale[3]);
+
     void setLICEdgeVisibility(const DataSetId& id, bool state);
     
@@ -456 +500 @@
 
     PseudoColor *getPseudoColor(const DataSetId& id);
-    
+
+    void setPseudoColorTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setPseudoColorOrientation(const DataSetId& id, double quat[4]);
+
+    void setPseudoColorOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setPseudoColorPosition(const DataSetId& id, double pos[3]);
+
+    void setPseudoColorScale(const DataSetId& id, double scale[3]);
+
     void setPseudoColorEdgeVisibility(const DataSetId& id, bool state);
 
@@ -480 +534 @@
 
     Streamlines *getStreamlines(const DataSetId& id);
+
+    void setStreamlinesTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setStreamlinesOrientation(const DataSetId& id, double quat[4]);
+
+    void setStreamlinesOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setStreamlinesPosition(const DataSetId& id, double pos[3]);
+
+    void setStreamlinesScale(const DataSetId& id, double scale[3]);
 
     void setStreamlinesEdgeVisibility(const DataSetId& id, bool state);
@@ -521 +585 @@
 
     Volume *getVolume(const DataSetId& id);
-    
+
+    void setVolumeTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setVolumeOrientation(const DataSetId& id, double quat[4]);
+
+    void setVolumeOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setVolumePosition(const DataSetId& id, double pos[3]);
+
+    void setVolumeScale(const DataSetId& id, double scale[3]);
+
     void setVolumeAmbient(const DataSetId& id, double coeff);
 

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -757 +757 @@
 
 static int
+Contour2DOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setContour2DOrientation(name, quat);
+    } else {
+        g_renderer->setContour2DOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour2DPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour2DPosition(name, pos);
+    } else {
+        g_renderer->setContour2DPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour2DScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour2DScale(name, scale);
+    } else {
+        g_renderer->setContour2DScale("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
 Contour2DVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                    Tcl_Obj *const *objv)
@@ -779 +837 @@
     {"linecolor", 5, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth", 5, Contour2DLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   1, Contour2DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"opacity",   2, Contour2DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",    2, Contour2DOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, Contour2DPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",     1, Contour2DScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",   1, Contour2DVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
@@ -998 +1059 @@
     } else {
         g_renderer->setContour3DOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setContour3DOrientation(name, quat);
+    } else {
+        g_renderer->setContour3DOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour3DPosition(name, pos);
+    } else {
+        g_renderer->setContour3DPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+Contour3DScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setContour3DScale(name, scale);
+    } else {
+        g_renderer->setContour3DScale("all", scale);
     }
     return TCL_OK;
@@ -1045 +1164 @@
     {"linecolor", 5, Contour3DLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth", 5, Contour3DLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   1, Contour3DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"opacity",   2, Contour3DOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",    2, Contour3DOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, Contour3DPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",     1, Contour3DScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",   1, Contour3DVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, Contour3DWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -1338 +1460 @@
 
 static int
+GlyphsColorModeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    Glyphs::ColorMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 's' && strcmp(str, "scale") == 0) {
+        mode = Glyphs::COLOR_BY_SCALE;
+    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = Glyphs::COLOR_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vector") == 0) {
+        mode = Glyphs::COLOR_BY_VECTOR;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode option \"", str,
+                         "\": should be one of: 'scale', 'scalar', 'vector'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGlyphsColorMode(name, mode);
+    } else {
+        g_renderer->setGlyphsColorMode("all", mode);
+    }
+    return TCL_OK;
+}
+
+static int
 GlyphsDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                Tcl_Obj *const *objv)
@@ -1438 +1586 @@
 
 static int
+GlyphsOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGlyphsOrientation(name, quat);
+    } else {
+        g_renderer->setGlyphsOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+GlyphsPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGlyphsPosition(name, pos);
+    } else {
+        g_renderer->setGlyphsPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
 GlyphsScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
 {
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGlyphsScale(name, scale);
+    } else {
+        g_renderer->setGlyphsScale("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+GlyphsScaleFactorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
     double scale;
     if (Tcl_GetDoubleFromObj(interp, objv[2], &scale) != TCL_OK) {
@@ -1450 +1656 @@
     } else {
         g_renderer->setGlyphsScaleFactor("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+GlyphsScalingModeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    Glyphs::ScalingMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = Glyphs::SCALE_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vector") == 0) {
+        mode = Glyphs::SCALE_BY_VECTOR;
+    } else if (str[0] == 'v' && strcmp(str, "vector_comp") == 0) {
+        mode = Glyphs::SCALE_BY_VECTOR_COMPONENTS;
+    } else if (str[0] == 'o' && strcmp(str, "off") == 0) {
+        mode = Glyphs::SCALING_OFF;
+    } else {
+        Tcl_AppendResult(interp, "bad scaling mode option \"", str,
+                         "\": should be one of: 'scalar', 'vector', 'vector_comp', 'off'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGlyphsScalingMode(name, mode);
+    } else {
+        g_renderer->setGlyphsScalingMode("all", mode);
     }
     return TCL_OK;
@@ -1530 +1764 @@
 static Rappture::CmdSpec glyphsOps[] = {
     {"add",       1, GlyphsAddOp, 3, 4, "shape ?dataSetNme?"},
-    {"colormap",  1, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetNme?"},
+    {"colormap",  7, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetNme?"},
+    {"colormode", 7, GlyphsColorModeOp, 3, 4, "mode ?dataSetNme?"},
     {"delete",    1, GlyphsDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, GlyphsEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"gscale",    1, GlyphsScaleFactorOp, 3, 4, "scaleFactor ?dataSetName?"},
     {"lighting",  3, GlyphsLightingOp, 3, 4, "bool ?dataSetName?"},
     {"linecolor", 5, GlyphsLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth", 5, GlyphsLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   1, GlyphsOpacityOp, 3, 4, "value ?dataSetName?"},
-    {"scale",     2, GlyphsScaleOp, 3, 4, "scaleFactor ?dataSetName?"},
+    {"opacity",   2, GlyphsOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",    2, GlyphsOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, GlyphsPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",     2, GlyphsScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"shape",     2, GlyphsShapeOp, 3, 4, "shapeVal ?dataSetName?"},
+    {"smode",     2, GlyphsScalingModeOp, 3, 4, "mode ?dataSetNme?"},
     {"visible",   1, GlyphsVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, GlyphsWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -1934 +2173 @@
     {"orient",       2, HeightMapOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     {"pos",          1, HeightMapPositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",        1, HeightMapScaleOp, 5, 6, "sx sy sz  ?dataSetName?"},
+    {"scale",        1, HeightMapScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",      2, HeightMapVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"volumeslice",  2, HeightMapVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"}
@@ -2135 +2374 @@
 
 static int
+LICOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setLICOrientation(name, quat);
+    } else {
+        g_renderer->setLICOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+LICPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setLICPosition(name, pos);
+    } else {
+        g_renderer->setLICPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+LICScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+           Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setLICScale(name, scale);
+    } else {
+        g_renderer->setLICScale("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
 LICVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
              Tcl_Obj *const *objv)
@@ -2190 +2487 @@
     {"linecolor",   5, LICLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth",   5, LICLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",     1, LICOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"opacity",     2, LICOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",      2, LICOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",         1, LICPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",       1, LICScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",     2, LICVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"volumeslice", 2, LICVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"}
@@ -2505 +2805 @@
     {"pos",        1, MoleculePositionOp, 5, 6, "x y z ?dataSetName?"},
     {"rscale",     1, MoleculeAtomScalingOp, 3, 4, "scaling ?dataSetName?"},
-    {"scale",      1, MoleculeScaleOp, 5, 6, "sx sy sz  ?dataSetName?"},
+    {"scale",      1, MoleculeScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",    1, MoleculeVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe",  1, MoleculeWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -2659 +2959 @@
 static int
 PolyDataOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                  Tcl_Obj *const *objv)
+                 Tcl_Obj *const *objv)
 {
     double quat[4];
@@ -2679 +2979 @@
 static int
 PolyDataPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                    Tcl_Obj *const *objv)
+                   Tcl_Obj *const *objv)
 {
     double pos[3];
@@ -2698 +2998 @@
 static int
 PolyDataScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                 Tcl_Obj *const *objv)
+                Tcl_Obj *const *objv)
 {
     double scale[3];
@@ -2714 +3014 @@
     return TCL_OK;
 }
-
 
 static int
@@ -2761 +3060 @@
     {"orient",    2, PolyDataOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     {"pos",       1, PolyDataPositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",     1, PolyDataScaleOp, 5, 6, "sx sy sz  ?dataSetName?"},
+    {"scale",     1, PolyDataScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",   1, PolyDataVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, PolyDataWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -2904 +3203 @@
     } else {
         g_renderer->setPseudoColorOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setPseudoColorOrientation(name, quat);
+    } else {
+        g_renderer->setPseudoColorOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPseudoColorPosition(name, pos);
+    } else {
+        g_renderer->setPseudoColorPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+PseudoColorScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setPseudoColorScale(name, scale);
+    } else {
+        g_renderer->setPseudoColorScale("all", scale);
     }
     return TCL_OK;
@@ -2950 +3307 @@
     {"linecolor", 5, PseudoColorLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth", 5, PseudoColorLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   1, PseudoColorOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"opacity",   2, PseudoColorOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",    2, PseudoColorOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, PseudoColorPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",     1, PseudoColorScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",   1, PseudoColorVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, PseudoColorWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -3258 +3618 @@
     } else {
         g_renderer->setStreamlinesOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+StreamlinesOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setStreamlinesOrientation(name, quat);
+    } else {
+        g_renderer->setStreamlinesOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+StreamlinesPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setStreamlinesPosition(name, pos);
+    } else {
+        g_renderer->setStreamlinesPosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+StreamlinesScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setStreamlinesScale(name, scale);
+    } else {
+        g_renderer->setStreamlinesScale("all", scale);
     }
     return TCL_OK;
@@ -3461 +3879 @@
     {"lines",     5, StreamlinesLinesOp, 2, 3, "?dataSetName?"},
     {"linewidth", 5, StreamlinesLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   1, StreamlinesOpacityOp, 3, 4, "val ?dataSetName?"},
+    {"opacity",   2, StreamlinesOpacityOp, 3, 4, "val ?dataSetName?"},
+    {"orient",    2, StreamlinesOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, StreamlinesPositionOp, 5, 6, "x y z ?dataSetName?"},
     {"ribbons",   1, StreamlinesRibbonsOp, 4, 5, "width angle ?dataSetName?"},
-    {"seed",      1, StreamlinesSeedOp, 4, 11, "op params... ?dataSetName?"},
+    {"scale",     2, StreamlinesScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"seed",      2, StreamlinesSeedOp, 4, 11, "op params... ?dataSetName?"},
     {"tubes",     1, StreamlinesTubesOp, 4, 5, "numSides radius ?dataSetName?"},
     {"visible",   1, StreamlinesVisibleOp, 3, 4, "bool ?dataSetName?"}
@@ -3553 +3974 @@
     } else {
         g_renderer->setVolumeOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+VolumeOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setVolumeOrientation(name, quat);
+    } else {
+        g_renderer->setVolumeOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+VolumePositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setVolumePosition(name, pos);
+    } else {
+        g_renderer->setVolumePosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+VolumeScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setVolumeScale(name, scale);
+    } else {
+        g_renderer->setVolumeScale("all", scale);
     }
     return TCL_OK;
@@ -3655 +4134 @@
     {"delete",   1, VolumeDeleteOp, 2, 3, "?dataSetName?"},
     {"lighting", 1, VolumeLightingOp, 3, 4, "bool ?dataSetName?"},
-    {"opacity",  1, VolumeOpacityOp, 3, 4, "val ?dataSetName?"},
-    {"shading",  1, VolumeShadingOp, 4, 6, "oper val ?dataSetName?"},
+    {"opacity",  2, VolumeOpacityOp, 3, 4, "val ?dataSetName?"},
+    {"orient",   2, VolumeOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",      1, VolumePositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",    2, VolumeScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"shading",  2, VolumeShadingOp, 4, 6, "oper val ?dataSetName?"},
     {"visible",  1, VolumeVisibleOp, 3, 4, "bool ?dataSetName?"}
 };

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -94 +94 @@
 contour2d linewidth <val> <?datasetName?>
 contour2d opacity <val> <?datasetName?>
+contour2d orient <qw> <qx> <qy> <qz> <?dataSetName?>
+contour2d pos <x> <y> <z> <?dataSetName?>
+contour2d scale <sx> <sy> <sz> <?dataSetName?>
 contour2d visible <bool> <?datasetName?>
 
@@ -109 +112 @@
 contour3d linewidth <val> <?datasetName?>
 contour3d opacity <val> <?datasetName?>
+contour3d orient <qw> <qx> <qy> <qz> <?dataSetName?>
+contour3d pos <x> <y> <z> <?dataSetName?>
+contour3d scale <sx> <sy> <sz> <?dataSetName?>
 contour3d visible <bool> <?datasetName?>
 contour3d wireframe <bool> <?datasetName?>
@@ -114 +120 @@
 glyphs add <?dataSetName?>
 glyphs colormap <colorMapName> <?dataSetName?>
+glyphs colormode <scale|scalar|vector> <?dataSetName?>
+       Set the color mode: color by scale, scalar field or
+       vector magnitude -- uses the current color map
 glyphs delete <?dataSetName?>
 glyphs edges <bool> <?datasetName?>
+glyphs gscale <scaleFactor> <?datasetName?>
+       Set glyph scaling factor
 glyphs lighting <bool> <?datasetName?>
 glyphs linecolor <r> <g> <b> <?datasetName?>
 glyphs linewidth <val> <?datasetName?>
 glyphs opacity <val> <?datasetName?>
-glyphs scale <scaleFactor> <?datasetName?>
+glyphs orient <qw> <qx> <qy> <qz> <?dataSetName?>
+glyphs pos <x> <y> <z> <?dataSetName?>
+glyphs scale <sx> <sy> <sz> <?dataSetName?>
 glyphs shape <arrow|cone|cube|cylinder|dodecahedron|icosahedron|octahedron|sphere|tetrahedron> <?datasetName?>
+glyphs smode <scalar|vector|vector_comp|off> <?dataSetName?>
+       Set the scaling mode: use the scalar field, vector magnitude 
+       (uniform scale), vector components, or disable scaling
 glyphs visible <bool> <?datasetName?>
 glyphs wireframe <bool> <?datasetName?>
@@ -157 +173 @@
 lic linewidth <val> <?datasetName?>
 lic opacity <val> <?datasetName?>
+lic orient <qw> <qx> <qy> <qz> <?dataSetName?>
+lic pos <x> <y> <z> <?dataSetName?>
+lic scale <sx> <sy> <sz> <?dataSetName?>
 lic visible <bool> <?datasetName?>
 lic volumeslice <axis> <ratio> <?datasetName?>
@@ -203 +222 @@
 pseudocolor linewidth <val> <?datasetName?>
 pseudocolor opacity <val> <?datasetName?>
+pseudocolor orient <qw> <qx> <qy> <qz> <?dataSetName?>
+pseudocolor pos <x> <y> <z> <?dataSetName?>
+pseudocolor scale <sx> <sy> <sz> <?dataSetName?>
 pseudocolor visible <bool> <?datasetName?>
 pseudocolor wireframe <bool> <?datasetName?>
@@ -221 +243 @@
 streamlines linewidth <val> <?datasetName?>
 streamlines opacity <val> <?datasetName?>
+streamlines orient <qw> <qx> <qy> <qz> <?dataSetName?>
+streamlines pos <x> <y> <z> <?dataSetName?>
 streamlines ribbons <width> <angle> <?datasetName?>
             Set rendering type to ribbons, width is minimum half-width, angle is
             degrees offset from normal orientation
+streamlines scale <sx> <sy> <sz> <?dataSetName?>
 streamlines seed color <r> <g> <b> <?datasetName?>
 streamlines seed polygon <centerX> <centerY> <centerZ> <normalX> <normalY> <normalZ> <radius> <numSides> <?dataSetName?>
@@ -238 +263 @@
 volume delete <?datasetName?>
 volume lighting <bool> <?datasetName?>
+volume orient <qw> <qx> <qy> <qz> <?dataSetName?>
+volume pos <x> <y> <z> <?dataSetName?>
+volume scale <sx> <sy> <sz> <?dataSetName?>
 volume shading ambient <coeff> <?datasetName?>
 volume shading diffuse <coeff> <?datasetName?>