Changeset 2523

Timestamp:

Sep 18, 2011 10:49:05 PM (12 years ago)

Author:

ldelgass

Message:

Merge 2494:2522 from trunk

Location:

branches/vtkvis_threaded

Files:

• Makefile.in (modified) (5 diffs)
• RpContour3D.cpp (modified) (1 diff)
• RpHeightMap.cpp (modified) (1 diff)
• RpHeightMap.h (modified) (1 diff)
• RpLIC.cpp (modified) (1 diff)
• RpPseudoColor.cpp (modified) (5 diffs)
• RpStreamlines.cpp (modified) (26 diffs)
• RpStreamlines.h (modified) (4 diffs)
• RpVtkRenderServer.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (28 diffs)
• RpVtkRenderer.h (modified) (6 diffs)
• RpVtkRendererCmd.cpp (modified) (16 diffs)
• Trace.cpp (modified) (1 diff)
• Trace.h (modified) (1 diff)
• protocol.txt (modified) (4 diffs)
• vtkRpCubeAxesActor2D.cpp (modified) (2 diffs)
• vtkRpCubeAxesActor2D.h (modified) (1 diff)

branches/vtkvis_threaded/Makefile.in

@@ -47 +47 @@
 DEBUG                   = #yes
 TRACE                   = #yes
-USE_CUSTOM_AXES         = yes
-USE_GPU_RAYCASTING      = yes
-USE_OFFSCREEN_RENDERING = yes
+HAVE_GLYPH3D_MAPPER     = #yes
+USE_CUSTOM_AXES         = yes
+USE_GPU_RAYCASTING      = yes
+USE_OFFSCREEN_RENDERING = yes
 USE_THREADS             = yes
 
@@ -61 +62 @@
 ifdef TRACE
 DEFINES         += -DWANT_TRACE
+endif
+ifdef HAVE_GLYPH3D_MAPPER
+DEFINES         += -DHAVE_GLYPH3D_MAPPER
 endif
 ifdef USE_CUSTOM_AXES
@@ -82 +86 @@
                 RpContour2D.cpp \
                 RpContour3D.cpp \
+                RpCutplane.cpp \
                 RpGlyphs.cpp \
                 RpHeightMap.cpp \
@@ -140 +145 @@
 RpContour2D.o: RpContour2D.h RpVtkGraphicsObject.h RpVtkDataSet.h Trace.h
 RpContour3D.o: RpContour3D.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
+RpCutplane.o: RpCutplane.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
 RpGlyphs.o: RpGlyphs.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
 RpHeightMap.o: RpHeightMap.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
@@ -149 +155 @@
 RpVolume.o: RpVolume.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
 RpVtkDataSet.o: RpVtkDataSet.h Trace.h
-RpVtkRenderer.o: RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
-RpVtkRendererCmd.o: RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
-RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
+RpVtkRenderer.o: RpVtkRenderer.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
+RpVtkRendererCmd.o: RpVtkRenderer.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor2D.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
 Trace.o: Trace.h
 TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h

branches/vtkvis_threaded/RpContour3D.cpp

@@ -172 +172 @@
         _contourMapper->SetResolveCoincidentTopologyToPolygonOffset();
         _contourMapper->SetInputConnection(_contourFilter->GetOutputPort());
+        _contourMapper->SetColorModeToMapScalars();
         getActor()->SetMapper(_contourMapper);
     }

branches/vtkvis_threaded/RpHeightMap.cpp

@@ -91 +91 @@
                 _dataRange[1] = scalarRange[1];
             } else {
-                dataSet->getScalarRange(_dataRange);
+                _dataSet->getScalarRange(_dataRange);
             }
 

branches/vtkvis_threaded/RpHeightMap.h

@@ -73 +73 @@
     void setHeightScale(double scale);
 
+    double getHeightScale()
+    {
+        return _warpScale;
+    }
+
     void setNumContours(int numContours);
 

branches/vtkvis_threaded/RpLIC.cpp

@@ -24 +24 @@
 #include "RpLIC.h"
 #include "Trace.h"
-#include "RpVtkRenderServer.h"
 
 using namespace Rappture::VtkVis;

branches/vtkvis_threaded/RpPseudoColor.cpp

@@ -10 +10 @@
 #include <vtkDataSet.h>
 #include <vtkPointData.h>
+#include <vtkCellData.h>
 #include <vtkDataSetMapper.h>
 #include <vtkUnstructuredGrid.h>
@@ -235 +236 @@
     case COLOR_BY_VECTOR_MAGNITUDE: {
         _dsMapper->ScalarVisibilityOn();
-        _dsMapper->SetScalarModeToUsePointFieldData();
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUsePointFieldData();
             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        } else if (ds->GetCellData() != NULL &&
+                   ds->GetCellData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUseCellFieldData();
+            _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
         }
         if (_lut != NULL) {
@@ -248 +253 @@
     case COLOR_BY_VECTOR_X:
         _dsMapper->ScalarVisibilityOn();
-        _dsMapper->SetScalarModeToUsePointFieldData();
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUsePointFieldData();
             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        } else if (ds->GetCellData() != NULL &&
+                   ds->GetCellData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUseCellFieldData();
+            _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
         }
         if (_lut != NULL) {
@@ -261 +270 @@
     case COLOR_BY_VECTOR_Y:
         _dsMapper->ScalarVisibilityOn();
-        _dsMapper->SetScalarModeToUsePointFieldData();
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUsePointFieldData();
             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        } else if (ds->GetCellData() != NULL &&
+                   ds->GetCellData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUseCellFieldData();
+            _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
         }
         if (_lut != NULL) {
@@ -274 +287 @@
     case COLOR_BY_VECTOR_Z:
         _dsMapper->ScalarVisibilityOn();
-        _dsMapper->SetScalarModeToUsePointFieldData();
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUsePointFieldData();
             _dsMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+        } else if (ds->GetCellData() != NULL &&
+                   ds->GetCellData()->GetVectors() != NULL) {
+            _dsMapper->SetScalarModeToUseCellFieldData();
+            _dsMapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
         }
         if (_lut != NULL) {

branches/vtkvis_threaded/RpStreamlines.cpp

@@ -21 +21 @@
 #include <vtkCellData.h>
 #include <vtkCellDataToPointData.h>
+#include <vtkPolygon.h>
 #include <vtkPolyData.h>
 #include <vtkTubeFilter.h>
@@ -26 +27 @@
 #include <vtkTransform.h>
 #include <vtkTransformPolyDataFilter.h>
+#include <vtkVertexGlyphFilter.h>
 
 #include "RpStreamlines.h"
@@ -123 +125 @@
         _seedActor = vtkSmartPointer<vtkActor>::New();
         _seedActor->GetProperty()->SetColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+        _seedActor->GetProperty()->SetEdgeColor(_seedColor[0], _seedColor[1], _seedColor[2]);
         _seedActor->GetProperty()->SetLineWidth(1);
         _seedActor->GetProperty()->SetPointSize(2);
@@ -172 +175 @@
  */
 void Streamlines::getRandomPointInTriangle(double pt[3],
+                                           const double v0[3],
                                            const double v1[3],
-                                           const double v2[3],
-                                           const double v3[3])
+                                           const double v2[3])
 {
     // Choose random barycentric coordinates
@@ -189 +192 @@
     // Convert to cartesian coords
     for (int i = 0; i < 3; i++) {
-        pt[i] = v1[i] * bary[0] + v2[i] * bary[1] + v3[i] * bary[2];
+        pt[i] = v0[i] * bary[0] + v1[i] * bary[1] + v2[i] * bary[2];
+    }
+}
+
+void Streamlines::getRandomPointInTetrahedron(double pt[3],
+                                              const double v0[3],
+                                              const double v1[3],
+                                              const double v2[3],
+                                              const double v3[3])
+{
+    // Choose random barycentric coordinates
+    double bary[4];
+    bary[0] = getRandomNum(0, 1);
+    bary[1] = getRandomNum(0, 1);
+    bary[2] = getRandomNum(0, 1);
+    if (bary[0] + bary[1] > 1.0) {
+        bary[0] = 1.0 - bary[0];
+        bary[1] = 1.0 - bary[1];
+    }
+    if (bary[1] + bary[2] > 1.0) {
+        double tmp = bary[2];
+        bary[2] = 1.0 - bary[0] - bary[1];
+        bary[1] = 1.0 - tmp;
+    } else if (bary[0] + bary[1] + bary[2] > 1.0) {
+        double tmp = bary[2];
+        bary[2] = bary[0] + bary[1] + bary[2] - 1.0;
+        bary[0] = 1.0 - bary[1] - tmp;
+    }
+    bary[3] = 1.0 - bary[0] - bary[1] - bary[2];
+    TRACE("bary %g %g %g %g", bary[0], bary[1], bary[2], bary[3]);
+    // Convert to cartesian coords
+    for (int i = 0; i < 3; i++) {
+#if 0
+        pt[i] = (v0[i] - v3[i]) * bary[0] +
+                (v1[i] - v3[i]) * bary[1] + 
+                (v2[i] - v3[i]) * bary[2] + v3[i];
+#else
+        pt[i] = v0[i] * bary[0] + v1[i] * bary[1] +
+                v2[i] * bary[2] + v3[i] * bary[3];
+#endif
     }
 }
@@ -209 +251 @@
  * \brief Get a random point within a vtkDataSet's mesh
  *
- * Note: This currently doesn't give a uniform distribution of
- * points in space and can generate points outside the mesh
+ * Note: This currently doesn't always give a uniform distribution 
+ * of points in space and can generate points outside the mesh for
+ * unusual cell types
  */
 void Streamlines::getRandomCellPt(double pt[3], vtkDataSet *ds)
@@ -218 +261 @@
     // all cells are equal area/volume)
     int cell = rand() % numCells;
-    double bounds[6];
-    ds->GetCellBounds(cell, bounds);
-    // Note: point is inside AABB of cell, but may be outside the cell
-    getRandomPoint(pt, bounds);
+    int type = ds->GetCellType(cell);
+    if (type == VTK_VERTEX) {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 1);
+        ds->GetPoint(ptIds->GetId(0), pt);
+    } else if (type == VTK_POLY_VERTEX) {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() >= 1);
+        int id = rand() % ptIds->GetNumberOfIds();
+        ds->GetPoint(ptIds->GetId(id), pt);
+    } else if (type == VTK_LINE) {
+        double v[2][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 2);
+        for (int i = 0; i < 2; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        getRandomPointOnLineSegment(pt, v[0], v[1]);
+    } else if (type == VTK_POLY_LINE) {
+        double v[2][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() >= 2);
+        int id = rand() % (ptIds->GetNumberOfIds()-1);
+        for (int i = 0; i < 2; i++) {
+            ds->GetPoint(ptIds->GetId(id+i), v[i]);
+        }
+        getRandomPointOnLineSegment(pt, v[0], v[1]);
+    } else if (type == VTK_TRIANGLE) {
+        double v[3][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 3);
+        for (int i = 0; i < 3; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+    } else if (type == VTK_TRIANGLE_STRIP) {
+        double v[3][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() >= 3);
+        int id = rand() % (ptIds->GetNumberOfIds()-2);
+        for (int i = 0; i < 3; i++) {
+            ds->GetPoint(ptIds->GetId(id+i), v[i]);
+        }
+        getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+    } else if (type == VTK_POLYGON) {
+        vtkPolygon *poly = vtkPolygon::SafeDownCast(ds->GetCell(cell));
+        assert (poly != NULL);
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        poly->Triangulate(ptIds);
+        assert(ptIds->GetNumberOfIds() >= 3 && ptIds->GetNumberOfIds() % 3 == 0);
+        int tri = rand() % (ptIds->GetNumberOfIds()/3);
+        double v[3][3];
+        for (int i = 0; i < 3; i++) {
+            ds->GetPoint(ptIds->GetId(i + tri * 3), v[i]);
+        }
+        getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+    } else if (type == VTK_QUAD) {
+        double v[4][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 4);
+        for (int i = 0; i < 4; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        int tri = rand() & 0x1;
+        if (tri) {
+            getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+        } else {
+            getRandomPointInTriangle(pt, v[0], v[2], v[3]);
+        }
+    } else if (type == VTK_TETRA) {
+        double v[4][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 4);
+        for (int i = 0; i < 4; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[3]);
+    } else if (type == VTK_HEXAHEDRON) {
+        double v[8][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 8);
+        for (int i = 0; i < 8; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        int tetra = rand() % 5;
+        switch (tetra) {
+        case 0:
+            getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[5]);
+            break;
+        case 1:
+            getRandomPointInTetrahedron(pt, v[0], v[2], v[7], v[3]);
+            break;
+        case 2:
+            getRandomPointInTetrahedron(pt, v[0], v[5], v[7], v[4]);
+            break;
+        case 3:
+            getRandomPointInTetrahedron(pt, v[5], v[2], v[7], v[6]);
+            break;
+        case 4:
+        default:
+            getRandomPointInTetrahedron(pt, v[0], v[2], v[7], v[5]);
+            break;
+        }
+    } else if (type == VTK_WEDGE) {
+        double v[6][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 6);
+        for (int i = 0; i < 6; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        double vv[3][3];
+        getRandomPointOnLineSegment(vv[0], v[0], v[3]);
+        getRandomPointOnLineSegment(vv[1], v[1], v[4]);
+        getRandomPointOnLineSegment(vv[2], v[2], v[5]);
+        getRandomPointInTriangle(pt, vv[0], vv[1], vv[2]);
+    } else if (type == VTK_PYRAMID) {
+        double v[5][3];
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 5);
+        for (int i = 0; i < 5; i++) {
+            ds->GetPoint(ptIds->GetId(i), v[i]);
+        }
+        int tetra = rand() & 0x1;
+        if (tetra) {
+            getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[4]);
+        } else {
+            getRandomPointInTetrahedron(pt, v[0], v[2], v[3], v[4]);
+        }
+    } else {
+        double bounds[6];
+        ds->GetCellBounds(cell, bounds);
+        // Note: For pixel/voxel cells, this is exact.  However, if the cell is
+        // not an axis aligned box, the point may be outside the cell
+        getRandomPoint(pt, bounds);
+    }
 }
 
@@ -237 +422 @@
     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 maxBound = 0.0;
-    if (bounds[1] - bounds[0] > maxBound) {
-        maxBound = bounds[1] - bounds[0];
-    }
-    if (bounds[3] - bounds[2] > maxBound) {
-        maxBound = bounds[3] - bounds[2];
-    }
-    if (bounds[5] - bounds[4] > maxBound) {
-        maxBound = bounds[5] - bounds[4];
+    if (xLen > maxBound) {
+        maxBound = xLen;
+    }
+    if (yLen > maxBound) {
+        maxBound = yLen;
+    }
+    if (zLen > maxBound) {
+        maxBound = zLen;
     }
 
@@ -276 +464 @@
 
     _streamTracer->SetInput(ds);
-    _streamTracer->SetMaximumPropagation(maxBound);
+    _streamTracer->SetMaximumPropagation(xLen + yLen + zLen);
+    _streamTracer->SetIntegratorTypeToRungeKutta45();
+
+    TRACE("Setting streamlines max length to %g", 
+          _streamTracer->GetMaximumPropagation());
 
     if (_pdMapper == NULL) {
@@ -286 +478 @@
         _seedMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
         _seedMapper->SetResolveCoincidentTopologyToPolygonOffset();
+        _seedMapper->ScalarVisibilityOff();
     }
 
     // Set up seed source object
-    setSeedToRandomPoints(200);
+    setSeedToFilledMesh(200);
 
     switch (_lineType) {
@@ -343 +536 @@
 
 /**
- * \brief Use randomly distributed seed points
+ * \brief Use points of the DataSet associated with this 
+ * Streamlines as seeds
+ */
+void Streamlines::setSeedToMeshPoints()
+{
+    setSeedToMeshPoints(_dataSet->getVtkDataSet());
+}
+
+/**
+ * \brief Use seed points randomly distributed within the cells 
+ * of the DataSet associated with this Streamlines
  *
  * Note: The current implementation doesn't give a uniform 
@@ -351 +554 @@
  * \param[in] numPoints Number of random seed points to generate
  */
-void Streamlines::setSeedToRandomPoints(int numPoints)
+void Streamlines::setSeedToFilledMesh(int numPoints)
+{
+    setSeedToFilledMesh(_dataSet->getVtkDataSet(), numPoints);
+}
+
+/**
+ * \brief Use points of a supplied vtkDataSet as seeds
+ *
+ * \param[in] seed vtkDataSet with points to use as seeds
+ */
+void Streamlines::setSeedToMeshPoints(vtkDataSet *seed)
+{
+    if (_streamTracer != NULL) {
+        TRACE("Seed points: %d", seed->GetNumberOfPoints());
+        vtkSmartPointer<vtkDataSet> oldSeed;
+        if (_streamTracer->GetSource() != NULL) {
+            oldSeed = _streamTracer->GetSource();
+        }
+
+        _streamTracer->SetSource(seed);
+        if (oldSeed != NULL) {
+            oldSeed->SetPipelineInformation(NULL);
+        }
+
+        if (vtkPolyData::SafeDownCast(seed) != NULL) {
+            _seedMapper->SetInput(vtkPolyData::SafeDownCast(seed));
+        } else {
+            vtkSmartPointer<vtkVertexGlyphFilter> vertFilter = vtkSmartPointer<vtkVertexGlyphFilter>::New();
+            vertFilter->SetInput(seed);
+            _seedMapper->SetInputConnection(vertFilter->GetOutputPort());
+        }
+    }
+}
+
+/**
+ * \brief Use seed points randomly distributed within the cells 
+ * of a supplied vtkDataSet
+ *
+ * Note: The current implementation doesn't give a uniform 
+ * distribution of points, and points outside the mesh bounds
+ * may be generated
+ *
+ * \param[in] ds vtkDataSet containing cells
+ * \param[in] numPoints Number of random seed points to generate
+ */
+void Streamlines::setSeedToFilledMesh(vtkDataSet *ds, int numPoints)
 {
     if (_streamTracer != NULL) {
@@ -359 +607 @@
         vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
 
+        if (ds->GetNumberOfCells() < 1) {
+            ERROR("No cells in mesh");
+        }
+
         for (int i = 0; i < numPoints; i++) {
             double pt[3];
-            getRandomCellPt(pt, _dataSet->getVtkDataSet());
-            TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
+            getRandomCellPt(pt, ds);
+            //TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
             pts->InsertNextPoint(pt);
             cells->InsertNextCell(1);
@@ -415 +667 @@
                 pt[ii] = start[ii] + dir[ii] * ((double)i / (numPoints-1));
             }
-            TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
+            //TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
             pts->InsertNextPoint(pt);
             polyline->GetPointIds()->SetId(i, i);
@@ -507 +759 @@
                 pt[i] = center[i] + r * (px[i] * cos(angle) + py[i] * sin(angle));
             }
-            TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
+            //TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
             pts->InsertNextPoint(pt);
             cells->InsertNextCell(1);
@@ -662 +914 @@
                                                     py[i] * sin(theta));
             }
-            TRACE("Vert %d: %g %g %g", j, verts[j][0], verts[j][1], verts[j][2]);
+            //TRACE("Vert %d: %g %g %g", j, verts[j][0], verts[j][1], verts[j][2]);
         }
 
@@ -671 +923 @@
                 double pt[3];
                 getRandomPointInTriangle(pt, verts[0], verts[1], verts[2]);
-                TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
+                //TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
                 pts->InsertNextPoint(pt);
                 cells->InsertNextCell(1);
@@ -682 +934 @@
                 double pt[3];
                 getRandomPointInTriangle(pt, center, verts[tri], verts[(tri+1) % numSides]);
-                TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
+                //TRACE("Seed pt: %g %g %g", pt[0], pt[1], pt[2]);
                 pts->InsertNextPoint(pt);
                 cells->InsertNextCell(1);
@@ -708 +960 @@
 
 /**
- * \brief Set maximum length of stream lines in world coordinates
+ * \brief Set the integration method used
+ */
+void Streamlines::setIntegrator(IntegratorType integrator)
+{
+    if (_streamTracer != NULL) {
+        switch (integrator) {
+        case RUNGE_KUTTA2:
+            _streamTracer->SetIntegratorTypeToRungeKutta2();
+            break;
+        case RUNGE_KUTTA4:
+            _streamTracer->SetIntegratorTypeToRungeKutta4();
+            break;
+        case RUNGE_KUTTA45:
+            _streamTracer->SetIntegratorTypeToRungeKutta45();
+            break;
+        default:
+            ;
+        }
+    }
+}
+
+/**
+ * \brief Set the direction of integration
+ */
+void Streamlines::setIntegrationDirection(IntegrationDirection dir)
+{
+    if (_streamTracer != NULL) {
+        switch (dir) {
+        case FORWARD:
+            _streamTracer->SetIntegrationDirectionToForward();
+            break;
+        case BACKWARD:
+            _streamTracer->SetIntegrationDirectionToBackward();
+            break;
+        case BOTH:
+            _streamTracer->SetIntegrationDirectionToBoth();
+            break;
+        default:
+            ;
+        }
+    }
+}
+
+/**
+ * \brief Set the step size units.  Length units are world 
+ * coordinates, and cell units means steps are from cell to 
+ * cell.  Default is cell units.
+ *
+ * Note: calling this function will not convert existing
+ * initial, minimum or maximum step value settings to the
+ * new units, so this function should be called before 
+ * setting step values.
+ */
+void Streamlines::setIntegrationStepUnit(StepUnit unit)
+{
+    if (_streamTracer != NULL) {
+        switch (unit) {
+        case LENGTH_UNIT:
+            _streamTracer->SetIntegrationStepUnit(vtkStreamTracer::LENGTH_UNIT);
+            break;
+        case CELL_LENGTH_UNIT:
+            _streamTracer->SetIntegrationStepUnit(vtkStreamTracer::CELL_LENGTH_UNIT);
+            break;
+        default:
+            ;
+        }
+    }
+}
+
+/**
+ * \brief Set initial step size for adaptive step integrator in 
+ * step units (see setIntegrationStepUnit).  For non-adaptive
+ * integrators, this is the fixed step size.
+ */
+void Streamlines::setInitialIntegrationStep(double step)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetInitialIntegrationStep(step);
+    }
+}
+
+/**
+ * \brief Set minimum step for adaptive step integrator in 
+ * step units (see setIntegrationStepUnit)
+ */
+void Streamlines::setMinimumIntegrationStep(double step)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetMinimumIntegrationStep(step);
+    }
+}
+
+/**
+ * \brief Set maximum step for adaptive step integrator in 
+ * step units (see setIntegrationStepUnit)
+ */
+void Streamlines::setMaximumIntegrationStep(double step)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetMaximumIntegrationStep(step);
+    }
+}
+
+/**
+ * \brief Set maximum error tolerance
+ */
+void Streamlines::setMaximumError(double error)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetMaximumError(error);
+    }
+}
+
+/**
+ * \brief Set maximum length of stream lines in world
+ * coordinates
  */
 void Streamlines::setMaxPropagation(double length)
@@ -714 +1081 @@
     if (_streamTracer != NULL) {
         _streamTracer->SetMaximumPropagation(length);
+    }
+}
+
+/**
+ * \brief Set maximum number of integration steps
+ */
+void Streamlines::setMaxNumberOfSteps(int steps)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetMaximumNumberOfSteps(steps);
+    }
+}
+
+/**
+ * \brief Set the minimum speed before integration stops
+ */
+void Streamlines::setTerminalSpeed(double speed)
+{
+    if (_streamTracer != NULL) {
+        _streamTracer->SetTerminalSpeed(speed);
     }
 }
@@ -820 +1207 @@
         return;
 
-    vtkDataSet *ds = _dataSet->getVtkDataSet();
-
     switch (mode) {
     case COLOR_BY_SCALAR: {
@@ -834 +1219 @@
         _pdMapper->ScalarVisibilityOn();
         _pdMapper->SetScalarModeToUsePointFieldData();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        }
+        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
             _lut->SetRange(_vectorMagnitudeRange);
@@ -847 +1229 @@
         _pdMapper->ScalarVisibilityOn();
         _pdMapper->SetScalarModeToUsePointFieldData();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        }
+        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
             _lut->SetRange(_vectorComponentRange[0]);
@@ -860 +1239 @@
         _pdMapper->ScalarVisibilityOn();
         _pdMapper->SetScalarModeToUsePointFieldData();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        }
+        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
             _lut->SetRange(_vectorComponentRange[1]);
@@ -873 +1249 @@
         _pdMapper->ScalarVisibilityOn();
         _pdMapper->SetScalarModeToUsePointFieldData();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _pdMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        }
+        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
             _lut->SetRange(_vectorComponentRange[2]);
@@ -1058 +1431 @@
     _seedColor[1] = color[1];
     _seedColor[2] = color[2];
-    if (_seedActor != NULL)
+    if (_seedActor != NULL) {
         _seedActor->GetProperty()->SetColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+        _seedActor->GetProperty()->SetEdgeColor(_seedColor[0], _seedColor[1], _seedColor[2]);
+    }
 }
 

branches/vtkvis_threaded/RpStreamlines.h

@@ -44 +44 @@
         COLOR_CONSTANT
     };
+    enum StepUnit {
+        LENGTH_UNIT,
+        CELL_LENGTH_UNIT
+    };
+    enum IntegratorType {
+        RUNGE_KUTTA2,
+        RUNGE_KUTTA4,
+        RUNGE_KUTTA45
+    };
+    enum IntegrationDirection {
+        FORWARD,
+        BACKWARD,
+        BOTH
+    };
 
     Streamlines();
@@ -77 +91 @@
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
 
-    void setSeedToRandomPoints(int numPoints);
+    void setSeedToMeshPoints();
+
+    void setSeedToFilledMesh(int numPoints);
+
+    void setSeedToMeshPoints(vtkDataSet *ds);
+
+    void setSeedToFilledMesh(vtkDataSet *ds, int numPoints);
 
     void setSeedToRake(double start[3], double end[3], int numPoints);
@@ -92 +112 @@
                                 int numSides, int numPoints);
 
+    void setIntegrator(IntegratorType integrator);
+
+    void setIntegrationDirection(IntegrationDirection dir);
+
+    void setIntegrationStepUnit(StepUnit unit);
+
+    void setInitialIntegrationStep(double step);
+
+    void setMinimumIntegrationStep(double step);
+
+    void setMaximumIntegrationStep(double step);
+
+    void setMaximumError(double error);
+
     void setMaxPropagation(double length);
+
+    void setMaxNumberOfSteps(int steps);
+
+    void setTerminalSpeed(double speed);
 
     void setLineTypeToLines();
@@ -130 +168 @@
     static void getRandomPoint(double pt[3], const double bounds[6]);
     static void getRandomPointInTriangle(double pt[3],
+                                         const double v0[3],
                                          const double v1[3],
-                                         const double v2[3],
-                                         const double v3[3]);
+                                         const double v2[3]);
     static void getRandomPointOnLineSegment(double pt[3],
                                             const double endpt[3],
                                             const double endpt2[3]);
+    static void getRandomPointInTetrahedron(double pt[3],
+                                            const double v0[3],
+                                            const double v1[3],
+                                            const double v2[3],
+                                            const double v3[3]);
     static void getRandomCellPt(double pt[3], vtkDataSet *ds);
 

branches/vtkvis_threaded/RpVtkRenderServer.h

@@ -9 +9 @@
 #define __RAPPTURE_VTKVIS_RENDERSERVER_H__
 
-#include "RpVtkRenderer.h"
-
 namespace Rappture {
 namespace VtkVis {
+
+class Renderer;
 
 extern int g_fdIn;

branches/vtkvis_threaded/RpVtkRenderer.cpp

@@ -158 +158 @@
     }
     _contour3Ds.clear();
+    TRACE("Deleting Cutplanes");
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+             itr != _cutplanes.end(); ++itr) {
+        delete itr->second;
+    }
+    _cutplanes.clear();
     TRACE("Deleting Glyphs");
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
@@ -314 +320 @@
 
 /**
+ * \brief Remove the Cutplane for the specified DataSet
+ *
+ * The underlying Cutplane is deleted, freeing its memory
+ */
+void Renderer::deleteCutplane(const DataSetId& id)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    TRACE("Deleting Cutplanes for %s", id.c_str());
+
+    do {
+        Cutplane *cutplane = itr->second;
+        if (cutplane->getProp())
+            _renderer->RemoveViewProp(cutplane->getProp());
+        delete cutplane;
+
+        itr = _cutplanes.erase(itr);
+    } while (doAll && itr != _cutplanes.end());
+
+    _renderer->ResetCameraClippingRange();
+    _needsRedraw = true;
+}
+
+/**
  * \brief Remove the Glyphs for the specified DataSet
  *
@@ -637 +680 @@
         deleteContour2D(itr->second->getName());
         deleteContour3D(itr->second->getName());
+        deleteCutplane(itr->second->getName());
         deleteGlyphs(itr->second->getName());
         deleteHeightMap(itr->second->getName());
@@ -858 +902 @@
     // Don't offset labels at origin
     _cubeAxesActor->SetCornerOffset(0);
-    _cubeAxesActor->SetFlyModeToClosestTriad();
+    _cubeAxesActor->SetFlyModeToStaticTriad();
 
 #ifdef USE_CUSTOM_AXES
@@ -1213 +1257 @@
         }
     }
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+         itr != _cutplanes.end(); ++itr) {
+        if (itr->second->getColorMap() == cmap) {
+            itr->second->updateColorMap();
+            _needsRedraw = true;
+        }
+    }
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
          itr != _glyphs.end(); ++itr) {
@@ -1271 +1322 @@
     for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
          itr != _contour3Ds.end(); ++itr) {
+        if (itr->second->getColorMap() == cmap)
+            return true;
+    }
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+         itr != _cutplanes.end(); ++itr) {
         if (itr->second->getColorMap() == cmap)
             return true;
@@ -2197 +2253 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -2672 +2726 @@
 
 /**
+ * \brief Create a new Cutplane and associate it with the named DataSet
+ */
+bool Renderer::addCutplane(const DataSetId& id)
+{
+    DataSetHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _dataSets.begin();
+    } else {
+        itr = _dataSets.find(id);
+    }
+    if (itr == _dataSets.end()) {
+        ERROR("Unknown dataset %s", id.c_str());
+        return false;
+    }
+
+    do {
+        DataSet *ds = itr->second;
+        const DataSetId& dsID = ds->getName();
+
+        if (getCutplane(dsID)) {
+            WARN("Replacing existing Cutplane %s", dsID.c_str());
+            deleteCutplane(dsID);
+        }
+
+        Cutplane *cutplane = new Cutplane();
+        _cutplanes[dsID] = cutplane;
+
+        cutplane->setDataSet(ds,
+                             _useCumulativeRange, 
+                             _cumulativeScalarRange,
+                             _cumulativeVectorMagnitudeRange,
+                             _cumulativeVectorComponentRange);
+
+        _renderer->AddViewProp(cutplane->getProp());
+    } while (doAll && ++itr != _dataSets.end());
+
+    _needsRedraw = true;
+    return true;
+}
+
+/**
+ * \brief Get the Cutplane associated with a named DataSet
+ */
+Cutplane *Renderer::getCutplane(const DataSetId& id)
+{
+    CutplaneHashmap::iterator itr = _cutplanes.find(id);
+
+    if (itr == _cutplanes.end()) {
+#ifdef DEBUG
+        TRACE("Cutplane not found: %s", id.c_str());
+#endif
+        return NULL;
+    } else
+        return itr->second;
+}
+
+/**
+ * \brief Set an additional transform on the prop
+ */
+void Renderer::setCutplaneTransform(const DataSetId& id, vtkMatrix4x4 *trans)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setTransform(trans);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a quaternion
+ */
+void Renderer::setCutplaneOrientation(const DataSetId& id, double quat[4])
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(quat);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop orientation with a rotation about an axis
+ */
+void Renderer::setCutplaneOrientation(const DataSetId& id, double angle, double axis[3])
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOrientation(angle, axis);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop position in world coords
+ */
+void Renderer::setCutplanePosition(const DataSetId& id, double pos[3])
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setPosition(pos);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the prop scaling
+ */
+void Renderer::setCutplaneScale(const DataSetId& id, double scale[3])
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setScale(scale);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    resetAxes();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the volume slice used for mapping volumetric data
+ */
+void Renderer::setCutplaneVolumeSlice(const DataSetId& id, Cutplane::Axis axis, double ratio)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->selectVolumeSlice(axis, ratio);
+     } while (doAll && ++itr != _cutplanes.end());
+
+    _renderer->ResetCameraClippingRange();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Associate an existing named color map with a Cutplane for the given DataSet
+ */
+void Renderer::setCutplaneColorMap(const DataSetId& id, const ColorMapId& colorMapId)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    ColorMap *cmap = getColorMap(colorMapId);
+    if (cmap == NULL) {
+        ERROR("Unknown colormap: %s", colorMapId.c_str());
+        return;
+    }
+
+    do {
+        TRACE("Set Cutplane color map: %s for dataset %s", colorMapId.c_str(),
+              itr->second->getDataSet()->getName().c_str());
+
+        itr->second->setColorMap(cmap);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the color mode for the specified DataSet
+ */
+void Renderer::setCutplaneColorMode(const DataSetId& id, Cutplane::ColorMode mode)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setColorMode(mode);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set opacity of height map for the given DataSet
+ */
+void Renderer::setCutplaneOpacity(const DataSetId& id, double opacity)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setOpacity(opacity);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering height map for the given DataSet
+ */
+void Renderer::setCutplaneVisibility(const DataSetId& id, bool state)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setVisibility(state);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set wireframe rendering for the specified DataSet
+ */
+void Renderer::setCutplaneWireframe(const DataSetId& id, bool state)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setWireframe(state);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn on/off rendering height map mesh edges for the given DataSet
+ */
+void Renderer::setCutplaneEdgeVisibility(const DataSetId& id, bool state)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeVisibility(state);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the RGB height map mesh edge color for the specified DataSet
+ */
+void Renderer::setCutplaneEdgeColor(const DataSetId& id, float color[3])
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeColor(color);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the height map mesh edge width for the specified DataSet (may be a no-op)
+ *
+ * If the OpenGL implementation/hardware does not support wide lines, 
+ * this function may not have an effect.
+ */
+void Renderer::setCutplaneEdgeWidth(const DataSetId& id, float edgeWidth)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setEdgeWidth(edgeWidth);
+    } while (doAll && ++itr != _cutplanes.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Turn height map lighting on/off for the specified DataSet
+ */
+void Renderer::setCutplaneLighting(const DataSetId& id, bool state)
+{
+    CutplaneHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _cutplanes.begin();
+        doAll = true;
+    } else {
+        itr = _cutplanes.find(id);
+    }
+    if (itr == _cutplanes.end()) {
+        ERROR("Cutplane not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setLighting(state);
+    } while (doAll && ++itr != _cutplanes.end());
+    _needsRedraw = true;
+}
+
+/**
  * \brief Create a new Glyphs and associate it with the named DataSet
  */
@@ -2717 +3255 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3322 +3858 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3376 +3910 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3561 +4093 @@
     }
 
+    bool initCam = false;
     do {
         itr->second->selectVolumeSlice(axis, ratio);
+        if (itr->second->getHeightScale() > 0.0)
+            initCam = true;
      } while (doAll && ++itr != _heightMaps.end());
 
-    initCamera();
+    if (initCam)
+        initCamera();
+    else
+        _renderer->ResetCameraClippingRange();
     _needsRedraw = true;
 }
@@ -4032 +4570 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -4220 +4756 @@
      } while (doAll && ++itr != _lics.end());
 
-    initCamera();
+    _renderer->ResetCameraClippingRange();
     _needsRedraw = true;
 }
@@ -4462 +4998 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -4971 +5505 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -6073 +6605 @@
 
 /**
+ * \brief Set the streamlines seed to points of the streamlines DataSet
+ */
+void Renderer::setStreamlinesSeedToMeshPoints(const DataSetId& id)
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setSeedToMeshPoints();
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the streamlines seed to points distributed randomly inside
+ * cells of the streamlines DataSet
+ */
+void Renderer::setStreamlinesSeedToFilledMesh(const DataSetId& id, int numPoints)
+{
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return;
+    }
+
+    do {
+        itr->second->setSeedToFilledMesh(numPoints);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the streamlines seed to points of a DataSet
+ *
+ * \param[in] id DataSet identifier
+ * \param[in] data Bytes of VTK DataSet file
+ * \param[in] nbytes Length of data array
+ *
+ * \return boolean indicating success or failure
+ */
+bool Renderer::setStreamlinesSeedToMeshPoints(const DataSetId& id,
+                                              char *data, size_t nbytes)
+{
+    vtkSmartPointer<vtkDataSetReader> reader = vtkSmartPointer<vtkDataSetReader>::New();
+    vtkSmartPointer<vtkCharArray> dataSetString = vtkSmartPointer<vtkCharArray>::New();
+
+    dataSetString->SetArray(data, nbytes, 1);
+    reader->SetInputArray(dataSetString);
+    reader->ReadFromInputStringOn();
+    reader->Update();
+
+    vtkSmartPointer<vtkDataSet> dataSet = reader->GetOutput();
+    if (dataSet == NULL) {
+        return false;
+    }
+    dataSet->SetPipelineInformation(NULL);
+
+    StreamlinesHashmap::iterator itr;
+
+    bool doAll = false;
+
+    if (id.compare("all") == 0) {
+        itr = _streamlines.begin();
+        doAll = true;
+    } else {
+        itr = _streamlines.find(id);
+    }
+    if (itr == _streamlines.end()) {
+        ERROR("Streamlines not found: %s", id.c_str());
+        return false;
+    }
+
+    do {
+        itr->second->setSeedToMeshPoints(dataSet);
+    } while (doAll && ++itr != _streamlines.end());
+
+    _needsRedraw = true;
+    return true;
+}
+
+/**
  * \brief Set the streamlines seed to points distributed randomly inside
  * cells of DataSet
- */
-void Renderer::setStreamlinesSeedToRandomPoints(const DataSetId& id, int numPoints)
-{
+ *
+ * \param[in] id DataSet identifier
+ * \param[in] data Bytes of VTK DataSet file
+ * \param[in] nbytes Length of data array
+ * \param[in] numPoints Number of random seed points to generate
+ *
+ * \return boolean indicating success or failure
+ */
+bool Renderer::setStreamlinesSeedToFilledMesh(const DataSetId& id,
+                                              char *data, size_t nbytes,
+                                              int numPoints)
+{
+    vtkSmartPointer<vtkDataSetReader> reader = vtkSmartPointer<vtkDataSetReader>::New();
+    vtkSmartPointer<vtkCharArray> dataSetString = vtkSmartPointer<vtkCharArray>::New();
+
+    dataSetString->SetArray(data, nbytes, 1);
+    reader->SetInputArray(dataSetString);
+    reader->ReadFromInputStringOn();
+    reader->Update();
+
+    vtkSmartPointer<vtkDataSet> dataSet = reader->GetOutput();
+    if (dataSet == NULL) {
+        return false;
+    }
+    dataSet->SetPipelineInformation(NULL);
+
     StreamlinesHashmap::iterator itr;
 
@@ -6090 +6749 @@
     if (itr == _streamlines.end()) {
         ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setSeedToRandomPoints(numPoints);
+        return false;
+    }
+
+    do {
+        itr->second->setSeedToFilledMesh(dataSet, numPoints);
     } while (doAll && ++itr != _streamlines.end());
 
     _needsRedraw = true;
+    return true;
 }
 
@@ -6681 +7341 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -7416 +8074 @@
             _cameraOrientation[3] = 0.0;
         }
-        setViewAngle(_windowHeight);
+        //setViewAngle(_windowHeight);
         double bounds[6];
         collectBounds(bounds, false);
@@ -7952 +8610 @@
             mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
     }
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+             itr != _cutplanes.end(); ++itr) {
+        if ((!onlyVisible || itr->second->getVisibility()) &&
+            itr->second->getProp() != NULL)
+            mergeBounds(bounds, bounds, itr->second->getProp()->GetBounds());
+    }
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
              itr != _glyphs.end(); ++itr) {
@@ -8048 +8712 @@
     for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
          itr != _contour3Ds.end(); ++itr) {
+        itr->second->updateRanges(_useCumulativeRange, 
+                                  _cumulativeScalarRange,
+                                  _cumulativeVectorMagnitudeRange,
+                                  _cumulativeVectorComponentRange);
+    }
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+         itr != _cutplanes.end(); ++itr) {
         itr->second->updateRanges(_useCumulativeRange, 
                                   _cumulativeScalarRange,
@@ -8383 +9054 @@
     if (id.compare("all") == 0 || getContour3D(id) != NULL)
         setContour3DOpacity(id, opacity);
+    if (id.compare("all") == 0 || getCutplane(id) != NULL)
+        setCutplaneOpacity(id, opacity);
     if (id.compare("all") == 0 || getGlyphs(id) != NULL)
         setGlyphsOpacity(id, opacity);
@@ -8431 +9104 @@
     if (id.compare("all") == 0 || getContour3D(id) != NULL)
         setContour3DVisibility(id, state);
+   if (id.compare("all") == 0 || getCutplane(id) != NULL)
+        setCutplaneVisibility(id, state);
     if (id.compare("all") == 0 || getGlyphs(id) != NULL)
         setGlyphsVisibility(id, state);
@@ -8537 +9212 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[1] == NULL) {
                     _userClipPlanes[1] = vtkSmartPointer<vtkPlane>::New();
@@ -8560 +9235 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[3] == NULL) {
                     _userClipPlanes[3] = vtkSmartPointer<vtkPlane>::New();
@@ -8583 +9258 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[5] == NULL) {
                     _userClipPlanes[5] = vtkSmartPointer<vtkPlane>::New();
@@ -8639 +9314 @@
         itr->second->setClippingPlanes(_activeClipPlanes);
     }
+    for (CutplaneHashmap::iterator itr = _cutplanes.begin();
+         itr != _cutplanes.end(); ++itr) {
+        itr->second->setClippingPlanes(_activeClipPlanes);
+    }
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
          itr != _glyphs.end(); ++itr) {

branches/vtkvis_threaded/RpVtkRenderer.h

@@ -29 +29 @@
 #include "RpContour2D.h"
 #include "RpContour3D.h"
+#include "RpCutplane.h"
 #include "RpGlyphs.h"
 #include "RpHeightMap.h"
@@ -101 +102 @@
     typedef std::tr1::unordered_map<DataSetId, Contour2D *> Contour2DHashmap;
     typedef std::tr1::unordered_map<DataSetId, Contour3D *> Contour3DHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Cutplane *> CutplaneHashmap;
     typedef std::tr1::unordered_map<DataSetId, Glyphs *> GlyphsHashmap;
     typedef std::tr1::unordered_map<DataSetId, HeightMap *> HeightMapHashmap;
@@ -164 +166 @@
     void setViewAngle(int height);
 
+    vtkCamera *getVtkCamera()
+    {
+        if (_renderer != NULL)
+            return _renderer->GetActiveCamera();
+        else
+            return NULL;
+    }
+
     void setCameraMode(CameraMode mode);
 
@@ -333 +343 @@
     void setContour3DColorMap(const DataSetId& id, const ColorMapId& colorMapId);
 
+    // Cutplanes
+
+    bool addCutplane(const DataSetId& id);
+    
+    void deleteCutplane(const DataSetId& id);
+
+    Cutplane *getCutplane(const DataSetId& id);
+
+    void setCutplaneTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    void setCutplaneOrientation(const DataSetId& id, double quat[4]);
+
+    void setCutplaneOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    void setCutplanePosition(const DataSetId& id, double pos[3]);
+
+    void setCutplaneScale(const DataSetId& id, double scale[3]);
+
+    void setCutplaneEdgeVisibility(const DataSetId& id, bool state);
+
+    void setCutplaneEdgeColor(const DataSetId& id, float color[3]);
+
+    void setCutplaneEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    void setCutplaneLighting(const DataSetId& id, bool state);
+
+    void setCutplaneOpacity(const DataSetId& id, double opacity);
+
+    void setCutplaneVisibility(const DataSetId& id, bool state);
+
+    void setCutplaneWireframe(const DataSetId& id, bool state);
+
+    void setCutplaneVolumeSlice(const DataSetId& id, Cutplane::Axis axis, double ratio);
+
+    void setCutplaneColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    void setCutplaneColorMode(const DataSetId& id, Cutplane::ColorMode mode);
+
     // Glyphs
 
@@ -611 +659 @@
     void setStreamlinesVisibility(const DataSetId& id, bool state);
 
-    void setStreamlinesSeedToRandomPoints(const DataSetId& id, int numPoints);
+    void setStreamlinesSeedToMeshPoints(const DataSetId& id);
+
+    void setStreamlinesSeedToFilledMesh(const DataSetId& id, int numPoints);
+
+    bool setStreamlinesSeedToMeshPoints(const DataSetId& id,
+                                        char *data, size_t nbytes);
+
+    bool setStreamlinesSeedToFilledMesh(const DataSetId& id,
+                                        char *data, size_t nbytes,
+                                        int numPoints);
 
     void setStreamlinesSeedToRake(const DataSetId& id,
@@ -745 +802 @@
     Contour2DHashmap _contour2Ds;
     Contour3DHashmap _contour3Ds;
+    CutplaneHashmap _cutplanes;
     GlyphsHashmap _glyphs;
     HeightMapHashmap _heightMaps;

branches/vtkvis_threaded/RpVtkRendererCmd.cpp

@@ -21 +21 @@
 #include "RpVtkRendererCmd.h"
 #include "RpVtkRenderServer.h"
+#include "RpVtkRenderer.h"
 #include "PPMWriter.h"
 #include "TGAWriter.h"
@@ -63 +64 @@
 
 #endif  /*USE_THREADS*/
+
+static size_t
+SocketRead(void *bytes, size_t len)
+{
+#ifdef notdef
+    size_t ofs = 0;
+    ssize_t bytesRead = 0;
+    while ((bytesRead = read(g_fdIn, bytes + ofs, len - ofs)) > 0) {
+        ofs += bytesRead;
+        if (ofs == len)
+            break;
+    }
+    TRACE("bytesRead: %lu", ofs);
+    return ofs;
+#else
+    size_t bytesRead = fread(bytes, 1, len, g_fIn);
+    TRACE("bytesRead: %lu", bytesRead);
+    return bytesRead;
+#endif
+}
 
 static int
@@ -203 +224 @@
 {
     const char *title = Tcl_GetString(objv[3]);
+    if (strlen(title) > 30) {
+        Tcl_AppendResult(interp, "axis name \"", title,
+                         "\" is too long", (char*)NULL);
+        return TCL_ERROR;
+    }
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
@@ -270 +296 @@
 {
     const char *units = Tcl_GetString(objv[3]);
+    if (strlen(units) > 10) {
+        Tcl_AppendResult(interp, "axis units name \"", units,
+                         "\" is too long", (char*)NULL);
+        return TCL_ERROR;
+    }
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
@@ -277 +308 @@
         g_renderer->setAxisUnits(Renderer::Y_AXIS, units);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        g_renderer->setAxisUnits(Renderer::Z_AXIS, units);
+    } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
+        g_renderer->setAxisUnits(Renderer::X_AXIS, units);
+        g_renderer->setAxisUnits(Renderer::Y_AXIS, units);
         g_renderer->setAxisUnits(Renderer::Z_AXIS, units);
     } else {
@@ -1266 +1301 @@
 
 static int
+CutplaneAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+              Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        if (!g_renderer->addCutplane(name)) {
+            Tcl_AppendResult(interp, "Failed to create cutplane", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->addCutplane("all")) {
+            Tcl_AppendResult(interp, "Failed to create cutplane for one or more data sets", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneColorMapOp(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->setCutplaneColorMap(dataSetName, colorMapName);
+    } else {
+        g_renderer->setCutplaneColorMap("all", colorMapName);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneColorModeOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    Cutplane::ColorMode mode;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 's' && strcmp(str, "scalar") == 0) {
+        mode = Cutplane::COLOR_BY_SCALAR;
+    } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
+        mode = Cutplane::COLOR_BY_VECTOR_MAGNITUDE;
+    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
+        mode = Cutplane::COLOR_BY_VECTOR_X;
+    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
+        mode = Cutplane::COLOR_BY_VECTOR_Y;
+    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
+        mode = Cutplane::COLOR_BY_VECTOR_Z;
+    } else {
+        Tcl_AppendResult(interp, "bad color mode option \"", str,
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setCutplaneColorMode(name, mode);
+    } else {
+        g_renderer->setCutplaneColorMode("all", mode);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                 Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteCutplane(name);
+    } else {
+        g_renderer->deleteCutplane("all");
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneEdgeVisibilityOp(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->setCutplaneEdgeVisibility(name, state);
+    } else {
+        g_renderer->setCutplaneEdgeVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneLightingOp(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->setCutplaneLighting(name, state);
+    } else {
+        g_renderer->setCutplaneLighting("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneLineColorOp(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->setCutplaneEdgeColor(name, color);
+    } else {
+        g_renderer->setCutplaneEdgeColor("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setCutplaneEdgeWidth(name, width);
+    } else {
+        g_renderer->setCutplaneEdgeWidth("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneOpacityOp(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->setCutplaneOpacity(name, opacity);
+    } else {
+        g_renderer->setCutplaneOpacity("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneOrientOp(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->setCutplaneOrientation(name, quat);
+    } else {
+        g_renderer->setCutplaneOrientation("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplanePositionOp(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->setCutplanePosition(name, pos);
+    } else {
+        g_renderer->setCutplanePosition("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneScaleOp(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->setCutplaneScale(name, scale);
+    } else {
+        g_renderer->setCutplaneScale("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneVisibleOp(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->setCutplaneVisibility(name, state);
+    } else {
+        g_renderer->setCutplaneVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneVolumeSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    double ratio;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &ratio) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    Cutplane::Axis axis;
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        axis = Cutplane::X_AXIS;
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        axis = Cutplane::Y_AXIS;
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        axis = Cutplane::Z_AXIS;
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName ratio", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setCutplaneVolumeSlice(name, axis, ratio);
+    } else {
+        g_renderer->setCutplaneVolumeSlice("all", axis, ratio);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneWireframeOp(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->setCutplaneWireframe(name, state);
+    } else {
+        g_renderer->setCutplaneWireframe("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec cutplaneOps[] = {
+    {"add",          1, CutplaneAddOp, 2, 3, "oper value ?dataSetName?"},
+    {"colormap",     7, CutplaneColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"colormode",    7, CutplaneColorModeOp, 3, 4, "mode ?dataSetNme?"},
+    {"delete",       1, CutplaneDeleteOp, 2, 3, "?dataSetName?"},
+    {"edges",        1, CutplaneEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
+    {"lighting",     3, CutplaneLightingOp, 3, 4, "bool ?dataSetName?"},
+    {"linecolor",    5, CutplaneLineColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"linewidth",    5, CutplaneLineWidthOp, 3, 4, "width ?dataSetName?"},
+    {"opacity",      2, CutplaneOpacityOp, 3, 4, "value ?dataSetName?"},
+    {"orient",       2, CutplaneOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",          1, CutplanePositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"scale",        2, CutplaneScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"slice",        2, CutplaneVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"},
+    {"visible",      1, CutplaneVisibleOp, 3, 4, "bool ?dataSetName?"},
+    {"wireframe",    1, CutplaneWireframeOp, 3, 4, "bool ?dataSetName?"}
+};
+static int nCutplaneOps = NumCmdSpecs(cutplaneOps);
+
+static int
+CutplaneCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nCutplaneOps, cutplaneOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 DataSetActiveScalarsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                        Tcl_Obj *const *objv)
@@ -1334 +1688 @@
     }
     char *data = (char *)malloc(nbytes);
-    size_t bytesRead = fread(data, 1, nbytes, g_fIn);
-    TRACE("bytesRead: %d", bytesRead);
+    size_t bytesRead = SocketRead(data, nbytes);
     if (bytesRead < (size_t)nbytes) {
         free(data);
@@ -2589 +2942 @@
 static Rappture::CmdSpec heightmapOps[] = {
     {"add",          1, HeightMapAddOp, 5, 6, "oper value ?dataSetName?"},
-    {"colormap",     2, HeightMapColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
-    {"contourlist",  2, HeightMapContourListOp, 3, 4, "contourList ?dataSetName?"},
+    {"colormap",     3, HeightMapColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
+    {"contourlist",  3, HeightMapContourListOp, 3, 4, "contourList ?dataSetName?"},
     {"delete",       1, HeightMapDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",        1, HeightMapEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -2604 +2957 @@
     {"orient",       2, HeightMapOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     {"pos",          1, HeightMapPositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",        1, HeightMapScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"scale",        2, HeightMapScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"slice",        2, HeightMapVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"},
     {"surface",      2, HeightMapContourSurfaceVisibleOp, 3, 4, "bool ?dataSetName?"},
-    {"visible",      2, HeightMapVisibleOp, 3, 4, "bool ?dataSetName?"},
-    {"volumeslice",  2, HeightMapVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"},
+    {"visible",      1, HeightMapVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe",    1, HeightMapWireframeOp, 3, 4, "bool ?dataSetName?"}
 };
@@ -2978 +3331 @@
     {"orient",      2, LICOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     {"pos",         1, LICPositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",       1, LICScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
-    {"visible",     2, LICVisibleOp, 3, 4, "bool ?dataSetName?"},
-    {"volumeslice", 2, LICVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"}
+    {"scale",       2, LICScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"slice",       2, LICVolumeSliceOp, 4, 5, "axis ratio ?dataSetName?"},
+    {"visible",     1, LICVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
 static int nLICOps = NumCmdSpecs(licOps);
@@ -4386 +4739 @@
 
 static int
+StreamlinesSeedFilledMeshOp(ClientData clientData, Tcl_Interp *interp,
+                            int objc, Tcl_Obj *const *objv)
+{
+    int numPoints = 0;
+    if (Tcl_GetIntFromObj(interp, objv[3], &numPoints) != TCL_OK ||
+        numPoints < 1) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[4]);
+    char c = string[0];
+    if ((c != 'd') || (strcmp(string, "data") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be data", (char*)NULL);
+        return TCL_ERROR;
+    }
+    string = Tcl_GetString(objv[5]);
+    c = string[0];
+    if ((c != 'f') || (strcmp(string, "follows") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be follows", (char*)NULL);
+        return TCL_ERROR;
+    }
+    int nbytes = 0;
+    if (Tcl_GetIntFromObj(interp, objv[6], &nbytes) != TCL_OK ||
+        nbytes < 0) {
+        return TCL_ERROR;
+    }
+    char *data = (char *)malloc(nbytes);
+    size_t bytesRead = SocketRead(data, nbytes);
+    if (bytesRead < (size_t)nbytes) {
+        free(data);
+        return TCL_ERROR;
+    }
+    if (objc == 8) {
+        const char *name = Tcl_GetString(objv[7]);
+        if (!g_renderer->setStreamlinesSeedToFilledMesh(name, data, nbytes,
+                                                        numPoints)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setStreamlinesSeedToFilledMesh("all", data, nbytes,
+                                                        numPoints)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    free(data);
+    return TCL_OK;
+}
+
+static int
+StreamlinesSeedMeshPointsOp(ClientData clientData, Tcl_Interp *interp,
+                            int objc, Tcl_Obj *const *objv)
+{
+    const char *string = Tcl_GetString(objv[3]);
+    char c = string[0];
+    if ((c != 'd') || (strcmp(string, "data") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be data", (char*)NULL);
+        return TCL_ERROR;
+    }
+    string = Tcl_GetString(objv[4]);
+    c = string[0];
+    if ((c != 'f') || (strcmp(string, "follows") != 0)) {
+        Tcl_AppendResult(interp, "bad streamlines seed fmesh option \"",
+                         string, "\": should be follows", (char*)NULL);
+        return TCL_ERROR;
+    }
+    int nbytes = 0;
+    if (Tcl_GetIntFromObj(interp, objv[5], &nbytes) != TCL_OK ||
+        nbytes < 0) {
+        return TCL_ERROR;
+    }
+    char *data = (char *)malloc(nbytes);
+    size_t bytesRead = SocketRead(data, nbytes);
+    if (bytesRead < (size_t)nbytes) {
+        free(data);
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        if (!g_renderer->setStreamlinesSeedToMeshPoints(name, data, nbytes)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    } else {
+        if (!g_renderer->setStreamlinesSeedToMeshPoints("all", data, nbytes)) {
+            free(data);
+            Tcl_AppendResult(interp, "Couldn't read mesh data or streamlines not found", (char*)NULL);
+            return TCL_ERROR;
+        }
+    }
+    free(data);
+    return TCL_OK;
+}
+
+static int
+StreamlinesSeedPointsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                        Tcl_Obj *const *objv)
+{
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setStreamlinesSeedToMeshPoints(name);
+    } else {
+        g_renderer->setStreamlinesSeedToMeshPoints("all");
+    }
+    return TCL_OK;
+}
+
+static int
 StreamlinesSeedPolygonOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                          Tcl_Obj *const *objv)
@@ -4498 +4965 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setStreamlinesSeedToRandomPoints(name, numPoints);
-    } else {
-        g_renderer->setStreamlinesSeedToRandomPoints("all", numPoints);
+        g_renderer->setStreamlinesSeedToFilledMesh(name, numPoints);
+    } else {
+        g_renderer->setStreamlinesSeedToFilledMesh("all", numPoints);
     }
     return TCL_OK;
@@ -4525 +4992 @@
     {"color",   1, StreamlinesSeedColorOp, 6, 7, "r g b ?dataSetName?"},
     {"disk",    1, StreamlinesSeedDiskOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ radius innerRadius numPoints ?dataSetName?"},
-    {"fpoly",   1, StreamlinesSeedFilledPolygonOp, 13, 14, "centerX centerY centerZ normalX normalY normalZ angle radius numSides numPoints ?dataSetName?"},
-    {"polygon", 1, StreamlinesSeedPolygonOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ angle radius numSides ?dataSetName?"},
+    {"fmesh",   2, StreamlinesSeedFilledMeshOp, 7, 8, "numPoints data follows nbytes ?dataSetName?"},
+    {"fpoly",   2, StreamlinesSeedFilledPolygonOp, 13, 14, "centerX centerY centerZ normalX normalY normalZ angle radius numSides numPoints ?dataSetName?"},
+    {"mesh",    1, StreamlinesSeedMeshPointsOp, 6, 7, "data follows nbytes ?dataSetName?"},
+    {"points",  3, StreamlinesSeedPointsOp, 3, 4, "?dataSetName?"},
+    {"polygon", 3, StreamlinesSeedPolygonOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ angle radius numSides ?dataSetName?"},
     {"rake",    3, StreamlinesSeedRakeOp, 10, 11, "startX startY startZ endX endY endZ numPoints ?dataSetName?"},
     {"random",  3, StreamlinesSeedRandomOp, 4, 5, "numPoints ?dataSetName?"},
@@ -4602 +5072 @@
     {"ribbons",   1, StreamlinesRibbonsOp,   4, 5, "width angle ?dataSetName?"},
     {"scale",     2, StreamlinesScaleOp,     5, 6, "sx sy sz ?dataSetName?"},
-    {"seed",      2, StreamlinesSeedOp,  4, 14, "op params... ?dataSetName?"},
+    {"seed",      2, StreamlinesSeedOp,  3, 14, "op params... ?dataSetName?"},
     {"tubes",     1, StreamlinesTubesOp, 4, 5, "numSides radius ?dataSetName?"},
     {"visible",   1, StreamlinesVisibleOp, 3, 4, "bool ?dataSetName?"}
@@ -4980 +5450 @@
     Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   clientData, NULL);
     Tcl_CreateObjCommand(interp, "contour3d",   Contour3DCmd,   clientData, NULL);
+    Tcl_CreateObjCommand(interp, "cutplane",    CutplaneCmd,    clientData, NULL);
     Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     clientData, NULL);
     Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      clientData, NULL);
@@ -5006 +5477 @@
     Tcl_DeleteCommand(interp, "contour2d");
     Tcl_DeleteCommand(interp, "contour3d");
+    Tcl_DeleteCommand(interp, "cutplane");
     Tcl_DeleteCommand(interp, "dataset");
     Tcl_DeleteCommand(interp, "glyphs");

branches/vtkvis_threaded/Trace.cpp

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 

branches/vtkvis_threaded/Trace.h

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 

branches/vtkvis_threaded/protocol.txt

@@ -144 +144 @@
 contour3d wireframe <bool> <?datasetName?>
 
-glyphs add <?dataSetName?>
+cutplane add <?dataSetName?>
+cutplane colormap <colorMapName> <?dataSetName?>
+cutplane colormode <scalar|vmag|vx|vy|vz> <?datasetName?>
+         Set the field used to color the object.  '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.
+cutplane delete <?dataSetName?>
+cutplane edges <bool> <?dataSetName?>
+cutplane lighting <bool> <?dataSetName?>
+cutplane linecolor <r> <g> <b> <?dataSetName?>
+cutplane linewidth <width> <?dataSetName?>
+cutplane opacity <value> <?dataSetName?>
+cutplane orient <qw> <qx> <qy> <qz> <?dataSetName?>
+cutplane pos <x> <y> <z> <?dataSetName?>
+cutplane scale <sx> <sy> <sz> <?dataSetName?>
+cutplane slice axis ratio <?dataSetName?>
+         For 3D data, select a slice along a principle axis of the volume. The
+         ratio is [0,1]
+cutplane visible <bool> <?dataSetName?>
+cutplane wireframe <bool> <?datasetName?>
+
+glyphs add <shape> <?dataSetName?>
+       See 'glyphs shape' for list of shapes
 glyphs ccolor r g b <?datasetName?>
 glyphs colormap <colorMapName> <?dataSetName?>
@@ -193 +216 @@
 heightmap pos <x> <y> <z> <?dataSetName?>
 heightmap scale <sx> <sy> <sz> <?dataSetName?>
+heightmap slice axis ratio <?dataSetName?>
+          For 3D data, select a slice along a principle axis of the volume. The
+          ratio is [0,1]
 heightmap surface <bool> <?dataSetName?>
           Toggle rendering of colormapped surface (mountain plot or cutplane)
 heightmap visible <bool> <?dataSetName?>
-heightmap volumeslice axis ratio <?dataSetName?>
-          For 3D data, select a slice along a principle axis of the volume. The
-          ratio is [0,1]
 heightmap wireframe <bool> <?datasetName?>
 
@@ -212 +235 @@
 lic pos <x> <y> <z> <?dataSetName?>
 lic scale <sx> <sy> <sz> <?dataSetName?>
+lic slice <axis> <ratio> <?datasetName?>
+    For 3D data, select a slice along a principle axis of the volume. The
+    ratio is [0,1]
 lic visible <bool> <?datasetName?>
-lic volumeslice <axis> <ratio> <?datasetName?>
 
 molecule add <?datasetName?>
@@ -305 +330 @@
             Create a disk seed area with optional hole, filled with randomly 
             placed points
+streamlines seed fmesh <numPoints> data follows <nbytes> <?datasetName?>
+            Fill a mesh supplied as a VTK data file with randomly placed points
 streamlines seed fpoly <centerX> <centerY> <centerZ> <normalX> <normalY> <normalZ> <angle> <radius> <numSides> <numPoints> <?dataSetName?>
             Create a regular n-sided polygonal seed area filled with randomly 
             placed points
+streamlines seed mesh data follows <nbytes> <?datasetName?>
+            Use points of a mesh supplied as a VTK data file
+streamlines seed points <?datasetName?>
+            Use points of the streamlines' dataset mesh
 streamlines seed polygon <centerX> <centerY> <centerZ> <normalX> <normalY> <normalZ> <angle> <radius> <numSides> <?dataSetName?>
             Create seed points from vertices of a regular n-sided polygon
 streamlines seed rake <startX> <startY> <startZ> <endX> <endY> <endZ> <numPoints> <?datasetName?>
 streamlines seed random <numPoints> <?datasetName?>
+            Fill the streamlines' dataset mesh with randomly placed points
 streamlines seed visible <bool> <?datasetName?>
 streamlines tubes <numSides> <radius> <?datasetName?>

branches/vtkvis_threaded/vtkRpCubeAxesActor2D.cpp

@@ -439 +439 @@
   // can be changed). Therefore, we can not just assign pointers otherwise
   // each individual axis text prop would point to the same text prop.
-#ifdef notdef
+#if 1
   if (this->AxisLabelTextProperty &&
       this->AxisLabelTextProperty->GetMTime() > this->BuildTime)
@@ -1078 +1078 @@
 }
 
-//----------------------------------------------------------------------------
-
-// Disable warnings about qualifiers on return types.
-#if defined(_COMPILER_VERSION)
-# pragma set woff 3303
-#endif
-#if defined(__INTEL_COMPILER)
-# pragma warning (disable:858)
-#endif
-
-#ifndef VTK_LEGACY_REMOVE
-# ifdef VTK_WORKAROUND_WINDOWS_MANGLE
-#  undef SetProp
-#  undef GetProp
-void vtkRpCubeAxesActor2D::SetPropA(vtkProp* prop)
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::SetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::SetViewProp);
-  this->SetViewProp(prop);
-}
-void vtkRpCubeAxesActor2D::SetPropW(vtkProp* prop)
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::SetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::SetViewProp);
-  this->SetViewProp(prop);
-}
-vtkProp* vtkRpCubeAxesActor2D::GetPropA()
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::GetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::GetViewProp);
-  return this->GetViewProp();
-}
-vtkProp* vtkRpCubeAxesActor2D::GetPropW()
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::GetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::GetViewProp);
-  return this->GetViewProp();
-}
-# endif
-void vtkRpCubeAxesActor2D::SetProp(vtkProp* prop)
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::SetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::SetViewProp);
-  this->SetViewProp(prop);
-}
-vtkProp* vtkRpCubeAxesActor2D::GetProp()
-{
-  VTK_LEGACY_REPLACED_BODY(vtkRpCubeAxesActor2D::GetProp, "VTK 5.0",
-                           vtkRpCubeAxesActor2D::GetViewProp);
-  return this->GetViewProp();
-}
-#endif

branches/vtkvis_threaded/vtkRpCubeAxesActor2D.h

@@ -253 +253 @@
   void ShallowCopy(vtkRpCubeAxesActor2D *actor);
 
-// Disable warnings about qualifiers on return types.
-#if defined(_COMPILER_VERSION)
-# pragma set woff 3303
-#endif
-#if defined(__INTEL_COMPILER)
-# pragma warning (push)
-# pragma warning (disable:858)
-#endif
-
-#ifdef VTK_WORKAROUND_WINDOWS_MANGLE
-# define SetPropA SetProp
-# define SetPropW SetProp
-# define GetPropA GetProp
-# define GetPropW GetProp
-#endif
-
-  // Description:
-  // @deprecated Replaced by vtkRpCubeAxesActor2D::SetViewProp() as of VTK 5.0.
-  VTK_LEGACY(virtual void SetProp(vtkProp* prop));
-
-  // Description:
-  // @deprecated Replaced by vtkRpCubeAxesActor2D::GetViewProp() as of VTK 5.0.
-  VTK_LEGACY(virtual vtkProp* GetProp());
-
-#ifdef VTK_WORKAROUND_WINDOWS_MANGLE
-# undef SetPropW
-# undef SetPropA
-# undef GetPropW
-# undef GetPropA
-  //BTX
-  VTK_LEGACY(virtual void SetPropA(vtkProp* prop));
-  VTK_LEGACY(virtual void SetPropW(vtkProp* prop));
-  VTK_LEGACY(virtual vtkProp* GetPropA());
-  VTK_LEGACY(virtual vtkProp* GetPropW());
-  //ETX
-#endif
-
-// Reset disabled warning about qualifiers on return types.
-#if defined(__INTEL_COMPILER)
-# pragma warning (pop)
-#endif
-#if defined(_COMPILER_VERSION)
-# pragma reset woff 3303
-#endif
-
 protected:
   vtkRpCubeAxesActor2D();