Changeset 3877 for branches

Timestamp:

Aug 21, 2013 10:52:23 AM (11 years ago)

Author:

ldelgass

Message:

Merge from trunk

Location:

branches/1.3

Files:

• . (modified) (1 prop)
• gui/scripts/drawing.tcl (modified) (1 diff)
• gui/scripts/field.tcl (modified) (2 diffs)
• gui/scripts/vtkviewer.tcl (modified) (11 diffs)
• gui/src/RpDxToVtk.c (modified) (16 diffs)
• gui/src/RpPdbToVtk.c (modified) (8 diffs)
• packages/vizservers/nanovis/Command.cpp (modified) (4 diffs)
• packages/vizservers/nanovis/DataSetResample.cpp (copied) (copied from trunk/packages/vizservers/nanovis/DataSetResample.cpp)
• packages/vizservers/nanovis/DataSetResample.h (copied) (copied from trunk/packages/vizservers/nanovis/DataSetResample.h)
• packages/vizservers/nanovis/Makefile.in (modified) (10 diffs)
• packages/vizservers/nanovis/Shader.cpp (modified) (2 diffs)
• packages/vizservers/nanovis/Shader.h (modified) (2 diffs)
• packages/vizservers/nanovis/VelocityArrowsSlice.cpp (modified) (4 diffs)
• packages/vizservers/nanovis/VtkDataSetReader.cpp (copied) (copied from trunk/packages/vizservers/nanovis/VtkDataSetReader.cpp)
• packages/vizservers/nanovis/VtkDataSetReader.h (copied) (copied from trunk/packages/vizservers/nanovis/VtkDataSetReader.h)
• packages/vizservers/nanovis/VtkReader.cpp (modified) (1 diff)
• packages/vizservers/nanovis/config.h (modified) (1 diff)
• packages/vizservers/nanovis/dxReader.cpp (modified) (1 diff)
• packages/vizservers/nanovis/nanovis.cpp (modified) (2 diffs)
• packages/vizservers/nanovis/vrmath/include/vrmath/Vector2f.h (modified) (2 diffs)
• packages/vizservers/nanovis/vrmath/include/vrmath/Vector3f.h (modified) (6 diffs)
• packages/vizservers/nanovis/vrmath/include/vrmath/Vector4f.h (modified) (3 diffs)
• packages/vizservers/vtkvis/DataSet.cpp (modified) (1 diff)
• packages/vizservers/vtkvis/Makefile.in (modified) (3 diffs)
• packages/vizservers/vtkvis/Parallelepiped.cpp (copied) (copied from trunk/packages/vizservers/vtkvis/Parallelepiped.cpp)
• packages/vizservers/vtkvis/Parallelepiped.h (copied) (copied from trunk/packages/vizservers/vtkvis/Parallelepiped.h)
• packages/vizservers/vtkvis/RenderServer.h (modified) (1 diff)
• packages/vizservers/vtkvis/Renderer.cpp (modified) (5 diffs)
• packages/vizservers/vtkvis/Renderer.h (modified) (5 diffs)
• packages/vizservers/vtkvis/RendererCmd.cpp (modified) (3 diffs)
• packages/vizservers/vtkvis/RendererGraphicsObjs.cpp (modified) (5 diffs)
• packages/vizservers/vtkvis/Volume.cpp (modified) (5 diffs)
• packages/vizservers/vtkvis/protocol.txt (modified) (1 diff)

branches/1.3/gui/scripts/drawing.tcl

@@ -117 +117 @@
                     }
                     set contents [Rappture::PdbToVtk $pdbdata]
-                    if 0 {
+                    if 1 {
                         set f [open /tmp/convertedpdb.vtk "w"]
                         puts $f $contents

branches/1.3/gui/scripts/field.tcl

@@ -868 +868 @@
             # off to the NanoVis visualizer.
             #
-            set _viewer "nanovis"
+            set _viewer "nanovis"
             set _dim 3
-            set _type "dx"
             set _comp2dims($cname) "3D"
-            set contents [$_field get -decode no $cname.$type]
-            if { $contents == "" } {
-                puts stderr "WARNING: no data for \"$_path.$cname.$type\""
-                continue;               # Ignore this component
-            }
-            set _comp2dx($cname) $contents
             if 0 {
-                set hdr "@@RP-ENC:zb64\n"
-                set data  [$_field get -decode no $cname.$type]
-                set data "$hdr$data"
-                set data  [Rappture::encoding::decode $data]
-                set data  [Rappture::DxToVtk $data]
-                set f [open /tmp/$_path.$cname.vtk "w"]
-                puts $f $data
-                close $f
+                set vtkdata  [$_field get -decode yes $cname.$type]
+                if { $vtkdata == "" } {
+                    puts stderr "WARNING: no data for \"$_path.$cname.$type\""
+                    continue;               # Ignore this component
+                }
+                set vtkdata  [Rappture::DxToVtk $vtkdata]
+                if 0 {
+                    set f [open /tmp/$_path.$cname.vtk "w"]
+                    puts $f $vtkdata
+                    close $f
+                }
+                ReadVtkDataSet $cname $vtkdata
+                set _type "vtk"
+                set _comp2vtk($cname) $vtkdata
+            } else {
+                set contents [$_field get -decode no $cname.$type]
+                if { $contents == "" } {
+                    puts stderr "WARNING: no data for \"$_path.$cname.$type\""
+                    continue;               # Ignore this component
+                }
+                set _type "dx"
+                set _comp2dx($cname) $contents
+            }
+            set viewer [$_field get "about.view"]
+            if { $viewer != "" } {
+                set _viewer $viewer
             }
             set _comp2style($cname) [$_field get $cname.style]
@@ -1508 +1519 @@
     }
     if { ![$mesh isvalid] } {
+        puts stderr "Mesh is invalid"
         return 0
     }
     set _dim [$mesh dimensions]
+    if { $_dim == 3 } {
+        set dim 0 
+        foreach axis {x y z} {
+            foreach {min max} [$mesh limits $axis] { 
+                if { $min < $max } {
+                    incr dim
+                }
+            }
+        }
+        if { $dim  != 3 } {
+            set _dim $dim
+        }
+    }
+        
     if {$_dim == 1} {
         # 1D data: Create vectors for graph widget.

branches/1.3/gui/scripts/vtkviewer.tcl

@@ -267 +267 @@
         molecule-atomscale      0.3
         molecule-bondscale      0.075
+        molecule-bondstyle      "cylinder"
         molecule-atoms-visible  1
         molecule-bonds-visible  1
@@ -1076 +1077 @@
     }
 
-    SendCmd "dataset maprange visible"
-
     if { $_haveMolecules } {
         #FixSettings molecule-representation 
@@ -1459 +1458 @@
                     set _settings(molecule-atoms-visible) 1
                     set _settings(molecule-bonds-visible) 1
-                    set bstyle cylinder
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 0.3
                     set _settings(molecule-bondscale) 0.075
@@ -1467 +1466 @@
                     set _settings(molecule-atoms-visible) 1
                     set _settings(molecule-bonds-visible) 0
-                    set bstyle cylinder
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 0.3
                     set _settings(molecule-bondscale) 0.075
@@ -1475 +1474 @@
                     set _settings(molecule-atoms-visible) 1
                     set _settings(molecule-bonds-visible) 1
-                    set bstyle cylinder
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 0.075
                     set _settings(molecule-bondscale) 0.075
@@ -1483 +1482 @@
                     set _settings(molecule-atoms-visible) 1
                     set _settings(molecule-bonds-visible) 0
-                    set bstyle cylinder
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 1.0
                     set _settings(molecule-bondscale) 0.075
@@ -1491 +1490 @@
                     set _settings(molecule-atoms-visible) 1
                     set _settings(molecule-bonds-visible) 1
-                    set bstyle cylinder
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 0.1
                     set _settings(molecule-bondscale) 0.1
@@ -1499 +1498 @@
                     set _settings(molecule-atoms-visible) 0
                     set _settings(molecule-bonds-visible) 1
-                    set bstyle line
+                    set _settings(molecule-bondstyle) cylinder
                     set _settings(molecule-atomscale) 1.0
                     set _settings(molecule-bondscale) 1.0
@@ -1516 +1515 @@
                 }
             }
-            foreach dataset [CurrentDatasets -visible $_first] {
+            foreach dataset [CurrentDatasets -all] {
                 foreach {dataobj comp} [split $dataset -] break
                 set type [$dataobj type $comp]
@@ -1523 +1522 @@
 molecule ascale $_settings(molecule-atomscale) $dataset
 molecule bscale $_settings(molecule-bondscale) $dataset
-molecule bstyle $bstyle $dataset
+molecule bstyle $_settings(molecule-bondstyle) $dataset
 molecule atoms $_settings(molecule-atoms-visible) $dataset
 molecule bonds $_settings(molecule-bonds-visible) $dataset}]
@@ -2477 +2476 @@
         "molecule" {
             SendCmd "molecule add $tag"
+            SendCmd "molecule ascale $_settings(molecule-atomscale) $tag"
+            SendCmd "molecule bscale $_settings(molecule-bondscale) $tag"
+            SendCmd "molecule bstyle $_settings(molecule-bondstyle) $tag"
+            SendCmd "molecule atoms $_settings(molecule-atoms-visible) $tag"
+            SendCmd "molecule bonds $_settings(molecule-bonds-visible) $tag"
             set _haveMolecules 1
         }

branches/1.3/gui/src/RpDxToVtk.c

@@ -12 +12 @@
  * ======================================================================
  */
+#include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include <ctype.h>
 #include <math.h>
@@ -19 +22 @@
 #include <float.h>
 #include "tcl.h"
+
+#define DO_WEDGES
 
 static INLINE char *
@@ -109 +114 @@
 
 static int
+GetStructuredGridFieldValues(Tcl_Interp *interp, int nPoints, char **stringPtr, 
+                             const char *endPtr, Tcl_Obj *objPtr) 
+{
+    int i;
+    const char *p;
+    char mesg[2000];
+    double *array, scale, vmin, vmax;
+
+    p = *stringPtr;
+    array = malloc(sizeof(double) * nPoints);
+    if (array == NULL) {
+        return TCL_ERROR;
+    }
+    vmin = DBL_MAX, vmax = -DBL_MAX;
+    for (i = 0; i < nPoints; i++) {
+        double value;
+        char *nextPtr;
+
+        if (p >= endPtr) {
+            Tcl_AppendResult(interp, "unexpected EOF in reading points",
+                             (char *)NULL);
+            return TCL_ERROR;
+        }
+        value = strtod(p, &nextPtr);
+        if (nextPtr == p) {
+            Tcl_AppendResult(interp, "bad value found in reading points",
+                             (char *)NULL);
+            return TCL_ERROR;
+        }
+        p = nextPtr;
+        array[i] = value;
+        if (value < vmin) {
+            vmin = value;
+        } 
+        if (value > vmax) {
+            vmax = value;
+        }
+    }
+    scale = 1.0 / (vmax - vmin);
+    for (i = 0; i < nPoints; i++) {
+#ifdef notdef
+        sprintf(mesg, "%g\n", (array[i] - vmin) * scale);
+#endif
+        sprintf(mesg, "%g\n", array[i]);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+    }
+    free(array);
+    *stringPtr = (char *)p;
+    return TCL_OK;
+}
+
+static int
 GetCloudFieldValues(Tcl_Interp *interp, int nXYPoints, int nZPoints, char **stringPtr, 
                     const char *endPtr, Tcl_Obj *objPtr) 
@@ -183 +240 @@
     }
     for (i = 0; i < nXYPoints; i++) {
-        double x, y, z;
+        double x, y;
         char *nextPtr;
 
@@ -205 +262 @@
         }
         p = nextPtr;
-        z = strtod(p, &nextPtr);
+        /* z is unused */
+        strtod(p, &nextPtr);
         if (nextPtr == p) {
             Tcl_AppendResult(interp, "bad value found in reading points",
@@ -219 +277 @@
     *stringPtr = (char *)p;
     return TCL_OK;
+}
+
+static void
+Normalize(double v[3])
+{
+    double len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
+    v[0] /= len;
+    v[1] /= len;
+    v[2] /= len;
+}
+
+static double
+Dot(double v1[3], double v2[3])
+{
+    return (v1[0]*v2[0] + v1[1]*v2[1] + v1[2]*v2[2]);
+}
+
+static void
+Cross(double v1[3], double v2[3], double vout[3])
+{
+    vout[0] = v1[1]*v2[2] - v1[2]*v2[1];
+    vout[1] = v1[2]*v2[0] - v1[0]*v2[2];
+    vout[2] = v1[0]*v2[1] - v1[1]*v2[0];
 }
 
@@ -240 +321 @@
 {
     double *points;
-    Tcl_Obj *objPtr, *pointsObjPtr, *fieldObjPtr;
+    Tcl_Obj *objPtr, *pointsObjPtr, *fieldObjPtr, *cellsObjPtr;
     char *p, *pend;
     char *string;
     char mesg[2000];
+    double dv0[3], dv1[3], dv2[3];
     double dx, dy, dz;
     double origin[3];
     int count[3];
-    int length, nAxes, nPoints, nXYPoints;
+    int length, nAxes, nPoints, nXYPoints, nCells;
     char *name;
     int isUniform;
-    int i, iz;
-
-    name = "myScalars";
-    nAxes = nPoints = nXYPoints = 0;
+    int isStructuredGrid;
+    int i, ix, iy, iz;
+
+    name = "component";
+    points = NULL;
+    nAxes = nPoints = nXYPoints = nCells = 0;
     dx = dy = dz = 0.0; /* Suppress compiler warning. */
     origin[0] = origin[1] = origin[2] = 0.0; /* May not have an origin line. */
+    dv0[0] = dv0[1] = dv0[2] = 0.0;
+    dv1[0] = dv1[1] = dv1[2] = 0.0;
+    dv2[0] = dv2[1] = dv2[2] = 0.0;
     count[0] = count[1] = count[2] = 0; /* Suppress compiler warning. */
     isUniform = 1; /* Default to expecting uniform grid */
-    
+    isStructuredGrid = 0;
+
     if (objc != 2) {
         Tcl_AppendResult(interp, "wrong # arguments: should be \"",
@@ -270 +358 @@
     }
     pointsObjPtr = Tcl_NewStringObj("", -1);
+    cellsObjPtr = Tcl_NewStringObj("", -1);
     fieldObjPtr = Tcl_NewStringObj("", -1);
     for (p = string, pend = p + length; p < pend; /*empty*/) {
@@ -308 +397 @@
                 return TCL_ERROR;
             }
+            switch (nAxes) {
+            case 0:
+                dv0[0] = ddx;
+                dv0[1] = ddy;
+                dv0[2] = ddz;
+                break;
+            case 1:
+                dv1[0] = ddx;
+                dv1[1] = ddy;
+                dv1[2] = ddz;
+                break;
+            case 2:
+                dv2[0] = ddx;
+                dv2[1] = ddy;
+                dv2[2] = ddz;
+                break;
+            default:
+                break;
+            }
+
             if (ddx != 0.0) {
                 if (ddy != 0.0 || ddz != 0.0) {
-                    Tcl_AppendResult(interp, "invalid delta statement", 
-                                     (char *)NULL);
-                    return TCL_ERROR;
+                    /* Not axis aligned or skewed grid */
+                    isUniform = 0;
+                    isStructuredGrid = 1;
                 }
                 dx = ddx;
             } else if (ddy != 0.0) {
                 if (ddx != 0.0 || ddz != 0.0) {
-                    Tcl_AppendResult(interp, "invalid delta statement", 
-                                     (char *)NULL);
-                    return TCL_ERROR;
+                    /* Not axis aligned or skewed grid */
+                    isUniform = 0;
+                    isStructuredGrid = 1;
                 }
                 dy = ddy;
             } else if (ddz != 0.0) {
                 if (ddx != 0.0 || ddy != 0.0) {
-                    Tcl_AppendResult(interp, "invalid delta statement", 
-                                     (char *)NULL);
-                    return TCL_ERROR;
+                    /* Not axis aligned or skewed grid */
+                    isUniform = 0;
+                    isStructuredGrid = 1;
                 }
                 dz = ddz;
@@ -360 +469 @@
                 nPoints);
 #endif
-            if (isUniform && nPoints != count[0]*count[1]*count[2]) {
+            if ((isUniform || isStructuredGrid) &&
+                nPoints != count[0]*count[1]*count[2]) {
                 sprintf(mesg, "inconsistent data: expected %d points"
                         " but found %d points", count[0]*count[1]*count[2], 
@@ -366 +476 @@
                 Tcl_AppendResult(interp, mesg, (char *)NULL);
                 return TCL_ERROR;
-            } else if (!isUniform && nPoints != nXYPoints * count[2]) {
+            } else if (!(isUniform || isStructuredGrid) &&
+                       nPoints != nXYPoints * count[2]) {
                 sprintf(mesg, "inconsistent data: expected %d points"
                         " but found %d points", nXYPoints * count[2], 
@@ -375 +486 @@
             if (isUniform) {
                 if (GetUniformFieldValues(interp, nPoints, count, &p, pend, fieldObjPtr) 
+                    != TCL_OK) {
+                    return TCL_ERROR;
+                }
+            } else if (isStructuredGrid) {
+                if (GetStructuredGridFieldValues(interp, nPoints, &p, pend, fieldObjPtr) 
                     != TCL_OK) {
                     return TCL_ERROR;
@@ -402 +518 @@
         sprintf(mesg, "SPACING %g %g %g\n", dx, dy, dz);
         Tcl_AppendToObj(objPtr, mesg, -1);
+        sprintf(mesg, "POINT_DATA %d\n", nPoints);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        sprintf(mesg, "SCALARS %s double 1\n", name);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        sprintf(mesg, "LOOKUP_TABLE default\n");
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        Tcl_AppendObjToObj(objPtr, fieldObjPtr);
+    } else if (isStructuredGrid) {
+#ifdef notdef
+        fprintf(stderr, "dv0 %g %g %g\n", dv0[0], dv0[1], dv0[2]);
+        fprintf(stderr, "dv1 %g %g %g\n", dv1[0], dv1[1], dv1[2]);
+        fprintf(stderr, "dv2 %g %g %g\n", dv2[0], dv2[1], dv2[2]);
+#endif
+        objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
+        Tcl_AppendToObj(objPtr, "Converted from DX file\n", -1);
+        Tcl_AppendToObj(objPtr, "ASCII\n", -1);
+        Tcl_AppendToObj(objPtr, "DATASET STRUCTURED_GRID\n", -1);
+        sprintf(mesg, "DIMENSIONS %d %d %d\n", count[0], count[1], count[2]);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        for (iz = 0; iz < count[2]; iz++) {
+            for (iy = 0; iy < count[1]; iy++) {
+                for (ix = 0; ix < count[0]; ix++) {
+                    double x, y, z;
+                    x = origin[0] + dv2[0] * iz + dv1[0] * iy + dv0[0] * ix;
+                    y = origin[1] + dv2[1] * iz + dv1[1] * iy + dv0[1] * ix;
+                    z = origin[2] + dv2[2] * iz + dv1[2] * iy + dv0[2] * ix;
+                    sprintf(mesg, "%g %g %g\n", x, y, z);
+                    Tcl_AppendToObj(pointsObjPtr, mesg, -1);
+                }
+            }
+        }
+        sprintf(mesg, "POINTS %d double\n", nPoints);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        Tcl_AppendObjToObj(objPtr, pointsObjPtr);
         sprintf(mesg, "POINT_DATA %d\n", nPoints);
         Tcl_AppendToObj(objPtr, mesg, -1);
@@ -419 +569 @@
             }
         }
-        free(points);
 
         objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
@@ -428 +577 @@
         Tcl_AppendToObj(objPtr, mesg, -1);
         Tcl_AppendObjToObj(objPtr, pointsObjPtr);
+#ifdef DO_WEDGES
+        {
+            double xmin, xmax, ymin, ymax;
+            xmin = xmax = points[0];
+            ymin = ymax = points[1];
+            for (i = 1; i < nXYPoints; i++) {
+                double x, y;
+                x = points[i*2];
+                y = points[i*2+1];
+                if (x < xmin) xmin = x;
+                if (x > xmax) xmax = x;
+                if (y < ymin) ymin = y;
+                if (y > ymax) ymax = y;
+            }
+
+            char fpts[128];
+            sprintf(fpts, "/tmp/tmppts%d", getpid());
+            char fcells[128];
+            sprintf(fcells, "/tmp/tmpcells%d", getpid());
+
+            FILE *ftmp = fopen(fpts, "w");
+            // save corners of bounding box first, to work around meshing
+            // problems in voronoi utility
+            int numBoundaryPoints = 4;
+
+            // Bump out the bounds by an epsilon to avoid problem when
+            // corner points are already nodes
+            double XEPS = (xmax - xmin) / 10.0f;
+            double YEPS = (ymax - ymin) / 10.0f;
+
+            fprintf(ftmp, "%g %g\n", xmin - XEPS, ymin - YEPS);
+            fprintf(ftmp, "%g %g\n", xmax + XEPS, ymin - YEPS);
+            fprintf(ftmp, "%g %g\n", xmax + XEPS, ymax + YEPS);
+            fprintf(ftmp, "%g %g\n", xmin - XEPS, ymax + YEPS);
+
+            for (i = 0; i < nXYPoints; i++) {
+                fprintf(ftmp, "%g %g\n", points[i*2], points[i*2+1]);
+            }
+            fclose(ftmp);
+#ifdef notdef
+            double normal[3];
+            normal[0] = normal[1] = 0.0;
+            if (dx >= 0) {
+                normal[2] = 1.0;
+            } else {
+                normal[2] = -1.0;
+            }
+#endif
+            char cmdstr[512];
+            sprintf(cmdstr, "voronoi -t < %s > %s", fpts, fcells);
+            if (system(cmdstr) == 0) {
+                int c0, c1, c2;
+                ftmp = fopen(fcells, "r");
+                while (!feof(ftmp)) {
+                    if (fscanf(ftmp, "%d %d %d", &c0, &c1, &c2) == 3) {
+                        c0 -= numBoundaryPoints;
+                        c1 -= numBoundaryPoints;
+                        c2 -= numBoundaryPoints;
+                        // skip boundary points we added
+                        if (c0 >= 0 && c1 >= 0 && c2 >= 0) {
+#ifdef notdef
+                            /* Winding of base triangle should point to 
+                               outside of cell using right hand rule */
+                            double v1[3], v2[3], c[3];
+                            v1[0] = points[c1*2] - points[c0*2];
+                            v1[1] = points[c1*2+1] - points[c0*2+1];
+                            v1[2] = 0;
+                            v2[0] = points[c2*2] - points[c0*2];
+                            v2[1] = points[c2*2+1] - points[c0*2+1];
+                            v2[2] = 0;
+                            Cross(v1, v2, c);
+                            if (Dot(normal, c) > 0) {
+                                int tmp = c0;
+                                c0 = c2;
+                                c2 = tmp;
+                            }
+#endif
+                            for (iz = 0; iz < count[2] - 1; iz++) {
+                                int base = nXYPoints * iz;
+                                int top = base + nXYPoints;
+                                nCells++;
+                                sprintf(mesg, "%d %d %d %d %d %d %d\n", 6,
+                                        base + c0, base + c1, base + c2,
+                                        top + c0, top + c1, top + c2);
+                                Tcl_AppendToObj(cellsObjPtr, mesg, -1);
+                            }
+                        }
+                    } else {
+                        break;
+                    }
+                }
+                fclose(ftmp);
+             } else {
+                fprintf(stderr, "voronoi mesher failed");
+            }
+            unlink(fpts);
+            unlink(fcells);
+        }
+        free(points);
+        sprintf(mesg, "CELLS %d %d\n", nCells, 7*nCells);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        Tcl_AppendObjToObj(objPtr, cellsObjPtr);
+        sprintf(mesg, "CELL_TYPES %d\n", nCells);
+        Tcl_AppendToObj(objPtr, mesg, -1);
+        sprintf(mesg, "%d\n", 13);
+        for (i = 0; i < nCells; i++) {
+            Tcl_AppendToObj(objPtr, mesg, -1);
+        }
+#endif
         sprintf(mesg, "POINT_DATA %d\n", nPoints);
         Tcl_AppendToObj(objPtr, mesg, -1);
@@ -438 +696 @@
 
     Tcl_DecrRefCount(pointsObjPtr);
+    Tcl_DecrRefCount(cellsObjPtr);
     Tcl_DecrRefCount(fieldObjPtr);
     Tcl_SetObjResult(interp, objPtr);

branches/1.3/gui/src/RpPdbToVtk.c

@@ -1 @@
-
 
 /* 
@@ -21 +20 @@
 #include "tcl.h"
 
-
-static INLINE char *
-SkipSpaces(char *string) 
+#define BOND_NONE       (0)
+#define BOND_CONECT     (1<<0)
+#define BOND_COMPUTE    (1<<1)
+#define BOND_BOTH       (BOND_CONECT|BOND_COMPUTE)
+
+typedef struct {
+    int from, to;
+} ConnectKey;
+
+typedef struct {
+    double x, y, z;                     /* Coordinates of atom. */
+    int number;                         /* Atomic number */
+    int ordinal;                        /* Index of the atom in VTK. */
+    int numConnections;                 /*  */
+} PdbAtom;
+
+typedef struct {
+    const char *symbol;                 /* Atom symbol. */
+    float radius;                       /* Covalent radius of atom. */
+} PeriodicElement;
+
+static PeriodicElement elements[] = {
+    {    "X",       0.1f,       },      /* 0 */
+    {    "H",       0.32f,      },      /* 1 */         
+    {    "He",      0.93f,      },      /* 2 */         
+    {    "Li",      1.23f,      },      /* 3 */         
+    {    "Be",      0.90f,      },      /* 4 */         
+    {    "B",       0.82f,      },      /* 5 */         
+    {    "C",       0.77f,      },      /* 6 */         
+    {    "N",       0.75f,      },      /* 7 */         
+    {    "O",       0.73f,      },      /* 8 */         
+    {    "F",       0.72f,      },      /* 9 */         
+    {    "Ne",      0.71f,      },      /* 10 */        
+    {    "Na",      1.54f,      },      /* 11 */        
+    {    "Mg",      1.36f,      },      /* 12 */        
+    {    "Al",      1.18f,      },      /* 13 */        
+    {    "Si",      1.11f,      },      /* 14 */        
+    {    "P",       1.06f,      },      /* 15 */        
+    {    "S",       1.02f,      },      /* 16 */        
+    {    "Cl",      0.99f,      },      /* 17 */        
+    {    "Ar",      0.98f,      },      /* 18 */        
+    {    "K",       2.03f,      },      /* 19 */        
+    {    "Ca",      1.74f,      },      /* 20 */        
+    {    "Sc",      1.44f,      },      /* 21 */        
+    {    "Ti",      1.32f,      },      /* 22 */        
+    {    "V",       1.22f,      },      /* 23 */        
+    {    "Cr",      1.18f,      },      /* 24 */        
+    {    "Mn",      1.17f,      },      /* 25 */        
+    {    "Fe",      1.17f,      },      /* 26 */        
+    {    "Co",      1.16f,      },      /* 27 */        
+    {    "Ni",      1.15f,      },      /* 28 */        
+    {    "Cu",      1.17f,      },      /* 29 */        
+    {    "Zn",      1.25f,      },      /* 30 */        
+    {    "Ga",      1.26f,      },      /* 31 */        
+    {    "Ge",      1.22f,      },      /* 32 */        
+    {    "As",      1.20f,      },      /* 33 */        
+    {    "Se",      1.16f,      },      /* 34 */        
+    {    "Br",      1.14f,      },      /* 35 */        
+    {    "Kr",      1.12f,      },      /* 36 */        
+    {    "Rb",      2.16f,      },      /* 37 */        
+    {    "Sr",      1.91f,      },      /* 38 */        
+    {    "Y",       1.62f,      },      /* 39 */        
+    {    "Zr",      1.45f,      },      /* 40 */        
+    {    "Nb",      1.34f,      },      /* 41 */        
+    {    "Mo",      1.30f,      },      /* 42 */        
+    {    "Tc",      1.27f,      },      /* 43 */        
+    {    "Ru",      1.25f,      },      /* 44 */        
+    {    "Rh",      1.25f,      },      /* 45 */        
+    {    "Pd",      1.28f,      },      /* 46 */        
+    {    "Ag",      1.34f,      },      /* 47 */        
+    {    "Cd",      1.48f,      },      /* 48 */        
+    {    "In",      1.44f,      },      /* 49 */        
+    {    "Sn",      1.41f,      },      /* 50 */        
+    {    "Sb",      1.40f,      },      /* 51 */        
+    {    "Te",      1.36f,      },      /* 52 */        
+    {    "I",       1.33f,      },      /* 53 */        
+    {    "Xe",      1.31f,      },      /* 54 */        
+    {    "Cs",      2.35f,      },      /* 55 */        
+    {    "Ba",      1.98f,      },      /* 56 */        
+    {    "La",      1.69f,      },      /* 57 */        
+    {    "Ce",      1.65f,      },      /* 58 */        
+    {    "Pr",      1.65f,      },      /* 59 */        
+    {    "Nd",      1.64f,      },      /* 60 */        
+    {    "Pm",      1.63f,      },      /* 61 */        
+    {    "Sm",      1.62f,      },      /* 62 */        
+    {    "Eu",      1.85f,      },      /* 63 */        
+    {    "Gd",      1.61f,      },      /* 64 */        
+    {    "Tb",      1.59f,      },      /* 65 */        
+    {    "Dy",      1.59f,      },      /* 66 */        
+    {    "Ho",      1.58f,      },      /* 67 */        
+    {    "Er",      1.57f,      },      /* 68 */        
+    {    "Tm",      1.56f,      },      /* 69 */        
+    {    "Yb",      1.74f,      },      /* 70 */        
+    {    "Lu",      1.56f,      },      /* 71 */        
+    {    "Hf",      1.44f,      },      /* 72 */        
+    {    "Ta",      1.34f,      },      /* 73 */        
+    {    "W",       1.30f,      },      /* 74 */        
+    {    "Re",      1.28f,      },      /* 75 */        
+    {    "Os",      1.26f,      },      /* 76 */        
+    {    "Ir",      1.27f,      },      /* 77 */        
+    {    "Pt",      1.30f,      },      /* 78 */        
+    {    "Au",      1.34f,      },      /* 79 */        
+    {    "Hg",      1.49f,      },      /* 80 */        
+    {    "Tl",      1.48f,      },      /* 81 */        
+    {    "Pb",      1.47f,      },      /* 82 */        
+    {    "Bi",      1.46f,      },      /* 83 */        
+    {    "Po",      1.46f,      },      /* 84 */        
+    {    "At",      1.45f,      },      /* 85 */        
+    {    "Rn",      1.50f,      },      /* 86 */        
+    {    "Fr",      2.60f,      },      /* 87 */        
+    {    "Ra",      2.21f,      },      /* 88 */        
+    {    "Ac",      2.15f,      },      /* 89 */        
+    {    "Th",      2.06f,      },      /* 90 */        
+    {    "Pa",      2.00f,      },      /* 91 */        
+    {    "U",       1.96f,      },      /* 92 */        
+    {    "Np",      1.90f,      },      /* 93 */        
+    {    "Pu",      1.87f,      },      /* 94 */        
+    {    "Am",      1.80f,      },      /* 95 */        
+    {    "Cm",      1.69f,      },      /* 96 */        
+    {    "Bk",      0.1f,       },      /* 97 */        
+    {    "Cf",      0.1f,       },      /* 98 */        
+    {    "Es",      0.1f,       },      /* 99 */        
+    {    "Fm",      0.1f,       },      /* 100 */       
+    {    "Md",      0.1f,       },      /* 101 */       
+    {    "No",      0.1f,       },      /* 102 */       
+    {    "Lr",      0.1f,       },      /* 103 */       
+    {    "Rf",      0.1f,       },      /* 104 */       
+    {    "Db",      0.1f,       },      /* 105 */       
+    {    "Sg",      0.1f,       },      /* 106 */       
+    {    "Bh",      0.1f,       },      /* 107 */       
+    {    "Hs",      0.1f,       },      /* 108 */       
+    {    "Mt",      0.1f,       },      /* 109 */       
+    {    "Ds",      0.1f,       },      /* 110 */       
+    {    "Rg",      0.1f,       },      /* 111 */       
+    {    "Cn",      0.1f,       },      /* 112 */       
+    {    "Uut",     0.1f,       },      /* 113 */       
+    {    "Fl",      0.1f,       },      /* 114 */       
+    {    "Uup",     0.1f,       },      /* 115 */       
+    {    "Lv",      0.1f,       },      /* 116 */       
+    {    "Uus",     0.1f,       },      /* 117 */       
+    {    "Uuo",     0.1f,       }       /* 118 */       
+};
+
+static int numPeriodicElements = sizeof(elements) / sizeof(PeriodicElement);
+
+static int lineNum = 0;
+
+static const char *
+Itoa(int number) 
+{
+    static char buf[200];
+    sprintf(buf, "%d", number);
+    return buf;
+}
+
+static void
+ComputeBonds(Tcl_HashTable *atomTablePtr, Tcl_HashTable *conectTablePtr)
+{
+    PdbAtom **array;
+    int i;
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+
+#define TOLERANCE 0.45                  /* Fuzz factor for comparing distances
+                                         * (in angstroms) */
+    array = calloc(atomTablePtr->numEntries, sizeof(PdbAtom *));
+    if (array == NULL) {
+        return;
+    }
+    for (i = 0, hPtr = Tcl_FirstHashEntry(atomTablePtr, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter), i++) {
+        PdbAtom *atomPtr;
+
+        atomPtr = Tcl_GetHashValue(hPtr);
+        array[i] = atomPtr;
+    }
+    for (i = 0; i < atomTablePtr->numEntries; i++) {
+        PdbAtom *atom1Ptr;
+        double r1;
+        int j;
+
+        atom1Ptr = array[i];
+        r1 = elements[atom1Ptr->number].radius;
+        for (j = i+1; j < atomTablePtr->numEntries; j++) {
+            PdbAtom *atom2Ptr;
+            double ds2, cut;
+            double r2;
+
+            atom2Ptr  = array[j];
+            if ((atom2Ptr->number == 1) && (atom1Ptr->number == 1)) {
+                continue;
+            }
+            r2 = elements[atom2Ptr->number].radius;
+            cut = (r1 + r2 + TOLERANCE);
+            ds2 = (((atom1Ptr->x - atom2Ptr->x) * (atom1Ptr->x - atom2Ptr->x)) +
+                   ((atom1Ptr->y - atom2Ptr->y) * (atom1Ptr->y - atom2Ptr->y)) +
+                   ((atom1Ptr->z - atom2Ptr->z) * (atom1Ptr->z - atom2Ptr->z)));
+
+            // perform distance test, but ignore pairs between atoms
+            // with nearly identical coords
+            if (ds2 < 0.16) {
+                continue;
+            }
+            if (ds2 < (cut*cut)) {
+                ConnectKey key;
+                int isNew;
+
+                if (atom1Ptr->ordinal > atom2Ptr->ordinal) {
+                    key.from = atom2Ptr->ordinal;
+                    key.to = atom1Ptr->ordinal;
+                } else {
+                    key.from = atom1Ptr->ordinal;
+                    key.to = atom2Ptr->ordinal;
+                }
+                Tcl_CreateHashEntry(conectTablePtr, (char *)&key, &isNew);
+                if (isNew) {
+                    atom1Ptr->numConnections++;
+                    atom2Ptr->numConnections++;
+                }
+            }
+        }
+    }
+    free(array);
+}
+
+int 
+GetAtomicNumber(Tcl_Interp *interp, PdbAtom *atomPtr, const char *atomName, 
+                const char *symbolName, const char *residueName)
+{
+    char name[5], *namePtr;
+    int elemIndex, symbolIndex;
+    int count;
+    const char *p;
+
+    symbolIndex = elemIndex = -1;
+
+    /* 
+     * The atomic symbol may be found the atom name in various locations
+     *  "C   "
+     *  " C  "
+     *  "  C "
+     "  "   C"
+     "  "C 12"
+     "  " C12"
+     */
+    count = 0;
+    for (p = atomName; *p != '\0'; p++) {
+        if (isspace(*p) || isdigit(*p)) {
+            continue;
+        }
+        name[count] = *p;
+        count++;
+    }
+    name[count] = '\0';
+    if (count > 0) {
+        int i;
+
+        namePtr = name;
+        if (name[0] == ' ') {
+            namePtr++;
+        }
+        if (name[1] == ' ') {
+            name[1] = '\0';
+        }
+        for (i = 0; i < numPeriodicElements; i++) {
+            if (strcasecmp(namePtr, elements[i].symbol) == 0) {
+                elemIndex = i;
+                break;
+            }
+        }
+        if ((elemIndex == -1) && (count > 1)) {
+            name[1] = '\0';
+            for (i = 0; i < numPeriodicElements; i++) {
+                if (strcasecmp(namePtr, elements[i].symbol) == 0) {
+                    elemIndex = i;
+                    break;
+                }
+            }
+        }
+    }
+    name[0] = symbolName[0];
+    name[1] = symbolName[1];
+    name[2] = '\0';
+    if (isdigit(name[1])) {
+        sscanf(name, "%d", &atomPtr->number);
+        return TCL_OK;
+    }
+    if ((name[0] != ' ') || (name[1] != ' ')) {
+        int i;
+
+        namePtr = name;
+        if (name[0] == ' ') {
+            namePtr++;
+        }
+        if (name[1] == ' ') {
+            name[1] = '\0';
+        }
+        for (i = 0; i < numPeriodicElements; i++) {
+            if (strcasecmp(namePtr, elements[i].symbol) == 0) {
+                symbolIndex = i;
+                break;
+            }
+        }
+    }
+    if (symbolIndex > 0) {
+        if (elemIndex < 0) {
+            atomPtr->number = symbolIndex;
+            return TCL_OK;
+        }
+        if (symbolIndex != elemIndex) {
+            fprintf(stderr, "atomName %s and symbolName %s don't match\n",
+                    atomName, symbolName);
+            atomPtr->number = symbolIndex;
+            return TCL_OK;
+        }
+        atomPtr->number = elemIndex;
+        return TCL_OK;
+    } else if (elemIndex > 0) {
+        atomPtr->number = elemIndex;
+        return TCL_OK;
+    }
+    Tcl_AppendResult(interp, "line ", Itoa(lineNum), ": bad atom \"", 
+                     atomName, "\" or element \"", 
+                     symbolName, "\"", (char *)NULL);
+    return TCL_ERROR;
+}
+
+static PdbAtom *
+NewAtom(Tcl_Interp *interp, int ordinal, const char *line, int lineLength)
+{
+    PdbAtom *atomPtr;
+    char buf[200];
+    char atomName[6];                   /* Atom name.  */
+    char symbolName[3];                 /* Symbol name.  */
+    char residueName[4];                /* Residue name. */
+    double value;
+
+    atomPtr = calloc(1, sizeof(PdbAtom));
+    if (atomPtr == NULL) {
+        return NULL;
+    }
+    atomPtr->ordinal = ordinal;
+    strncpy(atomName, line + 12, 4);
+    atomName[4] = '\0';
+    strncpy(residueName, line + 17, 3);
+    residueName[3] = '\0';
+
+    strncpy(buf, line + 30, 8);
+    buf[8] = '\0';
+    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
+        Tcl_AppendResult(interp, "bad x-coordinate \"", buf,
+                         "\"", (char *)NULL);
+        return NULL;
+    }
+    atomPtr->x = value;
+    strncpy(buf, line + 38, 8);
+    buf[8] = '\0';
+    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
+        Tcl_AppendResult(interp, "bad y-coordinate \"", buf,
+                         "\"", (char *)NULL);
+        return NULL;
+    }
+    atomPtr->y = value;
+    strncpy(buf, line + 46, 8);
+    buf[8] = '\0';
+    if (Tcl_GetDouble(interp, buf, &value) != TCL_OK) {
+        Tcl_AppendResult(interp, "bad z-coordinate \"", buf,
+                         "\"", (char *)NULL);
+        return NULL;
+    }
+    atomPtr->z = value;
+    symbolName[2] = symbolName[1]  = symbolName[0] = '\0';
+    if (lineLength >= 77) {
+        symbolName[0] = line[76];
+        symbolName[1] = line[77];
+        symbolName[2] = '\0';
+    }
+    if (GetAtomicNumber(interp, atomPtr, atomName, symbolName, residueName) 
+        != TCL_OK) {
+        return NULL;
+    }
+    return atomPtr;
+}
+
+static void
+FreeAtoms(Tcl_HashTable *tablePtr)
+{
+    Tcl_HashEntry *hPtr;
+    Tcl_HashSearch iter;
+
+    for (hPtr = Tcl_FirstHashEntry(tablePtr, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter)) {
+        PdbAtom *atomPtr;
+        
+        atomPtr = Tcl_GetHashValue(hPtr);
+        free(atomPtr);
+    }
+    Tcl_DeleteHashTable(tablePtr);
+}
+
+
+static INLINE const char *
+SkipSpaces(const char *string) 
 {
     while (isspace(*string)) {
@@ -31 +430 @@
 }
 
-static INLINE char *
-GetLine(char **stringPtr, const char *endPtr, int *lengthPtr) 
-{
-    char *line, *p;
+static int
+IsSpaces(const char *string) 
+{
+    const char *p;
+    for (p = string; *p != '\0'; p++) {
+        if (!isspace(*p)) {
+            return 0;
+        }
+    }
+    return 1;
+}
+
+static INLINE const char *
+GetLine(const char **stringPtr, const char *endPtr, int *lengthPtr) 
+{
+    const char *line;
+    const char *p;
 
     line = SkipSpaces(*stringPtr);
@@ -44 +456 @@
         }
     }
+    *lengthPtr = (p - line) - 1;
     *stringPtr = p;
     return line;
 }
 
-static const char *elemNames[] = {
-    "Hydrogen",                         /* 1 */         
-    "Helium",                           /* 2 */         
-    "Lithium",                          /* 3 */         
-    "Beryllium",                        /* 4 */         
-    "Boron",                            /* 5 */         
-    "Carbon",                           /* 6 */         
-    "Nitrogen",                         /* 7 */         
-    "Oxygen",                           /* 8 */         
-    "Fluorine",                         /* 9 */         
-    "Neon",                             /* 10 */        
-    "Sodium",                           /* 11 */        
-    "Magnesium",                        /* 12 */        
-    "Aluminium",                        /* 13 */        
-    "Silicon",                          /* 14 */        
-    "Phosphorus",                       /* 15 */        
-    "Sulfur",                           /* 16 */        
-    "Chlorine",                         /* 17 */        
-    "Argon",                            /* 18 */        
-    "Potassium",                        /* 19 */        
-    "Calcium",                          /* 20 */        
-    "Scandium",                         /* 21 */        
-    "Titanium",                         /* 22 */        
-    "Vanadium",                         /* 23 */        
-    "Chromium",                         /* 24 */        
-    "Manganese",                        /* 25 */        
-    "Iron",                             /* 26 */        
-    "Cobalt",                           /* 27 */        
-    "Nickel",                           /* 28 */        
-    "Copper",                           /* 29 */        
-    "Zinc",                             /* 30 */        
-    "Gallium",                          /* 31 */        
-    "Germanium",                /* 32 */        
-    "Arsenic",          /* 33 */        
-    "Selenium",         /* 34 */        
-    "Bromine",          /* 35 */        
-    "Krypton",          /* 36 */        
-    "Rubidium",         /* 37 */        
-    "Strontium",                /* 38 */        
-    "Yttrium",          /* 39 */        
-    "Zirconium",                /* 40 */        
-    "Niobium",          /* 41 */        
-    "Molybdenum",               /* 42 */        
-    "Technetium",               /* 43 */        
-    "Ruthenium",                /* 44 */        
-    "Rhodium",          /* 45 */        
-    "Palladium",                /* 46 */        
-    "Silver",           /* 47 */        
-    "Cadmium",          /* 48 */        
-    "Indium",           /* 49 */        
-    "Tin",                      /* 50 */        
-    "Antimony",         /* 51 */        
-    "Tellurium",                /* 52 */        
-    "Iodine",           /* 53 */        
-    "Xenon",            /* 54 */        
-    "Cesium",           /* 55 */        
-    "Barium",           /* 56 */        
-    "Lanthanum",                /* 57 */        
-    "Cerium",           /* 58 */        
-    "Praseodymium",             /* 59 */        
-    "Neodymium",                /* 60 */        
-    "Promethium",               /* 61 */        
-    "Samarium",         /* 62 */        
-    "Europium",         /* 63 */        
-    "Gadolinium",               /* 64 */        
-    "Terbium",          /* 65 */        
-    "Dysprosium",               /* 66 */        
-    "Holmium",          /* 67 */        
-    "Erbium",           /* 68 */        
-    "Thulium",          /* 69 */        
-    "Ytterbium",                /* 70 */        
-    "Lutetium",         /* 71 */        
-    "Hafnium",          /* 72 */        
-    "Tantalum",         /* 73 */        
-    "Tungsten",         /* 74 */        
-    "Rhenium",          /* 75 */        
-    "Osmium",           /* 76 */        
-    "Iridium",          /* 77 */        
-    "Platinum",         /* 78 */        
-    "Gold",                     /* 79 */        
-    "Mercury",          /* 80 */        
-    "Thallium",         /* 81 */        
-    "Lead",                     /* 82 */        
-    "Bismuth",          /* 83 */        
-    "Polonium",         /* 84 */        
-    "Astatine",         /* 85 */        
-    "Radon",            /* 86 */        
-    "Francium",         /* 87 */        
-    "Radium",           /* 88 */        
-    "Actinium",         /* 89 */        
-    "Thorium",          /* 90 */        
-    "Protactinium",             /* 91 */        
-    "Uranium",          /* 92 */        
-    "Neptunium",                /* 93 */        
-    "Plutonium",                /* 94 */        
-    "Americium",                /* 95 */        
-    "Curium",           /* 96 */        
-    "Berkelium",                /* 97 */        
-    "Californium",              /* 98 */        
-    "Einsteinium",              /* 99 */        
-    "Fermium",          /* 100 */       
-    "Mendelevium",              /* 101 */       
-    "Nobelium",         /* 102 */       
-    "Lawrencium",               /* 103 */       
-    "Rutherfordium",    /* 104 */       
-    "Dubnium",          /* 105 */       
-    "Seaborgium",               /* 106 */       
-    "Bohrium",          /* 107 */       
-    "Hassium",          /* 108 */       
-    "Meitnerium",               /* 109 */       
-    "Darmstadtium",             /* 110 */       
-    "Roentgenium",              /* 111 */       
-    "Copernicium",              /* 112 */       
-    "Ununtrium",                /* 113 */       
-    "Flerovium",                /* 114 */       
-    "Ununpentium",              /* 115 */       
-    "Livermorium",              /* 116 */       
-    "Ununseptium",              /* 117 */       
-    "Ununoctium",               /* 118 */       
-    NULL
-};
-
-static const char *symbolNames[] = {
-    "H",                        /* 1 */         
-    "He",                       /* 2 */         
-    "Li",                       /* 3 */         
-    "Be",                       /* 4 */         
-    "B",                        /* 5 */         
-    "C",                        /* 6 */         
-    "N",                        /* 7 */         
-    "O",                        /* 8 */         
-    "F",                        /* 9 */         
-    "Ne",                       /* 10 */        
-    "Na",                       /* 11 */        
-    "Mg",                       /* 12 */        
-    "Al",                       /* 13 */        
-    "Si",                       /* 14 */        
-    "P",                        /* 15 */        
-    "S",                        /* 16 */        
-    "Cl",                       /* 17 */        
-    "Ar",                       /* 18 */        
-    "K",                        /* 19 */        
-    "Ca",                       /* 20 */        
-    "Sc",                       /* 21 */        
-    "Ti",                       /* 22 */        
-    "V",                        /* 23 */        
-    "Cr",                       /* 24 */        
-    "Mn",                       /* 25 */        
-    "Fe",                       /* 26 */        
-    "Co",                       /* 27 */        
-    "Ni",                       /* 28 */        
-    "Cu",                       /* 29 */        
-    "Zn",                       /* 30 */        
-    "Ga",                       /* 31 */        
-    "Ge",                       /* 32 */        
-    "As",                       /* 33 */        
-    "Se",                       /* 34 */        
-    "Br",                       /* 35 */        
-    "Kr",                       /* 36 */        
-    "Rb",                       /* 37 */        
-    "Sr",                       /* 38 */        
-    "Y",                        /* 39 */        
-    "Zr",                       /* 40 */        
-    "Nb",                       /* 41 */        
-    "Mo",                       /* 42 */        
-    "Tc",                       /* 43 */        
-    "Ru",                       /* 44 */        
-    "Rh",                       /* 45 */        
-    "Pd",                       /* 46 */        
-    "Ag",                       /* 47 */        
-    "Cd",                       /* 48 */        
-    "In",                       /* 49 */        
-    "Sn",                       /* 50 */        
-    "Sb",                       /* 51 */        
-    "Te",                       /* 52 */        
-    "I",                        /* 53 */        
-    "Xe",                       /* 54 */        
-    "Cs",                       /* 55 */        
-    "Ba",                       /* 56 */        
-    "La",                       /* 57 */        
-    "Ce",                       /* 58 */        
-    "Pr",                       /* 59 */        
-    "Nd",                       /* 60 */        
-    "Pm",                       /* 61 */        
-    "Sm",                       /* 62 */        
-    "Eu",                       /* 63 */        
-    "Gd",                       /* 64 */        
-    "Tb",                       /* 65 */        
-    "Dy",                       /* 66 */        
-    "Ho",                       /* 67 */        
-    "Er",                       /* 68 */        
-    "Tm",                       /* 69 */        
-    "Yb",                       /* 70 */        
-    "Lu",                       /* 71 */        
-    "Hf",                       /* 72 */        
-    "Ta",                       /* 73 */        
-    "W",                        /* 74 */        
-    "Re",                       /* 75 */        
-    "Os",                       /* 76 */        
-    "Ir",                       /* 77 */        
-    "Pt",                       /* 78 */        
-    "Au",                       /* 79 */        
-    "Hg",                       /* 80 */        
-    "Tl",                       /* 81 */        
-    "Pb",                       /* 82 */        
-    "Bi",                       /* 83 */        
-    "Po",                       /* 84 */        
-    "At",                       /* 85 */        
-    "Rn",                       /* 86 */        
-    "Fr",                       /* 87 */        
-    "Ra",                       /* 88 */        
-    "Ac",                       /* 89 */        
-    "Th",                       /* 90 */        
-    "Pa",                       /* 91 */        
-    "U",                        /* 92 */        
-    "Np",                       /* 93 */        
-    "Pu",                       /* 94 */        
-    "Am",                       /* 95 */        
-    "Cm",                       /* 96 */        
-    "Bk",                       /* 97 */        
-    "Cf",                       /* 98 */        
-    "Es",                       /* 99 */        
-    "Fm",                       /* 100 */       
-    "Md",                       /* 101 */       
-    "No",                       /* 102 */       
-    "Lr",                       /* 103 */       
-    "Rf",                       /* 104 */       
-    "Db",                       /* 105 */       
-    "Sg",                       /* 106 */       
-    "Bh",                       /* 107 */       
-    "Hs",                       /* 108 */       
-    "Mt",                       /* 109 */       
-    "Ds",                       /* 110 */       
-    "Rg",                       /* 111 */       
-    "Cn",                       /* 112 */       
-    "Uut",                      /* 113 */       
-    "Fl",                       /* 114 */       
-    "Uup",                      /* 115 */       
-    "Lv",                       /* 116 */       
-    "Uus",                      /* 117 */       
-    "Uuo",                      /* 118 */       
-    NULL
-};
-
-int 
-VerifyElement(const char *elemName, const char *symbolName)
-{
-    const char **p;
-    int elemIndex, symbolIndex;
-
-    symbolIndex = elemIndex = -1;
-    elemName = SkipSpaces(elemName);
-    for (p = symbolNames; *p != NULL; p++) {
-        if (strcasecmp(elemName, *p) == 0) {
-            elemIndex = (p - symbolNames) + 1;
-            break;
-        }
-    }
-    symbolName = SkipSpaces(symbolName);
-    for (p = symbolNames; *p != NULL; p++) {
-        if (strcasecmp(symbolName, *p) == 0) {
-            symbolIndex = (p - symbolNames) + 1;
-            break;
-        }
-    }
-    if (symbolIndex > 0) {
-        if (elemIndex < 0) {
-            return symbolIndex;
-        }
-        if (symbolIndex != elemIndex) {
-            return -1;
-        }
-        return elemIndex;
-    } else if (elemIndex > 0) {
-        return elemIndex;
-    }
-    return -1;
+
+static int 
+SerialToAtom(Tcl_Interp *interp, Tcl_HashTable *tablePtr, const char *string,
+                PdbAtom **atomPtrPtr)
+{
+    int serial;
+    long lserial;
+    Tcl_HashEntry *hPtr;
+
+    string = SkipSpaces(string);
+    if (Tcl_GetInt(interp, string, &serial) != TCL_OK) {
+        Tcl_AppendResult(interp, ": line ", Itoa(lineNum), 
+                ": invalid serial number \"", string, 
+                "\" in CONECT record", (char *)NULL);
+        return TCL_ERROR;
+    }
+    lserial = (long)serial;
+    hPtr = Tcl_FindHashEntry(tablePtr, (char *)lserial);
+    if (hPtr == NULL) {
+        Tcl_AppendResult(interp, "serial number \"", string, 
+                         "\" not found in table", (char *)NULL);
+        return TCL_ERROR;
+    }
+    *atomPtrPtr = Tcl_GetHashValue(hPtr);
+    return TCL_OK;
 }
 
 /* 
- *  PdbToVtk string
+ *  PdbToVtk string ?-bonds none|both|auto|conect?
  */
-
 static int
 PdbToVtkCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
            Tcl_Obj *const *objv) 
 {
-    Tcl_Obj *objPtr, *pointsObjPtr, *atomsObjPtr, *verticesObjPtr;
-    char *p, *pend;
-    char *string;
+    Tcl_Obj *objPtr, *pointsObjPtr, *atomsObjPtr;
+    const char *p, *pend;
+    const char *string;
     char mesg[2000];
-    int length, numAtoms, numConnections;
-    Tcl_HashTable serialTable;
-    int i;
+    int length, nextOrdinal;
+    Tcl_HashTable atomTable, conectTable;
     Tcl_HashEntry *hPtr;
     Tcl_HashSearch iter;
     int isNew;
-
-    numConnections = numAtoms = 0;
-    if (objc != 2) {
+    int bondFlags;
+
+    bondFlags = BOND_BOTH;
+    lineNum = nextOrdinal = 0;
+    if ((objc != 2) && (objc != 4)) {
         Tcl_AppendResult(interp, "wrong # arguments: should be \"",
-                         Tcl_GetString(objv[0]), " string\"", (char *)NULL);
+                Tcl_GetString(objv[0]), 
+                " string ?-bonds none|both|auto|conect\"", (char *)NULL);
         return TCL_ERROR;
     }
-    Tcl_InitHashTable(&serialTable, TCL_ONE_WORD_KEYS);
+    if (objc == 4) {
+        const char *string;
+        char c;
+
+        string = Tcl_GetString(objv[2]);
+        if ((string[0] != '-') || (strcmp(string, "-bonds") != 0)) {
+            Tcl_AppendResult(interp, "bad switch \"", string, 
+                             "\": should be \"-bonds\"", (char *)NULL);
+            return TCL_ERROR;
+        }
+        string = Tcl_GetString(objv[3]);
+        c = string[0];
+        if ((c == 'n') && (strcmp(string, "none") == 0)) {
+            bondFlags = BOND_NONE;
+        } else if ((c == 'b') && (strcmp(string, "both") == 0)) {
+            bondFlags = BOND_BOTH;
+        } else if ((c == 'a') && (strcmp(string, "auto") == 0)) {
+            bondFlags = BOND_COMPUTE;
+        } else if ((c == 'c') && (strcmp(string, "conect") == 0)) {
+            bondFlags = BOND_CONECT;
+        } else {
+            Tcl_AppendResult(interp, "bad value \"", string, 
+                "\" for -bonds switch: should be none, both, manual, or auto",
+                (char *)NULL);
+            return TCL_ERROR;
+        }
+    }
+    Tcl_InitHashTable(&atomTable, TCL_ONE_WORD_KEYS);
+    Tcl_InitHashTable(&conectTable, sizeof(ConnectKey) / sizeof(int));
     string = Tcl_GetStringFromObj(objv[1], &length);
     pointsObjPtr = Tcl_NewStringObj("", -1);
     atomsObjPtr = Tcl_NewStringObj("", -1);
-    verticesObjPtr = Tcl_NewStringObj("", -1);
     Tcl_IncrRefCount(pointsObjPtr);
     Tcl_IncrRefCount(atomsObjPtr);
-    Tcl_IncrRefCount(verticesObjPtr);
     objPtr = NULL;
     for (p = string, pend = p + length; p < pend; /*empty*/) {
-        char *line, *q;
+        const char *line;
         char c;
         int lineLength;
 
+        lineLength = 0;                 /* Suppress compiler warning. */
+        lineNum++;
         line = GetLine(&p, pend, &lineLength);
         if (line >= pend) {
@@ -374 +564 @@
         }
         c = line[0];
-        
         if (((c == 'A') && (strncmp(line, "ATOM  ", 6) == 0)) ||
             ((c == 'H') && (strncmp(line, "HETATM", 6) == 0))) {
             char buf[200];
-            char atomName[6];
-            char symbolName[3];
-            int serial;
-            double x, y, z;
-            int atom;
+            int serialNum;
+            long lserial;
+            PdbAtom *atomPtr;
 
             if (lineLength < 47) {
-                Tcl_AppendResult(interp, "short ATOM line \"", line, "\"", 
-                        (char *)NULL);
-                goto error;
+                char *msg;
+
+                msg = (char *)line;
+                msg[lineLength] = '\0';
+                Tcl_AppendResult(interp, "line ", Itoa(lineNum), 
+                        " short ATOM line \"", line, "\"", (char *)NULL);
+                return TCL_ERROR;
             }           
             strncpy(buf, line + 6, 5);
             buf[5] = '\0';
-            if (Tcl_GetInt(interp, buf, &serial) != TCL_OK) {
-                Tcl_AppendResult(interp, "bad serial number \"", buf,
-                                 "\"", (char *)NULL);
+            if (Tcl_GetInt(interp, buf, &serialNum) != TCL_OK) {
+                Tcl_AppendResult(interp, "line ", Itoa(lineNum), 
+                        ": bad serial number \"", buf, "\"", (char *)NULL);
                 goto error;
             }
-            hPtr = Tcl_CreateHashEntry(&serialTable, (char *)serial, &isNew);
+            lserial = (long)serialNum;
+            hPtr = Tcl_CreateHashEntry(&atomTable, (char *)lserial, &isNew);
             if (!isNew) {
-                Tcl_AppendResult(interp, "serial number \"", buf,
-                                 "\" found more than once", (char *)NULL);
+                Tcl_AppendResult(interp, "line ", Itoa(lineNum), 
+                        ": serial number \"", buf, "\" found more than once", 
+                        (char *)NULL);
                 goto error;
             }
-            Tcl_SetHashValue(hPtr, numAtoms);
-            Tcl_ListObjAppendElement(interp, verticesObjPtr, 
-                                     Tcl_NewIntObj(1));
-            Tcl_ListObjAppendElement(interp, verticesObjPtr, 
-                                     Tcl_NewIntObj(serial));
-
-            strncpy(atomName, line + 12, 4);
-            atomName[4] = '\0';
-            
-            strncpy(buf, line + 30, 8);
-            buf[8] = '\0';
-            if (Tcl_GetDouble(interp, buf, &x) != TCL_OK) {
-                Tcl_AppendResult(interp, "bad x-coordinate \"", buf,
-                                 "\"", (char *)NULL);
+            atomPtr = NewAtom(interp, nextOrdinal, line, lineLength);
+            if (atomPtr == NULL) {
                 goto error;
             }
-            Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(x));
-            strncpy(buf, line + 38, 8);
-            buf[8] = '\0';
-            if (Tcl_GetDouble(interp, buf, &y) != TCL_OK) {
-                Tcl_AppendResult(interp, "bad y-coordinate \"", buf,
-                                 "\"", (char *)NULL);
+            Tcl_SetHashValue(hPtr, atomPtr);
+            Tcl_ListObjAppendElement(interp, pointsObjPtr, 
+                                     Tcl_NewDoubleObj(atomPtr->x));
+            Tcl_ListObjAppendElement(interp, pointsObjPtr, 
+                                     Tcl_NewDoubleObj(atomPtr->y));
+            Tcl_ListObjAppendElement(interp, pointsObjPtr, 
+                                     Tcl_NewDoubleObj(atomPtr->z));
+            Tcl_ListObjAppendElement(interp, atomsObjPtr, 
+                                     Tcl_NewIntObj(atomPtr->number));
+            nextOrdinal++;
+        } else if ((c == 'C') && (strncmp(line, "CONECT", 6) == 0)) {
+            PdbAtom *atom1Ptr;
+            int i, n;
+            char buf[200];
+
+            if ((bondFlags & BOND_CONECT) == 0) {
+                continue;
+            }
+            strncpy(buf, line + 6, 5);
+            buf[5] = '\0';
+            if (lineLength < 11) {
+                char *msg;
+
+                msg = (char *)line;
+                msg[lineLength] = '\0';
+                Tcl_AppendResult(interp, "line ", Itoa(lineNum), 
+                        ": bad CONECT record \"", msg, "\"",
+                        (char *)NULL);
                 goto error;
             }
-            Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(y));
-            strncpy(buf, line + 46, 8);
-            buf[8] = '\0';
-            if (Tcl_GetDouble(interp, buf, &z) != TCL_OK) {
-                Tcl_AppendResult(interp, "bad z-coordinate \"", buf,
-                                 "\"", (char *)NULL);
+            if (SerialToAtom(interp, &atomTable, buf, &atom1Ptr) != TCL_OK) {
                 goto error;
             }
-            Tcl_ListObjAppendElement(interp, pointsObjPtr, Tcl_NewDoubleObj(z));
-            symbolName[0] = '\0';
-            if (lineLength >= 78) {
-                symbolName[0] = line[76];
-                symbolName[1] = line[77];
-                symbolName[2] = '\0';
-            }
-            atom = VerifyElement(SkipSpaces(atomName), SkipSpaces(symbolName));
-            if (atom < 0) {
-                Tcl_AppendResult(interp, "bad atom \"", atomName, 
-                        "\" or element \"", symbolName, "\"", (char *)NULL);
-                goto error;
-            }
-            Tcl_ListObjAppendElement(interp, atomsObjPtr, Tcl_NewIntObj(atom));
-            numAtoms++;
-        } else if ((c == 'C') && (strncmp(line, "CONECT", 6) == 0)) {
-            numConnections++;
-        }
+            /* Allow basic maximum of 4 connections. */
+            for (n = 11, i = 0; i < 4; i++, n += 5) {
+                ConnectKey key;
+                PdbAtom *atom2Ptr;
+
+                if (n >= lineLength) {
+                    break;              
+                }
+                strncpy(buf, line + n, 5);
+                buf[5] = '\0';
+                if (IsSpaces(buf)) {
+                    break;              /* No more entries */
+                }
+                if (SerialToAtom(interp, &atomTable, buf, &atom2Ptr) !=TCL_OK) {
+                    goto error;
+                }
+                if (atom1Ptr->ordinal > atom2Ptr->ordinal) {
+                    key.from = atom2Ptr->ordinal;
+                    key.to = atom1Ptr->ordinal;
+                } else {
+                    key.from = atom1Ptr->ordinal;
+                    key.to = atom2Ptr->ordinal;
+                }
+                Tcl_CreateHashEntry(&conectTable, (char *)&key, &isNew);
+                if (isNew) {
+                    atom1Ptr->numConnections++;
+                    atom2Ptr->numConnections++;
+                }
+            }
+        }
+    }
+    if (bondFlags & BOND_COMPUTE) {
+        ComputeBonds(&atomTable, &conectTable);
     }
     objPtr = Tcl_NewStringObj("# vtk DataFile Version 2.0\n", -1);
-    Tcl_AppendToObj(objPtr, "Converted from PDB file\n", -1);
+    Tcl_AppendToObj(objPtr, "Converted from PDB format\n", -1);
     Tcl_AppendToObj(objPtr, "ASCII\n", -1);
     Tcl_AppendToObj(objPtr, "DATASET POLYDATA\n", -1);
-    sprintf(mesg, "POINTS %d float\n", numAtoms);
+    sprintf(mesg, "POINTS %d float\n", atomTable.numEntries);
     Tcl_AppendToObj(objPtr, mesg, -1);
     Tcl_AppendObjToObj(objPtr, pointsObjPtr);
@@ -463 +676 @@
     Tcl_AppendToObj(objPtr, mesg, -1);
 
-#ifdef notdef
-    if (numConnections > 0) {
-        sprintf(mesg, "LINES %d %d\n", numConnections, numConnections * 3);
+    if (conectTable.numEntries > 0) {
+        sprintf(mesg, "LINES %d %d\n", conectTable.numEntries, 
+                conectTable.numEntries * 3);
         Tcl_AppendToObj(objPtr, mesg, -1);
-        for (hPtr = Tcl_FirstHashEntry(&connectTable, &iter); hPtr != NULL;
+        for (hPtr = Tcl_FirstHashEntry(&conectTable, &iter); hPtr != NULL;
              hPtr = Tcl_NextHashEntry(&iter)) {
-            connectPtr = Tcl_GetHashEntry(hPtr);
-            sprintf(mesg, "2 %d %d\n", connectPtr->from, connectPtr->to);
-        }
-    }
-    Tcl_AppendObjToObj(objPtr, linesObjPtr);
-    sprintf(mesg, "\n");
-    Tcl_AppendToObj(objPtr, mesg, -1);
-#endif
-    
-    sprintf(mesg, "VERTICES %d %d\n", numAtoms, numAtoms * 2);
-    Tcl_AppendToObj(objPtr, mesg, -1);
-    for (i = 0; i < numAtoms; i++) {
-        sprintf(mesg, " 1 %d\n", i);
+            ConnectKey *keyPtr;
+
+            keyPtr = (ConnectKey *)Tcl_GetHashKey(&conectTable, hPtr);
+            sprintf(mesg, "2 %d %d\n", keyPtr->from, keyPtr->to);
+            Tcl_AppendToObj(objPtr, mesg, -1);
+        }
+        sprintf(mesg, "\n");
         Tcl_AppendToObj(objPtr, mesg, -1);
     }
-    sprintf(mesg, "POINT_DATA %d\n", numAtoms);
+    for (hPtr = Tcl_FirstHashEntry(&atomTable, &iter); hPtr != NULL;
+         hPtr = Tcl_NextHashEntry(&iter)) {
+        PdbAtom *atomPtr;
+
+        atomPtr = Tcl_GetHashValue(hPtr);
+        fprintf(stderr, "%d %s %d connections\n", atomPtr->ordinal,
+                elements[atomPtr->number].symbol, atomPtr->numConnections);
+    }
+    sprintf(mesg, "POINT_DATA %d\n", atomTable.numEntries);
     Tcl_AppendToObj(objPtr, mesg, -1);
     sprintf(mesg, "SCALARS element int\n");
@@ -491 +706 @@
     Tcl_AppendToObj(objPtr, mesg, -1);
     Tcl_AppendObjToObj(objPtr, atomsObjPtr);
-    Tcl_DeleteHashTable(&serialTable);
+    FreeAtoms(&atomTable);
+    Tcl_DeleteHashTable(&conectTable);
     Tcl_DecrRefCount(pointsObjPtr);
     Tcl_DecrRefCount(atomsObjPtr);
-    Tcl_DecrRefCount(verticesObjPtr);
     if (objPtr != NULL) {
         Tcl_SetObjResult(interp, objPtr);
@@ -500 +715 @@
     return TCL_OK;
  error:
-    Tcl_DeleteHashTable(&serialTable);
+    Tcl_DeleteHashTable(&conectTable);
+    FreeAtoms(&atomTable);
     Tcl_DecrRefCount(pointsObjPtr);
     Tcl_DecrRefCount(atomsObjPtr);
-    Tcl_DecrRefCount(verticesObjPtr);
     return TCL_ERROR;
 }

branches/1.3/packages/vizservers/nanovis/Command.cpp

@@ -55 +55 @@
 #include "FlowCmd.h"
 #include "dxReader.h"
+#ifdef USE_VTK
+#include "VtkDataSetReader.h"
+#endif
 #include "VtkReader.h"
 #include "BMPWriter.h"
@@ -1273 +1276 @@
     } else if ((nBytes > 14) && (strncmp(bytes, "# vtk DataFile", 14) == 0)) {
         TRACE("VTK loading...");
-        std::stringstream fdata;
-        fdata.write(bytes, nBytes);
         if (nBytes <= 0) {
             ERROR("data buffer is empty");
@@ -1280 +1281 @@
         }
         Rappture::Outcome context;
+#ifdef USE_VTK
+        volume = load_vtk_volume_stream(context, tag, bytes, nBytes);
+#else
+        std::stringstream fdata;
+        fdata.write(bytes, nBytes);
         volume = load_vtk_volume_stream(context, tag, fdata);
+#endif
         if (volume == NULL) {
             Tcl_AppendResult(interp, context.remark(), (char*)NULL);
@@ -1292 +1299 @@
         }
         TRACE("DX loading...");
-        std::stringstream fdata;
-        fdata.write(bytes, nBytes);
         if (nBytes <= 0) {
             ERROR("data buffer is empty");
             abort();
         }
+        std::stringstream fdata;
+        fdata.write(bytes, nBytes);
         Rappture::Outcome context;
         volume = load_dx_volume_stream(context, tag, fdata);

branches/1.3/packages/vizservers/nanovis/Makefile.in

@@ -3 +3 @@
 USE_POINTSET_RENDERER   = #yes
 USE_PARTICLE_SYSTEM     = #yes
+USE_VTK                 = yes
 
 SHELL = /bin/sh
@@ -53 +54 @@
 VRMATH_LIB_SPEC = $(VRMATH_LIB)
 
+VTK_LIB_DIR     = @VTK_LIB_DIR@
+VTK_INC_SPEC    = @VTK_INC_SPEC@
+VTK_LIB_SPEC    = \
+                -lvtkIOCore-6.0 \
+                -lvtkIOLegacy-6.0 \
+                -lvtkFiltersCore-6.0 \
+                -lvtkImagingHybrid-6.0 \
+                -lvtkImagingCore-6.0 \
+                -lvtkCommonCore-6.0 \
+                -lvtkCommonDataModel-6.0 \
+                -lvtkCommonExecutionModel-6.0  \
+                -lvtkCommonMisc-6.0  \
+                -lvtkCommonSystem-6.0 \
+                -lvtkCommonTransforms-6.0 \
+                -lvtkCommonMath-6.0
+
 EXTRA_LIBS      = -lm -lpthread
 RP_DIR          =  @RP_DIR@
@@ -73 +90 @@
                 $(UTIL_LIB_SPEC) \
                 $(VRMATH_LIB_SPEC) \
+                $(VTK_LIB_SPEC) \
                 $(TCL_LIB_SPEC) \
                 $(CG_LIB_SPEC) \
@@ -85 +103 @@
                 $(MAT_INC_SPEC) \
                 $(VRMATH_INC_SPEC) \
+                $(VTK_INC_SPEC) \
                 $(TCL_INC_SPEC) \
                 $(CG_INC_SPEC) \
@@ -103 +122 @@
 ifdef USE_POINTSET_RENDERER
 DEFINES         += -DUSE_POINTSET_RENDERER
+endif
+ifdef USE_VTK
+DEFINES         += -DUSE_VTK
 endif
 CXX_SWITCHES    = $(CFLAGS) $(EXTRA_CFLAGS) $(DEFINES) $(INCLUDES)
@@ -204 +226 @@
 endif
 
+ifdef USE_VTK
+OBJS +=         DataSetResample.o \
+                VtkDataSetReader.o
+endif
+
 .PHONY: all install install-resources install-shaders install-nanovis docs clean-docs clean distclean graphics imgloaders newmat11 util vrmath
 
@@ -287 +314 @@
 ContourLineFilter.o: ContourLineFilter.cpp ContourLineFilter.h
 ConvexPolygon.o: ConvexPolygon.cpp ConvexPolygon.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h Plane.h
+DataSetResample.o: DataSetResample.cpp DataSetResample.h
 Flow.o: Flow.cpp Flow.h FlowCmd.h FlowTypes.h FlowBox.h FlowParticles.h LIC.h VelocityArrowsSlice.h Switch.h Unirect.h Volume.h TransferFunction.h Trace.h
 FlowBox.o: FlowBox.cpp FlowBox.h FlowTypes.h Switch.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h $(VRMATH_DIR)/include/vrmath/Matrix4x4d.h
@@ -293 +321 @@
 GradientFilter.o: GradientFilter.cpp GradientFilter.h
 Grid.o: Grid.cpp Grid.h Axis.h Chain.h $(UTIL_DIR)/Fonts.h $(VRMATH_DIR)/include/vrmath/Color4f.h $(VRMATH_DIR)/include/vrmath/Vector4f.h
-HeightMap.o: HeightMap.cpp HeightMap.h
-LIC.o: LIC.cpp LIC.h
+HeightMap.o: HeightMap.cpp HeightMap.h Shader.h
+LIC.o: LIC.cpp LIC.h Shader.h
 OrientationIndicator.o: OrientationIndicator.cpp OrientationIndicator.h
 ParticleAdvectionShader.o: ParticleAdvectionShader.cpp ParticleAdvectionShader.h Shader.h
@@ -312 +340 @@
 RegularVolumeShader.o: RegularVolumeShader.cpp RegularVolumeShader.h VolumeShader.h Shader.h
 RenderVertexArray.o: RenderVertexArray.cpp RenderVertexArray.h
-Shader.o: Shader.cpp Shader.h
+Shader.o: Shader.cpp Shader.h config.h
 ShaderGL.o: ShaderGL.cpp ShaderGL.h
 StdVertexShader.o: StdVertexShader.cpp StdVertexShader.h Shader.h
@@ -327 +355 @@
 VolumeRenderer.o: VolumeRenderer.cpp VolumeRenderer.h ConvexPolygon.h Volume.h nanovis.h Trace.h Plane.h StdVertexShader.h Shader.h
 VolumeShader.o: VolumeShader.cpp VolumeShader.h Shader.h
-VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h
+VtkDataSetReader.o: VtkDataSetReader.cpp VtkDataSetReader.h DataSetResample.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h Trace.h Volume.h nanovis.h config.h
+VtkReader.o: VtkReader.h Trace.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h ReaderCommon.h nanovis.h config.h
 ZincBlendeReconstructor.o: ZincBlendeReconstructor.cpp ZincBlendeReconstructor.h ZincBlendeVolume.h Volume.h $(VRMATH_DIR)/include/vrmath/Vector3f.h
 ZincBlendeVolume.o: ZincBlendeVolume.cpp ZincBlendeVolume.h config.h define.h

branches/1.3/packages/vizservers/nanovis/Shader.cpp

@@ -12 +12 @@
 #include <util/FilePath.h>
 
+#include "config.h"
 #include "Shader.h"
 #include "Trace.h"
@@ -18 +19 @@
 using namespace nv::util;
 
+/**
+ * These correspond to NV_vertex_program3 and NV_fragment_program2:
+ * CG_PROFILE_VP40
+ * CG_PROFILE_FP40
+ *
+ * These correspond to ARB_vertex_program and ARB_fragment_program:
+ * CG_PROFILE_ARBVP1
+ * CG_PROFILE_ARBFP1
+ *
+ * Generic GLSL targets:
+ * CG_PROFILE_GLSLV
+ * CG_PROFILE_GLSLF
+ */
+#ifdef USE_ARB_PROGRAMS
+CGprofile Shader::_defaultVertexProfile = CG_PROFILE_ARBVP1;
+CGprofile Shader::_defaultFragmentProfile = CG_PROFILE_ARBFP1;
+#else
 CGprofile Shader::_defaultVertexProfile = CG_PROFILE_VP40;
 CGprofile Shader::_defaultFragmentProfile = CG_PROFILE_FP40;
+#endif
 CGcontext Shader::_cgContext = NULL;
 

branches/1.3/packages/vizservers/nanovis/Shader.h

@@ -49 +49 @@
     void loadFragmentProgram(const char *fileName);
 
+    bool isVertexProgramLoaded()
+    {
+        return (getVP() == NULL);
+    }
+
+    bool isFragmentProgramLoaded()
+    {
+        return (getFP() == NULL);
+    }
+
     void setVPParameter1f(const char *name, float val)
     {
@@ -284 +294 @@
     void resetPrograms();
 
-
     CGprogram getVP()
     {

branches/1.3/packages/vizservers/nanovis/VelocityArrowsSlice.cpp

@@ -65 +65 @@
     _queryVelocityFP.loadFragmentProgram("queryvelocity.cg");
 
-    _particleShader.loadVertexProgram("velocityslicevp.cg");
-    _particleShader.loadFragmentProgram("velocityslicefp.cg");
+    // Delay loading of shaders only required for glyph style rendering
+    if (_renderMode == GLYPHS) {
+        _particleShader.loadVertexProgram("velocityslicevp.cg");
+        _particleShader.loadFragmentProgram("velocityslicefp.cg");
+    }
 
     createRenderTarget();
@@ -362 +365 @@
                     continue;
                 }
-                if (length > 1.0e-6) {
+                if (length > 0.0) {
                     Vector3f vnorm = vel.normalize();
                     Vector3f rotationAxis = refVec.cross(vnorm);
@@ -414 +417 @@
         glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
 
+        // FIXME: This vertex shader won't compile with ARB_vertex_program,
+        // so it should use GLSL
+        if (!_particleShader.isVertexProgramLoaded()) {
+            _particleShader.loadVertexProgram("velocityslicevp.cg");
+        }
+        if (!_particleShader.isFragmentProgramLoaded()) {
+            _particleShader.loadFragmentProgram("velocityslicefp.cg");
+        }
+
         _particleShader.bind();
         _particleShader.setVPTextureParameter("vfield", _vectorFieldGraphicsID);
@@ -458 +470 @@
     Vector3f bmin, bmax;
     volume->getBounds(bmin, bmax);
-    _origin = bmin;
+    _origin.set(bmin.x, bmin.y, bmin.z);
     _scale.set(bmax.x-bmin.x, bmax.y-bmin.y, bmax.z-bmin.z);
 

branches/1.3/packages/vizservers/nanovis/VtkReader.cpp

@@ -16 +16 @@
 #include "ReaderCommon.h"
 
+#include "config.h"
 #include "nanovis.h"
 #include "VtkReader.h"

branches/1.3/packages/vizservers/nanovis/config.h

@@ -38 +38 @@
 
 /*
+ * If defined, use ARB_vertex_program and ARB_fragment_program as Cg
+ * profile target, otherwise NV_vertex_program3 and NV_fragment_program2
+ * are required
+ */
+//#define USE_ARB_PROGRAMS
+
+/*
  * Keep statistics
  */

branches/1.3/packages/vizservers/nanovis/dxReader.cpp

@@ -211 +211 @@
     }
 
-    TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%f dy=%f dz=%f\nx0=%f y0=%f z0=%f", 
+    TRACE("found nx=%d ny=%d nxy=%d nz=%d\ndx=%g dy=%g dz=%g\nx0=%g y0=%g z0=%g", 
           nx, ny, nxy, nz, dx, dy, dz, x0, y0, z0);
 

branches/1.3/packages/vizservers/nanovis/nanovis.cpp

@@ -504 +504 @@
     }
 #endif
-    // FIXME: should use ARB programs or (preferably) a GLSL profile for portability
+    // FIXME: should use GLSL for portability
+#ifdef USE_ARB_PROGRAMS
+    if (!GLEW_ARB_vertex_program ||
+        !GLEW_ARB_fragment_program) {
+        ERROR("ARB_vertex_program and ARB_fragment_program extensions are required");
+        return false;
+    }
+#else
     if (!GLEW_NV_vertex_program3 ||
         !GLEW_NV_fragment_program2) {
@@ -510 +517 @@
         return false;
     }
+#endif
 
     if (!FilePath::getInstance()->setPath(path)) {

branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector2f.h

@@ -40 +40 @@
     void set(const Vector2f& v);
 
-    float dot() const;
+    double dot() const;
 
     double length() const;
@@ -67 +67 @@
 }
 
-inline float Vector2f::dot() const
+inline double Vector2f::dot() const
 {
     return (x * x + y * y);

branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector3f.h

@@ -58 +58 @@
     Vector3f scale(const Vector3f& scale) const;
 
-    Vector3f scale(float scale) const;
+    Vector3f scale(double scale) const;
 
     bool operator==(const Vector3f& v) const;
@@ -67 +67 @@
 
     // scalar ops
-    Vector3f operator+(float scalar) const;
-    Vector3f operator-(float scalar) const;
-    Vector3f operator*(float scalar) const;
-    Vector3f operator/(float scalar) const;
-    Vector3f& operator*=(float scalar);
+    Vector3f operator+(double scalar) const;
+    Vector3f operator-(double scalar) const;
+    Vector3f operator*(double scalar) const;
+    Vector3f operator/(double scalar) const;
+    Vector3f& operator*=(double scalar);
 
     // vector ops
@@ -113 +113 @@
 }
 
-inline Vector3f Vector3f::operator+(float scalar) const
+inline Vector3f Vector3f::operator+(double scalar) const
 {
     return Vector3f(x + scalar, y + scalar, z + scalar);
 }
 
-inline Vector3f Vector3f::operator-(float scalar) const
+inline Vector3f Vector3f::operator-(double scalar) const
 {
     return Vector3f(x - scalar, y - scalar, z - scalar);
 }
 
-inline Vector3f Vector3f::operator*(float scalar) const
+inline Vector3f Vector3f::operator*(double scalar) const
 {
     return Vector3f(x * scalar, y * scalar, z * scalar);
 }
 
-inline Vector3f Vector3f::operator/(float scalar) const
+inline Vector3f Vector3f::operator/(double scalar) const
 {
     return Vector3f(x / scalar, y / scalar, z / scalar);
 }
 
-inline Vector3f& Vector3f::operator*=(float scalar)
+inline Vector3f& Vector3f::operator*=(double scalar)
 {
     x *= scalar;
@@ -168 +168 @@
 
 #if 0
-inline Vector3f operator*(float scale, const Vector3f& value)
+inline Vector3f operator*(double scale, const Vector3f& value)
 {
     return Vector3f(value.x * scale, value.y * scale, value.z * scale);
@@ -231 +231 @@
 inline Vector3f Vector3f::normalize() const
 {
-    float len = length();
-    if (len > 1.0e-6) {
+    double len = length();
+    if (len > 0.0) {
         return Vector3f(x / len, y / len, z / len);
     } else {
@@ -239 +239 @@
 }
 
-inline Vector3f Vector3f::scale(float scale) const
+inline Vector3f Vector3f::scale(double scale) const
 {
     return Vector3f(x * scale, y * scale, z * scale);

branches/1.3/packages/vizservers/nanovis/vrmath/include/vrmath/Vector4f.h

@@ -66 +66 @@
     }
 
-    Vector4f operator*(float op2) const
+    Vector4f operator*(double op2) const
     {
         return Vector4f(x * op2, y * op2, z * op2, w * op2);
     }
 
-    Vector4f operator/(float op2) const
+    Vector4f operator/(double op2) const
     {
         return Vector4f(x / op2, y / op2, z / op2, w / op2);
@@ -78 +78 @@
     void divideByW();
 
-    float dot(const Vector4f& vec) const;
+    double dot(const Vector4f& vec) const;
 
     union {
@@ -122 +122 @@
 }
 
-inline float Vector4f::dot(const Vector4f& v) const
+inline double Vector4f::dot(const Vector4f& v) const
 {
-    return (x * v.x + y * v.y + z * v.z + w * v.w);
+    return ((double)x * v.x + (double)y * v.y + (double)z * v.z + (double)w * v.w);
 }
 

branches/1.3/packages/vizservers/vtkvis/DataSet.cpp

@@ -164 +164 @@
         return false;
 
-    if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL) {
+    if (vtkUnstructuredGrid::SafeDownCast(_dataSet) != NULL && !isCloud()) {
         vtkSmartPointer<vtkExtractUnstructuredGrid> filter = vtkSmartPointer<vtkExtractUnstructuredGrid>::New();
 #ifdef USE_VTK6

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

@@ -147 +147 @@
                 Molecule.cpp \
                 Outline.cpp \
+                Parallelepiped.cpp \
                 PolyData.cpp \
                 Polygon.cpp \
@@ -230 +231 @@
 Molecule.o: Molecule.h MoleculeData.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
 Outline.o: Outline.h GraphicsObject.h DataSet.h Trace.h
+Parallelepiped.o: Parallelepiped.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 PolyData.o: PolyData.h GraphicsObject.h DataSet.h Renderer.h Trace.h
 Polygon.o: Polygon.h Shape.h GraphicsObject.h DataSet.h Renderer.h Trace.h
@@ -235 +237 @@
 PseudoColor.o: PseudoColor.h GraphicsObject.h DataSet.h Renderer.h ColorMap.h Trace.h
 ReadBuffer.o: ReadBuffer.h Trace.h
-Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
-RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
-RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
+Renderer.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h Math.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
+RendererCmd.o: Renderer.h RendererGraphicsObjs.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h ReadBuffer.h ResponseQueue.h Trace.h CmdProc.h PPMWriter.h TGAWriter.h
+RendererGraphicsObjs.o: Renderer.h RendererGraphicsObjs.h DataSet.h Arc.h Arrow.h Box.h Cone.h Contour2D.h Contour3D.h Cutplane.h Cylinder.h Disk.h Glyphs.h Group.h HeightMap.h Image.h LIC.h Line.h Molecule.h Outline.h Parallelepiped.h PolyData.h Polygon.h PseudoColor.h Sphere.h Streamlines.h Text3D.h Volume.h Warp.h ColorMap.h Trace.h
 RenderServer.o: RenderServer.h RendererCmd.h Renderer.h vtkRpCubeAxesActor.h vtkRpAxisFollower.h vtkRpAxisActor.h ReadBuffer.h ResponseQueue.h Trace.h PPMWriter.h TGAWriter.h
 ResponseQueue.o: ResponseQueue.h Trace.h

branches/1.3/packages/vizservers/vtkvis/RenderServer.h

@@ -16 +16 @@
 class Renderer;
 
-#define VTKVIS_VERSION_STRING "1.5"
+#define VTKVIS_VERSION_STRING "1.6"
 
 #define MSECS_ELAPSED(t1, t2) \

branches/1.3/packages/vizservers/vtkvis/Renderer.cpp

@@ -197 +197 @@
     deleteAllGraphicsObjects<Molecule>();
     deleteAllGraphicsObjects<Outline>();
+    deleteAllGraphicsObjects<Parallelepiped>();
     deleteAllGraphicsObjects<PolyData>();
     deleteAllGraphicsObjects<Polygon>();
@@ -2436 +2437 @@
     setGraphicsObjectAspect<Molecule>(aspectRatio);
     setGraphicsObjectAspect<Outline>(aspectRatio);
+    setGraphicsObjectAspect<Parallelepiped>(aspectRatio);
     setGraphicsObjectAspect<PolyData>(aspectRatio);
     setGraphicsObjectAspect<Polygon>(aspectRatio);
@@ -3357 +3359 @@
     mergeGraphicsObjectBounds<Molecule>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Outline>(bounds, onlyVisible);
+    mergeGraphicsObjectBounds<Parallelepiped>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<PolyData>(bounds, onlyVisible);
     mergeGraphicsObjectBounds<Polygon>(bounds, onlyVisible);
@@ -3429 +3432 @@
     mergeGraphicsObjectUnscaledBounds<Outline>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<PolyData>(bounds, onlyVisible);
+    mergeGraphicsObjectUnscaledBounds<Parallelepiped>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<Polygon>(bounds, onlyVisible);
     mergeGraphicsObjectUnscaledBounds<PseudoColor>(bounds, onlyVisible);
@@ -4577 +4581 @@
     setGraphicsObjectClippingPlanes<Molecule>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Outline>(_activeClipPlanes);
+    setGraphicsObjectClippingPlanes<Parallelepiped>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<PolyData>(_activeClipPlanes);
     setGraphicsObjectClippingPlanes<Polygon>(_activeClipPlanes);

branches/1.3/packages/vizservers/vtkvis/Renderer.h

@@ -45 +45 @@
 #include "Molecule.h"
 #include "Outline.h"
+#include "Parallelepiped.h"
 #include "PolyData.h"
 #include "Polygon.h"
@@ -809 +810 @@
                               const char *name, double range[2] = NULL);
 
-    // N-sided Regular Polygons
-
-    bool addPolygon(const DataSetId& id, int numSides, double center[3], double normal[3], double radius);
+    // Parallelepipeds
+
+    bool addParallelepiped(const DataSetId& id, double vec1[3], double vec2[3], double vec3[3],
+                           bool flipNormals = false);
 
     // PolyData meshes
@@ -826 +828 @@
                               DataSet::DataAttributeType type,
                               const char *name, double range[2] = NULL);
+
+    // N-sided Regular Polygons
+
+    bool addPolygon(const DataSetId& id, int numSides, double center[3], double normal[3], double radius);
 
     // Color-mapped surfaces
@@ -975 +981 @@
     typedef std::tr1::unordered_map<DataSetId, Molecule *> MoleculeHashmap;
     typedef std::tr1::unordered_map<DataSetId, Outline *> OutlineHashmap;
+    typedef std::tr1::unordered_map<DataSetId, Parallelepiped *> ParallelepipedHashmap;
     typedef std::tr1::unordered_map<DataSetId, PolyData *> PolyDataHashmap;
     typedef std::tr1::unordered_map<DataSetId, Polygon *> PolygonHashmap;
@@ -1114 +1121 @@
     MoleculeHashmap _molecules;
     OutlineHashmap _outlines;
+    ParallelepipedHashmap _parallelepipeds;
     PolyDataHashmap _polyDatas;
     PolygonHashmap _polygons;

branches/1.3/packages/vizservers/vtkvis/RendererCmd.cpp

@@ -8559 +8559 @@
 
 static int
+ParallelepipedAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                    Tcl_Obj *const *objv)
+{
+    double vec1[3], vec2[3], vec3[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &vec1[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &vec1[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &vec1[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &vec2[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[6], &vec2[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[7], &vec2[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[8], &vec3[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[9], &vec3[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[10], &vec3[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    const char *name = Tcl_GetString(objv[11]);
+    if (!g_renderer->addParallelepiped(name, vec1, vec2, vec3)) {
+        Tcl_AppendResult(interp, "Failed to create parallelepiped", (char*)NULL);
+        return TCL_ERROR;
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedDeleteOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    if (objc == 3) {
+        const char *name = Tcl_GetString(objv[2]);
+        g_renderer->deleteGraphicsObject<Parallelepiped>(name);
+    } else {
+        g_renderer->deleteGraphicsObject<Parallelepiped>("all");
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectColor<Parallelepiped>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectColor<Parallelepiped>("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedCullingOp(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->setGraphicsObjectCulling<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectCulling<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedEdgeVisibilityOp(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->setGraphicsObjectEdgeVisibility<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectEdgeVisibility<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedFlipNormalsOp(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->setGraphicsObjectFlipNormals<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectFlipNormals<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedLightingOp(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->setGraphicsObjectLighting<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectLighting<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedLineColorOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    float color[3];
+    if (GetFloatFromObj(interp, objv[2], &color[0]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[3], &color[1]) != TCL_OK ||
+        GetFloatFromObj(interp, objv[4], &color[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectEdgeColor<Parallelepiped>(name, color);
+    } else {
+        g_renderer->setGraphicsObjectEdgeColor<Parallelepiped>("all", color);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedLineWidthOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                          Tcl_Obj *const *objv)
+{
+    float width;
+    if (GetFloatFromObj(interp, objv[2], &width) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectEdgeWidth<Parallelepiped>(name, width);
+    } else {
+        g_renderer->setGraphicsObjectEdgeWidth<Parallelepiped>("all", width);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedMaterialOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                         Tcl_Obj *const *objv)
+{
+    double ambient, diffuse, specCoeff, specPower;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &ambient) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &diffuse) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &specCoeff) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &specPower) != TCL_OK) {
+        return TCL_ERROR;
+    }
+
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGraphicsObjectAmbient<Parallelepiped>(name, ambient);
+        g_renderer->setGraphicsObjectDiffuse<Parallelepiped>(name, diffuse);
+        g_renderer->setGraphicsObjectSpecular<Parallelepiped>(name, specCoeff, specPower);
+    } else {
+        g_renderer->setGraphicsObjectAmbient<Parallelepiped>("all", ambient);
+        g_renderer->setGraphicsObjectDiffuse<Parallelepiped>("all", diffuse);
+        g_renderer->setGraphicsObjectSpecular<Parallelepiped>("all", specCoeff, specPower);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedOpacityOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                        Tcl_Obj *const *objv)
+{
+    double opacity;
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &opacity) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectOpacity<Parallelepiped>(name, opacity);
+    } else {
+        g_renderer->setGraphicsObjectOpacity<Parallelepiped>("all", opacity);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedOrientOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    double quat[4];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &quat[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &quat[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &quat[2]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[5], &quat[3]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 7) {
+        const char *name = Tcl_GetString(objv[6]);
+        g_renderer->setGraphicsObjectOrientation<Parallelepiped>(name, quat);
+    } else {
+        g_renderer->setGraphicsObjectOrientation<Parallelepiped>("all", quat);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedOriginOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                       Tcl_Obj *const *objv)
+{
+    double origin[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &origin[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &origin[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &origin[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectOrigin<Parallelepiped>(name, origin);
+    } else {
+        g_renderer->setGraphicsObjectOrigin<Parallelepiped>("all", origin);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedPositionOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                         Tcl_Obj *const *objv)
+{
+    double pos[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &pos[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &pos[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &pos[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectPosition<Parallelepiped>(name, pos);
+    } else {
+        g_renderer->setGraphicsObjectPosition<Parallelepiped>("all", pos);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedScaleOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                      Tcl_Obj *const *objv)
+{
+    double scale[3];
+    if (Tcl_GetDoubleFromObj(interp, objv[2], &scale[0]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[3], &scale[1]) != TCL_OK ||
+        Tcl_GetDoubleFromObj(interp, objv[4], &scale[2]) != TCL_OK) {
+        return TCL_ERROR;
+    }
+    if (objc == 6) {
+        const char *name = Tcl_GetString(objv[5]);
+        g_renderer->setGraphicsObjectScale<Parallelepiped>(name, scale);
+    } else {
+        g_renderer->setGraphicsObjectScale<Parallelepiped>("all", scale);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedShadingOp(ClientData clientData, Tcl_Interp *interp, int objc, 
+                        Tcl_Obj *const *objv)
+{
+    GraphicsObject::ShadingModel shadeModel;
+    const char *str = Tcl_GetString(objv[2]);
+    if (str[0] == 'f' && strcmp(str, "flat") == 0) {
+        shadeModel = GraphicsObject::SHADE_FLAT;
+    } else if (str[0] == 's' && strcmp(str, "smooth") == 0) {
+        shadeModel = GraphicsObject::SHADE_GOURAUD;
+    } else {
+         Tcl_AppendResult(interp, "bad shading option \"", str,
+                         "\": should be one of: 'flat', 'smooth'", (char*)NULL);
+        return TCL_ERROR;
+    }
+    if (objc == 4) {
+        const char *name = Tcl_GetString(objv[3]);
+        g_renderer->setGraphicsObjectShadingModel<Parallelepiped>(name, shadeModel);
+    } else {
+        g_renderer->setGraphicsObjectShadingModel<Parallelepiped>("all", shadeModel);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedVisibleOp(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->setGraphicsObjectVisibility<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectVisibility<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static int
+ParallelepipedWireframeOp(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->setGraphicsObjectWireframe<Parallelepiped>(name, state);
+    } else {
+        g_renderer->setGraphicsObjectWireframe<Parallelepiped>("all", state);
+    }
+    return TCL_OK;
+}
+
+static Rappture::CmdSpec parallelepipedOps[] = {
+    {"add",       1, ParallelepipedAddOp, 12, 12, "v0x v0y v0z v1x v1y v1z v2x v2y v2z name"},
+    {"color",     2, ParallelepipedColorOp, 5, 6, "r g b ?name?"},
+    {"culling",   2, ParallelepipedCullingOp, 3, 4, "bool ?name?"},
+    {"delete",    1, ParallelepipedDeleteOp, 2, 3, "?name?"},
+    {"edges",     1, ParallelepipedEdgeVisibilityOp, 3, 4, "bool ?name?"},
+    {"flipnorms", 1, ParallelepipedFlipNormalsOp, 3, 4, "bool ?name?"},
+    {"lighting",  3, ParallelepipedLightingOp, 3, 4, "bool ?name?"},
+    {"linecolor", 5, ParallelepipedLineColorOp, 5, 6, "r g b ?name?"},
+    {"linewidth", 5, ParallelepipedLineWidthOp, 3, 4, "width ?name?"},
+    {"material",  1, ParallelepipedMaterialOp, 6, 7, "ambientCoeff diffuseCoeff specularCoeff specularPower ?name?"},
+    {"opacity",   2, ParallelepipedOpacityOp, 3, 4, "value ?name?"},
+    {"orient",    4, ParallelepipedOrientOp, 6, 7, "qw qx qy qz ?name?"},
+    {"origin",    4, ParallelepipedOriginOp, 5, 6, "x y z ?name?"},
+    {"pos",       1, ParallelepipedPositionOp, 5, 6, "x y z ?name?"},
+    {"scale",     2, ParallelepipedScaleOp, 5, 6, "sx sy sz ?name?"},
+    {"shading",   2, ParallelepipedShadingOp, 3, 4, "val ?name?"},
+    {"visible",   1, ParallelepipedVisibleOp, 3, 4, "bool ?name?"},
+    {"wireframe", 1, ParallelepipedWireframeOp, 3, 4, "bool ?name?"}
+};
+static int nParallelepipedOps = NumCmdSpecs(parallelepipedOps);
+
+static int
+ParallelepipedCmd(ClientData clientData, Tcl_Interp *interp, int objc, 
+       Tcl_Obj *const *objv)
+{
+    Tcl_ObjCmdProc *proc;
+
+    proc = Rappture::GetOpFromObj(interp, nParallelepipedOps, parallelepipedOps,
+                                  Rappture::CMDSPEC_ARG1, objc, objv, 0);
+    if (proc == NULL) {
+        return TCL_ERROR;
+    }
+    return (*proc) (clientData, interp, objc, objv);
+}
+
+static int
 PolyDataAddOp(ClientData clientData, Tcl_Interp *interp, int objc, 
               Tcl_Obj *const *objv)
@@ -12228 +12601 @@
 {
     Tcl_MakeSafe(interp);
-    Tcl_CreateObjCommand(interp, "arc",         ArcCmd,         clientData, NULL);
-    Tcl_CreateObjCommand(interp, "arrow",       ArrowCmd,       clientData, NULL);
-    Tcl_CreateObjCommand(interp, "axis",        AxisCmd,        clientData, NULL);
-    Tcl_CreateObjCommand(interp, "box",         BoxCmd,         clientData, NULL);
-    Tcl_CreateObjCommand(interp, "camera",      CameraCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "clientinfo",  ClientInfoCmd,  clientData, NULL);
-    Tcl_CreateObjCommand(interp, "colormap",    ColorMapCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "cone",        ConeCmd,        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, "cylinder",    CylinderCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "dataset",     DataSetCmd,     clientData, NULL);
-    Tcl_CreateObjCommand(interp, "disk",        DiskCmd,        clientData, NULL);
-    Tcl_CreateObjCommand(interp, "glyphs",      GlyphsCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "group",       GroupCmd,       clientData, NULL);
-    Tcl_CreateObjCommand(interp, "heightmap",   HeightMapCmd,   clientData, NULL);
-    Tcl_CreateObjCommand(interp, "image",       ImageCmd,       clientData, NULL);
-    Tcl_CreateObjCommand(interp, "imgflush",    ImageFlushCmd,  clientData, NULL);
-    Tcl_CreateObjCommand(interp, "legend",      LegendCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "legend2",     LegendSimpleCmd,clientData, NULL);
-    Tcl_CreateObjCommand(interp, "lic",         LICCmd,         clientData, NULL);
-    Tcl_CreateObjCommand(interp, "line",        LineCmd,        clientData, NULL);
-    Tcl_CreateObjCommand(interp, "molecule",    MoleculeCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "outline",     OutlineCmd,     clientData, NULL);
-    Tcl_CreateObjCommand(interp, "polydata",    PolyDataCmd,    clientData, NULL);
-    Tcl_CreateObjCommand(interp, "polygon",     PolygonCmd,     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, "sphere",      SphereCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "streamlines", StreamlinesCmd, clientData, NULL);
-    Tcl_CreateObjCommand(interp, "text3d",      Text3DCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "volume",      VolumeCmd,      clientData, NULL);
-    Tcl_CreateObjCommand(interp, "warp",        WarpCmd,        clientData, NULL);
+    Tcl_CreateObjCommand(interp, "arc",            ArcCmd,            clientData, NULL);
+    Tcl_CreateObjCommand(interp, "arrow",          ArrowCmd,          clientData, NULL);
+    Tcl_CreateObjCommand(interp, "axis",           AxisCmd,           clientData, NULL);
+    Tcl_CreateObjCommand(interp, "box",            BoxCmd,            clientData, NULL);
+    Tcl_CreateObjCommand(interp, "camera",         CameraCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "clientinfo",     ClientInfoCmd,     clientData, NULL);
+    Tcl_CreateObjCommand(interp, "colormap",       ColorMapCmd,       clientData, NULL);
+    Tcl_CreateObjCommand(interp, "cone",           ConeCmd,           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, "cylinder",       CylinderCmd,       clientData, NULL);
+    Tcl_CreateObjCommand(interp, "dataset",        DataSetCmd,        clientData, NULL);
+    Tcl_CreateObjCommand(interp, "disk",           DiskCmd,           clientData, NULL);
+    Tcl_CreateObjCommand(interp, "glyphs",         GlyphsCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "group",          GroupCmd,          clientData, NULL);
+    Tcl_CreateObjCommand(interp, "heightmap",      HeightMapCmd,      clientData, NULL);
+    Tcl_CreateObjCommand(interp, "image",          ImageCmd,          clientData, NULL);
+    Tcl_CreateObjCommand(interp, "imgflush",       ImageFlushCmd,     clientData, NULL);
+    Tcl_CreateObjCommand(interp, "legend",         LegendCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "legend2",        LegendSimpleCmd,   clientData, NULL);
+    Tcl_CreateObjCommand(interp, "lic",            LICCmd,            clientData, NULL);
+    Tcl_CreateObjCommand(interp, "line",           LineCmd,           clientData, NULL);
+    Tcl_CreateObjCommand(interp, "molecule",       MoleculeCmd,       clientData, NULL);
+    Tcl_CreateObjCommand(interp, "outline",        OutlineCmd,        clientData, NULL);
+    Tcl_CreateObjCommand(interp, "parallelepiped", ParallelepipedCmd, clientData, NULL);
+    Tcl_CreateObjCommand(interp, "polydata",       PolyDataCmd,       clientData, NULL);
+    Tcl_CreateObjCommand(interp, "polygon",        PolygonCmd,        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, "sphere",         SphereCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "streamlines",    StreamlinesCmd,    clientData, NULL);
+    Tcl_CreateObjCommand(interp, "text3d",         Text3DCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "volume",         VolumeCmd,         clientData, NULL);
+    Tcl_CreateObjCommand(interp, "warp",           WarpCmd,           clientData, NULL);
 }
 
@@ -12295 +12669 @@
     Tcl_DeleteCommand(interp, "molecule");
     Tcl_DeleteCommand(interp, "outline");
+    Tcl_DeleteCommand(interp, "parallelepiped");
     Tcl_DeleteCommand(interp, "polydata");
     Tcl_DeleteCommand(interp, "polygon");

branches/1.3/packages/vizservers/vtkvis/RendererGraphicsObjs.cpp

@@ -28 +28 @@
 #include "Line.h"
 #include "Molecule.h"
+#include "Parallelepiped.h"
 #include "PolyData.h"
 #include "PseudoColor.h"
@@ -123 +124 @@
 Renderer::getGraphicsObjectHashmap<Outline>()
 { return _outlines; }
+
+template<>
+Renderer::ParallelepipedHashmap &
+Renderer::getGraphicsObjectHashmap<Parallelepiped>()
+{ return _parallelepipeds; }
 
 template<>
@@ -173 +179 @@
 template Group *Renderer::getGraphicsObject(const DataSetId&);
 template Line *Renderer::getGraphicsObject(const DataSetId&);
+template Parallelepiped *Renderer::getGraphicsObject(const DataSetId&);
 template Polygon *Renderer::getGraphicsObject(const DataSetId&);
 template Sphere *Renderer::getGraphicsObject(const DataSetId&);
@@ -287 +294 @@
     }
     if ((gobj = getGraphicsObject<Line>(id)) != NULL) {
+        return gobj;
+    }
+    if ((gobj = getGraphicsObject<Parallelepiped>(id)) != NULL) {
         return gobj;
     }
@@ -2938 +2948 @@
 
 /**
+ * \brief Create a new Parallelepiped and associate it with an ID
+ */
+bool Renderer::addParallelepiped(const DataSetId& id,
+                                 double vec1[3], double vec2[3], double vec3[3],
+                                 bool flipNormals)
+{
+    Parallelepiped *gobj;
+    if ((gobj = getGraphicsObject<Parallelepiped>(id)) != NULL) {
+        WARN("Replacing existing %s %s", gobj->getClassName(), id.c_str());
+        deleteGraphicsObject<Parallelepiped>(id);
+    }
+
+    gobj = new Parallelepiped();
+ 
+    gobj->setDataSet(NULL, this);
+
+    if (gobj->getProp() == NULL &&
+        gobj->getOverlayProp() == NULL) {
+        delete gobj;
+        return false;
+    } else {
+        if (gobj->getProp())
+            _renderer->AddViewProp(gobj->getProp());
+        if (gobj->getOverlayProp())
+            _renderer->AddViewProp(gobj->getOverlayProp());
+    }
+
+    gobj->setVectors(vec1, vec2, vec3);
+    if (flipNormals)
+        gobj->flipNormals(flipNormals);
+
+    getGraphicsObjectHashmap<Parallelepiped>()[id] = gobj;
+
+    sceneBoundsChanged();
+    _needsRedraw = true;
+    return true;
+}
+
+/**
  * \brief Create a new n-sided regular Polygon and associate it with an ID
  */

branches/1.3/packages/vizservers/vtkvis/Volume.cpp

@@ -14 +14 @@
 #include <vtkGPUVolumeRayCastMapper.h>
 #include <vtkVolumeTextureMapper3D.h>
+#include <vtkRectilinearGrid.h>
+#include <vtkStructuredGrid.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkPolyData.h>
@@ -121 +123 @@
 #endif
         vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
-    } else if (_dataSet->isCloud()) {
-        // DataSet is a 3D point cloud
+    } else if (_dataSet->isCloud() ||
+               vtkUnstructuredGrid::SafeDownCast(ds) == NULL) {
+        // DataSet is a 3D point cloud, rectilinear grid or structured grid
         vtkSmartPointer<vtkGaussianSplatter> splatter = vtkSmartPointer<vtkGaussianSplatter>::New();
 #ifdef USE_VTK6
@@ -131 +134 @@
         int dims[3];
         dims[0] = dims[1] = dims[2] = 64;
-        TRACE("Generating volume with dims (%d,%d,%d) from point cloud",
-              dims[0], dims[1], dims[2]);
+        if (vtkStructuredGrid::SafeDownCast(ds) != NULL) {
+            vtkStructuredGrid::SafeDownCast(ds)->GetDimensions(dims);
+        } else if (vtkRectilinearGrid::SafeDownCast(ds) != NULL) {
+            vtkRectilinearGrid::SafeDownCast(ds)->GetDimensions(dims);
+        }
+        TRACE("Generating volume with dims (%d,%d,%d) from %d points",
+              dims[0], dims[1], dims[2], ds->GetNumberOfPoints());
         splatter->SetSampleDimensions(dims);
         splatter->Update();
@@ -144 +152 @@
         _volumeMapper->SetInputConnection(splatter->GetOutputPort());
         vtkVolumeMapper::SafeDownCast(_volumeMapper)->SetBlendModeToComposite();
-    } else if (vtkUnstructuredGrid::SafeDownCast(ds) != NULL) {
+    } else {
         // Unstructured grid with cells (not a cloud)
         vtkUnstructuredGrid *ugrid = vtkUnstructuredGrid::SafeDownCast(ds);
+        assert(ugrid != NULL);
         // DataSet is unstructured grid
         // Only works if cells are all tetrahedra
@@ -177 +186 @@
         vtkUnstructuredGridVolumeMapper::SafeDownCast(_volumeMapper)->
             SetBlendModeToComposite();
-    } else {
-        ERROR("Unsupported DataSet type: %s", _dataSet->getVtkType());
-        _dataSet = NULL;
-        return;
     }
 

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

@@ -685 +685 @@
 outline scale <sx> <sy> <sz> <?datasetName?>
 outline visible <bool> <?datasetName?>
+
+parallelepiped add <v0x> <v0y> <v0z> <v1x> <v1y> <v1z> <v2x> <v2y> <v2z> <name>
+               Specify parallelepiped using 3 basis vectors.  The 3 vectors should
+               be given in order to create a right-handed coordinate system, i.e.
+               (v0 cross v1) dot v2 should be positive.
+parallelepiped color <r> <g> <b> <?name?>
+parallelepiped culling <bool> <?name?>
+parallelepiped delete <?name?>
+parallelepiped edges <bool> <?name?>
+parallelepiped flipnorm <bool> <?name?>
+parallelepiped lighting <bool> <?name?>
+parallelepiped linecolor <r> <g> <b> <?name?>
+parallelepiped linewidth <val> <?name?>
+parallelepiped material <ambientCoeff> <diffuseCoeff> <specularCoeff> <specularExp> <?name?>
+parallelepiped opacity <val> <?name?>
+parallelepiped orient <qw> <qx> <qy> <qz> <?name?>
+parallelepiped origin <x> <y> <z> <?name?>
+parallelepiped pos <x> <y> <z> <?name?>
+parallelepiped scale <sx> <sy> <sz> <?name?>
+parallelepiped shading <val> <?name?>
+               val = flat|smooth
+parallelepiped visible <bool> <?name?>
+parallelepiped wireframe <bool> <?name?>
 
 polydata add <?datasetName?>