Changeset 1306

Timestamp:

Mar 10, 2009 2:12:28 PM (15 years ago)

Author:

vrinside

Message:

Implemented a vector field loader without using Rappture interploration

Location:

trunk/packages/vizservers/nanovis

Files:

• Command.cpp (modified) (2 diffs)
• dxReader.cpp (modified) (1 diff)

trunk/packages/vizservers/nanovis/Command.cpp

@@ -105 +105 @@
             double nzero_min);
 extern void load_vector_stream(int index, std::istream& fin);
+extern void load_vector_stream2(int index, std::istream& fin);
 
 // Tcl interpreter for incoming messages
@@ -1736 +1737 @@
     std::stringstream fdata;
     fdata.write(buf.bytes(),buf.size());
-    load_vector_stream(n, fdata);
+    //load_vector_stream(n, fdata);
+    load_vector_stream2(n, fdata);
     Volume *volPtr = NanoVis::volume[n];
 

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -47 +47 @@
  * Load a 3D vector field from a dx-format file
  */
+void
+load_vector_stream2(int volindex, std::istream& fin)
+{
+    int dummy, nx, ny, nz, npts;
+    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
+    char line[128], type[128], *start;
+
+    dx = dy = dz = 0.0;         // Suppress compiler warning.
+    x0 = y0 = z0 = 0.0;         // May not have an origin line.
+    while (!fin.eof()) {
+        fin.getline(line, sizeof(line) - 1);
+        if (fin.fail()) {
+            //return result.error("error in data stream");
+            return;
+        }
+        for (start=&line[0]; *start == ' ' || *start == '\t'; start++)
+            ;  // skip leading blanks
+
+        if (*start != '#') {  // skip comment lines
+            if (sscanf(start, "object %d class gridpositions counts %d %d %d", &dummy, &nx, &ny, &nz) == 4) {
+                printf("w:%d h:%d d:%d\n", nx, ny, nz);
+                // found grid size
+            } else if (sscanf(start, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
+                // found origin
+            } else if (sscanf(start, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
+                // found one of the delta lines
+                if (ddx != 0.0) {
+                    dx = ddx;
+                } else if (ddy != 0.0) {
+                    dy = ddy;
+                } else if (ddz != 0.0) {
+                    dz = ddz;
+                }
+            } else if (sscanf(start, "object %d class array type %s shape 3 rank 1 items %d data follows", &dummy, type, &npts) == 3) {
+                printf("point %d\n", npts);
+                if (npts != nx*ny*nz) {
+                    std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << npts << " points" << std::endl;
+                    return;
+                }
+                break;
+            } else if (sscanf(start, "object %d class array type %s rank 0 times %d data follows", &dummy, type, &npts) == 3) {
+                if (npts != nx*ny*nz) {
+                    std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << npts << " points" << std::endl;
+                    return;
+                }
+                break;
+            }
+        }
+    }
+
+    // read data points
+    float* srcdata = new float[nx * ny * nz * 3];
+    if (!fin.eof()) {
+        double vx, vy, vz, vm;
+        double max_x = -1e21, min_x = 1e21;
+        double max_y = -1e21, min_y = 1e21;
+        double max_z = -1e21, min_z = 1e21;
+        double max_mag = -1e21, min_mag = 1e21;
+        int nread = 0;
+        for (int ix=0; ix < nx; ix++) {
+            for (int iy=0; iy < ny; iy++) {
+                for (int iz=0; iz < nz; iz++) {
+                    if (fin.eof() || nread > npts) {
+                        break;
+                    }
+                    fin.getline(line,sizeof(line)-1);
+                    if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) {
+                        int nindex = (iz*nx*ny + iy*nx + ix) * 3;
+                        srcdata[nindex] = vx;
+                        //if (srcdata[nindex] > max_x) max_x = srcdata[nindex];
+                        //if (srcdata[nindex] < min_x) min_x = srcdata[nindex];
+                        ++nindex;
+
+                        srcdata[nindex] = vy;
+                        //if (srcdata[nindex] > max_y) max_y = srcdata[nindex];
+                        //if (srcdata[nindex] < min_y) min_y = srcdata[nindex];
+                        ++nindex;
+
+                        srcdata[nindex] = vz;
+                        //if (srcdata[nindex] > max_z) max_z = srcdata[nindex];
+                        //if (srcdata[nindex] < min_z) min_z = srcdata[nindex];
+                    
+                        vm = sqrt(vx*vx + vy*vy + vz*vz);
+                        if (vm > max_mag) max_mag = vm;
+                        if (vm < min_mag) min_mag = vm;
+        
+                        ++nread;
+                    }
+                }
+            }
+        }
+
+        // make sure that we read all of the expected points
+        if (nread != nx*ny*nz) {
+            std::cerr << "inconsistent data: expected " << nx*ny*nz << " points but found " << nread << " points" << std::endl;
+            return;
+        }
+
+        float *data = new float[4*nx*ny*nz];
+        memset(data, 0, sizeof(float) * 4 * nx * ny * nz);
+
+        std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
+
+        // generate the uniformly sampled data that we need for a volume
+        double nzero_min = 0.0;
+        int ngen = 0;
+        int nindex = 0;
+        for (int iz=0; iz < nz; iz++) {
+            for (int iy=0; iy < ny; iy++) {
+                for (int ix=0; ix < nx; ix++) {
+
+                    vx = srcdata[nindex++];
+                    vy = srcdata[nindex++];
+                    vz = srcdata[nindex++];
+                        
+                    double vm;
+                    vm = sqrt(vx*vx + vy*vy + vz*vz);
+
+                    data[ngen] = vm / max_mag; ++ngen;
+                    data[ngen] = vx /(2.0*max_mag) + 0.5; ++ngen;
+                    data[ngen] = vy /(2.0*max_mag) + 0.5; ++ngen;
+                    data[ngen] = vz /(2.0*max_mag) + 0.5; ++ngen;
+                }
+            }
+        }
+
+        Volume *volPtr;
+        volPtr = NanoVis::load_volume(volindex, nx, ny, nz, 4, data, min_mag, max_mag,
+                    0);
+
+        volPtr->xAxis.SetRange(x0, x0 + nx);
+        volPtr->yAxis.SetRange(y0, y0 + ny);
+        volPtr->zAxis.SetRange(z0, z0 + nz);
+        volPtr->wAxis.SetRange(min_mag, max_mag);
+        volPtr->update_pending = true;
+        delete [] data;
+    } else {
+        std::cerr << "WARNING: data not found in stream" << std::endl;
+    }
+}
 void
 load_vector_stream(int index, std::istream& fin)