Changeset 2861 for trunk


Ignore:
Timestamp:
Mar 16, 2012, 1:23:13 AM (13 years ago)
Author:
ldelgass
Message:

Continue bringing load_volume_stream and load_volume_stream2 in line in
anticipation of merging into a single function.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r2850 r2861  
    6565    do {
    6666        fin.getline(line, sizeof(line) - 1);
     67        if (fin.fail()) {
     68            result.error("error in data stream");
     69            return NULL;
     70        }
    6771        for (start = line; *start == ' ' || *start == '\t'; start++)
    6872            ;  // skip leading blanks
     
    8185                    fin.getline(line,sizeof(line)-1);
    8286                    if (sscanf(line, "%lg %lg %lg", &xx, &yy, &zz) == 3) {
    83                         xymesh.addNode( Rappture::Node2D(xx,yy) );
     87                        xymesh.addNode(Rappture::Node2D(xx,yy));
    8488                    }
    8589                }
     
    176180
    177181    TRACE("found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
    178            nx, ny, nz, x0, y0, z0);
     182          nx, ny, nz, x0, y0, z0);
     183
    179184    // read data points
    180185    if (fin.eof() && (npts > 0)) {
     
    199204        while (!fin.eof() && nread < npts) {
    200205            fin.getline(line,sizeof(line)-1);
     206            if (fin.fail()) {
     207                result.addError("error reading data points");
     208                return NULL;
     209            }
    201210            int n = sscanf(line, "%lg %lg %lg %lg %lg %lg",
    202211                           &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
     
    265274        delete [] data;
    266275    } else {
    267         Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
     276        Rappture::Mesh1D zgrid(z0, z0 + nz*dz, nz);
    268277        Rappture::FieldPrism3D field(xymesh, zgrid);
    269278
     
    371380    if (volPtr) {
    372381        volPtr->location(Vector3(dx0, dy0, dz0));
    373         TRACE("volume moved\n");
     382        TRACE("Set volume location to %g %g %g\n", dx0, dy0, dz0);
    374383    }
    375384    return volPtr;
     
    378387/**
    379388 * \brief Load a 3D volume from a dx-format file
     389 *
     390 * In DX format:
     391 *  rank 0 means scalars,
     392 *  rank 1 means vectors,
     393 *  rank 2 means matrices,
     394 *  rank 3 means tensors
     395 *
     396 *  For rank 1, shape is a single number equal to the number of dimensions.
     397 *  e.g. rank 1 shape 3 means a 3-component vector field
    380398 */
    381399Volume *
     
    417435                    fin.getline(line,sizeof(line)-1);
    418436                    if (sscanf(line, "%lg %lg %lg", &xx, &yy, &zz) == 3) {
    419                         xymesh.addNode( Rappture::Node2D(xx,yy) );
     437                        xymesh.addNode(Rappture::Node2D(xx,yy));
    420438                    }
    421439                }
     
    469487            } else if (sscanf(start, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
    470488                // found one of the delta lines
     489                int count = 0;
    471490                if (ddx != 0.0) {
    472491                    dx = ddx;
    473                 } else if (ddy != 0.0) {
     492                    count++;
     493                }
     494                if (ddy != 0.0) {
    474495                    dy = ddy;
    475                 } else if (ddz != 0.0) {
     496                    count++;
     497                }
     498                if (ddz != 0.0) {
    476499                    dz = ddz;
     500                    count++;
     501                }
     502                if (count > 1) {
     503                    result.addError("don't know how to handle multiple non-zero"
     504                                    " delta values");
     505                    return NULL;
    477506                }
    478507            } else if (sscanf(start, "object %d class array type %s rank 0 items %d data follows",
     
    484513                } else if (!isrect && (npts != nxy*nz)) {
    485514                    result.addError("inconsistent data: expected %d points"
    486                                     " but found %d points", nx*ny*nz, npts);
     515                                    " but found %d points", nxy*nz, npts);
    487516                    return NULL;
    488517                }
     
    499528        }
    500529    }
     530
     531    TRACE("found nx=%d ny=%d, nz=%d, x0=%f, y0=%f, z0=%f\n",
     532          nx, ny, nz, x0, y0, z0);
     533
    501534    // read data points
    502535    if (fin.eof()) {
     
    506539    Volume *volPtr = NULL;
    507540    if (isrect) {
    508         Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
    509         Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
    510         Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
     541        Rappture::Mesh1D xgrid(x0, x0 + nx*dx, nx);
     542        Rappture::Mesh1D ygrid(y0, y0 + ny*dy, ny);
     543        Rappture::Mesh1D zgrid(z0, z0 + nz*dz, nz);
    511544        Rappture::FieldRect3D field(xgrid, ygrid, zgrid);
    512545
     
    542575        if (nread != nx*ny*nz) {
    543576            result.addError("inconsistent data: expected %d points"
    544                             " but found %d points", nx*ny*nz, npts);
     577                            " but found %d points", nx*ny*nz, nread);
    545578            return NULL;
    546579        }
     
    564597#endif
    565598
    566 //#define _SOBEL
     599//#define _SOBEL_
    567600#ifdef _SOBEL_
    568601        const int step = 1;
     
    613646                    double v = field.value(xval,yval,zval);
    614647
     648                    if (v != 0.0 && v < nzero_min) {
     649                        nzero_min = v;
     650                    }
     651
    615652                    // scale all values [0-1], -1 => out of bounds
    616653                    v = (isnan(v)) ? -1.0 : (v - vmin)/dv;
     
    642679        volPtr->update_pending = true;
    643680        // TBD..
    644         // POINTSET
    645         /*
    646           PointSet *pset = new PointSet();
    647           pset->initialize(volPtr, (float*)data);
    648           pset->setVisible(true);
    649           NanoVis::pointSet.push_back(pset);
    650           updateColor(pset);
    651           volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
    652         */
    653 
     681#if 0 && defined(USE_POINTSET_RENDERER)
     682        PointSet *pset = new PointSet();
     683        pset->initialize(volPtr, (float*)data);
     684        pset->setVisible(true);
     685        NanoVis::pointSet.push_back(pset);
     686        updateColor(pset);
     687        volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
     688#endif
    654689        delete [] data;
    655690    } else {
    656         Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
     691        Rappture::Mesh1D zgrid(z0, z0 + nz*dz, nz);
    657692        Rappture::FieldPrism3D field(xymesh, zgrid);
    658693
     
    682717        if (nread != nxy*nz) {
    683718            result.addError("inconsistent data: expected %d points"
    684                             " but found %d points", nx*ny*nz, npts);
     719                            " but found %d points", nxy*nz, nread);
    685720            return NULL;
    686721        }
     
    736771        }
    737772
    738         // Compute the gradient of this data.  BE CAREFUL: center
    739         // calculation on each node to avoid skew in either direction.
    740         ngen = 0;
    741         for (int iz=0; iz < nz; iz++) {
    742             for (int iy=0; iy < ny; iy++) {
    743                 for (int ix=0; ix < nx; ix++) {
    744                     // gradient in x-direction
    745                     double valm1 = (ix == 0) ? 0.0 : data[ngen-1];
    746                     double valp1 = (ix == nx-1) ? 0.0 : data[ngen+1];
    747                     if (valm1 < 0 || valp1 < 0) {
    748                         data[ngen+1] = 0.0;
    749                     } else {
    750                         data[ngen+1] = valp1-valm1; // assume dx=1
    751                         //data[ngen+1] = ((valp1-valm1) + 1.0) * 0.5; // assume dx=1 (ISO)
    752                     }
    753                    
    754                     // gradient in y-direction
    755                     valm1 = (iy == 0) ? 0.0 : data[ngen-4*nx];
    756                     valp1 = (iy == ny-1) ? 0.0 : data[ngen+4*nx];
    757                     if (valm1 < 0 || valp1 < 0) {
    758                         data[ngen+2] = 0.0;
    759                     } else {
    760                         data[ngen+2] = valp1-valm1; // assume dy=1
    761                         //data[ngen+2] = ((valp1-valm1) + 1.0) * 0.5; // assume dy=1 (ISO)
    762                     }
    763                    
    764                     // gradient in z-direction
    765                     valm1 = (iz == 0) ? 0.0 : data[ngen-4*nx*ny];
    766                     valp1 = (iz == nz-1) ? 0.0 : data[ngen+4*nx*ny];
    767                     if (valm1 < 0 || valp1 < 0) {
    768                         data[ngen+3] = 0.0;
    769                     } else {
    770                         data[ngen+3] = valp1-valm1; // assume dz=1
    771                         //data[ngen+3] = ((valp1-valm1) + 1.0) * 0.5; // assume dz=1 (ISO)
    772                     }
    773                    
    774                     ngen += 4;
    775                 }
    776             }
    777         }
     773        computeSimpleGradient(data, nx, ny, nz);
    778774
    779775        volPtr = NanoVis::load_volume(tag, nx, ny, nz, 4, data,
     
    789785        volPtr->update_pending = true;
    790786        // TBD..
    791         // POINTSET
    792         /*
    793           PointSet *pset = new PointSet();
    794           pset->initialize(volPtr, (float*)data);
    795           pset->setVisible(true);
    796           NanoVis::pointSet.push_back(pset);
    797           updateColor(pset);
    798           volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
    799         */
    800 
     787#if 0 && defined(USE_POINTSET_RENDERER)
     788        PointSet *pset = new PointSet();
     789        pset->initialize(volPtr, (float*)data);
     790        pset->setVisible(true);
     791        NanoVis::pointSet.push_back(pset);
     792        updateColor(pset);
     793        volPtr->pointsetIndex = NanoVis::pointSet.size() - 1;
     794#endif
    801795        delete [] data;
    802796    }
     
    810804    if (volPtr) {
    811805        volPtr->location(Vector3(dx0, dy0, dz0));
     806        TRACE("Set volume location to %g %g %g\n", dx0, dy0, dz0);
    812807    }
    813808    return volPtr;
Note: See TracChangeset for help on using the changeset viewer.