Changeset 2533 for trunk

Timestamp:

Sep 21, 2011 9:00:24 AM (13 years ago)

Author:

ldelgass

Message:

Check VTK version defines for Glyph3DMapper, remove Makefile variable. For
choosing random streamline seed point in a cell, for cells without a specialized
implementation, default to a simplex decomposition of cell (tris or tetras) --
will work with new polyhedron cells in VTK 5.8.0.

Location:

trunk/packages/vizservers/vtkvis

Files:

• Makefile.in (modified) (2 diffs)
• RpGlyphs.h (modified) (1 diff)
• RpStreamlines.cpp (modified) (11 diffs)
• RpVtkRenderer.cpp (modified) (3 diffs)

trunk/packages/vizservers/vtkvis/Makefile.in

@@ -47 +47 @@
 DEBUG                   = #yes
 TRACE                   = #yes
-HAVE_GLYPH3D_MAPPER     = #yes
 USE_CUSTOM_AXES         = yes
 USE_GPU_RAYCASTING      = yes
@@ -61 +60 @@
 ifdef TRACE
 DEFINES         += -DWANT_TRACE
-endif
-ifdef HAVE_GLYPH3D_MAPPER
-DEFINES         += -DHAVE_GLYPH3D_MAPPER
 endif
 ifdef USE_CUSTOM_AXES

trunk/packages/vizservers/vtkvis/RpGlyphs.h

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

trunk/packages/vizservers/vtkvis/RpStreamlines.cpp

@@ -262 +262 @@
     int cell = rand() % numCells;
     int type = ds->GetCellType(cell);
-    if (type == VTK_VERTEX) {
+    switch (type) {
+    case VTK_VERTEX: {
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
         ds->GetCellPoints(cell, ptIds);
         assert(ptIds->GetNumberOfIds() == 1);
         ds->GetPoint(ptIds->GetId(0), pt);
-    } else if (type == VTK_POLY_VERTEX) {
+    }
+        break;
+    case VTK_POLY_VERTEX: {
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
         ds->GetCellPoints(cell, ptIds);
@@ -273 +276 @@
         int id = rand() % ptIds->GetNumberOfIds();
         ds->GetPoint(ptIds->GetId(id), pt);
-    } else if (type == VTK_LINE) {
+    }
+        break;
+    case VTK_LINE: {
         double v[2][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -282 +287 @@
         }
         getRandomPointOnLineSegment(pt, v[0], v[1]);
-    } else if (type == VTK_POLY_LINE) {
+    }
+        break;
+    case VTK_POLY_LINE: {
         double v[2][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -292 +299 @@
         }
         getRandomPointOnLineSegment(pt, v[0], v[1]);
-    } else if (type == VTK_TRIANGLE) {
+    }
+        break;
+    case VTK_TRIANGLE: {
         double v[3][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -301 +310 @@
         }
         getRandomPointInTriangle(pt, v[0], v[1], v[2]);
-    } else if (type == VTK_TRIANGLE_STRIP) {
+    }
+        break;
+    case VTK_TRIANGLE_STRIP: {
         double v[3][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -311 +322 @@
         }
         getRandomPointInTriangle(pt, v[0], v[1], v[2]);
-    } else if (type == VTK_POLYGON) {
+    }
+        break;
+    case VTK_POLYGON: {
         vtkPolygon *poly = vtkPolygon::SafeDownCast(ds->GetCell(cell));
         assert (poly != NULL);
@@ -323 +336 @@
         }
         getRandomPointInTriangle(pt, v[0], v[1], v[2]);
-    } else if (type == VTK_QUAD) {
+    }
+        break;
+    case VTK_QUAD: {
         double v[4][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -337 +352 @@
             getRandomPointInTriangle(pt, v[0], v[2], v[3]);
         }
-    } else if (type == VTK_TETRA) {
+    }
+        break;
+    case VTK_TETRA: {
         double v[4][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -346 +363 @@
         }
         getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[3]);
-    } else if (type == VTK_HEXAHEDRON) {
-        double v[8][3];
-        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
-        ds->GetCellPoints(cell, ptIds);
-        assert(ptIds->GetNumberOfIds() == 8);
-        for (int i = 0; i < 8; i++) {
-            ds->GetPoint(ptIds->GetId(i), v[i]);
-        }
-        int tetra = rand() % 5;
-        switch (tetra) {
-        case 0:
-            getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[5]);
-            break;
-        case 1:
-            getRandomPointInTetrahedron(pt, v[0], v[2], v[7], v[3]);
-            break;
-        case 2:
-            getRandomPointInTetrahedron(pt, v[0], v[5], v[7], v[4]);
-            break;
-        case 3:
-            getRandomPointInTetrahedron(pt, v[5], v[2], v[7], v[6]);
-            break;
-        case 4:
-        default:
-            getRandomPointInTetrahedron(pt, v[0], v[2], v[7], v[5]);
-            break;
-        }
-    } else if (type == VTK_WEDGE) {
+    }
+        break;
+    case VTK_WEDGE: {
         double v[6][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -386 +378 @@
         getRandomPointOnLineSegment(vv[2], v[2], v[5]);
         getRandomPointInTriangle(pt, vv[0], vv[1], vv[2]);
-    } else if (type == VTK_PYRAMID) {
+    }
+        break;
+    case VTK_PYRAMID: {
         double v[5][3];
         vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
@@ -400 +394 @@
             getRandomPointInTetrahedron(pt, v[0], v[2], v[3], v[4]);
         }
-    } else {
+    }
+        break;
+    case VTK_PIXEL:
+    case VTK_VOXEL: {
         double bounds[6];
         ds->GetCellBounds(cell, bounds);
-        // Note: For pixel/voxel cells, this is exact.  However, if the cell is
-        // not an axis aligned box, the point may be outside the cell
         getRandomPoint(pt, bounds);
+    }
+        break;
+    default: {
+        vtkSmartPointer<vtkIdList> ptIds = vtkSmartPointer<vtkIdList>::New();
+        vtkSmartPointer<vtkPoints> pts = vtkSmartPointer<vtkPoints>::New();
+        ds->GetCell(cell)->Triangulate(0, ptIds, pts);
+        if (ptIds->GetNumberOfIds() % 4 == 0) {
+            int tetra = rand() % (ptIds->GetNumberOfIds()/4);
+            double v[4][3];
+            for (int i = 0; i < 4; i++) {
+                ds->GetPoint(ptIds->GetId(i + tetra * 4), v[i]);
+            }
+            getRandomPointInTetrahedron(pt, v[0], v[1], v[2], v[4]);
+        } else {
+            assert(ptIds->GetNumberOfIds() % 3 == 0);
+            int tri = rand() % (ptIds->GetNumberOfIds()/3);
+            double v[3][3];
+            for (int i = 0; i < 3; i++) {
+                ds->GetPoint(ptIds->GetId(i + tri * 3), v[i]);
+            }
+            getRandomPointInTriangle(pt, v[0], v[1], v[2]);
+        }
+    }
     }
 }

trunk/packages/vizservers/vtkvis/RpVtkRenderer.cpp

@@ -40 +40 @@
 #include <vtkTextProperty.h>
 #include <vtkOpenGLRenderWindow.h>
+#include <vtkVersion.h>
 
 #include "RpVtkRenderer.h"
@@ -869 +870 @@
             double newBounds[6];
             collectBounds(newBounds, false);
+#if ((VTK_MAJOR_VERSION > 5) || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION >= 8))
+            _cubeAxesActor->SetXAxisRange(newBounds[0], newBounds[1]);
+            _cubeAxesActor->SetYAxisRange(newBounds[2], newBounds[3]);
+            _cubeAxesActor->SetZAxisRange(newBounds[4], newBounds[5]);
+#endif
             _cubeAxesActor->SetBounds(newBounds);
             TRACE("Bounds (computed): %g %g %g %g %g %g",
@@ -878 +884 @@
                   newBounds[5]);
         } else {
+#if ((VTK_MAJOR_VERSION > 5) || (VTK_MAJOR_VERSION == 5 && VTK_MINOR_VERSION >= 8))
+            _cubeAxesActor->SetXAxisRange(bounds[0], bounds[1]);
+            _cubeAxesActor->SetYAxisRange(bounds[2], bounds[3]);
+            _cubeAxesActor->SetZAxisRange(bounds[4], bounds[5]);
+#endif
             _cubeAxesActor->SetBounds(bounds);
             TRACE("Bounds (supplied): %g %g %g %g %g %g",