Changeset 2681 for branches/blt4/packages/vizservers/vtkvis

Timestamp:

Nov 15, 2011 11:56:51 AM (12 years ago)

Author:

gah

Message:

 

Location:

branches/blt4/packages/vizservers/vtkvis

Files:

• CmdProc.cpp (modified) (5 diffs)
• CmdProc.h (modified) (3 diffs)
• ColorMap.cpp (modified) (2 diffs)
• Makefile.in (modified) (8 diffs)
• PPMWriter.cpp (modified) (5 diffs)
• PPMWriter.h (modified) (1 diff)
• ResponseQueue.cpp (modified) (3 diffs)
• ResponseQueue.h (modified) (8 diffs)
• RpContour2D.cpp (modified) (3 diffs)
• RpContour2D.h (modified) (1 diff)
• RpContour3D.cpp (modified) (1 diff)
• RpContour3D.h (modified) (1 diff)
• RpCutplane.cpp (modified) (15 diffs)
• RpCutplane.h (modified) (4 diffs)
• RpGlyphs.cpp (modified) (11 diffs)
• RpGlyphs.h (modified) (4 diffs)
• RpHeightMap.cpp (modified) (8 diffs)
• RpHeightMap.h (modified) (4 diffs)
• RpLIC.cpp (modified) (2 diffs)
• RpLIC.h (modified) (3 diffs)
• RpMolecule.cpp (modified) (1 diff)
• RpMolecule.h (modified) (1 diff)
• RpPolyData.cpp (modified) (5 diffs)
• RpPseudoColor.cpp (modified) (13 diffs)
• RpPseudoColor.h (modified) (2 diffs)
• RpStreamlines.cpp (modified) (22 diffs)
• RpStreamlines.h (modified) (8 diffs)
• RpVolume.cpp (modified) (3 diffs)
• RpVolume.h (modified) (1 diff)
• RpVtkDataSet.cpp (modified) (8 diffs)
• RpVtkDataSet.h (modified) (3 diffs)
• RpVtkGraphicsObject.h (modified) (5 diffs)
• RpVtkRenderServer.cpp (modified) (14 diffs)
• RpVtkRenderServer.h (modified) (1 diff)
• RpVtkRenderer.cpp (modified) (42 diffs)
• RpVtkRenderer.h (modified) (15 diffs)
• RpVtkRendererCmd.cpp (modified) (187 diffs)
• RpVtkRendererCmd.h (modified) (1 diff)
• TGAWriter.cpp (modified) (2 diffs)
• TGAWriter.h (modified) (1 diff)
• Trace.cpp (modified) (4 diffs)
• Trace.h (modified) (1 diff)
• protocol.txt (modified) (7 diffs)

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

@@ -10 +10 @@
 
 #include "CmdProc.h"
+
+using namespace Rappture;
 
 /**
@@ -22 +24 @@
  */
 static int
-BinaryOpSearch(Rappture::CmdSpec *specs, 
+BinaryOpSearch(CmdSpec *specs, 
                int nSpecs, 
                char *string)       /* Name of minor operation to search for */
@@ -35 +37 @@
     length = strlen(string);
     while (low <= high) {
-        Rappture::CmdSpec *specPtr;
+        CmdSpec *specPtr;
         int compare;
         int median;
@@ -76 +78 @@
  */
 static int
-LinearOpSearch(Rappture::CmdSpec *specs,
+LinearOpSearch(CmdSpec *specs,
                int nSpecs,
                char *string)       /* Name of minor operation to search for */
 {
-    Rappture::CmdSpec *specPtr;
+    CmdSpec *specPtr;
     char c;
     size_t length;
@@ -120 +122 @@
  */
 Tcl_ObjCmdProc *
-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 */
+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 */
                        int flags)
 {

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

@@ -19 +19 @@
  * for a function pointer associated with the operation name.
  */
-typedef struct {
+struct CmdSpec {
     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;
+};
 
-typedef enum {
+enum CmdSpecIndex {
     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/ColorMap.cpp

@@ -106 +106 @@
         cp.value = 1.0;
 
+#ifdef DEBUG
     TRACE("New control point: %g  = %g %g %g",
           cp.value, cp.color[0], cp.color[1], cp.color[2]);
-
+#endif
     for (std::list<ControlPoint>::iterator itr = _controlPoints.begin();
          itr != _controlPoints.end(); ++itr) {
@@ -136 +137 @@
         cp.value = 1.0;
 
+#ifdef DEBUG
     TRACE("New opacity control point: %g  = %g",
           cp.value, cp.alpha);
-
+#endif
     for (std::list<OpacityControlPoint>::iterator itr = _opacityControlPoints.begin();
          itr != _opacityControlPoints.end(); ++itr) {

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

@@ -24 +24 @@
 
 GL_LIB_SPEC     = -lGL -lm
+PTHREAD_LIB_SPEC= -lpthread
 
 TCL_LIB_SPEC    = @TCL_LIB_SPEC@
@@ -35 +36 @@
 
 LIBS            = \
-                $(GL_LIB_SPEC) \
                 $(TCL_LIB_SPEC) \
                 $(VTK_LIB_SPEC) \
+                $(GL_LIB_SPEC) \
+                $(PTHREAD_LIB_SPEC) \
                 -Wl,-rpath,$(LD_RUN_PATH)
 
@@ -49 +51 @@
 USE_CUSTOM_AXES         = yes
 USE_GPU_RAYCASTING      = yes
-USE_OFFSCREEN_RENDERING = yes
+USE_OFFSCREEN_RENDERING = #yes
+USE_THREADS             = yes
 
 #vtk uses deprecated strstream header (instead of sstream)
@@ -70 +73 @@
 DEFINES         += -DUSE_GPU_RAYCAST_MAPPER
 endif
+ifdef USE_THREADS
+DEFINES         += -DUSE_THREADS
+endif
 CXX_SWITCHES    = $(CXXFLAGS) $(EXTRA_CFLAGS) $(DEFINES) $(INCLUDES)
 
@@ -76 +82 @@
                 ColorMap.cpp \
                 PPMWriter.cpp \
+                ReadBuffer.cpp \
                 RpContour2D.cpp \
                 RpContour3D.cpp \
@@ -88 +95 @@
                 RpVolume.cpp \
                 RpVtkDataSet.cpp \
-                RpVtkRenderer.cpp\
+                RpVtkGraphicsObject.cpp \
+                RpVtkRenderer.cpp \
                 RpVtkRendererCmd.cpp \
+                RpVtkRendererGraphicsObjs.cpp \
                 RpVtkRenderServer.cpp \
                 TGAWriter.cpp \
@@ -96 +105 @@
 ifdef USE_CUSTOM_AXES
 SERVER_SRCS+=vtkRpCubeAxesActor2D.cpp
+endif
+ifdef USE_THREADS
+SERVER_SRCS+=ResponseQueue.cpp
 endif
 
@@ -130 +142 @@
 CmdProc.o: CmdProc.h
 ColorMap.o: ColorMap.h RpMolecule.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
-RpLIC.o: RpLIC.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h RpVtkRenderServer.h
-RpMolecule.o: RpMolecule.h RpMoleculeData.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
-RpPolyData.o: RpPolyData.h RpVtkGraphicsObject.h RpVtkDataSet.h Trace.h
-RpPseudoColor.o: RpPseudoColor.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
-RpStreamlines.o: RpStreamlines.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
-RpVolume.o: RpVolume.h RpVtkGraphicsObject.h RpVtkDataSet.h ColorMap.h Trace.h
+PPMWriter.o: PPMWriter.h ResponseQueue.h Trace.h
+ReadBuffer.o: ReadBuffer.h Trace.h
+ResponseQueue.o: ResponseQueue.h Trace.h
+RpContour2D.o: RpContour2D.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h Trace.h
+RpContour3D.o: RpContour3D.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpCutplane.o: RpCutplane.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpGlyphs.o: RpGlyphs.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpHeightMap.o: RpHeightMap.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpLIC.o: RpLIC.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h RpVtkRenderServer.h
+RpMolecule.o: RpMolecule.h RpMoleculeData.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpPolyData.o: RpPolyData.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h Trace.h
+RpPseudoColor.o: RpPseudoColor.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpStreamlines.o: RpStreamlines.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
+RpVolume.o: RpVolume.h RpVtkGraphicsObject.h RpVtkDataSet.h RpVtkRenderer.h ColorMap.h Trace.h
 RpVtkDataSet.o: RpVtkDataSet.h Trace.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
+RpVtkGraphicsObject.o: RpVtkGraphicsObject.h RpVtkRenderer.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
+RpVtkRenderer.o: RpVtkRenderer.h RpMath.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.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 RpVtkRendererGraphicsObjs.h vtkRpCubeAxesActor2D.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RpVtkRendererGraphicsObjs.o: RpVtkRenderer.h RpVtkRendererGraphicsObjs.h RpVtkDataSet.h RpContour2D.h RpContour3D.h RpCutplane.h RpGlyphs.h RpHeightMap.h RpLIC.h RpMolecule.h RpPolyData.h RpPseudoColor.h RpStreamlines.h RpVolume.h ColorMap.h Trace.h
+RpVtkRenderServer.o: RpVtkRenderServer.h RpVtkRendererCmd.h RpVtkRenderer.h vtkRpCubeAxesActor2D.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
 Trace.o: Trace.h
-TGAWriter.o: TGAWriter.h Trace.h
+TGAWriter.o: TGAWriter.h ResponseQueue.h Trace.h
 vtkRpCubeAxesActor2D.o: vtkRpCubeAxesActor2D.h

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

@@ -12 +12 @@
 #include <sys/uio.h>
 
+#include "Trace.h"
 #include "PPMWriter.h"
-#include "Trace.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
 
 /**
@@ -39 +121 @@
  */
 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
@@ -47 +129 @@
     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);
@@ -79 +162 @@
     }
     if (writev(fd, iov, nRecs) < 0) {
-        ERROR("write failed: %s\n", strerror(errno));
+        ERROR("write failed: %s\n", strerror(errno));
     }
     free(iov);
@@ -85 +168 @@
     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 writePPM(int fd, const char *cmdName, const unsigned char *data, int width, int height);
-
+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
 }
 }
-
 #endif

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

@@ -29 +29 @@
 ResponseQueue::~ResponseQueue() 
 {
+    TRACE("Deleting ResponseQueue");
     pthread_mutex_destroy(&_idle);
     if (sem_destroy(&_ready) < 0) {
         ERROR("can't destroy semaphore: %s", strerror(errno));
     }
+    for (std::list<Response *>::iterator itr = _list.begin();
+         itr != _list.end(); ++itr) {
+        delete *itr;
+    }
+    _list.clear();
 }
 
@@ -64 +70 @@
 ResponseQueue::dequeue()
 {
-    Response *response;
+    Response *response = NULL;
 
     if (sem_wait(&_ready) < 0) {
@@ -71 +77 @@
     if (pthread_mutex_lock(&_idle) != 0) {
         ERROR("can't lock mutex: %s", strerror(errno));
-    }   
-    response = _list.front();
-    _list.pop_front();
+    }
+    if (_list.empty()) {
+        ERROR("Empty queue");
+    } else {
+        response = _list.front();
+        _list.pop_front();
+    }
     if (pthread_mutex_unlock(&_idle) != 0) {
         ERROR("can't unlock mutex: %s", strerror(errno));

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

@@ -17 +17 @@
 namespace VtkVis {
 
+/**
+ * \brief Holds data for a response to be sent to client
+ */
 class Response
 {
@@ -40 +43 @@
     virtual ~Response()
     {
-        if (_length > 0) {
-            if (_allocType == DYNAMIC) {
-                free(_mesg);
-            }
+        if ((_length > 0) && (_mesg != NULL) && (_allocType == DYNAMIC)) {
+            free(_mesg);
         }
     }
 
+    /// Get the ResponseType
     ResponseType type()
     {
@@ -52 +54 @@
     }
 
+    /// Get the Response data
     unsigned char *message()
     {
@@ -57 +60 @@
     }
 
+    /// Get the number of bytes in the Response data
     size_t length()
     {
@@ -62 +66 @@
     }
 
+    /// Set the message/data making up the Response
+    /**
+     * If the AllocationType is DYNAMIC, the message data will be free()d
+     * by the destructor.  If the AllocationType is VOLATILE, a copy of 
+     * the message data will be made.
+     *
+     * \param[in] mesg The Response data, can be a command and/or binary data
+     * \param[in] length The number of bytes in mesg
+     * \param[in] type Specify how the memory was allocated for mesg
+     */ 
     void setMessage(unsigned char *mesg, size_t length, AllocationType type)
     {
@@ -86 +100 @@
 };
 
+/**
+ * \brief Queue to hold pending Responses to be sent to the client
+ *
+ * A semaphore and mutex are used to control access to the 
+ * queue by a reader and writer thread
+ */
 class ResponseQueue
 {
@@ -93 +113 @@
     virtual ~ResponseQueue();
 
+    /// A place to store a data pointer.  Not used internally.
+    /* XXX: This probably doesn't belong here */
     void *clientData()
     {
@@ -98 +120 @@
     }
 
+    /// Add a response to the end of the queue
     void enqueue(Response *response);
 
+    /// Remove a response from the front of the queue
     Response *dequeue();
 

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

@@ -100 +100 @@
             pd->GetNumberOfStrips() == 0) {
             // DataSet is a point cloud
-            DataSet::PrincipalPlane plane;
+            PrincipalPlane plane;
             double offset;
             if (_dataSet->is2D(&plane, &offset)) {
                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
-                if (plane == DataSet::PLANE_ZY) {
+                if (plane == PLANE_ZY) {
                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(90, 0, 1, 0);
@@ -111 +111 @@
                     }
                     mesher->SetTransform(trans);
-                } else if (plane == DataSet::PLANE_XZ) {
+                } else if (plane == PLANE_XZ) {
                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(-90, 1, 0, 0);
@@ -179 +179 @@
 }
 
-void Contour2D::updateRanges(bool useCumulative,
-                             double scalarRange[2],
-                             double vectorMagnitudeRange[2],
-                             double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    } else {
-        WARN("updateRanges called before setDataSet");
-    }
-
+void Contour2D::updateRanges(Renderer *renderer)
+{
+    VtkGraphicsObject::updateRanges(renderer);
+ 
     if (_contours.empty() && _numContours > 0) {
         // Contour isovalues need to be recomputed

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

@@ -48 +48 @@
     const std::vector<double>& getContourList() const;
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
     virtual void setColor(float color[3])

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

@@ -186 +186 @@
 }
 
-void Contour3D::updateRanges(bool useCumulative,
-                             double scalarRange[2],
-                             double vectorMagnitudeRange[2],
-                             double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    }
+void Contour3D::updateRanges(Renderer *renderer)
+{
+    VtkGraphicsObject::updateRanges(renderer);
 
     if (_lut != NULL) {

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

@@ -62 +62 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:

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

@@ -7 +7 @@
 
 #include <cassert>
+#include <cfloat>
+#include <cstring>
 
 #include <vtkDataSet.h>
@@ -25 +27 @@
 
 #include "RpCutplane.h"
+#include "RpVtkRenderer.h"
 #include "Trace.h"
 
@@ -33 +36 @@
 Cutplane::Cutplane() :
     VtkGraphicsObject(),
+    _colorMap(NULL),
     _colorMode(COLOR_BY_SCALAR),
-    _colorMap(NULL),
-    _sliceAxis(Z_AXIS)
-{
+    _colorFieldType(DataSet::POINT_DATA),
+    _renderer(NULL)
+{
+    _colorFieldRange[0] = DBL_MAX;
+    _colorFieldRange[1] = -DBL_MAX;
 }
 
@@ -50 +56 @@
 
 void Cutplane::setDataSet(DataSet *dataSet,
-                          bool useCumulative,
-                          double scalarRange[2],
-                          double vectorMagnitudeRange[2],
-                          double vectorComponentRange[3][2])
+                          Renderer *renderer)
 {
     if (_dataSet != dataSet) {
         _dataSet = dataSet;
 
-        if (useCumulative) {
-            _dataRange[0] = scalarRange[0];
-            _dataRange[1] = scalarRange[1];
-            _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-            _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
-            for (int i = 0; i < 3; i++) {
-                _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-                _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+        _renderer = renderer;
+
+        if (renderer->getUseCumulativeRange()) {
+            renderer->getCumulativeDataRange(_dataRange,
+                                             _dataSet->getActiveScalarsName(),
+                                             1);
+            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                             _dataSet->getActiveVectorsName(),
+                                             3);
+            for (int i = 0; i < 3; i++) {
+                renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                                 _dataSet->getActiveVectorsName(),
+                                                 3, i);
             }
         } else {
@@ -79 +87 @@
 }
 
+/**
+ * \brief Create and initialize a VTK Prop to render the object
+ */
+void Cutplane::initProp()
+{
+    if (_prop == NULL) {
+        _prop = vtkSmartPointer<vtkAssembly>::New();
+
+        for (int i = 0; i < 3; i++) {
+            _actor[i] = vtkSmartPointer<vtkActor>::New();
+            //_actor[i]->VisibilityOff();
+            vtkProperty *property = _actor[i]->GetProperty();
+            property->SetColor(_color[0], _color[1], _color[2]);
+            property->SetEdgeColor(_edgeColor[0], _edgeColor[1], _edgeColor[2]);
+            property->SetLineWidth(_edgeWidth);
+            property->SetPointSize(_pointSize);
+            property->EdgeVisibilityOff();
+            property->SetOpacity(_opacity);
+            property->SetAmbient(.2);
+            if (!_lighting)
+                property->LightingOff();
+            if (_faceCulling && _opacity == 1.0) {
+                setCulling(property, true);
+            }
+            getAssembly()->AddPart(_actor[i]);
+        }
+    }
+}
+
 void Cutplane::update()
 {
@@ -86 +123 @@
     vtkDataSet *ds = _dataSet->getVtkDataSet();
 
+    double bounds[6];
+    _dataSet->getBounds(bounds);
     // Mapper, actor to render color-mapped data set
-    if (_mapper == NULL) {
-        _mapper = vtkSmartPointer<vtkDataSetMapper>::New();
-        // Map scalars through lookup table regardless of type
-        _mapper->SetColorModeToMapScalars();
-        //_mapper->InterpolateScalarsBeforeMappingOn();
-    }
+    for (int i = 0; i < 3; i++) {
+        if (_mapper[i] == NULL) {
+            _mapper[i] = vtkSmartPointer<vtkDataSetMapper>::New();
+            // Map scalars through lookup table regardless of type
+            _mapper[i]->SetColorModeToMapScalars();
+            //_mapper->InterpolateScalarsBeforeMappingOn();
+        }
+        _cutPlane[i] = vtkSmartPointer<vtkPlane>::New();
+        switch (i) {
+        case 0:
+            _cutPlane[i]->SetNormal(1, 0, 0);
+            _cutPlane[i]->SetOrigin(bounds[0] + (bounds[1]-bounds[0])/2.,
+                                    0,
+                                    0);
+            break;
+        case 1:
+            _cutPlane[i]->SetNormal(0, 1, 0);
+            _cutPlane[i]->SetOrigin(0,
+                                    bounds[2] + (bounds[3]-bounds[2])/2.,
+                                    0);
+            break;
+        case 2:
+        default:
+            _cutPlane[i]->SetNormal(0, 0, 1);
+            _cutPlane[i]->SetOrigin(0,
+                                    0,
+                                    bounds[4] + (bounds[5]-bounds[4])/2.);
+            break;
+        }
+        _cutter[i] = vtkSmartPointer<vtkCutter>::New();
+        _cutter[i]->SetCutFunction(_cutPlane[i]);
+    }
+
+    initProp();
 
     vtkPolyData *pd = vtkPolyData::SafeDownCast(ds);
-    if (pd) {
-        // DataSet is a vtkPolyData
-        if (pd->GetNumberOfLines() == 0 &&
-            pd->GetNumberOfPolys() == 0 &&
-            pd->GetNumberOfStrips() == 0) {
-            // DataSet is a point cloud
-            DataSet::PrincipalPlane plane;
-            double offset;
-            if (_dataSet->is2D(&plane, &offset)) {
-                // DataSet is a 2D point cloud
+    if (pd && 
+        pd->GetNumberOfLines() == 0 &&
+        pd->GetNumberOfPolys() == 0 &&
+        pd->GetNumberOfStrips() == 0) {
+        // DataSet is a point cloud
+        PrincipalPlane plane;
+        double offset;
+        if (_dataSet->is2D(&plane, &offset)) {
+            // DataSet is a 2D point cloud
 #ifdef MESH_POINT_CLOUDS
-                vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
-                if (plane == DataSet::PLANE_ZY) {
-                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
-                    trans->RotateWXYZ(90, 0, 1, 0);
-                    if (offset != 0.0) {
-                        trans->Translate(-offset, 0, 0);
-                    }
-                    mesher->SetTransform(trans);
-                    _sliceAxis = X_AXIS;
-                } else if (plane == DataSet::PLANE_XZ) {
-                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
-                    trans->RotateWXYZ(-90, 1, 0, 0);
-                    if (offset != 0.0) {
-                        trans->Translate(0, -offset, 0);
-                    }
-                    mesher->SetTransform(trans);
-                    _sliceAxis = Y_AXIS;
-                } else if (offset != 0.0) {
-                    // XY with Z offset
-                    vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
-                    trans->Translate(0, 0, -offset);
-                    mesher->SetTransform(trans);
+            vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
+            if (plane == PLANE_ZY) {
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->RotateWXYZ(90, 0, 1, 0);
+                if (offset != 0.0) {
+                    trans->Translate(-offset, 0, 0);
                 }
-                mesher->SetInput(pd);
-                _mapper->SetInputConnection(mesher->GetOutputPort());
+                mesher->SetTransform(trans);
+                _actor[1]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } else if (plane == PLANE_XZ) {
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->RotateWXYZ(-90, 1, 0, 0);
+                if (offset != 0.0) {
+                    trans->Translate(0, -offset, 0);
+                }
+                mesher->SetTransform(trans);
+                _actor[0]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } else if (offset != 0.0) {
+                // XY with Z offset
+                vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
+                trans->Translate(0, 0, -offset);
+                mesher->SetTransform(trans);
+                _actor[0]->VisibilityOff();
+                _actor[1]->VisibilityOff();
+            }
+            mesher->SetInput(pd);
+            for (int i = 0; i < 3; i++) {
+                _mapper[i]->SetInputConnection(mesher->GetOutputPort());
+            }
 #else
-                vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
-                splatter->SetInput(pd);
-                int dims[3];
-                splatter->GetSampleDimensions(dims);
-                TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
+            vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
+            splatter->SetInput(pd);
+            int dims[3];
+            splatter->GetSampleDimensions(dims);
+            TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
+            if (plane == DataSet::PLANE_ZY) {
+                dims[0] = 3;
+            } else if (plane == DataSet::PLANE_XZ) {
+                dims[1] = 3;
+            } else {
                 dims[2] = 3;
-                splatter->SetSampleDimensions(dims);
-                double bounds[6];
-                splatter->Update();
-                splatter->GetModelBounds(bounds);
-                TRACE("Model bounds: %g %g %g %g %g %g",
-                      bounds[0], bounds[1],
-                      bounds[2], bounds[3],
-                      bounds[4], bounds[5]);
-                vtkSmartPointer<vtkExtractVOI> slicer = vtkSmartPointer<vtkExtractVOI>::New();
-                slicer->SetInputConnection(splatter->GetOutputPort());
-                slicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, 1, 1);
-                slicer->SetSampleRate(1, 1, 1);
+            }
+            splatter->SetSampleDimensions(dims);
+            for (int i = 0; i < 3; i++) {
+                _cutter[i]->SetInputConnection(splatter->GetOutputPort());
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
                 gf->UseStripsOn();
-                gf->SetInputConnection(slicer->GetOutputPort());
-                _mapper->SetInputConnection(gf->GetOutputPort());
+                gf->SetInputConnection(_cutter[i]->GetOutputPort());
+                _mapper[i]->SetInputConnection(gf->GetOutputPort());
+            }
 #endif
-            } else {
+        } else {
 #ifdef MESH_POINT_CLOUDS
-                // Data Set is a 3D point cloud
-                // Result of Delaunay3D mesher is unstructured grid
-                vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
-                mesher->SetInput(pd);
-                // Run the mesher
-                mesher->Update();
-                // Get bounds of resulting grid
-                double bounds[6];
-                mesher->GetOutput()->GetBounds(bounds);
-                // Sample a plane within the grid bounding box
-                vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
-                cutter->SetInputConnection(mesher->GetOutputPort());
-                if (_cutPlane == NULL) {
-                    _cutPlane = vtkSmartPointer<vtkPlane>::New();
-                }
-                _cutPlane->SetNormal(0, 0, 1);
-                _cutPlane->SetOrigin(0,
-                                     0,
-                                     bounds[4] + (bounds[5]-bounds[4])/2.);
-                cutter->SetCutFunction(_cutPlane);
+            // Data Set is a 3D point cloud
+            // Result of Delaunay3D mesher is unstructured grid
+            vtkSmartPointer<vtkDelaunay3D> mesher = vtkSmartPointer<vtkDelaunay3D>::New();
+            mesher->SetInput(pd);
+            // Sample a plane within the grid bounding box
+            for (int i = 0; i < 3; i++) {
+                _cutter[i]->SetInputConnection(mesher->GetOutputPort());
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
                 gf->UseStripsOn();
-                gf->SetInputConnection(cutter->GetOutputPort());
+                gf->SetInputConnection(_cutter[i]->GetOutputPort());
+                _mapper[i]->SetInputConnection(gf->GetOutputPort());
+            }
 #else
-                if (_pointSplatter == NULL)
-                    _pointSplatter = vtkSmartPointer<vtkGaussianSplatter>::New();
-                _pointSplatter->SetInput(pd);
-                int dims[3];
-                _pointSplatter->GetSampleDimensions(dims);
-                TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
-                dims[2] = 3;
-                _pointSplatter->SetSampleDimensions(dims);
-                double bounds[6];
-                _pointSplatter->Update();
-                _pointSplatter->GetModelBounds(bounds);
-                TRACE("Model bounds: %g %g %g %g %g %g",
-                      bounds[0], bounds[1],
-                      bounds[2], bounds[3],
-                      bounds[4], bounds[5]);
-                if (_volumeSlicer == NULL)
-                    _volumeSlicer = vtkSmartPointer<vtkExtractVOI>::New();
-                _volumeSlicer->SetInputConnection(_pointSplatter->GetOutputPort());
-                _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, 1, 1);
-                _volumeSlicer->SetSampleRate(1, 1, 1);
+            vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
+            splatter->SetInput(pd);
+            int dims[3];
+            splatter->GetSampleDimensions(dims);
+            TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
+            for (int i = 0; i < 3; i++) {
+                _cutter[i]->SetInputConnection(splatter->GetOutputPort());
                 vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
                 gf->UseStripsOn();
-                gf->SetInputConnection(_volumeSlicer->GetOutputPort());
+                gf->SetInputConnection(_cutter[i]->GetOutputPort());
+                _mapper[i]->SetInputConnection(gf->GetOutputPort());
+            }
 #endif
-                _mapper->SetInputConnection(gf->GetOutputPort());
-             }
-        } else {
-            // DataSet is a vtkPolyData with lines and/or polygons
-            _mapper->SetInput(ds);
         }
     } else {
-        // DataSet is NOT a vtkPolyData
-        // Can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid
-        vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
-        gf->UseStripsOn();
-        vtkImageData *imageData = vtkImageData::SafeDownCast(ds);
-        if (!_dataSet->is2D() && imageData != NULL) {
-            // 3D image/volume/uniform grid
-            if (_volumeSlicer == NULL)
-                _volumeSlicer = vtkSmartPointer<vtkExtractVOI>::New();
-            int dims[3];
-            imageData->GetDimensions(dims);
-            TRACE("Image data dimensions: %d %d %d", dims[0], dims[1], dims[2]);
-            _volumeSlicer->SetInput(ds);
-            _volumeSlicer->SetVOI(0, dims[0]-1, 0, dims[1]-1, (dims[2]-1)/2, (dims[2]-1)/2);
-            _volumeSlicer->SetSampleRate(1, 1, 1);
-            gf->SetInputConnection(_volumeSlicer->GetOutputPort());
-        } else if (!_dataSet->is2D() && imageData == NULL) {
-            // 3D structured grid, unstructured grid, or rectilinear grid
-            double bounds[6];
-            ds->GetBounds(bounds);
+        // DataSet can be: image/volume/uniform grid, structured grid, unstructured grid, rectilinear grid, or
+        // PolyData with cells other than points
+        PrincipalPlane plane;
+        double offset;
+        if (!_dataSet->is2D(&plane, &offset)) {
             // Sample a plane within the grid bounding box
-            vtkSmartPointer<vtkCutter> cutter = vtkSmartPointer<vtkCutter>::New();
-            cutter->SetInput(ds);
-            if (_cutPlane == NULL) {
-                _cutPlane = vtkSmartPointer<vtkPlane>::New();
-            }
-            _cutPlane->SetNormal(0, 0, 1);
-            _cutPlane->SetOrigin(0,
-                                 0,
-                                 bounds[4] + (bounds[5]-bounds[4])/2.);
-            cutter->SetCutFunction(_cutPlane);
-            gf->SetInputConnection(cutter->GetOutputPort());
+            for (int i = 0; i < 3; i++) {
+                _cutter[i]->SetInput(ds);
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->UseStripsOn();
+                gf->SetInputConnection(_cutter[i]->GetOutputPort());
+                _mapper[i]->SetInputConnection(gf->GetOutputPort());
+            }
         } else {
             // 2D data
-            gf->SetInput(ds);
-        }
-        _mapper->SetInputConnection(gf->GetOutputPort());
+            if (plane == PLANE_ZY) {
+                _actor[1]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } else if (plane == PLANE_XZ) {
+                _actor[0]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } else if (offset != 0.0) {
+                // XY with Z offset
+                _actor[0]->VisibilityOff();
+                _actor[1]->VisibilityOff();
+            }
+            for (int i = 0; i < 3; i++) {
+                vtkSmartPointer<vtkDataSetSurfaceFilter> gf = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
+                gf->UseStripsOn();
+                gf->SetInput(ds);
+                _mapper[i]->SetInputConnection(gf->GetOutputPort());
+            }
+        }
     }
 
@@ -255 +294 @@
     }
 
-    initProp();
-    getActor()->SetMapper(_mapper);
-    _mapper->Update();
-}
-
+    setColorMode(_colorMode);
+
+    for (int i = 0; i < 3; i++) {
+        if (_mapper[i] != NULL) {
+            _actor[i]->SetMapper(_mapper[i]);
+            _mapper[i]->Update();
+        }
+    }
+}
 
 /**
@@ -274 +317 @@
     }
 
-    if (_volumeSlicer == NULL &&
-        _cutPlane == NULL) {
+    if ((axis == X_AXIS &&_cutPlane[0] == NULL) ||
+        (axis == Y_AXIS &&_cutPlane[1] == NULL) ||
+        (axis == Z_AXIS &&_cutPlane[2] == NULL)) {
         WARN("Called before update() or DataSet is not a volume");
         return;
     }
 
-    _sliceAxis = axis;
-
-    if (_cutPlane != NULL) {
-        double bounds[6];
-        _dataSet->getBounds(bounds);
-        switch (axis) {
-        case X_AXIS:
-            _cutPlane->SetNormal(1, 0, 0);
-            _cutPlane->SetOrigin(bounds[0] + (bounds[1]-bounds[0]) * ratio,
-                                 0,
-                                 0);
-            break;
-        case Y_AXIS:
-            _cutPlane->SetNormal(0, 1, 0);
-            _cutPlane->SetOrigin(0,
-                                 bounds[2] + (bounds[3]-bounds[2]) * ratio,
-                                 0);
-            break;
-        case Z_AXIS:
-            _cutPlane->SetNormal(0, 0, 1);
-            _cutPlane->SetOrigin(0,
-                                 0,
-                                 bounds[4] + (bounds[5]-bounds[4]) * ratio);
-            break;
-        default:
-            ERROR("Invalid Axis");
-            return;
+    double bounds[6];
+    _dataSet->getBounds(bounds);
+    switch (axis) {
+    case X_AXIS:
+        _cutPlane[0]->SetOrigin(bounds[0] + (bounds[1]-bounds[0]) * ratio,
+                                0,
+                                0);
+        if (_mapper[0] != NULL)
+            _mapper[0]->Update();
+        break;
+    case Y_AXIS:
+        _cutPlane[1]->SetOrigin(0,
+                                bounds[2] + (bounds[3]-bounds[2]) * ratio,
+                                0);
+        if (_mapper[1] != NULL)
+            _mapper[1]->Update();
+        break;
+    case Z_AXIS:
+        _cutPlane[2]->SetOrigin(0,
+                                0,
+                                bounds[4] + (bounds[5]-bounds[4]) * ratio);
+        if (_mapper[2] != NULL)
+            _mapper[2]->Update();
+        break;
+    default:
+        ERROR("Invalid Axis");
+        return;
+    }
+}
+
+void Cutplane::updateRanges(Renderer *renderer)
+{
+    if (_dataSet == NULL) {
+        ERROR("called before setDataSet");
+        return;
+    }
+
+    if (renderer->getUseCumulativeRange()) {
+        renderer->getCumulativeDataRange(_dataRange,
+                                         _dataSet->getActiveScalarsName(),
+                                         1);
+        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                         _dataSet->getActiveVectorsName(),
+                                         3);
+        for (int i = 0; i < 3; i++) {
+            renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                             _dataSet->getActiveVectorsName(),
+                                             3, i);
         }
     } else {
-        int dims[3];
-        if (_pointSplatter != NULL) {
-            _pointSplatter->GetSampleDimensions(dims);
-        } else {
-            vtkImageData *imageData = vtkImageData::SafeDownCast(_dataSet->getVtkDataSet());
-            if (imageData == NULL) {
-                ERROR("Not a volume data set");
-                return;
-            }
-            imageData->GetDimensions(dims);
-        }
-        int voi[6];
-
-        switch (axis) {
-        case X_AXIS:
-            voi[0] = voi[1] = (int)((dims[0]-1) * ratio);
-            voi[2] = 0;
-            voi[3] = dims[1]-1;
-            voi[4] = 0;
-            voi[5] = dims[2]-1;
-            break;
-        case Y_AXIS:
-            voi[0] = 0;
-            voi[1] = dims[0]-1;
-            voi[2] = voi[3] = (int)((dims[1]-1) * ratio);
-            voi[4] = 0;
-            voi[5] = dims[2]-1;
-            break;
-        case Z_AXIS:
-            voi[0] = 0;
-            voi[1] = dims[0]-1;
-            voi[2] = 0;
-            voi[3] = dims[1]-1;
-            voi[4] = voi[5] = (int)((dims[2]-1) * ratio);
-            break;
-        default:
-            ERROR("Invalid Axis");
-            return;
-        }
-
-        _volumeSlicer->SetVOI(voi);
-    }
-
-    if (_mapper != NULL)
-        _mapper->Update();
-}
-
-void Cutplane::updateRanges(bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-        _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-        _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
-        for (int i = 0; i < 3; i++) {
-            _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-            _vectorComponentRange[i][1] = vectorComponentRange[i][1];
-        }
-    } else if (_dataSet != NULL) {
         _dataSet->getScalarRange(_dataRange);
         _dataSet->getVectorRange(_vectorMagnitudeRange);
@@ -378 +381 @@
     }
 
-    // Need to update color map ranges and/or active vector field
-    setColorMode(_colorMode);
+    // Need to update color map ranges
+    double *rangePtr = _colorFieldRange;
+    if (_colorFieldRange[0] > _colorFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
 }
 
@@ -385 +392 @@
 {
     _colorMode = mode;
-    if (_dataSet == NULL || _mapper == NULL)
-        return;
-
-    vtkDataSet *ds = _dataSet->getVtkDataSet();
+    if (_dataSet == NULL)
+        return;
 
     switch (mode) {
-    case COLOR_BY_SCALAR: {
-        _mapper->ScalarVisibilityOn();
-        _mapper->SetScalarModeToDefault();
+    case COLOR_BY_SCALAR:
+        setColorMode(mode,
+                     _dataSet->getActiveScalarsType(),
+                     _dataSet->getActiveScalarsName(),
+                     _dataRange);
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorMagnitudeRange);
+        break;
+    case COLOR_BY_VECTOR_X:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[0]);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[1]);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[2]);
+        break;
+    default:
+        ;
+    }
+}
+
+void Cutplane::setColorMode(ColorMode mode,
+                            const char *name, double range[2])
+{
+    if (_dataSet == NULL)
+        return;
+    DataSet::DataAttributeType type;
+    int numComponents;
+    if (!_dataSet->getFieldInfo(name, &type, &numComponents)) {
+        ERROR("Field not found: %s", name);
+        return;
+    }
+    setColorMode(mode, type, name, range);
+}
+
+void Cutplane::setColorMode(ColorMode mode,
+                            DataSet::DataAttributeType type,
+                            const char *name, double range[2])
+{
+    _colorMode = mode;
+    _colorFieldType = type;
+    if (name == NULL)
+        _colorFieldName.clear();
+    else
+        _colorFieldName = name;
+    if (range == NULL) {
+        _colorFieldRange[0] = DBL_MAX;
+        _colorFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_colorFieldRange, range, sizeof(double)*2);
+    }
+
+    if (_dataSet == NULL ||
+        _mapper[0] == NULL ||
+        _mapper[1] == NULL ||
+        _mapper[2] == NULL)
+        return;
+
+    switch (type) {
+    case DataSet::POINT_DATA:
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->SetScalarModeToUsePointFieldData();
+        }
+        break;
+    case DataSet::CELL_DATA:
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->SetScalarModeToUseCellFieldData();
+        }
+        break;
+    default:
+        ERROR("Unsupported DataAttributeType: %d", type);
+        return;
+    }
+
+    if (name != NULL && strlen(name) > 0) {
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->SelectColorArray(name);
+        }
+    } else {
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->SetScalarModeToDefault();
+        }
+    }
+
+    if (_lut != NULL) {
+        if (range != NULL) {
+            _lut->SetRange(range);
+        } else if (name != NULL && strlen(name) > 0) {
+            double r[2];
+            int comp = -1;
+            if (mode == COLOR_BY_VECTOR_X)
+                comp = 0;
+            else if (mode == COLOR_BY_VECTOR_Y)
+                comp = 1;
+            else if (mode == COLOR_BY_VECTOR_Z)
+                comp = 2;
+
+            if (_renderer->getUseCumulativeRange()) {
+                int numComponents;
+                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                    ERROR("Field not found: %s, type: %d", name, type);
+                    return;
+                } else if (numComponents < comp+1) {
+                    ERROR("Request for component %d in field with %d components",
+                          comp, numComponents);
+                    return;
+                }
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+            _lut->SetRange(r);
+        }
+    }
+
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
         if (_lut != NULL) {
-            _lut->SetRange(_dataRange);
-        }
-    }
-        break;
-    case COLOR_BY_VECTOR_MAGNITUDE: {
-        _mapper->ScalarVisibilityOn();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        } else if (ds->GetCellData() != NULL &&
-                   ds->GetCellData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUseCellFieldData();
-            _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+            _lut->SetVectorModeToMagnitude();
+        }
+        break;
+    case COLOR_BY_VECTOR_X:
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
         }
         if (_lut != NULL) {
-            _lut->SetRange(_vectorMagnitudeRange);
-            _lut->SetVectorModeToMagnitude();
-        }
-    }
-        break;
-    case COLOR_BY_VECTOR_X:
-        _mapper->ScalarVisibilityOn();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        } else if (ds->GetCellData() != NULL &&
-                   ds->GetCellData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUseCellFieldData();
-            _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
-        }
-        if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[0]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(0);
@@ -434 +550 @@
         break;
     case COLOR_BY_VECTOR_Y:
-        _mapper->ScalarVisibilityOn();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        } else if (ds->GetCellData() != NULL &&
-                   ds->GetCellData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUseCellFieldData();
-            _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
         }
         if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[1]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(1);
@@ -451 +559 @@
         break;
     case COLOR_BY_VECTOR_Z:
-        _mapper->ScalarVisibilityOn();
-        if (ds->GetPointData() != NULL &&
-            ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-        } else if (ds->GetCellData() != NULL &&
-                   ds->GetCellData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUseCellFieldData();
-            _mapper->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
         }
         if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[2]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(2);
@@ -468 +568 @@
         break;
     default:
-        _mapper->ScalarVisibilityOff();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOff();
+        }
         break;
     }
@@ -493 +595 @@
     if (_lut == NULL) {
         _lut = vtkSmartPointer<vtkLookupTable>::New();
-        if (_mapper != NULL) {
-            _mapper->UseLookupTableScalarRangeOn();
-            _mapper->SetLookupTable(_lut);
-        }
-    }
-
-    _lut->DeepCopy(cmap->getLookupTable());
+        for (int i = 0; i < 3; i++) {
+            if (_mapper[i] != NULL) {
+                _mapper[i]->UseLookupTableScalarRangeOn();
+                _mapper[i]->SetLookupTable(_lut);
+            }
+        }
+        _lut->DeepCopy(cmap->getLookupTable());
+        switch (_colorMode) {
+        case COLOR_BY_SCALAR:
+            _lut->SetRange(_dataRange);
+            break;
+        case COLOR_BY_VECTOR_MAGNITUDE:
+            _lut->SetRange(_vectorMagnitudeRange);
+            break;
+        case COLOR_BY_VECTOR_X:
+            _lut->SetRange(_vectorComponentRange[0]);
+            break;
+        case COLOR_BY_VECTOR_Y:
+            _lut->SetRange(_vectorComponentRange[1]);
+            break;
+        case COLOR_BY_VECTOR_Z:
+            _lut->SetRange(_vectorComponentRange[2]);
+            break;
+        default:
+            break;
+        }
+    } else {
+        double range[2];
+        _lut->GetTableRange(range);
+        _lut->DeepCopy(cmap->getLookupTable());
+        _lut->SetRange(range);
+    }
 
     switch (_colorMode) {
-    case COLOR_BY_SCALAR:
-        _lut->SetRange(_dataRange);
-        break;
     case COLOR_BY_VECTOR_MAGNITUDE:
         _lut->SetVectorModeToMagnitude();
-        _lut->SetRange(_vectorMagnitudeRange);
         break;
     case COLOR_BY_VECTOR_X:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(0);
-        _lut->SetRange(_vectorComponentRange[0]);
         break;
     case COLOR_BY_VECTOR_Y:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(1);
-        _lut->SetRange(_vectorComponentRange[1]);
         break;
     case COLOR_BY_VECTOR_Z:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(2);
-        _lut->SetRange(_vectorComponentRange[2]);
         break;
     default:
          break;
+    }
+}
+
+/**
+ * \brief Set visibility of cutplane on specified axis
+ */
+void Cutplane::setSliceVisibility(Axis axis, bool state)
+{
+    switch (axis) {
+    case X_AXIS:
+        if (_actor[0] != NULL)
+            _actor[0]->SetVisibility((state ? 1 : 0));
+        break;
+    case Y_AXIS:
+        if (_actor[1] != NULL)
+            _actor[1]->SetVisibility((state ? 1 : 0));
+        break;
+    case Z_AXIS:
+    default:
+        if (_actor[2] != NULL)
+            _actor[2]->SetVisibility((state ? 1 : 0));
+        break;
     }
 }
@@ -536 +678 @@
 void Cutplane::setClippingPlanes(vtkPlaneCollection *planes)
 {
-    if (_mapper != NULL) {
-        _mapper->SetClippingPlanes(planes);
-    }
-}
+    for (int i = 0; i < 3; i++) {
+        if (_mapper[i] != NULL) {
+            _mapper[i]->SetClippingPlanes(planes);
+        }
+    }
+}

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

@@ -14 +14 @@
 #include <vtkActor.h>
 #include <vtkPlaneCollection.h>
-#include <vtkGaussianSplatter.h>
-#include <vtkExtractVOI.h>
+#include <vtkCutter.h>
 #include <vtkPlane.h>
 
 #include "ColorMap.h"
+#include "RpTypes.h"
 #include "RpVtkGraphicsObject.h"
 
@@ -31 +31 @@
 class Cutplane : public VtkGraphicsObject {
 public:
-    enum Axis {
-        X_AXIS,
-        Y_AXIS,
-        Z_AXIS
-    };
     enum ColorMode {
         COLOR_BY_SCALAR,
@@ -53 +48 @@
 
     virtual void setDataSet(DataSet *dataSet,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2]);
+                            Renderer *renderer);
 
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
 
     void selectVolumeSlice(Axis axis, double ratio);
+
+    void setSliceVisibility(Axis axis, bool state);
+
+    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                      const char *name, double range[2] = NULL);
+
+    void setColorMode(ColorMode mode,
+                      const char *name, double range[2] = NULL);
 
     void setColorMode(ColorMode mode);
@@ -76 +76 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:
+    virtual void initProp();
     virtual void update();
 
+    ColorMap *_colorMap;
     ColorMode _colorMode;
-    ColorMap *_colorMap;
-    Axis _sliceAxis;
+    std::string _colorFieldName;
+    DataSet::DataAttributeType _colorFieldType;
+    double _colorFieldRange[2];
     double _vectorMagnitudeRange[2];
     double _vectorComponentRange[3][2];
+    Renderer *_renderer;
 
     vtkSmartPointer<vtkLookupTable> _lut;
-    vtkSmartPointer<vtkDataSetMapper> _mapper;
-    vtkSmartPointer<vtkGaussianSplatter> _pointSplatter;
-    vtkSmartPointer<vtkExtractVOI> _volumeSlicer;
-    vtkSmartPointer<vtkPlane> _cutPlane;
+    vtkSmartPointer<vtkActor> _actor[3];
+    vtkSmartPointer<vtkDataSetMapper> _mapper[3];
+    vtkSmartPointer<vtkCutter> _cutter[3];
+    vtkSmartPointer<vtkPlane> _cutPlane[3];
 };
 

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

@@ -5 +5 @@
  * Author: Leif Delgass <ldelgass@purdue.edu>
  */
+
+#include <cstring>
+#include <cfloat>
 
 #include <vtkDataSet.h>
@@ -25 +28 @@
 
 #include "RpGlyphs.h"
+#include "RpVtkRenderer.h"
 #include "Trace.h"
 
@@ -36 +40 @@
     _scaleFactor(1.0),
     _normalizeScale(true),
-    _colorMode(COLOR_BY_SCALAR),
-    _colorMap(NULL)
+    _colorMap(NULL),
+    _colorMode(COLOR_BY_SCALAR)
 {
     _faceCulling = true;
+    _scalingFieldRange[0] = DBL_MAX;
+    _scalingFieldRange[1] = -DBL_MAX;
+    _colorFieldRange[0] = DBL_MAX;
+    _colorFieldRange[1] = -DBL_MAX;
 }
 
 Glyphs::~Glyphs()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting Glyphs for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting Glyphs with NULL DataSet");
+#endif
 }
 
 void Glyphs::setDataSet(DataSet *dataSet,
-                        bool useCumulative,
-                        double scalarRange[2],
-                        double vectorMagnitudeRange[2],
-                        double vectorComponentRange[3][2])
+                        Renderer *renderer)
 {
     if (_dataSet != dataSet) {
         _dataSet = dataSet;
 
-        if (useCumulative) {
-            _dataRange[0] = scalarRange[0];
-            _dataRange[1] = scalarRange[1];
-            _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-            _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+        _renderer = renderer;
+
+        if (renderer->getUseCumulativeRange()) {
+            renderer->getCumulativeDataRange(_dataRange,
+                                             _dataSet->getActiveScalarsName(),
+                                             1);
+            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                             _dataSet->getActiveVectorsName(),
+                                             3);
             for (int i = 0; i < 3; i++) {
-                _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-                _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+                renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                                 _dataSet->getActiveVectorsName(),
+                                                 3, i);
             }
         } else {
@@ -240 +256 @@
 #endif
 
+    if (_lut == NULL) {
+        setColorMap(ColorMap::getDefault());
+    }
+
     if (ds->GetPointData()->GetScalars() == NULL) {
         TRACE("Setting color mode to vector magnitude");
@@ -248 +268 @@
     }
 
-    if (_lut == NULL) {
-        setColorMap(ColorMap::getDefault());
-    }
-
 #ifdef HAVE_GLYPH3D_MAPPER
     getActor()->SetMapper(_glyphMapper);
@@ -281 +297 @@
 }
 
+#ifdef HAVE_GLYPH3D_MAPPER
 /**
  * \brief Control how glyphs are scaled
  */
-void Glyphs::setScalingMode(ScalingMode mode)
+void Glyphs::setScalingMode(ScalingMode mode, const char *name, double range[2])
 {
     _scalingMode = mode;
-#ifdef HAVE_GLYPH3D_MAPPER
-    if (_glyphMapper != NULL) {
-#else
-    if (_glyphGenerator != NULL) {
-#endif
+
+    if (_dataSet == NULL || _glyphMapper == NULL)
+        return;
+
+    if (name != NULL && strlen(name) > 0) {
+        if (!_dataSet->hasField(name, DataSet::POINT_DATA)) {
+            ERROR("Field not found: %s", name);
+            return;
+        }
+        _scalingFieldName = name;
+    } else
+        _scalingFieldName.clear();
+    if (range == NULL) {
+        _scalingFieldRange[0] = DBL_MAX;
+        _scalingFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_scalingFieldRange, range, sizeof(double)*2);
+    }
+
+    if (name != NULL && strlen(name) > 0) {
+        _glyphMapper->SetScaleArray(name);
+    } else {
+        if (mode == SCALE_BY_SCALAR) {
+            _glyphMapper->SetScaleArray(vtkDataSetAttributes::SCALARS);
+        } else {
+            _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
+        }
+    }
+
+    if (range != NULL) {
+        TRACE("Setting size range to: %g,%g", range[0], range[1]);
+        _glyphMapper->SetRange(range);
+    } else if (name != NULL && strlen(name) > 0) {
+        double r[2];
+        DataSet::DataAttributeType type = DataSet::POINT_DATA;
+        int comp = -1;
+
+        if (_renderer->getUseCumulativeRange()) {
+            int numComponents;
+            if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                ERROR("Field not found: %s, type: %d", name, type);
+                return;
+            } else if (mode == SCALE_BY_VECTOR_COMPONENTS && numComponents < 3) {
+                ERROR("Field %s needs 3 components but has only %d components",
+                      name, numComponents);
+                return;
+            }
+            if (mode == SCALE_BY_VECTOR_COMPONENTS) {
+                double tmpR[2];
+                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 0);
+                r[0] = tmpR[0];
+                r[1] = tmpR[1];
+                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 1);
+                r[0] = min2(r[0], tmpR[0]);
+                r[1] = max2(r[1], tmpR[1]);
+                _renderer->getCumulativeDataRange(tmpR, name, type, numComponents, 2);
+                r[0] = min2(r[0], tmpR[0]);
+                r[1] = max2(r[1], tmpR[1]);
+            } else {
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            }
+        } else {
+            if (mode == SCALE_BY_VECTOR_COMPONENTS) {
+                double tmpR[2];
+                _dataSet->getDataRange(tmpR, name, type, 0);
+                r[0] = tmpR[0];
+                r[1] = tmpR[1];
+                _dataSet->getDataRange(tmpR, name, type, 1);
+                r[0] = min2(r[0], tmpR[0]);
+                r[1] = max2(r[1], tmpR[1]);
+                _dataSet->getDataRange(tmpR, name, type, 2);
+                r[0] = min2(r[0], tmpR[0]);
+                r[1] = max2(r[1], tmpR[1]);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+        }
+        TRACE("Setting size range to: %g,%g", r[0], r[1]);
+        _glyphMapper->SetRange(r);
+    } else {
         switch (mode) {
-        case SCALE_BY_SCALAR: {
-#ifdef HAVE_GLYPH3D_MAPPER
+        case SCALE_BY_SCALAR:
+            TRACE("Setting size range to: %g,%g", _dataRange[0], _dataRange[1]);
             _glyphMapper->SetRange(_dataRange);
-            _glyphMapper->SetScaleModeToScaleByMagnitude();
-            _glyphMapper->SetScaleArray(vtkDataSetAttributes::SCALARS);
-#else
-            _glyphGenerator->SetRange(_dataRange);
-            _glyphGenerator->SetScaleModeToScaleByScalar();
-#endif
-        }
-            break;
-        case SCALE_BY_VECTOR_MAGNITUDE: {
-#ifdef HAVE_GLYPH3D_MAPPER
-            _glyphMapper->SetRange(_dataRange);
-            _glyphMapper->SetScaleModeToScaleByMagnitude();
-            _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
-#else
-            _glyphGenerator->SetRange(_vectorMagnitudeRange);
-            _glyphGenerator->SetScaleModeToScaleByVector();
-#endif
-        }
+            break;
+        case SCALE_BY_VECTOR_MAGNITUDE:
+            TRACE("Setting size range to: %g,%g", _vectorMagnitudeRange[0], _vectorMagnitudeRange[1]);
+            _glyphMapper->SetRange(_vectorMagnitudeRange);
             break;
         case SCALE_BY_VECTOR_COMPONENTS: {
@@ -323 +401 @@
             sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[2][0]);
             sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[2][1]);
-#ifdef HAVE_GLYPH3D_MAPPER
+            TRACE("Setting size range to: %g,%g", sizeRange[0], sizeRange[1]);
             _glyphMapper->SetRange(sizeRange);
-            _glyphMapper->SetScaleModeToScaleByVectorComponents();
-            _glyphMapper->SetScaleArray(vtkDataSetAttributes::VECTORS);
-#else
+        }
+            break;
+        case SCALING_OFF:
+        default:
+            ;
+        }
+    }
+
+    switch (mode) {
+    case SCALE_BY_SCALAR:
+    case SCALE_BY_VECTOR_MAGNITUDE:
+        _glyphMapper->SetScaleModeToScaleByMagnitude();
+        break;
+    case SCALE_BY_VECTOR_COMPONENTS:
+        _glyphMapper->SetScaleModeToScaleByVectorComponents();
+        break;
+    case SCALING_OFF:
+    default:
+        _glyphMapper->SetScaleModeToNoDataScaling();
+    }
+}
+
+void Glyphs::setScalingMode(ScalingMode mode)
+{
+    setScalingMode(mode, NULL, NULL);
+}
+
+void Glyphs::setColorMode(ColorMode mode,
+                          const char *name, double range[2])
+{
+    _colorMode = mode;
+    if (name == NULL)
+        _colorFieldName.clear();
+    else
+        _colorFieldName = name;
+    if (range == NULL) {
+        _colorFieldRange[0] = DBL_MAX;
+        _colorFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_colorFieldRange, range, sizeof(double)*2);
+    }
+
+    if (_dataSet == NULL || _glyphMapper == NULL)
+        return;
+
+    if (name != NULL && strlen(name) > 0) {
+        _glyphMapper->SetScalarModeToUsePointFieldData();
+        _glyphMapper->SelectColorArray(name);
+    } else {
+        _glyphMapper->SetScalarModeToDefault();
+    }
+
+    if (_lut != NULL) {
+        if (range != NULL) {
+            _lut->SetRange(range);
+        } else if (name != NULL && strlen(name) > 0) {
+            double r[2];
+            int comp = -1;
+            if (mode == COLOR_BY_VECTOR_X)
+                comp = 0;
+            else if (mode == COLOR_BY_VECTOR_Y)
+                comp = 1;
+            else if (mode == COLOR_BY_VECTOR_Z)
+                comp = 2;
+
+            DataSet::DataAttributeType type = DataSet::POINT_DATA;
+
+            if (_renderer->getUseCumulativeRange()) {
+                int numComponents;
+                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                    ERROR("Field not found: %s, type: %d", name, type);
+                    return;
+                } else if (numComponents < comp+1) {
+                    ERROR("Request for component %d in field with %d components",
+                          comp, numComponents);
+                    return;
+                }
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+            TRACE("Setting lut range to: %g,%g", r[0], r[1]);
+            _lut->SetRange(r);
+        }
+    }
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        _glyphMapper->ScalarVisibilityOn();
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        _glyphMapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToMagnitude();
+        }
+        break;
+    case COLOR_BY_VECTOR_X:
+        _glyphMapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(0);
+        }
+        break;
+    case COLOR_BY_VECTOR_Y:
+        _glyphMapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(1);
+        }
+        break;
+    case COLOR_BY_VECTOR_Z:
+        _glyphMapper->ScalarVisibilityOn();
+        if (_lut != NULL) {
+            _lut->SetVectorModeToComponent();
+            _lut->SetVectorComponent(2);
+        }
+        break;
+    case COLOR_CONSTANT:
+    default:
+        _glyphMapper->ScalarVisibilityOff();
+        break;
+    }
+}
+
+void Glyphs::setColorMode(ColorMode mode)
+{
+    _colorMode = mode;
+    if (_dataSet == NULL)
+        return;
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        setColorMode(mode,
+                     _dataSet->getActiveScalarsName(),
+                     _dataRange);
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsName(),
+                     _vectorMagnitudeRange);
+        break;
+    case COLOR_BY_VECTOR_X:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[0]);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[1]);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[2]);
+        break;
+    case COLOR_CONSTANT:
+    default:
+        setColorMode(mode, NULL, NULL);
+        break;
+    }
+}
+
+#else
+
+/**
+ * \brief Control how glyphs are scaled
+ */
+void Glyphs::setScalingMode(ScalingMode mode)
+{
+    _scalingMode = mode;
+    if (_glyphGenerator != NULL) {
+        switch (mode) {
+        case SCALE_BY_SCALAR:
+            _glyphGenerator->SetRange(_dataRange);
+            _glyphGenerator->SetScaleModeToScaleByScalar();
+            break;
+        case SCALE_BY_VECTOR_MAGNITUDE:
+            _glyphGenerator->SetRange(_vectorMagnitudeRange);
+            _glyphGenerator->SetScaleModeToScaleByVector();
+            break;
+        case SCALE_BY_VECTOR_COMPONENTS: {
+            double sizeRange[2];
+            sizeRange[0] = _vectorComponentRange[0][0];
+            sizeRange[1] = _vectorComponentRange[0][1];
+            sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[1][0]);
+            sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[1][1]);
+            sizeRange[0] = min2(sizeRange[0], _vectorComponentRange[2][0]);
+            sizeRange[1] = max2(sizeRange[1], _vectorComponentRange[2][1]);
             _glyphGenerator->SetRange(sizeRange);
             _glyphGenerator->SetScaleModeToScaleByVectorComponents();
-#endif
         }
             break;
         case SCALING_OFF:
         default:
-#ifdef HAVE_GLYPH3D_MAPPER
-            _glyphMapper->SetScaleModeToNoDataScaling();
-#else
             _glyphGenerator->SetScaleModeToDataScalingOff();
-#endif
         }
     }
@@ -350 +609 @@
 {
     _colorMode = mode;
-#ifdef HAVE_GLYPH3D_MAPPER
-    if (_glyphMapper != NULL) {
-#else
     if (_glyphGenerator != NULL) {
-#endif
         switch (mode) {
-        case COLOR_BY_VECTOR_MAGNITUDE: {
-#ifdef HAVE_GLYPH3D_MAPPER
-            _glyphMapper->ScalarVisibilityOn();
-            _glyphMapper->SetScalarModeToUsePointFieldData();
-            vtkDataSet *ds = _dataSet->getVtkDataSet();
-            if (ds->GetPointData() != NULL &&
-                ds->GetPointData()->GetVectors() != NULL) {
-                _glyphMapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
-            }
-#else
+        case COLOR_BY_VECTOR_MAGNITUDE:
             _glyphGenerator->SetColorModeToColorByVector();
             _pdMapper->ScalarVisibilityOn();
-#endif
             if (_lut != NULL) {
                 _lut->SetVectorModeToMagnitude();
                 _lut->SetRange(_vectorMagnitudeRange);
             }
-        }
-            break;
-        case COLOR_BY_SCALAR: {
-#ifdef HAVE_GLYPH3D_MAPPER
-            _glyphMapper->ScalarVisibilityOn();
-            _glyphMapper->SetScalarModeToDefault();
-#else
+            break;
+        case COLOR_BY_SCALAR:
             _glyphGenerator->SetColorModeToColorByScalar();
             _pdMapper->ScalarVisibilityOn();
-#endif
             if (_lut != NULL) {
                 _lut->SetRange(_dataRange);
             }
-        }
             break;
         case COLOR_CONSTANT:
+            _pdMapper->ScalarVisibilityOff();
+            break;
         default:
-#ifdef HAVE_GLYPH3D_MAPPER
-            _glyphMapper->ScalarVisibilityOff();
-#else
-            _pdMapper->ScalarVisibilityOff();
-#endif
-        }
-     }
-}
+            ERROR("Unsupported ColorMode: %d", mode);
+        }
+    }
+}
+
+#endif
 
 /**
@@ -416 +654 @@
 }
 
-void Glyphs::updateRanges(bool useCumulative,
-                          double scalarRange[2],
-                          double vectorMagnitudeRange[2],
-                          double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-        _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-        _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+void Glyphs::updateRanges(Renderer *renderer)
+{
+    if (_dataSet == NULL) {
+        ERROR("called before setDataSet");
+        return;
+    }
+
+    if (renderer->getUseCumulativeRange()) {
+        renderer->getCumulativeDataRange(_dataRange,
+                                         _dataSet->getActiveScalarsName(),
+                                         1);
+        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                         _dataSet->getActiveVectorsName(),
+                                         3);
         for (int i = 0; i < 3; i++) {
-            _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-            _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+            renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                             _dataSet->getActiveVectorsName(),
+                                             3, i);
         }
     } else {
@@ -439 +682 @@
 
     // Need to update color map ranges and/or active vector field
+#ifdef HAVE_GLYPH3D_MAPPER
+    double *rangePtr = _colorFieldRange;
+    if (_colorFieldRange[0] > _colorFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setColorMode(_colorMode, _colorFieldName.c_str(), rangePtr);
+
+    rangePtr = _scalingFieldRange;
+    if (_scalingFieldRange[0] > _scalingFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setScalingMode(_scalingMode, _scalingFieldName.c_str(), rangePtr);
+#else
     setColorMode(_colorMode);
     setScalingMode(_scalingMode);
+#endif
 }
 
@@ -474 +731 @@
         }
 #endif
-    }
-
-    _lut->DeepCopy(cmap->getLookupTable());
+        _lut->DeepCopy(cmap->getLookupTable());
+        switch (_colorMode) {
+        case COLOR_CONSTANT:
+        case COLOR_BY_SCALAR:
+            _lut->SetRange(_dataRange);
+            break;
+        case COLOR_BY_VECTOR_MAGNITUDE:
+            _lut->SetRange(_vectorMagnitudeRange);
+            break;
+        case COLOR_BY_VECTOR_X:
+            _lut->SetRange(_vectorComponentRange[0]);
+            break;
+        case COLOR_BY_VECTOR_Y:
+            _lut->SetRange(_vectorComponentRange[1]);
+            break;
+        case COLOR_BY_VECTOR_Z:
+            _lut->SetRange(_vectorComponentRange[2]);
+            break;
+        default:
+            break;
+        }
+    } else {
+        double range[2];
+        _lut->GetTableRange(range);
+        _lut->DeepCopy(cmap->getLookupTable());
+        _lut->SetRange(range);
+    }
 
     switch (_colorMode) {
     case COLOR_BY_VECTOR_MAGNITUDE:
-        _lut->SetRange(_vectorMagnitudeRange);
         _lut->SetVectorModeToMagnitude();
         break;
-    case COLOR_BY_SCALAR:
+    case COLOR_BY_VECTOR_X:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(0);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(1);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        _lut->SetVectorModeToComponent();
+        _lut->SetVectorComponent(2);
+        break;
     default:
-        _lut->SetRange(_dataRange);
         break;
     }

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

@@ -58 +58 @@
         COLOR_BY_SCALAR,
         COLOR_BY_VECTOR_MAGNITUDE,
+        COLOR_BY_VECTOR_X,
+        COLOR_BY_VECTOR_Y,
+        COLOR_BY_VECTOR_Z,
         COLOR_CONSTANT
     };
@@ -70 +73 @@
 
     virtual void setDataSet(DataSet *dataSet,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2]);
+                            Renderer *renderer);
 
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
+
+#ifdef HAVE_GLYPH3D_MAPPER
+    void setScalingMode(ScalingMode mode, const char *name, double range[2]);
+
+    void setColorMode(ColorMode mode, const char *name, double range[2]);
+#endif
 
     void setScalingMode(ScalingMode mode);
@@ -99 +105 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:
@@ -118 +121 @@
     GlyphShape _glyphShape;
     ScalingMode _scalingMode;
+    std::string _scalingFieldName;
+    double _scalingFieldRange[2];
     double _dataScale;
     double _scaleFactor;
     bool _normalizeScale;
+    ColorMap *_colorMap;
     ColorMode _colorMode;
-    ColorMap *_colorMap;
+    std::string _colorFieldName;
+    double _colorFieldRange[2];
     double _vectorMagnitudeRange[2];
     double _vectorComponentRange[3][2];
+    Renderer *_renderer;
 
     vtkSmartPointer<vtkLookupTable> _lut;

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

@@ -32 +32 @@
 
 #include "RpHeightMap.h"
+#include "RpVtkRenderer.h"
 #include "Trace.h"
 
@@ -78 +79 @@
 
 void HeightMap::setDataSet(DataSet *dataSet,
-                           bool useCumulative,
-                           double scalarRange[2],
-                           double vectorMagnitudeRange[2],
-                           double vectorComponentRange[3][2])
+                           Renderer *renderer)
 {
     if (_dataSet != dataSet) {
@@ -87 +85 @@
 
         if (_dataSet != NULL) {
-            if (useCumulative) {
-                _dataRange[0] = scalarRange[0];
-                _dataRange[1] = scalarRange[1];
+            if (renderer->getUseCumulativeRange()) {
+                renderer->getCumulativeDataRange(_dataRange,
+                                                 _dataSet->getActiveScalarsName(),
+                                                 1);
             } else {
                 _dataSet->getScalarRange(_dataRange);
@@ -207 +206 @@
                 pd->GetNumberOfStrips() == 0) {
                 // DataSet is a point cloud
-                DataSet::PrincipalPlane plane;
+                PrincipalPlane plane;
                 double offset;
                 if (_dataSet->is2D(&plane, &offset)) {
@@ -213 +212 @@
                     // Result of Delaunay2D is a PolyData
                     vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
-                    if (plane == DataSet::PLANE_ZY) {
+                    if (plane == PLANE_ZY) {
                         vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                         trans->RotateWXYZ(90, 0, 1, 0);
@@ -221 +220 @@
                         mesher->SetTransform(trans);
                         _sliceAxis = X_AXIS;
-                    } else if (plane == DataSet::PLANE_XZ) {
+                    } else if (plane == PLANE_XZ) {
                         vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                         trans->RotateWXYZ(-90, 1, 0, 0);
@@ -248 +247 @@
                     _pointSplatter->GetSampleDimensions(dims);
                     TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
-                    if (plane == DataSet::PLANE_ZY) {
+                    if (plane == PLANE_ZY) {
                         dims[0] = 3;
                         _volumeSlicer->SetVOI(1, 1, 0, dims[1]-1, 0, dims[1]-1);
                         _sliceAxis = X_AXIS;
-                    } else if (plane == DataSet::PLANE_XZ) {
+                    } else if (plane == PLANE_XZ) {
                         dims[1] = 3;
                         _volumeSlicer->SetVOI(0, dims[0]-1, 1, 1, 0, dims[2]-1);
@@ -660 +659 @@
 }
 
-void HeightMap::updateRanges(bool useCumulative,
-                             double scalarRange[2],
-                             double vectorMagnitudeRange[2],
-                             double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    }
+void HeightMap::updateRanges(Renderer *renderer)
+{
+    VtkGraphicsObject::updateRanges(renderer);
 
     if (_lut != NULL) {

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

@@ -26 +26 @@
 
 #include "ColorMap.h"
+#include "RpTypes.h"
 #include "RpVtkGraphicsObject.h"
 
@@ -36 +37 @@
 class HeightMap : public VtkGraphicsObject {
 public:
-    enum Axis {
-        X_AXIS,
-        Y_AXIS,
-        Z_AXIS
-    };
-
     HeightMap(int numContours, double heightScale = 1.0);
 
@@ -53 +48 @@
     }
 
-    virtual void setDataSet(DataSet *dataset,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2]);
+    virtual void setDataSet(DataSet *dataSet,
+                            Renderer *renderer);
 
     virtual void setLighting(bool state);
@@ -98 +90 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
     void setContourLineVisibility(bool state);

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

@@ -36 +36 @@
 LIC::~LIC()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting LIC for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting LIC with NULL DataSet");
+#endif
 }
 
@@ -395 +401 @@
 }
 
-void LIC::updateRanges(bool useCumulative,
-                       double scalarRange[2],
-                       double vectorMagnitudeRange[2],
-                       double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    }
+void LIC::updateRanges(Renderer *renderer)
+{
+    VtkGraphicsObject::updateRanges(renderer);
 
     if (_lut != NULL) {

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

@@ -21 +21 @@
 
 #include "ColorMap.h"
+#include "RpTypes.h"
 #include "RpVtkGraphicsObject.h"
 
@@ -33 +34 @@
 class LIC : public VtkGraphicsObject {
 public:
-    enum Axis {
-        X_AXIS,
-        Y_AXIS,
-        Z_AXIS
-    };
-
     LIC();
     virtual ~LIC();
@@ -63 +58 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:

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

@@ -167 +167 @@
 }
 
-void Molecule::updateRanges(bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    }
-
-    if (_lut != NULL) {
+void Molecule::updateRanges(Renderer *renderer)
+{
+    VtkGraphicsObject::updateRanges(renderer);
+
+    if (_lut != NULL && _dataSet != NULL) {
         vtkDataSet *ds = _dataSet->getVtkDataSet();
         if (ds == NULL)

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

@@ -64 +64 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
     void setAtomScaling(AtomScaling state);

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

@@ -48 +48 @@
 {
     VtkGraphicsObject::initProp();
-    getActor()->GetProperty()->EdgeVisibilityOn();
 }
 
@@ -80 +79 @@
             pd->GetNumberOfStrips() == 0) {
             // DataSet is a point cloud
-            DataSet::PrincipalPlane plane;
+            PrincipalPlane plane;
             double offset;
             if (_dataSet->numDimensions() < 2 || pd->GetNumberOfPoints() < 3) {
@@ -87 +86 @@
             } else if (_dataSet->is2D(&plane, &offset)) {
                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
-                if (plane == DataSet::PLANE_ZY) {
+                if (plane == PLANE_ZY) {
                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(90, 0, 1, 0);
@@ -94 +93 @@
                     }
                     mesher->SetTransform(trans);
-                } else if (plane == DataSet::PLANE_XZ) {
+                } else if (plane == PLANE_XZ) {
                      vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(-90, 1, 0, 0);
@@ -159 +158 @@
 
     initProp();
+    setVisibility(_dataSet->getVisibility());
     getActor()->SetMapper(_pdMapper);
     _pdMapper->Update();

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

@@ -7 +7 @@
 
 #include <cassert>
+#include <cfloat>
+#include <cstring>
 
 #include <vtkDataSet.h>
@@ -24 +26 @@
 
 #include "RpPseudoColor.h"
+#include "RpVtkRenderer.h"
 #include "Trace.h"
 
@@ -32 +35 @@
 PseudoColor::PseudoColor() :
     VtkGraphicsObject(),
+    _colorMap(NULL),
     _colorMode(COLOR_BY_SCALAR),
-    _colorMap(NULL)
-{
+    _colorFieldType(DataSet::POINT_DATA),
+    _renderer(NULL)
+{
+    _colorFieldRange[0] = DBL_MAX;
+    _colorFieldRange[1] = -DBL_MAX;
 }
 
@@ -48 +55 @@
 
 void PseudoColor::setDataSet(DataSet *dataSet,
-                             bool useCumulative,
-                             double scalarRange[2],
-                             double vectorMagnitudeRange[2],
-                             double vectorComponentRange[3][2])
+                             Renderer *renderer)
 {
     if (_dataSet != dataSet) {
         _dataSet = dataSet;
 
-        if (useCumulative) {
-            _dataRange[0] = scalarRange[0];
-            _dataRange[1] = scalarRange[1];
-            _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-            _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+        _renderer = renderer;
+
+        if (renderer->getUseCumulativeRange()) {
+            renderer->getCumulativeDataRange(_dataRange,
+                                             _dataSet->getActiveScalarsName(),
+                                             1);
+            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                             _dataSet->getActiveVectorsName(),
+                                             3);
             for (int i = 0; i < 3; i++) {
-                _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-                _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+                renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                                 _dataSet->getActiveVectorsName(),
+                                                 3, i);
             }
         } else {
@@ -102 +111 @@
             pd->GetNumberOfStrips() == 0) {
             // DataSet is a point cloud
-            DataSet::PrincipalPlane plane;
+            PrincipalPlane plane;
             double offset;
             if (_dataSet->is2D(&plane, &offset)) {
 #ifdef MESH_POINT_CLOUDS
                 vtkSmartPointer<vtkDelaunay2D> mesher = vtkSmartPointer<vtkDelaunay2D>::New();
-                if (plane == DataSet::PLANE_ZY) {
+                if (plane == PLANE_ZY) {
                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(90, 0, 1, 0);
@@ -114 +123 @@
                     }
                     mesher->SetTransform(trans);
-                } else if (plane == DataSet::PLANE_XZ) {
+                } else if (plane == PLANE_XZ) {
                     vtkSmartPointer<vtkTransform> trans = vtkSmartPointer<vtkTransform>::New();
                     trans->RotateWXYZ(-90, 1, 0, 0);
@@ -136 +145 @@
                 splatter->GetSampleDimensions(dims);
                 TRACE("Sample dims: %d %d %d", dims[0], dims[1], dims[2]);
-                if (plane == DataSet::PLANE_ZY) {
+                if (plane == PLANE_ZY) {
                     dims[0] = 3;
                     slicer->SetVOI(1, 1, 0, dims[1]-1, 0, dims[1]-1);
-                } else if (plane == DataSet::PLANE_XZ) {
+                } else if (plane == PLANE_XZ) {
                     dims[1] = 3;
                     slicer->SetVOI(0, dims[0]-1, 1, 1, 0, dims[2]-1);
@@ -191 +200 @@
 }
 
-void PseudoColor::updateRanges(bool useCumulative,
-                               double scalarRange[2],
-                               double vectorMagnitudeRange[2],
-                               double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-        _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-        _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+void PseudoColor::updateRanges(Renderer *renderer)
+{
+    if (_dataSet == NULL) {
+        ERROR("called before setDataSet");
+        return;
+    }
+
+    if (renderer->getUseCumulativeRange()) {
+        renderer->getCumulativeDataRange(_dataRange,
+                                         _dataSet->getActiveScalarsName(),
+                                         1);
+        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                         _dataSet->getActiveVectorsName(),
+                                         3);
         for (int i = 0; i < 3; i++) {
-            _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-            _vectorComponentRange[i][1] = vectorComponentRange[i][1];
-        }
-    } else if (_dataSet != NULL) {
+            renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                             _dataSet->getActiveVectorsName(),
+                                             3, i);
+        }
+    } else {
         _dataSet->getScalarRange(_dataRange);
         _dataSet->getVectorRange(_vectorMagnitudeRange);
@@ -213 +227 @@
     }
 
-    // Need to update color map ranges and/or active vector field
-    setColorMode(_colorMode);
+    // Need to update color map ranges
+    double *rangePtr = _colorFieldRange;
+    if (_colorFieldRange[0] > _colorFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
 }
 
@@ -220 +238 @@
 {
     _colorMode = mode;
+    if (_dataSet == NULL)
+        return;
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        setColorMode(mode,
+                     _dataSet->getActiveScalarsType(),
+                     _dataSet->getActiveScalarsName(),
+                     _dataRange);
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorMagnitudeRange);
+        break;
+    case COLOR_BY_VECTOR_X:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[0]);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[1]);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[2]);
+        break;
+    case COLOR_CONSTANT:
+    default:
+        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
+        break;
+    }
+}
+
+void PseudoColor::setColorMode(ColorMode mode,
+                               const char *name, double range[2])
+{
+    if (_dataSet == NULL)
+        return;
+    DataSet::DataAttributeType type = DataSet::POINT_DATA;
+    int numComponents = 1;
+    if (name != NULL && strlen(name) > 0 &&
+        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
+        ERROR("Field not found: %s", name);
+        return;
+    }
+    setColorMode(mode, type, name, range);
+}
+
+void PseudoColor::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                               const char *name, double range[2])
+{
+    _colorMode = mode;
+    _colorFieldType = type;
+    if (name == NULL)
+        _colorFieldName.clear();
+    else
+        _colorFieldName = name;
+    if (range == NULL) {
+        _colorFieldRange[0] = DBL_MAX;
+        _colorFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_colorFieldRange, range, sizeof(double)*2);
+    }
+
     if (_dataSet == NULL || _dsMapper == NULL)
         return;
 
-    vtkDataSet *ds = _dataSet->getVtkDataSet();
+    switch (type) {
+    case DataSet::POINT_DATA:
+        _dsMapper->SetScalarModeToUsePointFieldData();
+        break;
+    case DataSet::CELL_DATA:
+        _dsMapper->SetScalarModeToUseCellFieldData();
+        break;
+    default:
+        ERROR("Unsupported DataAttributeType: %d", type);
+        return;
+    }
+
+    if (name != NULL && strlen(name) > 0) {
+        _dsMapper->SelectColorArray(name);
+    } else {
+        _dsMapper->SetScalarModeToDefault();
+    }
+
+    if (_lut != NULL) {
+        if (range != NULL) {
+            _lut->SetRange(range);
+        } else if (name != NULL && strlen(name) > 0) {
+            double r[2];
+            int comp = -1;
+            if (mode == COLOR_BY_VECTOR_X)
+                comp = 0;
+            else if (mode == COLOR_BY_VECTOR_Y)
+                comp = 1;
+            else if (mode == COLOR_BY_VECTOR_Z)
+                comp = 2;
+
+            if (_renderer->getUseCumulativeRange()) {
+                int numComponents;
+                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                    ERROR("Field not found: %s, type: %d", name, type);
+                    return;
+                } else if (numComponents < comp+1) {
+                    ERROR("Request for component %d in field with %d components",
+                          comp, numComponents);
+                    return;
+                }
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+            _lut->SetRange(r);
+        }
+    }
 
     switch (mode) {
-    case COLOR_BY_SCALAR: {
+    case COLOR_BY_SCALAR:
         _dsMapper->ScalarVisibilityOn();
-        _dsMapper->SetScalarModeToDefault();
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        _dsMapper->ScalarVisibilityOn();
         if (_lut != NULL) {
-            _lut->SetRange(_dataRange);
-        }
-    }
-        break;
-    case COLOR_BY_VECTOR_MAGNITUDE: {
-        _dsMapper->ScalarVisibilityOn();
-        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) {
-            _lut->SetRange(_vectorMagnitudeRange);
             _lut->SetVectorModeToMagnitude();
         }
-    }
         break;
     case COLOR_BY_VECTOR_X:
         _dsMapper->ScalarVisibilityOn();
-        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) {
-            _lut->SetRange(_vectorComponentRange[0]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(0);
@@ -270 +381 @@
     case COLOR_BY_VECTOR_Y:
         _dsMapper->ScalarVisibilityOn();
-        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) {
-            _lut->SetRange(_vectorComponentRange[1]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(1);
@@ -287 +388 @@
     case COLOR_BY_VECTOR_Z:
         _dsMapper->ScalarVisibilityOn();
-        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) {
-            _lut->SetRange(_vectorComponentRange[2]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(2);
@@ -333 +424 @@
             _dsMapper->SetLookupTable(_lut);
         }
-    }
-
-    _lut->DeepCopy(cmap->getLookupTable());
+        _lut->DeepCopy(cmap->getLookupTable());
+        switch (_colorMode) {
+        case COLOR_CONSTANT:
+        case COLOR_BY_SCALAR:
+            _lut->SetRange(_dataRange);
+            break;
+        case COLOR_BY_VECTOR_MAGNITUDE:
+            _lut->SetRange(_vectorMagnitudeRange);
+            break;
+        case COLOR_BY_VECTOR_X:
+            _lut->SetRange(_vectorComponentRange[0]);
+            break;
+        case COLOR_BY_VECTOR_Y:
+            _lut->SetRange(_vectorComponentRange[1]);
+            break;
+        case COLOR_BY_VECTOR_Z:
+            _lut->SetRange(_vectorComponentRange[2]);
+            break;
+        default:
+            break;
+        }
+    } else {
+        double range[2];
+        _lut->GetTableRange(range);
+        _lut->DeepCopy(cmap->getLookupTable());
+        _lut->SetRange(range);
+    }
 
     switch (_colorMode) {
-    case COLOR_CONSTANT:
-    case COLOR_BY_SCALAR:
-        _lut->SetRange(_dataRange);
-        break;
     case COLOR_BY_VECTOR_MAGNITUDE:
         _lut->SetVectorModeToMagnitude();
-        _lut->SetRange(_vectorMagnitudeRange);
         break;
     case COLOR_BY_VECTOR_X:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(0);
-        _lut->SetRange(_vectorComponentRange[0]);
         break;
     case COLOR_BY_VECTOR_Y:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(1);
-        _lut->SetRange(_vectorComponentRange[1]);
         break;
     case COLOR_BY_VECTOR_Z:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(2);
-        _lut->SetRange(_vectorComponentRange[2]);
         break;
     default:

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

@@ -44 +44 @@
 
     virtual void setDataSet(DataSet *dataSet,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2]);
+                            Renderer *renderer);
 
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
+
+    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                      const char *name, double range[2] = NULL);
+
+    void setColorMode(ColorMode mode,
+                      const char *name, double range[2] = NULL);
 
     void setColorMode(ColorMode mode);
@@ -65 +68 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:
     virtual void update();
 
+    ColorMap *_colorMap;
     ColorMode _colorMode;
-    ColorMap *_colorMap;
+    std::string _colorFieldName;
+    DataSet::DataAttributeType _colorFieldType;
+    double _colorFieldRange[2];
     double _vectorMagnitudeRange[2];
     double _vectorComponentRange[3][2];
+    Renderer *_renderer;
 
     vtkSmartPointer<vtkLookupTable> _lut;

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

@@ -10 +10 @@
 #include <cfloat>
 #include <cmath>
+#include <cstring>
 
 #include <vtkMath.h>
@@ -30 +31 @@
 
 #include "RpStreamlines.h"
+#include "RpVtkRenderer.h"
 #include "Trace.h"
 
@@ -37 +39 @@
     VtkGraphicsObject(),
     _lineType(LINES),
+    _colorMap(NULL),
     _colorMode(COLOR_BY_VECTOR_MAGNITUDE),
-    _colorMap(NULL),
+    _colorFieldType(DataSet::POINT_DATA),
     _seedVisible(true),
+    _renderer(NULL),
     _dataScale(1)
 {
@@ -49 +53 @@
     _seedColor[1] = 1.0f;
     _seedColor[2] = 1.0f;
+    _colorFieldRange[0] = DBL_MAX;
+    _colorFieldRange[1] = -DBL_MAX;
     vtkMath::RandomSeed((int)time(NULL));
     srand((unsigned int)time(NULL));
@@ -55 +61 @@
 Streamlines::~Streamlines()
 {
+#ifdef WANT_TRACE
+    if (_dataSet != NULL)
+        TRACE("Deleting Streamlines for %s", _dataSet->getName().c_str());
+    else
+        TRACE("Deleting Streamlines with NULL DataSet");
+#endif
 }
 
 void Streamlines::setDataSet(DataSet *dataSet,
-                             bool useCumulative,
-                             double scalarRange[2],
-                             double vectorMagnitudeRange[2],
-                             double vectorComponentRange[3][2])
+                             Renderer *renderer)
 {
     if (_dataSet != dataSet) {
         _dataSet = dataSet;
 
-        if (useCumulative) {
-            _dataRange[0] = scalarRange[0];
-            _dataRange[1] = scalarRange[1];
-            _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-            _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+        _renderer = renderer;
+
+        if (renderer->getUseCumulativeRange()) {
+            renderer->getCumulativeDataRange(_dataRange,
+                                             _dataSet->getActiveScalarsName(),
+                                             1);
+            renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                             _dataSet->getActiveVectorsName(),
+                                             3);
             for (int i = 0; i < 3; i++) {
-                _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-                _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+                renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                                 _dataSet->getActiveVectorsName(),
+                                                 3, i);
             }
         } else {
@@ -189 +203 @@
     bary[2] = 1.0 - bary[0] - bary[1];
 
-    TRACE("bary %g %g %g", bary[0], bary[1], bary[2]);
+    //TRACE("bary %g %g %g", bary[0], bary[1], bary[2]);
     // Convert to cartesian coords
     for (int i = 0; i < 3; i++) {
@@ -221 +235 @@
     }
     bary[3] = 1.0 - bary[0] - bary[1] - bary[2];
-    TRACE("bary %g %g %g %g", bary[0], bary[1], bary[2], bary[3]);
+    //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++) {
@@ -553 +567 @@
 }
 
+void Streamlines::setNumberOfSeedPoints(int numPoints)
+{
+    switch(_seedType) {
+    case DATASET_FILLED_MESH:
+        setSeedToFilledMesh(numPoints);
+        break;
+    case FILLED_MESH:
+        if (_seedMesh != NULL) {
+            setSeedToFilledMesh(_seedMesh, numPoints);
+        } else {
+            ERROR("NULL _seedMesh");
+        }
+        break;
+    default:
+        ERROR("Can't set number of points for seed type %d", _seedType);
+        break;
+    }
+}
+
 /**
  * \brief Use points of the DataSet associated with this 
@@ -559 +592 @@
 void Streamlines::setSeedToMeshPoints()
 {
+    _seedType = DATASET_MESH_POINTS;
     setSeedToMeshPoints(_dataSet->getVtkDataSet());
 }
@@ -574 +608 @@
 void Streamlines::setSeedToFilledMesh(int numPoints)
 {
+    _seedType = DATASET_FILLED_MESH;
     setSeedToFilledMesh(_dataSet->getVtkDataSet(), numPoints);
 }
@@ -584 +619 @@
 void Streamlines::setSeedToMeshPoints(vtkDataSet *seed)
 {
+    if (seed != _dataSet->getVtkDataSet()) {
+        _seedType = MESH_POINTS;
+    }
+    _seedMesh = NULL;
     if (_streamTracer != NULL) {
         TRACE("Seed points: %d", seed->GetNumberOfPoints());
@@ -619 +658 @@
 void Streamlines::setSeedToFilledMesh(vtkDataSet *ds, int numPoints)
 {
+    if (ds != _dataSet->getVtkDataSet()) {
+        _seedMesh = ds;
+        _seedType = FILLED_MESH;
+    } else {
+        _seedMesh = NULL;
+    }
     if (_streamTracer != NULL) {
         // Set up seed source object
@@ -667 +712 @@
     if (numPoints < 2)
         return;
+    _seedType = RAKE;
+    _seedMesh = NULL;
     if (_streamTracer != NULL) {
         // Set up seed source object
@@ -724 +771 @@
                                 int numPoints)
 {
+    _seedType = DISK;
+    _seedMesh = NULL;
     if (_streamTracer != NULL) {
         // Set up seed source object
@@ -816 +865 @@
                                    int numSides)
 {
+    _seedType = POLYGON;
+    _seedMesh = NULL;
     if (_streamTracer != NULL) {
         // Set up seed source object
@@ -880 +931 @@
                                          int numPoints)
 {
+    _seedType = FILLED_POLYGON;
+    _seedMesh = NULL;
     if (_streamTracer != NULL) {
          // Set up seed source object
@@ -1193 +1246 @@
 }
 
-void Streamlines::updateRanges(bool useCumulative,
-                               double scalarRange[2],
-                               double vectorMagnitudeRange[2],
-                               double vectorComponentRange[3][2])
-{
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-        _vectorMagnitudeRange[0] = vectorMagnitudeRange[0];
-        _vectorMagnitudeRange[1] = vectorMagnitudeRange[1];
+void Streamlines::updateRanges(Renderer *renderer)
+{
+    if (_dataSet == NULL) {
+        ERROR("called before setDataSet");
+        return;
+    }
+
+    if (renderer->getUseCumulativeRange()) {
+        renderer->getCumulativeDataRange(_dataRange,
+                                         _dataSet->getActiveScalarsName(),
+                                         1);
+        renderer->getCumulativeDataRange(_vectorMagnitudeRange,
+                                         _dataSet->getActiveVectorsName(),
+                                         3);
         for (int i = 0; i < 3; i++) {
-            _vectorComponentRange[i][0] = vectorComponentRange[i][0];
-            _vectorComponentRange[i][1] = vectorComponentRange[i][1];
+            renderer->getCumulativeDataRange(_vectorComponentRange[i],
+                                             _dataSet->getActiveVectorsName(),
+                                             3, i);
         }
     } else {
@@ -1216 +1274 @@
 
     // Need to update color map ranges and/or active vector field
-    setColorMode(_colorMode);
+    double *rangePtr = _colorFieldRange;
+    if (_colorFieldRange[0] > _colorFieldRange[1]) {
+        rangePtr = NULL;
+    }
+    setColorMode(_colorMode, _colorFieldType, _colorFieldName.c_str(), rangePtr);
 }
 
@@ -1222 +1284 @@
 {
     _colorMode = mode;
+    if (_dataSet == NULL)
+        return;
+
+    switch (mode) {
+    case COLOR_BY_SCALAR:
+        setColorMode(mode,
+                     _dataSet->getActiveScalarsType(),
+                     _dataSet->getActiveScalarsName(),
+                     _dataRange);
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorMagnitudeRange);
+        break;
+    case COLOR_BY_VECTOR_X:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[0]);
+        break;
+    case COLOR_BY_VECTOR_Y:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[1]);
+        break;
+    case COLOR_BY_VECTOR_Z:
+        setColorMode(mode,
+                     _dataSet->getActiveVectorsType(),
+                     _dataSet->getActiveVectorsName(),
+                     _vectorComponentRange[2]);
+        break;
+    case COLOR_CONSTANT:
+    default:
+        setColorMode(mode, DataSet::POINT_DATA, NULL, NULL);
+        break;
+    }
+}
+
+void Streamlines::setColorMode(ColorMode mode,
+                               const char *name, double range[2])
+{
+    if (_dataSet == NULL)
+        return;
+    DataSet::DataAttributeType type = DataSet::POINT_DATA;
+    int numComponents = 1;
+    if (name != NULL && strlen(name) > 0 &&
+        !_dataSet->getFieldInfo(name, &type, &numComponents)) {
+        ERROR("Field not found: %s", name);
+        return;
+    }
+    setColorMode(mode, type, name, range);
+}
+
+void Streamlines::setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                               const char *name, double range[2])
+{
+    _colorMode = mode;
+    _colorFieldType = type;
+    if (name == NULL)
+        _colorFieldName.clear();
+    else
+        _colorFieldName = name;
+    if (range == NULL) {
+        _colorFieldRange[0] = DBL_MAX;
+        _colorFieldRange[1] = -DBL_MAX;
+    } else {
+        memcpy(_colorFieldRange, range, sizeof(double)*2);
+    }
+
     if (_dataSet == NULL || _pdMapper == NULL)
         return;
 
+    switch (type) {
+    case DataSet::POINT_DATA:
+        _pdMapper->SetScalarModeToUsePointFieldData();
+        break;
+    case DataSet::CELL_DATA:
+        _pdMapper->SetScalarModeToUseCellFieldData();
+        break;
+    default:
+        ERROR("Unsupported DataAttributeType: %d", type);
+        return;
+    }
+
+    if (name != NULL && strlen(name) > 0) {
+        _pdMapper->SelectColorArray(name);
+    } else {
+        _pdMapper->SetScalarModeToDefault();
+    }
+
+    if (_lut != NULL) {
+        if (range != NULL) {
+            _lut->SetRange(range);
+        } else if (name != NULL && strlen(name) > 0) {
+            double r[2];
+            int comp = -1;
+            if (mode == COLOR_BY_VECTOR_X)
+                comp = 0;
+            else if (mode == COLOR_BY_VECTOR_Y)
+                comp = 1;
+            else if (mode == COLOR_BY_VECTOR_Z)
+                comp = 2;
+
+            if (_renderer->getUseCumulativeRange()) {
+                int numComponents;
+                if  (!_dataSet->getFieldInfo(name, type, &numComponents)) {
+                    ERROR("Field not found: %s, type: %d", name, type);
+                    return;
+                } else if (numComponents < comp+1) {
+                    ERROR("Request for component %d in field with %d components",
+                          comp, numComponents);
+                    return;
+                }
+                _renderer->getCumulativeDataRange(r, name, type, numComponents, comp);
+            } else {
+                _dataSet->getDataRange(r, name, type, comp);
+            }
+            _lut->SetRange(r);
+        }
+    }
+
     switch (mode) {
-    case COLOR_BY_SCALAR: {
+    case COLOR_BY_SCALAR:
         _pdMapper->ScalarVisibilityOn();
-        _pdMapper->SetScalarModeToDefault();
+        break;
+    case COLOR_BY_VECTOR_MAGNITUDE:
+        _pdMapper->ScalarVisibilityOn();
         if (_lut != NULL) {
-            _lut->SetRange(_dataRange);
-        }
-    }
-        break;
-    case COLOR_BY_VECTOR_MAGNITUDE: {
-        _pdMapper->ScalarVisibilityOn();
-        _pdMapper->SetScalarModeToUsePointFieldData();
-        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
-        if (_lut != NULL) {
-            _lut->SetRange(_vectorMagnitudeRange);
             _lut->SetVectorModeToMagnitude();
         }
-    }
         break;
     case COLOR_BY_VECTOR_X:
         _pdMapper->ScalarVisibilityOn();
-        _pdMapper->SetScalarModeToUsePointFieldData();
-        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[0]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(0);
@@ -1256 +1427 @@
     case COLOR_BY_VECTOR_Y:
         _pdMapper->ScalarVisibilityOn();
-        _pdMapper->SetScalarModeToUsePointFieldData();
-        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[1]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(1);
@@ -1266 +1434 @@
     case COLOR_BY_VECTOR_Z:
         _pdMapper->ScalarVisibilityOn();
-        _pdMapper->SetScalarModeToUsePointFieldData();
-        _pdMapper->SelectColorArray(_dataSet->getActiveVectorsName());
         if (_lut != NULL) {
-            _lut->SetRange(_vectorComponentRange[2]);
             _lut->SetVectorModeToComponent();
             _lut->SetVectorComponent(2);
@@ -1305 +1470 @@
             _pdMapper->SetLookupTable(_lut);
         }
-    }
-
-    _lut->DeepCopy(cmap->getLookupTable());
+        _lut->DeepCopy(cmap->getLookupTable());
+        switch (_colorMode) {
+        case COLOR_CONSTANT:
+        case COLOR_BY_SCALAR:
+            _lut->SetRange(_dataRange);
+            break;
+        case COLOR_BY_VECTOR_MAGNITUDE:
+            _lut->SetRange(_vectorMagnitudeRange);
+            break;
+        case COLOR_BY_VECTOR_X:
+            _lut->SetRange(_vectorComponentRange[0]);
+            break;
+        case COLOR_BY_VECTOR_Y:
+            _lut->SetRange(_vectorComponentRange[1]);
+            break;
+        case COLOR_BY_VECTOR_Z:
+            _lut->SetRange(_vectorComponentRange[2]);
+            break;
+        default:
+            break;
+        }
+    } else {
+        double range[2];
+        _lut->GetTableRange(range);
+        _lut->DeepCopy(cmap->getLookupTable());
+        _lut->SetRange(range);
+    }
 
     switch (_colorMode) {
-    case COLOR_CONSTANT:
-    case COLOR_BY_SCALAR:
-        _lut->SetRange(_dataRange);
-        break;
     case COLOR_BY_VECTOR_MAGNITUDE:
         _lut->SetVectorModeToMagnitude();
-        _lut->SetRange(_vectorMagnitudeRange);
         break;
     case COLOR_BY_VECTOR_X:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(0);
-        _lut->SetRange(_vectorComponentRange[0]);
         break;
     case COLOR_BY_VECTOR_Y:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(1);
-        _lut->SetRange(_vectorComponentRange[1]);
         break;
     case COLOR_BY_VECTOR_Z:
         _lut->SetVectorModeToComponent();
         _lut->SetVectorComponent(2);
-        _lut->SetRange(_vectorComponentRange[2]);
         break;
     default:

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

@@ -20 +20 @@
 #include "ColorMap.h"
 #include "RpVtkGraphicsObject.h"
+#include "RpVtkDataSet.h"
 
 namespace Rappture {
@@ -58 +59 @@
         BOTH
     };
+    enum SeedType {
+        DATASET_MESH_POINTS,
+        DATASET_FILLED_MESH,
+        MESH_POINTS,
+        FILLED_MESH,
+        RAKE,
+        DISK,
+        POLYGON,
+        FILLED_POLYGON
+    };
 
     Streamlines();
@@ -68 +79 @@
 
     virtual void setDataSet(DataSet *dataSet,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2]);
+                            Renderer *renderer);
 
     virtual void setLighting(bool state);
@@ -90 +98 @@
 
     virtual void setClippingPlanes(vtkPlaneCollection *planes);
+
+    void setNumberOfSeedPoints(int numPoints);
 
     void setSeedToMeshPoints();
@@ -137 +147 @@
 
     void setLineTypeToRibbons(double width, double angle);
+
+    void setColorMode(ColorMode mode, DataSet::DataAttributeType type,
+                      const char *name, double range[2] = NULL);
+
+    void setColorMode(ColorMode mode,
+                      const char *name, double range[2] = NULL);
 
     void setColorMode(ColorMode mode);
@@ -152 +168 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
     void setSeedVisibility(bool state);
@@ -182 +195 @@
 
     LineType _lineType;
+    ColorMap *_colorMap;
     ColorMode _colorMode;
-    ColorMap *_colorMap;
+    std::string _colorFieldName;
+    DataSet::DataAttributeType _colorFieldType;
+    double _colorFieldRange[2];
+    SeedType _seedType;
     float _seedColor[3];
     bool _seedVisible;
     double _vectorMagnitudeRange[2];
     double _vectorComponentRange[3][2];
+    Renderer *_renderer;
     double _dataScale;
 
@@ -193 +211 @@
     vtkSmartPointer<vtkActor> _linesActor;
     vtkSmartPointer<vtkActor> _seedActor;
+    vtkSmartPointer<vtkDataSet> _seedMesh;
     vtkSmartPointer<vtkStreamTracer> _streamTracer;
     vtkSmartPointer<vtkPolyDataAlgorithm> _lineFilter;

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

@@ -116 +116 @@
 }
 
-void Volume::updateRanges(bool useCumulative,
-                          double scalarRange[2],
-                          double vectorMagnitudeRange[2],
-                          double vectorComponentRange[3][2])
+void Volume::updateRanges(Renderer *renderer)
 {
-    if (useCumulative) {
-        _dataRange[0] = scalarRange[0];
-        _dataRange[1] = scalarRange[1];
-    } else if (_dataSet != NULL) {
-        _dataSet->getScalarRange(_dataRange);
-    }
+    VtkGraphicsObject::updateRanges(renderer);
 
     if (getVolume() != NULL) {
@@ -133 +125 @@
     }
 }
+
 void Volume::updateColorMap()
 {
@@ -143 +136 @@
 void Volume::setColorMap(ColorMap *cmap)
 {
+    if (cmap == NULL)
+        return;
+
     _colorMap = cmap;
 

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

@@ -53 +53 @@
     void updateColorMap();
 
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2]);
+    virtual void updateRanges(Renderer *renderer);
 
 private:

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

@@ -411 +411 @@
  * and if so, returns the plane normal and offset from origin
  */
-bool DataSet::is2D(DataSet::PrincipalPlane *plane, double *offset) const
+bool DataSet::is2D(PrincipalPlane *plane, double *offset) const
 {
     double bounds[6];
@@ -447 +447 @@
  * largest two dimensions of the AABB
  */
-DataSet::PrincipalPlane DataSet::principalPlane() const
+PrincipalPlane DataSet::principalPlane() const
 {
     double bounds[6];
@@ -529 +529 @@
  * \brief Get the active scalar array field name
  */
-const char *DataSet::getActiveScalarsName()
+const char *DataSet::getActiveScalarsName() const
 {
     if (_dataSet != NULL) {
@@ -544 +544 @@
     }
     return NULL;
+}
+
+/**
+ * \brief Get the active scalar array default attribute type
+ */
+DataSet::DataAttributeType DataSet::getActiveScalarsType() const
+{
+    if (_dataSet != NULL) {
+         if (_dataSet->GetPointData() != NULL &&
+             _dataSet->GetPointData()->GetScalars() != NULL) {
+            return POINT_DATA;
+        }
+        TRACE("No point scalars");
+        if (_dataSet->GetCellData() != NULL &&
+            _dataSet->GetCellData()->GetScalars() != NULL) {
+            return CELL_DATA;
+        }
+        TRACE("No cell scalars");
+    }
+    return POINT_DATA;
 }
 
@@ -571 +591 @@
 
 /**
+ * \brief Get the active vector array default attribute type
+ */
+DataSet::DataAttributeType DataSet::getActiveVectorsType() const
+{
+    if (_dataSet != NULL) {
+         if (_dataSet->GetPointData() != NULL &&
+             _dataSet->GetPointData()->GetVectors() != NULL) {
+            return POINT_DATA;
+        }
+        TRACE("No point vectors");
+        if (_dataSet->GetCellData() != NULL &&
+            _dataSet->GetCellData()->GetVectors() != NULL) {
+            return CELL_DATA;
+        }
+        TRACE("No cell vectors");
+    }
+    return POINT_DATA;
+}
+
+/**
  * \brief Get the active vector array field name
  */
-const char *DataSet::getActiveVectorsName()
+const char *DataSet::getActiveVectorsName() const
 {
     if (_dataSet != NULL) {
@@ -588 +628 @@
     }
     return NULL;
+}
+
+bool DataSet::getFieldInfo(const char *fieldName,
+                           DataAttributeType *type,
+                           int *numComponents) const
+{
+    if (_dataSet->GetPointData() != NULL &&
+        _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
+        if (type != NULL)
+            *type = POINT_DATA;
+        if (numComponents != NULL)
+            *numComponents = _dataSet->GetPointData()->GetArray(fieldName)->GetNumberOfComponents();
+        return true;
+    } else if (_dataSet->GetCellData() != NULL &&
+               _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
+        if (type != NULL)
+            *type = CELL_DATA;
+        if (numComponents != NULL)
+            *numComponents = _dataSet->GetCellData()->GetArray(fieldName)->GetNumberOfComponents();
+        return true;
+    } else if (_dataSet->GetFieldData() != NULL &&
+               _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
+        if (type != NULL)
+            *type = FIELD_DATA;
+        if (numComponents != NULL)
+            *numComponents = _dataSet->GetFieldData()->GetArray(fieldName)->GetNumberOfComponents();
+        return true;
+    }
+    return false;
+}
+
+bool DataSet::getFieldInfo(const char *fieldName,
+                           DataAttributeType type,
+                           int *numComponents) const
+{
+    switch (type) {
+    case POINT_DATA:
+        if (_dataSet->GetPointData() != NULL &&
+            _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
+            if (numComponents != NULL)
+                *numComponents = _dataSet->GetPointData()->GetArray(fieldName)->GetNumberOfComponents();
+            return true;
+        } else
+            return false;
+        break;
+    case CELL_DATA:
+        if (_dataSet->GetCellData() != NULL &&
+            _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
+            if (numComponents != NULL)
+                *numComponents = _dataSet->GetCellData()->GetArray(fieldName)->GetNumberOfComponents();
+            return true;
+        } else
+            return false;
+        break;
+    case FIELD_DATA:
+        if (_dataSet->GetFieldData() != NULL &&
+            _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
+            if (numComponents != NULL)
+                *numComponents = _dataSet->GetFieldData()->GetArray(fieldName)->GetNumberOfComponents();
+            return true;
+        } else
+            return false;
+        break;
+    default:
+        ;
+    }
+    return false;
+}
+
+/**
+ * \brief Get the list of field names in the DataSet
+ * 
+ * \param[in,out] names The field names will be appended to this list
+ * \param[in] type The DataAttributeType: e.g. POINT_DATA, CELL_DATA
+ * \param[in] numComponents Filter list by number of components, -1 means to
+ * return all fields regardless of dimension
+ */
+void DataSet::getFieldNames(std::vector<std::string>& names,
+                            DataAttributeType type, int numComponents) const
+{
+    if (_dataSet == NULL)
+        return;
+    switch (type) {
+    case POINT_DATA:
+        if (_dataSet->GetPointData() != NULL) {
+            for (int i = 0; i < _dataSet->GetPointData()->GetNumberOfArrays(); i++) {
+                if (numComponents == -1 ||
+                    _dataSet->GetPointData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
+                    names.push_back(_dataSet->GetPointData()->GetArrayName(i));
+                }
+            }
+        }
+        break;
+    case CELL_DATA:
+        if (_dataSet->GetCellData() != NULL) {
+            for (int i = 0; i < _dataSet->GetCellData()->GetNumberOfArrays(); i++) {
+                if (numComponents == -1 ||
+                    _dataSet->GetCellData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
+                    names.push_back(_dataSet->GetCellData()->GetArrayName(i));
+                }
+            }
+        }
+        break;
+    case FIELD_DATA:
+        if (_dataSet->GetFieldData() != NULL) {
+            for (int i = 0; i < _dataSet->GetFieldData()->GetNumberOfArrays(); i++) {
+                if (numComponents == -1 ||
+                    _dataSet->GetFieldData()->GetArray(i)->GetNumberOfComponents() == numComponents) {
+                    names.push_back(_dataSet->GetFieldData()->GetArrayName(i));
+                }
+            }
+        }
+        break;
+    default:
+        ERROR("Unknown DataAttributeType %d", type);
+    }
 }
 
@@ -630 +786 @@
  * \param[out] minmax The data range
  * \param[in] fieldName The array name
+ * \param[in] type The DataAttributeType
  * \param[in] component The field component, -1 means magnitude
- */
-void DataSet::getDataRange(double minmax[2], const char *fieldName, int component) const
+ * \return boolean indicating if field was found
+ */
+bool DataSet::getDataRange(double minmax[2], const char *fieldName,
+                           DataAttributeType type, int component) const
 {
     if (_dataSet == NULL)
-        return;
-    if (_dataSet->GetPointData() != NULL &&
-        _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
-        _dataSet->GetPointData()->GetArray(fieldName)->GetRange(minmax, component);
-    } else if (_dataSet->GetCellData() != NULL &&
-        _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
-        _dataSet->GetCellData()->GetArray(fieldName)->GetRange(minmax, component);
-    } else if (_dataSet->GetFieldData() != NULL &&
-        _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
-        _dataSet->GetFieldData()->GetArray(fieldName)->GetRange(minmax, component);
-    }
+        return false;
+    switch (type) {
+    case POINT_DATA:
+        if (_dataSet->GetPointData() != NULL &&
+            _dataSet->GetPointData()->GetArray(fieldName) != NULL) {
+            _dataSet->GetPointData()->GetArray(fieldName)->GetRange(minmax, component);
+            return true;
+        } else {
+            return false;
+        }
+        break;
+    case CELL_DATA:
+        if (_dataSet->GetCellData() != NULL &&
+            _dataSet->GetCellData()->GetArray(fieldName) != NULL) {
+            _dataSet->GetCellData()->GetArray(fieldName)->GetRange(minmax, component);
+            return true;
+        } else {
+            return false;
+        }
+        break;
+    case FIELD_DATA:
+        if (_dataSet->GetFieldData() != NULL &&
+            _dataSet->GetFieldData()->GetArray(fieldName) != NULL) {
+            _dataSet->GetFieldData()->GetArray(fieldName)->GetRange(minmax, component);
+            return true;
+        } else {
+            return false;
+        }
+        break;
+    default:
+        ERROR("Unknown DataAttributeType %d", type);
+        break;
+    }
+    return false;
 }
 
@@ -706 +888 @@
  * Note: no interpolation is performed on data
  *
- * \return the value of the nearest point or 0 if no scalar data available
+ * \param[in] x World x coordinate to probe
+ * \param[in] y World y coordinate to probe
+ * \param[in] z World z coordinate to probe
+ * \param[out] value On success, contains the data value
+ * \return boolean indicating success or failure
  */
 bool DataSet::getScalarValue(double x, double y, double z, double *value) const

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

@@ -20 +20 @@
 #include <vector>
 
+#include "RpTypes.h"
+
 namespace Rappture {
 namespace VtkVis {
@@ -28 +30 @@
 class DataSet {
 public:
-    enum PrincipalPlane {
-        PLANE_XY,
-        PLANE_ZY,
-        PLANE_XZ
+    enum DataAttributeType {
+        POINT_DATA,
+        CELL_DATA,
+        FIELD_DATA
     };
     DataSet(const std::string& name);
@@ -62 +64 @@
     bool setActiveScalars(const char *name);
 
-    const char *getActiveScalarsName();
+    const char *getActiveScalarsName() const;
+
+    DataAttributeType getActiveScalarsType() const;
 
     bool setActiveVectors(const char *name);
 
-    const char *getActiveVectorsName();
+    const char *getActiveVectorsName() const;
+
+    DataAttributeType getActiveVectorsType() const;
+
+    bool hasField(const char *fieldName) const
+    {
+        return getFieldInfo(fieldName, NULL, NULL);
+    }
+
+    bool hasField(const char *fieldName, DataAttributeType type) const
+    {
+        return getFieldInfo(fieldName, type, NULL);
+    }
+
+    bool getFieldInfo(const char *fieldName, DataAttributeType *type, int *numComponents) const;
+
+    bool getFieldInfo(const char *fieldName, DataAttributeType type, int *numComponents) const;
+
+    void getFieldNames(std::vector<std::string>& names,
+                       DataAttributeType type, int numComponents = -1) const;
+
+    bool getDataRange(double minmax[2], const char *fieldName,
+                      DataAttributeType type, int component = -1) const;
 
     void getScalarRange(double minmax[2]) const;
-
-    void getDataRange(double minmax[2], const char *fieldName, int component = -1) const;
 
     void getVectorRange(double minmax[2], int component = -1) const;

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

@@ -31 +31 @@
 namespace VtkVis {
 
+class Renderer;
+
 /**
  * \brief Base class for graphics objects
@@ -92 +94 @@
      *
      * \param[in] dataSet DataSet to use in rendering
-     * \param[in] useCumulative Whether the cumulative data ranges should be 
-     * used in place of the dataSet's ranges
-     * \param[in] scalarRange Current cumulative scalar data range
-     * \param[in] vectorMagnitudeRange Current cumulative vector magnitude data range
-     * \param[in] vectorComponentRange Current cumulative vector component data ranges
+     * \param[in] renderer Pointer to Renderer -- may be used to get 
+     * cumulative data ranges
      */
     virtual void setDataSet(DataSet *dataSet,
-                            bool useCumulative,
-                            double scalarRange[2],
-                            double vectorMagnitudeRange[2],
-                            double vectorComponentRange[3][2])
-    {
-        if (_dataSet != dataSet) {
-            _dataSet = dataSet;
-
-            if (useCumulative) {
-                _dataRange[0] = scalarRange[0];
-                _dataRange[1] = scalarRange[1];
-            } else {
-                _dataSet->getScalarRange(_dataRange);
-            }
-
-            update();
-        }
-    }
+                            Renderer *renderer);
 
     /**
@@ -122 +104 @@
      * cumulative ranges or settings change
      *
-     * \param[in] useCumulative Whether the cumulative data ranges should be 
-     * used in place of the dataSet's ranges
-     * \param[in] scalarRange Current cumulative scalar data range
-     * \param[in] vectorMagnitudeRange Current cumulative vector magnitude data range
-     * \param[in] vectorComponentRange Current cumulative vector component data ranges
-     */
-    virtual void updateRanges(bool useCumulative,
-                              double scalarRange[2],
-                              double vectorMagnitudeRange[2],
-                              double vectorComponentRange[3][2])
-    {
-        if (useCumulative) {
-            _dataRange[0] = scalarRange[0];
-            _dataRange[1] = scalarRange[1];
-        } else {
-            _dataSet->getScalarRange(_dataRange);
-        }
-    }
+     * \param[in] renderer Pointer to Renderer -- may be used to get 
+     * cumulative data ranges
+     */
+    virtual void updateRanges(Renderer *renderer);
 
     /**
@@ -730 +698 @@
             property->SetPointSize(_pointSize);
             property->EdgeVisibilityOff();
+            if (_dataSet != NULL)
+                _opacity = _dataSet->getOpacity();
             property->SetOpacity(_opacity);
             property->SetAmbient(.2);
@@ -737 +707 @@
                 setCulling(property, true);
             }
+            if (_dataSet != NULL)
+                setVisibility(_dataSet->getVisibility());
         }
     }

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

@@ -9 +9 @@
 #include <cstring>
 #include <cstdlib>
-#include <string>
-#include <sstream>
+#include <cerrno>
 #include <unistd.h>
 #include <signal.h>
@@ -18 +17 @@
 #endif
 
+#include <string>
+#include <sstream>
+
 #include "Trace.h"
+#include "ReadBuffer.h"
 #include "RpVtkRenderServer.h"
 #include "RpVtkRendererCmd.h"
@@ -24 +27 @@
 #include "PPMWriter.h"
 #include "TGAWriter.h"
+#ifdef USE_THREADS
+#include <pthread.h>
+#include "ResponseQueue.h"
+#endif 
 
 using namespace Rappture::VtkVis;
@@ -29 +36 @@
 int Rappture::VtkVis::g_fdIn = STDIN_FILENO; ///< Input file descriptor
 int Rappture::VtkVis::g_fdOut = STDOUT_FILENO; ///< Output file descriptor
-FILE *Rappture::VtkVis::g_fIn = stdin; ///< Input file handle
 FILE *Rappture::VtkVis::g_fOut = stdout; ///< Output file handle
 FILE *Rappture::VtkVis::g_fLog = NULL; ///< Trace logging file handle
 Renderer *Rappture::VtkVis::g_renderer = NULL; ///< Main render worker
+ReadBuffer *Rappture::VtkVis::g_inBufPtr = NULL; ///< Socket read buffer
 
 #define ELAPSED_TIME(t1, t2) \
@@ -38 +45 @@
      (((t2).tv_sec - (t1).tv_sec))*1.0e+3f + (float)((t2).tv_usec - (t1).tv_usec)/1.0e+3f)
 
+#ifdef USE_THREADS
 static void
-writeFrame(int fd, vtkUnsignedCharArray *imgData)
+queueFrame(ResponseQueue *queue, vtkUnsignedCharArray *imgData)
 {
 #ifdef DEBUG
@@ -65 +73 @@
                  TARGA_BYTES_PER_PIXEL,
                  true);
-#endif
+#endif  /*RENDER_TARGA*/
 
 #else
@@ -82 +90 @@
 
 #ifdef RENDER_TARGA
+        queueTGA(queue, oss.str().c_str(),
+                 imgData->GetPointer(0),
+                 g_renderer->getWindowWidth(),
+                 g_renderer->getWindowHeight(),
+                 TARGA_BYTES_PER_PIXEL);
+#else
+        queuePPM(queue, 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),
@@ -92 +174 @@
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
-#endif
+#endif  /*RENDER_TARGA*/
     } else {
 #ifdef RENDER_TARGA
@@ -105 +187 @@
                  g_renderer->getWindowWidth(),
                  g_renderer->getWindowHeight());
-#endif
-    }
-#endif
-}
+#endif  /*RENDER_TARGA*/
+    }
+#endif  /*DEBUG*/
+}
+#endif /*USE_THREADS*/
 
 static void
@@ -153 +236 @@
 }
 
+#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 (;;) {
+        if (processCommands(interp, g_inBufPtr, g_fdOut) < 0)
+            break;
+
+        if (g_renderer->render()) {
+            TRACE("Rendering new frame");
+            g_renderer->getRenderedFrame(imgData);
+            queueFrame(queue, imgData);
+        } else {
+            TRACE("No render required");
+        }
+
+        if (g_inBufPtr->status() == ReadBuffer::ENDFILE)
+            break;
+    }    
+    return NULL;
+}
+
+static void *
+writerThread(void *clientData)
+{
+    ResponseQueue *queue = (ResponseQueue *)clientData;
+
+    TRACE("Starting writer thread");
+    for (;;) {
+        Response *response;
+
+        response = queue->dequeue();
+        if (response == NULL)
+            continue;
+        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[])
@@ -159 +298 @@
     signal(SIGPIPE, SIG_IGN);
     initService();
-    InitLog();
+    initLog();
 
     TRACE("Starting VTKVis Server");
-
-    g_fIn = stdin;
-    g_fOut = stdout;
-    g_fdIn = fileno(stdin);
-    g_fdOut = fileno(stdout);
 
     /* This synchronizes the client with the server, so that the client 
@@ -172 +306 @@
      * also be used to supply information about the server (version, memory
      * size, etc). */
-    fprintf(stdout, "VtkVis 1.0\n");
-    fflush(stdout);
+    fprintf(g_fOut, "VtkVis 1.0\n");
+    fflush(g_fOut);
 
     g_renderer = new Renderer();
+    g_inBufPtr = new ReadBuffer(g_fdIn, 1<<12);
+
+    Tcl_Interp *interp = Tcl_CreateInterp();
+
+#ifdef USE_THREADS
+    ResponseQueue *queue = new ResponseQueue((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));
+    } else {
+        TRACE("Reader thread exited");
+    }
+    // Writer thread is probably blocked on sem_wait, so cancel instead
+    // of joining
+    if (pthread_cancel(writerThreadId) < 0) {
+        ERROR("Can't cancel writer thread: %s", strerror(errno));
+    } else {
+        TRACE("Cancelled writer thread");
+    }
+
+    TRACE("Deleting ResponseQueue");
+    delete queue;
+    queue = NULL;
+#else 
+    initTcl(interp, (ClientData)NULL);
+
     vtkSmartPointer<vtkUnsignedCharArray> imgData = 
         vtkSmartPointer<vtkUnsignedCharArray>::New();
-
-    Tcl_Interp *interp = initTcl();
-
-    int ret = 0;
-
-    while (1) {
-        ret = processCommands(interp, g_fIn, g_fOut);
-        if (ret < 0)
+    for (;;) {
+        if (processCommands(interp, g_inBufPtr, g_fdOut) < 0)
             break;
 
@@ -196 +358 @@
         }
 
-        if (feof(g_fIn))
-            break;
-    }
-
+        if (g_inBufPtr->status() == ReadBuffer::ENDFILE)
+            break;
+    }
+#endif
+
+    TRACE("Stopping Tcl interpreter");
     exitTcl(interp);
     interp = NULL;
 
+    TRACE("Deleting ReadBuffer");
+    delete g_inBufPtr;
+    g_inBufPtr = NULL;
+
+    TRACE("Deleting renderer");
     delete g_renderer;
     g_renderer = NULL;
@@ -208 +377 @@
     TRACE("Exiting VTKVis Server");
 
-    CloseLog();
+    closeLog();
     exitService();
 
-    return ret;
-}
-
+    return 0;
+}

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

@@ -16 +16 @@
 extern int g_fdIn;
 extern int g_fdOut;
-extern FILE *g_fIn;
 extern FILE *g_fOut;
 extern FILE *g_fLog;
 extern Renderer *g_renderer;
+extern ReadBuffer *g_inBufPtr;
 
 }

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

@@ -43 +43 @@
 
 #include "RpVtkRenderer.h"
+#include "RpVtkRendererGraphicsObjs.h"
+#include "RpMath.h"
 #include "ColorMap.h"
 #include "Trace.h"
@@ -72 +74 @@
     _cameraOrientation[2] = 0.0;
     _cameraOrientation[3] = 0.0;
-    _cumulativeScalarRange[0] = 0.0;
-    _cumulativeScalarRange[1] = 1.0;
-    _cumulativeVectorMagnitudeRange[0] = 0.0;
-    _cumulativeVectorMagnitudeRange[1] = 1.0;
-    for (int i = 0; i < 3; i++) {
-        _cumulativeVectorComponentRange[i][0] = 0.0;
-        _cumulativeVectorComponentRange[i][1] = 1.0;
-    }
     // clipping planes to prevent overdrawing axes
     _activeClipPlanes = vtkSmartPointer<vtkPlaneCollection>::New();
@@ -149 +143 @@
     TRACE("Deleting Contour2Ds");
     for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
-             itr != _contour2Ds.end(); ++itr) {
+         itr != _contour2Ds.end(); ++itr) {
         delete itr->second;
     }
@@ -155 +149 @@
     TRACE("Deleting Contour3Ds");
     for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
-             itr != _contour3Ds.end(); ++itr) {
+         itr != _contour3Ds.end(); ++itr) {
         delete itr->second;
     }
@@ -161 +155 @@
     TRACE("Deleting Cutplanes");
     for (CutplaneHashmap::iterator itr = _cutplanes.begin();
-             itr != _cutplanes.end(); ++itr) {
+         itr != _cutplanes.end(); ++itr) {
         delete itr->second;
     }
@@ -167 +161 @@
     TRACE("Deleting Glyphs");
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
-             itr != _glyphs.end(); ++itr) {
+         itr != _glyphs.end(); ++itr) {
         delete itr->second;
     }
@@ -173 +167 @@
     TRACE("Deleting HeightMaps");
     for (HeightMapHashmap::iterator itr = _heightMaps.begin();
-             itr != _heightMaps.end(); ++itr) {
+         itr != _heightMaps.end(); ++itr) {
         delete itr->second;
     }
@@ -179 +173 @@
     TRACE("Deleting LICs");
     for (LICHashmap::iterator itr = _lics.begin();
-             itr != _lics.end(); ++itr) {
+         itr != _lics.end(); ++itr) {
         delete itr->second;
     }
@@ -185 +179 @@
     TRACE("Deleting Molecules");
     for (MoleculeHashmap::iterator itr = _molecules.begin();
-             itr != _molecules.end(); ++itr) {
+         itr != _molecules.end(); ++itr) {
         delete itr->second;
     }
@@ -191 +185 @@
     TRACE("Deleting PolyDatas");
     for (PolyDataHashmap::iterator itr = _polyDatas.begin();
-             itr != _polyDatas.end(); ++itr) {
+         itr != _polyDatas.end(); ++itr) {
         delete itr->second;
     }
@@ -197 +191 @@
     TRACE("Deleting PseudoColors");
     for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
-             itr != _pseudoColors.end(); ++itr) {
+         itr != _pseudoColors.end(); ++itr) {
         delete itr->second;
     }
@@ -203 +197 @@
     TRACE("Deleting Streamlines");
     for (StreamlinesHashmap::iterator itr = _streamlines.begin();
-             itr != _streamlines.end(); ++itr) {
+         itr != _streamlines.end(); ++itr) {
         delete itr->second;
     }
@@ -209 +203 @@
     TRACE("Deleting Volumes");
     for (VolumeHashmap::iterator itr = _volumes.begin();
-             itr != _volumes.end(); ++itr) {
+         itr != _volumes.end(); ++itr) {
         delete itr->second;
     }
@@ -217 +211 @@
     // exist
     for (ColorMapHashmap::iterator itr = _colorMaps.begin();
-             itr != _colorMaps.end(); ++itr) {
+         itr != _colorMaps.end(); ++itr) {
         delete itr->second;
     }
@@ -223 +217 @@
     TRACE("Deleting DataSets");
     for (DataSetHashmap::iterator itr = _dataSets.begin();
-             itr != _dataSets.end(); ++itr) {
+         itr != _dataSets.end(); ++itr) {
         delete itr->second;
     }
     _dataSets.clear();
+
+    clearFieldRanges();
+
     TRACE("Leave");
 }
@@ -244 +241 @@
     }
     _dataSets[id] = new DataSet(id);
-}
-
-/**
- * \brief Remove the Contour2D isolines for the specified DataSet
- *
- * The underlying Contour2D is deleted, freeing its memory
- */
-void Renderer::deleteContour2D(const DataSetId& id)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting Contour2Ds for %s", id.c_str());
-
-    do {
-        Contour2D *contour = itr->second;
-        if (contour->getProp())
-            _renderer->RemoveViewProp(contour->getProp());
-        delete contour;
-
-        itr = _contour2Ds.erase(itr);
-    } while (doAll && itr != _contour2Ds.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the Contour3D isosurfaces for the specified DataSet
- *
- * The underlying Contour3D is deleted, freeing its memory
- */
-void Renderer::deleteContour3D(const DataSetId& id)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting Contour3Ds for %s", id.c_str());
-
-    do {
-        Contour3D *contour = itr->second;
-        if (contour->getProp())
-            _renderer->RemoveViewProp(contour->getProp());
-        delete contour;
-
-        itr = _contour3Ds.erase(itr);
-    } while (doAll && itr != _contour3Ds.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \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
- *
- * The underlying Glyphs is deleted, freeing its memory
- */
-void Renderer::deleteGlyphs(const DataSetId& id)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting Glyphs for %s", id.c_str());
-
-    do {
-        Glyphs *glyphs = itr->second;
-        if (glyphs->getProp())
-            _renderer->RemoveViewProp(glyphs->getProp());
-        delete glyphs;
-
-        itr = _glyphs.erase(itr);
-    } while (doAll && itr != _glyphs.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the HeightMap for the specified DataSet
- *
- * The underlying HeightMap is deleted, freeing its memory
- */
-void Renderer::deleteHeightMap(const DataSetId& id)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting HeightMaps for %s", id.c_str());
-
-    do {
-        HeightMap *hmap = itr->second;
-        if (hmap->getProp())
-            _renderer->RemoveViewProp(hmap->getProp());
-        delete hmap;
-
-        itr = _heightMaps.erase(itr);
-    } while (doAll && itr != _heightMaps.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the LIC for the specified DataSet
- *
- * The underlying LIC is deleted, freeing its memory
- */
-void Renderer::deleteLIC(const DataSetId& id)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting LICs for %s", id.c_str());
-
-    do {
-        LIC *lic = itr->second;
-        if (lic->getProp())
-            _renderer->RemoveViewProp(lic->getProp());
-        delete lic;
-
-        itr = _lics.erase(itr);
-    } while (doAll && itr != _lics.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the Molecule for the specified DataSet
- *
- * The underlying Molecule is deleted, freeing its memory
- */
-void Renderer::deleteMolecule(const DataSetId& id)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting Molecules for %s", id.c_str());
-
-    do {
-        Molecule *molecule = itr->second;
-        if (molecule->getProp())
-            _renderer->RemoveViewProp(molecule->getProp());
-        delete molecule;
-
-        itr = _molecules.erase(itr);
-    } while (doAll && itr != _molecules.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the PolyData mesh for the specified DataSet
- *
- * The underlying PolyData is deleted, freeing its memory
- */
-void Renderer::deletePolyData(const DataSetId& id)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting PolyDatas for %s", id.c_str());
-
-    do {
-        PolyData *polyData = itr->second;
-        if (polyData->getProp())
-            _renderer->RemoveViewProp(polyData->getProp());
-        delete polyData;
-
-        itr = _polyDatas.erase(itr);
-    } while (doAll && itr != _polyDatas.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the PseudoColor mapping for the specified DataSet
- *
- * The underlying PseudoColor object is deleted, freeing its memory
- */
-void Renderer::deletePseudoColor(const DataSetId& id)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting PseudoColors for %s", id.c_str());
-
-    do  {
-        PseudoColor *ps = itr->second;
-        if (ps->getProp())
-            _renderer->RemoveViewProp(ps->getProp());
-        delete ps;
-
-        itr = _pseudoColors.erase(itr);
-    } while (doAll && itr != _pseudoColors.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the Streamlines mapping for the specified DataSet
- *
- * The underlying Streamlines object is deleted, freeing its memory
- */
-void Renderer::deleteStreamlines(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;
-    }
-
-    TRACE("Deleting Streamlines for %s", id.c_str());
-
-    do  {
-        Streamlines *sl = itr->second;
-        if (sl->getProp())
-            _renderer->RemoveViewProp(sl->getProp());
-        delete sl;
-
-        itr = _streamlines.erase(itr);
-    } while (doAll && itr != _streamlines.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Remove the Volume for the specified DataSet
- *
- * The underlying Volume is deleted, freeing its memory
- */
-void Renderer::deleteVolume(const DataSetId& id)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    TRACE("Deleting Volumes for %s", id.c_str());
-
-    do {
-        Volume *volume = itr->second;
-        if (volume->getProp())
-            _renderer->RemoveViewProp(volume->getProp());
-        delete volume;
-
-        itr = _volumes.erase(itr);
-    } while (doAll && itr != _volumes.end());
-
-    initCamera();
-    _needsRedraw = true;
 }
 
@@ -679 +269 @@
         TRACE("Deleting dataset %s", itr->second->getName().c_str());
 
-        deleteContour2D(itr->second->getName());
-        deleteContour3D(itr->second->getName());
-        deleteCutplane(itr->second->getName());
-        deleteGlyphs(itr->second->getName());
-        deleteHeightMap(itr->second->getName());
-        deleteLIC(itr->second->getName());
-        deleteMolecule(itr->second->getName());
-        deletePolyData(itr->second->getName());
-        deletePseudoColor(itr->second->getName());
-        deleteStreamlines(itr->second->getName());
-        deleteVolume(itr->second->getName());
+        deleteGraphicsObject<Contour2D>(itr->second->getName());
+        deleteGraphicsObject<Contour3D>(itr->second->getName());
+        deleteGraphicsObject<Cutplane>(itr->second->getName());
+        deleteGraphicsObject<Glyphs>(itr->second->getName());
+        deleteGraphicsObject<HeightMap>(itr->second->getName());
+        deleteGraphicsObject<LIC>(itr->second->getName());
+        deleteGraphicsObject<Molecule>(itr->second->getName());
+        deleteGraphicsObject<PolyData>(itr->second->getName());
+        deleteGraphicsObject<PseudoColor>(itr->second->getName());
+        deleteGraphicsObject<Streamlines>(itr->second->getName());
+        deleteGraphicsObject<Volume>(itr->second->getName());
  
         if (itr->second->getProp() != NULL) {
@@ -702 +292 @@
 
     // Update cumulative data range
-    updateRanges();
+    initFieldRanges();
+    updateFieldRanges();
 
     initCamera();
@@ -708 +299 @@
 }
 
+/**
+ * \brief Get a list of DataSets this Renderer knows about
+ */
 void Renderer::getDataSetNames(std::vector<std::string>& names)
 {
@@ -742 +336 @@
     if (ds) {
         bool ret = ds->setDataFile(filename);
-        updateRanges();
+        initFieldRanges();
+        updateFieldRanges();
         _needsRedraw = true;
         return ret;
@@ -757 +352 @@
     if (ds) {
         bool ret = ds->setData(data, nbytes);
-        updateRanges();
+        initFieldRanges();
+        updateFieldRanges();
         _needsRedraw = true;
         return ret;
@@ -764 +360 @@
 }
 
+/**
+ * \brief Set the active scalar field array by name for a DataSet
+ */
 bool Renderer::setDataSetActiveScalars(const DataSetId& id, const char *scalarName)
 {
@@ -782 +381 @@
 
     bool ret = true;
+    bool needRangeUpdate = false;
     do {
-        if (!itr->second->setActiveScalars(scalarName)) {
-            ret = false;
+        if (strcmp(itr->second->getActiveScalarsName(), scalarName) != 0) {
+            if (!itr->second->setActiveScalars(scalarName)) {
+                ret = false;
+            } else {
+                needRangeUpdate = true;
+            }
         }
     } while (doAll && ++itr != _dataSets.end());
 
-    if (ret) {
-         updateRanges();
+    if (needRangeUpdate) {
+         updateFieldRanges();
         _needsRedraw = true;
     } 
@@ -796 +400 @@
 }
 
+/**
+ * \brief Set the active vector field array by name for a DataSet
+ */
 bool Renderer::setDataSetActiveVectors(const DataSetId& id, const char *vectorName)
 {
@@ -814 +421 @@
 
     bool ret = true;
+    bool needRangeUpdate = false;
     do {
-        if (!itr->second->setActiveVectors(vectorName)) {
-            ret = false;
+        if (strcmp(itr->second->getActiveVectorsName(), vectorName) != 0) {
+            if (!itr->second->setActiveVectors(vectorName)) {
+                ret = false;
+            } else {
+                needRangeUpdate = true;
+            }
         }
     } while (doAll && ++itr != _dataSets.end());
 
-    if (ret) {
-        updateRanges();
+    if (needRangeUpdate) {
+        updateFieldRanges();
         _needsRedraw = true;
     } 
@@ -837 +449 @@
         _useCumulativeRange = state;
         _cumulativeRangeOnlyVisible = onlyVisible;
-        updateRanges();
+        updateFieldRanges();
         _needsRedraw = true;
     }
@@ -1462 +1074 @@
  * \brief Render a labelled legend image for the given colormap
  *
+ * The field is assumed to be the active scalar or vector field
+ * based on the legendType.
+ *
  * \param[in] id ColorMap name
  * \param[in] dataSetID DataSet name
@@ -1469 +1084 @@
  * If title was blank or "#auto", will be filled with field name on
  * return
- * \param[out] range Filled with min and max values
+ * \param[in,out] range Data range to use in legend.  Set min > max to have
+ * range computed, will be filled with valid min and max values
  * \param[in] width Pixel width of legend (aspect controls orientation)
  * \param[in] height Pixel height of legend (aspect controls orientation)
@@ -1487 +1103 @@
                               vtkUnsignedCharArray *imgData)
 {
+    DataSet *dataSet = NULL;
+    if (dataSetID.compare("all") == 0) {
+        if (_dataSets.empty()) {
+            WARN("No DataSets exist, can't fill title or range");
+            return renderColorMap(id, dataSetID, legendType,
+                                  NULL,
+                                  DataSet::POINT_DATA,
+                                  title, range, width, height, numLabels, imgData);
+        } else {
+            dataSet = _dataSets.begin()->second;
+        }
+    } else {
+        dataSet = getDataSet(dataSetID);
+        if (dataSet == NULL) {
+            ERROR("DataSet '%s' not found", dataSetID.c_str());
+            return false;
+        }
+    }
+
+    if (legendType == LEGEND_SCALAR) {
+        return renderColorMap(id, dataSetID, legendType,
+                              dataSet->getActiveScalarsName(),
+                              dataSet->getActiveScalarsType(),
+                              title, range, width, height, numLabels, imgData);
+    } else {
+        return renderColorMap(id, dataSetID, legendType,
+                              dataSet->getActiveVectorsName(),
+                              dataSet->getActiveVectorsType(),
+                              title, range, width, height, numLabels, imgData);
+    }
+}
+
+/**
+ * \brief Render a labelled legend image for the given colormap
+ *
+ * The field is assumed to be point data, if the field is not found
+ * as point data, cell data is used.
+ *
+ * \param[in] id ColorMap name
+ * \param[in] dataSetID DataSet name
+ * \param[in] legendType scalar or vector field legend
+ * \param[in] fieldName Name of the field array this legend is for
+ * \param[in,out] title If supplied, draw title ("#auto" means to
+ * fill in field name and draw).  If blank, do not draw title.  
+ * If title was blank or "#auto", will be filled with field name on
+ * return
+ * \param[in,out] range Data range to use in legend.  Set min > max to have
+ * range computed, will be filled with valid min and max values
+ * \param[in] width Pixel width of legend (aspect controls orientation)
+ * \param[in] height Pixel height of legend (aspect controls orientation)
+ * \param[in] numLabels Number of labels to render (includes min/max)
+ * \param[in,out] imgData Pointer to array to fill with image bytes. Array
+ * will be resized if needed.
+ * \return The image is rendered into the supplied array, false is 
+ * returned if the color map is not found
+ */
+bool Renderer::renderColorMap(const ColorMapId& id, 
+                              const DataSetId& dataSetID,
+                              Renderer::LegendType legendType,
+                              const char *fieldName,
+                              std::string& title,
+                              double range[2],
+                              int width, int height,
+                              int numLabels,
+                              vtkUnsignedCharArray *imgData)
+{
+    DataSet *dataSet = NULL;
+    if (dataSetID.compare("all") == 0) {
+        if (_dataSets.empty()) {
+            WARN("No DataSets exist, can't fill title or range");
+            return renderColorMap(id, dataSetID, legendType,
+                                  NULL,
+                                  DataSet::POINT_DATA,
+                                  title, range, width, height, numLabels, imgData);
+        } else {
+            dataSet = _dataSets.begin()->second;
+        }
+    } else {
+        dataSet = getDataSet(dataSetID);
+        if (dataSet == NULL) {
+            ERROR("DataSet '%s' not found", dataSetID.c_str());
+            return false;
+        }
+    }
+
+    DataSet::DataAttributeType attrType;
+    int numComponents;
+
+    dataSet->getFieldInfo(fieldName, &attrType, &numComponents);
+
+    return renderColorMap(id, dataSetID, legendType,
+                          fieldName,
+                          attrType,
+                          title, range, width, height, numLabels, imgData);
+}
+
+/**
+ * \brief Render a labelled legend image for the given colormap
+ *
+ * \param[in] id ColorMap name
+ * \param[in] dataSetID DataSet name
+ * \param[in] legendType scalar or vector field legend
+ * \param[in] fieldName Name of the field array this legend is for
+ * \param[in] type DataAttributeType of the field
+ * \param[in,out] title If supplied, draw title ("#auto" means to
+ * fill in field name and draw).  If blank, do not draw title.  
+ * If title was blank or "#auto", will be filled with field name on
+ * return
+ * \param[in,out] range Data range to use in legend.  Set min > max to have
+ * range computed, will be filled with valid min and max values
+ * \param[in] width Pixel width of legend (aspect controls orientation)
+ * \param[in] height Pixel height of legend (aspect controls orientation)
+ * \param[in] numLabels Number of labels to render (includes min/max)
+ * \param[in,out] imgData Pointer to array to fill with image bytes. Array
+ * will be resized if needed.
+ * \return The image is rendered into the supplied array, false is 
+ * returned if the color map is not found
+ */
+bool Renderer::renderColorMap(const ColorMapId& id, 
+                              const DataSetId& dataSetID,
+                              Renderer::LegendType legendType,
+                              const char *fieldName,
+                              DataSet::DataAttributeType type,
+                              std::string& title,
+                              double range[2],
+                              int width, int height,
+                              int numLabels,
+                              vtkUnsignedCharArray *imgData)
+{
     TRACE("Enter");
     ColorMap *colorMap = getColorMap(id);
@@ -1494 +1239 @@
     if (_legendRenderWindow == NULL) {
         _legendRenderWindow = vtkSmartPointer<vtkRenderWindow>::New();
+        _legendRenderWindow->SetMultiSamples(0);
 #ifdef USE_OFFSCREEN_RENDERING
         _legendRenderWindow->DoubleBufferOff();
@@ -1575 +1321 @@
     }
 
-    range[0] = 0.0;
-    range[1] = 1.0;
+    bool needRange = false;
+    if (range[0] > range[1]) {
+        range[0] = 0.0;
+        range[1] = 1.0;
+        needRange = true;
+    } 
 
     switch (legendType) {
-    case ACTIVE_VECTOR_MAGNITUDE:
-        if (cumulative) {
-            lut->SetRange(_cumulativeVectorMagnitudeRange);
-            range[0] = _cumulativeVectorMagnitudeRange[0];
-            range[1] = _cumulativeVectorMagnitudeRange[1];
-        } else if (dataSet != NULL) {
-            dataSet->getVectorRange(range);
-            lut->SetRange(range);
-        }
+    case LEGEND_VECTOR_MAGNITUDE:
+        if (needRange) {
+            if (cumulative) {
+                getCumulativeDataRange(range, fieldName, type, 3);
+            } else if (dataSet != NULL) {
+                dataSet->getDataRange(range, fieldName, type);
+            }
+        }
+
+        lut->SetRange(range);
+
         if (title.empty() && dataSet != NULL) {
-            const char *name = dataSet->getActiveVectorsName();
-            if (name != NULL) {
-                title = name;
+            if (fieldName != NULL) {
+                title = fieldName;
                 title.append("(mag)");
             }
         }
         break;
-    case ACTIVE_VECTOR_X:
-        if (cumulative) {
-            lut->SetRange(_cumulativeVectorComponentRange[0]);
-            range[0] = _cumulativeVectorComponentRange[0][0];
-            range[1] = _cumulativeVectorComponentRange[0][1];
-        } else if (dataSet != NULL) {
-            dataSet->getVectorRange(range, 0);
-            lut->SetRange(range);
-        }
+    case LEGEND_VECTOR_X:
+        if (needRange) {
+            if (cumulative) {
+                getCumulativeDataRange(range, fieldName, type, 3, 0);
+            } else if (dataSet != NULL) {
+                dataSet->getDataRange(range, fieldName, type, 0);
+            }
+        }
+
+        lut->SetRange(range);
+
         if (title.empty() && dataSet != NULL) {
-            const char *name = dataSet->getActiveVectorsName();
-            if (name != NULL) {
-                title = name;
+            if (fieldName != NULL) {
+                title = fieldName;
                 title.append("(x)");
             }
         }
         break;
-    case ACTIVE_VECTOR_Y:
-        if (cumulative) {
-            lut->SetRange(_cumulativeVectorComponentRange[1]);
-            range[0] = _cumulativeVectorComponentRange[1][0];
-            range[1] = _cumulativeVectorComponentRange[1][1];
-        } else if (dataSet != NULL) {
-            dataSet->getVectorRange(range, 1);
-            lut->SetRange(range);
-        }
+    case LEGEND_VECTOR_Y:
+        if (needRange) {
+            if (cumulative) {
+                getCumulativeDataRange(range, fieldName, type, 3, 1);
+            } else if (dataSet != NULL) {
+                dataSet->getDataRange(range, fieldName, type, 1);
+            }
+        }
+
+        lut->SetRange(range);
+
         if (title.empty() && dataSet != NULL) {
-            const char *name = dataSet->getActiveVectorsName();
-            if (name != NULL) {
-                title = name;
+            if (fieldName != NULL) {
+                title = fieldName;
                 title.append("(y)");
             }
         }
         break;
-    case ACTIVE_VECTOR_Z:
-        if (cumulative) {
-            lut->SetRange(_cumulativeVectorComponentRange[2]);
-            range[0] = _cumulativeVectorComponentRange[2][0];
-            range[1] = _cumulativeVectorComponentRange[2][1];
-        } else if (dataSet != NULL) {
-            dataSet->getVectorRange(range, 1);
-            lut->SetRange(range);
-        }
+    case LEGEND_VECTOR_Z:
+        if (needRange) {
+            if (cumulative) {
+                getCumulativeDataRange(range, fieldName, type, 3, 2);
+            } else if (dataSet != NULL) {
+                dataSet->getDataRange(range, fieldName, type, 1);
+            }
+        }
+
+        lut->SetRange(range);
+
         if (title.empty() && dataSet != NULL) {
-            const char *name = dataSet->getActiveVectorsName();
-            if (name != NULL) {
-                title = name;
+            if (fieldName != NULL) {
+                title = fieldName;
                 title.append("(z)");
             }
         }
         break;
-    case ACTIVE_SCALAR:
+    case LEGEND_SCALAR:
     default:
-        if (cumulative) {
-            lut->SetRange(_cumulativeScalarRange);
-            range[0] = _cumulativeScalarRange[0];
-            range[1] = _cumulativeScalarRange[1];
-        } else if (dataSet != NULL) {
-            dataSet->getScalarRange(range);
-            lut->SetRange(range);
-        }
+        if (needRange) {
+            if (cumulative) {
+                getCumulativeDataRange(range, fieldName, type, 1);
+            } else if (dataSet != NULL) {
+                dataSet->getDataRange(range, fieldName, type);
+            }
+        }
+
+        lut->SetRange(range);
+
         if (title.empty() && dataSet != NULL) {
-            const char *name = dataSet->getActiveScalarsName();
-            if (name != NULL)
-                title = name;
+            if (fieldName != NULL)
+                title = fieldName;
         }
         break;
@@ -1695 +1450 @@
     }
     glDisable(GL_TEXTURE_2D);
-    glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_renderWindow)->GetFrontLeftBuffer()));
+    if (_legendRenderWindow->GetDoubleBuffer()) {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetBackLeftBuffer()));
+    } else {
+        glReadBuffer(static_cast<GLenum>(vtkOpenGLRenderWindow::SafeDownCast(_legendRenderWindow)->GetFrontLeftBuffer()));
+    }
     glPixelStorei(GL_PACK_ALIGNMENT, 1);
     if (bytesPerPixel == 4) {
@@ -1714 +1473 @@
     TRACE("Leave");
     return true;
-}
-
-/**
- * \brief Create a new Contour2D and associate it with the named DataSet
- */
-bool Renderer::addContour2D(const DataSetId& id, int numContours)
-{
-    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 (getContour2D(dsID)) {
-            WARN("Replacing existing Contour2D %s", dsID.c_str());
-            deleteContour2D(dsID);
-        }
-
-        Contour2D *contour = new Contour2D(numContours);
- 
-        contour->setDataSet(ds,
-                            _useCumulativeRange, 
-                            _cumulativeScalarRange,
-                            _cumulativeVectorMagnitudeRange,
-                            _cumulativeVectorComponentRange);
-
-        if (contour->getProp() == NULL) {
-            delete contour;
-            return false;
-        } else {
-            _renderer->AddViewProp(contour->getProp());
-        }
-
-        _contour2Ds[dsID] = contour;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Create a new Contour2D and associate it with the named DataSet
- */
-bool Renderer::addContour2D(const DataSetId& id, const std::vector<double>& contours)
-{
-    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 (getContour2D(dsID)) {
-            WARN("Replacing existing Contour2D %s", dsID.c_str());
-            deleteContour2D(dsID);
-        }
-
-        Contour2D *contour = new Contour2D(contours);
-
-        contour->setDataSet(ds,
-                            _useCumulativeRange, 
-                            _cumulativeScalarRange,
-                            _cumulativeVectorMagnitudeRange,
-                            _cumulativeVectorComponentRange);
-
-        if (contour->getProp() == NULL) {
-            delete contour;
-            return false;
-        } else {
-            _renderer->AddViewProp(contour->getProp());
-        }
-
-        _contour2Ds[dsID] = contour;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Contour2D associated with a named DataSet
- */
-Contour2D *Renderer::getContour2D(const DataSetId& id)
-{
-    Contour2DHashmap::iterator itr = _contour2Ds.find(id);
-
-    if (itr == _contour2Ds.end()) {
-#ifdef DEBUG
-        TRACE("Contour2D not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setContour2DTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setContour2DOrientation(const DataSetId& id, double quat[4])
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setContour2DOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setContour2DPosition(const DataSetId& id, double pos[3])
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setContour2DScale(const DataSetId& id, double scale[3])
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the number of equally spaced contour isolines for the given DataSet
- */
-void Renderer::setContour2DContours(const DataSetId& id, int numContours)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContours(numContours);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set a list of isovalues for the given DataSet
- */
-void Renderer::setContour2DContourList(const DataSetId& id, const std::vector<double>& contours)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourList(contours);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-     _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of contour lines for the given DataSet
- */
-void Renderer::setContour2DOpacity(const DataSetId& id, double opacity)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering contour lines for the given DataSet
- */
-void Renderer::setContour2DVisibility(const DataSetId& id, bool state)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB isoline color for the specified DataSet
- */
-void Renderer::setContour2DColor(const DataSetId& id, float color[3])
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the isoline 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::setContour2DEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _contour2Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn contour lighting on/off for the specified DataSet
- */
-void Renderer::setContour2DLighting(const DataSetId& id, bool state)
-{
-    Contour2DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour2Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour2Ds.find(id);
-    }
-    if (itr == _contour2Ds.end()) {
-        ERROR("Contour2D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _contour2Ds.end());
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new Contour3D and associate it with the named DataSet
- */
-bool Renderer::addContour3D(const DataSetId& id, int numContours)
-{
-    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 (getContour3D(dsID)) {
-            WARN("Replacing existing Contour3D %s", dsID.c_str());
-            deleteContour3D(dsID);
-        }
-
-        Contour3D *contour = new Contour3D(numContours);
-
-        contour->setDataSet(ds,
-                            _useCumulativeRange,
-                            _cumulativeScalarRange,
-                            _cumulativeVectorMagnitudeRange,
-                            _cumulativeVectorComponentRange);
-
-        if (contour->getProp() == NULL) {
-            delete contour;
-            return false;
-        } else {
-            _renderer->AddViewProp(contour->getProp());
-        }
-
-        _contour3Ds[dsID] = contour;
-    } while (doAll && ++itr != _dataSets.end());
-
-    if (_cameraMode == IMAGE)
-        setCameraMode(PERSPECTIVE);
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Create a new Contour3D and associate it with the named DataSet
- */
-bool Renderer::addContour3D(const DataSetId& id,const std::vector<double>& contours)
-{
-    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 (getContour3D(dsID)) {
-            WARN("Replacing existing Contour3D %s", dsID.c_str());
-            deleteContour3D(dsID);
-        }
-
-        Contour3D *contour = new Contour3D(contours);
-
-        contour->setDataSet(ds,
-                            _useCumulativeRange, 
-                            _cumulativeScalarRange,
-                            _cumulativeVectorMagnitudeRange,
-                            _cumulativeVectorComponentRange);
-
-        if (contour->getProp() == NULL) {
-            delete contour;
-            return false;
-        } else {
-            _renderer->AddViewProp(contour->getProp());
-        }
-
-        _contour3Ds[dsID] = contour;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Contour3D associated with a named DataSet
- */
-Contour3D *Renderer::getContour3D(const DataSetId& id)
-{
-    Contour3DHashmap::iterator itr = _contour3Ds.find(id);
-
-    if (itr == _contour3Ds.end()) {
-#ifdef DEBUG
-        TRACE("Contour3D not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setContour3DTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setContour3DOrientation(const DataSetId& id, double quat[4])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setContour3DOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setContour3DPosition(const DataSetId& id, double pos[3])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setContour3DScale(const DataSetId& id, double scale[3])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the number of equally spaced isosurfaces for the given DataSet
- */
-void Renderer::setContour3DContours(const DataSetId& id, int numContours)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContours(numContours);
-     } while (doAll && ++itr != _contour3Ds.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set a list of isovalues for the given DataSet
- */
-void Renderer::setContour3DContourList(const DataSetId& id, const std::vector<double>& contours)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourList(contours);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    initCamera();
-     _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of isosurfaces for the given DataSet
- */
-void Renderer::setContour3DOpacity(const DataSetId& id, double opacity)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering isosurfaces for the given DataSet
- */
-void Renderer::setContour3DVisibility(const DataSetId& id, bool state)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a Contour3D for the given 
- * DataSet
- */
-void Renderer::setContour3DColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set Contour3D color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB isosurface color for the specified DataSet
- */
-void Renderer::setContour3DColor(const DataSetId& id, float color[3])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _contour3Ds.end());
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering isosurface edges for the given DataSet
- */
-void Renderer::setContour3DEdgeVisibility(const DataSetId& id, bool state)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB isosurface edge color for the specified DataSet
- */
-void Renderer::setContour3DEdgeColor(const DataSetId& id, float color[3])
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the isosurface 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::setContour3DEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set wireframe rendering for the specified DataSet
- */
-void Renderer::setContour3DWireframe(const DataSetId& id, bool state)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _contour3Ds.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn contour lighting on/off for the specified DataSet
- */
-void Renderer::setContour3DLighting(const DataSetId& id, bool state)
-{
-    Contour3DHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _contour3Ds.begin();
-        doAll = true;
-    } else {
-        itr = _contour3Ds.find(id);
-    }
-    if (itr == _contour3Ds.end()) {
-        ERROR("Contour3D not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _contour3Ds.end());
-    _needsRedraw = true;
-}
-
-/**
- * \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
- */
-bool Renderer::addGlyphs(const DataSetId& id, Glyphs::GlyphShape shape)
-{
-    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 (getGlyphs(dsID)) {
-            WARN("Replacing existing Glyphs %s", dsID.c_str());
-            deleteGlyphs(dsID);
-        }
-
-        Glyphs *glyphs = new Glyphs(shape);
-
-        glyphs->setDataSet(ds,
-                           _useCumulativeRange, 
-                           _cumulativeScalarRange,
-                           _cumulativeVectorMagnitudeRange,
-                           _cumulativeVectorComponentRange);
-
-        if (glyphs->getProp() == NULL) {
-            delete glyphs;
-            return false;
-        } else {
-            _renderer->AddViewProp(glyphs->getProp());
-        }
-
-        _glyphs[dsID] = glyphs;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Glyphs associated with a named DataSet
- */
-Glyphs *Renderer::getGlyphs(const DataSetId& id)
-{
-    GlyphsHashmap::iterator itr = _glyphs.find(id);
-
-    if (itr == _glyphs.end()) {
-#ifdef DEBUG
-        TRACE("Glyphs not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setGlyphsTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _glyphs.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setGlyphsOrientation(const DataSetId& id, double quat[4])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _glyphs.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setGlyphsOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _glyphs.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setGlyphsPosition(const DataSetId& id, double pos[3])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _glyphs.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setGlyphsScale(const DataSetId& id, double scale[3])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _glyphs.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon color for the specified DataSet
- */
-void Renderer::setGlyphsColor(const DataSetId& id, float color[3])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a Glyphs for the given DataSet
- */
-void Renderer::setGlyphsColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set Glyphs color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Controls the array used to color glyphs for the given DataSet
- */
-void Renderer::setGlyphsColorMode(const DataSetId& id, Glyphs::ColorMode mode)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColorMode(mode);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Controls the array used to scale glyphs for the given DataSet
- */
-void Renderer::setGlyphsScalingMode(const DataSetId& id, Glyphs::ScalingMode mode)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScalingMode(mode);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _renderer->ResetCameraClippingRange();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Controls if field data range is normalized to [0,1] before
- * applying scale factor for the given DataSet
- */
-void Renderer::setGlyphsNormalizeScale(const DataSetId& id, bool normalize)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setNormalizeScale(normalize);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _renderer->ResetCameraClippingRange();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the shape of Glyphs for the given DataSet
- */
-void Renderer::setGlyphsShape(const DataSetId& id, Glyphs::GlyphShape shape)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setGlyphShape(shape);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _renderer->ResetCameraClippingRange();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the glyph scaling factor for the given DataSet
- */
-void Renderer::setGlyphsScaleFactor(const DataSetId& id, double scale)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScaleFactor(scale);
-    } while (doAll && ++itr != _glyphs.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setGlyphsEdgeVisibility(const DataSetId& id, bool state)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon edge color for the specified DataSet
- */
-void Renderer::setGlyphsEdgeColor(const DataSetId& id, float color[3])
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the polygon 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::setGlyphsEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn Glyphs lighting on/off for the specified DataSet
- */
-void Renderer::setGlyphsLighting(const DataSetId& id, bool state)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _glyphs.end());
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of Glyphs for the given DataSet
- */
-void Renderer::setGlyphsOpacity(const DataSetId& id, double opacity)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering Glyphs for the given DataSet
- */
-void Renderer::setGlyphsVisibility(const DataSetId& id, bool state)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off wireframe rendering of Glyphs for the given DataSet
- */
-void Renderer::setGlyphsWireframe(const DataSetId& id, bool state)
-{
-    GlyphsHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _glyphs.begin();
-        doAll = true;
-    } else {
-        itr = _glyphs.find(id);
-    }
-    if (itr == _glyphs.end()) {
-        ERROR("Glyphs not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _glyphs.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new HeightMap and associate it with the named DataSet
- */
-bool Renderer::addHeightMap(const DataSetId& id, int numContours, double heightScale)
-{
-    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 (getHeightMap(dsID)) {
-            WARN("Replacing existing HeightMap %s", dsID.c_str());
-            deleteHeightMap(dsID);
-        }
-
-        HeightMap *hmap = new HeightMap(numContours, heightScale);
-
-        hmap->setDataSet(ds,
-                         _useCumulativeRange, 
-                         _cumulativeScalarRange,
-                         _cumulativeVectorMagnitudeRange,
-                         _cumulativeVectorComponentRange);
-
-        if (hmap->getProp() == NULL) {
-            delete hmap;
-            return false;
-        } else {
-            _renderer->AddViewProp(hmap->getProp());
-        }
-
-        _heightMaps[dsID] = hmap;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Create a new HeightMap and associate it with the named DataSet
- */
-bool Renderer::addHeightMap(const DataSetId& id, const std::vector<double>& contours, double heightScale)
-{
-    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 (getHeightMap(dsID)) {
-            WARN("Replacing existing HeightMap %s", dsID.c_str());
-            deleteHeightMap(dsID);
-        }
-
-        HeightMap *hmap = new HeightMap(contours, heightScale);
-
-        hmap->setDataSet(ds,
-                         _useCumulativeRange, 
-                         _cumulativeScalarRange,
-                         _cumulativeVectorMagnitudeRange,
-                         _cumulativeVectorComponentRange);
-
-        if (hmap->getProp() == NULL) {
-            delete hmap;
-            return false;
-        } else {
-            _renderer->AddViewProp(hmap->getProp());
-        }
-
-        _heightMaps[dsID] = hmap;
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the HeightMap associated with a named DataSet
- */
-HeightMap *Renderer::getHeightMap(const DataSetId& id)
-{
-    HeightMapHashmap::iterator itr = _heightMaps.find(id);
-
-    if (itr == _heightMaps.end()) {
-#ifdef DEBUG
-        TRACE("HeightMap not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set an additional transform on the prop
- */
-void Renderer::setHeightMapTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setHeightMapOrientation(const DataSetId& id, double quat[4])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setHeightMapOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setHeightMapPosition(const DataSetId& id, double pos[3])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setHeightMapScale(const DataSetId& id, double scale[3])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the volume slice used for mapping volumetric data
- */
-void Renderer::setHeightMapVolumeSlice(const DataSetId& id, HeightMap::Axis axis, double ratio)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    bool initCam = false;
-    do {
-        itr->second->selectVolumeSlice(axis, ratio);
-        if (itr->second->getHeightScale() > 0.0)
-            initCam = true;
-     } while (doAll && ++itr != _heightMaps.end());
-
-    if (initCam)
-        initCamera();
-    else
-        _renderer->ResetCameraClippingRange();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set amount to scale scalar values when creating elevations
- * in the height map
- */
-void Renderer::setHeightMapHeightScale(const DataSetId& id, double scale)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setHeightScale(scale);
-     } while (doAll && ++itr != _heightMaps.end());
-
-    initCamera();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a HeightMap for the given DataSet
- */
-void Renderer::setHeightMapColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap 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 HeightMap color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the number of equally spaced contour isolines for the given DataSet
- */
-void Renderer::setHeightMapNumContours(const DataSetId& id, int numContours)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setNumContours(numContours);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set a list of height map contour isovalues for the given DataSet
- */
-void Renderer::setHeightMapContourList(const DataSetId& id, const std::vector<double>& contours)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourList(contours);
-    } while (doAll && ++itr != _heightMaps.end());
-
-     _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of height map for the given DataSet
- */
-void Renderer::setHeightMapOpacity(const DataSetId& id, double opacity)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering height map for the given DataSet
- */
-void Renderer::setHeightMapVisibility(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set wireframe rendering for the specified DataSet
- */
-void Renderer::setHeightMapWireframe(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering height map mesh edges for the given DataSet
- */
-void Renderer::setHeightMapEdgeVisibility(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB height map mesh edge color for the specified DataSet
- */
-void Renderer::setHeightMapEdgeColor(const DataSetId& id, float color[3])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _heightMaps.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::setHeightMapEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering height map contour lines for the given DataSet
- */
-void Renderer::setHeightMapContourLineVisibility(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourLineVisibility(state);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering height map colormap surface for the given DataSet
- */
-void Renderer::setHeightMapContourSurfaceVisibility(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourSurfaceVisibility(state);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB height map isoline color for the specified DataSet
- */
-void Renderer::setHeightMapContourEdgeColor(const DataSetId& id, float color[3])
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourEdgeColor(color);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the height map isoline 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::setHeightMapContourEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setContourEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _heightMaps.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn height map lighting on/off for the specified DataSet
- */
-void Renderer::setHeightMapLighting(const DataSetId& id, bool state)
-{
-    HeightMapHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _heightMaps.begin();
-        doAll = true;
-    } else {
-        itr = _heightMaps.find(id);
-    }
-    if (itr == _heightMaps.end()) {
-        ERROR("HeightMap not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _heightMaps.end());
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new LIC and associate it with the named DataSet
- */
-bool Renderer::addLIC(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 (getLIC(dsID)) {
-            WARN("Replacing existing LIC %s", dsID.c_str());
-            deleteLIC(dsID);
-        }
-
-        LIC *lic = new LIC();
-        _lics[dsID] = lic;
-
-        lic->setDataSet(ds,
-                        _useCumulativeRange, 
-                        _cumulativeScalarRange,
-                        _cumulativeVectorMagnitudeRange,
-                        _cumulativeVectorComponentRange);
-
-        _renderer->AddViewProp(lic->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the LIC associated with a named DataSet
- */
-LIC *Renderer::getLIC(const DataSetId& id)
-{
-    LICHashmap::iterator itr = _lics.find(id);
-
-    if (itr == _lics.end()) {
-#ifdef DEBUG
-        TRACE("LIC not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setLICTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _lics.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setLICOrientation(const DataSetId& id, double quat[4])
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _lics.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setLICOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _lics.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setLICPosition(const DataSetId& id, double pos[3])
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _lics.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setLICScale(const DataSetId& id, double scale[3])
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _lics.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the volume slice used for mapping volumetric data
- */
-void Renderer::setLICVolumeSlice(const DataSetId& id, LIC::Axis axis, double ratio)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->selectVolumeSlice(axis, ratio);
-     } while (doAll && ++itr != _lics.end());
-
-    _renderer->ResetCameraClippingRange();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with an LIC for the given DataSet
- */
-void Renderer::setLICColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set LIC color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of the LIC for the given DataSet
- */
-void Renderer::setLICOpacity(const DataSetId& id, double opacity)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the LIC for the given DataSet
- */
-void Renderer::setLICVisibility(const DataSetId& id, bool state)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setLICEdgeVisibility(const DataSetId& id, bool state)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon edge color for the specified DataSet
- */
-void Renderer::setLICEdgeColor(const DataSetId& id, float color[3])
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the polygon 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::setLICEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn LIC lighting on/off for the specified DataSet
- */
-void Renderer::setLICLighting(const DataSetId& id, bool state)
-{
-    LICHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _lics.begin();
-        doAll = true;
-    } else {
-        itr = _lics.find(id);
-    }
-    if (itr == _lics.end()) {
-        ERROR("LIC not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _lics.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new Molecule and associate it with the named DataSet
- */
-bool Renderer::addMolecule(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 (getMolecule(dsID)) {
-            WARN("Replacing existing Molecule %s", dsID.c_str());
-            deleteMolecule(dsID);
-        }
-
-        Molecule *molecule = new Molecule();
-        _molecules[dsID] = molecule;
-
-        molecule->setDataSet(ds);
-
-        _renderer->AddViewProp(molecule->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Molecule associated with a named DataSet
- */
-Molecule *Renderer::getMolecule(const DataSetId& id)
-{
-    MoleculeHashmap::iterator itr = _molecules.find(id);
-
-    if (itr == _molecules.end()) {
-#ifdef DEBUG
-        TRACE("Molecule not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setMoleculeTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _molecules.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setMoleculeOrientation(const DataSetId& id, double quat[4])
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _molecules.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setMoleculeOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _molecules.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setMoleculePosition(const DataSetId& id, double pos[3])
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _molecules.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setMoleculeScale(const DataSetId& id, double scale[3])
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _molecules.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a Molecule for the given DataSet
- */
-void Renderer::setMoleculeColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-
-    if (itr == _molecules.end()) {
-        ERROR("Molecule 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 Molecule color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of the Molecule for the given DataSet
- */
-void Renderer::setMoleculeOpacity(const DataSetId& id, double opacity)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set radius standard for scaling atoms
- */
-void Renderer::setMoleculeAtomScaling(const DataSetId& id, Molecule::AtomScaling scaling)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setAtomScaling(scaling);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Molecule atoms for the given DataSet
- */
-void Renderer::setMoleculeAtomVisibility(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setAtomVisibility(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Molecule bonds for the given DataSet
- */
-void Renderer::setMoleculeBondVisibility(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setBondVisibility(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Molecule for the given DataSet
- */
-void Renderer::setMoleculeVisibility(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setMoleculeEdgeVisibility(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon edge color for the specified DataSet
- */
-void Renderer::setMoleculeEdgeColor(const DataSetId& id, float color[3])
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the polygon 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::setMoleculeEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set wireframe rendering for the specified DataSet
- */
-void Renderer::setMoleculeWireframe(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn Molecule lighting on/off for the specified DataSet
- */
-void Renderer::setMoleculeLighting(const DataSetId& id, bool state)
-{
-    MoleculeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _molecules.begin();
-        doAll = true;
-    } else {
-        itr = _molecules.find(id);
-    }
-    if (itr == _molecules.end()) {
-        ERROR("Molecule not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _molecules.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new PolyData and associate it with the named DataSet
- */
-bool Renderer::addPolyData(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 (getPolyData(dsID)) {
-            WARN("Replacing existing PolyData %s", dsID.c_str());
-            deletePolyData(dsID);
-        }
-
-        PolyData *polyData = new PolyData();
-        _polyDatas[dsID] = polyData;
-
-        polyData->setDataSet(ds);
-
-        _renderer->AddViewProp(polyData->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the PolyData associated with a named DataSet
- */
-PolyData *Renderer::getPolyData(const DataSetId& id)
-{
-    PolyDataHashmap::iterator itr = _polyDatas.find(id);
-
-    if (itr == _polyDatas.end()) {
-#ifdef DEBUG
-        TRACE("PolyData not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set an additional transform on the prop
- */
-void Renderer::setPolyDataTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setPolyDataOrientation(const DataSetId& id, double quat[4])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setPolyDataOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setPolyDataPosition(const DataSetId& id, double pos[3])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setPolyDataScale(const DataSetId& id, double scale[3])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of the PolyData for the given DataSet
- */
-void Renderer::setPolyDataOpacity(const DataSetId& id, double opacity)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the PolyData mapper for the given DataSet
- */
-void Renderer::setPolyDataVisibility(const DataSetId& id, bool state)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon face color for the specified DataSet
- */
-void Renderer::setPolyDataColor(const DataSetId& id, float color[3])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _polyDatas.end());
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setPolyDataEdgeVisibility(const DataSetId& id, bool state)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon edge color for the specified DataSet
- */
-void Renderer::setPolyDataEdgeColor(const DataSetId& id, float color[3])
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the polygon 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::setPolyDataEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the point size for the specified DataSet (may be a no-op)
- *
- * If the OpenGL implementation/hardware does not support wide points, 
- * this function may not have an effect.
- */
-void Renderer::setPolyDataPointSize(const DataSetId& id, float size)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPointSize(size);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set wireframe rendering for the specified DataSet
- */
-void Renderer::setPolyDataWireframe(const DataSetId& id, bool state)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn mesh lighting on/off for the specified DataSet
- */
-void Renderer::setPolyDataLighting(const DataSetId& id, bool state)
-{
-    PolyDataHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _polyDatas.begin();
-        doAll = true;
-    } else {
-        itr = _polyDatas.find(id);
-    }
-    if (itr == _polyDatas.end()) {
-        ERROR("PolyData not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _polyDatas.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new PseudoColor rendering for the specified DataSet
- */
-bool Renderer::addPseudoColor(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 (getPseudoColor(dsID)) {
-            WARN("Replacing existing PseudoColor %s", dsID.c_str());
-            deletePseudoColor(dsID);
-        }
-        PseudoColor *pc = new PseudoColor();
-        _pseudoColors[dsID] = pc;
-
-        pc->setDataSet(ds,
-                       _useCumulativeRange, 
-                       _cumulativeScalarRange,
-                       _cumulativeVectorMagnitudeRange,
-                       _cumulativeVectorComponentRange);
-
-        _renderer->AddViewProp(pc->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the PseudoColor associated with the specified DataSet
- */
-PseudoColor *Renderer::getPseudoColor(const DataSetId& id)
-{
-    PseudoColorHashmap::iterator itr = _pseudoColors.find(id);
-
-    if (itr == _pseudoColors.end()) {
-#ifdef DEBUG
-        TRACE("PseudoColor not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setPseudoColorTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setPseudoColorOrientation(const DataSetId& id, double quat[4])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setPseudoColorOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setPseudoColorPosition(const DataSetId& id, double pos[3])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setPseudoColorScale(const DataSetId& id, double scale[3])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB color for the specified DataSet
- */
-void Renderer::setPseudoColorColor(const DataSetId& id, float color[3])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a PseudoColor for the given DataSet
- */
-void Renderer::setPseudoColorColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set PseudoColor color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the color mode for the specified DataSet
- */
-void Renderer::setPseudoColorColorMode(const DataSetId& id, PseudoColor::ColorMode mode)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColorMode(mode);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set opacity of the PseudoColor for the given DataSet
- */
-void Renderer::setPseudoColorOpacity(const DataSetId& id, double opacity)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the PseudoColor mapper for the given DataSet
- */
-void Renderer::setPseudoColorVisibility(const DataSetId& id, bool state)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setPseudoColorEdgeVisibility(const DataSetId& id, bool state)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeVisibility(state);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB polygon edge color for the specified DataSet
- */
-void Renderer::setPseudoColorEdgeColor(const DataSetId& id, float color[3])
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the polygon 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::setPseudoColorEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set wireframe rendering for the specified DataSet
- */
-void Renderer::setPseudoColorWireframe(const DataSetId& id, bool state)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setWireframe(state);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn mesh lighting on/off for the specified DataSet
- */
-void Renderer::setPseudoColorLighting(const DataSetId& id, bool state)
-{
-    PseudoColorHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _pseudoColors.begin();
-        doAll = true;
-    } else {
-        itr = _pseudoColors.find(id);
-    }
-
-    if (itr == _pseudoColors.end()) {
-        ERROR("PseudoColor not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _pseudoColors.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new Streamlines and associate it with the named DataSet
- */
-bool Renderer::addStreamlines(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 (getStreamlines(dsID)) {
-            WARN("Replacing existing Streamlines %s", dsID.c_str());
-            deleteStreamlines(dsID);
-        }
-
-        Streamlines *streamlines = new Streamlines();
-        _streamlines[dsID] = streamlines;
-
-        streamlines->setDataSet(ds,
-                                _useCumulativeRange, 
-                                _cumulativeScalarRange,
-                                _cumulativeVectorMagnitudeRange,
-                                _cumulativeVectorComponentRange);
-
-        _renderer->AddViewProp(streamlines->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Streamlines associated with a named DataSet
- */
-Streamlines *Renderer::getStreamlines(const DataSetId& id)
-{
-    StreamlinesHashmap::iterator itr = _streamlines.find(id);
-
-    if (itr == _streamlines.end()) {
-#ifdef DEBUG
-        TRACE("Streamlines not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setStreamlinesTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _streamlines.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setStreamlinesOrientation(const DataSetId& id, double quat[4])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _streamlines.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setStreamlinesOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _streamlines.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setStreamlinesPosition(const DataSetId& id, double pos[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _streamlines.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setStreamlinesScale(const DataSetId& id, double scale[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _streamlines.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the streamlines seed to points 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
- *
- * \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;
-
-    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->setSeedToFilledMesh(dataSet, numPoints);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Set the streamlines seed to points along a line
- */
-void Renderer::setStreamlinesSeedToRake(const DataSetId& id,
-                                        double start[3], double end[3],
-                                        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->setSeedToRake(start, end, numPoints);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the streamlines seed to points inside a disk, with optional
- * hole
- */
-void Renderer::setStreamlinesSeedToDisk(const DataSetId& id,
-                                        double center[3], double normal[3],
-                                        double radius, double innerRadius,
-                                        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->setSeedToDisk(center, normal, radius, innerRadius, numPoints);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the streamlines seed to vertices of an n-sided polygon
- */
-void Renderer::setStreamlinesSeedToPolygon(const DataSetId& id,
-                                           double center[3], double normal[3],
-                                           double angle, double radius,
-                                           int numSides)
-{
-    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->setSeedToPolygon(center, normal, angle, radius, numSides);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the streamlines seed to vertices of an n-sided polygon
- */
-void Renderer::setStreamlinesSeedToFilledPolygon(const DataSetId& id,
-                                                 double center[3],
-                                                 double normal[3],
-                                                 double angle, double radius,
-                                                 int numSides, 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->setSeedToFilledPolygon(center, normal, angle,
-                                            radius, numSides, numPoints);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Streamlines rendering to polylines for the specified DataSet
- */
-void Renderer::setStreamlinesTypeToLines(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->setLineTypeToLines();
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Streamlines rendering to tubes for the specified DataSet
- */
-void Renderer::setStreamlinesTypeToTubes(const DataSetId& id, int numSides, double radius)
-{
-    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->setLineTypeToTubes(numSides, radius);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Streamlines rendering to ribbons for the specified DataSet
- */
-void Renderer::setStreamlinesTypeToRibbons(const DataSetId& id, double width, double angle)
-{
-    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->setLineTypeToRibbons(width, angle);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Streamlines maximum length for the specified DataSet
- */
-void Renderer::setStreamlinesLength(const DataSetId& id, double length)
-{
-    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->setMaxPropagation(length);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Streamlines opacity scaling for the specified DataSet
- */
-void Renderer::setStreamlinesOpacity(const DataSetId& id, double opacity)
-{
-    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->setOpacity(opacity);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Streamlines mapper for the given DataSet
- */
-void Renderer::setStreamlinesVisibility(const DataSetId& id, bool state)
-{
-    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->setVisibility(state);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Streamlines seed geometry for the given DataSet
- */
-void Renderer::setStreamlinesSeedVisibility(const DataSetId& id, bool state)
-{
-    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->setSeedVisibility(state);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the color mode for the specified DataSet
- */
-void Renderer::setStreamlinesColorMode(const DataSetId& id, Streamlines::ColorMode mode)
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColorMode(mode);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a Streamlines for the given DataSet
- */
-void Renderer::setStreamlinesColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    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;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set Streamlines color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB line/edge color for the specified DataSet
- */
-void Renderer::setStreamlinesSeedColor(const DataSetId& id, float color[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setSeedColor(color);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the visibility of polygon edges for the specified DataSet
- */
-void Renderer::setStreamlinesEdgeVisibility(const DataSetId& id, bool state)
-{
-    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->setEdgeVisibility(state);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB color for the specified DataSet
- */
-void Renderer::setStreamlinesColor(const DataSetId& id, float color[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setColor(color);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the RGB line/edge color for the specified DataSet
- */
-void Renderer::setStreamlinesEdgeColor(const DataSetId& id, float color[3])
-{
-    StreamlinesHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _streamlines.begin();
-        doAll = true;
-    } else {
-        itr = _streamlines.find(id);
-    }
-    if (itr == _streamlines.end()) {
-        ERROR("Streamlines not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setEdgeColor(color);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the line/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::setStreamlinesEdgeWidth(const DataSetId& id, float edgeWidth)
-{
-    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->setEdgeWidth(edgeWidth);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn Streamlines lighting on/off for the specified DataSet
- */
-void Renderer::setStreamlinesLighting(const DataSetId& id, bool state)
-{
-    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->setLighting(state);
-    } while (doAll && ++itr != _streamlines.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Create a new Volume and associate it with the named DataSet
- */
-bool Renderer::addVolume(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 (getVolume(dsID)) {
-            WARN("Replacing existing Volume %s", dsID.c_str());
-            deleteVolume(dsID);
-        }
-
-        Volume *volume = new Volume();
-        _volumes[dsID] = volume;
-
-        volume->setDataSet(ds,
-                           _useCumulativeRange, 
-                           _cumulativeScalarRange,
-                           _cumulativeVectorMagnitudeRange,
-                           _cumulativeVectorComponentRange );
-
-        _renderer->AddViewProp(volume->getProp());
-    } while (doAll && ++itr != _dataSets.end());
-
-    initCamera();
-    _needsRedraw = true;
-    return true;
-}
-
-/**
- * \brief Get the Volume associated with a named DataSet
- */
-Volume *Renderer::getVolume(const DataSetId& id)
-{
-    VolumeHashmap::iterator itr = _volumes.find(id);
-
-    if (itr == _volumes.end()) {
-#ifdef DEBUG
-        TRACE("Volume not found: %s", id.c_str());
-#endif
-        return NULL;
-    } else
-        return itr->second;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setVolumeTransform(const DataSetId& id, vtkMatrix4x4 *trans)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setTransform(trans);
-    } while (doAll && ++itr != _volumes.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a quaternion
- */
-void Renderer::setVolumeOrientation(const DataSetId& id, double quat[4])
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(quat);
-    } while (doAll && ++itr != _volumes.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop orientation with a rotation about an axis
- */
-void Renderer::setVolumeOrientation(const DataSetId& id, double angle, double axis[3])
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOrientation(angle, axis);
-    } while (doAll && ++itr != _volumes.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop position in world coords
- */
-void Renderer::setVolumePosition(const DataSetId& id, double pos[3])
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setPosition(pos);
-    } while (doAll && ++itr != _volumes.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set the prop scaling
- */
-void Renderer::setVolumeScale(const DataSetId& id, double scale[3])
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setScale(scale);
-    } while (doAll && ++itr != _volumes.end());
-
-    resetAxes();
-    _needsRedraw = true;
-}
-
-/**
- * \brief Associate an existing named color map with a Volume for the given DataSet
- */
-void Renderer::setVolumeColorMap(const DataSetId& id, const ColorMapId& colorMapId)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    ColorMap *cmap = getColorMap(colorMapId);
-    if (cmap == NULL) {
-        ERROR("Unknown colormap: %s", colorMapId.c_str());
-        return;
-    }
-
-    do {
-        TRACE("Set Volume color map: %s for dataset %s", colorMapId.c_str(),
-              itr->second->getDataSet()->getName().c_str());
-
-        itr->second->setColorMap(cmap);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set Volume opacity scaling for the specified DataSet
- */
-void Renderer::setVolumeOpacity(const DataSetId& id, double opacity)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setOpacity(opacity);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn on/off rendering of the Volume mapper for the given DataSet
- */
-void Renderer::setVolumeVisibility(const DataSetId& id, bool state)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setVisibility(state);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set volume ambient lighting/shading coefficient for the specified DataSet
- */
-void Renderer::setVolumeAmbient(const DataSetId& id, double coeff)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setAmbient(coeff);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set volume diffuse lighting/shading coefficient for the specified DataSet
- */
-void Renderer::setVolumeDiffuse(const DataSetId& id, double coeff)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setDiffuse(coeff);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Set volume specular lighting/shading coefficient and power for the specified DataSet
- */
-void Renderer::setVolumeSpecular(const DataSetId& id, double coeff, double power)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setSpecular(coeff, power);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
-}
-
-/**
- * \brief Turn volume lighting/shading on/off for the specified DataSet
- */
-void Renderer::setVolumeLighting(const DataSetId& id, bool state)
-{
-    VolumeHashmap::iterator itr;
-
-    bool doAll = false;
-
-    if (id.compare("all") == 0) {
-        itr = _volumes.begin();
-        doAll = true;
-    } else {
-        itr = _volumes.find(id);
-    }
-    if (itr == _volumes.end()) {
-        ERROR("Volume not found: %s", id.c_str());
-        return;
-    }
-
-    do {
-        itr->second->setLighting(state);
-    } while (doAll && ++itr != _volumes.end());
-
-    _needsRedraw = true;
 }
 
@@ -7853 +1616 @@
     camera->SetFocalPoint(fp);
     camera->SetViewUp(vu);
-}
-
-inline void quaternionToMatrix4x4(const double quat[4], vtkMatrix4x4& mat)
-{
-    double ww = quat[0]*quat[0];
-    double wx = quat[0]*quat[1];
-    double wy = quat[0]*quat[2];
-    double wz = quat[0]*quat[3];
-
-    double xx = quat[1]*quat[1];
-    double yy = quat[2]*quat[2];
-    double zz = quat[3]*quat[3];
-
-    double xy = quat[1]*quat[2];
-    double xz = quat[1]*quat[3];
-    double yz = quat[2]*quat[3];
-
-    double rr = xx + yy + zz;
-    // normalization factor, just in case quaternion was not normalized
-    double f = double(1)/double(sqrt(ww + rr));
-    double s = (ww - rr)*f;
-    f *= 2;
-
-    mat[0][0] = xx*f + s;
-    mat[1][0] = (xy + wz)*f;
-    mat[2][0] = (xz - wy)*f;
-
-    mat[0][1] = (xy - wz)*f;
-    mat[1][1] = yy*f + s;
-    mat[2][1] = (yz + wx)*f;
-
-    mat[0][2] = (xz + wy)*f;
-    mat[1][2] = (yz - wx)*f;
-    mat[2][2] = zz*f + s;
-}
-
-inline void quaternionToTransposeMatrix4x4(const double quat[4], vtkMatrix4x4& mat)
-{
-    double ww = quat[0]*quat[0];
-    double wx = quat[0]*quat[1];
-    double wy = quat[0]*quat[2];
-    double wz = quat[0]*quat[3];
-
-    double xx = quat[1]*quat[1];
-    double yy = quat[2]*quat[2];
-    double zz = quat[3]*quat[3];
-
-    double xy = quat[1]*quat[2];
-    double xz = quat[1]*quat[3];
-    double yz = quat[2]*quat[3];
-
-    double rr = xx + yy + zz;
-    // normalization factor, just in case quaternion was not normalized
-    double f = double(1)/double(sqrt(ww + rr));
-    double s = (ww - rr)*f;
-    f *= 2;
-
-    mat[0][0] = xx*f + s;
-    mat[0][1] = (xy + wz)*f;
-    mat[0][2] = (xz - wy)*f;
-
-    mat[1][0] = (xy - wz)*f;
-    mat[1][1] = yy*f + s;
-    mat[1][2] = (yz + wx)*f;
-
-    mat[2][0] = (xz + wy)*f;
-    mat[2][1] = (yz - wx)*f;
-    mat[2][2] = zz*f + s;
-}
-
-inline double *quatMult(const double q1[4], const double q2[4], double result[4])
-{
-    double q1w = q1[0];
-    double q1x = q1[1];
-    double q1y = q1[2];
-    double q1z = q1[3];
-    double q2w = q2[0];
-    double q2x = q2[1];
-    double q2y = q2[2];
-    double q2z = q2[3];
-    result[0] = (q1w*q2w) - (q1x*q2x) - (q1y*q2y) - (q1z*q2z);
-    result[1] = (q1w*q2x) + (q1x*q2w) + (q1y*q2z) - (q1z*q2y);
-    result[2] = (q1w*q2y) + (q1y*q2w) + (q1z*q2x) - (q1x*q2z);
-    result[3] = (q1w*q2z) + (q1z*q2w) + (q1x*q2y) - (q1y*q2x);
-    return result;
-}
-
-inline double *quatConjugate(const double quat[4], double result[4])
-{
-    result[1] = -quat[1];
-    result[2] = -quat[2];
-    result[3] = -quat[3];
-    return result;
-}
-
-inline double *quatReciprocal(const double quat[4], double result[4])
-{
-    double denom = 
-        quat[0]*quat[0] + 
-        quat[1]*quat[1] + 
-        quat[2]*quat[2] + 
-        quat[3]*quat[3];
-    quatConjugate(quat, result);
-    for (int i = 0; i < 4; i++) {
-        result[i] /= denom;
-    }
-    return result;
-}
-
-inline double *quatReciprocal(double quat[4])
-{
-    return quatReciprocal(quat, quat);
-}
-
-inline void copyQuat(const double quat[4], double result[4])
-{
-    memcpy(result, quat, sizeof(double)*4);
 }
 
@@ -8710 +2356 @@
  * \brief Update data ranges for color-mapping and contours
  */
-void Renderer::updateRanges()
+void Renderer::updateFieldRanges()
 {
     collectDataRanges();
@@ -8716 +2362 @@
     for (Contour2DHashmap::iterator itr = _contour2Ds.begin();
          itr != _contour2Ds.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (Contour3DHashmap::iterator itr = _contour3Ds.begin();
          itr != _contour3Ds.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (CutplaneHashmap::iterator itr = _cutplanes.begin();
          itr != _cutplanes.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (GlyphsHashmap::iterator itr = _glyphs.begin();
          itr != _glyphs.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (HeightMapHashmap::iterator itr = _heightMaps.begin();
          itr != _heightMaps.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (LICHashmap::iterator itr = _lics.begin();
          itr != _lics.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (MoleculeHashmap::iterator itr = _molecules.begin();
          itr != _molecules.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (PseudoColorHashmap::iterator itr = _pseudoColors.begin();
          itr != _pseudoColors.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (StreamlinesHashmap::iterator itr = _streamlines.begin();
          itr != _streamlines.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
+        itr->second->updateRanges(this);
     }
     for (VolumeHashmap::iterator itr = _volumes.begin();
          itr != _volumes.end(); ++itr) {
-        itr->second->updateRanges(_useCumulativeRange, 
-                                  _cumulativeScalarRange,
-                                  _cumulativeVectorMagnitudeRange,
-                                  _cumulativeVectorComponentRange);
-    }
-}
-
-void Renderer::collectDataRanges()
-{
-    collectScalarRanges(_cumulativeScalarRange,
-                        _cumulativeRangeOnlyVisible);
-    collectVectorMagnitudeRanges(_cumulativeVectorMagnitudeRange,
-                                 _cumulativeRangeOnlyVisible);
-    for (int i = 0; i < 3; i++) {
-        collectVectorComponentRanges(_cumulativeVectorComponentRange[i], i,
-                                     _cumulativeRangeOnlyVisible);
-    }
-
-    TRACE("Cumulative scalar range: %g, %g",
-          _cumulativeScalarRange[0],
-          _cumulativeScalarRange[1]);
-    TRACE("Cumulative vmag range: %g, %g",
-          _cumulativeVectorMagnitudeRange[0],
-          _cumulativeVectorMagnitudeRange[1]);
-    for (int i = 0; i < 3; i++) {
-        TRACE("Cumulative v[%d] range: %g, %g", i,
-              _cumulativeVectorComponentRange[i][0],
-              _cumulativeVectorComponentRange[i][1]);
+        itr->second->updateRanges(this);
     }
 }
@@ -8813 +2405 @@
  * \brief Collect cumulative data range of all DataSets
  *
- * \param[in,out] range Data range of all DataSets
+ * \param[out] range Data range of all DataSets
+ * \param[in] name Field name
+ * \param[in] type Attribute type: e.g. POINT_DATA, CELL_DATA
+ * \param[in] component Array component or -1 for magnitude
  * \param[in] onlyVisible Only collect range of visible DataSets
  */
-void Renderer::collectScalarRanges(double *range, bool onlyVisible)
+void Renderer::collectDataRanges(double *range, const char *name,
+                                 DataSet::DataAttributeType type,
+                                 int component, bool onlyVisible)
 {
     range[0] = DBL_MAX;
@@ -8825 +2422 @@
         if (!onlyVisible || itr->second->getVisibility()) {
             double r[2];
-            itr->second->getScalarRange(r);
+            itr->second->getDataRange(r, name, type, component);
             range[0] = min2(range[0], r[0]);
             range[1] = max2(range[1], r[1]);
@@ -8834 +2431 @@
     if (range[1] == -DBL_MAX)
         range[1] = 1;
-}
-
-/**
- * \brief Collect cumulative data range of all DataSets
- *
- * \param[in,out] range Data range of all DataSets
- * \param[in] onlyVisible Only collect range of visible DataSets
- */
-void Renderer::collectVectorMagnitudeRanges(double *range, bool onlyVisible)
-{
-    range[0] = DBL_MAX;
-    range[1] = -DBL_MAX;
+    
+    TRACE("n:'%s' t:%d c:%d [%g,%g]", name, type, component,
+          range[0], range[1]);
+}
+
+/**
+ * \brief Clear field range hashtables and free memory
+ */
+void Renderer::clearFieldRanges()
+{
+    TRACE("Deleting Field Ranges");
+    for (FieldRangeHashmap::iterator itr = _scalarPointDataRange.begin();
+         itr != _scalarPointDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _scalarPointDataRange.clear();
+    for (FieldRangeHashmap::iterator itr = _scalarCellDataRange.begin();
+         itr != _scalarCellDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _scalarCellDataRange.clear();
+    for (FieldRangeHashmap::iterator itr = _vectorPointDataRange.begin();
+         itr != _vectorPointDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _vectorPointDataRange.clear();
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompPointDataRange[i].begin();
+             itr != _vectorCompPointDataRange[i].end(); ++itr) {
+            delete [] itr->second;
+        }
+        _vectorCompPointDataRange[i].clear();
+    }
+    for (FieldRangeHashmap::iterator itr = _vectorCellDataRange.begin();
+         itr != _vectorCellDataRange.end(); ++itr) {
+        delete [] itr->second;
+    }
+    _vectorCellDataRange.clear();
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompCellDataRange[i].begin();
+             itr != _vectorCompCellDataRange[i].end(); ++itr) {
+            delete [] itr->second;
+        }
+        _vectorCompCellDataRange[i].clear();
+    }
+}
+
+void Renderer::initFieldRanges()
+{
+    clearFieldRanges();
 
     for (DataSetHashmap::iterator itr = _dataSets.begin();
          itr != _dataSets.end(); ++itr) {
-        if (!onlyVisible || itr->second->getVisibility()) {
-            double r[2];
-            itr->second->getVectorRange(r);
-            range[0] = min2(range[0], r[0]);
-            range[1] = max2(range[1], r[1]);
-        }
-    }
-    if (range[0] == DBL_MAX)
-        range[0] = 0;
-    if (range[1] == -DBL_MAX)
-        range[1] = 1;
-}
-
-/**
- * \brief Collect cumulative data range of all DataSets
- *
- * \param[in,out] range Data range of all DataSets
- * \param[in] onlyVisible Only collect range of visible DataSets
- */
-void Renderer::collectVectorComponentRanges(double *range, int component, bool onlyVisible)
-{
-    range[0] = DBL_MAX;
-    range[1] = -DBL_MAX;
-
-    for (DataSetHashmap::iterator itr = _dataSets.begin();
-         itr != _dataSets.end(); ++itr) {
-        if (!onlyVisible || itr->second->getVisibility()) {
-            double r[2];
-            itr->second->getVectorRange(r, component);
-            range[0] = min2(range[0], r[0]);
-            range[1] = max2(range[1], r[1]);
-        }
-    }
-    if (range[0] == DBL_MAX)
-        range[0] = 0;
-    if (range[1] == -DBL_MAX)
-        range[1] = 1;
- }
+        DataSet *ds = itr->second;
+        std::vector<std::string> names;
+        ds->getFieldNames(names, DataSet::POINT_DATA, 1);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _scalarPointDataRange.find(*itr);
+            if (fritr == _scalarPointDataRange.end()) {
+                _scalarPointDataRange[*itr] = new double[2];
+                _scalarPointDataRange[*itr][0] = 0;
+                _scalarPointDataRange[*itr][1] = 1;
+            }
+        }
+        names.clear();
+        ds->getFieldNames(names, DataSet::CELL_DATA, 1);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _scalarCellDataRange.find(*itr);
+            if (fritr == _scalarCellDataRange.end()) {
+                _scalarCellDataRange[*itr] = new double[2];
+                _scalarCellDataRange[*itr][0] = 0;
+                _scalarCellDataRange[*itr][1] = 1;
+            }
+        }
+        names.clear();
+        ds->getFieldNames(names, DataSet::POINT_DATA, 3);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _vectorPointDataRange.find(*itr);
+            if (fritr == _vectorPointDataRange.end()) {
+                _vectorPointDataRange[*itr] = new double[2];
+                _vectorPointDataRange[*itr][0] = 0;
+                _vectorPointDataRange[*itr][1] = 1;
+            }
+            for (int i = 0; i < 3; i++) {
+                fritr = _vectorCompPointDataRange[i].find(*itr);
+                if (fritr == _vectorCompPointDataRange[i].end()) {
+                    _vectorCompPointDataRange[i][*itr] = new double[2];
+                    _vectorCompPointDataRange[i][*itr][0] = 0;
+                    _vectorCompPointDataRange[i][*itr][1] = 1;
+                }
+            }
+        }
+        names.clear();
+        ds->getFieldNames(names, DataSet::CELL_DATA, 3);
+        for (std::vector<std::string>::iterator itr = names.begin();
+             itr != names.end(); ++itr) {
+            FieldRangeHashmap::iterator fritr = 
+                _vectorCellDataRange.find(*itr);
+            if (fritr == _vectorCellDataRange.end()) {
+                _vectorCellDataRange[*itr] = new double[2];
+                _vectorCellDataRange[*itr][0] = 0;
+                _vectorCellDataRange[*itr][1] = 1;
+            }
+            for (int i = 0; i < 3; i++) {
+                fritr = _vectorCompCellDataRange[i].find(*itr);
+                if (fritr == _vectorCompCellDataRange[i].end()) {
+                    _vectorCompCellDataRange[i][*itr] = new double[2];
+                    _vectorCompCellDataRange[i][*itr][0] = 0;
+                    _vectorCompCellDataRange[i][*itr][1] = 1;
+                }
+            }
+        }
+    }
+}
+
+/**
+ * \brief Returns boolean flag indicating if cumulative data ranges 
+ * should be used
+ */
+bool Renderer::getUseCumulativeRange()
+{
+    return _useCumulativeRange;
+}
+
+/**
+ * \brief Get the cumulative range across all DataSets for a point
+ * data field if it exists, otherwise a cell data field if it exists
+ *
+ * \param[out] range Pointer to an array of 2 doubles
+ * \param[in] name Field name
+ * \param[in] numComponents Number of components in field
+ * \param[in] component Index of component or -1 for magnitude/scalar
+ * \return boolean indicating if field was found
+ */
+bool Renderer::getCumulativeDataRange(double *range, const char *name,
+                                      int numComponents,
+                                      int component)
+{
+    bool ret;
+    if (!(ret = getCumulativeDataRange(range, name, DataSet::POINT_DATA,
+                                       numComponents, component)))
+        ret = getCumulativeDataRange(range, name, DataSet::CELL_DATA,
+                                     numComponents, component);
+    return ret;
+}
+
+/**
+ * \brief Get the cumulative range across all DataSets for a field
+ *
+ * \param[out] range Pointer to an array of 2 doubles
+ * \param[in] name Field name
+ * \param[in] type DataAttributeType of field
+ * \param[in] numComponents Number of components in field
+ * \param[in] component Index of component or -1 for magnitude/scalar
+ * \return boolean indicating if field was found
+ */
+bool Renderer::getCumulativeDataRange(double *range, const char *name,
+                                      DataSet::DataAttributeType type,
+                                      int numComponents,
+                                      int component)
+{
+    if (name == NULL)
+        return false;
+    switch (type) {
+    case DataSet::POINT_DATA: {
+        FieldRangeHashmap::iterator itr;
+        if (numComponents == 1) {
+            itr = _scalarPointDataRange.find(name);
+            if (itr == _scalarPointDataRange.end()) {
+                return false;
+            } else {
+                memcpy(range, itr->second, sizeof(double)*2);
+                return true;
+            }
+        } else if (numComponents == 3) {
+            if (component == -1) {
+                itr = _vectorPointDataRange.find(name);
+                if (itr == _vectorPointDataRange.end()) {
+                    return false;
+                } else {
+                    memcpy(range, itr->second, sizeof(double)*2);
+                    return true;
+                }
+            } else if (component >= 0 && component <= 3) {
+                itr = _vectorCompPointDataRange[component].find(name);
+                if (itr == _vectorCompPointDataRange[component].end()) {
+                    return false;
+                } else {
+                    memcpy(range, itr->second, sizeof(double)*2);
+                    return true;
+                }
+            }
+        }
+    }
+        break;
+    case DataSet::CELL_DATA: {
+        FieldRangeHashmap::iterator itr;
+        if (numComponents == 1) {
+            itr = _scalarCellDataRange.find(name);
+            if (itr == _scalarCellDataRange.end()) {
+                return false;
+            } else {
+                memcpy(range, itr->second, sizeof(double)*2);
+                return true;
+            }
+        } else if (numComponents == 3) {
+            if (component == -1) {
+                itr = _vectorCellDataRange.find(name);
+                if (itr == _vectorCellDataRange.end()) {
+                    return false;
+                } else {
+                    memcpy(range, itr->second, sizeof(double)*2);
+                    return true;
+                }
+            } else if (component >= 0 && component <= 3) {
+                itr = _vectorCompCellDataRange[component].find(name);
+                if (itr == _vectorCompCellDataRange[component].end()) {
+                    return false;
+                } else {
+                    memcpy(range, itr->second, sizeof(double)*2);
+                    return true;
+                }
+            }
+        }
+    }
+        break;
+    default:
+        break;
+    }
+    return false;
+}
+
+void Renderer::collectDataRanges()
+{
+    for (FieldRangeHashmap::iterator itr = _scalarPointDataRange.begin();
+         itr != _scalarPointDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::POINT_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (FieldRangeHashmap::iterator itr = _scalarCellDataRange.begin();
+         itr != _scalarCellDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::CELL_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (FieldRangeHashmap::iterator itr = _vectorPointDataRange.begin();
+         itr != _vectorPointDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::POINT_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompPointDataRange[i].begin();
+             itr != _vectorCompPointDataRange[i].end(); ++itr) {
+            collectDataRanges(itr->second, itr->first.c_str(),
+                              DataSet::POINT_DATA, i,
+                              _cumulativeRangeOnlyVisible);
+        }
+    }
+    for (FieldRangeHashmap::iterator itr = _vectorCellDataRange.begin();
+         itr != _vectorCellDataRange.end(); ++itr) {
+        collectDataRanges(itr->second, itr->first.c_str(),
+                          DataSet::CELL_DATA, -1,
+                          _cumulativeRangeOnlyVisible);
+    }
+    for (int i = 0; i < 3; i++) {
+        for (FieldRangeHashmap::iterator itr = _vectorCompCellDataRange[i].begin();
+             itr != _vectorCompCellDataRange[i].end(); ++itr) {
+            collectDataRanges(itr->second, itr->first.c_str(),
+                              DataSet::CELL_DATA, i,
+                              _cumulativeRangeOnlyVisible);
+        }
+    }
+}
 
 /**
@@ -8893 +2718 @@
  */
 bool Renderer::is2D(const double bounds[6],
-                    Renderer::PrincipalPlane *plane,
+                    PrincipalPlane *plane,
                     double *offset) const
 {
@@ -9061 +2886 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (id.compare("all") == 0 || getContour2D(id) != NULL)
-        setContour2DOpacity(id, opacity);
-    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);
-    if (id.compare("all") == 0 || getHeightMap(id) != NULL)
-        setHeightMapOpacity(id, opacity);
-    if (id.compare("all") == 0 || getLIC(id) != NULL)
-        setLICOpacity(id, opacity);
-    if (id.compare("all") == 0 || getMolecule(id) != NULL)
-        setMoleculeOpacity(id, opacity);
-    if (id.compare("all") == 0 || getPolyData(id) != NULL)
-        setPolyDataOpacity(id, opacity);
-    if (id.compare("all") == 0 || getPseudoColor(id) != NULL)
-        setPseudoColorOpacity(id, opacity);
-    if (id.compare("all") == 0 || getStreamlines(id) != NULL)
-        setStreamlinesOpacity(id, opacity);
-    if (id.compare("all") == 0 || getVolume(id) != NULL)
-        setVolumeOpacity(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Contour2D>(id) != NULL)
+        setGraphicsObjectOpacity<Contour2D>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Contour3D>(id) != NULL)
+        setGraphicsObjectOpacity<Contour3D>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Cutplane>(id) != NULL)
+        setGraphicsObjectOpacity<Cutplane>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Glyphs>(id) != NULL)
+        setGraphicsObjectOpacity<Glyphs>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
+        setGraphicsObjectOpacity<HeightMap>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
+        setGraphicsObjectOpacity<LIC>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Molecule>(id) != NULL)
+        setGraphicsObjectOpacity<Molecule>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<PolyData>(id) != NULL)
+        setGraphicsObjectOpacity<PolyData>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<PseudoColor>(id) != NULL)
+        setGraphicsObjectOpacity<PseudoColor>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Streamlines>(id) != NULL)
+        setGraphicsObjectOpacity<Streamlines>(id, opacity);
+    if (id.compare("all") == 0 || getGraphicsObject<Volume>(id) != NULL)
+        setGraphicsObjectOpacity<Volume>(id, opacity);
 
     _needsRedraw = true;
@@ -9111 +2936 @@
     } while (doAll && ++itr != _dataSets.end());
 
-    if (id.compare("all") == 0 || getContour2D(id) != NULL)
-        setContour2DVisibility(id, state);
-    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);
-    if (id.compare("all") == 0 || getHeightMap(id) != NULL)
-        setHeightMapVisibility(id, state);
-    if (id.compare("all") == 0 || getLIC(id) != NULL)
-        setLICVisibility(id, state);
-    if (id.compare("all") == 0 || getMolecule(id) != NULL)
-        setMoleculeVisibility(id, state);
-    if (id.compare("all") == 0 || getPolyData(id) != NULL)
-        setPolyDataVisibility(id, state);
-    if (id.compare("all") == 0 || getPseudoColor(id) != NULL)
-        setPseudoColorVisibility(id, state);
-    if (id.compare("all") == 0 || getStreamlines(id) != NULL)
-        setStreamlinesVisibility(id, state);
-    if (id.compare("all") == 0 || getVolume(id) != NULL)
-        setVolumeVisibility(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Contour2D>(id) != NULL)
+        setGraphicsObjectVisibility<Contour2D>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Contour3D>(id) != NULL)
+        setGraphicsObjectVisibility<Contour3D>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Cutplane>(id) != NULL)
+        setGraphicsObjectVisibility<Cutplane>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Glyphs>(id) != NULL)
+        setGraphicsObjectVisibility<Glyphs>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<HeightMap>(id) != NULL)
+        setGraphicsObjectVisibility<HeightMap>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<LIC>(id) != NULL)
+        setGraphicsObjectVisibility<LIC>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Molecule>(id) != NULL)
+        setGraphicsObjectVisibility<Molecule>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<PolyData>(id) != NULL)
+        setGraphicsObjectVisibility<PolyData>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<PseudoColor>(id) != NULL)
+        setGraphicsObjectVisibility<PseudoColor>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Streamlines>(id) != NULL)
+        setGraphicsObjectVisibility<Streamlines>(id, state);
+    if (id.compare("all") == 0 || getGraphicsObject<Volume>(id) != NULL)
+        setGraphicsObjectVisibility<Volume>(id, state);
 
     _needsRedraw = true;

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

@@ -8 +8 @@
 #ifndef __RAPPTURE_VTKVIS_RENDERER_H__
 #define __RAPPTURE_VTKVIS_RENDERER_H__
+
+#include <string>
+#include <vector>
+#include <tr1/unordered_map>
+#include <typeinfo>
 
 #include <vtkSmartPointer.h>
@@ -21 +26 @@
 #include <vtkUnsignedCharArray.h>
 
-#include <string>
-#include <vector>
-#include <tr1/unordered_map>
-
 #include "ColorMap.h"
+#include "RpTypes.h"
 #include "RpVtkDataSet.h"
 #include "RpContour2D.h"
@@ -56 +58 @@
     virtual ~Renderer();
 
-    enum Axis {
-        X_AXIS,
-        Y_AXIS,
-        Z_AXIS
-    };
-
-    enum PrincipalPlane {
-        PLANE_XY,
-        PLANE_ZY,
-        PLANE_XZ
-    };
-
     enum AxesFlyMode {
         FLY_OUTER_EDGES = 0,
@@ -89 +79 @@
 
     enum LegendType {
-        ACTIVE_SCALAR,
-        ACTIVE_VECTOR_MAGNITUDE,
-        ACTIVE_VECTOR_X,
-        ACTIVE_VECTOR_Y,
-        ACTIVE_VECTOR_Z
+        LEGEND_SCALAR,
+        LEGEND_VECTOR_MAGNITUDE,
+        LEGEND_VECTOR_X,
+        LEGEND_VECTOR_Y,
+        LEGEND_VECTOR_Z
     };
 
     typedef std::string DataSetId;
     typedef std::string ColorMapId;
+    typedef std::string FieldId;
     typedef std::tr1::unordered_map<DataSetId, DataSet *> DataSetHashmap;
+    typedef std::tr1::unordered_map<FieldId, double *> FieldRangeHashmap;
     typedef std::tr1::unordered_map<ColorMapId, ColorMap *> ColorMapHashmap;
     typedef std::tr1::unordered_map<DataSetId, Contour2D *> Contour2DHashmap;
@@ -148 +140 @@
     void setUseCumulativeDataRange(bool state, bool onlyVisible = false);
 
+    bool getUseCumulativeRange();
+
+    bool getCumulativeDataRange(double *range, const char *name,
+                                int numComponents,
+                                int component = -1);
+
+    bool getCumulativeDataRange(double *range, const char *name,
+                                DataSet::DataAttributeType type,
+                                int numComponents,
+                                int component = -1);
+
     // Render window
 
@@ -257 +260 @@
 
     ColorMap *getColorMap(const ColorMapId& id);
+
+    bool renderColorMap(const ColorMapId& id, 
+                        const DataSetId& dataSetID,
+                        LegendType legendType,
+                        const char *fieldName,
+                        DataSet::DataAttributeType type,
+                        std::string& title,
+                        double range[2],
+                        int width, int height,
+                        int numLabels,
+                        vtkUnsignedCharArray *imgData);
+
+    bool renderColorMap(const ColorMapId& id, 
+                        const DataSetId& dataSetID,
+                        LegendType legendType,
+                        const char *fieldName,
+                        std::string& title,
+                        double range[2],
+                        int width, int height,
+                        int numLabels,
+                        vtkUnsignedCharArray *imgData);
 
     bool renderColorMap(const ColorMapId& id, 
@@ -267 +291 @@
                         vtkUnsignedCharArray *imgData);
 
+    // Generic VtkGraphicsObject methods
+
+    template<class GraphicsObject>
+    GraphicsObject *getGraphicsObject(const DataSetId& id);
+
+    template<class GraphicsObject>
+    bool addGraphicsObject(const DataSetId& id);
+
+    template<class GraphicsObject>
+    void deleteGraphicsObject(const DataSetId& id);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectVolumeSlice(const DataSetId& id, Axis axis, double ratio);
+
+    //   Prop/Prop3D properties
+
+    template<class GraphicsObject>
+    void setGraphicsObjectOrientation(const DataSetId& id, double quat[4]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectOrientation(const DataSetId& id, double angle, double axis[3]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectPosition(const DataSetId& id, double pos[3]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectScale(const DataSetId& id, double scale[3]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectTransform(const DataSetId& id, vtkMatrix4x4 *trans);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectVisibility(const DataSetId& id, bool state);
+
+    //   Actor properties
+
+    template<class GraphicsObject>
+    void setGraphicsObjectColor(const DataSetId& id, float color[3]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectEdgeVisibility(const DataSetId& id, bool state);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectEdgeColor(const DataSetId& id, float color[3]);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectEdgeWidth(const DataSetId& id, float edgeWidth);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectAmbient(const DataSetId& id, double coeff);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectDiffuse(const DataSetId& id, double coeff);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectSpecular(const DataSetId& id, double coeff, double power);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectLighting(const DataSetId& id, bool state);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectOpacity(const DataSetId& id, double opacity);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectPointSize(const DataSetId& id, float size);
+
+    template<class GraphicsObject>
+    void setGraphicsObjectWireframe(const DataSetId& id, bool state);
+
     // 2D Contour plots
 
@@ -273 +369 @@
     bool addContour2D(const DataSetId& id, const std::vector<double>& contours);
 
-    void deleteContour2D(const DataSetId& id);
-
-    Contour2D *getContour2D(const DataSetId& id);
-
-    void setContour2DTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setContour2DOrientation(const DataSetId& id, double quat[4]);
-
-    void setContour2DOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setContour2DPosition(const DataSetId& id, double pos[3]);
-
-    void setContour2DScale(const DataSetId& id, double scale[3]);
-
-    void setContour2DColor(const DataSetId& id, float color[3]);
-
-    void setContour2DEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setContour2DLighting(const DataSetId& id, bool state);
-    
-    void setContour2DOpacity(const DataSetId& id, double opacity);
-
-    void setContour2DVisibility(const DataSetId& id, bool state);
-
     void setContour2DContours(const DataSetId& id, int numContours);
 
@@ -307 +379 @@
     bool addContour3D(const DataSetId& id, const std::vector<double>& contours);
 
-    void deleteContour3D(const DataSetId& id);
-
-    Contour3D *getContour3D(const DataSetId& id);
-
-    void setContour3DTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setContour3DOrientation(const DataSetId& id, double quat[4]);
-
-    void setContour3DOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setContour3DPosition(const DataSetId& id, double pos[3]);
-
-    void setContour3DScale(const DataSetId& id, double scale[3]);
-
-    void setContour3DColor(const DataSetId& id, float color[3]);
-
-    void setContour3DEdgeVisibility(const DataSetId& id, bool state);
-
-    void setContour3DEdgeColor(const DataSetId& id, float color[3]);
-
-    void setContour3DEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setContour3DLighting(const DataSetId& id, bool state);
-
-    void setContour3DOpacity(const DataSetId& id, double opacity);
-
-    void setContour3DVisibility(const DataSetId& id, bool state);
-
-    void setContour3DWireframe(const DataSetId& id, bool state);
-
     void setContour3DContours(const DataSetId& id, int numContours);
 
     void setContour3DContourList(const DataSetId& id, const std::vector<double>& contours);
 
-    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);
+    void setCutplaneSliceVisibility(const DataSetId& id, Axis axis, bool state);
+
+    void setCutplaneColorMode(const DataSetId& id,
+                              Cutplane::ColorMode mode,
+                              const char *name, double range[2] = NULL);
+
+    void setCutplaneColorMode(const DataSetId& id,
+                              Cutplane::ColorMode mode,
+                              DataSet::DataAttributeType type,
+                              const char *name, double range[2] = NULL);
 
     // Glyphs
@@ -385 +400 @@
     bool addGlyphs(const DataSetId& id, Glyphs::GlyphShape shape);
 
-    void deleteGlyphs(const DataSetId& id);
-
-    Glyphs *getGlyphs(const DataSetId& id);
-
-    void setGlyphsTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setGlyphsOrientation(const DataSetId& id, double quat[4]);
-
-    void setGlyphsOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setGlyphsPosition(const DataSetId& id, double pos[3]);
-
-    void setGlyphsScale(const DataSetId& id, double scale[3]);
-
-    void setGlyphsColor(const DataSetId& id, float color[3]);
-
-    void setGlyphsEdgeVisibility(const DataSetId& id, bool state);
-
-    void setGlyphsEdgeColor(const DataSetId& id, float color[3]);
-
-    void setGlyphsEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setGlyphsLighting(const DataSetId& id, bool state);
-
-    void setGlyphsOpacity(const DataSetId& id, double opacity);
-
-    void setGlyphsVisibility(const DataSetId& id, bool state);
-
-    void setGlyphsWireframe(const DataSetId& id, bool state);
-
-    void setGlyphsColorMap(const DataSetId& id, const ColorMapId& colorMapId);
-
     void setGlyphsShape(const DataSetId& id, Glyphs::GlyphShape shape);
 
-    void setGlyphsColorMode(const DataSetId& id, Glyphs::ColorMode mode);
-
-    void setGlyphsScalingMode(const DataSetId& id, Glyphs::ScalingMode mode);
+    void setGlyphsColorMode(const DataSetId& id,
+                            Glyphs::ColorMode mode,
+                            const char *name,
+                            double range[2] = NULL);
+
+    void setGlyphsScalingMode(const DataSetId& id,
+                              Glyphs::ScalingMode mode,
+                              const char *name,
+                              double range[2] = NULL);
 
     void setGlyphsNormalizeScale(const DataSetId& id, bool normalize);
@@ -433 +422 @@
     bool addHeightMap(const DataSetId& id, const std::vector<double>& contours, double heightScale);
 
-    void deleteHeightMap(const DataSetId& id);
-
-    HeightMap *getHeightMap(const DataSetId& id);
-
-    void setHeightMapTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setHeightMapOrientation(const DataSetId& id, double quat[4]);
-
-    void setHeightMapOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setHeightMapPosition(const DataSetId& id, double pos[3]);
-
-    void setHeightMapScale(const DataSetId& id, double scale[3]);
-    
-    void setHeightMapEdgeVisibility(const DataSetId& id, bool state);
-
-    void setHeightMapEdgeColor(const DataSetId& id, float color[3]);
-
-    void setHeightMapEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setHeightMapLighting(const DataSetId& id, bool state);
-
-    void setHeightMapOpacity(const DataSetId& id, double opacity);
-
-    void setHeightMapVisibility(const DataSetId& id, bool state);
-
-    void setHeightMapWireframe(const DataSetId& id, bool state);
-
-    void setHeightMapVolumeSlice(const DataSetId& id, HeightMap::Axis axis, double ratio);
-
     void setHeightMapHeightScale(const DataSetId& id, double scale);
 
-    void setHeightMapColorMap(const DataSetId& id, const ColorMapId& colorMapId);
-
     void setHeightMapNumContours(const DataSetId& id, int numContours);
 
@@ -479 +436 @@
     void setHeightMapContourEdgeWidth(const DataSetId& id, float edgeWidth);
 
-    // LIC plots
-
-    bool addLIC(const DataSetId& id);
-    
-    void deleteLIC(const DataSetId& id);
-
-    LIC *getLIC(const DataSetId& id);
-
-    void setLICTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setLICOrientation(const DataSetId& id, double quat[4]);
-
-    void setLICOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setLICPosition(const DataSetId& id, double pos[3]);
-
-    void setLICScale(const DataSetId& id, double scale[3]);
-
-    void setLICEdgeVisibility(const DataSetId& id, bool state);
-    
-    void setLICEdgeColor(const DataSetId& id, float color[3]);
-
-    void setLICEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setLICLighting(const DataSetId& id, bool state);
-
-    void setLICOpacity(const DataSetId& id, double opacity);
-
-    void setLICVisibility(const DataSetId& id, bool state);
-
-    void setLICVolumeSlice(const DataSetId& id, LIC::Axis axis, double ratio);
-
-    void setLICColorMap(const DataSetId& id, const ColorMapId& colorMapId);
-
     // Molecules
 
-    bool addMolecule(const DataSetId& id);
-    
-    void deleteMolecule(const DataSetId& id);
-
-    Molecule *getMolecule(const DataSetId& id);
-
-    void setMoleculeTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setMoleculeOrientation(const DataSetId& id, double quat[4]);
-
-    void setMoleculeOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setMoleculePosition(const DataSetId& id, double pos[3]);
-
-    void setMoleculeScale(const DataSetId& id, double scale[3]);
-    
-    void setMoleculeEdgeVisibility(const DataSetId& id, bool state);
-
-    void setMoleculeEdgeColor(const DataSetId& id, float color[3]);
-
-    void setMoleculeEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setMoleculeLighting(const DataSetId& id, bool state);
-
-    void setMoleculeOpacity(const DataSetId& id, double opacity);
-
-    void setMoleculeVisibility(const DataSetId& id, bool state);
-
-    void setMoleculeWireframe(const DataSetId& id, bool state);
-
-    void setMoleculeColorMap(const DataSetId& id, const ColorMapId& colorMapId);
-
     void setMoleculeAtomScaling(const DataSetId& id, Molecule::AtomScaling scaling);
 
@@ -553 +444 @@
     void setMoleculeBondVisibility(const DataSetId& id, bool state);
 
-    // PolyData Meshes
-
-    bool addPolyData(const DataSetId& id);
-    
-    void deletePolyData(const DataSetId& id);
-
-    PolyData *getPolyData(const DataSetId& id);
-
-    void setPolyDataTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setPolyDataOrientation(const DataSetId& id, double quat[4]);
-
-    void setPolyDataOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setPolyDataPosition(const DataSetId& id, double pos[3]);
-
-    void setPolyDataScale(const DataSetId& id, double scale[3]);
-
-    void setPolyDataColor(const DataSetId& id, float color[3]);
-
-    void setPolyDataEdgeVisibility(const DataSetId& id, bool state);
-
-    void setPolyDataEdgeColor(const DataSetId& id, float color[3]);
-
-    void setPolyDataEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setPolyDataPointSize(const DataSetId& id, float size);
-
-    void setPolyDataLighting(const DataSetId& id, bool state);
-
-    void setPolyDataOpacity(const DataSetId& id, double opacity);
-
-    void setPolyDataVisibility(const DataSetId& id, bool state);
-
-    void setPolyDataWireframe(const DataSetId& id, bool state);
-
     // Color-mapped surfaces
 
-    bool addPseudoColor(const DataSetId& id);
-
-    void deletePseudoColor(const DataSetId& id);
-
-    PseudoColor *getPseudoColor(const DataSetId& id);
-
-    void setPseudoColorTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setPseudoColorOrientation(const DataSetId& id, double quat[4]);
-
-    void setPseudoColorOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setPseudoColorPosition(const DataSetId& id, double pos[3]);
-
-    void setPseudoColorScale(const DataSetId& id, double scale[3]);
-
-    void setPseudoColorColor(const DataSetId& id, float color[3]);
-
-    void setPseudoColorEdgeVisibility(const DataSetId& id, bool state);
-
-    void setPseudoColorEdgeColor(const DataSetId& id, float color[3]);
-
-    void setPseudoColorEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setPseudoColorLighting(const DataSetId& id, bool state);
-    
-    void setPseudoColorOpacity(const DataSetId& id, double opacity);
-
-    void setPseudoColorVisibility(const DataSetId& id, bool state);
-
-    void setPseudoColorWireframe(const DataSetId& id, bool state);
-
-    void setPseudoColorColorMap(const DataSetId& id, const ColorMapId& colorMapId);
-
-    void setPseudoColorColorMode(const DataSetId& id, PseudoColor::ColorMode mode);
+    void setPseudoColorColorMode(const DataSetId& id,
+                                 PseudoColor::ColorMode mode,
+                                 const char *name, double range[2] = NULL);
+
+    void setPseudoColorColorMode(const DataSetId& id,
+                                 PseudoColor::ColorMode mode,
+                                 DataSet::DataAttributeType type,
+                                 const char *name, double range[2] = NULL);
 
     // Streamlines
 
-    bool addStreamlines(const DataSetId& id);
-
-    void deleteStreamlines(const DataSetId& id);
-
-    Streamlines *getStreamlines(const DataSetId& id);
-
-    void setStreamlinesTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setStreamlinesOrientation(const DataSetId& id, double quat[4]);
-
-    void setStreamlinesOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setStreamlinesPosition(const DataSetId& id, double pos[3]);
-
-    void setStreamlinesScale(const DataSetId& id, double scale[3]);
-
-    void setStreamlinesColor(const DataSetId& id, float color[3]);
-
-    void setStreamlinesEdgeVisibility(const DataSetId& id, bool state);
-
-    void setStreamlinesEdgeColor(const DataSetId& id, float color[3]);
-
-    void setStreamlinesEdgeWidth(const DataSetId& id, float edgeWidth);
-
-    void setStreamlinesLighting(const DataSetId& id, bool state);
-
-    void setStreamlinesOpacity(const DataSetId& id, double opacity);
-
-    void setStreamlinesVisibility(const DataSetId& id, bool state);
+    void setStreamlinesNumberOfSeedPoints(const DataSetId& id, int numPoints);
 
     void setStreamlinesSeedToMeshPoints(const DataSetId& id);
@@ -699 +499 @@
     void setStreamlinesSeedVisibility(const DataSetId& id, bool state);
 
-    void setStreamlinesColorMode(const DataSetId& id, Streamlines::ColorMode mode);
-
-    void setStreamlinesColorMap(const DataSetId& id, const ColorMapId& colorMapId);
+    void setStreamlinesColorMode(const DataSetId& id,
+                                 Streamlines::ColorMode mode,
+                                 const char *name, double range[2] = NULL);
+
+    void setStreamlinesColorMode(const DataSetId& id,
+                                 Streamlines::ColorMode mode,
+                                 DataSet::DataAttributeType type,
+                                 const char *name, double range[2] = NULL);
 
     void setStreamlinesSeedColor(const DataSetId& id, float color[3]);
-
-    // Volumes
-
-    bool addVolume(const DataSetId& id);
-
-    void deleteVolume(const DataSetId& id);
-
-    Volume *getVolume(const DataSetId& id);
-
-    void setVolumeTransform(const DataSetId& id, vtkMatrix4x4 *trans);
-
-    void setVolumeOrientation(const DataSetId& id, double quat[4]);
-
-    void setVolumeOrientation(const DataSetId& id, double angle, double axis[3]);
-
-    void setVolumePosition(const DataSetId& id, double pos[3]);
-
-    void setVolumeScale(const DataSetId& id, double scale[3]);
-
-    void setVolumeAmbient(const DataSetId& id, double coeff);
-
-    void setVolumeDiffuse(const DataSetId& id, double coeff);
-
-    void setVolumeSpecular(const DataSetId& id, double coeff, double power);
-
-    void setVolumeLighting(const DataSetId& id, bool state);
-    
-    void setVolumeOpacity(const DataSetId& id, double opacity);
-
-    void setVolumeVisibility(const DataSetId& id, bool state);
-
-    void setVolumeColorMap(const DataSetId& id, const ColorMapId& colorMapId);
 
 private:
     static void printCameraInfo(vtkCamera *camera);
-    static inline double min2(double a, double b)
-    {
-        return ((a < b) ? a : b);
-    }
-    static inline double max2(double a, double b)
-    {
-        return ((a > b) ? a : b);
-    }
+
+    static void setCameraFromMatrix(vtkCamera *camera, vtkMatrix4x4 &mat);
+
     static void mergeBounds(double *boundsDest, const double *bounds1, const double *bounds2);
 
+    template<class GraphicsObject>
+    std::tr1::unordered_map<DataSetId, GraphicsObject *>&getGraphicsObjectHashmap();
+
     void collectBounds(double *bounds, bool onlyVisible);
 
     void collectDataRanges();
 
-    void collectScalarRanges(double *range, bool onlyVisible);
-
-    void collectVectorMagnitudeRanges(double *range, bool onlyVisible);
-
-    void collectVectorComponentRanges(double *range, int component, bool onlyVisible);
-
-    void updateRanges();
+    void collectDataRanges(double *range, const char *name,
+                           DataSet::DataAttributeType type,
+                           int component, bool onlyVisible);
+
+    void clearFieldRanges();
+
+    void initFieldRanges();
+
+    void updateFieldRanges();
 
     void updateColorMap(ColorMap *cmap);
 
     bool colorMapUsed(ColorMap *cmap);
-
-    void setCameraFromMatrix(vtkCamera *camera, vtkMatrix4x4 &mat);
 
     void computeDisplayToWorld(double x, double y, double z, double worldPt[4]);
@@ -794 +565 @@
     bool _useCumulativeRange;
     bool _cumulativeRangeOnlyVisible;
-    double _cumulativeScalarRange[2];
-    double _cumulativeVectorMagnitudeRange[2];
-    double _cumulativeVectorComponentRange[3][2];
+
+    FieldRangeHashmap _scalarPointDataRange;
+    FieldRangeHashmap _vectorPointDataRange;
+    FieldRangeHashmap _vectorCompPointDataRange[3];
+    FieldRangeHashmap _scalarCellDataRange;
+    FieldRangeHashmap _vectorCellDataRange;
+    FieldRangeHashmap _vectorCompCellDataRange[3];
 
     ColorMapHashmap _colorMaps;

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

@@ -9 +9 @@
 #include <cstdio>
 #include <cstring>
+#include <cfloat>
 #include <cerrno>
 #include <string>
 #include <sstream>
 #include <unistd.h>
+#include <sys/select.h>
 #include <sys/uio.h>
-#include <fcntl.h>
 #include <tcl.h>
 
 #include "Trace.h"
 #include "CmdProc.h"
+#include "ReadBuffer.h"
+#include "RpTypes.h"
 #include "RpVtkRendererCmd.h"
 #include "RpVtkRenderServer.h"
 #include "RpVtkRenderer.h"
+#include "RpVtkRendererGraphicsObjs.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
@@ -43 +67 @@
 }
 
-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
+#endif  /*USE_THREADS*/
+
+static bool
+SocketRead(char *bytes, size_t len)
+{
+    ReadBuffer::BufferStatus status;
+    status = g_inBufPtr->followingData((unsigned char *)bytes, len);
+    TRACE("followingData status: %d", status);
+    return (status == ReadBuffer::OK);
 }
 
@@ -68 +83 @@
     int result;
 
-    result = Tcl_Eval(interp, Tcl_DStringValue(dsPtr));
+    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);
     Tcl_DStringSetLength(dsPtr, 0);
-
+    if (lastCmdStatus == TCL_BREAK) {
+        return TCL_BREAK;
+    }
+    lastCmdStatus = result;
     return result;
 }
@@ -149 +171 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisGridVisibility(Renderer::X_AXIS, visible);
+        g_renderer->setAxisGridVisibility(X_AXIS, visible);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisGridVisibility(Renderer::Y_AXIS, visible);
+        g_renderer->setAxisGridVisibility(Y_AXIS, visible);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisGridVisibility(Renderer::Z_AXIS, visible);
+        g_renderer->setAxisGridVisibility(Z_AXIS, visible);
     } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
         g_renderer->setAxesGridVisibility(visible);
@@ -175 +197 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisLabelVisibility(Renderer::X_AXIS, visible);
+        g_renderer->setAxisLabelVisibility(X_AXIS, visible);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisLabelVisibility(Renderer::Y_AXIS, visible);
+        g_renderer->setAxisLabelVisibility(Y_AXIS, visible);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisLabelVisibility(Renderer::Z_AXIS, visible);
+        g_renderer->setAxisLabelVisibility(Z_AXIS, visible);
     } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
         g_renderer->setAxesLabelVisibility(visible);
@@ -203 +225 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisTitle(Renderer::X_AXIS, title);
+        g_renderer->setAxisTitle(X_AXIS, title);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisTitle(Renderer::Y_AXIS, title);
+        g_renderer->setAxisTitle(Y_AXIS, title);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisTitle(Renderer::Z_AXIS, title);
+        g_renderer->setAxisTitle(Z_AXIS, title);
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,
@@ -227 +249 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisTickVisibility(Renderer::X_AXIS, visible);
+        g_renderer->setAxisTickVisibility(X_AXIS, visible);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisTickVisibility(Renderer::Y_AXIS, visible);
+        g_renderer->setAxisTickVisibility(Y_AXIS, visible);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisTickVisibility(Renderer::Z_AXIS, visible);
+        g_renderer->setAxisTickVisibility(Z_AXIS, visible);
     } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
         g_renderer->setAxesTickVisibility(visible);
@@ -275 +297 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisUnits(Renderer::X_AXIS, units);
+        g_renderer->setAxisUnits(X_AXIS, units);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisUnits(Renderer::Y_AXIS, units);
+        g_renderer->setAxisUnits(Y_AXIS, units);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisUnits(Renderer::Z_AXIS, units);
+        g_renderer->setAxisUnits(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);
+        g_renderer->setAxisUnits(X_AXIS, units);
+        g_renderer->setAxisUnits(Y_AXIS, units);
+        g_renderer->setAxisUnits(Z_AXIS, units);
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,
@@ -303 +325 @@
     char c = string[0];
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        g_renderer->setAxisVisibility(Renderer::X_AXIS, visible);
+        g_renderer->setAxisVisibility(X_AXIS, visible);
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        g_renderer->setAxisVisibility(Renderer::Y_AXIS, visible);
+        g_renderer->setAxisVisibility(Y_AXIS, visible);
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        g_renderer->setAxisVisibility(Renderer::Z_AXIS, visible);
+        g_renderer->setAxisVisibility(Z_AXIS, visible);
     } else if ((c == 'a') && (strcmp(string, "all") == 0)) {
         g_renderer->setAxesVisibility(visible);
@@ -380 +402 @@
              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;
 }
@@ -751 +776 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteContour2D(name);
-    } else {
-        g_renderer->deleteContour2D("all");
+        g_renderer->deleteGraphicsObject<Contour2D>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Contour2D>("all");
     }
     return TCL_OK;
@@ -768 +793 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour2DLighting(name, state);
-    } else {
-        g_renderer->setContour2DLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Contour2D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Contour2D>("all", state);
     }
     return TCL_OK;
@@ -787 +812 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour2DColor(name, color);
-    } else {
-        g_renderer->setContour2DColor("all", color);
+        g_renderer->setGraphicsObjectColor<Contour2D>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Contour2D>("all", color);
     }
     return TCL_OK;
@@ -804 +829 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour2DEdgeWidth(name, width);
-    } else {
-        g_renderer->setContour2DEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Contour2D>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Contour2D>("all", width);
     }
     return TCL_OK;
@@ -821 +846 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour2DOpacity(name, opacity);
-    } else {
-        g_renderer->setContour2DOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Contour2D>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Contour2D>("all", opacity);
     }
     return TCL_OK;
@@ -841 +866 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setContour2DOrientation(name, quat);
-    } else {
-        g_renderer->setContour2DOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Contour2D>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Contour2D>("all", quat);
     }
     return TCL_OK;
@@ -860 +885 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour2DPosition(name, pos);
-    } else {
-        g_renderer->setContour2DPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Contour2D>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Contour2D>("all", pos);
     }
     return TCL_OK;
@@ -879 +904 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour2DScale(name, scale);
-    } else {
-        g_renderer->setContour2DScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Contour2D>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Contour2D>("all", scale);
     }
     return TCL_OK;
@@ -896 +921 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour2DVisibility(name, state);
-    } else {
-        g_renderer->setContour2DVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Contour2D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Contour2D>("all", state);
     }
     return TCL_OK;
@@ -1023 +1048 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour3DColor(name, color);
-    } else {
-        g_renderer->setContour3DColor("all", color);
+        g_renderer->setGraphicsObjectColor<Contour3D>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Contour3D>("all", color);
     }
     return TCL_OK;
@@ -1037 +1062 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setContour3DColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Contour3D>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Contour3D>("all", colorMapName);
     }
     return TCL_OK;
@@ -1050 +1075 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteContour3D(name);
-    } else {
-        g_renderer->deleteContour3D("all");
+        g_renderer->deleteGraphicsObject<Contour3D>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Contour3D>("all");
     }
     return TCL_OK;
@@ -1067 +1092 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DEdgeVisibility(name, state);
-    } else {
-        g_renderer->setContour3DEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<Contour3D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Contour3D>("all", state);
     }
     return TCL_OK;
@@ -1084 +1109 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DLighting(name, state);
-    } else {
-        g_renderer->setContour3DLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Contour3D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Contour3D>("all", state);
     }
     return TCL_OK;
@@ -1103 +1128 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour3DEdgeColor(name, color);
-    } else {
-        g_renderer->setContour3DEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<Contour3D>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Contour3D>("all", color);
     }
     return TCL_OK;
@@ -1120 +1145 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DEdgeWidth(name, width);
-    } else {
-        g_renderer->setContour3DEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Contour3D>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Contour3D>("all", width);
     }
     return TCL_OK;
@@ -1137 +1162 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DOpacity(name, opacity);
-    } else {
-        g_renderer->setContour3DOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Contour3D>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Contour3D>("all", opacity);
     }
     return TCL_OK;
@@ -1157 +1182 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setContour3DOrientation(name, quat);
-    } else {
-        g_renderer->setContour3DOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Contour3D>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Contour3D>("all", quat);
     }
     return TCL_OK;
@@ -1176 +1201 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour3DPosition(name, pos);
-    } else {
-        g_renderer->setContour3DPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Contour3D>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Contour3D>("all", pos);
     }
     return TCL_OK;
@@ -1195 +1220 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setContour3DScale(name, scale);
-    } else {
-        g_renderer->setContour3DScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Contour3D>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Contour3D>("all", scale);
     }
     return TCL_OK;
@@ -1212 +1237 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DVisibility(name, state);
-    } else {
-        g_renderer->setContour3DVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Contour3D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Contour3D>("all", state);
     }
     return TCL_OK;
@@ -1229 +1254 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setContour3DWireframe(name, state);
-    } else {
-        g_renderer->setContour3DWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<Contour3D>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<Contour3D>("all", state);
     }
     return TCL_OK;
@@ -1274 +1299 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addCutplane(name)) {
+        if (!g_renderer->addGraphicsObject<Cutplane>(name)) {
             Tcl_AppendResult(interp, "Failed to create cutplane", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addCutplane("all")) {
+        if (!g_renderer->addGraphicsObject<Cutplane>("all")) {
             Tcl_AppendResult(interp, "Failed to create cutplane for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -1294 +1319 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setCutplaneColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Cutplane>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Cutplane>("all", colorMapName);
     }
     return TCL_OK;
@@ -1322 +1347 @@
         return TCL_ERROR;
     }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneColorMode(name, mode);
-    } else {
-        g_renderer->setCutplaneColorMode("all", mode);
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setCutplaneColorMode(name, mode, fieldName);
+    } else {
+        g_renderer->setCutplaneColorMode("all", mode, fieldName);
     }
     return TCL_OK;
@@ -1337 +1363 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteCutplane(name);
-    } else {
-        g_renderer->deleteCutplane("all");
+        g_renderer->deleteGraphicsObject<Cutplane>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Cutplane>("all");
     }
     return TCL_OK;
@@ -1354 +1380 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneEdgeVisibility(name, state);
-    } else {
-        g_renderer->setCutplaneEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<Cutplane>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Cutplane>("all", state);
     }
     return TCL_OK;
@@ -1371 +1397 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneLighting(name, state);
-    } else {
-        g_renderer->setCutplaneLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Cutplane>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Cutplane>("all", state);
     }
     return TCL_OK;
@@ -1390 +1416 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setCutplaneEdgeColor(name, color);
-    } else {
-        g_renderer->setCutplaneEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<Cutplane>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Cutplane>("all", color);
     }
     return TCL_OK;
@@ -1407 +1433 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneEdgeWidth(name, width);
-    } else {
-        g_renderer->setCutplaneEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Cutplane>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Cutplane>("all", width);
     }
     return TCL_OK;
@@ -1424 +1450 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneOpacity(name, opacity);
-    } else {
-        g_renderer->setCutplaneOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Cutplane>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Cutplane>("all", opacity);
     }
     return TCL_OK;
@@ -1444 +1470 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setCutplaneOrientation(name, quat);
-    } else {
-        g_renderer->setCutplaneOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Cutplane>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Cutplane>("all", quat);
     }
     return TCL_OK;
@@ -1463 +1489 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setCutplanePosition(name, pos);
-    } else {
-        g_renderer->setCutplanePosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Cutplane>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Cutplane>("all", pos);
     }
     return TCL_OK;
@@ -1482 +1508 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setCutplaneScale(name, scale);
-    } else {
-        g_renderer->setCutplaneScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Cutplane>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Cutplane>("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneSliceVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    Axis axis;
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        axis = X_AXIS;
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        axis = Y_AXIS;
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        axis = Z_AXIS;
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
+                         "\": should be axisName bool", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setCutplaneSliceVisibility(name, axis, state);
+    } else {
+        g_renderer->setCutplaneSliceVisibility("all", axis, state);
     }
     return TCL_OK;
@@ -1499 +1556 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneVisibility(name, state);
-    } else {
-        g_renderer->setCutplaneVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Cutplane>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Cutplane>("all", state);
     }
     return TCL_OK;
@@ -1516 +1573 @@
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
-    Cutplane::Axis axis;
+    Axis axis;
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        axis = Cutplane::X_AXIS;
+        axis = X_AXIS;
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        axis = Cutplane::Y_AXIS;
+        axis = Y_AXIS;
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        axis = Cutplane::Z_AXIS;
+        axis = Z_AXIS;
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,
@@ -1530 +1587 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setCutplaneVolumeSlice(name, axis, ratio);
-    } else {
-        g_renderer->setCutplaneVolumeSlice("all", axis, ratio);
+        g_renderer->setGraphicsObjectVolumeSlice<Cutplane>(name, axis, ratio);
+    } else {
+        g_renderer->setGraphicsObjectVolumeSlice<Cutplane>("all", axis, ratio);
     }
     return TCL_OK;
@@ -1547 +1604 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneWireframe(name, state);
-    } else {
-        g_renderer->setCutplaneWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<Cutplane>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<Cutplane>("all", state);
     }
     return TCL_OK;
@@ -1555 +1612 @@
 
 static Rappture::CmdSpec cutplaneOps[] = {
-    {"add",          1, CutplaneAddOp, 2, 3, "oper value ?dataSetName?"},
+    {"add",          2, CutplaneAddOp, 2, 3, "oper value ?dataSetName?"},
+    {"axis",         2, CutplaneSliceVisibilityOp, 4, 5, "axis bool ?dataSetName?"},
     {"colormap",     7, CutplaneColorMapOp, 3, 4, "colorMapName ?dataSetName?"},
-    {"colormode",    7, CutplaneColorModeOp, 3, 4, "mode ?dataSetNme?"},
+    {"colormode",    7, CutplaneColorModeOp, 4, 5, "mode fieldName ?dataSetNme?"},
     {"delete",       1, CutplaneDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",        1, CutplaneEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -1656 +1714 @@
     }
     char *data = (char *)malloc(nbytes);
-    size_t bytesRead = SocketRead(data, nbytes);
-    if (bytesRead < 0) {
+    if (!SocketRead(data, nbytes)) {
         free(data);
         return TCL_ERROR;
@@ -1698 +1755 @@
 
     char buf[256];
-    snprintf(buf, sizeof(buf), "nv>dataset scalar pixel %d %d %g %s\n", x, y, value, name);
-
-    ssize_t bytesWritten = SocketWrite(buf, strlen(buf));
+    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);
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
+#endif
     return TCL_OK;
 }
@@ -1726 +1790 @@
 
     char buf[256];
-    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));
-
+    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);
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
+#endif
     return TCL_OK;
 }
@@ -1773 +1844 @@
 
     char buf[256];
-    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));
+    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);
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
+#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -1802 +1880 @@
 
     char buf[256];
-    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));
+    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);
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
+#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -1872 +1956 @@
     oss << "}\n";
     len += 2;
-
-    size_t bytesWritten = SocketWrite(oss.str().c_str(), len);
+#ifdef USE_THREADS
+    QueueResponse(clientData, oss.str().c_str(), len, Response::VOLATILE);
+#else 
+    ssize_t bytesWritten = SocketWrite(oss.str().c_str(), len);
 
     if (bytesWritten < 0) {
         return TCL_ERROR;
     }
+#endif /*USE_THREADS*/
     return TCL_OK;
 }
@@ -2041 +2128 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setGlyphsColor(name, color);
-    } else {
-        g_renderer->setGlyphsColor("all", color);
+        g_renderer->setGraphicsObjectColor<Glyphs>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Glyphs>("all", color);
     }
     return TCL_OK;
@@ -2055 +2142 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setGlyphsColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Glyphs>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Glyphs>("all", colorMapName);
     }
     return TCL_OK;
@@ -2074 +2161 @@
     } else if (str[0] == 'v' && strcmp(str, "vmag") == 0) {
         mode = Glyphs::COLOR_BY_VECTOR_MAGNITUDE;
+    } else if (str[0] == 'v' && strcmp(str, "vx") == 0) {
+        mode = Glyphs::COLOR_BY_VECTOR_X;
+    } else if (str[0] == 'v' && strcmp(str, "vy") == 0) {
+        mode = Glyphs::COLOR_BY_VECTOR_Y;
+    } else if (str[0] == 'v' && strcmp(str, "vz") == 0) {
+        mode = Glyphs::COLOR_BY_VECTOR_Z;
     } else {
         Tcl_AppendResult(interp, "bad color mode option \"", str,
-                         "\": should be one of: 'scalar', 'vmag', 'ccolor'", (char*)NULL);
-        return TCL_ERROR;
-    }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsColorMode(name, mode);
-    } else {
-        g_renderer->setGlyphsColorMode("all", mode);
+                         "\": should be one of: 'scalar', 'vmag', 'vx', 'vy', 'vz', 'ccolor'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (mode == Glyphs::COLOR_CONSTANT) {
+        fieldName = NULL;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setGlyphsColorMode(name, mode, fieldName);
+    } else {
+        g_renderer->setGlyphsColorMode("all", mode, fieldName);
     }
     return TCL_OK;
@@ -2094 +2191 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteGlyphs(name);
-    } else {
-        g_renderer->deleteGlyphs("all");
+        g_renderer->deleteGraphicsObject<Glyphs>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Glyphs>("all");
     }
     return TCL_OK;
@@ -2111 +2208 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsEdgeVisibility(name, state);
-    } else {
-        g_renderer->setGlyphsEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<Glyphs>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Glyphs>("all", state);
     }
     return TCL_OK;
@@ -2128 +2225 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsLighting(name, state);
-    } else {
-        g_renderer->setGlyphsLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Glyphs>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Glyphs>("all", state);
     }
     return TCL_OK;
@@ -2147 +2244 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setGlyphsEdgeColor(name, color);
-    } else {
-        g_renderer->setGlyphsEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<Glyphs>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Glyphs>("all", color);
     }
     return TCL_OK;
@@ -2164 +2261 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsEdgeWidth(name, width);
-    } else {
-        g_renderer->setGlyphsEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Glyphs>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Glyphs>("all", width);
     }
     return TCL_OK;
@@ -2198 +2295 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsOpacity(name, opacity);
-    } else {
-        g_renderer->setGlyphsOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Glyphs>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Glyphs>("all", opacity);
     }
     return TCL_OK;
@@ -2218 +2315 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setGlyphsOrientation(name, quat);
-    } else {
-        g_renderer->setGlyphsOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Glyphs>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Glyphs>("all", quat);
     }
     return TCL_OK;
@@ -2237 +2334 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setGlyphsPosition(name, pos);
-    } else {
-        g_renderer->setGlyphsPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Glyphs>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Glyphs>("all", pos);
     }
     return TCL_OK;
@@ -2256 +2353 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setGlyphsScale(name, scale);
-    } else {
-        g_renderer->setGlyphsScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Glyphs>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Glyphs>("all", scale);
     }
     return TCL_OK;
@@ -2299 +2396 @@
         return TCL_ERROR;
     }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsScalingMode(name, mode);
-    } else {
-        g_renderer->setGlyphsScalingMode("all", mode);
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setGlyphsScalingMode(name, mode, fieldName);
+    } else {
+        g_renderer->setGlyphsScalingMode("all", mode, fieldName);
     }
     return TCL_OK;
@@ -2360 +2458 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsVisibility(name, state);
-    } else {
-        g_renderer->setGlyphsVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Glyphs>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Glyphs>("all", state);
     }
     return TCL_OK;
@@ -2377 +2475 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setGlyphsWireframe(name, state);
-    } else {
-        g_renderer->setGlyphsWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<Glyphs>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<Glyphs>("all", state);
     }
     return TCL_OK;
@@ -2388 +2486 @@
     {"ccolor",    2, GlyphsColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",  7, GlyphsColorMapOp, 3, 4, "colorMapName ?dataSetNme?"},
-    {"colormode", 7, GlyphsColorModeOp, 3, 4, "mode ?dataSetNme?"},
+    {"colormode", 7, GlyphsColorModeOp, 4, 5, "mode fieldName ?dataSetNme?"},
     {"delete",    1, GlyphsDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, GlyphsEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -2401 +2499 @@
     {"scale",     2, GlyphsScaleOp, 5, 6, "sx sy sz ?dataSetName?"},
     {"shape",     2, GlyphsShapeOp, 3, 4, "shapeVal ?dataSetName?"},
-    {"smode",     2, GlyphsScalingModeOp, 3, 4, "mode ?dataSetNme?"},
+    {"smode",     2, GlyphsScalingModeOp, 4, 5, "mode fieldName ?dataSetNme?"},
     {"visible",   1, GlyphsVisibleOp, 3, 4, "bool ?dataSetName?"},
     {"wireframe", 1, GlyphsWireframeOp, 3, 4, "bool ?dataSetName?"}
@@ -2516 +2614 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setHeightMapColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<HeightMap>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<HeightMap>("all", colorMapName);
     }
     return TCL_OK;
@@ -2629 +2727 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteHeightMap(name);
-    } else {
-        g_renderer->deleteHeightMap("all");
+        g_renderer->deleteGraphicsObject<HeightMap>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<HeightMap>("all");
     }
     return TCL_OK;
@@ -2646 +2744 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapEdgeVisibility(name, state);
-    } else {
-        g_renderer->setHeightMapEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<HeightMap>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<HeightMap>("all", state);
     }
     return TCL_OK;
@@ -2680 +2778 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapLighting(name, state);
-    } else {
-        g_renderer->setHeightMapLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<HeightMap>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<HeightMap>("all", state);
     }
     return TCL_OK;
@@ -2699 +2797 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setHeightMapEdgeColor(name, color);
-    } else {
-        g_renderer->setHeightMapEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<HeightMap>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<HeightMap>("all", color);
     }
     return TCL_OK;
@@ -2716 +2814 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapEdgeWidth(name, width);
-    } else {
-        g_renderer->setHeightMapEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<HeightMap>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<HeightMap>("all", width);
     }
     return TCL_OK;
@@ -2751 +2849 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapOpacity(name, opacity);
-    } else {
-        g_renderer->setHeightMapOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<HeightMap>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<HeightMap>("all", opacity);
     }
     return TCL_OK;
@@ -2771 +2869 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setHeightMapOrientation(name, quat);
-    } else {
-        g_renderer->setHeightMapOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<HeightMap>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<HeightMap>("all", quat);
     }
     return TCL_OK;
@@ -2790 +2888 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setHeightMapPosition(name, pos);
-    } else {
-        g_renderer->setHeightMapPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<HeightMap>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<HeightMap>("all", pos);
     }
     return TCL_OK;
@@ -2809 +2907 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setHeightMapScale(name, scale);
-    } else {
-        g_renderer->setHeightMapScale("all", scale);
+        g_renderer->setGraphicsObjectScale<HeightMap>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<HeightMap>("all", scale);
     }
     return TCL_OK;
@@ -2826 +2924 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapVisibility(name, state);
-    } else {
-        g_renderer->setHeightMapVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<HeightMap>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<HeightMap>("all", state);
     }
     return TCL_OK;
@@ -2843 +2941 @@
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
-    HeightMap::Axis axis;
+    Axis axis;
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        axis = HeightMap::X_AXIS;
+        axis = X_AXIS;
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        axis = HeightMap::Y_AXIS;
+        axis = Y_AXIS;
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        axis = HeightMap::Z_AXIS;
+        axis = Z_AXIS;
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,
@@ -2857 +2955 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setHeightMapVolumeSlice(name, axis, ratio);
-    } else {
-        g_renderer->setHeightMapVolumeSlice("all", axis, ratio);
+        g_renderer->setGraphicsObjectVolumeSlice<HeightMap>(name, axis, ratio);
+    } else {
+        g_renderer->setGraphicsObjectVolumeSlice<HeightMap>("all", axis, ratio);
     }
     return TCL_OK;
@@ -2874 +2972 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setHeightMapWireframe(name, state);
-    } else {
-        g_renderer->setHeightMapWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<HeightMap>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<HeightMap>("all", state);
     }
     return TCL_OK;
@@ -2921 +3019 @@
 
 static int
+ImageFlushCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+             Tcl_Obj *const *objv)
+{
+    lastCmdStatus = TCL_BREAK;
+    return TCL_OK;
+}
+
+static int
 LegendCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
           Tcl_Obj *const *objv)
 {
-    if (objc < 7) {
+    if (objc < 8) {
         Tcl_AppendResult(interp, "wrong # args: should be \"",
-                Tcl_GetString(objv[0]), " colormapName legendType title width height numLabels ?dataSetName?\"", (char*)NULL);
+                Tcl_GetString(objv[0]), " colormapName legendType fieldName title width height numLabels ?dataSetName?\"", (char*)NULL);
         return TCL_ERROR;
     }
     const char *colorMapName = Tcl_GetString(objv[1]);
     const char *typeStr = Tcl_GetString(objv[2]);
-    Renderer::LegendType type;
+    Renderer::LegendType legendType;
     if (typeStr[0] == 's' && strcmp(typeStr, "scalar") == 0) {
-        type = Renderer::ACTIVE_SCALAR;
+        legendType = Renderer::LEGEND_SCALAR;
     } else if (typeStr[0] == 'v' && strcmp(typeStr, "vmag") == 0) {
-        type = Renderer::ACTIVE_VECTOR_MAGNITUDE;
+        legendType = Renderer::LEGEND_VECTOR_MAGNITUDE;
     } else if (typeStr[0] == 'v' && strcmp(typeStr, "vx") == 0) {
-        type = Renderer::ACTIVE_VECTOR_X;
+        legendType = Renderer::LEGEND_VECTOR_X;
     } else if (typeStr[0] == 'v' && strcmp(typeStr, "vy") == 0) {
-        type = Renderer::ACTIVE_VECTOR_Y;
+        legendType = Renderer::LEGEND_VECTOR_Y;
     } else if (typeStr[0] == 'v' && strcmp(typeStr, "vz") == 0) {
-        type = Renderer::ACTIVE_VECTOR_Z;
+        legendType = Renderer::LEGEND_VECTOR_Z;
     } else {
         Tcl_AppendResult(interp, "Bad legendType option \"",
@@ -2948 +3054 @@
     }
 
-    std::string title(Tcl_GetString(objv[3]));
+    const char *fieldName = Tcl_GetString(objv[3]);
+
+    std::string title(Tcl_GetString(objv[4]));
     int width, height, numLabels;
 
-    if (Tcl_GetIntFromObj(interp, objv[4], &width) != TCL_OK ||
-        Tcl_GetIntFromObj(interp, objv[5], &height) != TCL_OK ||
-        Tcl_GetIntFromObj(interp, objv[6], &numLabels) != TCL_OK) {
+    if (Tcl_GetIntFromObj(interp, objv[5], &width) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[6], &height) != TCL_OK ||
+        Tcl_GetIntFromObj(interp, objv[7], &numLabels) != TCL_OK) {
         return TCL_ERROR;
     }
@@ -2961 +3069 @@
 
     double range[2];
-
-    if (objc == 8) {
-        const char *dataSetName = Tcl_GetString(objv[7]);
-        if (!g_renderer->renderColorMap(colorMapName, dataSetName, type, title,
+    range[0] = DBL_MAX;
+    range[1] = -DBL_MAX;
+
+    if (objc == 9) {
+        const char *dataSetName = Tcl_GetString(objv[8]);
+        if (!g_renderer->renderColorMap(colorMapName, dataSetName, legendType, fieldName, title,
                                         range, width, height, numLabels, imgData)) {
             Tcl_AppendResult(interp, "Color map \"",
@@ -2972 +3082 @@
         }
     } else {
-        if (!g_renderer->renderColorMap(colorMapName, "all", type, title,
+        if (!g_renderer->renderColorMap(colorMapName, "all", legendType, fieldName, title,
                                         range, width, height, numLabels, imgData)) {
             Tcl_AppendResult(interp, "Color map \"",
@@ -2981 +3091 @@
 
 #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 RENDER_TARGA
+
+# ifdef USE_THREADS
+#  ifdef RENDER_TARGA
+    ResponseQueue *queue = (ResponseQueue *)clientData;
+    queueTGA(queue, cmd, imgData->GetPointer(0), width, height,
+             TARGA_BYTES_PER_PIXEL);
+#  else
+    ResponseQueue *queue = (ResponseQueue *)clientData;
+    queuePPM(queue, cmd, imgData->GetPointer(0), width, height);
+#  endif
+# else
+#  ifdef RENDER_TARGA
     writeTGA(g_fdOut, cmd, imgData->GetPointer(0), width, height,
-                 TARGA_BYTES_PER_PIXEL);
-#else
+             TARGA_BYTES_PER_PIXEL);
+#  else
     writePPM(g_fdOut, cmd, imgData->GetPointer(0), width, height);
-#endif
-#endif
-
+#  endif
+# endif // USE_THREADS
+#endif // DEBUG
     return TCL_OK;
 }
@@ -3004 +3130 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addLIC(name)) {
+        if (!g_renderer->addGraphicsObject<LIC>(name)) {
             Tcl_AppendResult(interp, "Failed to create lic", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addLIC("all")) {
+        if (!g_renderer->addGraphicsObject<LIC>("all")) {
             Tcl_AppendResult(interp, "Failed to create lic for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -3024 +3150 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setLICColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setLICColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<LIC>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<LIC>("all", colorMapName);
     }
     return TCL_OK;
@@ -3037 +3163 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteLIC(name);
-    } else {
-        g_renderer->deleteLIC("all");
+        g_renderer->deleteGraphicsObject<LIC>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<LIC>("all");
     }
     return TCL_OK;
@@ -3054 +3180 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setLICEdgeVisibility(name, state);
-    } else {
-        g_renderer->setLICEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<LIC>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<LIC>("all", state);
     }
     return TCL_OK;
@@ -3071 +3197 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setLICLighting(name, state);
-    } else {
-        g_renderer->setLICLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<LIC>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<LIC>("all", state);
     }
     return TCL_OK;
@@ -3090 +3216 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setLICEdgeColor(name, color);
-    } else {
-        g_renderer->setLICEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<LIC>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<LIC>("all", color);
     }
     return TCL_OK;
@@ -3107 +3233 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setLICEdgeWidth(name, width);
-    } else {
-        g_renderer->setLICEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<LIC>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<LIC>("all", width);
     }
     return TCL_OK;
@@ -3124 +3250 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setLICOpacity(name, opacity);
-    } else {
-        g_renderer->setLICOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<LIC>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<LIC>("all", opacity);
     }
     return TCL_OK;
@@ -3144 +3270 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setLICOrientation(name, quat);
-    } else {
-        g_renderer->setLICOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<LIC>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<LIC>("all", quat);
     }
     return TCL_OK;
@@ -3163 +3289 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setLICPosition(name, pos);
-    } else {
-        g_renderer->setLICPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<LIC>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<LIC>("all", pos);
     }
     return TCL_OK;
@@ -3182 +3308 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setLICScale(name, scale);
-    } else {
-        g_renderer->setLICScale("all", scale);
+        g_renderer->setGraphicsObjectScale<LIC>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<LIC>("all", scale);
     }
     return TCL_OK;
@@ -3199 +3325 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setLICVisibility(name, state);
-    } else {
-        g_renderer->setLICVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<LIC>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<LIC>("all", state);
     }
     return TCL_OK;
@@ -3216 +3342 @@
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
-    LIC::Axis axis;
+    Axis axis;
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        axis = LIC::X_AXIS;
+        axis = X_AXIS;
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        axis = LIC::Y_AXIS;
+        axis = Y_AXIS;
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        axis = LIC::Z_AXIS;
+        axis = Z_AXIS;
     } else {
         Tcl_AppendResult(interp, "bad axis option \"", string,
@@ -3230 +3356 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setLICVolumeSlice(name, axis, ratio);
-    } else {
-        g_renderer->setLICVolumeSlice("all", axis, ratio);
+        g_renderer->setGraphicsObjectVolumeSlice<LIC>(name, axis, ratio);
+    } else {
+        g_renderer->setGraphicsObjectVolumeSlice<LIC>("all", axis, ratio);
     }
     return TCL_OK;
@@ -3274 +3400 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addMolecule(name)) {
+        if (!g_renderer->addGraphicsObject<Molecule>(name)) {
             Tcl_AppendResult(interp, "Failed to create molecule", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addMolecule("all")) {
+        if (!g_renderer->addGraphicsObject<Molecule>("all")) {
             Tcl_AppendResult(interp, "Failed to create molecule for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -3356 +3482 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setMoleculeColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Molecule>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Molecule>("all", colorMapName);
     }
     return TCL_OK;
@@ -3369 +3495 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteMolecule(name);
-    } else {
-        g_renderer->deleteMolecule("all");
+        g_renderer->deleteGraphicsObject<Molecule>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Molecule>("all");
     }
     return TCL_OK;
@@ -3386 +3512 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeEdgeVisibility(name, state);
-    } else {
-        g_renderer->setMoleculeEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<Molecule>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Molecule>("all", state);
     }
     return TCL_OK;
@@ -3403 +3529 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeLighting(name, state);
-    } else {
-        g_renderer->setMoleculeLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Molecule>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Molecule>("all", state);
     }
     return TCL_OK;
@@ -3422 +3548 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setMoleculeEdgeColor(name, color);
-    } else {
-        g_renderer->setMoleculeEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<Molecule>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Molecule>("all", color);
     }
     return TCL_OK;
@@ -3439 +3565 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeEdgeWidth(name, width);
-    } else {
-        g_renderer->setMoleculeEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Molecule>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Molecule>("all", width);
     }
     return TCL_OK;
@@ -3456 +3582 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeOpacity(name, opacity);
-    } else {
-        g_renderer->setMoleculeOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Molecule>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Molecule>("all", opacity);
     }
     return TCL_OK;
@@ -3476 +3602 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setMoleculeOrientation(name, quat);
-    } else {
-        g_renderer->setMoleculeOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Molecule>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Molecule>("all", quat);
     }
     return TCL_OK;
@@ -3495 +3621 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setMoleculePosition(name, pos);
-    } else {
-        g_renderer->setMoleculePosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Molecule>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Molecule>("all", pos);
     }
     return TCL_OK;
@@ -3514 +3640 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setMoleculeScale(name, scale);
-    } else {
-        g_renderer->setMoleculeScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Molecule>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Molecule>("all", scale);
     }
     return TCL_OK;
@@ -3531 +3657 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeVisibility(name, state);
-    } else {
-        g_renderer->setMoleculeVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Molecule>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Molecule>("all", state);
     }
     return TCL_OK;
@@ -3548 +3674 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setMoleculeWireframe(name, state);
-    } else {
-        g_renderer->setMoleculeWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<Molecule>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<Molecule>("all", state);
     }
     return TCL_OK;
@@ -3595 +3721 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addPolyData(name)) {
+        if (!g_renderer->addGraphicsObject<PolyData>(name)) {
             Tcl_AppendResult(interp, "Failed to create polydata", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addPolyData("all")) {
+        if (!g_renderer->addGraphicsObject<PolyData>("all")) {
             Tcl_AppendResult(interp, "Failed to create polydata for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -3614 +3740 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deletePolyData(name);
-    } else {
-        g_renderer->deletePolyData("all");
+        g_renderer->deleteGraphicsObject<PolyData>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<PolyData>("all");
     }
     return TCL_OK;
@@ -3633 +3759 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataColor(name, color);
-    } else {
-        g_renderer->setPolyDataColor("all", color);
+        g_renderer->setGraphicsObjectColor<PolyData>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<PolyData>("all", color);
     }
     return TCL_OK;
@@ -3650 +3776 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataEdgeVisibility(name, state);
-    } else {
-        g_renderer->setPolyDataEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<PolyData>("all", state);
     }
     return TCL_OK;
@@ -3667 +3793 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataLighting(name, state);
-    } else {
-        g_renderer->setPolyDataLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<PolyData>("all", state);
     }
     return TCL_OK;
@@ -3686 +3812 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataEdgeColor(name, color);
-    } else {
-        g_renderer->setPolyDataEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<PolyData>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<PolyData>("all", color);
     }
     return TCL_OK;
@@ -3703 +3829 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataEdgeWidth(name, width);
-    } else {
-        g_renderer->setPolyDataEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<PolyData>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<PolyData>("all", width);
     }
     return TCL_OK;
@@ -3720 +3846 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataOpacity(name, opacity);
-    } else {
-        g_renderer->setPolyDataOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<PolyData>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<PolyData>("all", opacity);
     }
     return TCL_OK;
@@ -3740 +3866 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setPolyDataOrientation(name, quat);
-    } else {
-        g_renderer->setPolyDataOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<PolyData>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<PolyData>("all", quat);
     }
     return TCL_OK;
@@ -3757 +3883 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataPointSize(name, size);
-    } else {
-        g_renderer->setPolyDataPointSize("all", size);
+        g_renderer->setGraphicsObjectPointSize<PolyData>(name, size);
+    } else {
+        g_renderer->setGraphicsObjectPointSize<PolyData>("all", size);
     }
     return TCL_OK;
@@ -3776 +3902 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataPosition(name, pos);
-    } else {
-        g_renderer->setPolyDataPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<PolyData>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<PolyData>("all", pos);
     }
     return TCL_OK;
@@ -3795 +3921 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPolyDataScale(name, scale);
-    } else {
-        g_renderer->setPolyDataScale("all", scale);
+        g_renderer->setGraphicsObjectScale<PolyData>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<PolyData>("all", scale);
     }
     return TCL_OK;
@@ -3812 +3938 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataVisibility(name, state);
-    } else {
-        g_renderer->setPolyDataVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<PolyData>("all", state);
     }
     return TCL_OK;
@@ -3829 +3955 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPolyDataWireframe(name, state);
-    } else {
-        g_renderer->setPolyDataWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<PolyData>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<PolyData>("all", state);
     }
     return TCL_OK;
@@ -3874 +4000 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addPseudoColor(name)) {
+        if (!g_renderer->addGraphicsObject<PseudoColor>(name)) {
             Tcl_AppendResult(interp, "Failed to create pseudocolor", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addPseudoColor("all")) {
+        if (!g_renderer->addGraphicsObject<PseudoColor>("all")) {
             Tcl_AppendResult(interp, "Failed to create pseudocolor for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -3899 +4025 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPseudoColorColor(name, color);
-    } else {
-        g_renderer->setPseudoColorColor("all", color);
+        g_renderer->setGraphicsObjectColor<PseudoColor>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<PseudoColor>("all", color);
     }
     return TCL_OK;
@@ -3913 +4039 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setPseudoColorColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<PseudoColor>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<PseudoColor>("all", colorMapName);
     }
     return TCL_OK;
@@ -3943 +4069 @@
         return TCL_ERROR;
     }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorColorMode(name, mode);
-    } else {
-        g_renderer->setPseudoColorColorMode("all", mode);
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (mode == PseudoColor::COLOR_CONSTANT) {
+        fieldName = NULL;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setPseudoColorColorMode(name, mode, fieldName);
+    } else {
+        g_renderer->setPseudoColorColorMode("all", mode, fieldName);
     }
     return TCL_OK;
@@ -3958 +4088 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deletePseudoColor(name);
-    } else {
-        g_renderer->deletePseudoColor("all");
+        g_renderer->deleteGraphicsObject<PseudoColor>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<PseudoColor>("all");
     }
     return TCL_OK;
@@ -3975 +4105 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorEdgeVisibility(name, state);
-    } else {
-        g_renderer->setPseudoColorEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<PseudoColor>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<PseudoColor>("all", state);
     }
     return TCL_OK;
@@ -3992 +4122 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorLighting(name, state);
-    } else {
-        g_renderer->setPseudoColorLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<PseudoColor>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<PseudoColor>("all", state);
     }
     return TCL_OK;
@@ -4011 +4141 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPseudoColorEdgeColor(name, color);
-    } else {
-        g_renderer->setPseudoColorEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<PseudoColor>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<PseudoColor>("all", color);
     }
     return TCL_OK;
@@ -4028 +4158 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorEdgeWidth(name, width);
-    } else {
-        g_renderer->setPseudoColorEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<PseudoColor>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<PseudoColor>("all", width);
     }
     return TCL_OK;
@@ -4045 +4175 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorOpacity(name, opacity);
-    } else {
-        g_renderer->setPseudoColorOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<PseudoColor>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<PseudoColor>("all", opacity);
     }
     return TCL_OK;
@@ -4065 +4195 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setPseudoColorOrientation(name, quat);
-    } else {
-        g_renderer->setPseudoColorOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<PseudoColor>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<PseudoColor>("all", quat);
     }
     return TCL_OK;
@@ -4084 +4214 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPseudoColorPosition(name, pos);
-    } else {
-        g_renderer->setPseudoColorPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<PseudoColor>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<PseudoColor>("all", pos);
     }
     return TCL_OK;
@@ -4103 +4233 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setPseudoColorScale(name, scale);
-    } else {
-        g_renderer->setPseudoColorScale("all", scale);
+        g_renderer->setGraphicsObjectScale<PseudoColor>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<PseudoColor>("all", scale);
     }
     return TCL_OK;
@@ -4120 +4250 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorVisibility(name, state);
-    } else {
-        g_renderer->setPseudoColorVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<PseudoColor>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<PseudoColor>("all", state);
     }
     return TCL_OK;
@@ -4137 +4267 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setPseudoColorWireframe(name, state);
-    } else {
-        g_renderer->setPseudoColorWireframe("all", state);
+        g_renderer->setGraphicsObjectWireframe<PseudoColor>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<PseudoColor>("all", state);
     }
     return TCL_OK;
@@ -4148 +4278 @@
     {"ccolor",    2, PseudoColorColorOp, 5, 6, "r g b ?dataSetName?"},
     {"colormap",  7, PseudoColorColorMapOp, 3, 4, "colorMapName ?dataSetNme?"},
-    {"colormode", 7, PseudoColorColorModeOp, 3, 4, "mode ?dataSetNme?"},
+    {"colormode", 7, PseudoColorColorModeOp, 4, 5, "mode fieldName ?dataSetNme?"},
     {"delete",    1, PseudoColorDeleteOp, 2, 3, "?dataSetName?"},
     {"edges",     1, PseudoColorEdgeVisibilityOp, 3, 4, "bool ?dataSetName?"},
@@ -4183 +4313 @@
     const char *string = Tcl_GetString(objv[2]);
     char c = string[0];
-    Renderer::Axis axis;
+    Axis axis;
     if ((c == 'x') && (strcmp(string, "x") == 0)) {
-        axis = Renderer::X_AXIS;
+        axis = X_AXIS;
     } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
-        axis = Renderer::Y_AXIS;
+        axis = Y_AXIS;
     } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
-        axis = Renderer::Z_AXIS;
+        axis = Z_AXIS;
     } else {
         Tcl_AppendResult(interp, "bad clipplane option \"", string,
@@ -4318 +4448 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addStreamlines(name)) {
+        if (!g_renderer->addGraphicsObject<Streamlines>(name)) {
             Tcl_AppendResult(interp, "Failed to create streamlines", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addStreamlines("all")) {
+        if (!g_renderer->addGraphicsObject<Streamlines>("all")) {
             Tcl_AppendResult(interp, "Failed to create streamlines for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -4343 +4473 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setStreamlinesColor(name, color);
-    } else {
-        g_renderer->setStreamlinesColor("all", color);
+        g_renderer->setGraphicsObjectColor<Streamlines>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Streamlines>("all", color);
     }
     return TCL_OK;
@@ -4357 +4487 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setStreamlinesColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Streamlines>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Streamlines>("all", colorMapName);
     }
     return TCL_OK;
@@ -4387 +4517 @@
         return TCL_ERROR;
     }
-    if (objc == 4) {
-        const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesColorMode(dataSetName, mode);
-    } else {
-        g_renderer->setStreamlinesColorMode("all", mode);
+    const char *fieldName = Tcl_GetString(objv[3]);
+    if (mode == Streamlines::COLOR_CONSTANT) {
+        fieldName = NULL;
+    }
+    if (objc == 5) {
+        const char *dataSetName = Tcl_GetString(objv[4]);
+        g_renderer->setStreamlinesColorMode(dataSetName, mode, fieldName);
+    } else {
+        g_renderer->setStreamlinesColorMode("all", mode, fieldName);
     }
     return TCL_OK;
@@ -4402 +4536 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteStreamlines(name);
-    } else {
-        g_renderer->deleteStreamlines("all");
+        g_renderer->deleteGraphicsObject<Streamlines>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Streamlines>("all");
     }
     return TCL_OK;
@@ -4419 +4553 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesEdgeVisibility(name, state);
-    } else {
-        g_renderer->setStreamlinesEdgeVisibility("all", state);
+        g_renderer->setGraphicsObjectEdgeVisibility<Streamlines>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Streamlines>("all", state);
     }
     return TCL_OK;
@@ -4453 +4587 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesLighting(name, state);
-    } else {
-        g_renderer->setStreamlinesLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Streamlines>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Streamlines>("all", state);
     }
     return TCL_OK;
@@ -4472 +4606 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setStreamlinesEdgeColor(name, color);
-    } else {
-        g_renderer->setStreamlinesEdgeColor("all", color);
+        g_renderer->setGraphicsObjectEdgeColor<Streamlines>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Streamlines>("all", color);
     }
     return TCL_OK;
@@ -4502 +4636 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesEdgeWidth(name, width);
-    } else {
-        g_renderer->setStreamlinesEdgeWidth("all", width);
+        g_renderer->setGraphicsObjectEdgeWidth<Streamlines>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Streamlines>("all", width);
     }
     return TCL_OK;
@@ -4519 +4653 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesOpacity(name, opacity);
-    } else {
-        g_renderer->setStreamlinesOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Streamlines>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Streamlines>("all", opacity);
     }
     return TCL_OK;
@@ -4539 +4673 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setStreamlinesOrientation(name, quat);
-    } else {
-        g_renderer->setStreamlinesOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Streamlines>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Streamlines>("all", quat);
     }
     return TCL_OK;
@@ -4558 +4692 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setStreamlinesPosition(name, pos);
-    } else {
-        g_renderer->setStreamlinesPosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Streamlines>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Streamlines>("all", pos);
     }
     return TCL_OK;
@@ -4577 +4711 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setStreamlinesScale(name, scale);
-    } else {
-        g_renderer->setStreamlinesScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Streamlines>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Streamlines>("all", scale);
     }
     return TCL_OK;
@@ -4684 +4818 @@
     }
     char *data = (char *)malloc(nbytes);
-    size_t bytesRead = SocketRead(data, nbytes);
-    if (bytesRead < 0) {
+    if (!SocketRead(data, nbytes)) {
         free(data);
         return TCL_ERROR;
@@ -4733 +4866 @@
     }
     char *data = (char *)malloc(nbytes);
-    size_t bytesRead = SocketRead(data, nbytes);
-    if (bytesRead < 0) {
+    if (!SocketRead(data, nbytes)) {
         free(data);
         return TCL_ERROR;
@@ -4757 +4889 @@
 
 static int
+StreamlinesSeedNumPointsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                           Tcl_Obj *const *objv)
+{
+    int numPoints;
+    if (Tcl_GetIntFromObj(interp, objv[3], &numPoints) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 5) {
+        const char *name = Tcl_GetString(objv[4]);
+        g_renderer->setStreamlinesNumberOfSeedPoints(name, numPoints);
+    } else {
+        g_renderer->setStreamlinesNumberOfSeedPoints("all", numPoints);
+    }
+    return TCL_OK;
+}
+
+static int
 StreamlinesSeedPointsOp(ClientData clientData, Tcl_Interp *interp, int objc, 
                         Tcl_Obj *const *objv)
@@ -4907 +5056 @@
 
 static Rappture::CmdSpec streamlinesSeedOps[] = {
-    {"color",   1, StreamlinesSeedColorOp, 6, 7, "r g b ?dataSetName?"},
-    {"disk",    1, StreamlinesSeedDiskOp, 12, 13, "centerX centerY centerZ normalX normalY normalZ radius innerRadius numPoints ?dataSetName?"},
-    {"fmesh",   2, StreamlinesSeedFilledMeshOp, 7, 8, "numPoints data follows nbytes ?dataSetName?"},
+    {"color",   1, StreamlinesSeedColorOp,         6, 7, "r g b ?dataSetName?"},
+    {"disk",    1, StreamlinesSeedDiskOp,          12, 13, "centerX centerY centerZ normalX normalY normalZ radius innerRadius numPoints ?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?"},
-    {"visible", 1, StreamlinesSeedVisibleOp, 4, 5, "bool ?dataSetName?"}
+    {"mesh",    1, StreamlinesSeedMeshPointsOp,    6, 7, "data follows nbytes ?dataSetName?"},
+    {"numpts",  1, StreamlinesSeedNumPointsOp,     4, 5, "numPoints ?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?"},
+    {"visible", 1, StreamlinesSeedVisibleOp,       4, 5, "bool ?dataSetName?"}
 };
 static int nStreamlinesSeedOps = NumCmdSpecs(streamlinesSeedOps);
@@ -4965 +5115 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setStreamlinesVisibility(name, state);
-    } else {
-        g_renderer->setStreamlinesVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Streamlines>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Streamlines>("all", state);
     }
     return TCL_OK;
@@ -4973 +5123 @@
 
 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?"},
-    {"colormode", 7, StreamlinesColorModeOp, 3, 4, "mode ?dataSetNme?"},
-    {"delete",    1, StreamlinesDeleteOp, 2, 3, "?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,      4, 5, "mode fieldName ?dataSetNme?"},
+    {"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?"},
-    {"linecolor", 5, StreamlinesLineColorOp, 5, 6, "r g b ?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, 3, 14, "op params... ?dataSetName?"},
-    {"tubes",     1, StreamlinesTubesOp, 4, 5, "numSides radius ?dataSetName?"},
-    {"visible",   1, StreamlinesVisibleOp, 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?"},
+    {"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,           3, 14, "op params... ?dataSetName?"},
+    {"tubes",     1, StreamlinesTubesOp,          4, 5, "numSides radius ?dataSetName?"},
+    {"visible",   1, StreamlinesVisibleOp,        3, 4, "bool ?dataSetName?"}
 };
 static int nStreamlinesOps = NumCmdSpecs(streamlinesOps);
@@ -5015 +5165 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        if (!g_renderer->addVolume(name)) {
+        if (!g_renderer->addGraphicsObject<Volume>(name)) {
             Tcl_AppendResult(interp, "Failed to create volume", (char*)NULL);
             return TCL_ERROR;
         }
     } else {
-        if (!g_renderer->addVolume("all")) {
+        if (!g_renderer->addGraphicsObject<Volume>("all")) {
             Tcl_AppendResult(interp, "Failed to create volume for one or more data sets", (char*)NULL);
             return TCL_ERROR;
@@ -5035 +5185 @@
     if (objc == 4) {
         const char *dataSetName = Tcl_GetString(objv[3]);
-        g_renderer->setVolumeColorMap(dataSetName, colorMapName);
-    } else {
-        g_renderer->setVolumeColorMap("all", colorMapName);
+        g_renderer->setGraphicsObjectColorMap<Volume>(dataSetName, colorMapName);
+    } else {
+        g_renderer->setGraphicsObjectColorMap<Volume>("all", colorMapName);
     }
     return TCL_OK;
@@ -5048 +5198 @@
     if (objc == 3) {
         const char *name = Tcl_GetString(objv[2]);
-        g_renderer->deleteVolume(name);
-    } else {
-        g_renderer->deleteVolume("all");
+        g_renderer->deleteGraphicsObject<Volume>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Volume>("all");
     }
     return TCL_OK;
@@ -5065 +5215 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setVolumeLighting(name, state);
-    } else {
-        g_renderer->setVolumeLighting("all", state);
+        g_renderer->setGraphicsObjectLighting<Volume>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Volume>("all", state);
     }
     return TCL_OK;
@@ -5082 +5232 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setVolumeOpacity(name, opacity);
-    } else {
-        g_renderer->setVolumeOpacity("all", opacity);
+        g_renderer->setGraphicsObjectOpacity<Volume>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Volume>("all", opacity);
     }
     return TCL_OK;
@@ -5102 +5252 @@
     if (objc == 7) {
         const char *name = Tcl_GetString(objv[6]);
-        g_renderer->setVolumeOrientation(name, quat);
-    } else {
-        g_renderer->setVolumeOrientation("all", quat);
+        g_renderer->setGraphicsObjectOrientation<Volume>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Volume>("all", quat);
     }
     return TCL_OK;
@@ -5121 +5271 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setVolumePosition(name, pos);
-    } else {
-        g_renderer->setVolumePosition("all", pos);
+        g_renderer->setGraphicsObjectPosition<Volume>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Volume>("all", pos);
     }
     return TCL_OK;
@@ -5140 +5290 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setVolumeScale(name, scale);
-    } else {
-        g_renderer->setVolumeScale("all", scale);
+        g_renderer->setGraphicsObjectScale<Volume>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Volume>("all", scale);
     }
     return TCL_OK;
@@ -5158 +5308 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setVolumeAmbient(name, coeff);
-    } else {
-        g_renderer->setVolumeAmbient("all", coeff);
+        g_renderer->setGraphicsObjectAmbient<Volume>(name, coeff);
+    } else {
+        g_renderer->setGraphicsObjectAmbient<Volume>("all", coeff);
     }
     return TCL_OK;
@@ -5176 +5326 @@
     if (objc == 5) {
         const char *name = Tcl_GetString(objv[4]);
-        g_renderer->setVolumeDiffuse(name, coeff);
-    } else {
-        g_renderer->setVolumeDiffuse("all", coeff);
+        g_renderer->setGraphicsObjectDiffuse<Volume>(name, coeff);
+    } else {
+        g_renderer->setGraphicsObjectDiffuse<Volume>("all", coeff);
     }
     return TCL_OK;
@@ -5195 +5345 @@
     if (objc == 6) {
         const char *name = Tcl_GetString(objv[5]);
-        g_renderer->setVolumeSpecular(name, coeff, power);
-    } else {
-        g_renderer->setVolumeSpecular("all", coeff, power);
+        g_renderer->setGraphicsObjectSpecular<Volume>(name, coeff, power);
+    } else {
+        g_renderer->setGraphicsObjectSpecular<Volume>("all", coeff, power);
     }
     return TCL_OK;
@@ -5203 +5353 @@
 
 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?"}
 };
@@ -5233 +5383 @@
     if (objc == 4) {
         const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setVolumeVisibility(name, state);
-    } else {
-        g_renderer->setVolumeVisibility("all", state);
+        g_renderer->setGraphicsObjectVisibility<Volume>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Volume>("all", state);
     }
     return TCL_OK;
@@ -5241 +5391 @@
 
 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);
@@ -5270 +5420 @@
 /**
  * \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);
-
+Rappture::VtkVis::processCommands(Tcl_Interp *interp, ReadBuffer *inBufPtr, 
+                                  int fdOut)
+{
     int status = TCL_OK;
-    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;
+
+    Tcl_DString command;
+    Tcl_DStringInit(&command);
+    fd_set readFds;
+    struct timeval tv, *tvPtr;
+
+    FD_ZERO(&readFds);
+    FD_SET(inBufPtr->file(), &readFds);
+    tvPtr = NULL;                       /* Wait for the first read. This is so
+                                         * that we don't spin when no data is
+                                         * available. */
+    while (inBufPtr->isLineAvailable() || 
+           (select(1, &readFds, NULL, NULL, tvPtr) > 0)) {
+        size_t numBytes;
+        unsigned char *buffer;
+
+        /* A short read is treated as an error here because we assume that we
+         * will always get commands line by line. */
+        if (inBufPtr->getLine(&numBytes, &buffer) != ReadBuffer::OK) {
+            /* Terminate the server if we can't communicate with the client
+             * anymore. */
+            if (inBufPtr->status() == ReadBuffer::ENDFILE) {
+                TRACE("Exiting server on EOF from client");
+                return -1;
+            } else {
+                ERROR("Exiting server, failed to read from client: %s",
+                      strerror(errno));
+                return -1;
             }
-            char ch = (char)c;
-            Tcl_DStringAppend(&cmdbuffer, &ch, 1);
-            if (ch == '\n') {
-                isComplete = Tcl_CommandComplete(Tcl_DStringValue(&cmdbuffer));
-                if (isComplete) {
-                    break;
-                }
+        }
+        Tcl_DStringAppend(&command, (char *)buffer, numBytes);
+        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. */
             }
         }
-        // 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);
+        tv.tv_sec = tv.tv_usec = 0L;    /* On successive reads, we break out
+                                         * if no data is available. */
+        FD_SET(inBufPtr->file(), &readFds);
+        tvPtr = &tv;
+    }
 
     if (status != TCL_OK) {
@@ -5328 +5486 @@
 
         string = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);
-        TRACE("ERROR errorInfo=(%s)", string);
-
+        TRACE("%s: status=%d ERROR errorInfo=(%s)", Tcl_DStringValue(&command),
+              status, string);
         nBytes = strlen(string);
         struct iovec iov[3];
@@ -5339 +5497 @@
         iov[2].iov_len = strlen((char *)iov[2].iov_base);
         if (writev(fdOut, iov, 3) < 0) {
-            ERROR("write failed: %s", strerror(errno));
+            ERROR("write failed: %s", strerror(errno));
+            return -1;
         }
         return 0;
@@ -5352 +5511 @@
  * \return The initialized Tcl interpreter
  */
-Tcl_Interp *
-Rappture::VtkVis::initTcl()
-{
-    Tcl_Interp *interp;
-    interp = Tcl_CreateInterp();
-
+void
+Rappture::VtkVis::initTcl(Tcl_Interp *interp, ClientData clientData)
+{
     Tcl_MakeSafe(interp);
-
-    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;
+    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, "cutplane",    CutplaneCmd,    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);
 }
 
 /**
  * \brief Delete Tcl commands and interpreter
- *
  */
 void Rappture::VtkVis::exitTcl(Tcl_Interp *interp)
@@ -5397 +5551 @@
     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

@@ -11 +11 @@
 #include <cstdio>
 #include <tcl.h>
+#include "ReadBuffer.h"
 
 namespace Rappture {
 namespace VtkVis {
 
-extern int processCommands(Tcl_Interp *interp, FILE *fin, FILE *fout);
-extern Tcl_Interp *initTcl();
+extern int processCommands(Tcl_Interp *interp, ReadBuffer *inBufPtr, 
+                           int fdOut);
+extern void initTcl(Tcl_Interp *interp, ClientData clientData);
 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
 
 /**
@@ -79 +149 @@
     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 writeTGA(int fd, const char *cmdName, const unsigned char *data,
-              int width, int height, int bytesPerPixel);
-
+void queueTGA(ResponseQueue *queue, const char *cmdName, 
+              const unsigned char *data, int width, int height, 
+              int bytesPerPixel);
+#else
 extern
-void writeTGAFile(const char *filename, const unsigned char *data,
-                  int width, int height, int bytesPerPixel,
-                  bool srcIsRGB = false);
-
+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);
 }
 }

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

@@ -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, ...)
 {
@@ -64 +64 @@
     syslog(priority, message, length);
 }
-
-

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

@@ -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(...)      LogMessage(LOG_ERR, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define ERROR(...)      Rappture::VtkVis::logMessage(LOG_ERR, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 #ifdef WANT_TRACE
-#define TRACE(...)      LogMessage(LOG_DEBUG, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#define TRACE(...)      Rappture::VtkVis::logMessage(LOG_DEBUG, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
 #else 
 #define TRACE(...) 
-#endif
-#define WARN(...)       LogMessage(LOG_WARNING, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
-#define INFO(...)       LogMessage(LOG_INFO, __FUNCTION__, __FILE__, __LINE__, __VA_ARGS__)
+#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__)
 
 }

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

@@ -73 +73 @@
 colormap delete <?colorMapName?>
 
-legend <colormapName> <legendType> <legendTitle> <width> <height> <numLabels> <?datasetName?>
+legend <colormapName> <legendType> <fieldName> <legendTitle> <width> <height> <numLabels> <?datasetName?>
        Causes legend to be rendered and written back with labels and title
        (title may be left blank)
@@ -145 +145 @@
 
 cutplane add <?dataSetName?>
+cutplane axis <axis> <bool> <?dataSetName?>
+         Toggle visibility of the 3 principal axis cutplanes
 cutplane colormap <colorMapName> <?dataSetName?>
-cutplane colormode <scalar|vmag|vx|vy|vz> <?datasetName?>
+cutplane colormode <scalar|vmag|vx|vy|vz> <fieldName> <?datasetName?>
          Set the field used to color the object.  'scalar' uses
          the active scalar field.  'vmag' uses the magnitude of the current
@@ -170 +172 @@
 glyphs ccolor r g b <?datasetName?>
 glyphs colormap <colorMapName> <?dataSetName?>
-glyphs colormode <scalar|vmag|ccolor> <?dataSetName?>
+glyphs colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?dataSetName?>
        Set the color mode: color by scalar field or
        vector magnitude -- uses the current color map,
@@ -189 +191 @@
 glyphs scale <sx> <sy> <sz> <?dataSetName?>
 glyphs shape <arrow|cone|cube|cylinder|dodecahedron|icosahedron|line|octahedron|sphere|tetrahedron> <?datasetName?>
-glyphs smode <scalar|vmag|vcomp|off> <?dataSetName?>
+glyphs smode <scalar|vmag|vcomp|off> <fieldName> <?dataSetName?>
        Set the scaling mode: use the scalar field, vector magnitude 
        (uniform scale), vector components, or disable scaling
@@ -279 +281 @@
 pseudocolor ccolor r g b <?datasetName?>
 pseudocolor colormap <colormapName> <?datasetName?>
-pseudocolor colormode <scalar|vmag|vx|vy|vz|ccolor> <?datasetName?>
+pseudocolor colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
             Set the field used to color the object.  'ccolor' means to use
             the constant color defined by the ccolor subcommand.  'scalar' uses
@@ -302 +304 @@
 streamlines colormap <colormapName> <?datasetName?>
             Colormap used to color streamlines/tubes/ribbons by vector magnitude
-streamlines colormode <scalar|vmag|vx|vy|vz|ccolor> <?datasetName?>
+streamlines colormode <scalar|vmag|vx|vy|vz|ccolor> <fieldName> <?datasetName?>
             Set the field used to color the streamlines.  'ccolor' means to use
             the constant color defined by the ccolor subcommand.  'scalar' uses
@@ -337 +339 @@
 streamlines seed mesh data follows <nbytes> <?datasetName?>
             Use points of a mesh supplied as a VTK data file
+streamlines seed numpts <?datasetName?>
+            If seeds have been created using 'seed random' or 'seed fmesh', 
+            this command can be used to change the number of randomly 
+            distributed seeds
 streamlines seed points <?datasetName?>
             Use points of the streamlines' dataset mesh