Changeset 2550 for branches/blt4

Timestamp:

Sep 21, 2011, 2:33:59 PM (13 years ago)

Author:

gah

Message:

updates from trunk

Location:

branches/blt4/packages/vizservers/vtkvis

Files:

• CmdProc.cpp (modified) (5 diffs)
• CmdProc.h (modified) (3 diffs)
• Makefile.in (modified) (6 diffs)
• PPMWriter.cpp (modified) (5 diffs)
• PPMWriter.h (modified) (1 diff)
• RpContour3D.cpp (modified) (1 diff)
• RpCutplane.cpp (added)
• RpCutplane.h (added)
• RpGlyphs.h (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.cpp (modified) (14 diffs)
• RpVtkRenderServer.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (31 diffs)
• RpVtkRenderer.h (modified) (6 diffs)
• RpVtkRendererCmd.cpp (modified) (30 diffs)
• RpVtkRendererCmd.h (modified) (1 diff)
• TGAWriter.cpp (modified) (2 diffs)
• TGAWriter.h (modified) (1 diff)
• Trace.cpp (modified) (4 diffs)
• Trace.h (modified) (2 diffs)
• protocol.txt (modified) (4 diffs)
• vtkRpCubeAxesActor2D.cpp (modified) (2 diffs)
• vtkRpCubeAxesActor2D.h (modified) (1 diff)

branches/blt4/packages/vizservers/vtkvis/CmdProc.cpp

@@ -10 +10 @@
 
 #include "CmdProc.h"
-
-using namespace Rappture;
 
 /**
@@ -24 +22 @@
  */
 static int
-BinaryOpSearch(CmdSpec *specs, 
+BinaryOpSearch(Rappture::CmdSpec *specs, 
                int nSpecs, 
                char *string)       /* Name of minor operation to search for */
@@ -37 +35 @@
     length = strlen(string);
     while (low <= high) {
-        CmdSpec *specPtr;
+        Rappture::CmdSpec *specPtr;
         int compare;
         int median;
@@ -78 +76 @@
  */
 static int
-LinearOpSearch(CmdSpec *specs,
+LinearOpSearch(Rappture::CmdSpec *specs,
                int nSpecs,
                char *string)       /* Name of minor operation to search for */
 {
-    CmdSpec *specPtr;
+    Rappture::CmdSpec *specPtr;
     char c;
     size_t length;
@@ -122 +120 @@
  */
 Tcl_ObjCmdProc *
-Rappture::GetOpFromObj(Tcl_Interp *interp,      /* Interpreter to report errors to */
-                       int nSpecs,              /* Number of specifications in array */
-                       CmdSpec *specs,          /* Op specification array */
-                       int operPos,             /* Position of operation in argument
-                                                 * list. */
-                       int objc,                /* Number of arguments in the argument
-                                                 * vector.  This includes any prefixed
-                                                 * arguments */ 
-                       Tcl_Obj *const *objv,    /* Argument vector */
+Rappture::GetOpFromObj(Tcl_Interp *interp,              /* Interpreter to report errors to */
+                       int nSpecs,                      /* Number of specifications in array */
+                       Rappture::CmdSpec *specs,        /* Op specification array */
+                       int operPos,                     /* Position of operation in argument
+                                                         * list. */
+                       int objc,                        /* Number of arguments in the argument
+                                                         * vector.  This includes any prefixed
+                                                         * arguments */ 
+                       Tcl_Obj *const *objv,            /* Argument vector */
                        int flags)
 {

branches/blt4/packages/vizservers/vtkvis/CmdProc.h

@@ -19 +19 @@
  * for a function pointer associated with the operation name.
  */
-struct CmdSpec {
+typedef struct {
     const char *name;           /**< Name of operation */
     int minChars;               /**< Minimum # characters to disambiguate */
@@ -26 +26 @@
     int maxArgs;                /**< Maximum # args required */
     const char *usage;          /**< Usage message */
-};
+} CmdSpec;
 
-enum CmdSpecIndex {
+typedef enum {
     CMDSPEC_ARG0,               /**< Op is the first argument. */
     CMDSPEC_ARG1,               /**< Op is the second argument. */
@@ -34 +34 @@
     CMDSPEC_ARG3,               /**< Op is the fourth argument. */
     CMDSPEC_ARG4                /**< Op is the fifth argument. */
-};
+} CmdSpecIndex;
 
 #define CMDSPEC_LINEAR_SEARCH   1

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

@@ -47 +47 @@
 DEBUG                   = #yes
 TRACE                   = #yes
-USE_CUSTOM_AXES         = yes
-USE_GPU_RAYCASTING      = yes
-USE_OFFSCREEN_RENDERING = yes
-USE_THREADS             = yes
+USE_CUSTOM_AXES         = yes
+USE_GPU_RAYCASTING      = yes
+USE_OFFSCREEN_RENDERING = yes
 
 #vtk uses deprecated strstream header (instead of sstream)
@@ -71 +70 @@
 DEFINES         += -DUSE_GPU_RAYCAST_MAPPER
 endif
-ifdef USE_THREADS
-DEFINES         += -DUSE_THREADS
-endif
 CXX_SWITCHES    = $(CXXFLAGS) $(EXTRA_CFLAGS) $(DEFINES) $(INCLUDES)
 
@@ -82 +78 @@
                 RpContour2D.cpp \
                 RpContour3D.cpp \
+                RpCutplane.cpp \
                 RpGlyphs.cpp \
                 RpHeightMap.cpp \
@@ -99 +96 @@
 ifdef USE_CUSTOM_AXES
 SERVER_SRCS+=vtkRpCubeAxesActor2D.cpp
-endif
-ifdef USE_THREADS
-SERVER_SRCS+=ResponseQueue.cpp
 endif
 
@@ -136 +130 @@
 CmdProc.o: CmdProc.h
 ColorMap.o: ColorMap.h RpMolecule.h Trace.h
-PPMWriter.o: PPMWriter.h ResponseQueue.h Trace.h
-ResponseQueue.o: ResponseQueue.h Trace.h
+PPMWriter.o: PPMWriter.h Trace.h
 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 +143 @@
 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 Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor2D.h Trace.h PPMWriter.h TGAWriter.h
 Trace.o: Trace.h
-TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h
+TGAWriter.o: TGAWriter.h Trace.h
 vtkRpCubeAxesActor2D.o: vtkRpCubeAxesActor2D.h

branches/blt4/packages/vizservers/vtkvis/PPMWriter.cpp

@@ -12 +12 @@
 #include <sys/uio.h>
 
+#include "PPMWriter.h"
 #include "Trace.h"
-#include "PPMWriter.h"
-#ifdef USE_THREADS
-#include "ResponseQueue.h"
-#endif
 
 using namespace Rappture::VtkVis;
-
-#ifdef USE_THREADS
-
-/**
- * \brief Writes image data as PPM binary data to the client.
- *
- * The PPM binary format is very simple.
- *
- *     P6 w h 255\n
- *     3-byte RGB pixel data.
- *
- * The client (using the TkImg library) will do less work to unpack this 
- * format, as opposed to BMP or PNG.
- *
- * Note that currently the image data has bottom to top scanlines.  This 
- * routine could be made even simpler (faster) if the image data had top 
- * to bottom scanlines.
- *
- * \param[in] queue Pointer to ResponseQueue to write to
- * \param[in] cmdName Command name to send (byte length will be appended)
- * \param[in] data Image data
- * \param[in] width Width of image in pixels
- * \param[in] height Height of image in pixels
- */
-void
-Rappture::VtkVis::queuePPM(ResponseQueue *queue, const char *cmdName, 
-                           const unsigned char *data, int width, int height)
-{
-#define PPM_MAXVAL 255
-    char header[200];
-
-    TRACE("Entering (%dx%d)\n", width, height);
-    // Generate the PPM binary file header
-    snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height, 
-             PPM_MAXVAL);
-
-    size_t headerLength = strlen(header);
-    size_t dataLength = width * height * 3;
-
-    char command[200];
-    snprintf(command, sizeof(command), "%s %lu\n", cmdName, 
-             (unsigned long)headerLength + dataLength);
-
-    size_t cmdLength;
-    cmdLength = strlen(command);
-
-    size_t length;
-    unsigned char *mesg;
-
-    length = headerLength + dataLength + cmdLength;
-    mesg = (unsigned char *)malloc(length);
-    if (mesg == NULL) {
-        ERROR("can't allocate %ld bytes for the image message", length);
-        return;
-    }
-    memcpy(mesg, command, cmdLength);
-    memcpy(mesg + cmdLength, header, headerLength);
-
-    size_t bytesPerRow = width * 3;
-    unsigned char *destRowPtr = mesg + length - bytesPerRow;
-    int y;
-    unsigned char *srcRowPtr = const_cast<unsigned char *>(data);
-    for (y = 0; y < height; y++) {
-        memcpy(destRowPtr, srcRowPtr, bytesPerRow);
-        srcRowPtr += bytesPerRow;
-        destRowPtr -= bytesPerRow;
-    }
-
-    Response *response;
-    if (strncmp(cmdName, "nv>legend", 9) == 0) {
-        response = new Response(Response::LEGEND);
-    } else {
-        response = new Response(Response::IMAGE);
-    }
-    response->setMessage(mesg, length, Response::DYNAMIC);
-    queue->enqueue(response);
-    TRACE("Leaving (%dx%d)\n", width, height);
-}
-#else
 
 /**
@@ -121 +39 @@
  */
 void
-Rappture::VtkVis::writePPM(int fd, const char *cmdName, 
-                           const unsigned char *data, int width, int height)
+Rappture::VtkVis::writePPM(int fd, const char *cmdName, const unsigned char *data,
+                           int width, int height)
 {
 #define PPM_MAXVAL 255
@@ -129 +47 @@
     TRACE("Entering (%dx%d)\n", width, height);
     // Generate the PPM binary file header
-    snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height,
-             PPM_MAXVAL);
+    snprintf(header, sizeof(header), "P6 %d %d %d\n", width, height, PPM_MAXVAL);
 
     size_t headerLength = strlen(header);
@@ -162 +79 @@
     }
     if (writev(fd, iov, nRecs) < 0) {
-        ERROR("write failed: %s\n", strerror(errno));
+        ERROR("write failed: %s\n", strerror(errno));
     }
     free(iov);
@@ -168 +85 @@
     TRACE("Leaving (%dx%d)\n", width, height);
 }
-
-#endif /*USE_THREADS*/

branches/blt4/packages/vizservers/vtkvis/PPMWriter.h

@@ -9 +9 @@
 #define __RAPPTURE_VTKVIS_PPMWRITER_H__
 
-#ifdef USE_THREADS
-#include "ResponseQueue.h"
-#endif
-
 namespace Rappture {
 namespace VtkVis {
-#ifdef USE_THREADS
+
 extern
-void queuePPM(ResponseQueue *queue, const char *cmdName, 
-              const unsigned char *data, int width, int height);
-#else
-extern
-void writePPM(int fd, const char *cmdName, 
-              const unsigned char *data, int width, int height);
-#endif
+void writePPM(int fd, const char *cmdName, const unsigned char *data, int width, int height);
+
 }
 }
+
 #endif

branches/blt4/packages/vizservers/vtkvis/RpContour3D.cpp

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

branches/blt4/packages/vizservers/vtkvis/RpGlyphs.h

@@ -14 +14 @@
 #include <vtkProp.h>
 #include <vtkActor.h>
-#ifdef HAVE_GLYPH3D_MAPPER
+#include <vtkVersion.h>
+#if ((VTK_MAJOR_VERSION > 5) || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION >= 8))
+#define HAVE_GLYPH3D_MAPPER
 #include <vtkGlyph3DMapper.h>
 #else

branches/blt4/packages/vizservers/vtkvis/RpHeightMap.cpp

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

branches/blt4/packages/vizservers/vtkvis/RpHeightMap.h

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

branches/blt4/packages/vizservers/vtkvis/RpLIC.cpp

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

branches/blt4/packages/vizservers/vtkvis/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/blt4/packages/vizservers/vtkvis/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);
+    switch (type) {
+    case VTK_VERTEX: {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        ds->GetCellPoints(cell, ptIds);
+        assert(ptIds->GetNumberOfIds() == 1);
+        ds->GetPoint(ptIds->GetId(0), pt);
+    }
+        break;
+    case 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);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+        }
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+    }
+        break;
+    case 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]);
+        }
+    }
+        break;
+    case VTK_PIXEL:
+    case VTK_VOXEL: {
+        double bounds[6];
+        ds->GetCellBounds(cell, bounds);
+        getRandomPoint(pt, bounds);
+    }
+        break;
+    default: {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        vtkSmartPointer<vtkPoints> pts = vtkSmartPointer<vtkPoints>::New();
+        ds->GetCell(cell)->Triangulate(0, ptIds, pts);
+        if (ptIds->GetNumberOfIds() % 4 == 0) {
+            int tetra = rand() % (ptIds->GetNumberOfIds()/4);
+            double v[4][3];
+            for (int i = 0; i < 4; i++) {
+                ds->GetPoint(ptIds->GetId(i + tetra * 4), v[i]);
+            }
+            getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[4]);
+        } else {
+            assert(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]);
+        }
+    }
+    }
 }
 
@@ -237 +440 @@
     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 +482 @@
 
     _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 +496 @@
         _seedMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
         _seedMapper->SetResolveCoincidentTopologyToPolygonOffset();
+        _seedMapper->ScalarVisibilityOff();
     }
 
     // Set up seed source object
-    setSeedToRandomPoints(200);
+    setSeedToFilledMesh(200);
 
     switch (_lineType) {
@@ -343 +554 @@
 
 /**
- * \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 +572 @@
  * \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 +625 @@
         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 +685 @@
                 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 +777 @@
                 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 +932 @@
                                                     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 +941 @@
                 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 +952 @@
                 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 +978 @@
 
 /**
- * \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 +1099 @@
     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 +1225 @@
         return;
 
-    vtkDataSet *ds = _dataSet->getVtkDataSet();
-
     switch (mode) {
     case COLOR_BY_SCALAR: {
@@ -834 +1237 @@
         _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 +1247 @@
         _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 +1257 @@
         _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 +1267 @@
         _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 +1449 @@
     _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/blt4/packages/vizservers/vtkvis/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/blt4/packages/vizservers/vtkvis/RpVtkRenderServer.cpp

@@ -1 @@
-
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
@@ -10 +9 @@
 #include <cstring>
 #include <cstdlib>
-#include <cerrno>
+#include <string>
+#include <sstream>
 #include <unistd.h>
 #include <signal.h>
@@ -17 +17 @@
 #include <sys/time.h>
 #endif
-
-#include <string>
-#include <sstream>
 
 #include "Trace.h"
@@ -27 +24 @@
 #include "PPMWriter.h"
 #include "TGAWriter.h"
-#ifdef USE_THREADS
-#include <pthread.h>
-#include "ResponseQueue.h"
-#endif 
 
 using namespace Rappture::VtkVis;
@@ -45 +38 @@
      (((t2).tv_sec - (t1).tv_sec))*1.0e+3f + (float)((t2).tv_usec - (t1).tv_usec)/1.0e+3f)
 
-#ifdef USE_THREADS
 static void
-queueFrame(ResponseQueue *queue, vtkUnsignedCharArray *imgData)
+writeFrame(int fd, vtkUnsignedCharArray *imgData)
 {
 #ifdef DEBUG
@@ -73 +65 @@
                  TARGA_BYTES_PER_PIXEL,
                  true);
-#endif  /*RENDER_TARGA*/
+#endif
 
 #else
@@ -90 +82 @@
 
 #ifdef RENDER_TARGA
-        queueTGA(queue, oss.str().c_str(),
+        writeTGA(fd, oss.str().c_str(),
                  imgData->GetPointer(0),
                  g_renderer->getWindowWidth(),
@@ -96 +88 @@
                  TARGA_BYTES_PER_PIXEL);
 #else
-        queuePPM(queue, oss.str().c_str(),
+        writePPM(fd, oss.str().c_str(),
                  imgData->GetPointer(0),
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
-#endif  /*RENDER_TARGA*/
-    } else {
-#ifdef RENDER_TARGA
-        queueTGA(queue, "nv>image -type image -bytes",
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight(),
-                 TARGA_BYTES_PER_PIXEL);
-#else
-        queuePPM(queue, "nv>image -type image -bytes",
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight());
-#endif  /*RENDER_TARGA*/
-    }
-#endif  /*DEBUG*/
-}
-
-#else
-
-static void
-writeFrame(int fd, vtkUnsignedCharArray *imgData)
-{
-#ifdef DEBUG
-    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
-        double xywh[4];
-        g_renderer->getScreenWorldCoords(xywh);
-        TRACE("Image bbox: %g %g %g %g", 
-              xywh[0], 
-              (xywh[1] + xywh[3]), 
-              (xywh[0] + xywh[2]), 
-              xywh[1]);
-    }
-
-#ifdef RENDER_TARGA
-    writeTGAFile("/tmp/frame.tga",
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight(),
-                 TARGA_BYTES_PER_PIXEL);
-#else
-    writeTGAFile("/tmp/frame.tga",
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight(),
-                 TARGA_BYTES_PER_PIXEL,
-                 true);
-#endif  /*RENDER_TARGA*/
-
-#else
-    if (g_renderer->getCameraMode() == Renderer::IMAGE) {
-        double xywh[4];
-        g_renderer->getCameraZoomRegion(xywh);
-        std::ostringstream oss;
-        oss.precision(12);
-        // Send upper left and lower right corners as bbox
-        oss << "nv>image -type image -bbox {"
-            << std::scientific
-            << xywh[0] << " "
-            << xywh[1] << " "
-            << xywh[2] << " "
-            << xywh[3] << "} -bytes";
-
-#ifdef RENDER_TARGA
-        writeTGA(fd, oss.str().c_str(),
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight(),
-                 TARGA_BYTES_PER_PIXEL);
-#else
-        writePPM(fd, oss.str().c_str(),
-                 imgData->GetPointer(0),
-                 g_renderer->getWindowWidth(),
-                 g_renderer->getWindowHeight());
-#endif  /*RENDER_TARGA*/
+#endif
     } else {
 #ifdef RENDER_TARGA
@@ -187 +105 @@
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
-#endif  /*RENDER_TARGA*/
-    }
-#endif  /*DEBUG*/
-}
-#endif /*USE_THREADS*/
+#endif
+    }
+#endif
+}
 
 static void
@@ -236 +153 @@
 }
 
-#ifdef USE_THREADS
-static void *
-readerThread(void *clientData)
-{
-    ResponseQueue *queue = (ResponseQueue *)clientData;
-    Tcl_Interp *interp;
-
-    TRACE("starting reader thread");
-    interp = (Tcl_Interp *)queue->clientData();
-    vtkSmartPointer<vtkUnsignedCharArray> imgData = 
-        vtkSmartPointer<vtkUnsignedCharArray>::New();
-    for (;;) {
-        int ret;
-
-        ret = processCommands(interp, g_fIn, g_fOut);
-        if (ret < 0)
-            break;
-        if (g_renderer->render()) {
-            TRACE("Rendering new frame");
-            g_renderer->getRenderedFrame(imgData);
-            queueFrame(queue, imgData);
-        } else {
-            TRACE("No render required");
-        }
-        if (feof(g_fIn))
-            break;
-    }    
-    return NULL;
-}
-
-static void *
-writerThread(void *clientData)
-{
-    ResponseQueue *queue = (ResponseQueue *)clientData;
-
-    TRACE("starting writer thread");
-    for (;;) {
-        Response *response;
-
-        response = queue->dequeue(); 
-        if (fwrite(response->message(), sizeof(char), response->length(),
-                   g_fOut) != response->length()) {
-            ERROR("short write while trying to write %ld bytes", 
-                  response->length());
-        }
-        fflush(g_fOut);
-        delete response;
-        if (feof(g_fOut))
-            break;
-    }    
-    return NULL;
-}
-
-#endif  /*USE_THREADS*/
-
 int
 main(int argc, char *argv[])
@@ -297 +159 @@
     signal(SIGPIPE, SIG_IGN);
     initService();
-    initLog();
+    InitLog();
 
     TRACE("Starting VTKVis Server");
@@ -314 +176 @@
 
     g_renderer = new Renderer();
-
-    Tcl_Interp *interp = Tcl_CreateInterp();
-
-#ifdef USE_THREADS
-    ResponseQueue queue((void *)interp);
-    initTcl(interp, (ClientData)&queue);
-
-    pthread_t readerThreadId, writerThreadId;
-    if (pthread_create(&readerThreadId, NULL, &readerThread, &queue) < 0) {
-        ERROR("can't create reader thread: %s", strerror(errno));
-    }
-    if (pthread_create(&writerThreadId, NULL, &writerThread, &queue) < 0) {
-        ERROR("can't create writer thread: %s", strerror(errno));
-    }
-    if (pthread_join(readerThreadId, NULL) < 0) {
-        ERROR("can't join reader thread: %s", strerror(errno));
-    }
-    if (pthread_join(writerThreadId, NULL) < 0) {
-        ERROR("can't join writer thread: %s", strerror(errno));
-    }
-#else 
-    initTcl(interp, (ClientData)NULL);
-    int ret = 0;
-
     vtkSmartPointer<vtkUnsignedCharArray> imgData = 
         vtkSmartPointer<vtkUnsignedCharArray>::New();
+
+    Tcl_Interp *interp = initTcl();
+
+    int ret = 0;
+
     while (1) {
         ret = processCommands(interp, g_fIn, g_fOut);
@@ -356 +199 @@
             break;
     }
-#endif
-    INFO("exiting vtkvis");
+
     exitTcl(interp);
     interp = NULL;
@@ -366 +208 @@
     TRACE("Exiting VTKVis Server");
 
-    closeLog();
+    CloseLog();
     exitService();
 
-    return 0;
-}
-
+    return ret;
+}
+

branches/blt4/packages/vizservers/vtkvis/RpVtkRenderServer.h

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

branches/blt4/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -40 +40 @@
 #include <vtkTextProperty.h>
 #include <vtkOpenGLRenderWindow.h>
+#include <vtkVersion.h>
 
 #include "RpVtkRenderer.h"
@@ -158 +159 @@
     }
     _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 +321 @@
 
 /**
+ * \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 +681 @@
         deleteContour2D(itr->second->getName());
         deleteContour3D(itr->second->getName());
+        deleteCutplane(itr->second->getName());
         deleteGlyphs(itr->second->getName());
         deleteHeightMap(itr->second->getName());
@@ -825 +870 @@
             double newBounds[6];
             collectBounds(newBounds, false);
+#if ((VTK_MAJOR_VERSION > 5) || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION >= 8))
+            _cubeAxesActor->SetXAxisRange(newBounds[0], newBounds[1]);
+            _cubeAxesActor->SetYAxisRange(newBounds[2], newBounds[3]);
+            _cubeAxesActor->SetZAxisRange(newBounds[4], newBounds[5]);
+#endif
             _cubeAxesActor->SetBounds(newBounds);
             TRACE("Bounds (computed): %g %g %g %g %g %g",
@@ -834 +884 @@
                   newBounds[5]);
         } else {
+#if ((VTK_MAJOR_VERSION > 5) || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION >= 8))
+            _cubeAxesActor->SetXAxisRange(bounds[0], bounds[1]);
+            _cubeAxesActor->SetYAxisRange(bounds[2], bounds[3]);
+            _cubeAxesActor->SetZAxisRange(bounds[4], bounds[5]);
+#endif
             _cubeAxesActor->SetBounds(bounds);
             TRACE("Bounds (supplied): %g %g %g %g %g %g",
@@ -858 +913 @@
     // Don't offset labels at origin
     _cubeAxesActor->SetCornerOffset(0);
-    _cubeAxesActor->SetFlyModeToClosestTriad();
+    _cubeAxesActor->SetFlyModeToStaticTriad();
 
 #ifdef USE_CUSTOM_AXES
@@ -1213 +1268 @@
         }
     }
+    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 +1333 @@
     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 +2264 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -2672 +2737 @@
 
 /**
+ * \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 +3266 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3322 +3869 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3376 +3921 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
 
@@ -3561 +4104 @@
     }
 
+    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 +4581 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -4220 +4767 @@
      } while (doAll && ++itr != _lics.end());
 
-    initCamera();
+    _renderer->ResetCameraClippingRange();
     _needsRedraw = true;
 }
@@ -4462 +5009 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -4971 +5516 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -6073 +6616 @@
 
 /**
+ * \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 +6760 @@
     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 +7352 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
     initCamera();
     _needsRedraw = true;
@@ -7416 +8085 @@
             _cameraOrientation[3] = 0.0;
         }
-        setViewAngle(_windowHeight);
+        //setViewAngle(_windowHeight);
         double bounds[6];
         collectBounds(bounds, false);
@@ -7952 +8621 @@
             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 +8723 @@
     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 +9065 @@
     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 +9115 @@
     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 +9223 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[1] == NULL) {
                     _userClipPlanes[1] = vtkSmartPointer<vtkPlane>::New();
@@ -8560 +9246 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[3] == NULL) {
                     _userClipPlanes[3] = vtkSmartPointer<vtkPlane>::New();
@@ -8583 +9269 @@
             }
         } else {
-            if (ratio > 0.0) {
+            if (ratio < 1.0) {
                 if (_userClipPlanes[5] == NULL) {
                     _userClipPlanes[5] = vtkSmartPointer<vtkPlane>::New();
@@ -8639 +9325 @@
         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/blt4/packages/vizservers/vtkvis/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/blt4/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -21 +21 @@
 #include "RpVtkRendererCmd.h"
 #include "RpVtkRenderServer.h"
+#include "RpVtkRenderer.h"
 #include "PPMWriter.h"
 #include "TGAWriter.h"
-#ifdef USE_THREADS
-#include "ResponseQueue.h"
-#endif
 
 using namespace Rappture::VtkVis;
-
-static int lastCmdStatus;
-
-#ifdef USE_THREADS
-static void
-QueueResponse(ClientData clientData, const void *bytes, size_t len, 
-              Response::AllocationType allocType)
-{
-    ResponseQueue *queue = (ResponseQueue *)clientData;
-
-    Response *response;
-
-    response = new Response(Response::DATA);
-    response->setMessage((unsigned char *)bytes, len, allocType);
-    queue->enqueue(response);
-}
-#else
 
 static ssize_t
@@ -62 +43 @@
 }
 
-#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
@@ -69 +68 @@
     int result;
 
-    TRACE("command: '%s'", Tcl_DStringValue(dsPtr));
-    lastCmdStatus = TCL_OK;
-    result = Tcl_EvalEx(interp, Tcl_DStringValue(dsPtr), 
-                        Tcl_DStringLength(dsPtr), 
-                        TCL_EVAL_DIRECT | TCL_EVAL_GLOBAL);
+    result = Tcl_Eval(interp, Tcl_DStringValue(dsPtr));
     Tcl_DStringSetLength(dsPtr, 0);
-    if (lastCmdStatus == TCL_BREAK) {
-        return TCL_BREAK;
-    }
-    lastCmdStatus = result;
+
     return result;
 }
@@ -203 +195 @@
 {
     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 +267 @@
 {
     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 +279 @@
         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 {
@@ -374 +380 @@
              pos[0], pos[1], pos[2], focalPt[0], focalPt[1], focalPt[2], viewUp[0], viewUp[1], viewUp[2]);
 
-#ifdef USE_THREADS
-    QueueResponse(clientData, buf, strlen(buf), Response::VOLATILE);
-#else 
     ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
+
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif
     return TCL_OK;
 }
@@ -1266 +1269 @@
 
 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 +1656 @@
     }
     char *data = (char *)malloc(nbytes);
-    size_t bytesRead = fread(data, 1, nbytes, g_fIn);
-    TRACE("bytesRead: %d", bytesRead);
-    if (bytesRead < (size_t)nbytes) {
+    size_t bytesRead = SocketRead(data, nbytes);
+    if (bytesRead < 0) {
         free(data);
         return TCL_ERROR;
@@ -1377 +1698 @@
 
     char buf[256];
-    int length;
-
-    length = snprintf(buf, sizeof(buf), "nv>dataset scalar pixel %d %d %g %s\n",
-        x, y, value, name);
-
-#ifdef USE_THREADS
-    QueueResponse(clientData, buf, length, Response::VOLATILE);
-#else
-    ssize_t bytesWritten = SocketWrite(buf, length);
+    snprintf(buf, sizeof(buf), "nv>dataset scalar pixel %d %d %g %s\n", x, y, value, name);
+
+    ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif
     return TCL_OK;
 }
@@ -1412 +1726 @@
 
     char buf[256];
-    int length;
-
-    length = snprintf(buf, sizeof(buf), 
-        "nv>dataset scalar world %g %g %g %g %s\n", x, y, z, value, name);
-
-#ifdef USE_THREADS
-    QueueResponse(clientData, buf, length, Response::VOLATILE);
-#else 
-    ssize_t bytesWritten = SocketWrite(buf, length);
+    snprintf(buf, sizeof(buf), "nv>dataset scalar world %g %g %g %g %s\n", x, y, z, value, name);
+
+    ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
+
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif
     return TCL_OK;
 }
@@ -1465 +1773 @@
 
     char buf[256];
-    int length; 
-    length = snprintf(buf, sizeof(buf), 
-        "nv>dataset vector pixel %d %d %g %g %g %s\n", x, y, value[0], 
-        value[1], value[2], name);
-
-#ifdef USE_THREADS
-    QueueResponse(clientData, buf, length, Response::VOLATILE);
-#else 
-    ssize_t bytesWritten = SocketWrite(buf, length);
+    snprintf(buf, sizeof(buf), "nv>dataset vector pixel %d %d %g %g %g %s\n", x, y,
+             value[0], value[1], value[2], name);
+
+    ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -1500 +1802 @@
 
     char buf[256];
-    int length;
-    length = snprintf(buf, sizeof(buf), 
-        "nv>dataset vector world %g %g %g %g %g %g %s\n", x, y, z,
-        value[0], value[1], value[2], name);
-#ifdef USE_THREADS
-    QueueResponse(clientData, buf, length, Response::VOLATILE);
-#else 
-    ssize_t bytesWritten = SocketWrite(buf, length);
+    snprintf(buf, sizeof(buf), "nv>dataset vector world %g %g %g %g %g %g %s\n", x, y, z,
+             value[0], value[1], value[2], name);
+
+    ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -1575 +1872 @@
     oss << "}\n";
     len += 2;
-#ifdef USE_THREADS
-    QueueResponse(clientData, oss.str().c_str(), len, Response::VOLATILE);
-#else 
-    ssize_t bytesWritten = SocketWrite(oss.str().c_str(), len);
+
+    size_t bytesWritten = SocketWrite(oss.str().c_str(), len);
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
-#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -2589 +2883 @@
 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 +2898 @@
     {"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?"}
 };
@@ -2624 +2918 @@
     }
     return (*proc) (clientData, interp, objc, objv);
-}
-
-static int
-ImageFlushCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
-             Tcl_Obj *const *objv)
-{
-    lastCmdStatus = TCL_BREAK;
-    return TCL_OK;
 }
 
@@ -2695 +2981 @@
 
 #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} {%s} %g %g",
              colorMapName, title.c_str(), range[0], range[1]);
-
-# 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
+#ifdef RENDER_TARGA
     writeTGA(g_fdOut, cmd, imgData->GetPointer(0), width, height,
-             TARGA_BYTES_PER_PIXEL);
-#  else
+                 TARGA_BYTES_PER_PIXEL);
+#else
     writePPM(g_fdOut, cmd, imgData->GetPointer(0), width, height);
-#  endif
-# endif // USE_THREADS
-#endif // DEBUG
+#endif
+#endif
+
     return TCL_OK;
 }
@@ -2978 +3248 @@
     {"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 +4656 @@
 
 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 < 0) {
+        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 < 0) {
+        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 +4882 @@
     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 +4909 @@
     {"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?"},
@@ -4586 +4973 @@
 
 static Rappture::CmdSpec streamlinesOps[] = {
-    {"add",       1, StreamlinesAddOp,       2, 3, "?dataSetName?"},
-    {"ccolor",    1, StreamlinesColorOp,     5, 6, "r g b ?dataSetName?"},
-    {"colormap",  7, StreamlinesColorMapOp,  3, 4, "colorMapName ?dataSetName?"},
+    {"add",       1, StreamlinesAddOp, 2, 3, "?dataSetName?"},
+    {"ccolor",    1, StreamlinesColorOp, 5, 6, "r g b ?dataSetName?"},
+    {"colormap",  7, StreamlinesColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
     {"colormode", 7, StreamlinesColorModeOp, 3, 4, "mode ?dataSetNme?"},
-    {"delete",    1, StreamlinesDeleteOp,    2, 3, "?dataSetName?"},
+    {"delete",    1, StreamlinesDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, StreamlinesEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
-    {"length",    2, StreamlinesLengthOp,    3, 4, "length ?dataSetName?"},
-    {"lighting",  3, StreamlinesLightingOp,  3, 4, "bool ?dataSetName?"},
+    {"length",    2, StreamlinesLengthOp, 3, 4, "length ?dataSetName?"},
+    {"lighting",  3, StreamlinesLightingOp, 3, 4, "bool ?dataSetName?"},
     {"linecolor", 5, StreamlinesLineColorOp, 5, 6, "r g b ?dataSetName?"},
-    {"lines",     5, StreamlinesLinesOp,     2, 3, "?dataSetName?"},
+    {"lines",     5, StreamlinesLinesOp, 2, 3, "?dataSetName?"},
     {"linewidth", 5, StreamlinesLineWidthOp, 3, 4, "width ?dataSetName?"},
-    {"opacity",   2, StreamlinesOpacityOp,   3, 4, "val ?dataSetName?"},
-    {"orient",    2, StreamlinesOrientOp,    6, 7, "qw qx qy qz ?dataSetName?"},
-    {"pos",       1, StreamlinesPositionOp,  5, 6, "x y z ?dataSetName?"},
-    {"ribbons",   1, StreamlinesRibbonsOp,   4, 5, "width angle ?dataSetName?"},
-    {"scale",     2, StreamlinesScaleOp,     5, 6, "sx sy sz ?dataSetName?"},
-    {"seed",      2, StreamlinesSeedOp,  4, 14, "op params... ?dataSetName?"},
+    {"opacity",   2, StreamlinesOpacityOp, 3, 4, "val ?dataSetName?"},
+    {"orient",    2, StreamlinesOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
+    {"pos",       1, StreamlinesPositionOp, 5, 6, "x y z ?dataSetName?"},
+    {"ribbons",   1, StreamlinesRibbonsOp, 4, 5, "width angle ?dataSetName?"},
+    {"scale",     2, StreamlinesScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"seed",      2, StreamlinesSeedOp, 3, 14, "op params... ?dataSetName?"},
     {"tubes",     1, StreamlinesTubesOp, 4, 5, "numSides radius ?dataSetName?"},
     {"visible",   1, StreamlinesVisibleOp, 3, 4, "bool ?dataSetName?"}
@@ -4816 +5203 @@
 
 static Rappture::CmdSpec volumeShadingOps[] = {
-    {"ambient",  1, VolumeShadingAmbientOp,  4, 5, "coeff ?dataSetName?"},
-    {"diffuse",  1, VolumeShadingDiffuseOp,  4, 5, "coeff ?dataSetName?"},
+    {"ambient",  1, VolumeShadingAmbientOp, 4, 5, "coeff ?dataSetName?"},
+    {"diffuse",  1, VolumeShadingDiffuseOp, 4, 5, "coeff ?dataSetName?"},
     {"specular", 1, VolumeShadingSpecularOp, 5, 6, "coeff power ?dataSetName?"}
 };
@@ -4854 +5241 @@
 
 static Rappture::CmdSpec volumeOps[] = {
-    {"add",      1, VolumeAddOp,      2, 3, "?dataSetName?"},
+    {"add",      1, VolumeAddOp, 2, 3, "?dataSetName?"},
     {"colormap", 1, VolumeColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
-    {"delete",   1, VolumeDeleteOp,   2, 3, "?dataSetName?"},
+    {"delete",   1, VolumeDeleteOp, 2, 3, "?dataSetName?"},
     {"lighting", 1, VolumeLightingOp, 3, 4, "bool ?dataSetName?"},
-    {"opacity",  2, VolumeOpacityOp,  3, 4, "val ?dataSetName?"},
-    {"orient",   2, VolumeOrientOp,   6, 7, "qw qx qy qz ?dataSetName?"},
+    {"opacity",  2, VolumeOpacityOp, 3, 4, "val ?dataSetName?"},
+    {"orient",   2, VolumeOrientOp, 6, 7, "qw qx qy qz ?dataSetName?"},
     {"pos",      1, VolumePositionOp, 5, 6, "x y z ?dataSetName?"},
-    {"scale",    2, VolumeScaleOp,    5, 6, "sx sy sz ?dataSetName?"},
-    {"shading",  2, VolumeShadingOp,  4, 6, "oper val ?dataSetName?"},
-    {"visible",  1, VolumeVisibleOp,  3, 4, "bool ?dataSetName?"}
+    {"scale",    2, VolumeScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
+    {"shading",  2, VolumeShadingOp, 4, 6, "oper val ?dataSetName?"},
+    {"visible",  1, VolumeVisibleOp, 3, 4, "bool ?dataSetName?"}
 };
 static int nVolumeOps = NumCmdSpecs(volumeOps);
@@ -4883 +5270 @@
 /**
  * \brief Execute commands from client in Tcl interpreter
- * 
- * In this threaded model, the select call is for event compression.  We
- * want to execute render server commands as long as they keep coming.  
- * This lets us execute a stream of many commands but render once.  This 
- * benefits camera movements, screen resizing, and opacity changes 
- * (using a slider on the client).  The down side is you don't render
- * until there's a lull in the command stream.  If the client needs an
- * image, it can issue an "imgflush" command.  That breaks us out of the
- * read loop.
  */
 int
 Rappture::VtkVis::processCommands(Tcl_Interp *interp, FILE *fin, FILE *fout)
 {
+    Tcl_DString cmdbuffer;
+    Tcl_DStringInit(&cmdbuffer);
+
+    int fdIn = fileno(fin);
+    int fdOut = fileno(fout);
+    int flags = fcntl(fdIn, F_GETFL, 0);
+    fcntl(fdIn, F_SETFL, flags & ~O_NONBLOCK);
+
     int status = TCL_OK;
-
-#define BUFFERSIZE   ((1<<16)-1)
-    char buffer[BUFFERSIZE+1];
-
-    Tcl_DString command;
-    Tcl_DStringInit(&command);
-
-    fd_set readFds;
-    struct timeval tv, *tvPtr;
-
-    FD_ZERO(&readFds);
-    FD_SET(fileno(fin), &readFds);
-    tvPtr = NULL;                       /* Initially there is no timeout. */
-    while (select(1, &readFds, NULL, NULL, tvPtr) > 0) {
-        if (fgets(buffer, BUFFERSIZE, fin) == NULL) {
-            /* Terminate the server if we can't
-             * communicate with the client
-             * anymore. */
-            if (feof(fin)) {
-                INFO("Exiting server on EOF from client");
-                exit(0);
-            } else {
-                ERROR("Exiting server, failed to read from client: %s",
-                      strerror(errno));
-                exit(1);
+    int nCommands = 0;
+    bool isComplete = false;
+    while ((!feof(fin)) && (status == TCL_OK)) {
+        while (!feof(fin)) {
+            int c = fgetc(fin);
+            if (c <= 0) {
+                if (errno == EWOULDBLOCK) {
+                    break;
+                }
+                if (feof(fin))
+                    return 1;
+                else
+                    return c;
             }
-        }
-        buffer[BUFFERSIZE] = '\0';
-        Tcl_DStringAppend(&command, buffer, -1);
-        if (Tcl_CommandComplete(Tcl_DStringValue(&command))) {
-            status = ExecuteCommand(interp, &command);
-            if (status == TCL_BREAK) {
-                return 1;               /* This was caused by a "imgflush"
-                                         * command. Break out of the read loop
-                                         * and allow a new image to be
-                                         * rendered. */
+            char ch = (char)c;
+            Tcl_DStringAppend(&cmdbuffer, &ch, 1);
+            if (ch == '\n') {
+                isComplete = Tcl_CommandComplete(Tcl_DStringValue(&cmdbuffer));
+                if (isComplete) {
+                    break;
+                }
             }
         }
-        tv.tv_sec = tv.tv_usec = 0L;
-        FD_SET(fileno(fin), &readFds);
-        tvPtr = &tv;
-    }
+        // no command? then we're done for now
+        if (Tcl_DStringLength(&cmdbuffer) == 0) {
+            break;
+        }
+        if (isComplete) {
+            // back to original flags during command evaluation...
+            fcntl(fdIn, F_SETFL, flags & ~O_NONBLOCK);
+            TRACE("command: '%s'", Tcl_DStringValue(&cmdbuffer));
+            status = ExecuteCommand(interp, &cmdbuffer);
+            // non-blocking for next read -- we might not get anything
+            fcntl(fdIn, F_SETFL, flags | O_NONBLOCK);
+            isComplete = false;
+            nCommands++;
+        }
+    }
+    fcntl(fdIn, F_SETFL, flags);
 
     if (status != TCL_OK) {
@@ -4946 +5329 @@
         string = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
         TRACE("ERROR errorInfo=(%s)", string);
-        INFO("%s: status=%d ERROR errorInfo=(%s)", Tcl_DStringValue(&command),
-             status, string);
+
         nBytes = strlen(string);
         struct iovec iov[3];
@@ -4956 +5338 @@
         iov[2].iov_base = (char *)"\n";
         iov[2].iov_len = strlen((char *)iov[2].iov_base);
-        int fdOut = fileno(fout);
         if (writev(fdOut, iov, 3) < 0) {
             ERROR("write failed: %s", strerror(errno));
@@ -4971 +5352 @@
  * \return The initialized Tcl interpreter
  */
-void
-Rappture::VtkVis::initTcl(Tcl_Interp *interp, ClientData clientData)
-{
+Tcl_Interp *
+Rappture::VtkVis::initTcl()
+{
+    Tcl_Interp *interp;
+    interp = Tcl_CreateInterp();
+
     Tcl_MakeSafe(interp);
-    Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        clientData, NULL);
-    Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "colormap",    ColorMapCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   clientData, NULL);
-    Tcl_CreateObjCommand(interp, "contour3d",   Contour3DCmd,   clientData, NULL);
-    Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     clientData, NULL);
-    Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
-    Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
-    Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "lic",         LICCmd,         clientData, NULL);
-    Tcl_CreateObjCommand(interp, "molecule",    MoleculeCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "pseudocolor", PseudoColorCmd, clientData, NULL);
-    Tcl_CreateObjCommand(interp, "renderer",    RendererCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "screen",      ScreenCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, clientData, NULL);
-    Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      clientData, NULL);
+
+    Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        NULL, NULL);
+    Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      NULL, NULL);
+    Tcl_CreateObjCommand(interp, "colormap",    ColorMapCmd,    NULL, NULL);
+    Tcl_CreateObjCommand(interp, "contour2d",   Contour2DCmd,   NULL, NULL);
+    Tcl_CreateObjCommand(interp, "contour3d",   Contour3DCmd,   NULL, NULL);
+    Tcl_CreateObjCommand(interp, "cutplane",    CutplaneCmd,    NULL, NULL);
+    Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     NULL, NULL);
+    Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      NULL, NULL);
+    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   NULL, NULL);
+    Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      NULL, NULL);
+    Tcl_CreateObjCommand(interp, "lic",         LICCmd,         NULL, NULL);
+    Tcl_CreateObjCommand(interp, "molecule",    MoleculeCmd,    NULL, NULL);
+    Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    NULL, NULL);
+    Tcl_CreateObjCommand(interp, "pseudocolor", PseudoColorCmd, NULL, NULL);
+    Tcl_CreateObjCommand(interp, "renderer",    RendererCmd,    NULL, NULL);
+    Tcl_CreateObjCommand(interp, "screen",      ScreenCmd,      NULL, NULL);
+    Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, NULL, NULL);
+    Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      NULL, NULL);
+    return interp;
 }
 
 /**
  * \brief Delete Tcl commands and interpreter
+ *
  */
 void Rappture::VtkVis::exitTcl(Tcl_Interp *interp)
@@ -5006 +5393 @@
     Tcl_DeleteCommand(interp, "contour2d");
     Tcl_DeleteCommand(interp, "contour3d");
+    Tcl_DeleteCommand(interp, "cutplane");
     Tcl_DeleteCommand(interp, "dataset");
     Tcl_DeleteCommand(interp, "glyphs");
     Tcl_DeleteCommand(interp, "heightmap");
-    Tcl_DeleteCommand(interp, "imgflush");
     Tcl_DeleteCommand(interp, "legend");
     Tcl_DeleteCommand(interp, "lic");

branches/blt4/packages/vizservers/vtkvis/RpVtkRendererCmd.h

@@ -16 +16 @@
 
 extern int processCommands(Tcl_Interp *interp, FILE *fin, FILE *fout);
-extern void initTcl(Tcl_Interp *interp, ClientData clientData);
+extern Tcl_Interp *initTcl();
 extern void exitTcl(Tcl_Interp *interp);
 

branches/blt4/packages/vizservers/vtkvis/TGAWriter.cpp

@@ -17 +17 @@
 #include "TGAWriter.h"
 #include "Trace.h"
-#ifdef USE_THREADS
-#include "ResponseQueue.h"
-#endif
-
-#ifdef USE_THREADS
-
-/**
- * \brief Writes image command + data to supplied file descriptor.
- *
- * The image data must be supplied in BGR(A) order with bottom to 
- * top scanline ordering.
- *
- * \param[in] queue Pointer to ResponseQueue to write to
- * \param[in] cmdName Command name to send (byte length will be appended)
- * \param[in] data Image data
- * \param[in] width Width of image in pixels
- * \param[in] height Height of image in pixels
- * \param[in] bytesPerPixel Should be 3 or 4, depending on alpha
- */
-void
-Rappture::VtkVis::queueTGA(ResponseQueue *queue, const char *cmdName, 
-                           const unsigned char *data,
-                           int width, int height,
-                           int bytesPerPixel)
-{
-    TRACE("(%dx%d)\n", width, height);
-
-    size_t headerLength = 18;
-
-    char header[headerLength];
-    memset(header, 0, headerLength);
-    header[2] = (char)2;  // image type (2 = uncompressed true-color)
-    header[12] = (char)width;
-    header[13] = (char)(width >> 8);
-    header[14] = (char)height;
-    header[15] = (char)(height >> 8);
-    header[16] = (char)(bytesPerPixel*8); // bits per pixel
-
-    size_t dataLength = width * height * bytesPerPixel;
-    size_t cmdLength;
-
-    char command[200];
-    cmdLength = snprintf(command, sizeof(command), "%s %lu\n", cmdName, 
-                         (unsigned long)headerLength + dataLength);
-
-    size_t length;
-    unsigned char *mesg = NULL;
-
-    length = headerLength + dataLength + cmdLength;
-    mesg = (unsigned char *)malloc(length);
-    if (mesg == NULL) {
-        ERROR("can't allocate %ld bytes for the image message", length);
-        return;
-    }
-    memcpy(mesg, command, cmdLength);
-    memcpy(mesg + cmdLength, header, headerLength);
-    memcpy(mesg + cmdLength + headerLength, 
-           const_cast<unsigned char *>(data), dataLength);
-
-    Response *response = NULL;
-    if (strncmp(cmdName, "nv>legend", 9) == 0) {
-        response = new Response(Response::LEGEND);
-    } else {
-        response = new Response(Response::IMAGE);
-    }
-    response->setMessage(mesg, length, Response::DYNAMIC);
-    queue->enqueue(response);
-    TRACE("Leaving (%dx%d)\n", width, height);
-}
-#else
 
 /**
@@ -149 +79 @@
     TRACE("Leaving (%dx%d)\n", width, height);
 }
-#endif  /*USE_THREADS*/
 
 /**

branches/blt4/packages/vizservers/vtkvis/TGAWriter.h

@@ -9 +9 @@
 #define __RAPPTURE_VTKVIS_TGAWRITER_H__
 
-#ifdef USE_THREADS
-#include "ResponseQueue.h"
-#endif
-
 namespace Rappture {
 namespace VtkVis {
-#ifdef USE_THREADS
+
 extern
-void queueTGA(ResponseQueue *queue, const char *cmdName, 
-              const unsigned char *data, int width, int height, 
-              int bytesPerPixel);
-#else
+void writeTGA(int fd, const char *cmdName, const unsigned char *data,
+              int width, int height, int bytesPerPixel);
+
 extern
-void writeTGA(int fd, const char *cmdName, 
-              const unsigned char *data, int width, int height, 
-              int bytesPerPixel);
-#endif
-extern
-void writeTGAFile(const char *filename, 
-                  const unsigned char *data, int width, int height, 
-                  int bytesPerPixel, bool srcIsRGB = false);
+void writeTGAFile(const char *filename, const unsigned char *data,
+                  int width, int height, int bytesPerPixel,
+                  bool srcIsRGB = false);
+
 }
 }

branches/blt4/packages/vizservers/vtkvis/Trace.cpp

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 
@@ -21 +21 @@
  */
 void
-Rappture::VtkVis::initLog()
+Rappture::VtkVis::InitLog()
 {
     openlog("vtkvis", LOG_CONS | LOG_PERROR | LOG_PID,  LOG_USER);
@@ -30 +30 @@
  */
 void
-Rappture::VtkVis::closeLog()
+Rappture::VtkVis::CloseLog()
 {
     closelog();
@@ -39 +39 @@
  */
 void 
-Rappture::VtkVis::logMessage(int priority, const char *funcname,
+Rappture::VtkVis::LogMessage(int priority, const char *funcname,
                              const char *path, int lineNum, const char* fmt, ...)
 {

branches/blt4/packages/vizservers/vtkvis/Trace.h

@@ -3 +3 @@
  * Copyright (C) 2011, Purdue Research Foundation
  *
- * Author: ?
+ * Author: George A. Howlett <gah@purdue.edu>
  */
 
@@ -14 +14 @@
 namespace VtkVis {
 
-extern void initLog();
+extern void InitLog();
 
-extern void closeLog();
+extern void CloseLog();
 
-extern void logMessage(int priority, const char *funcname, const char *fileName,
-                       int lineNum, const char* format, ...);
+extern void LogMessage(int priority, const char *funcname, const char *fileName, int lineNum,
+                       const char* format, ...);
 
-#define ERROR(...)      Rappture::VtkVis::logMessage(LOG_ERR, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define ERROR(...)      LogMessage(LOG_ERR, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 #ifdef WANT_TRACE
-#define TRACE(...)      Rappture::VtkVis::logMessage(LOG_DEBUG, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define TRACE(...)      LogMessage(LOG_DEBUG, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 #else 
 #define TRACE(...) 
-#endif  /*WANT_TRACE*/
-#define WARN(...)       Rappture::VtkVis::logMessage(LOG_WARNING, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
-#define INFO(...)       Rappture::VtkVis::logMessage(LOG_INFO, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#endif
+#define WARN(...)       LogMessage(LOG_WARNING, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define INFO(...)       LogMessage(LOG_INFO, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 
 }

branches/blt4/packages/vizservers/vtkvis/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/blt4/packages/vizservers/vtkvis/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/blt4/packages/vizservers/vtkvis/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();