Changeset 3844 for branches/1.3/packages

Timestamp:

Jul 26, 2013, 6:00:09 PM (11 years ago)

Author:

ldelgass

Message:

Sync with trunk. Branch now differs only from trunk by r3722 (branch is version
1.3, trunk is version 1.4)

Location:

branches/1.3

Files:

• . (modified) (1 prop)
• packages/vizservers/vtkvis/Contour3D.cpp (modified) (1 diff)
• packages/vizservers/vtkvis/DataSet.cpp (modified) (8 diffs)
• packages/vizservers/vtkvis/DataSet.h (modified) (1 diff)
• packages/vizservers/vtkvis/Glyphs.cpp (modified) (6 diffs)
• packages/vizservers/vtkvis/Glyphs.h (modified) (3 diffs)
• packages/vizservers/vtkvis/GraphicsObject.cpp (modified) (1 diff)
• packages/vizservers/vtkvis/GraphicsObject.h (modified) (10 diffs)
• packages/vizservers/vtkvis/HeightMap.cpp (modified) (1 diff)
• packages/vizservers/vtkvis/Image.cpp (copied) (copied from trunk/packages/vizservers/vtkvis/Image.cpp)
• packages/vizservers/vtkvis/Image.h (copied) (copied from trunk/packages/vizservers/vtkvis/Image.h)
• packages/vizservers/vtkvis/Makefile.in (modified) (11 diffs)
• packages/vizservers/vtkvis/Math.h (modified) (1 diff)
• packages/vizservers/vtkvis/Molecule.cpp (modified) (14 diffs)
• packages/vizservers/vtkvis/Molecule.h (modified) (4 diffs)
• packages/vizservers/vtkvis/PolyData.cpp (modified) (13 diffs)
• packages/vizservers/vtkvis/PolyData.h (modified) (3 diffs)
• packages/vizservers/vtkvis/PseudoColor.cpp (modified) (4 diffs)
• packages/vizservers/vtkvis/RenderServer.cpp (modified) (2 diffs)
• packages/vizservers/vtkvis/RenderServer.h (modified) (1 diff)
• packages/vizservers/vtkvis/Renderer.cpp (modified) (36 diffs)
• packages/vizservers/vtkvis/Renderer.h (modified) (13 diffs)
• packages/vizservers/vtkvis/RendererCmd.cpp (modified) (48 diffs)
• packages/vizservers/vtkvis/RendererGraphicsObjs.cpp (modified) (12 diffs)
• packages/vizservers/vtkvis/RendererGraphicsObjs.h (modified) (1 diff)
• packages/vizservers/vtkvis/Text3D.cpp (copied) (copied from trunk/packages/vizservers/vtkvis/Text3D.cpp)
• packages/vizservers/vtkvis/Text3D.h (copied) (copied from trunk/packages/vizservers/vtkvis/Text3D.h)
• packages/vizservers/vtkvis/Volume.cpp (modified) (4 diffs)
• packages/vizservers/vtkvis/protocol.txt (modified) (17 diffs)

branches/1.3/packages/vizservers/vtkvis/Contour3D.cpp

@@ -151 +151 @@
 #endif
             _contourFilter->SetInputConnection(mesher->GetOutputPort());
-        } else if (vtkPolyData::SafeDownCast(ds) != NULL) {
-            // DataSet is a vtkPolyData with lines and/or polygons
-            ERROR("Not a 3D DataSet");
-            return;
         } else {
-            // DataSet is NOT a vtkPolyData
+            // DataSet is 3D with cells.  If DataSet is a surface
+            // (e.g. polydata or ugrid with 2D cells), we will 
+            // generate lines instead of surfaces
 #ifdef USE_VTK6
             _contourFilter->SetInputData(ds);

branches/1.3/packages/vizservers/vtkvis/DataSet.cpp

@@ -24 +24 @@
 #include <vtkCell.h>
 #include <vtkLookupTable.h>
+#include <vtkExtractUnstructuredGrid.h>
 
 #include "DataSet.h"
@@ -145 +146 @@
 }
 
-void DataSet::print() const
-{
-    print(_dataSet);
-}
-
-void DataSet::print(vtkDataSet *ds)
-{
-    if (ds == NULL)
-        return;
-
-    TRACE("DataSet class: %s", ds->GetClassName());
-
-    TRACE("DataSet memory: %g MiB", ds->GetActualMemorySize()/1024.);
-
-    double bounds[6];
-    ds->GetBounds(bounds);
-
-    // Topology
-    TRACE("DataSet bounds: %g %g %g %g %g %g",
-          bounds[0], bounds[1],
-          bounds[2], bounds[3],
-          bounds[4], bounds[5]);
-    TRACE("Points: %d Cells: %d", ds->GetNumberOfPoints(), ds->GetNumberOfCells());
-
-    double dataRange[2];
-    if (ds->GetPointData() != NULL) {
-        TRACE("PointData arrays: %d", ds->GetPointData()->GetNumberOfArrays());
-        for (int i = 0; i < ds->GetPointData()->GetNumberOfArrays(); i++) {
-            if (ds->GetPointData()->GetArray(i) != NULL) {
-                ds->GetPointData()->GetArray(i)->GetRange(dataRange, -1);
-                TRACE("PointData[%d]: '%s' comp:%d, (%g,%g)", i,
-                      ds->GetPointData()->GetArrayName(i),
-                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents(),
-                      dataRange[0], dataRange[1]);
-            } else {
-                TRACE("PointData[%d]: '%s' comp:%d", i,
-                      ds->GetPointData()->GetArrayName(i),
-                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents());
-            }
-        }
-        if (ds->GetPointData()->GetScalars() != NULL) {
-            TRACE("Active point scalars: %s", ds->GetPointData()->GetScalars()->GetName());
-        }
-        if (ds->GetPointData()->GetVectors() != NULL) {
-            TRACE("Active point vectors: %s", ds->GetPointData()->GetVectors()->GetName());
-        }
-    }
-    if (ds->GetCellData() != NULL) {
-        TRACE("CellData arrays: %d", ds->GetCellData()->GetNumberOfArrays());
-        for (int i = 0; i < ds->GetCellData()->GetNumberOfArrays(); i++) {
-            if (ds->GetCellData()->GetArray(i) != NULL) {
-                ds->GetCellData()->GetArray(i)->GetRange(dataRange, -1);
-                TRACE("CellData[%d]: '%s' comp:%d, (%g,%g)", i,
-                      ds->GetCellData()->GetArrayName(i),
-                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents(),
-                      dataRange[0], dataRange[1]);
-            } else {
-                TRACE("CellData[%d]: '%s' comp:%d", i,
-                      ds->GetCellData()->GetArrayName(i),
-                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents());
-            }
-        }
-        if (ds->GetCellData()->GetScalars() != NULL) {
-            TRACE("Active cell scalars: %s", ds->GetCellData()->GetScalars()->GetName());
-        }
-        if (ds->GetCellData()->GetVectors() != NULL) {
-            TRACE("Active cell vectors: %s", ds->GetCellData()->GetVectors()->GetName());
-        }
-    }
-    if (ds->GetFieldData() != NULL) {
-        TRACE("FieldData arrays: %d", ds->GetFieldData()->GetNumberOfArrays());
-        for (int i = 0; i < ds->GetFieldData()->GetNumberOfArrays(); i++) {
-            if (ds->GetFieldData()->GetArray(i) != NULL) {
-                ds->GetFieldData()->GetArray(i)->GetRange(dataRange, -1);
-                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d (%g,%g)", i,
-                      ds->GetFieldData()->GetArrayName(i),
-                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
-                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples(),
-                      dataRange[0], dataRange[1]);
-            } else {
-                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d", i,
-                      ds->GetFieldData()->GetArrayName(i),
-                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
-                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples());
-            }
-        }
-    }
-}
-
-void DataSet::setDefaultArrays()
-{
-    if (_dataSet->GetPointData() != NULL &&
-        _dataSet->GetPointData()->GetScalars() == NULL &&
-        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
-        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
-            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
-                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 1) {
-                TRACE("Setting point scalars to '%s'", _dataSet->GetPointData()->GetArrayName(i));
-                _dataSet->GetPointData()->SetActiveScalars(_dataSet->GetPointData()->GetArrayName(i));
-                break;
-            }
-        }
-    }
-    if (_dataSet->GetPointData() != NULL &&
-        _dataSet->GetPointData()->GetVectors() == NULL &&
-        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
-        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
-            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
-                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 3) {
-                TRACE("Setting point vectors to '%s'", _dataSet->GetPointData()->GetArrayName(i));
-                _dataSet->GetPointData()->SetActiveVectors(_dataSet->GetPointData()->GetArrayName(i));
-                break;
-            }
-        }
-    }
-    if (_dataSet->GetCellData() != NULL &&
-        _dataSet->GetCellData()->GetScalars() == NULL &&
-        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
-        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
-            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
-                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 1) {
-                TRACE("Setting cell scalars to '%s'", _dataSet->GetCellData()->GetArrayName(i));
-                _dataSet->GetCellData()->SetActiveScalars(_dataSet->GetCellData()->GetArrayName(i));
-                break;
-            }
-        }
-    }
-    if (_dataSet->GetCellData() != NULL &&
-        _dataSet->GetCellData()->GetVectors() == NULL &&
-        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
-        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
-            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
-                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 3) {
-                TRACE("Setting cell vectors to '%s'", _dataSet->GetCellData()->GetArrayName(i));
-                _dataSet->GetCellData()->SetActiveVectors(_dataSet->GetCellData()->GetArrayName(i));
-                break;
-            }
-        }
-    }
-}
-
 /**
  * \brief Read dataset using supplied reader
@@ -303 +163 @@
     if (_dataSet == NULL)
         return false;
+
+    if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL) {
+        vtkSmartPointer<vtkExtractUnstructuredGrid> filter = vtkSmartPointer<vtkExtractUnstructuredGrid>::New();
+#ifdef USE_VTK6
+        filter->SetInputData(_dataSet);
+#else
+        filter->SetInput(_dataSet);
+#endif
+        filter->MergingOn();
+        filter->ReleaseDataFlagOn();
+        filter->Update();
+        _dataSet = filter->GetOutput();
+    }
+
 #ifndef USE_VTK6
     _dataSet->SetPipelineInformation(NULL);
@@ -560 +434 @@
             return _dataSet->GetPointData()->GetScalars()->GetName();
         }
+#ifdef DEBUG
         TRACE("No point scalars");
+#endif
         if (_dataSet->GetCellData() != NULL &&
             _dataSet->GetCellData()->GetScalars() != NULL) {
             return _dataSet->GetCellData()->GetScalars()->GetName();
         }
+#ifdef DEBUG
         TRACE("No cell scalars");
+#endif
     }
     return NULL;
@@ -580 +458 @@
             return POINT_DATA;
         }
+#ifdef DEBUG
         TRACE("No point scalars");
+#endif
         if (_dataSet->GetCellData() != NULL &&
             _dataSet->GetCellData()->GetScalars() != NULL) {
             return CELL_DATA;
         }
+#ifdef DEBUG
         TRACE("No cell scalars");
+#endif
     }
     return POINT_DATA;
@@ -624 +506 @@
             return POINT_DATA;
         }
+#ifdef DEBUG
         TRACE("No point vectors");
+#endif
         if (_dataSet->GetCellData() != NULL &&
             _dataSet->GetCellData()->GetVectors() != NULL) {
             return CELL_DATA;
         }
+#ifdef DEBUG
         TRACE("No cell vectors");
+#endif
     }
     return POINT_DATA;
@@ -644 +530 @@
             return _dataSet->GetPointData()->GetVectors()->GetName();
         }
+#ifdef DEBUG
         TRACE("No point vectors");
+#endif
         if (_dataSet->GetCellData() != NULL &&
             _dataSet->GetCellData()->GetVectors() != NULL) {
             return _dataSet->GetCellData()->GetVectors()->GetName();
         }
+#ifdef DEBUG
         TRACE("No cell vectors");
+#endif
     }
     return NULL;
+}
+
+void DataSet::setDefaultArrays()
+{
+    if (_dataSet->GetPointData() != NULL &&
+        _dataSet->GetPointData()->GetScalars() == NULL &&
+        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
+        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
+            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
+                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 1) {
+                TRACE("Setting point scalars to '%s'", _dataSet->GetPointData()->GetArrayName(i));
+                _dataSet->GetPointData()->SetActiveScalars(_dataSet->GetPointData()->GetArrayName(i));
+                break;
+            }
+        }
+    }
+    if (_dataSet->GetPointData() != NULL &&
+        _dataSet->GetPointData()->GetVectors() == NULL &&
+        _dataSet->GetPointData()->GetNumberOfArrays() > 0) {
+        for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
+            if (_dataSet->GetPointData()->GetArray(i) != NULL &&
+                _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == 3) {
+                TRACE("Setting point vectors to '%s'", _dataSet->GetPointData()->GetArrayName(i));
+                _dataSet->GetPointData()->SetActiveVectors(_dataSet->GetPointData()->GetArrayName(i));
+                break;
+            }
+        }
+    }
+    if (_dataSet->GetCellData() != NULL &&
+        _dataSet->GetCellData()->GetScalars() == NULL &&
+        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
+        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
+            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
+                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 1) {
+                TRACE("Setting cell scalars to '%s'", _dataSet->GetCellData()->GetArrayName(i));
+                _dataSet->GetCellData()->SetActiveScalars(_dataSet->GetCellData()->GetArrayName(i));
+                break;
+            }
+        }
+    }
+    if (_dataSet->GetCellData() != NULL &&
+        _dataSet->GetCellData()->GetVectors() == NULL &&
+        _dataSet->GetCellData()->GetNumberOfArrays() > 0) {
+        for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
+            if (_dataSet->GetCellData()->GetArray(i) != NULL &&
+                _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == 3) {
+                TRACE("Setting cell vectors to '%s'", _dataSet->GetCellData()->GetArrayName(i));
+                _dataSet->GetCellData()->SetActiveVectors(_dataSet->GetCellData()->GetArrayName(i));
+                break;
+            }
+        }
+    }
 }
 
@@ -973 +915 @@
     return true;
 }
+
+void DataSet::print() const
+{
+    print(_dataSet);
+}
+
+void DataSet::print(vtkDataSet *ds)
+{
+    if (ds == NULL)
+        return;
+
+    TRACE("DataSet class: %s", ds->GetClassName());
+
+    TRACE("DataSet memory: %g MiB", ds->GetActualMemorySize()/1024.);
+
+    double bounds[6];
+    ds->GetBounds(bounds);
+
+    // Topology
+    TRACE("DataSet bounds: %g %g %g %g %g %g",
+          bounds[0], bounds[1],
+          bounds[2], bounds[3],
+          bounds[4], bounds[5]);
+    TRACE("Points: %d Cells: %d", ds->GetNumberOfPoints(), ds->GetNumberOfCells());
+
+    double dataRange[2];
+    if (ds->GetPointData() != NULL) {
+        TRACE("PointData arrays: %d", ds->GetPointData()->GetNumberOfArrays());
+        for (int i = 0; i < ds->GetPointData()->GetNumberOfArrays(); i++) {
+            if (ds->GetPointData()->GetArray(i) != NULL) {
+                ds->GetPointData()->GetArray(i)->GetRange(dataRange, -1);
+                TRACE("PointData[%d]: '%s' comp:%d, (%g,%g)", i,
+                      ds->GetPointData()->GetArrayName(i),
+                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents(),
+                      dataRange[0], dataRange[1]);
+            } else {
+                TRACE("PointData[%d]: '%s' comp:%d", i,
+                      ds->GetPointData()->GetArrayName(i),
+                      ds->GetPointData()->GetAbstractArray(i)->GetNumberOfComponents());
+            }
+        }
+        if (ds->GetPointData()->GetScalars() != NULL) {
+            TRACE("Active point scalars: %s", ds->GetPointData()->GetScalars()->GetName());
+        }
+        if (ds->GetPointData()->GetVectors() != NULL) {
+            TRACE("Active point vectors: %s", ds->GetPointData()->GetVectors()->GetName());
+        }
+    }
+    if (ds->GetCellData() != NULL) {
+        TRACE("CellData arrays: %d", ds->GetCellData()->GetNumberOfArrays());
+        for (int i = 0; i < ds->GetCellData()->GetNumberOfArrays(); i++) {
+            if (ds->GetCellData()->GetArray(i) != NULL) {
+                ds->GetCellData()->GetArray(i)->GetRange(dataRange, -1);
+                TRACE("CellData[%d]: '%s' comp:%d, (%g,%g)", i,
+                      ds->GetCellData()->GetArrayName(i),
+                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents(),
+                      dataRange[0], dataRange[1]);
+            } else {
+                TRACE("CellData[%d]: '%s' comp:%d", i,
+                      ds->GetCellData()->GetArrayName(i),
+                      ds->GetCellData()->GetAbstractArray(i)->GetNumberOfComponents());
+            }
+        }
+        if (ds->GetCellData()->GetScalars() != NULL) {
+            TRACE("Active cell scalars: %s", ds->GetCellData()->GetScalars()->GetName());
+        }
+        if (ds->GetCellData()->GetVectors() != NULL) {
+            TRACE("Active cell vectors: %s", ds->GetCellData()->GetVectors()->GetName());
+        }
+    }
+    if (ds->GetFieldData() != NULL) {
+        TRACE("FieldData arrays: %d", ds->GetFieldData()->GetNumberOfArrays());
+        for (int i = 0; i < ds->GetFieldData()->GetNumberOfArrays(); i++) {
+            if (ds->GetFieldData()->GetArray(i) != NULL) {
+                ds->GetFieldData()->GetArray(i)->GetRange(dataRange, -1);
+                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d (%g,%g)", i,
+                      ds->GetFieldData()->GetArrayName(i),
+                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
+                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples(),
+                      dataRange[0], dataRange[1]);
+            } else {
+                TRACE("FieldData[%d]: '%s' comp:%d, tuples:%d", i,
+                      ds->GetFieldData()->GetArrayName(i),
+                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfComponents(),
+                      ds->GetFieldData()->GetAbstractArray(i)->GetNumberOfTuples());
+            }
+        }
+    }
+}
+

branches/1.3/packages/vizservers/vtkvis/DataSet.h

@@ -26 +26 @@
 class DataSet {
 public:
+    /** 
+     * These enum values intentionally match vtkDataObject::FieldAssociations
+     * and vtkDataObject::AttributeTypes
+     */
     enum DataAttributeType {
         POINT_DATA,

branches/1.3/packages/vizservers/vtkvis/Glyphs.cpp

@@ -29 +29 @@
 #include <vtkTransformPolyDataFilter.h>
 #include <vtkPolyDataNormals.h>
+#include <vtkDelaunay2D.h>
+#include <vtkDelaunay3D.h>
+#include <vtkPolyData.h>
+#include <vtkUnstructuredGrid.h>
 
 #include "Glyphs.h"
 #include "Renderer.h"
+#include "Math.h"
 #include "Trace.h"
 
@@ -280 +285 @@
         _glyphMapper = vtkSmartPointer<vtkGlyph3DMapper>::New();
         _glyphMapper->SetResolveCoincidentTopologyToPolygonOffset();
+        // If there are color scalars, use them without lookup table (if scalar visibility is on)
+        _glyphMapper->SetColorModeToDefault();
         _glyphMapper->ScalarVisibilityOn();
     }
@@ -323 +330 @@
     }
 
-    double cellSizeRange[2];
-    double avgSize;
-    _dataSet->getCellSizeRange(cellSizeRange, &avgSize);
-    //_dataScale = cellSizeRange[0] + (cellSizeRange[1] - cellSizeRange[0])/2.;
-    _dataScale = avgSize;
-
-    TRACE("Cell size range: %g,%g, Data scale factor: %g",
-          cellSizeRange[0], cellSizeRange[1], _dataScale);
+    if (_dataSet->isCloud()) {
+        PrincipalPlane plane;
+        double offset;
+        if (_dataSet->is2D(&plane, &offset)) {
+            // 2D cloud
+            vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
+            if (plane == PLANE_ZY) {
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->RotateWXYZ(90, 0, 1, 0);
+                if (offset != 0.0) {
+                    trans->Translate(-offset, 0, 0);
+                }
+                mesher->SetTransform(trans);
+            } else if (plane == PLANE_XZ) {
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->RotateWXYZ(-90, 1, 0, 0);
+                if (offset != 0.0) {
+                    trans->Translate(0, -offset, 0);
+                }
+                mesher->SetTransform(trans);
+            } else if (offset != 0.0) {
+                // XY with Z offset
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->Translate(0, 0, -offset);
+                mesher->SetTransform(trans);
+            }
+#ifdef USE_VTK6
+            mesher->SetInputData(ds);
+#else
+            mesher->SetInput(ds);
+#endif
+            mesher->Update();
+            vtkPolyData *pd = mesher->GetOutput();
+            if (pd->GetNumberOfPolys() == 0) {
+                // Meshing failed, fall back to scale based on bounds
+                double bounds[6];
+                _dataSet->getBounds(bounds);
+                double xlen = bounds[1] - bounds[0];
+                double ylen = bounds[3] - bounds[2];
+                double zlen = bounds[5] - bounds[4];
+                double max = max3(xlen, ylen, zlen);
+                _dataScale = max / 64.0;
+            } else {
+                double cellSizeRange[2];
+                double avgSize;
+                DataSet::getCellSizeRange(pd, cellSizeRange, &avgSize);
+                _dataScale = avgSize * 2.0;
+            }
+        } else {
+            // 3D cloud
+            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
+#ifdef USE_VTK6
+            mesher->SetInputData(ds);
+#else
+            mesher->SetInput(ds);
+#endif
+            mesher->Update();
+            vtkUnstructuredGrid *ugrid = mesher->GetOutput();
+            if (ugrid->GetNumberOfCells() == 0) {
+                // Meshing failed, fall back to scale based on bounds
+                double bounds[6];
+                _dataSet->getBounds(bounds);
+                double xlen = bounds[1] - bounds[0];
+                double ylen = bounds[3] - bounds[2];
+                double zlen = bounds[5] - bounds[4];
+                double max = max3(xlen, ylen, zlen);
+                _dataScale = max / 64.0;
+            } else {
+                double cellSizeRange[2];
+                double avgSize;
+                DataSet::getCellSizeRange(ugrid, cellSizeRange, &avgSize);
+                _dataScale = avgSize * 2.0;
+            }
+        }
+    } else {
+        double cellSizeRange[2];
+        double avgSize;
+        _dataSet->getCellSizeRange(cellSizeRange, &avgSize);
+        _dataScale = avgSize * 2.0;
+    }
+
+    TRACE("Data scale factor: %g", _dataScale);
 
     // Normalize sizes to [0,1] * ScaleFactor
     _glyphMapper->SetClamping(_normalizeScale ? 1 : 0);
-    _glyphMapper->SetScaleFactor(_scaleFactor * _dataScale);
+    if (_normalizeScale) {
+        _glyphMapper->SetScaleFactor(_scaleFactor * _dataScale);
+        TRACE("Setting scale factor: %g", _scaleFactor * _dataScale);
+    } else {
+        _glyphMapper->SetScaleFactor(_scaleFactor);
+        TRACE("Setting scale factor: %g", _scaleFactor);
+    }
     _glyphMapper->ScalingOn();
 
@@ -363 +450 @@
         if (_glyphMapper != NULL) {
             _glyphMapper->SetClamping(_normalizeScale ? 1 : 0);
+            if (_normalizeScale) {
+                _glyphMapper->SetScaleFactor(_scaleFactor * _dataScale);
+                TRACE("Setting scale factor: %g", _scaleFactor * _dataScale);
+            } else {
+                _glyphMapper->SetScaleFactor(_scaleFactor);
+                TRACE("Setting scale factor: %g", _scaleFactor);
+            }
         }
     }
@@ -667 +761 @@
     _scaleFactor = scale;
     if (_glyphMapper != NULL) {
-        _glyphMapper->SetScaleFactor(_scaleFactor * _dataScale);
+        if (_normalizeScale) {
+            _glyphMapper->SetScaleFactor(_scaleFactor * _dataScale);
+            TRACE("Setting scale factor: %g", _scaleFactor * _dataScale);
+        } else {
+            _glyphMapper->SetScaleFactor(_scaleFactor);
+            TRACE("Setting scale factor: %g", _scaleFactor);
+        }
     }
 }
@@ -787 +887 @@
 
 /**
+ * \brief Limit the number of glyphs displayed
+ *
+ * The choice of glyphs to display can be based on sampling every
+ * n-th point (ratio) or by random sample
+ *
+ * \param max Maximum number of glyphs to display, negative means display all
+ * \param random Flag to enable/disable random sampling
+ * \param offset If random is false, this controls the first sample point
+ * \param ratio If random is false, this ratio controls every n-th point sampling
+ */
+void Glyphs::setMaximumNumberOfGlyphs(int max, bool random, int offset, int ratio)
+{
+    if (_dataSet == NULL || _glyphMapper == NULL)
+        return;
+
+    if (max < 0) {
+        if (_maskPoints != NULL) {
+#ifdef USE_VTK6
+            _glyphMapper->SetInputData(_dataSet->getVtkDataSet());
+#else
+            _glyphMapper->SetInputConnection(_dataSet->getVtkDataSet()->GetProducerPort());
+#endif
+            _maskPoints = NULL;
+        }
+    } else {
+        if (_maskPoints == NULL) {
+            _maskPoints = vtkSmartPointer<vtkMaskPoints>::New();
+        }
+#ifdef USE_VTK6
+        _maskPoints->SetInputData(_dataSet->getVtkDataSet());
+#else
+        _maskPoints->SetInput(_dataSet->getVtkDataSet());
+#endif
+        _maskPoints->SetMaximumNumberOfPoints(max);
+        _maskPoints->SetOffset(offset);
+        _maskPoints->SetOnRatio(ratio);
+        _maskPoints->SetRandomMode((random ? 1 : 0));
+        _maskPoints->GenerateVerticesOff();
+        _glyphMapper->SetInputConnection(_maskPoints->GetOutputPort());
+    }
+}
+
+/**
  * \brief Set a group of world coordinate planes to clip rendering
  *

branches/1.3/packages/vizservers/vtkvis/Glyphs.h

@@ -16 +16 @@
 #include <vtkVersion.h>
 #include <vtkGlyph3DMapper.h>
+#include <vtkMaskPoints.h>
 #include <vtkLookupTable.h>
 #include <vtkPlaneCollection.h>
@@ -92 +93 @@
     void setScaleFactor(double scale);
 
+    void setMaximumNumberOfGlyphs(int max, bool random = true,
+                                  int offset = 0, int ratio = 1);
+
     void setColorMap(ColorMap *colorMap);
 
@@ -136 +140 @@
     vtkSmartPointer<vtkPolyDataAlgorithm> _glyphSource;
     vtkSmartPointer<vtkGlyph3DMapper> _glyphMapper;
+    vtkSmartPointer<vtkMaskPoints> _maskPoints;
 };
 

branches/1.3/packages/vizservers/vtkvis/GraphicsObject.cpp

@@ -13 +13 @@
 
 void GraphicsObject::setDataSet(DataSet *dataSet,
-                                   Renderer *renderer)
+                                Renderer *renderer)
 {
     if (_dataSet != dataSet) {

branches/1.3/packages/vizservers/vtkvis/GraphicsObject.h

@@ -14 +14 @@
 #include <vtkSmartPointer.h>
 #include <vtkProp.h>
+#include <vtkActor2D.h>
 #include <vtkProp3D.h>
 #include <vtkProp3DCollection.h>
 #include <vtkAssembly.h>
 #include <vtkActor.h>
+#include <vtkImageActor.h>
 #include <vtkVolume.h>
 #include <vtkProperty.h>
+#include <vtkImageProperty.h>
 #include <vtkVolumeProperty.h>
 #include <vtkMath.h>
@@ -114 +117 @@
 
     /**
+     * \brief Cast the vktProp to a vtkActor2D
+     *
+     * \return NULL or a vtkActor2D pointer
+     */
+    inline vtkActor2D *getActor2D()
+    {
+        return vtkActor2D::SafeDownCast(_prop);
+    }
+
+    /**
      * \brief Cast the vktProp to a vtkProp3D
      *
@@ -131 +144 @@
     {
         return vtkActor::SafeDownCast(_prop);
+    }
+
+    /**
+     * \brief Cast the vktProp to a vtkImageActor
+     *
+     * \return NULL or a vtkImageActor pointer
+     */
+    inline vtkImageActor *getImageActor()
+    {
+        return vtkImageActor::SafeDownCast(_prop);
     }
 
@@ -484 +507 @@
                         TRACE("Culling on");
                     }
-                }
-            }
+                } else if (vtkImageActor::SafeDownCast(prop) != NULL) {
+                    vtkImageActor::SafeDownCast(prop)->GetProperty()->SetOpacity(opacity);
+                }
+            }
+        } else if (getImageActor() != NULL) {
+            getImageActor()->GetProperty()->SetOpacity(_opacity);
         }
     }
@@ -504 +531 @@
         if (getActor() != NULL) {
             getActor()->GetProperty()->SetAmbient(ambient);
+        } else if (getImageActor() != NULL) {
+            getImageActor()->GetProperty()->SetAmbient(ambient);
         } else if (getVolume() != NULL) {
             getVolume()->GetProperty()->SetAmbient(ambient);
@@ -513 +542 @@
                 if (vtkActor::SafeDownCast(prop) != NULL) {
                     vtkActor::SafeDownCast(prop)->GetProperty()->SetAmbient(ambient);
+                } else if (vtkImageActor::SafeDownCast(prop) != NULL) {
+                    vtkImageActor::SafeDownCast(prop)->GetProperty()->SetAmbient(ambient);
                 } else if (vtkVolume::SafeDownCast(prop) != NULL) {
                     vtkVolume::SafeDownCast(prop)->GetProperty()->SetAmbient(ambient);
@@ -527 +558 @@
         if (getActor() != NULL) {
             getActor()->GetProperty()->SetDiffuse(diffuse);
+        } else if (getImageActor() != NULL) {
+            getImageActor()->GetProperty()->SetDiffuse(diffuse);
         } else if (getVolume() != NULL) {
             getVolume()->GetProperty()->SetDiffuse(diffuse);
@@ -536 +569 @@
                 if (vtkActor::SafeDownCast(prop) != NULL) {
                     vtkActor::SafeDownCast(prop)->GetProperty()->SetDiffuse(diffuse);
+                } else if (vtkImageActor::SafeDownCast(prop) != NULL) {
+                    vtkImageActor::SafeDownCast(prop)->GetProperty()->SetDiffuse(diffuse);
                 } else if (vtkVolume::SafeDownCast(prop) != NULL) {
                     vtkVolume::SafeDownCast(prop)->GetProperty()->SetDiffuse(diffuse);
@@ -581 +616 @@
             property->SetSpecular(specular);
             property->SetSpecularPower(specPower);
+        } else if (getImageActor() != NULL) {
+            vtkImageProperty *property = getImageActor()->GetProperty();
+            property->SetAmbient(ambient);
+            property->SetDiffuse(diffuse);
         } else if (getVolume() != NULL) {
             vtkVolumeProperty *property = getVolume()->GetProperty();
@@ -598 +637 @@
                     property->SetSpecular(specular);
                     property->SetSpecularPower(specPower);
+                } else if (vtkImageActor::SafeDownCast(prop) != NULL) {
+                    vtkImageProperty *property = vtkImageActor::SafeDownCast(prop)->GetProperty();
+                    property->SetAmbient(ambient);
+                    property->SetDiffuse(diffuse);
                 } else if (vtkVolume::SafeDownCast(prop) != NULL) {
                     vtkVolumeProperty *property = vtkVolume::SafeDownCast(prop)->GetProperty();

branches/1.3/packages/vizservers/vtkvis/HeightMap.cpp

@@ -478 +478 @@
     if (_contours.empty()) {
         // Evenly spaced isovalues
-        _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
+        if (_colorFieldRange[0] <= _colorFieldRange[1]) {
+            _contourFilter->GenerateValues(_numContours, _colorFieldRange[0], _colorFieldRange[1]);
+        } else {
+            _contourFilter->GenerateValues(_numContours, _dataRange[0], _dataRange[1]);
+        }
     } else {
         // User-supplied isovalues

branches/1.3/packages/vizservers/vtkvis/Makefile.in

@@ -2 +2 @@
 TRACE                   = #yes
 USE_CUSTOM_AXES         = yes
+USE_FONT_CONFIG         = #yes
 USE_GPU_RAYCASTING      = yes
 USE_OFFSCREEN_RENDERING = #yes
 USE_THREADS             = yes
-USE_VTK6                = yes
+NEW_SCALAR_BAR          = #yes
 
 bindir          = @bindir@
@@ -40 +41 @@
 
 VTK_LIB_DIR     = @VTK_LIB_DIR@
-VTK_LIB_SPEC    = -L$(VTK_LIB_DIR) \
-                -lvtkChemistry \
-                -lvtkIO \
-                -lvtkWidgets \
-                -lvtkFiltering \
-                -lvtkVolumeRendering \
-                -lvtkRendering \
-                -lvtkHybrid \
-                -lvtkGraphics \
-                -lvtkImaging \
-                -lvtkCommon
 VTK_INC_SPEC    = @VTK_INC_SPEC@
-VTK6_LIB_SPEC   = \
+VTK_LIB_SPEC    = \
                 -lvtkDomainsChemistry-6.0 \
                 -lvtkIOCore-6.0 \
                 -lvtkIOLegacy-6.0 \
+                -lvtkFiltersExtraction-6.0 \
                 -lvtkFiltersModeling-6.0 \
                 -lvtkFiltersFlowPaths-6.0 \
@@ -69 +60 @@
                 -lvtkRenderingHybridOpenGL-6.0 \
                 -lvtkRenderingFreeTypeOpenGL-6.0 \
+                -lvtkRenderingFreeTypeFontConfig-6.0 \
                 -lvtkRenderingFreeType-6.0  \
                 -lvtkRenderingVolumeOpenGL-6.0 \
@@ -80 +72 @@
                 -lvtkCommonMisc-6.0  \
                 -lvtkCommonTransforms-6.0 \
-                -lvtkCommonMath-6.0
-
-ifdef USE_VTK6
-VTK_LIB_SPEC    = $(VTK6_LIB_SPEC)
-endif
-
-ifdef USE_VTK6
+                -lvtkCommonMath-6.0 \
+                -lvtksys-6.0
+
 LD_RUN_PATH     = $(libdir)
-else
-LD_RUN_PATH     = $(libdir):$(VTK_LIB_DIR)
-endif
 
 LIBS            = \
@@ -119 +104 @@
 DEFINES         += -DUSE_CUSTOM_AXES
 endif
+ifdef USE_FONT_CONFIG
+DEFINES         += -DUSE_FONT_CONFIG
+endif
 ifdef USE_OFFSCREEN_RENDERING
 DEFINES         += -DUSE_OFFSCREEN_RENDERING
@@ -128 +116 @@
 DEFINES         += -DUSE_THREADS
 endif
-ifdef USE_VTK6
-VTK_MOD_DEFS    = -DvtkRenderingCore_AUTOINIT="4(vtkInteractionStyle,vtkRenderingFreeType,vtkRenderingFreeTypeOpenGL,vtkRenderingOpenGL)" -DvtkRenderingVolume_AUTOINIT="1(vtkRenderingVolumeOpenGL)"
+VTK_MOD_DEFS    = -DvtkRenderingCore_AUTOINIT="5(vtkInteractionStyle,vtkRenderingFreeType,vtkRenderingFreeTypeFontConfig,vtkRenderingFreeTypeOpenGL,vtkRenderingOpenGL)" -DvtkRenderingVolume_AUTOINIT="1(vtkRenderingVolumeOpenGL)"
 DEFINES         += -DUSE_VTK6 $(VTK_MOD_DEFS)
+ifdef NEW_SCALAR_BAR
+DEFINES         += -DNEW_SCALAR_BAR
 endif
 
@@ -153 +142 @@
                 Group.cpp \
                 HeightMap.cpp \
+                Image.cpp \
                 LIC.cpp \
                 Line.cpp \
@@ -169 +159 @@
                 Sphere.cpp \
                 Streamlines.cpp \
+                Text3D.cpp \
                 TGAWriter.cpp \
                 Trace.cpp \
@@ -233 +224 @@
 Group.o: Group.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 HeightMap.o: HeightMap.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
+Image.o: Image.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 LIC.o: LIC.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h RenderServer.h
 Line.o: Line.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
@@ -243 +235 @@
 PseudoColor.o: PseudoColor.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
 ReadBuffer.o: ReadBuffer.h Trace.h
-Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Volume.h Warp.h ColorMap.h Trace.h
-RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
-RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Volume.h Warp.h ColorMap.h Trace.h
+Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
+RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
 RenderServer.o: RenderServer.h RendererCmd.h Renderer.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
 ResponseQueue.o: ResponseQueue.h Trace.h
@@ -251 +243 @@
 Sphere.o: Sphere.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 Streamlines.o: Streamlines.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
+Text3D.o: Text3D.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h
 Trace.o: Trace.h

branches/1.3/packages/vizservers/vtkvis/Math.h

@@ -217 +217 @@
 }
 
+inline double min3(double a, double b, double c)
+{
+    return min2(min2(a, b), c);
+}
+
+inline double max3(double a, double b, double c)
+{
+    return max2(max2(a, b), c);
+}
+
 }
 

branches/1.3/packages/vizservers/vtkvis/Molecule.cpp

@@ -29 +29 @@
 #include <vtkLabelPlacementMapper.h>
 #include <vtkTextProperty.h>
+#include <vtkTransformPolyDataFilter.h>
 
 #include "Molecule.h"
@@ -108 +109 @@
         _atomProp->GetProperty()->SetOpacity(_opacity);
         _atomProp->GetProperty()->SetAmbient(.2);
+        _atomProp->GetProperty()->SetSpecular(.2);
+        _atomProp->GetProperty()->SetSpecularPower(80.0);
         if (!_lighting)
             _atomProp->GetProperty()->LightingOff();
@@ -121 +124 @@
         _bondProp->GetProperty()->SetOpacity(_opacity);
         _bondProp->GetProperty()->SetAmbient(.2);
+        _bondProp->GetProperty()->SetSpecular(.2);
+        _bondProp->GetProperty()->SetSpecularPower(80.0);
         if (!_lighting)
             _bondProp->GetProperty()->LightingOff();
@@ -178 +183 @@
     addLabelArray(ds);
     addRadiusArray(ds, _atomScaling, _radiusScale);
+    computeBonds(ds);
 
     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
@@ -231 +237 @@
                 _labelHierarchy = vtkSmartPointer<vtkPointSetToLabelHierarchy>::New();
             }
-#ifdef USE_VTK6
-            _labelHierarchy->SetInputData(pd);
+            if (_labelTransform == NULL) {
+                _labelTransform = vtkSmartPointer<vtkTransform>::New();
+            }
+            vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
+#ifdef USE_VTK6              
+            transformFilter->SetInputData(pd);
 #else
-            _labelHierarchy->SetInput(pd);
+            transformFilter->SetInput(pd);
 #endif
+            transformFilter->SetTransform(_labelTransform);
+            _labelHierarchy->SetInputConnection(transformFilter->GetOutputPort());
             _labelHierarchy->SetLabelArrayName("_atom_labels");
             _labelHierarchy->GetTextProperty()->SetColor(0, 0, 0);
@@ -255 +267 @@
             _atomMapper->SetInputConnection(pd->GetProducerPort());
 #endif
-            if (ds->GetPointData() != NULL &&
-                ds->GetPointData()->GetVectors() != NULL) {
-                _atomMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
-                _atomMapper->SetScaleModeToScaleByMagnitude();
-                _atomMapper->ScalingOn();
-            } else {
-                _atomMapper->SetScaleModeToNoDataScaling();
-                _atomMapper->ScalingOff();
-            }
+            _atomMapper->SetScaleArray("_radii");
+            _atomMapper->SetScaleModeToScaleByMagnitude();
+            _atomMapper->ScalingOn();
             _atomMapper->OrientOff();
 
@@ -283 +289 @@
     if (pd->GetNumberOfLines() > 0) {
         _bondMapper->Update();
+    }
+}
+
+void Molecule::updateLabelTransform()
+{
+    if (_labelTransform != NULL && getAssembly() != NULL) {
+        _labelTransform->SetMatrix(getAssembly()->GetMatrix());
     }
 }
@@ -797 +810 @@
         if (_atomMapper != NULL) {
              assert(ds->GetPointData() != NULL &&
-                    ds->GetPointData()->GetVectors() != NULL);
+                    ds->GetPointData()->GetArray("_radii") != NULL);
             _atomMapper->SetScaleModeToScaleByMagnitude();
-            _atomMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
+            _atomMapper->SetScaleArray("_radii");
             _atomMapper->ScalingOn();
         }
@@ -887 +900 @@
         bondPoints->InsertNextPoint(newPt1);
 
+#ifdef DEBUG
         TRACE("Bond %d: (%g,%g,%g)-(%g,%g,%g)-(%g,%g,%g)", i,
               pt0[0], pt0[1], pt0[2], 
               center[0], center[1], center[2],
               pt1[0], pt1[1], pt1[2]);
+#endif
 
         double vec[3];
@@ -898 +913 @@
         bondVectors->InsertNextTupleValue(vec);
         bondVectors->InsertNextTupleValue(vec);
+#ifdef DEBUG
         TRACE("Bond %d, vec: %g,%g,%g", i, vec[0], vec[1], vec[2]);
+#endif
 
         double scale[3];
@@ -910 +927 @@
         if (elements != NULL) {
             int element = (int)elements->GetComponent(pts[0], 0);
+#ifdef DEBUG
             TRACE("Bond %d, elt 0: %d", i, element);
+#endif
             bondElements->InsertNextValue(element);
             element = (int)elements->GetComponent(pts[1], 0);
+#ifdef DEBUG
             TRACE("Bond %d, elt 1: %d", i, element);
+#endif
             bondElements->InsertNextValue(element);
         }
@@ -984 +1005 @@
         ;
     }
-    vtkSmartPointer<vtkFloatArray> radii = vtkSmartPointer<vtkFloatArray>::New();
-    radii->SetName("_radii");
-    radii->SetNumberOfComponents(3);
     vtkPolyData *pd = vtkPolyData::SafeDownCast(dataSet);
     if (pd == NULL) {
@@ -992 +1010 @@
         return;
     }
+    vtkDataArray *array = dataSet->GetPointData()->GetArray("_radii");
+    vtkSmartPointer<vtkFloatArray> radii;
+    if (array == NULL) {
+        radii = vtkSmartPointer<vtkFloatArray>::New();
+        radii->SetName("_radii");
+        radii->SetNumberOfComponents(1);
+        radii->SetNumberOfValues(pd->GetNumberOfPoints());
+    } else {
+        radii = vtkFloatArray::SafeDownCast(array);
+        assert(radii != NULL);
+    }
     for (int i = 0; i < pd->GetNumberOfPoints(); i++) {
-        float tuple[3];
-        tuple[1] = tuple[2] = 0;
+        float value;
         if (elements != NULL && radiusSource != NULL) {
             int elt = (int)elements->GetComponent(i, 0);
-            tuple[0] = radiusSource[elt] * scaleFactor;
+            value = radiusSource[elt] * scaleFactor;
         } else {
-            tuple[0] = scaleFactor;
-        }
-        radii->InsertNextTupleValue(tuple);
-    }
-    dataSet->GetPointData()->SetVectors(radii);
+            value = scaleFactor;
+        }
+        radii->SetValue(i, value);
+    }
+    radii->Modified();
+    if (array == NULL) {
+        dataSet->GetPointData()->AddArray(radii);
+    }
 }
 
@@ -1037 +1068 @@
     return elementCmap;
 }
+
+int Molecule::computeBonds(vtkDataSet *dataSet, float tolerance)
+{
+    vtkPolyData *pd = vtkPolyData::SafeDownCast(dataSet);
+    if (pd == NULL) {
+        ERROR("DataSet not a PolyData");
+        return -1;
+    }
+
+    if (pd->GetNumberOfPoints() < 2 ||
+        pd->GetNumberOfLines() > 0) {
+        return 0;
+    }
+
+    vtkDataArray *elements = NULL;
+    if (pd->GetPointData() != NULL &&
+        pd->GetPointData()->GetScalars() != NULL &&
+        strcmp(pd->GetPointData()->GetScalars()->GetName(), "element") == 0) {
+        elements = pd->GetPointData()->GetScalars();
+    } else {
+        TRACE("Can't compute bonds without an element array");
+        return -1;
+    }
+    int numAtoms = pd->GetNumberOfPoints();
+    vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
+    for (int i = 0; i < numAtoms; i++) {
+        double pt1[3];
+        int elem1 = (int)elements->GetComponent(i, 0);
+        float r1 = g_covalentRadii[elem1];
+        pd->GetPoint(i, pt1);
+        for (int j = i+1; j < numAtoms; j++) {
+            float r2, dist;
+            double pt2[3];
+            int elem2 = (int)elements->GetComponent(j, 0);
+
+            if (elem1 == 1 && elem2 == 1)
+                continue;
+
+            r2 = g_covalentRadii[elem2];
+            pd->GetPoint(j, pt2);
+
+            double x = pt1[0] - pt2[0];
+            double y = pt1[1] - pt2[1];
+            double z = pt1[2] - pt2[2];
+            dist = (float)sqrt(x*x + y*y + z*z);
+            //TRACE("i=%d,j=%d elem1=%d,elem2=%d r1=%g,r2=%g, dist=%g", i, j, elem1, elem2, r1, r2, dist); 
+            if (dist < (r1 + r2 + tolerance)) {
+                vtkIdType pts[2];
+                pts[0] = i;
+                pts[1] = j;
+                cells->InsertNextCell(2, pts);
+            }
+        }
+    }
+
+    if (cells->GetNumberOfCells() > 0) {
+        pd->SetLines(cells);
+    }
+
+    TRACE("Generated %d bonds", cells->GetNumberOfCells());
+    return cells->GetNumberOfCells();
+}

branches/1.3/packages/vizservers/vtkvis/Molecule.h

@@ -22 +22 @@
 #include <vtkPointSetToLabelHierarchy.h>
 #include <vtkLabelPlacementMapper.h>
+#include <vtkTransform.h>
 
 #include "ColorMap.h"
@@ -78 +79 @@
     }
 
+    virtual void setTransform(vtkMatrix4x4 *matrix)
+    {
+        GraphicsObject::setTransform(matrix);
+        updateLabelTransform();
+    }
+
+    virtual void setOrigin(double origin[3])
+    {
+        GraphicsObject::setOrigin(origin);
+        updateLabelTransform();
+    }
+
+    virtual void setOrientation(double quat[4])
+    {
+        GraphicsObject::setOrientation(quat);
+        updateLabelTransform();
+    }
+
+    virtual void setOrientation(double angle, double axis[3])
+    {
+        GraphicsObject::setOrientation(angle, axis);
+        updateLabelTransform();
+    }
+
+    virtual void setPosition(double pos[3])
+    {
+        GraphicsObject::setPosition(pos);
+        updateLabelTransform();
+    }
+
+    virtual void setAspect(double aspect)
+    {
+        GraphicsObject::setAspect(aspect);
+        updateLabelTransform();
+    }
+
+    virtual void setScale(double scale[3])
+    {
+        GraphicsObject::setScale(scale);
+        updateLabelTransform();
+    }
+
     virtual void setDataSet(DataSet *dataSet,
                             Renderer *renderer);
@@ -141 +184 @@
     void setupBondPolyData();
 
+    void updateLabelTransform();
+
     static void addLabelArray(vtkDataSet *dataSet);
 
     static void addRadiusArray(vtkDataSet *dataSet, AtomScaling scaling, double scaleFactor);
+
+    static int computeBonds(vtkDataSet *dataSet, float tolerance = 0.45f);
 
     float _bondColor[3];
@@ -171 +218 @@
     vtkSmartPointer<vtkPointSetToLabelHierarchy> _labelHierarchy;
     vtkSmartPointer<vtkLabelPlacementMapper> _labelMapper;
+    vtkSmartPointer<vtkTransform> _labelTransform;
 };
 

branches/1.3/packages/vizservers/vtkvis/PolyData.cpp

@@ -10 +10 @@
 #include <vtkDataSet.h>
 #include <vtkPolyData.h>
+#include <vtkPolyDataNormals.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkPolyDataMapper.h>
@@ -19 +22 @@
 #include <vtkDataSetSurfaceFilter.h>
 #include <vtkVertexGlyphFilter.h>
+#include <vtkLookupTable.h>
 
 #include "PolyData.h"
+#include "Renderer.h"
 #include "Trace.h"
 
@@ -27 +32 @@
 PolyData::PolyData() :
     GraphicsObject(),
+    _colorMap(NULL),
+    _colorMode(COLOR_CONSTANT),
+    _colorFieldType(DataSet::POINT_DATA),
+    _renderer(NULL),
     _cloudStyle(CLOUD_MESH)
 {
+    _colorFieldRange[0] = DBL_MAX;
+    _colorFieldRange[1] = -DBL_MAX;
 }
 
@@ -41 +52 @@
 }
 
+void PolyData::setDataSet(DataSet *dataSet,
+                          Renderer *renderer)
+{
+    if (_dataSet != dataSet) {
+        _dataSet = dataSet;
+
+        _renderer = renderer;
+
+        if (renderer->getUseCumulativeRange()) {
+            renderer->getCumulativeDataRange(_dataRange,
+                                             _dataSet->getActiveScalarsName(),
+                                             1);
+            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                             _dataSet->getActiveVectorsName(),
+                                             3);
+            for (int i = 0; i < 3; i++) {
+                renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                                 _dataSet->getActiveVectorsName(),
+                                                 3, i);
+            }
+        } else {
+            _dataSet->getScalarRange(_dataRange);
+            _dataSet->getVectorRange(_vectorMagnitudeRange);
+            for (int i = 0; i < 3; i++) {
+                _dataSet->getVectorRange(_vectorComponentRange[i], i);
+            }
+        }
+
+        update();
+    }
+}
+
 /**
  * \brief Internal method to set up pipeline after a state change
@@ -50 +93 @@
     }
 
-    if (_pdMapper == NULL) {
-        _pdMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-        _pdMapper->SetResolveCoincidentTopologyToPolygonOffset();
-        _pdMapper->ScalarVisibilityOff();
-    }
-
     vtkDataSet *ds = _dataSet->getVtkDataSet();
+
+    if (_mapper == NULL) {
+        _mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+        _mapper->SetResolveCoincidentTopologyToPolygonOffset();
+        // If there are color scalars, use them without lookup table (if scalar visibility is on)
+        _mapper->SetColorModeToDefault();
+        // Use Point data if available, else cell data
+        _mapper->SetScalarModeToDefault();
+        _mapper->ScalarVisibilityOff();
+    }
+
     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
     if (pd) {
@@ -66 +114 @@
               pd->GetNumberOfStrips());
     }
+    bool hasNormals = false;
+    if ((ds->GetPointData() != NULL &&
+         ds->GetPointData()->GetNormals() != NULL) ||
+        (ds->GetCellData() != NULL &&
+         ds->GetCellData()->GetNormals() != NULL)) {
+        hasNormals = true;
+    }
+
     if (_dataSet->isCloud()) {
         // DataSet is a point cloud
@@ -78 +134 @@
             vgf->SetInput(ds);
 #endif
-            _pdMapper->SetInputConnection(vgf->GetOutputPort());
+            _mapper->SetInputConnection(vgf->GetOutputPort());
         } else if (_dataSet->is2D(&plane, &offset)) {
             vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
@@ -122 +178 @@
                 vgf->SetInput(ds);
 #endif
-                _pdMapper->SetInputConnection(vgf->GetOutputPort());
+                _mapper->SetInputConnection(vgf->GetOutputPort());
             } else {
-                _pdMapper->SetInputConnection(mesher->GetOutputPort());
+                vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+                normalFilter->SetInputConnection(mesher->GetOutputPort());
+                _mapper->SetInputConnection(normalFilter->GetOutputPort());
             }
         } else {
@@ -146 +204 @@
                 vgf->SetInput(ds);
 #endif
-                _pdMapper->SetInputConnection(vgf->GetOutputPort());
+                _mapper->SetInputConnection(vgf->GetOutputPort());
             } else {
                 // Delaunay3D returns an UnstructuredGrid, so feed it 
@@ -153 +211 @@
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
                 gf->UseStripsOn();
+                gf->ReleaseDataFlagOn();
                 gf->SetInputConnection(mesher->GetOutputPort());
-                gf->ReleaseDataFlagOn();
-                _pdMapper->SetInputConnection(gf->GetOutputPort());
+                vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+                normalFilter->SetInputConnection(gf->GetOutputPort());
+                _mapper->SetInputConnection(normalFilter->GetOutputPort());
             }
         }
     } else if (pd) {
         // DataSet is a vtkPolyData with cells
-#ifdef USE_VTK6
-        _pdMapper->SetInputData(pd);
-#else
-        _pdMapper->SetInput(pd);
-#endif
+        if (hasNormals) {
+#ifdef USE_VTK6
+            _mapper->SetInputData(pd);
+#else
+            _mapper->SetInput(pd);
+#endif
+        } else {
+            vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+#ifdef USE_VTK6
+            normalFilter->SetInputData(pd);
+#else
+            normalFilter->SetInput(pd);
+#endif
+            _mapper->SetInputConnection(normalFilter->GetOutputPort());
+        }
     } else {
         // DataSet is NOT a vtkPolyData
@@ -170 +240 @@
         vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
         gf->UseStripsOn();
+        gf->ReleaseDataFlagOn();
 #ifdef USE_VTK6
         gf->SetInputData(ds);
@@ -175 +246 @@
         gf->SetInput(ds);
 #endif
-        gf->ReleaseDataFlagOn();
-        _pdMapper->SetInputConnection(gf->GetOutputPort());
+        vtkSmartPointer<vtkPolyDataNormals> normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
+        normalFilter->SetInputConnection(gf->GetOutputPort());
+        _mapper->SetInputConnection(normalFilter->GetOutputPort());
+    }
+
+    setInterpolateBeforeMapping(true);
+
+    if (_lut == NULL) {
+        setColorMap(ColorMap::getDefault());
+        if (_dataSet->getActiveScalarsName() != NULL) {
+            int numComp;
+            _dataSet->getFieldInfo(_dataSet->getActiveScalarsName(),
+                                   _dataSet->getActiveScalarsType(),
+                                   &numComp);
+            // If DataSet is a PolyData with a scalar field, or has color scalars
+            if (pd != NULL || numComp > 1) {
+                if (numComp > 1) {
+                    // If we have color scalars, use triangle interpolation
+                    setInterpolateBeforeMapping(false);
+                }
+                setColorMode(COLOR_BY_SCALAR);
+            } else {
+                setColorMode(_colorMode);
+            }
+        } else {
+            setColorMode(_colorMode);
+        }
+    } else {
+        double *rangePtr = _colorFieldRange;
+        if (_colorFieldRange[0] > _colorFieldRange[1]) {
+            rangePtr = NULL;
+        }
+        setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
     }
 
     initProp();
-    getActor()->SetMapper(_pdMapper);
-    _pdMapper->Update();
+    getActor()->SetMapper(_mapper);
+    _mapper->Update();
 #ifdef WANT_TRACE
     double *b = getBounds();
     TRACE("bounds: %g %g %g %g %g %g", b[0], b[1], b[2], b[3], b[4], b[5]);
 #endif
+}
+
+void PolyData::setInterpolateBeforeMapping(bool state)
+{
+    if (_mapper != NULL) {
+        _mapper->SetInterpolateScalarsBeforeMapping((state ? 1 : 0));
+    }
+}
+
+void PolyData::updateRanges(Renderer *renderer)
+{
+    if (_dataSet == NULL) {
+        ERROR("called before setDataSet");
+        return;
+    }
+
+    if (renderer->getUseCumulativeRange()) {
+        renderer->getCumulativeDataRange(_dataRange,
+                                         _dataSet->getActiveScalarsName(),
+                                         1);
+        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                         _dataSet->getActiveVectorsName(),
+                                         3);
+        for (int i = 0; i < 3; i++) {
+            renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                             _dataSet->getActiveVectorsName(),
+                                             3, i);
+        }
+    } else {
+        _dataSet->getScalarRange(_dataRange);
+        _dataSet->getVectorRange(_vectorMagnitudeRange);
+        for (int i = 0; i < 3; i++) {
+            _dataSet->getVectorRange(_vectorComponentRange[i], i);
+        }
+    }
+
+    // Need to update color map ranges
+    double *rangePtr = _colorFieldRange;
+    if (_colorFieldRange[0] > _colorFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
+}
+
+void PolyData::setColorMode(ColorMode mode)
+{
+    _colorMode = mode;
+    if (_dataSet == NULL)
+        return;
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        setColorMode(mode,
+                     _dataSet->getActiveScalarsType(),
+                     _dataSet->getActiveScalarsName(),
+                     _dataRange);
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorMagnitudeRange);
+        break;
+    case COLOR_BY_VECTOR_X:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[0]);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[1]);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[2]);
+        break;
+    case COLOR_CONSTANT:
+    default:
+        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
+        break;
+    }
+}
+
+void PolyData::setColorMode(ColorMode mode,
+                            const char *name, double range[2])
+{
+    if (_dataSet == NULL)
+        return;
+    DataSet::DataAttributeType type = DataSet::POINT_DATA;
+    int numComponents = 1;
+    if (name != NULL && strlen(name) > 0 &&
+        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
+        ERROR("Field not found: %s", name);
+        return;
+    }
+    setColorMode(mode, type, name, range);
+}
+
+void PolyData::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                            const char *name, double range[2])
+{
+    _colorMode = mode;
+    _colorFieldType = type;
+    if (name == NULL)
+        _colorFieldName.clear();
+    else
+        _colorFieldName = name;
+    if (range == NULL) {
+        _colorFieldRange[0] = DBL_MAX;
+        _colorFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_colorFieldRange, range, sizeof(double)*2);
+    }
+
+    if (_dataSet == NULL || _mapper == NULL)
+        return;
+
+    switch (type) {
+    case DataSet::POINT_DATA:
+        _mapper->SetScalarModeToUsePointFieldData();
+        break;
+    case DataSet::CELL_DATA:
+        _mapper->SetScalarModeToUseCellFieldData();
+        break;
+    case DataSet::FIELD_DATA:
+        _mapper->SetScalarModeToUseFieldData();
+        break;
+    default:
+        ERROR("Unsupported DataAttributeType: %d", type);
+        return;
+    }
+
+    if (name != NULL && strlen(name) > 0) {
+        _mapper->SelectColorArray(name);
+    } else {
+        _mapper->SetScalarModeToDefault();
+    }
+
+    if (_lut != NULL) {
+        if (range != NULL) {
+            _lut->SetRange(range);
+        } else if (name != NULL && strlen(name) > 0) {
+            double r[2];
+            int comp = -1;
+            if (mode == COLOR_BY_VECTOR_X)
+                comp = 0;
+            else if (mode == COLOR_BY_VECTOR_Y)
+                comp = 1;
+            else if (mode == COLOR_BY_VECTOR_Z)
+                comp = 2;
+
+            if (_renderer->getUseCumulativeRange()) {
+                int numComponents;
+                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                    ERROR("Field not found: %s, type: %d", name, type);
+                    return;
+                } else if (numComponents < comp+1) {
+                    ERROR("Request for component %d in field with %d components",
+                          comp, numComponents);
+                    return;
+                }
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+            _lut->SetRange(r);
+        }
+    }
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        _mapper->ScalarVisibilityOn();
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        _mapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToMagnitude();
+        }
+        break;
+    case COLOR_BY_VECTOR_X:
+        _mapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(0);
+        }
+        break;
+    case COLOR_BY_VECTOR_Y:
+        _mapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(1);
+        }
+        break;
+    case COLOR_BY_VECTOR_Z:
+        _mapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(2);
+        }
+        break;
+    case COLOR_CONSTANT:
+    default:
+        _mapper->ScalarVisibilityOff();
+        break;
+    }
+}
+
+/**
+ * \brief Called when the color map has been edited
+ */
+void PolyData::updateColorMap()
+{
+    setColorMap(_colorMap);
+}
+
+/**
+ * \brief Associate a colormap lookup table with the DataSet
+ */
+void PolyData::setColorMap(ColorMap *cmap)
+{
+    if (cmap == NULL)
+        return;
+
+    _colorMap = cmap;
+ 
+    if (_lut == NULL) {
+        _lut = vtkSmartPointer<vtkLookupTable>::New();
+        if (_mapper != NULL) {
+            _mapper->UseLookupTableScalarRangeOn();
+            _mapper->SetLookupTable(_lut);
+        }
+        _lut->DeepCopy(cmap->getLookupTable());
+        switch (_colorMode) {
+        case COLOR_CONSTANT:
+        case COLOR_BY_SCALAR:
+            _lut->SetRange(_dataRange);
+            break;
+        case COLOR_BY_VECTOR_MAGNITUDE:
+            _lut->SetRange(_vectorMagnitudeRange);
+            break;
+        case COLOR_BY_VECTOR_X:
+            _lut->SetRange(_vectorComponentRange[0]);
+            break;
+        case COLOR_BY_VECTOR_Y:
+            _lut->SetRange(_vectorComponentRange[1]);
+            break;
+        case COLOR_BY_VECTOR_Z:
+            _lut->SetRange(_vectorComponentRange[2]);
+            break;
+        default:
+            break;
+        }
+    } else {
+        double range[2];
+        _lut->GetTableRange(range);
+        _lut->DeepCopy(cmap->getLookupTable());
+        _lut->SetRange(range);
+        _lut->Modified();
+    }
+
+    switch (_colorMode) {
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        _lut->SetVectorModeToMagnitude();
+        break;
+    case COLOR_BY_VECTOR_X:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(0);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(1);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(2);
+        break;
+    default:
+         break;
+    }
 }
 
@@ -195 +581 @@
 void PolyData::setClippingPlanes(vtkPlaneCollection *planes)
 {
-    if (_pdMapper != NULL) {
-        _pdMapper->SetClippingPlanes(planes);
+    if (_mapper != NULL) {
+        _mapper->SetClippingPlanes(planes);
     }
 }

branches/1.3/packages/vizservers/vtkvis/PolyData.h

@@ -12 +12 @@
 #include <vtkPolyDataMapper.h>
 #include <vtkActor.h>
+#include <vtkLookupTable.h>
 
+#include "ColorMap.h"
 #include "GraphicsObject.h"
-#include "DataSet.h"
 
 namespace VtkVis {
@@ -29 +30 @@
         CLOUD_POINTS
     };
+    enum ColorMode {
+        COLOR_BY_SCALAR,
+        COLOR_BY_VECTOR_MAGNITUDE,
+        COLOR_BY_VECTOR_X,
+        COLOR_BY_VECTOR_Y,
+        COLOR_BY_VECTOR_Z,
+        COLOR_CONSTANT
+    };
 
     PolyData();
@@ -38 +47 @@
     }
 
+    virtual void setDataSet(DataSet *dataSet,
+                            Renderer *renderer);
+
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
 
     void setCloudStyle(CloudStyle style);
 
+    void setInterpolateBeforeMapping(bool state);
+
+    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                      const char *name, double range[2] = NULL);
+
+    void setColorMode(ColorMode mode,
+                      const char *name, double range[2] = NULL);
+
+    void setColorMode(ColorMode mode);
+
+    void setColorMap(ColorMap *colorMap);
+
+    /**
+     * \brief Return the ColorMap in use
+     */
+    ColorMap *getColorMap()
+    {
+        return _colorMap;
+    }
+
+    void updateColorMap();
+
+    virtual void updateRanges(Renderer *renderer);
+
 private:
     virtual void update();
 
+    ColorMap *_colorMap;
+    ColorMode _colorMode;
+    std::string _colorFieldName;
+    DataSet::DataAttributeType _colorFieldType;
+    double _colorFieldRange[2];
+    double _vectorMagnitudeRange[2];
+    double _vectorComponentRange[3][2];
+    Renderer *_renderer;
+
     CloudStyle _cloudStyle;
-    vtkSmartPointer<vtkPolyDataMapper> _pdMapper;
+    vtkSmartPointer<vtkLookupTable> _lut;
+    vtkSmartPointer<vtkPolyDataMapper> _mapper;
 };
 

branches/1.3/packages/vizservers/vtkvis/PseudoColor.cpp

@@ -99 +99 @@
     if (_mapper == NULL) {
         _mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+        _mapper->SetResolveCoincidentTopologyToPolygonOffset();
         // Map scalars through lookup table regardless of type
         _mapper->SetColorModeToMapScalars();
@@ -106 +107 @@
     if (_dataSet->isCloud()) {
         // DataSet is a point cloud
-        if (_cloudStyle == CLOUD_POINTS) {
+        if (_cloudStyle == CLOUD_POINTS ||
+            _dataSet->numDimensions() < 2 || ds->GetNumberOfPoints() < 3) {
             vtkSmartPointer<vtkVertexGlyphFilter> vgf = vtkSmartPointer<vtkVertexGlyphFilter>::New();
 #ifdef USE_VTK6
@@ -385 +387 @@
         _mapper->SetScalarModeToUseCellFieldData();
         break;
+    case DataSet::FIELD_DATA:
+        _mapper->SetScalarModeToUseFieldData();
+        break;
     default:
         ERROR("Unsupported DataAttributeType: %d", type);
@@ -392 +397 @@
     if (_splatter != NULL) {
         if (name != NULL && strlen(name) > 0) {
-            _splatter->SetInputArrayToProcess(0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_POINTS, name);
+            _splatter->SetInputArrayToProcess(0, 0, 0, type, name);
         }
         _mapper->SelectColorArray("SplatterValues");

branches/1.3/packages/vizservers/vtkvis/RenderServer.cpp

@@ -22 +22 @@
 
 #include <tcl.h>
+
+#include <vtksys/SystemInformation.hxx>
 
 #include "Trace.h"
@@ -494 +496 @@
     TRACE("Starting VTKVis Server");
 
+#ifdef WANT_TRACE
+    vtksys::SystemInformation::SetStackTraceOnError(1);
+#endif
+
     /* This synchronizes the client with the server, so that the client 
      * doesn't start writing commands before the server is ready. It could

branches/1.3/packages/vizservers/vtkvis/RenderServer.h

@@ -16 +16 @@
 class Renderer;
 
-#define VTKVIS_VERSION_STRING "1.4"
+#define VTKVIS_VERSION_STRING "1.5"
 
 #define MSECS_ELAPSED(t1, t2) \

branches/1.3/packages/vizservers/vtkvis/Renderer.cpp

@@ -17 +17 @@
 #endif
 
+#ifdef USE_FONT_CONFIG
+#include <vtkFreeTypeTools.h>
+#endif
 #include <vtkMath.h>
 #include <vtkCamera.h>
@@ -42 +45 @@
 #include "ColorMap.h"
 #include "Trace.h"
-
-#define NEW_SCALAR_BAR
 
 #define MSECS_ELAPSED(t1, t2) \
@@ -120 +121 @@
     if (_cameraMode == IMAGE)
         _activeClipPlanes->AddItem(_cameraClipPlanes[3]);
+
+#ifdef USE_FONT_CONFIG
+    vtkFreeTypeTools *typeTools = vtkFreeTypeTools::GetInstance();
+    typeTools->ForceCompiledFontsOff();
+    TRACE("FreeTypeTools impl: %s", typeTools->GetClassName());
+#endif
+
     _renderer = vtkSmartPointer<vtkRenderer>::New();
 
@@ -184 +192 @@
     deleteAllGraphicsObjects<Group>();
     deleteAllGraphicsObjects<HeightMap>();
+    deleteAllGraphicsObjects<Image>();
     deleteAllGraphicsObjects<LIC>();
     deleteAllGraphicsObjects<Line>();
@@ -193 +202 @@
     deleteAllGraphicsObjects<Sphere>();
     deleteAllGraphicsObjects<Streamlines>();
+    deleteAllGraphicsObjects<Text3D>();
     deleteAllGraphicsObjects<Volume>();
     deleteAllGraphicsObjects<Warp>();
@@ -264 +274 @@
         deleteGraphicsObject<Glyphs>(itr->second->getName());
         deleteGraphicsObject<HeightMap>(itr->second->getName());
+        deleteGraphicsObject<Image>(itr->second->getName());
         deleteGraphicsObject<LIC>(itr->second->getName());
         deleteGraphicsObject<Molecule>(itr->second->getName());
@@ -1555 +1566 @@
     updateGraphicsObjectColorMap<Glyphs>(cmap);
     updateGraphicsObjectColorMap<HeightMap>(cmap);
+    updateGraphicsObjectColorMap<Image>(cmap);
     updateGraphicsObjectColorMap<LIC>(cmap);
     updateGraphicsObjectColorMap<Molecule>(cmap);
+    updateGraphicsObjectColorMap<PolyData>(cmap);
     updateGraphicsObjectColorMap<PseudoColor>(cmap);
     updateGraphicsObjectColorMap<Streamlines>(cmap);
@@ -1579 +1592 @@
     if (graphicsObjectColorMapUsed<HeightMap>(cmap))
         return true;
+    if (graphicsObjectColorMapUsed<Image>(cmap))
+        return true;
     if (graphicsObjectColorMapUsed<LIC>(cmap))
         return true;
     if (graphicsObjectColorMapUsed<Molecule>(cmap))
+        return true;
+    if (graphicsObjectColorMapUsed<PolyData>(cmap))
         return true;
     if (graphicsObjectColorMapUsed<PseudoColor>(cmap))
@@ -1931 +1948 @@
 #ifdef NEW_SCALAR_BAR
         _scalarBarActor->SetBarRatio(1);
+        _scalarBarActor->SetTitleRatio(0);
 #endif
         if (width > height) {
@@ -1958 +1976 @@
 #ifdef NEW_SCALAR_BAR
         _scalarBarActor->SetBarRatio(0.375);
+        _scalarBarActor->SetTitleRatio(0.5);
         _scalarBarActor->SetDisplayPosition(0, 0);
         _scalarBarActor->GetPosition2Coordinate()->SetCoordinateSystemToDisplay();
@@ -2125 +2144 @@
     _scalarBarActor->GetLabelTextProperty()->ShadowOff();
 #ifdef NEW_SCALAR_BAR
-    if (title.empty() && numLabels == 0) {
+    if (!drawTitle && numLabels == 0) {
         _scalarBarActor->DrawAnnotationsOff();
         _scalarBarActor->SetAnnotationLeaderPadding(0);
@@ -2137 +2156 @@
 
     _legendRenderWindow->Render();
+    int *sz = _legendRenderWindow->GetSize();
+    if (sz[0] != width || sz[1] != height) {
+        ERROR("Window size: %dx%d, but expected %dx%d", sz[0], sz[1], width, height);
+    }
+
+#ifdef RENDER_TARGA
+    _legendRenderWindow->MakeCurrent();
+    // Must clear previous errors first.
+    while (glGetError() != GL_NO_ERROR){
+        ;
+    }
+    int bytesPerPixel = TARGA_BYTES_PER_PIXEL;
+    int size = bytesPerPixel * width * height;
+
+    if (imgData->GetMaxId() + 1 != size)
+    {
+        imgData->SetNumberOfComponents(bytesPerPixel);
+        imgData->SetNumberOfValues(size);
+    }
+    glDisable(GL_TEXTURE_2D);
+    if (_legendRenderWindow->GetDoubleBuffer()) {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetBackLeftBuffer()));
+    } else {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetFrontLeftBuffer()));
+    }
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+    if (bytesPerPixel == 4) {
+        glReadPixels(0, 0, width, height, GL_BGRA,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    } else {
+        glReadPixels(0, 0, width, height, GL_BGR,
+                     GL_UNSIGNED_BYTE, imgData->GetPointer(0));
+    }
+    if (glGetError() != GL_NO_ERROR) {
+        ERROR("glReadPixels");
+    }
+#else
+    _legendRenderWindow->GetPixelData(0, 0, width-1, height-1,
+                                      !_legendRenderWindow->GetDoubleBuffer(),
+                                      imgData);
+#endif
+    TRACE("Leave");
+    return true;
+}
+
+bool Renderer::renderColorMap(const ColorMapId& id,
+                              int width, int height,
+                              bool opaque,
+                              vtkUnsignedCharArray *imgData)
+{
+    TRACE("Enter");
+    ColorMap *colorMap = getColorMap(id);
+    if (colorMap == NULL)
+        return false;
+
+    if (_legendRenderWindow == NULL) {
+        _legendRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+        _legendRenderWindow->SetMultiSamples(0);
+#ifdef USE_OFFSCREEN_RENDERING
+        _legendRenderWindow->DoubleBufferOff();
+        _legendRenderWindow->OffScreenRenderingOn();
+#else
+        _legendRenderWindow->DoubleBufferOn();
+        _legendRenderWindow->SwapBuffersOff();
+#endif
+    }
+
+    _legendRenderWindow->SetSize(width, height);
+
+    if (_legendRenderer == NULL) {
+        _legendRenderer = vtkSmartPointer<vtkRenderer>::New();
+        _legendRenderWindow->AddRenderer(_legendRenderer);
+    }
+    _legendRenderer->SetBackground(_bgColor[0], _bgColor[1], _bgColor[2]);
+
+    if (_scalarBarActor == NULL) {
+        _scalarBarActor = vtkSmartPointer<vtkScalarBarActor>::New();
+        _scalarBarActor->DrawFrameOff();
+        _scalarBarActor->DrawBackgroundOff();
+        _scalarBarActor->DrawColorBarOn();
+        _legendRenderer->AddViewProp(_scalarBarActor);
+    }
+
+    if (opaque) {
+        _scalarBarActor->UseOpacityOff();
+    } else {
+        _scalarBarActor->UseOpacityOn();
+    }
+
+    if (width > height) {
+        _scalarBarActor->SetOrientationToHorizontal();
+    } else {
+        _scalarBarActor->SetOrientationToVertical();
+    }
+
+    // Set viewport-relative width/height/pos
+#ifdef NEW_SCALAR_BAR
+    _scalarBarActor->SetBarRatio(1);
+    _scalarBarActor->SetTitleRatio(0);
+#endif
+    if (width > height) {
+        // horizontal
+#ifdef NEW_SCALAR_BAR
+        _scalarBarActor->SetDisplayPosition(0, 0);
+        _scalarBarActor->GetPosition2Coordinate()->SetCoordinateSystemToDisplay();
+        _scalarBarActor->GetPosition2Coordinate()->SetValue(width+4, height);
+#else
+        _scalarBarActor->SetPosition(0, 0);
+        _scalarBarActor->SetHeight((((double)height+1.5)/((double)height))/0.4); // VTK: floor(actorHeight * .4)
+        _scalarBarActor->SetWidth(1); // VTK: actorWidth
+#endif
+    } else {
+        // vertical
+#ifdef NEW_SCALAR_BAR
+        _scalarBarActor->SetDisplayPosition(0, -4);
+        _scalarBarActor->GetPosition2Coordinate()->SetCoordinateSystemToDisplay();
+        _scalarBarActor->GetPosition2Coordinate()->SetValue(width+1, height+5);
+#else
+        _scalarBarActor->SetPosition(0, 0);
+        _scalarBarActor->SetHeight((((double)height+1.5)/((double)height))/0.86); // VTK: floor(actorHeight * .86)
+        _scalarBarActor->SetWidth(((double)(width+5))/((double)width)); // VTK: actorWidth - 4 pixels
+#endif
+    }
+
+    vtkSmartPointer<vtkLookupTable> lut = colorMap->getLookupTable();
+
+    double range[2];
+    range[0] = 0.0;
+    range[1] = 1.0;
+
+    lut->SetRange(range);
+
+    _scalarBarActor->SetLookupTable(lut);
+    _scalarBarActor->SetMaximumNumberOfColors((width > height ? width : height));
+    _scalarBarActor->SetTitle("");
+    _scalarBarActor->SetNumberOfLabels(0);
+#ifdef NEW_SCALAR_BAR
+    _scalarBarActor->DrawAnnotationsOff();
+    _scalarBarActor->SetAnnotationLeaderPadding(0);
+    _scalarBarActor->SetTextPad(0);
+#endif
+
+    _legendRenderWindow->Render();
+    int *sz = _legendRenderWindow->GetSize();
+    if (sz[0] != width || sz[1] != height) {
+        ERROR("Window size: %dx%d, but expected %dx%d", sz[0], sz[1], width, height);
+    }
 
 #ifdef RENDER_TARGA
@@ -2265 +2431 @@
     setGraphicsObjectAspect<Glyphs>(aspectRatio);
     setGraphicsObjectAspect<HeightMap>(aspectRatio);
+    setGraphicsObjectAspect<Image>(aspectRatio);
     setGraphicsObjectAspect<LIC>(aspectRatio);
     setGraphicsObjectAspect<Line>(aspectRatio);
@@ -2274 +2441 @@
     setGraphicsObjectAspect<Sphere>(aspectRatio);
     setGraphicsObjectAspect<Streamlines>(aspectRatio);
+    setGraphicsObjectAspect<Text3D>(aspectRatio);
     setGraphicsObjectAspect<Volume>(aspectRatio);
     setGraphicsObjectAspect<Warp>(aspectRatio);
@@ -3184 +3352 @@
     mergeGraphicsObjectBounds<Group>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<HeightMap>(bounds, onlyVisible);
+    mergeGraphicsObjectBounds<Image>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<LIC>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Line>(bounds, onlyVisible);
@@ -3193 +3362 @@
     mergeGraphicsObjectBounds<Sphere>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Streamlines>(bounds, onlyVisible);
+    mergeGraphicsObjectBounds<Text3D>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Volume>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Warp>(bounds, onlyVisible);
@@ -3253 +3423 @@
     mergeGraphicsObjectUnscaledBounds<Glyphs>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<HeightMap>(bounds, onlyVisible);
+    mergeGraphicsObjectUnscaledBounds<Image>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<LIC>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<Line>(bounds, onlyVisible);
@@ -3262 +3433 @@
     mergeGraphicsObjectUnscaledBounds<Sphere>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<Streamlines>(bounds, onlyVisible);
+    mergeGraphicsObjectUnscaledBounds<Text3D>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<Volume>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<Warp>(bounds, onlyVisible);
@@ -3308 +3480 @@
     updateGraphicsObjectFieldRanges<Glyphs>();
     updateGraphicsObjectFieldRanges<HeightMap>();
+    updateGraphicsObjectFieldRanges<Image>();
     updateGraphicsObjectFieldRanges<LIC>();
     updateGraphicsObjectFieldRanges<Molecule>();
+    updateGraphicsObjectFieldRanges<PolyData>();
     updateGraphicsObjectFieldRanges<PseudoColor>();
     updateGraphicsObjectFieldRanges<Streamlines>();
@@ -3368 +3542 @@
     }
     _scalarCellDataRange.clear();
+    for (FieldRangeHashmap::iterator itr = _scalarFieldDataRange.begin();
+         itr != _scalarFieldDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _scalarFieldDataRange.clear();
     for (FieldRangeHashmap::iterator itr = _vectorPointDataRange.begin();
          itr != _vectorPointDataRange.end(); ++itr) {
@@ -3392 +3571 @@
         _vectorCompCellDataRange[i].clear();
     }
+    for (FieldRangeHashmap::iterator itr = _vectorFieldDataRange.begin();
+         itr != _vectorFieldDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _vectorFieldDataRange.clear();
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompFieldDataRange[i].begin();
+             itr != _vectorCompFieldDataRange[i].end(); ++itr) {
+            delete [] itr->second;
+        }
+        _vectorCompFieldDataRange[i].clear();
+    }
 }
 
@@ -3410 +3601 @@
     }
     _userScalarCellDataRange.clear();
+    for (FieldRangeHashmap::iterator itr = _userScalarFieldDataRange.begin();
+         itr != _userScalarFieldDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _userScalarFieldDataRange.clear();
     for (FieldRangeHashmap::iterator itr = _userVectorPointDataRange.begin();
          itr != _userVectorPointDataRange.end(); ++itr) {
@@ -3433 +3629 @@
         }
         _userVectorCompCellDataRange[i].clear();
+    }
+    for (FieldRangeHashmap::iterator itr = _userVectorFieldDataRange.begin();
+         itr != _userVectorFieldDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _userVectorFieldDataRange.clear();
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _userVectorCompFieldDataRange[i].begin();
+             itr != _userVectorCompFieldDataRange[i].end(); ++itr) {
+            delete [] itr->second;
+        }
+        _userVectorCompFieldDataRange[i].clear();
     }
 }
@@ -3472 +3680 @@
                 _scalarCellDataRange[*itr][0] = 0;
                 _scalarCellDataRange[*itr][1] = 1;
+            }
+        }
+        names.clear();
+        ds->getFieldNames(names, DataSet::FIELD_DATA, 1);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _scalarFieldDataRange.find(*itr);
+            if (fritr == _scalarFieldDataRange.end()) {
+                _scalarFieldDataRange[*itr] = new double[2];
+                _scalarFieldDataRange[*itr][0] = 0;
+                _scalarFieldDataRange[*itr][1] = 1;
             }
         }
@@ -3511 +3731 @@
                     _vectorCompCellDataRange[i][*itr][0] = 0;
                     _vectorCompCellDataRange[i][*itr][1] = 1;
+                }
+            }
+        }
+        names.clear();
+        ds->getFieldNames(names, DataSet::FIELD_DATA, 3);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _vectorFieldDataRange.find(*itr);
+            if (fritr == _vectorFieldDataRange.end()) {
+                _vectorFieldDataRange[*itr] = new double[2];
+                _vectorFieldDataRange[*itr][0] = 0;
+                _vectorFieldDataRange[*itr][1] = 1;
+            }
+            for (int i = 0; i < 3; i++) {
+                fritr = _vectorCompFieldDataRange[i].find(*itr);
+                if (fritr == _vectorCompFieldDataRange[i].end()) {
+                    _vectorCompFieldDataRange[i][*itr] = new double[2];
+                    _vectorCompFieldDataRange[i][*itr][0] = 0;
+                    _vectorCompFieldDataRange[i][*itr][1] = 1;
                 }
             }
@@ -3610 +3850 @@
     }
         break;
+    case DataSet::FIELD_DATA: {
+        FieldRangeHashmap::iterator itr;
+        if (numComponents == 1) {
+            itr = _userScalarFieldDataRange.find(name);
+            if (itr == _userScalarFieldDataRange.end()) {
+                _userScalarFieldDataRange[name] = new double[2];
+                memcpy(_userScalarFieldDataRange[name], range, sizeof(double)*2);
+            } else {
+                found = true;
+                memcpy(itr->second, range, sizeof(double)*2);
+            }
+        } else if (numComponents == 3) {
+            if (component == -1) {
+                itr = _userVectorFieldDataRange.find(name);
+                if (itr == _userVectorFieldDataRange.end()) {
+                    _userVectorFieldDataRange[name] = new double[2];
+                    memcpy(_userVectorFieldDataRange[name], range, sizeof(double)*2);
+                } else {
+                    found = true;
+                    memcpy(itr->second, range, sizeof(double)*2);
+                }
+            } else if (component >= 0 && component <= 3) {
+                itr = _userVectorCompFieldDataRange[component].find(name);
+                if (itr == _userVectorCompFieldDataRange[component].end()) {
+                    _userVectorCompFieldDataRange[component][name] = new double[2];
+                    memcpy(_userVectorCompFieldDataRange[component][name], range, sizeof(double)*2);
+                } else {
+                    found = true;
+                    memcpy(itr->second, range, sizeof(double)*2);
+                }
+            }
+        }
+    }
+        break;
     default:
         ERROR("Bad Field Type");
@@ -3626 +3900 @@
 /**
  * \brief Get the cumulative range across all DataSets for a point
- * data field if it exists, otherwise a cell data field if it exists
+ * data field if it exists, otherwise a cell data field if it exists,
+ * otherwise a field data field if it exists
  *
  * \param[out] range Pointer to an array of 2 doubles
@@ -3639 +3914 @@
 {
     bool ret;
-    if (!(ret = getCumulativeDataRange(range, name, DataSet::POINT_DATA,
-                                       numComponents, component)))
-        ret = getCumulativeDataRange(range, name, DataSet::CELL_DATA,
+    if ((ret = getCumulativeDataRange(range, name, DataSet::POINT_DATA,
+                                      numComponents, component))) {
+        ; // Found point data
+    } else if ((ret = getCumulativeDataRange(range, name, DataSet::CELL_DATA,
+                                             numComponents, component))) {
+        ; // Found cell data
+        
+    } else {
+        ret = getCumulativeDataRange(range, name, DataSet::FIELD_DATA,
                                      numComponents, component);
+    }
     return ret;
 }
@@ -3739 +4021 @@
     }
         break;
+    case DataSet::FIELD_DATA: {
+        FieldRangeHashmap::iterator itr;
+        if (numComponents == 1) {
+            itr = _userScalarFieldDataRange.find(name);
+            if (itr == _userScalarFieldDataRange.end()) {
+                itr = _scalarFieldDataRange.find(name);
+                if (itr == _scalarFieldDataRange.end()) {
+                    return false;
+                }
+            }
+            memcpy(range, itr->second, sizeof(double)*2);
+            return true;
+        } else if (numComponents == 3) {
+            if (component == -1) {
+                itr = _userVectorFieldDataRange.find(name);
+                if (itr == _userVectorFieldDataRange.end()) {
+                    itr = _vectorFieldDataRange.find(name);
+                    if (itr == _vectorFieldDataRange.end()) {
+                        return false;
+                    }
+                }
+                memcpy(range, itr->second, sizeof(double)*2);
+                return true;
+            } else if (component >= 0 && component <= 3) {
+                itr = _userVectorCompFieldDataRange[component].find(name);
+                if (itr == _userVectorCompFieldDataRange[component].end()) {
+                    itr = _vectorCompFieldDataRange[component].find(name);
+                    if (itr == _vectorCompFieldDataRange[component].end()) {
+                        return false;
+                    }
+                }
+                memcpy(range, itr->second, sizeof(double)*2);
+                return true;
+            }
+        }
+    }
+        break;
     default:
         break;
@@ -3757 +4076 @@
         collectDataRanges(itr->second, itr->first.c_str(),
                           DataSet::CELL_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (FieldRangeHashmap::iterator itr = _scalarFieldDataRange.begin();
+         itr != _scalarFieldDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::FIELD_DATA, -1,
                           _cumulativeRangeOnlyVisible);
     }
@@ -3784 +4109 @@
             collectDataRanges(itr->second, itr->first.c_str(),
                               DataSet::CELL_DATA, i,
+                              _cumulativeRangeOnlyVisible);
+        }
+    }
+    for (FieldRangeHashmap::iterator itr = _vectorFieldDataRange.begin();
+         itr != _vectorFieldDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::FIELD_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompFieldDataRange[i].begin();
+             itr != _vectorCompFieldDataRange[i].end(); ++itr) {
+            collectDataRanges(itr->second, itr->first.c_str(),
+                              DataSet::FIELD_DATA, i,
                               _cumulativeRangeOnlyVisible);
         }
@@ -4024 +4363 @@
     if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
         setGraphicsObjectOpacity<HeightMap>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Image>(id) != NULL)
+        setGraphicsObjectOpacity<Image>(id, opacity);
     if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
         setGraphicsObjectOpacity<LIC>(id, opacity);
@@ -4080 +4421 @@
     if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
         setGraphicsObjectVisibility<HeightMap>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Image>(id) != NULL)
+        setGraphicsObjectVisibility<Image>(id, state);
     if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
         setGraphicsObjectVisibility<LIC>(id, state);
@@ -4229 +4572 @@
     setGraphicsObjectClippingPlanes<Group>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<HeightMap>(_activeClipPlanes);
+    setGraphicsObjectClippingPlanes<Image>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<LIC>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Line>(_activeClipPlanes);
@@ -4238 +4582 @@
     setGraphicsObjectClippingPlanes<Sphere>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Streamlines>(_activeClipPlanes);
+    setGraphicsObjectClippingPlanes<Text3D>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Volume>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Warp>(_activeClipPlanes);
@@ -4293 +4638 @@
         setCameraClippingPlanes();
         _renderWindow->Render();
+        int *sz = _renderWindow->GetSize();
+        if (sz[0] != _windowWidth || sz[1] != _windowHeight) {
+            ERROR("Window size: %dx%d, but expected %dx%d", sz[0], sz[1], _windowWidth, _windowHeight);
+        }
         _needsRedraw = false;
         return true;

branches/1.3/packages/vizservers/vtkvis/Renderer.h

@@ -40 +40 @@
 #include "Group.h"
 #include "HeightMap.h"
+#include "Image.h"
 #include "LIC.h"
 #include "Line.h"
@@ -49 +50 @@
 #include "Sphere.h"
 #include "Streamlines.h"
+#include "Text3D.h"
 #include "Volume.h"
 #include "Warp.h"
@@ -420 +422 @@
 
     void setColorMapNumberOfTableEntries(const ColorMapId& id, int numEntries);
+
+    bool renderColorMap(const ColorMapId& id,
+                        int width, int height,
+                        bool opaque,
+                        vtkUnsignedCharArray *imgData);
 
     bool renderColorMap(const ColorMapId& id, 
@@ -699 +706 @@
     void setGlyphsScaleFactor(const DataSetId& id, double scale);
 
+    void setGlyphsMaximumNumberOfGlyphs(const DataSetId& id, int max,
+                                        bool random = true,
+                                        int offset = 0, int ratio = 1);
+
     // Groups
 
@@ -741 +752 @@
                                const char *name, double range[2] = NULL);
 
+    // Images
+
+    void setImageBackground(const DataSetId& id, bool state);
+
+    void setImageBacking(const DataSetId& id, bool state);
+
+    void setImageBorder(const DataSetId& id, bool state);
+
+    void setImageExtents(const DataSetId& id, int extents[6]);
+
+    void setImageLevel(const DataSetId& id, double level);
+
+    void setImageWindow(const DataSetId& id, double window);
+
+    void setImageZSlice(const DataSetId& id, int z);
 
     // Lines
@@ -792 +818 @@
                                PolyData::CloudStyle style);
 
+    void setPolyDataColorMode(const DataSetId& id,
+                              PolyData::ColorMode mode,
+                              const char *name, double range[2] = NULL);
+
+    void setPolyDataColorMode(const DataSetId& id,
+                              PolyData::ColorMode mode,
+                              DataSet::DataAttributeType type,
+                              const char *name, double range[2] = NULL);
+
     // Color-mapped surfaces
 
@@ -876 +911 @@
 
     void setStreamlinesTypeToRibbons(const DataSetId& id, double width, double angle);
+
+    // Text3Ds
+
+    bool addText3D(const DataSetId& id, const char *string,
+                   const char *fontFamily, int fontSize,
+                   bool bold = false, bool italic = false, bool shadow = false);
+
+    void setText3DBold(const DataSetId& id, bool state);
+
+    void setText3DFollowCamera(const DataSetId& id, bool state);
+
+    void setText3DFont(const DataSetId& id, const char *fontFamily);
+
+    void setText3DFontSize(const DataSetId& id, int size);
+
+    void setText3DItalic(const DataSetId& id, bool state);
+
+    void setText3DShadow(const DataSetId& id, bool state);
+
+    void setText3DText(const DataSetId& id, const char *text);
 
     // Volumes
@@ -915 +970 @@
     typedef std::tr1::unordered_map<DataSetId, Group *> GroupHashmap;
     typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Image *> ImageHashmap;
     typedef std::tr1::unordered_map<DataSetId, LIC *> LICHashmap;
     typedef std::tr1::unordered_map<DataSetId, Line *> LineHashmap;
@@ -924 +980 @@
     typedef std::tr1::unordered_map<DataSetId, Sphere *> SphereHashmap;
     typedef std::tr1::unordered_map<DataSetId, Streamlines *> StreamlinesHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Text3D *> Text3DHashmap;
     typedef std::tr1::unordered_map<DataSetId, Volume *> VolumeHashmap;
     typedef std::tr1::unordered_map<DataSetId, Warp *> WarpHashmap;
@@ -1019 +1076 @@
     FieldRangeHashmap _vectorCellDataRange;
     FieldRangeHashmap _vectorCompCellDataRange[3];
+    FieldRangeHashmap _scalarFieldDataRange;
+    FieldRangeHashmap _vectorFieldDataRange;
+    FieldRangeHashmap _vectorCompFieldDataRange[3];
 
     FieldRangeHashmap _userScalarPointDataRange;
@@ -1026 +1086 @@
     FieldRangeHashmap _userVectorCellDataRange;
     FieldRangeHashmap _userVectorCompCellDataRange[3];
+    FieldRangeHashmap _userScalarFieldDataRange;
+    FieldRangeHashmap _userVectorFieldDataRange;
+    FieldRangeHashmap _userVectorCompFieldDataRange[3];
 
     bool _axesAutoBounds[3];
@@ -1046 +1109 @@
     GroupHashmap _groups;
     HeightMapHashmap _heightMaps;
+    ImageHashmap _images;
     LICHashmap _lics;
     LineHashmap _lines;
@@ -1055 +1119 @@
     SphereHashmap _spheres;
     StreamlinesHashmap _streamlines;
+    Text3DHashmap _text3Ds;
     VolumeHashmap _volumes;
     WarpHashmap _warps;

branches/1.3/packages/vizservers/vtkvis/RendererCmd.cpp

@@ -2049 +2049 @@
     {"orient",    4, BoxOrientOp, 6, 7, "qw qx qy qz ?name?"},
     {"origin",    4, BoxOriginOp, 5, 6, "x y z ?name?"},
-    {"pos",       2, BoxPositionOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, BoxPositionOp, 5, 6, "x y z ?name?"},
     {"scale",     2, BoxScaleOp, 5, 6, "sx sy sz ?name?"},
     {"shading",   2, BoxShadingOp, 3, 4, "val ?name?"},
@@ -2891 +2891 @@
     {"orient",    4, ConeOrientOp, 6, 7, "qw qx qy qz ?name?"},
     {"origin",    4, ConeOriginOp, 5, 6, "x y z ?name?"},
-    {"pos",       2, ConePositionOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, ConePositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, ConeResolutionOp, 3, 4, "res ?name?"},
     {"scale",     2, ConeScaleOp, 5, 6, "sx sy sz ?name?"},
@@ -3026 +3026 @@
     Contour2D::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = Contour2D::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -3040 +3041 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -3253 +3254 @@
     {"add",          1, Contour2DAddOp, 4, 5, "oper value ?dataSetName?"},
     {"ccolor",       2, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"color",        5, Contour2DLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, Contour2DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, Contour2DColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -3401 +3403 @@
     Contour3D::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = Contour3D::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -3415 +3418 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -3688 +3691 @@
     {"add",          1, Contour3DAddOp, 4, 5, "oper value ?dataSetName?"},
     {"ccolor",       2, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"color",        5, Contour3DColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, Contour3DColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, Contour3DColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -4122 +4126 @@
     {"ccolor",       2, CutplaneColorOp, 5, 6, "r g b ?dataSetName?"},
     {"cloudstyle",   2, CutplaneCloudStyleOp, 3, 4, "style ?dataSetName?"},
+    {"color",        5, CutplaneColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, CutplaneColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, CutplaneColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -4518 +4523 @@
     {"orient",    4, CylinderOrientOp, 6, 7, "qw qx qy qz ?name?"},
     {"origin",    4, CylinderOriginOp, 5, 6, "x y z ?name?"},
-    {"pos",       2, CylinderPositionOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, CylinderPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, CylinderResolutionOp, 3, 4, "res ?name?"},
     {"scale",     2, CylinderScaleOp, 5, 6, "sx sy sz ?name?"},
@@ -5334 +5339 @@
     {"orient",    4, DiskOrientOp, 6, 7, "qw qx qy qz ?name?"},
     {"origin",    4, DiskOriginOp, 5, 6, "x y z ?name?"},
-    {"pos",       2, DiskPositionOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, DiskPositionOp, 5, 6, "x y z ?name?"},
     {"resolution",1, DiskResolutionOp, 4, 5, "resRadial resCircum ?name?"},
     {"scale",     2, DiskScaleOp, 5, 6, "sx sy sz ?name?"},
@@ -5446 +5451 @@
     Glyphs::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = Glyphs::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -5460 +5466 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -5555 +5561 @@
     } else {
         g_renderer->setGraphicsObjectEdgeWidth<Glyphs>("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+GlyphsMaxNumberOfGlyphsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    int max;
+    bool random = true;
+    int offset = 0;
+    int ratio = 1;
+    if (Tcl_GetIntFromObj(interp, objv[2], &max) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc > 3) {
+        if (GetBooleanFromObj(interp, objv[3], &random) != TCL_OK) {
+            return TCL_ERROR;
+        }
+        if (Tcl_GetIntFromObj(interp, objv[4], &offset) != TCL_OK) {
+            return TCL_ERROR;
+        }
+        if (Tcl_GetIntFromObj(interp, objv[5], &ratio) != TCL_OK) {
+            return TCL_ERROR;
+        }
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGlyphsMaximumNumberOfGlyphs(name, max, random, offset, ratio);
+    } else {
+        g_renderer->setGlyphsMaximumNumberOfGlyphs("all", max, random, offset, ratio);
     }
     return TCL_OK;
@@ -5830 +5867 @@
     {"add",          1, GlyphsAddOp, 3, 4, "shape ?dataSetName?"},
     {"ccolor",       2, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"color",        5, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, GlyphsColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -5839 +5877 @@
     {"linecolor",    5, GlyphsLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth",    5, GlyphsLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"normscale",    1, GlyphsNormalizeScaleOp, 3, 4, "bool ?dataSetName?"},
+    {"normscale",    2, GlyphsNormalizeScaleOp, 3, 4, "bool ?dataSetName?"},
+    {"numglyphs",    2, GlyphsMaxNumberOfGlyphsOp, 3, 7, "max ?random? ?offset? ?ratio? ?dataSetName?"},
     {"opacity",      2, GlyphsOpacityOp, 3, 4, "value ?dataSetName?"},
     {"orient",       2, GlyphsOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
@@ -6024 +6063 @@
     {"pos",       1, GroupPositionOp, 5, 6, "x y z ?name?"},
     {"remove",    1, GroupRemoveChildOp, 3, 4, "nodeList ?name?"},
-    {"scale",     2, GroupScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"scale",     1, GroupScaleOp, 5, 6, "sx sy sz ?name?"},
     {"visible",   1, GroupVisibleOp, 3, 4, "bool ?name?"},
 };
@@ -6212 +6251 @@
     HeightMap::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = HeightMap::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -6226 +6266 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -6238 +6278 @@
     } else {
         g_renderer->setHeightMapColorMode("all", mode, fieldName);
+    }
+    return TCL_OK;
+}
+
+static int
+HeightMapColorMode2Op(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    HeightMap::ColorMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
+        mode = HeightMap::COLOR_CONSTANT;
+    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = HeightMap::COLOR_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
+        mode = HeightMap::COLOR_BY_VECTOR_MAGNITUDE;
+    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
+        mode = HeightMap::COLOR_BY_VECTOR_X;
+    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
+        mode = HeightMap::COLOR_BY_VECTOR_Y;
+    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
+        mode = HeightMap::COLOR_BY_VECTOR_Z;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode option \"", str,
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (mode == HeightMap::COLOR_CONSTANT) {
+        fieldName = NULL;
+    }
+    str = Tcl_GetString(objv[4]);
+    DataSet::DataAttributeType association = DataSet::POINT_DATA;
+    bool haveAssoc = false;
+    if (str[0] == 'p' && strcmp(str, "point_data") == 0) {
+        association = DataSet::POINT_DATA;
+        haveAssoc = true;
+    } else if (str[0] == 'c' && strcmp(str, "cell_data") == 0) {
+        association = DataSet::CELL_DATA;
+        haveAssoc = true;
+    } else if (str[0] == 'f' && strcmp(str, "field_data") == 0) {
+        association = DataSet::FIELD_DATA;
+        haveAssoc = true;
+    } else if (str[0] == 'a' && strcmp(str, "any") == 0) {
+        haveAssoc = false;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode association option \"", str,
+                         "\": should be one of: 'point_data', 'cell_data', 'field_data', 'any'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    double *range = NULL;
+    if (objc >= 7) {
+        range = new double[2];
+        if (Tcl_GetDoubleFromObj(interp, objv[5], &range[0]) != TCL_OK ||
+            Tcl_GetDoubleFromObj(interp, objv[6], &range[1]) != TCL_OK) {
+            return TCL_ERROR;
+        }
+    }
+    if (objc == 6 || objc == 8) {
+        const char *name = Tcl_GetString((objc == 6 ? objv[5] : objv[7]));
+        if (haveAssoc) {
+            g_renderer->setHeightMapColorMode(name, mode, association, fieldName, range);
+        } else {
+            g_renderer->setHeightMapColorMode(name, mode, fieldName, range);
+        }
+    } else {
+        if (haveAssoc) {
+            g_renderer->setHeightMapColorMode("all", mode, association, fieldName, range);
+        } else {
+            g_renderer->setHeightMapColorMode("all", mode, fieldName, range);
+        }
+    }
+    if (range != NULL) {
+        delete [] range;
     }
     return TCL_OK;
@@ -6639 +6754 @@
     {"ccolor",       2, HeightMapColorOp, 5, 6, "r g b ?dataSetName?"},
     {"cloudstyle",   2, HeightMapCloudStyleOp, 3, 4, "style ?dataSetName?"},
+    {"color",        5, HeightMapColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, HeightMapColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
-    {"colormode",    7, HeightMapColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
+    {"colormode",    9, HeightMapColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
+    {"colormode2",   10,HeightMapColorMode2Op, 5, 8, "mode fieldName association ?min max? ?dataSetName?"},
     {"contourlist",  3, HeightMapContourListOp, 3, 4, "contourList ?dataSetName?"},
     {"delete",       1, HeightMapDeleteOp, 2, 3, "?dataSetName?"},
@@ -6680 +6797 @@
 
 static int
+ImageAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+           Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        if (!g_renderer->addGraphicsObject<Image>(name)) {
+            Tcl_AppendResult(interp, "Failed to create image", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->addGraphicsObject<Image>("all")) {
+            Tcl_AppendResult(interp, "Failed to create iamge for one or more data sets", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    return TCL_OK;
+}
+
+static int
+ImageBackgroundOp(ClientData clientData, Tcl_Interp *interp, int objc,
+                  Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageBackground(name, state);
+    } else {
+        g_renderer->setImageBackground("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageBackingOp(ClientData clientData, Tcl_Interp *interp, int objc,
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageBacking(name, state);
+    } else {
+        g_renderer->setImageBacking("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageBorderOp(ClientData clientData, Tcl_Interp *interp, int objc,
+              Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageBorder(name, state);
+    } else {
+        g_renderer->setImageBorder("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageColorOp(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->setGraphicsObjectColor<Image>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Image>("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    const char *colorMapName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectColorMap<Image>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Image>("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteGraphicsObject<Image>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Image>("all");
+    }
+    return TCL_OK;
+}
+
+static int
+ImageExtentsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    int extents[6];
+    if (Tcl_GetIntFromObj(interp, objv[2], &extents[0]) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[3], &extents[1]) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[4], &extents[2]) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[5], &extents[3]) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[6], &extents[4]) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[7], &extents[5]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 9) {
+        const char *name = Tcl_GetString(objv[8]);
+        g_renderer->setImageExtents(name, extents);
+    } else {
+        g_renderer->setImageExtents("all", extents);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageLevelOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    double level;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &level) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageLevel(name, level);
+    } else {
+        g_renderer->setImageLevel("all", level);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    double opacity;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectOpacity<Image>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Image>("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageOrientOp(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->setGraphicsObjectOrientation<Image>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Image>("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+ImagePositionOp(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->setGraphicsObjectPosition<Image>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Image>("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageScaleOp(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->setGraphicsObjectScale<Image>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Image>("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectVisibility<Image>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Image>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageWindowOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    double window;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &window) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageLevel(name, window);
+    } else {
+        g_renderer->setImageLevel("all", window);
+    }
+    return TCL_OK;
+}
+
+static int
+ImageZSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    int slice;
+    if (Tcl_GetIntFromObj(interp, objv[2], &slice) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setImageZSlice(name, slice);
+    } else {
+        g_renderer->setImageZSlice("all", slice);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec imageOps[] = {
+    {"add",          1, ImageAddOp, 2, 3, "?dataSetName?"},
+    {"backing",      2, ImageBackingOp, 3, 4, "bool ?dataSetName?"},
+    {"bg",           2, ImageBackgroundOp, 3, 4, "bool ?dataSetName?"},
+    {"border",       2, ImageBorderOp, 3, 4, "bool ?dataSetName?"},
+    {"color",        5, ImageColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",     6, ImageColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"delete",       1, ImageDeleteOp, 2, 3, "?dataSetName?"},
+    {"extents",      1, ImageExtentsOp, 8, 9, "xmin xmax ymin ymax zmin zmax ?dataSetName?"},
+    {"level",        1, ImageLevelOp, 3, 4, "val ?dataSetName?"},
+    {"opacity",      2, ImageOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",       2, ImageOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",          1, ImagePositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",        1, ImageScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"visible",      1, ImageVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"window",       1, ImageWindowOp, 3, 4, "val ?dataSetName?"},
+    {"zslice",       1, ImageZSliceOp, 3, 4, "val ?dataSetName?"}
+};
+static int nImageOps = NumCmdSpecs(imageOps);
+
+static int
+ImageCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+         Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nImageOps, imageOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 ImageFlushCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -6786 +7218 @@
 
 static int
+LegendSimpleCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    if (objc != 4) {
+        Tcl_AppendResult(interp, "wrong # args: should be \"",
+                Tcl_GetString(objv[0]), " colormapName width height\"", (char*)NULL);
+        return TCL_ERROR;
+    }
+    const char *colorMapName = Tcl_GetString(objv[1]);
+
+    int width, height;
+    if (Tcl_GetIntFromObj(interp, objv[2], &width) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[3], &height) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    vtkSmartPointer<vtkUnsignedCharArray> imgData = 
+        vtkSmartPointer<vtkUnsignedCharArray>::New();
+
+    if (!g_renderer->renderColorMap(colorMapName, width, height, true, imgData)) {
+        Tcl_AppendResult(interp, "Color map \"",
+                         colorMapName, "\" was not found", (char*)NULL);
+        return TCL_ERROR;
+    }
+
+#ifdef DEBUG
+# ifdef RENDER_TARGA
+    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height,
+                 TARGA_BYTES_PER_PIXEL);
+# else
+    writeTGAFile("/tmp/legend.tga", imgData->GetPointer(0), width, height,
+                 TARGA_BYTES_PER_PIXEL, true);
+# endif
+#else
+    char cmd[256];
+    snprintf(cmd, sizeof(cmd), "nv>legend {%s} {} 0 1", colorMapName);
+
+# ifdef USE_THREADS
+#  ifdef RENDER_TARGA
+    ResponseQueue *queue = (ResponseQueue *)clientData;
+    queueTGA(queue, cmd, imgData->GetPointer(0), width, height,
+             TARGA_BYTES_PER_PIXEL);
+#  else
+    ResponseQueue *queue = (ResponseQueue *)clientData;
+    queuePPM(queue, cmd, imgData->GetPointer(0), width, height);
+#  endif
+# else
+#  ifdef RENDER_TARGA
+    writeTGA(g_fdOut, cmd, imgData->GetPointer(0), width, height,
+             TARGA_BYTES_PER_PIXEL);
+#  else
+    writePPM(g_fdOut, cmd, imgData->GetPointer(0), width, height);
+#  endif
+# endif // USE_THREADS
+#endif // DEBUG
+    return TCL_OK;
+}
+
+static int
 LICAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
          Tcl_Obj *const *objv)
@@ -7271 +7762 @@
     {"orient",    4, LineOrientOp, 6, 7, "qw qx qy qz ?name?"},
     {"origin",    4, LineOriginOp, 5, 6, "x y z ?name?"},
-    {"pos",       2, LinePositionOp, 5, 6, "x y z ?name?"},
-    {"scale",     2, LineScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"pos",       1, LinePositionOp, 5, 6, "x y z ?name?"},
+    {"scale",     1, LineScaleOp, 5, 6, "sx sy sz ?name?"},
     {"visible",   1, LineVisibleOp, 3, 4, "bool ?name?"}
 };
@@ -7579 +8070 @@
     if (str[0] == 'b' && strcmp(str, "by_elements") == 0) {
         mode = Molecule::COLOR_BY_ELEMENTS;
-    } else if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    } else if (str[0] == 'c' &&
+               (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = Molecule::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -7593 +8085 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'by_elements', 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'by_elements', 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -7693 +8185 @@
     } else {
         g_renderer->setGraphicsObjectEdgeWidth<Molecule>("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+MoleculeMaterialOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    double ambient, diffuse, specCoeff, specPower;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &ambient) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &diffuse) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &specCoeff) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &specPower) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGraphicsObjectAmbient<Molecule>(name, ambient);
+        g_renderer->setGraphicsObjectDiffuse<Molecule>(name, diffuse);
+        g_renderer->setGraphicsObjectSpecular<Molecule>(name, specCoeff, specPower);
+    } else {
+        g_renderer->setGraphicsObjectAmbient<Molecule>("all", ambient);
+        g_renderer->setGraphicsObjectDiffuse<Molecule>("all", diffuse);
+        g_renderer->setGraphicsObjectSpecular<Molecule>("all", specCoeff, specPower);
     }
     return TCL_OK;
@@ -7818 +8335 @@
     {"bstyle",       3, MoleculeBondStyleOp, 3, 4, "value ?dataSetName?"},
     {"ccolor",       2, MoleculeColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"color",        5, MoleculeColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, MoleculeColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, MoleculeColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -7827 +8345 @@
     {"linecolor",    5, MoleculeLineColorOp, 5, 6, "r g b ?dataSetName?"},
     {"linewidth",    5, MoleculeLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"material",     1, MoleculeMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
     {"opacity",      2, MoleculeOpacityOp, 3, 4, "value ?dataSetName?"},
     {"orient",       2, MoleculeOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
@@ -8019 +8538 @@
     {"opacity",   2, OutlineOpacityOp, 3, 4, "value ?dataSetName?"},
     {"orient",    2, OutlineOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
-    {"pos",       2, OutlinePositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",     2, OutlineScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"pos",       1, OutlinePositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",     1, OutlineScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",   1, OutlineVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
@@ -8103 +8622 @@
 
 static int
+PolyDataColorMapOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    const char *colorMapName = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *dataSetName = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectColorMap<PolyData>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<PolyData>("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataColorModeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    PolyData::ColorMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
+        mode = PolyData::COLOR_CONSTANT;
+    } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = PolyData::COLOR_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
+        mode = PolyData::COLOR_BY_VECTOR_MAGNITUDE;
+    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
+        mode = PolyData::COLOR_BY_VECTOR_X;
+    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
+        mode = PolyData::COLOR_BY_VECTOR_Y;
+    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
+        mode = PolyData::COLOR_BY_VECTOR_Z;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode option \"", str,
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (mode == PolyData::COLOR_CONSTANT) {
+        fieldName = NULL;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setPolyDataColorMode(name, mode, fieldName);
+    } else {
+        g_renderer->setPolyDataColorMode("all", mode, fieldName);
+    }
+    return TCL_OK;
+}
+
+static int
 PolyDataCullingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                   Tcl_Obj *const *objv)
@@ -8315 +8885 @@
     } else {
         g_renderer->setGraphicsObjectPosition<PolyData>("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+PolyDataPreInterpOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectInterpolateBeforeMapping<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectInterpolateBeforeMapping<PolyData>("all", state);
     }
     return TCL_OK;
@@ -8398 +8985 @@
 static Rappture::CmdSpec polyDataOps[] = {
     {"add",       1, PolyDataAddOp, 2, 3, "?dataSetName?"},
+    {"ccolor",    2, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
     {"cloudstyle",2, PolyDataCloudStyleOp, 3, 4, "style ?dataSetName?"},
-    {"color",     2, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"color",     5, PolyDataColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",  7, PolyDataColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"colormode", 7, PolyDataColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
     {"culling",   2, PolyDataCullingOp, 3, 4, "bool ?name?"},
     {"delete",    1, PolyDataDeleteOp, 2, 3, "?dataSetName?"},
@@ -8411 +9001 @@
     {"origin",    4, PolyDataOriginOp, 5, 6, "x y z ?name?"},
     {"pos",       2, PolyDataPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"preinterp", 2, PolyDataPreInterpOp, 3, 4, "bool ?dataSetName?"},
     {"ptsize",    2, PolyDataPointSizeOp, 3, 4, "size ?dataSetName?"},
     {"scale",     2, PolyDataScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
@@ -8891 +9482 @@
     PseudoColor::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = PseudoColor::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -8905 +9497 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -9151 +9743 @@
     {"ccolor",       2, PseudoColorColorOp, 5, 6, "r g b ?dataSetName?"},
     {"cloudstyle",   2, PseudoColorCloudStyleOp, 3, 4, "style ?dataSetName?"},
+    {"color",        5, PseudoColorColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, PseudoColorColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, PseudoColorColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -9811 +10404 @@
     } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
         mode = Streamlines::COLOR_BY_VECTOR_Z;
-    } else if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    } else if (str[0] == 'c' &&
+               (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 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);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -10460 +11054 @@
 static Rappture::CmdSpec streamlinesOps[] = {
     {"add",          1, StreamlinesAddOp,            2, 3, "?dataSetName?"},
-    {"ccolor",       1, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
+    {"ccolor",       2, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
+    {"color",        5, StreamlinesColorOp,          5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, StreamlinesColorMapOp,       3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, StreamlinesColorModeOp,      4, 5, "mode fieldName ?dataSetName?"},
@@ -10497 +11092 @@
 
 static int
+Text3DAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+            Tcl_Obj *const *objv)
+{
+    int fontSize;
+    const char *fontFamily = Tcl_GetString(objv[2]);
+    if (Tcl_GetIntFromObj(interp, objv[3], &fontSize) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *text = Tcl_GetString(objv[4]);
+    const char *name = Tcl_GetString(objv[5]);
+    if (!g_renderer->addText3D(name, text, fontFamily, fontSize)) {
+        Tcl_AppendResult(interp, "Failed to create text3d", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DBoldOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DBold(name, state);
+    } else {
+        g_renderer->setText3DBold("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DColorOp(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->setGraphicsObjectColor<Text3D>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Text3D>("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteGraphicsObject<Text3D>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Text3D>("all");
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DFollowCameraOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                     Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DFollowCamera(name, state);
+    } else {
+        g_renderer->setText3DFollowCamera("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DFontFamilyOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                   Tcl_Obj *const *objv)
+{
+    const char *fontFamily = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DFont(name, fontFamily);
+    } else {
+        g_renderer->setText3DFont("all", fontFamily);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DFontSizeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    int fontSize;
+    if (Tcl_GetIntFromObj(interp, objv[2], &fontSize) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DFontSize(name, fontSize);
+    } else {
+        g_renderer->setText3DFontSize("all", fontSize);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DItalicOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DItalic(name, state);
+    } else {
+        g_renderer->setText3DItalic("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    double opacity;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectOpacity<Text3D>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Text3D>("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DOrientOp(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->setGraphicsObjectOrientation<Text3D>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Text3D>("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Text3D>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Text3D>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DPositionOp(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->setGraphicsObjectPosition<Text3D>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Text3D>("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DScaleOp(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->setGraphicsObjectScale<Text3D>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Text3D>("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DShadowOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+               Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DShadow(name, state);
+    } else {
+        g_renderer->setText3DShadow("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DTextOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    char *str = Tcl_GetString(objv[2]);
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setText3DText(name, str);
+    } else {
+        g_renderer->setText3DText("all", str);
+    }
+    return TCL_OK;
+}
+
+static int
+Text3DVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectVisibility<Text3D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Text3D>("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec text3DOps[] = {
+    {"add",       1, Text3DAddOp, 6, 6, "font size text name"},
+    {"bold",      1, Text3DBoldOp, 3, 4, "bool ?name?"},
+    {"color",     1, Text3DColorOp, 5, 6, "r g b ?name?"},
+    {"delete",    1, Text3DDeleteOp, 2, 3, "?name?"},
+    {"fntfamily", 4, Text3DFontFamilyOp, 3, 4, "font ?name?"},
+    {"fntsize",   4, Text3DFontSizeOp, 3, 4, "size ?name?"},
+    {"followcam", 2, Text3DFollowCameraOp, 3, 4, "bool ?name?"},
+    {"italic",    1, Text3DItalicOp, 3, 4, "bool ?name?"},
+    {"opacity",   2, Text3DOpacityOp, 3, 4, "value ?name?"},
+    {"orient",    4, Text3DOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, Text3DOriginOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, Text3DPositionOp, 5, 6, "x y z ?name?"},
+    {"scale",     1, Text3DScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shadow",    1, Text3DShadowOp, 3, 4, "bool ?name?"},
+    {"text",      1, Text3DTextOp, 3, 4, "text ?name?"},
+    {"visible",   1, Text3DVisibleOp, 3, 4, "bool ?name?"},
+};
+static int nText3DOps = NumCmdSpecs(text3DOps);
+
+static int
+Text3DCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+          Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nText3DOps, text3DOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 VolumeAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
             Tcl_Obj *const *objv)
@@ -10869 +11772 @@
     Warp::ColorMode mode;
     const char *str = Tcl_GetString(objv[2]);
-    if (str[0] == 'c' && strcmp(str, "ccolor") == 0) {
+    if (str[0] == 'c' &&
+        (strcmp(str, "ccolor") == 0 || strcmp(str, "constant") == 0)) {
         mode = Warp::COLOR_CONSTANT;
     } else if (str[0] == 's' && strcmp(str, "scalar") == 0) {
@@ -10883 +11787 @@
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor', 'constant'", (char*)NULL);
         return TCL_ERROR;
     }
@@ -11146 +12050 @@
     {"ccolor",       2, WarpColorOp, 5, 6, "r g b ?dataSetName?"},
     {"cloudstyle",   2, WarpCloudStyleOp, 3, 4, "style ?dataSetName?"},
+    {"color",        5, WarpColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",     7, WarpColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode",    7, WarpColorModeOp, 4, 5, "mode fieldName ?dataSetName?"},
@@ -11158 +12063 @@
     {"preinterp",    2, WarpPreInterpOp, 3, 4, "bool ?dataSetName?"},
     {"ptsize",       2, WarpPointSizeOp, 3, 4, "size ?dataSetName?"},
-    {"scale",        2, WarpScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"scale",        1, WarpScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"visible",      1, WarpVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"warpscale",    2, WarpWarpScaleOp, 3, 4, "value ?dataSetName?"},
@@ -11340 +12245 @@
     Tcl_CreateObjCommand(interp, "group",       GroupCmd,       clientData, NULL);
     Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
+    Tcl_CreateObjCommand(interp, "image",       ImageCmd,       clientData, NULL);
     Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
     Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      clientData, NULL);
+    Tcl_CreateObjCommand(interp, "legend2",     LegendSimpleCmd,clientData, NULL);
     Tcl_CreateObjCommand(interp, "lic",         LICCmd,         clientData, NULL);
     Tcl_CreateObjCommand(interp, "line",        LineCmd,        clientData, NULL);
@@ -11353 +12260 @@
     Tcl_CreateObjCommand(interp, "sphere",      SphereCmd,      clientData, NULL);
     Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, clientData, NULL);
+    Tcl_CreateObjCommand(interp, "text3d",      Text3DCmd,      clientData, NULL);
     Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      clientData, NULL);
     Tcl_CreateObjCommand(interp, "warp",        WarpCmd,        clientData, NULL);
@@ -11379 +12287 @@
     Tcl_DeleteCommand(interp, "group");
     Tcl_DeleteCommand(interp, "heightmap");
+    Tcl_DeleteCommand(interp, "image");
     Tcl_DeleteCommand(interp, "imgflush");
     Tcl_DeleteCommand(interp, "legend");
+    Tcl_DeleteCommand(interp, "legend2");
     Tcl_DeleteCommand(interp, "lic");
     Tcl_DeleteCommand(interp, "line");
@@ -11392 +12302 @@
     Tcl_DeleteCommand(interp, "sphere");
     Tcl_DeleteCommand(interp, "streamlines");
+    Tcl_DeleteCommand(interp, "text3d");
     Tcl_DeleteCommand(interp, "volume");
     Tcl_DeleteCommand(interp, "warp");

branches/1.3/packages/vizservers/vtkvis/RendererGraphicsObjs.cpp

@@ -100 +100 @@
 
 template<>
+Renderer::ImageHashmap &
+Renderer::getGraphicsObjectHashmap<Image>()
+{ return _images; }
+
+template<>
 Renderer::LICHashmap &
 Renderer::getGraphicsObjectHashmap<LIC>()
@@ -145 +150 @@
 
 template<>
+Renderer::Text3DHashmap &
+Renderer::getGraphicsObjectHashmap<Text3D>()
+{ return _text3Ds; }
+
+template<>
 Renderer::VolumeHashmap &
 Renderer::getGraphicsObjectHashmap<Volume>()
@@ -154 +164 @@
 { return _warps; }
 
+#if 0
 template Arc *Renderer::getGraphicsObject(const DataSetId&);
 template Arrow *Renderer::getGraphicsObject(const DataSetId&);
@@ -164 +175 @@
 template Polygon *Renderer::getGraphicsObject(const DataSetId&);
 template Sphere *Renderer::getGraphicsObject(const DataSetId&);
+template Text3D *Renderer::getGraphicsObject(const DataSetId&);
+#endif
 
 template <>
@@ -214 +227 @@
 }
 
-template <>
-bool Renderer::addGraphicsObject<Box>(const DataSetId& id)
-{
-    Box *gobj;
-    if ((gobj = getGraphicsObject<Box>(id)) != NULL) {
-        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
-        deleteGraphicsObject<Box>(id);
-    }
-
-    gobj = new Box();
- 
-    gobj->setDataSet(NULL, this);
-
-    if (gobj->getProp() == NULL &&
-        gobj->getOverlayProp() == NULL) {
-        delete gobj;
-        return false;
-    } else {
-        if (gobj->getProp())
-            _renderer->AddViewProp(gobj->getProp());
-        if (gobj->getOverlayProp())
-            _renderer->AddViewProp(gobj->getOverlayProp());
-    }
-
-    getGraphicsObjectHashmap<Box>()[id] = gobj;
-
-    sceneBoundsChanged();
-    _needsRedraw = true;
-    return true;
-}
-
-template <>
-bool Renderer::addGraphicsObject<Sphere>(const DataSetId& id)
-{
-    Sphere *gobj;
-    if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
-        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
-        deleteGraphicsObject<Sphere>(id);
-    }
-
-    gobj = new Sphere();
- 
-    gobj->setDataSet(NULL, this);
-
-    if (gobj->getProp() == NULL &&
-        gobj->getOverlayProp() == NULL) {
-        delete gobj;
-        return false;
-    } else {
-        if (gobj->getProp())
-            _renderer->AddViewProp(gobj->getProp());
-        if (gobj->getOverlayProp())
-            _renderer->AddViewProp(gobj->getOverlayProp());
-    }
-
-    getGraphicsObjectHashmap<Sphere>()[id] = gobj;
-
-    sceneBoundsChanged();
-    _needsRedraw = true;
-    return true;
-}
-
 /**
  * \brief Set the volume slice used for mapping volumetric data
@@ -342 +293 @@
     }
     if ((gobj = getGraphicsObject<Sphere>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Text3D>(id)) != NULL) {
         return gobj;
     }
@@ -358 +312 @@
     }
     if ((gobj = getGraphicsObject<HeightMap>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Image>(id)) != NULL) {
         return gobj;
     }
@@ -1554 +1511 @@
     do {
         itr->second->setScalingMode(mode, name, range);
+    } while (doAll && ++itr != _glyphs.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Limit the number of glyphs displayed
+ *
+ * The choice of glyphs to display can be based on sampling every
+ * n-th point (ratio) or by random sample
+ *
+ * \param max Maximum number of glyphs to display, negative means display all
+ * \param random Flag to enable/disable random sampling
+ * \param offset If random is false, this controls the first sample point
+ * \param ratio If random is false, this ratio controls every n-th point sampling
+ */
+void Renderer::setGlyphsMaximumNumberOfGlyphs(const DataSetId& id, int max,
+                                              bool random, int offset, int ratio)
+{
+    GlyphsHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _glyphs.begin();
+        if (itr == _glyphs.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _glyphs.find(id);
+    }
+    if (itr == _glyphs.end()) {
+        ERROR("Glyphs not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setMaximumNumberOfGlyphs(max, random, offset, ratio);
     } while (doAll && ++itr != _glyphs.end());
 
@@ -2269 +2265 @@
 }
 
+void Renderer::setImageBackground(const DataSetId& id, bool state)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setBackground(state);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageBacking(const DataSetId& id, bool state)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setBacking(state);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageBorder(const DataSetId& id, bool state)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setBorder(state);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageExtents(const DataSetId& id, int extents[6])
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setExtents(extents);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageLevel(const DataSetId& id, double level)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLevel(level);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageWindow(const DataSetId& id, double window)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setWindow(window);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
+void Renderer::setImageZSlice(const DataSetId& id, int z)
+{
+    ImageHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _images.begin();
+        if (itr == _images.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _images.find(id);
+    }
+    if (itr == _images.end()) {
+        ERROR("Image not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setZSlice(z);
+    } while (doAll && ++itr != _images.end());
+
+    _needsRedraw = true;
+}
+
 /**
  * \brief Create a new Line and associate it with an ID
@@ -2829 +3007 @@
 
 /**
+ * \brief Set the color mode for the specified DataSet
+ */
+void Renderer::setPolyDataColorMode(const DataSetId& id,
+                                    PolyData::ColorMode mode,
+                                    DataSet::DataAttributeType type,
+                                    const char *name, double range[2])
+{
+    PolyDataHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        if (itr == _polyDatas.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColorMode(mode, type, name, range);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the color mode for the specified DataSet
+ */
+void Renderer::setPolyDataColorMode(const DataSetId& id,
+                                    PolyData::ColorMode mode,
+                                    const char *name, double range[2])
+{
+    PolyDataHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _polyDatas.begin();
+        if (itr == _polyDatas.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _polyDatas.find(id);
+    }
+    if (itr == _polyDatas.end()) {
+        ERROR("PolyData not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColorMode(mode, name, range);
+    } while (doAll && ++itr != _polyDatas.end());
+
+    _needsRedraw = true;
+}
+
+/**
  * \brief Set the  point cloud render style for the specified DataSet
  */
@@ -2953 +3194 @@
 
     getGraphicsObjectHashmap<Sphere>()[id] = gobj;
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+    return true;
+}
+
+/**
+ * \brief Create a new Text3D label and associate it with an ID
+ */
+bool Renderer::addText3D(const DataSetId& id, const char *string,
+                         const char *fontFamily, int fontSize,
+                         bool bold, bool italic, bool shadow)
+{
+    Text3D *gobj;
+    if ((gobj = getGraphicsObject<Text3D>(id)) != NULL) {
+        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
+        deleteGraphicsObject<Text3D>(id);
+    }
+
+    gobj = new Text3D();
+
+    gobj->setDataSet(NULL, this);
+
+    gobj->setText(string);
+    gobj->setFont(fontFamily);
+    gobj->setFontSize(fontSize);
+    gobj->setBold(bold);
+    gobj->setItalic(italic);
+    gobj->setShadow(shadow);
+
+    if (gobj->getProp() == NULL &&
+        gobj->getOverlayProp() == NULL) {
+        delete gobj;
+        return false;
+    } else {
+        if (gobj->getProp())
+            _renderer->AddViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->AddViewProp(gobj->getOverlayProp());
+    }
+
+    getGraphicsObjectHashmap<Text3D>()[id] = gobj;
 
     sceneBoundsChanged();
@@ -3655 +3938 @@
 }
 
+void Renderer::setText3DBold(const DataSetId& id, bool state)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setBold(state);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the font family for the Text3D
+ */
+void Renderer::setText3DFont(const DataSetId& id, const char *fontFamily)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setFont(fontFamily);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the font family for the Text3D
+ */
+void Renderer::setText3DFontSize(const DataSetId& id, int size)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setFontSize(size);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+void Renderer::setText3DFollowCamera(const DataSetId& id, bool state)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setFollowCamera(state, _renderer);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+void Renderer::setText3DItalic(const DataSetId& id, bool state)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setItalic(state);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+void Renderer::setText3DShadow(const DataSetId& id, bool state)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setShadow(state);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
+void Renderer::setText3DText(const DataSetId& id, const char *text)
+{
+    Text3DHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _text3Ds.begin();
+        if (itr == _text3Ds.end())
+            return;
+        doAll = true;
+    } else {
+        itr = _text3Ds.find(id);
+    }
+    if (itr == _text3Ds.end()) {
+        ERROR("Text3D not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setText(text);
+    } while (doAll && ++itr != _text3Ds.end());
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+}
+
 /**
  * \brief Set the sample rate for the volume shader

branches/1.3/packages/vizservers/vtkvis/RendererGraphicsObjs.h

@@ -1034 +1034 @@
 
     ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
+    if (cmap == NULL && colorMapId.compare("none") != 0) {
         ERROR("Unknown colormap: %s", colorMapId.c_str());
         return;

branches/1.3/packages/vizservers/vtkvis/Volume.cpp

@@ -83 +83 @@
     double spacing[3];
     getSpacing(spacing);
+    TRACE("Spacing: %g %g %g", spacing[0], spacing[1], spacing[2]);
     return (spacing[0] + spacing[1] + spacing[2]) * 0.333;
 }
@@ -120 +121 @@
 #endif
         vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
+    } else if (_dataSet->isCloud()) {
+        // DataSet is a 3D point cloud
+        vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
+#ifdef USE_VTK6
+        splatter->SetInputData(ds);
+#else
+        splatter->SetInput(ds);
+#endif
+        int dims[3];
+        dims[0] = dims[1] = dims[2] = 64;
+        TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
+              dims[0], dims[1], dims[2]);
+        splatter->SetSampleDimensions(dims);
+        splatter->Update();
+        TRACE("Done generating volume");
+#ifdef USE_GPU_RAYCAST_MAPPER
+        _volumeMapper = vtkSmartPointer<vtkGPUVolumeRayCastMapper>::New();
+        vtkGPUVolumeRayCastMapper::SafeDownCast(_volumeMapper)->AutoAdjustSampleDistancesOff();
+#else
+        _volumeMapper = vtkSmartPointer<vtkVolumeTextureMapper3D>::New();
+#endif
+        _volumeMapper->SetInputConnection(splatter->GetOutputPort());
+        vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
     } else if (vtkUnstructuredGrid::SafeDownCast(ds) != NULL) {
+        // Unstructured grid with cells (not a cloud)
         vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::SafeDownCast(ds);
         // DataSet is unstructured grid
@@ -144 +169 @@
 #endif
             filter->TetrahedraOnlyOn();
+            TRACE("Decomposing grid to tets");
+            filter->Update();
+            TRACE("Decomposing done");
             _volumeMapper->SetInputConnection(filter->GetOutputPort());
         }
@@ -149 +177 @@
         vtkUnstructuredGridVolumeMapper::SafeDownCast(_volumeMapper)->
             SetBlendModeToComposite();
-    } else if (_dataSet->isCloud()) {
-        // DataSet is a 3D point cloud
-        vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
-#ifdef USE_VTK6
-        splatter->SetInputData(ds);
-#else
-        splatter->SetInput(ds);
-#endif
-        int dims[3];
-        dims[0] = dims[1] = dims[2] = 64;
-        TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
-              dims[0], dims[1], dims[2]);
-        splatter->SetSampleDimensions(dims);
-#ifdef USE_GPU_RAYCAST_MAPPER
-        _volumeMapper = vtkSmartPointer<vtkGPUVolumeRayCastMapper>::New();
-        vtkGPUVolumeRayCastMapper::SafeDownCast(_volumeMapper)->AutoAdjustSampleDistancesOff();
-#else
-        _volumeMapper = vtkSmartPointer<vtkVolumeTextureMapper3D>::New();
-#endif
-        _volumeMapper->SetInputConnection(splatter->GetOutputPort());
-        vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
     } else {
         ERROR("Unsupported DataSet type: %s", _dataSet->getVtkType());

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

@@ -342 +342 @@
 contour2d add contourlist <list> <?datasetName?>
           list = {isoval1 isoval2 isoval3...}
-contour2d ccolor <r> <g> <b> <?datasetName?>
+contour2d color <r> <g> <b> <?datasetName?>
           synonym for linecolor
 contour2d colormap <colormapName> <?datasetName?>
-contour2d colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-          Set the field used to color the object.  'ccolor' means to use
-          the constant color defined by the ccolor subcommand.  'scalar' uses
+contour2d colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+          Set the field used to color the object.  'constant' means to use
+          the constant color defined by the color 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
@@ -369 +369 @@
 contour3d add contourlist <list> <?datasetName?>
           list = {isoval1 isoval2 isoval3...}
-contour3d ccolor r g b <?datasetName?>
+contour3d color r g b <?datasetName?>
 contour3d colormap <colorMapName> <?dataSetName?>
-contour3d colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-          Set the field used to color the object.  'ccolor' means to use
-          the constant color defined by the ccolor subcommand.  'scalar' uses
+contour3d colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+          Set the field used to color the object.  'constant' means to use
+          the constant color defined by the color 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
@@ -394 +394 @@
 cutplane axis <axis> <bool> <?dataSetName?>
          Toggle visibility of the 3 principal axis cutplanes
-cutplane ccolor r g b <?datasetName?>
+cutplane color r g b <?datasetName?>
          Set color of outline bounding box
 cutplane cloudstyle <style> <?datasetName?>
@@ -471 +471 @@
 glyphs add <shape> <?dataSetName?>
        See 'glyphs shape' for list of shapes
-glyphs ccolor r g b <?datasetName?>
+glyphs color r g b <?datasetName?>
 glyphs colormap <colorMapName> <?dataSetName?>
-glyphs colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?dataSetName?>
+glyphs colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?dataSetName?>
        Set the color mode: color by scalar field or
        vector magnitude -- uses the current color map,
-       or ccolor for constant color
+       or color for constant color
 glyphs delete <?dataSetName?>
 glyphs edges <bool> <?datasetName?>
@@ -490 +490 @@
        Control if data values are normalized to [0,1] range before applying
        glyph scaling factor (gscale)
+glyphs numglyphs <max> <random> <offset> <ratio> <?dataSetName?>
+       Limit the maximum number of glyphs displayed.  Can use either a random
+       sampling or every nth point sampling (useful for uniform grids)
+       <max> = integer maximum number of glyphs
+       <random> = bool indicating if random sampling should be used
+       <offset> = offset point index from which to start sampling
+       <ratio> = If random is false, use this to control every nth point sampling
 glyphs opacity <val> <?datasetName?>
 glyphs orient <qw> <qx> <qy> <qz> <?dataSetName?>
@@ -505 +512 @@
 
 group add <nodeList> <name>
+      Add listed nodes to group named <name>.  Group will be created if
+      it doesn't exist, but nodes may be added to existing groups.  The
+      nodes will be removed from the virtual root scene.
 group delete <?name?>
 group orient <qw> <qx> <qy> <qz> <?name?>
@@ -510 +520 @@
 group pos <x> <y> <z> <?name?>
 group remove <nodeList> <name>
+      Remove listed nodes from group.  Currently, nodes will be added back
+      to the virtual root scene, and so nodes must be explicitly deleted to 
+      remove them from the scene.
 group scale <sx> <sy> <sz> <?name?>
 group visible <bool> <?name?>
@@ -524 +537 @@
           <style> = mesh | splat
 heightmap colormap <colorMapName> <?dataSetName?>
-heightmap colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-          Set the field used to color the object.  'ccolor' means to use
-          the constant color defined by the ccolor subcommand.  'scalar' uses
+heightmap colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+          Set the field used to color the object.  'constant' means to use
+          the constant color defined by the color 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
@@ -560 +573 @@
 heightmap wireframe <bool> <?datasetName?>
 
+image add <?dataSetName?>
+      Create an image from a vtkImageData data set
+image backing <bool> <?dataSetName?>
+image bg <bool> <?dataSetName?>
+image border <bool> <?dataSetName?>
+image color <r> <g> <b> <?dataSetName?>
+image colormap <colorMapName> <?dataSetName?>
+image delete <?dataSetName?>
+image extents <xmin> <xmax> <ymin> <ymax> <zmin> <zmax> <?dataSetName?>
+image level <level> <?dataSetName?>
+image opacity <opacity> <?dataSetName?>
+image orient <qw> <qx> <qy> <qz> <?dataSetName?>
+image pos <x> <y> <z> <?dataSetName?>
+image scale <sx> <sy> <sz> <?dataSetName?>
+image visible <bool> <?dataSetName?>
+image window <windowWidth> <?dataSetName?>
+image zslice <sliceNum> <?dataSetName?>
+
 lic add <?datasetName?>
 lic colormap <colormapName> <?datasetName?>
@@ -615 +646 @@
 molecule bstyle <cylinder|line> <?datasetName?>
          Set bond render style
-molecule ccolor r g b <?datasetName?>
+molecule color r g b <?datasetName?>
 molecule colormap <colormapName> <?datasetName?>
-molecule colormode <by_elements|scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-         Set the field used to color the object.  'ccolor' means to use
-         the constant color defined by the ccolor subcommand.  'scalar' uses
+molecule colormode <by_elements|scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+         Set the field used to color the object.  'constant' means to use
+         the constant color defined by the color 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
@@ -632 +663 @@
 molecule linecolor <r> <g> <b> <?datasetName?>
 molecule linewidth <val> <?datasetName?>
+molecule material <ambientCoeff> <diffuseCoeff> <specularCoeff> <specularExp> <?datasetName?>
 molecule opacity <val> <?datasetName?>
 molecule orient <qw> <qx> <qy> <qz> <?dataSetName?>
@@ -655 +687 @@
 
 polydata add <?datasetName?>
+polydata color <r> <g> <b> <?datasetName?>
 polydata cloudstyle <style> <?datasetName?>
          <style> = mesh | points
-polydata color <r> <g> <b> <?datasetName?>
+polydata colormap <colormapName> <?datasetName?>
+polydata colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+         Set the field used to color the object.  'constant' means to use
+         the constant color defined by the color 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.
 polydata culling <bool> <?name?>
 polydata delete <?datasetName?>
@@ -669 +708 @@
 polydata origin <x> <y> <z> <?name?>
 polydata pos <x> <y> <z> <?dataSetName?>
+polydata preinterp <bool> <?dataSetName?>
+         Controls if VTK's InterpolateScalarsBeforeMapping option is set.
+         Setting this on will give more correct colors, as the interpolation
+         is done on texture coordinates that lookup into a 1D texture instead
+         of using color interpolation from triangle vertices.
 polydata ptsize <size> <?dataSetName?>
 polydata scale <sx> <sy> <sz> <?dataSetName?>
@@ -697 +741 @@
 
 pseudocolor add <?datasetName?>
-pseudocolor ccolor <r> <g> <b> <?datasetName?>
+pseudocolor color <r> <g> <b> <?datasetName?>
 pseudocolor cloudstyle <style> <?datasetName?>
             <style> = mesh | points | splat
 pseudocolor colormap <colormapName> <?datasetName?>
-pseudocolor colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-            Set the field used to color the object.  'ccolor' means to use
-            the constant color defined by the ccolor subcommand.  'scalar' uses
+pseudocolor colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+            Set the field used to color the object.  'constant' means to use
+            the constant color defined by the color 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
@@ -749 +793 @@
 
 streamlines add <?datasetName?>
-streamlines ccolor <r> <g> <b> <?datasetName?>
-            Set the constant color of streamlines used for color mode 'ccolor'
+streamlines color <r> <g> <b> <?datasetName?>
+            Set the constant color of streamlines used for color mode 'constant'
 streamlines colormap <colormapName> <?datasetName?>
             Colormap used to color streamlines/tubes/ribbons by vector magnitude
-streamlines colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-            Set the field used to color the streamlines.  'ccolor' means to use
-            the constant color defined by the ccolor subcommand.  'scalar' uses
+streamlines colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+            Set the field used to color the streamlines.  'constant' means to use
+            the constant color defined by the color 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
@@ -812 +856 @@
 streamlines visible <bool> <?datasetName?>
 
+text3d add <textString> <name>
+text3d color <r> <g> <b> <?name?>
+text3d delete <?name?>
+text3d fntfamily <fontName> <?name?>
+text3d fntsize <fontSize> <?name?>
+text3d opacity <opacity> <?name?>
+text3d orient <qw> <qx> <qy> <qz> <?name?>
+text3d origin <x> <y> <z> <?name?>
+text3d pos <x> <y> <z> <?name?>
+text3d scale <sx> <sy> <sz> <?name?>
+text3d visible <bool> <?name?>
+
 volume add <?datasetName?>
 volume colormap <colorMapName> <?datasetName?>
@@ -827 +883 @@
 
 warp add <?dataSetName?>
-warp ccolor <r> <g> <b> <?datasetName?>
+warp color <r> <g> <b> <?datasetName?>
 warp cloudstyle <style> <?datasetName?>
      <style> = mesh | points
 warp colormap <colormapName> <?datasetName?>
-warp colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
-     Set the field used to color the object.  'ccolor' means to use
-     the constant color defined by the ccolor subcommand.  'scalar' uses
+warp colormode <scalar|vmag|vx|vy|vz|constant> <fieldName> <?datasetName?>
+     Set the field used to color the object.  'constant' means to use
+     the constant color defined by the color 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