Changeset 2575 for trunk/packages

Timestamp:

Sep 23, 2011, 6:54:41 PM (13 years ago)

Author:

ldelgass

Message:

cutplane now controls 3 axis aligned cutplanes. Add some comments to new
classes.

Location:

trunk/packages/vizservers/vtkvis

Files:

• ReadBuffer.cpp (modified) (5 diffs)
• ReadBuffer.h (modified) (5 diffs)
• ResponseQueue.h (modified) (8 diffs)
• RpCutplane.cpp (modified) (15 diffs)
• RpCutplane.h (modified) (3 diffs)
• RpVtkRenderer.cpp (modified) (2 diffs)
• RpVtkRenderer.h (modified) (1 diff)
• RpVtkRendererCmd.cpp (modified) (3 diffs)
• protocol.txt (modified) (1 diff)

trunk/packages/vizservers/vtkvis/ReadBuffer.cpp

@@ -17 +17 @@
 using namespace Rappture::VtkVis;
 
-ReadBuffer::ReadBuffer(int f, size_t bufferSize) :
+/**
+ * \param[in] fd File descriptor to read
+ * \param[in] bufferSize Block size to use in internal buffer
+ */
+ReadBuffer::ReadBuffer(int fd, size_t bufferSize) :
     _bufferSize(bufferSize),
-    _fd(f),
+    _fd(fd),
     _lastStatus(OK)
 {
@@ -33 +37 @@
 
 /**
- * Checks if a new line is currently in the buffer.  It returns
- * the index of the character past the new line.
+ * \brief Checks if a new line is currently in the buffer.
+ *
+ * \return the index of the character past the new line.
  */
 size_t
@@ -49 +54 @@
 
 /**  
- * Fills the buffer with available data.  Any existing data in the buffer
- * is moved to the front of the buffer, then the channel is read to fill
- * the rest of the buffer.
+ * \brief Fills the buffer with available data.
+ * 
+ * Any existing data in the buffer is moved to the front of the buffer, 
+ * then the channel is read to fill the rest of the buffer.
  *
  * \return If an error occur when reading the channel, then ERROR is
@@ -98 +104 @@
 
 /**
- * Read the requested number of bytes from the buffer.  Fails if
- * the requested number of bytes are not immediately available.
- * Never should be short. 
+ * \brief Read the requested number of bytes from the buffer.
+
+ * Fails if the requested number of bytes are not immediately 
+ * available. Never should be short. 
  */
 ReadBuffer::BufferStatus
@@ -135 +142 @@
 
 /** 
- * Returns the next available line (terminated by a newline).
+ * \brief Returns the next available line (terminated by a newline)
+ * 
  * If insufficient data is in the buffer, then the channel is
  * read for more data.  If reading the channel results in a
- * short read, CONTINUE is returned and *numBytesPtr is set to
- * 0.
+ * short read, CONTINUE is returned and *numBytesPtr is set to 0.
  */
 ReadBuffer::BufferStatus

trunk/packages/vizservers/vtkvis/ReadBuffer.h

@@ -14 +14 @@
 namespace VtkVis {
 
+/**
+ * \brief Buffered input for reading socket
+ */
 class ReadBuffer
 {
@@ -24 +27 @@
     };
 
-    ReadBuffer(int f, size_t bufferSize);
+    ReadBuffer(int fd, size_t bufferSize);
 
     virtual ~ReadBuffer();
@@ -32 +35 @@
     BufferStatus followingData(unsigned char *out, size_t numBytes);
 
+    /**
+     * \brief Check if buffer contains data ending in a newline
+     * 
+     * \return bool indicating if getLine can be called without blocking 
+     */
     bool isLineAvailable()
     {
@@ -37 +45 @@
     }
 
+    /**
+     * \brief Get the file descriptor this object reads from
+     */
     int file()
     {
@@ -42 +53 @@
     }
 
+    /**
+     * \brief Get the status of the last read
+     */
     BufferStatus status()
     {

trunk/packages/vizservers/vtkvis/ResponseQueue.h

@@ -17 +17 @@
 namespace VtkVis {
 
+/**
+ * \brief Holds data for a response to be sent to client
+ */
 class Response
 {
@@ -47 +50 @@
     }
 
+    /// Get the ResponseType
     ResponseType type()
     {
@@ -52 +56 @@
     }
 
+    /// Get the Response data
     unsigned char *message()
     {
@@ -57 +62 @@
     }
 
+    /// Get the number of bytes in the Response data
     size_t length()
     {
@@ -62 +68 @@
     }
 
+    /// 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 +102 @@
 };
 
+/**
+ * \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 +115 @@
     virtual ~ResponseQueue();
 
+    /// A place to store a data pointer.  Not used internally.
+    /* XXX: This probably doesn't belong here */
     void *clientData()
     {
@@ -98 +122 @@
     }
 
+    /// Add a response to the end of the queue
     void enqueue(Response *response);
 
+    /// Remove a response from the front of the queue
     Response *dequeue();
 

trunk/packages/vizservers/vtkvis/RpCutplane.cpp

@@ -34 +34 @@
     VtkGraphicsObject(),
     _colorMode(COLOR_BY_SCALAR),
-    _colorMap(NULL),
-    _sliceAxis(Z_AXIS)
+    _colorMap(NULL)
 {
 }
@@ -79 +78 @@
 }
 
+/**
+ * \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 +114 @@
     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
+        DataSet::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 == 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->SetInput(pd);
-                _mapper->SetInputConnection(mesher->GetOutputPort());
+                mesher->SetTransform(trans);
+                _actor[1]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } 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);
+                _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
+        DataSet::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 == DataSet::PLANE_ZY) {
+                _actor[1]->VisibilityOff();
+                _actor[2]->VisibilityOff();
+            } else if (plane == DataSet::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 +285 @@
     }
 
-    initProp();
-    getActor()->SetMapper(_mapper);
-    _mapper->Update();
+    for (int i = 0; i < 3; i++) {
+        if (_mapper[i] != NULL) {
+            _actor[i]->SetMapper(_mapper[i]);
+            _mapper[i]->Update();
+        }
+    }
 }
 
@@ -274 +307 @@
     }
 
-    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;
-        }
-    } 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();
+    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;
+    }
 }
 
@@ -385 +373 @@
 {
     _colorMode = mode;
-    if (_dataSet == NULL || _mapper == NULL)
+    if (_dataSet == NULL ||
+        _mapper[0] == NULL ||
+        _mapper[1] == NULL ||
+        _mapper[2] == NULL)
         return;
 
@@ -392 +383 @@
     switch (mode) {
     case COLOR_BY_SCALAR: {
-        _mapper->ScalarVisibilityOn();
-        _mapper->SetScalarModeToDefault();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+            _mapper[i]->SetScalarModeToDefault();
+        }
         if (_lut != NULL) {
             _lut->SetRange(_dataRange);
@@ -400 +393 @@
         break;
     case COLOR_BY_VECTOR_MAGNITUDE: {
-        _mapper->ScalarVisibilityOn();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+            for (int i = 0; i < 3; i++) {
+                _mapper[i]->SetScalarModeToUsePointFieldData();
+                _mapper[i]->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]->SetScalarModeToUseCellFieldData();
+                _mapper[i]->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+            }
         }
         if (_lut != NULL) {
@@ -417 +416 @@
         break;
     case COLOR_BY_VECTOR_X:
-        _mapper->ScalarVisibilityOn();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+            for (int i = 0; i < 3; i++) {
+                _mapper[i]->SetScalarModeToUsePointFieldData();
+                _mapper[i]->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]->SetScalarModeToUseCellFieldData();
+                _mapper[i]->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+            }
         }
         if (_lut != NULL) {
@@ -434 +439 @@
         break;
     case COLOR_BY_VECTOR_Y:
-        _mapper->ScalarVisibilityOn();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+            for (int i = 0; i < 3; i++) {
+                _mapper[i]->SetScalarModeToUsePointFieldData();
+                _mapper[i]->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]->SetScalarModeToUseCellFieldData();
+                _mapper[i]->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+            }
         }
         if (_lut != NULL) {
@@ -451 +462 @@
         break;
     case COLOR_BY_VECTOR_Z:
-        _mapper->ScalarVisibilityOn();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOn();
+        }
         if (ds->GetPointData() != NULL &&
             ds->GetPointData()->GetVectors() != NULL) {
-            _mapper->SetScalarModeToUsePointFieldData();
-            _mapper->SelectColorArray(ds->GetPointData()->GetVectors()->GetName());
+            for (int i = 0; i < 3; i++) {
+                _mapper[i]->SetScalarModeToUsePointFieldData();
+                _mapper[i]->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]->SetScalarModeToUseCellFieldData();
+                _mapper[i]->SelectColorArray(ds->GetCellData()->GetVectors()->GetName());
+            }
         }
         if (_lut != NULL) {
@@ -468 +485 @@
         break;
     default:
-        _mapper->ScalarVisibilityOff();
+        for (int i = 0; i < 3; i++) {
+            _mapper[i]->ScalarVisibilityOff();
+        }
         break;
     }
@@ -493 +512 @@
     if (_lut == NULL) {
         _lut = vtkSmartPointer<vtkLookupTable>::New();
-        if (_mapper != NULL) {
-            _mapper->UseLookupTableScalarRangeOn();
-            _mapper->SetLookupTable(_lut);
+        for (int i = 0; i < 3; i++) {
+            if (_mapper[i] != NULL) {
+                _mapper[i]->UseLookupTableScalarRangeOn();
+                _mapper[i]->SetLookupTable(_lut);
+            }
         }
     }
@@ -530 +551 @@
 
 /**
+ * \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;
+    }
+}
+
+/**
  * \brief Set a group of world coordinate planes to clip rendering
  *
@@ -536 +579 @@
 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);
+        }
+    }
+}

trunk/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>
 
@@ -62 +61 @@
     void selectVolumeSlice(Axis axis, double ratio);
 
+    void setSliceVisibility(Axis axis, bool state);
+
     void setColorMode(ColorMode mode);
 
@@ -82 +83 @@
 
 private:
+    virtual void initProp();
     virtual void update();
 
     ColorMode _colorMode;
     ColorMap *_colorMap;
-    Axis _sliceAxis;
     double _vectorMagnitudeRange[2];
     double _vectorComponentRange[3][2];
 
     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];
 };
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -2776 +2776 @@
     } while (doAll && ++itr != _dataSets.end());
 
+    initCamera();
     _needsRedraw = true;
     return true;
@@ -2959 +2960 @@
     do {
         itr->second->selectVolumeSlice(axis, ratio);
+     } while (doAll && ++itr != _cutplanes.end());
+
+    _renderer->ResetCameraClippingRange();
+    _needsRedraw = true;
+}
+
+/**
+ * \brief Set the visibility of slices in one of the three axes
+ */
+void Renderer::setCutplaneSliceVisibility(const DataSetId& id, Cutplane::Axis axis, 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->setSliceVisibility(axis, state);
      } while (doAll && ++itr != _cutplanes.end());
 

trunk/packages/vizservers/vtkvis/RpVtkRenderer.h

@@ -376 +376 @@
 
     void setCutplaneVolumeSlice(const DataSetId& id, Cutplane::Axis axis, double ratio);
+
+    void setCutplaneSliceVisibility(const DataSetId& id, Cutplane::Axis axis, bool state);
 
     void setCutplaneColorMap(const DataSetId& id, const ColorMapId& colorMapId);

trunk/packages/vizservers/vtkvis/RpVtkRendererCmd.cpp

@@ -1512 +1512 @@
 
 static int
-CutplaneVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                  Tcl_Obj *const *objv)
+CutplaneSliceVisibilityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
 {
     bool state;
-    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
-        return TCL_ERROR;
-    }
-    if (objc == 4) {
-        const char *name = Tcl_GetString(objv[3]);
-        g_renderer->setCutplaneVisibility(name, state);
-    } else {
-        g_renderer->setCutplaneVisibility("all", state);
-    }
-    return TCL_OK;
-}
-
-static int
-CutplaneVolumeSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
-                      Tcl_Obj *const *objv)
-{
-    double ratio;
-    if (Tcl_GetDoubleFromObj(interp, objv[3], &ratio) != TCL_OK) {
+    if (GetBooleanFromObj(interp, objv[3], &state) != TCL_OK) {
         return TCL_ERROR;
     }
@@ -1547 +1530 @@
     } 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;
+}
+
+static int
+CutplaneVisibleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                  Tcl_Obj *const *objv)
+{
+    bool state;
+    if (GetBooleanFromObj(interp, objv[2], &state) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setCutplaneVisibility(name, state);
+    } else {
+        g_renderer->setCutplaneVisibility("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+CutplaneVolumeSliceOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    double ratio;
+    if (Tcl_GetDoubleFromObj(interp, objv[3], &ratio) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *string = Tcl_GetString(objv[2]);
+    char c = string[0];
+    Cutplane::Axis axis;
+    if ((c == 'x') && (strcmp(string, "x") == 0)) {
+        axis = Cutplane::X_AXIS;
+    } else if ((c == 'y') && (strcmp(string, "y") == 0)) {
+        axis = Cutplane::Y_AXIS;
+    } else if ((c == 'z') && (strcmp(string, "z") == 0)) {
+        axis = Cutplane::Z_AXIS;
+    } else {
+        Tcl_AppendResult(interp, "bad axis option \"", string,
                          "\": should be axisName ratio", (char*)NULL);
         return TCL_ERROR;
@@ -1577 +1608 @@
 
 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?"},

trunk/packages/vizservers/vtkvis/protocol.txt

@@ -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?>