Changeset 3574 for trunk/packages/vizservers/nanovis

Timestamp:

Mar 25, 2013 1:17:55 PM (11 years ago)

Author:

ldelgass

Message:

Use normalizeScalar common function where possible. Also, don't set NaNs? to
-1 in unnormalized data since -1 could be a valid data value. Need to make
sure gradient filtering properly handles NaNs?.

Location:

trunk/packages/vizservers/nanovis

Files:

• ReaderCommon.cpp (modified) (3 diffs)
• ReaderCommon.h (modified) (1 diff)
• VtkReader.cpp (modified) (2 diffs)
• dxReader.cpp (modified) (3 diffs)

trunk/packages/vizservers/nanovis/ReaderCommon.cpp

@@ -31 +31 @@
 
 void
-normalizeScalar(float *fdata, int count, float min, float max)
+normalizeScalar(float *data, int count, int stride, double vmin, double vmax)
 {
-    float v = max - min;
-    if (v != 0.0f) {
-        for (int i = 0; i < count; ++i) {
-            if (fdata[i] != -1.0) {
-                fdata[i] = (fdata[i] - min)/ v;
-            }
+    double dv = vmax - vmin;
+    dv = (dv == 0.0) ? 1.0 : 0.0;
+    for (int pt = 0, i = 0; pt < count; ++pt, i += stride) {
+        double v = data[i];
+        if (isnan(v)) {
+            data[i] = -1.0f;
+        } else if (data[i] >= min) {
+            data[i] = (float)((v - vmin)/ dv);
         }
     }
@@ -48 +50 @@
  * This technique is fairly expensive in terms of memory and
  * running time due to the filter extent.
+ *
+ * \param data Data array with X the fastest running, stride of
+ * 1 float
+ * \param nx number of values in X direction
+ * \param ny number of values in Y direction
+ * \param nz number of values in Z direction
+ * \param dx Size of voxels in X direction
+ * \param dy Size of voxels in Y direction
+ * \param dz Size of voxels in Z direction
+ * \param min Minimum value in data
+ * \param max Maximum value in data
+ * \return Returns a float array with stride of 4 floats 
+ * containing the normalized scalar and the x,y,z components of 
+ * the (normalized) gradient vector
  */
 float *
-computeGradient(float *fdata,
-                int width, int height, int depth,
+computeGradient(float *data,
+                int nx, int ny, int nz,
                 float dx, float dy, float dz,
                 float min, float max)
 {
-    float *gradients = (float *)malloc(width * height * depth * 3 *
-                                       sizeof(float));
-    float *tempGradients = (float *)malloc(width * height * depth * 3 *
-                                           sizeof(float));
-    int sizes[3] = { width, height, depth };
+    int npts = nx * ny * nz;
+    float *gradients = (float *)malloc(npts * 3 * sizeof(float));
+    float *tempGradients = (float *)malloc(npts * 3 * sizeof(float));
+    int sizes[3] = { nx, ny, nz };
     float spacing[3] = { dx, dy, dz };
-    computeGradients(tempGradients, fdata, sizes, spacing, DATRAW_FLOAT);
+    computeGradients(tempGradients, data, sizes, spacing, DATRAW_FLOAT);
     filterGradients(tempGradients, sizes);
     quantizeGradients(tempGradients, gradients, sizes, DATRAW_FLOAT);
     free(tempGradients);
-    normalizeScalar(fdata, width * height * depth, min, max);
-    float *data = merge(fdata, gradients, width * height * depth);
+    normalizeScalar(data, npts, 1, min, max);
+    float *dataOut = merge(data, gradients, npts);
     free(gradients);
-    return data;
+    return dataOut;
 }
 
@@ -92 +107 @@
  */
 void
-computeSimpleGradient(float *data, int nx, int ny, int nz,
+computeSimpleGradient(float *data,
+                      int nx, int ny, int nz,
                       float dx, float dy, float dz)
 {

trunk/packages/vizservers/nanovis/ReaderCommon.h

@@ -11 +11 @@
 
 extern void
-normalizeScalar(float *fdata, int count, float min, float max);
+normalizeScalar(float *data, int count, int stride, double min, double max);
 
 extern float *
-computeGradient(float *fdata,
-                int width, int height, int depth,
+computeGradient(float *data,
+                int nx, int ny, int nz,
                 float dx, float dy, float dz,
                 float min, float max);
 
 extern void
-computeSimpleGradient(float *data, int nx, int ny, int nz,
+computeSimpleGradient(float *data,
+                      int nx, int ny, int nz,
                       float dx = 1.0f, float dy = 1.0f, float dz = 1.0f);
 

trunk/packages/vizservers/nanovis/VtkReader.cpp

@@ -378 +378 @@
 
 #ifndef DOWNSAMPLE_DATA
-        double dv = vmax - vmin;
-        if (dv == 0.0) {
-            dv = 1.0;
-        }
-
-        int ngen = 0;
-        const int step = 4;
-        for (int i = 0; i < npts; ++i) {
-            double v = data[ngen];
-            // scale all values [0-1], -1 => out of bounds
-            v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
-
-            data[ngen] = v;
-            ngen += step;
-        }
-
+
+        // scale all values [0-1], -1 => out of bounds
+        normalizeScalar(data, npts, 4, vmin, vmax);
         computeSimpleGradient(data, nx, ny, nz,
                               dx, dy, dz);
@@ -453 +440 @@
                     }
 #ifdef FILTER_GRADIENTS
-                    // NOT normalized, -1 => out of bounds
-                    v = (isnan(v)) ? -1.0 : v;
+                    // NOT normalized, may have NaNs (FIXME: how does gradient filter handle NaN?)
                     cdata[ngen] = v;
 #else // !FILTER_GRADIENTS

trunk/packages/vizservers/nanovis/dxReader.cpp

@@ -288 +288 @@
 
         // make sure that we read all of the expected points
-        if (nread != nx*ny*nz) {
+        if (nread != npts) {
             result.addError("inconsistent data: expected %d points"
-                            " but found %d points", nx*ny*nz, nread);
+                            " but found %d points", npts, nread);
             return NULL;
         }
 
 #ifndef DOWNSAMPLE_DATA
-        double dv = vmax - vmin;
-        if (dv == 0.0) {
-            dv = 1.0;
-        }
-
-        int ngen = 0;
-        const int step = 4;
-        for (int i = 0; i < nx*ny*nz; ++i) {
-            double v = data[ngen];
-            // scale all values [0-1], -1 => out of bounds
-            v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
-
-            data[ngen] = v;
-            ngen += step;
-        }
-
+
+        // scale all values [0-1], -1 => out of bounds
+        normalizeScalar(data, npts, 4, vmin, vmax);
         computeSimpleGradient(data, nx, ny, nz,
                               dx, dy, dz);
@@ -370 +357 @@
                     }
 #ifdef FILTER_GRADIENTS
-                    // NOT normalized, -1 => out of bounds
-                    v = (isnan(v)) ? -1.0 : v;
+                    // NOT normalized, may have NaNs (FIXME: how does gradient filter handle NaN?)
                     cdata[ngen] = v;
 #else // !FILTER_GRADIENTS
@@ -422 +408 @@
 
         // make sure that we read all of the expected points
-        if (nread != nxy*nz) {
+        if (nread != npts) {
             result.addError("inconsistent data: expected %d points"
-                            " but found %d points", nxy*nz, nread);
+                            " but found %d points", npts, nread);
             return NULL;
         }