Changeset 1381


Ignore:
Timestamp:
Apr 4, 2009 7:51:31 PM (15 years ago)
Author:
gah
Message:
 
Location:
trunk/packages/vizservers/nanovis
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/packages/vizservers/nanovis/Command.cpp

    r1380 r1381  
    9292extern Texture2D* plane[10];
    9393
    94 bool load_volume_stream(Rappture::Outcome &status, int index,
     94extern bool load_volume_stream(Rappture::Outcome &status, int index,
    9595                        std::iostream& fin);
    96 bool load_volume_stream_odx(Rappture::Outcome &status, int index,
     96extern bool load_volume_stream_odx(Rappture::Outcome &status, int index,
    9797        const char *buf, int nBytes);
    9898extern bool load_volume_stream2(Rappture::Outcome &status, int index,
    9999        std::iostream& fin);
    100 extern void load_volume(int index, int width, int height, int depth,
    101             int n_component, float* data, double vmin, double vmax,
    102             double nzero_min);
     100
    103101extern bool load_vector_stream(Rappture::Outcome &result, int index,
    104         std::istream& fin);
     102        size_t length, char *bytes);
    105103extern bool load_vector_stream2(Rappture::Outcome &result, int index,
    106104        size_t length, char *bytes);
    … …  
    108106        Rappture::Unirect3d &data);
    109107
     108extern void load_volume(int index, int width, int height, int depth,
     109            int n_component, float* data, double vmin, double vmax,
     110            double nzero_min);
    110111// Tcl interpreter for incoming messages
    111112
    … …  
    691692        unsigned int flags;
    692693
     694        if (buf.size() <= 0) {
     695            fprintf(stderr, "encoded DX buffer is empty\n");
     696        }
    693697        flags = RPENC_Z|RPENC_B64|RPENC_HDR;
    694698        if (!Rappture::encoding::decode(err, buf, flags)) {
    … …  
    698702            return TCL_ERROR;
    699703        }
     704        if (buf.size() <= 0) {
     705            fprintf(stderr, "decoded DX buffer is empty\n");
     706        }
    700707    }
    701708    return TCL_OK;

  • trunk/packages/vizservers/nanovis/Unirect.cpp

    r1365 r1381  
    115115            }
    116116        } else if ((c == 'u') && (strcmp(string, "units") == 0)) {
    117             _vUnits = strdup(Tcl_GetString(objv[i+1]));
     117            vUnits_ = strdup(Tcl_GetString(objv[i+1]));
    118118        } else if ((c == 'o') && (strcmp(string, "order") == 0)) {
    119119            Tcl_Obj **axes;
    … …  
    180180    }
    181181
    182     _values = values;
    183     _nValues = nValues;
    184     _extents = extents;
     182    values_ = values;
     183    nValues_ = nValues;
     184    extents_ = extents;
    185185    if (units[3] != NULL) {
    186         _vUnits = strdup(units[3]);
    187     }
    188     _xMin = min[axis3];
    189     _xMax = max[axis3];
    190     _xNum = num[axis3];
     186        vUnits_ = strdup(units[3]);
     187    }
     188    xMin_ = min[axis3];
     189    xMax_ = max[axis3];
     190    xNum_ = num[axis3];
    191191    if (units[axis3] != NULL) {
    192         _xUnits = strdup(units[axis3]);
    193     }
    194     _yMin = min[axis2];
    195     _yMax = max[axis2];
    196     _yNum = num[axis2];
     192        xUnits_ = strdup(units[axis3]);
     193    }
     194    yMin_ = min[axis2];
     195    yMax_ = max[axis2];
     196    yNum_ = num[axis2];
    197197    if (units[axis2] != NULL) {
    198         _yUnits = strdup(units[axis2]);
    199     }
    200     _zMin = min[axis1];
    201     _zMax = max[axis1];
    202     _zNum = num[axis1];
     198        yUnits_ = strdup(units[axis2]);
     199    }
     200    zMin_ = min[axis1];
     201    zMax_ = max[axis1];
     202    zNum_ = num[axis1];
    203203    if (units[axis1] != NULL) {
    204         _zUnits = strdup(units[axis1]);
    205     }
    206     _initialized = true;
     204        zUnits_ = strdup(units[axis1]);
     205    }
     206    initialized_ = true;
    207207    return TCL_OK;
    208208}
    … …  
    225225    axis[1] = 0;                        /* Y-axis */
    226226
    227     _extents = 1;
    228     _xNum = _yNum = _nValues = 0;
    229     _xMin = _yMin = _xMax = _yMax = 0.0f;
    230     if (_xUnits != NULL) {
    231         free(_xUnits);
    232     }
    233     if (_yUnits != NULL) {
    234         free(_yUnits);
    235     }
    236     if (_vUnits != NULL) {
    237         free(_vUnits);
    238     }
    239     _xUnits = _yUnits = _vUnits = NULL;
    240     if (_values != NULL) {
    241         delete [] _values;
    242     }
    243     _values = NULL;
     227    extents_ = 1;
     228    xNum_ = yNum_ = nValues_ = 0;
     229    xMin_ = yMin_ = xMax_ = yMax_ = 0.0f;
     230    if (xUnits_ != NULL) {
     231        free(xUnits_);
     232    }
     233    if (yUnits_ != NULL) {
     234        free(yUnits_);
     235    }
     236    if (vUnits_ != NULL) {
     237        free(vUnits_);
     238    }
     239    xUnits_ = yUnits_ = vUnits_ = NULL;
     240    if (values_ != NULL) {
     241        delete [] values_;
     242    }
     243    values_ = NULL;
    244244
    245245    int i;
    … …  
    251251        c = string[0];
    252252        if ((c == 'x') && (strcmp(string, "xmin") == 0)) {
    253             if (GetFloatFromObj(interp, objv[i+1], &_xMin) != TCL_OK) {
     253            if (GetFloatFromObj(interp, objv[i+1], &xMin_) != TCL_OK) {
    254254                return TCL_ERROR;
    255255            }
    256256        } else if ((c == 'x') && (strcmp(string, "xmax") == 0)) {
    257             if (GetFloatFromObj(interp, objv[i+1], &_xMax) != TCL_OK) {
     257            if (GetFloatFromObj(interp, objv[i+1], &xMax_) != TCL_OK) {
    258258                return TCL_ERROR;
    259259            }
    … …  
    268268                return TCL_ERROR;
    269269            }
    270             _xNum = n;
     270            xNum_ = n;
    271271        } else if ((c == 'x') && (strcmp(string, "xunits") == 0)) {
    272             _xUnits = strdup(Tcl_GetString(objv[i+1]));
     272            xUnits_ = strdup(Tcl_GetString(objv[i+1]));
    273273        } else if ((c == 'y') && (strcmp(string, "ymin") == 0)) {
    274             if (GetFloatFromObj(interp, objv[i+1], &_yMin) != TCL_OK) {
     274            if (GetFloatFromObj(interp, objv[i+1], &yMin_) != TCL_OK) {
    275275                return TCL_ERROR;
    276276            }
    277277        } else if ((c == 'y') && (strcmp(string, "ymax") == 0)) {
    278             if (GetFloatFromObj(interp, objv[i+1], &_yMax) != TCL_OK) {
     278            if (GetFloatFromObj(interp, objv[i+1], &yMax_) != TCL_OK) {
    279279                return TCL_ERROR;
    280280            }
    … …  
    289289                return TCL_ERROR;
    290290            }
    291             _yNum = n;
     291            yNum_ = n;
    292292        } else if ((c == 'y') && (strcmp(string, "yunits") == 0)) {
    293             _yUnits = strdup(Tcl_GetString(objv[i+1]));
     293            yUnits_ = strdup(Tcl_GetString(objv[i+1]));
    294294        } else if ((c == 'v') && (strcmp(string, "values") == 0)) {
    295295            Tcl_Obj **vobj;
    … …  
    304304                return TCL_ERROR;
    305305            }
    306             _nValues = n;
    307             _values = new float[_nValues];
     306            nValues_ = n;
     307            values_ = new float[nValues_];
    308308            size_t j;
    309             for (j = 0; j < _nValues; j++) {
    310                 if (GetFloatFromObj(interp, vobj[j], _values + j)!=TCL_OK) {
     309            for (j = 0; j < nValues_; j++) {
     310                if (GetFloatFromObj(interp, vobj[j], values_ + j)!=TCL_OK) {
    311311                    return TCL_ERROR;
    312312                }
    313313            }
    314314        } else if ((c == 'u') && (strcmp(string, "units") == 0)) {
    315             _vUnits = strdup(Tcl_GetString(objv[i+1]));
     315            vUnits_ = strdup(Tcl_GetString(objv[i+1]));
    316316        } else if ((c == 'e') && (strcmp(string, "extents") == 0)) {
    317317            int n;
    … …  
    325325                return TCL_ERROR;
    326326            }
    327             _extents = n;
     327            extents_ = n;
    328328        } else if ((c == 'a') && (strcmp(string, "axisorder") == 0)) {
    329329            Tcl_Obj **order;
    … …  
    350350        }
    351351    }
    352     if (_values == NULL) {
     352    if (values_ == NULL) {
    353353        Tcl_AppendResult(interp, "missing \"values\" key", (char *)NULL);
    354354        return TCL_ERROR;
    355355    }
    356     if (_nValues != (_xNum * _yNum * _extents)) {
     356    if (nValues_ != (xNum_ * yNum_ * extents_)) {
    357357        Tcl_AppendResult(interp,
    358358                "wrong number of values: must be xnum*ynum*extents",
    … …  
    362362   
    363363    fprintf(stderr, "generating %dx%dx%d = %d points\n",
    364             _xNum, _yNum, _extents, _xNum * _yNum * _extents);
     364            xNum_, yNum_, extents_, xNum_ * yNum_ * extents_);
    365365
    366366#ifndef notdef
    … …  
    371371        float *data, *dp;
    372372
    373         dp = data = new float[_nValues];
    374         for (y = 0; y < _yNum; y++) {
     373        dp = data = new float[nValues_];
     374        for (y = 0; y < yNum_; y++) {
    375375            size_t x;
    376376
    377             for (x = 0; x < _xNum; x++) {
     377            for (x = 0; x < xNum_; x++) {
    378378                size_t i, v;
    379379                   
    380380                /* Compute the index from the data's described ordering. */
    381                 i = (y + (_yNum * x)) * _extents;
    382                 for(v = 0; v < _extents; v++) {
    383                     dp[v] = _values[i+v];
     381                i = (y + (yNum_ * x)) * extents_;
     382                for(v = 0; v < extents_; v++) {
     383                    dp[v] = values_[i+v];
    384384                }
    385                 dp += _extents;
     385                dp += extents_;
    386386            }
    387387        }
    388         delete [] _values;
    389         _values = data;
     388        delete [] values_;
     389        values_ = data;
    390390    }
    391391#endif
    392     _initialized = true;
     392    initialized_ = true;
    393393    return TCL_OK;
    394394}

  • trunk/packages/vizservers/nanovis/Unirect.h

    r1365 r1381  
    77
    88class Unirect3d {
    9     size_t _xNum, _yNum, _zNum;
    10     size_t _nValues;
    11     int _extents;
    12 
    13     float _xMin, _xMax;
    14     float _yMin, _yMax;
    15     float _zMin, _zMax;
    16     float _vMin, _vMax;
    17 
    18     char *_xUnits;
    19     char *_yUnits;
    20     char *_zUnits;
    21     char *_vUnits;
    22 
    23     float *_values;
    24     bool _initialized;
     9    size_t xNum_, yNum_, zNum_;
     10    size_t nValues_;
     11    int extents_;
     12
     13    float xMin_, xMax_;
     14    float yMin_, yMax_;
     15    float zMin_, zMax_;
     16    float vMin_, vMax_;
     17
     18    char *xUnits_;
     19    char *yUnits_;
     20    char *zUnits_;
     21    char *vUnits_;
     22
     23    float *values_;
     24    bool initialized_;
    2525
    2626public:
     27    Unirect3d(float xMin, float xMax, size_t xNum,
     28              float yMin, float yMax, size_t yNum,
     29              float zMin, float zMax, size_t zNum,
     30              size_t nValues, float *values) {
     31        xMax_ = xMax;
     32        xMin_ = xMin;
     33        xNum_ = xNum;
     34        yMax_ = yMax;
     35        yMin_ = yMin;
     36        yNum_ = yNum;
     37        zMax_ = zMax;
     38        zMin_ = zMin;
     39        zNum_ = zNum;
     40        nValues_ = nValues;
     41        values_ = values;
     42        initialized_ = true;
     43    }
     44
    2745    Unirect3d(void) {
    28         _values = NULL;
    29         _initialized = false;
    30         _xNum = _yNum = _zNum = 0;
    31         _nValues = 0;
    32         _xUnits = _yUnits = _zUnits = _vUnits = NULL;
     46        values_ = NULL;
     47        initialized_ = false;
     48        xNum_ = yNum_ = zNum_ = 0;
     49        nValues_ = 0;
     50        xUnits_ = yUnits_ = zUnits_ = vUnits_ = NULL;
    3351    }
    3452    ~Unirect3d(void) {
    35         if (_values != NULL) {
    36             delete [] _values;
    37         }
    38         if (_xUnits != NULL) {
    39             free(_xUnits);
    40         }
    41         if (_yUnits != NULL) {
    42             free(_yUnits);
    43         }
    44         if (_zUnits != NULL) {
    45             free(_zUnits);
    46         }
    47         if (_vUnits != NULL) {
    48             free(_vUnits);
     53        if (values_ != NULL) {
     54            delete [] values_;
     55        }
     56        if (xUnits_ != NULL) {
     57            free(xUnits_);
     58        }
     59        if (yUnits_ != NULL) {
     60            free(yUnits_);
     61        }
     62        if (zUnits_ != NULL) {
     63            free(zUnits_);
     64        }
     65        if (vUnits_ != NULL) {
     66            free(vUnits_);
    4967        }
    5068    }
    5169    size_t xNum(void) {
    52         return _xNum;
     70        return xNum_;
    5371    }
    5472    size_t yNum(void) {
    55         return _yNum;
     73        return yNum_;
    5674    }
    5775    size_t zNum(void) {
    58         return _zNum;
     76        return zNum_;
    5977    }
    6078    float xMin(void) {
    61         return _xMin;
     79        return xMin_;
    6280    }
    6381    float yMin(void) {
    64         return _yMin;
     82        return yMin_;
    6583    }
    6684    float zMin(void) {
    67         return _zMin;
     85        return zMin_;
    6886    }
    6987    float xMax(void) {
    70         return _xMax;
     88        return xMax_;
    7189    }
    7290    float yMax(void) {
    73         return _yMax;
     91        return yMax_;
    7492    }
    7593    float zMax(void) {
    76         return _zMax;
     94        return zMax_;
    7795    }
    7896    const char *xUnits(void) {
    79         return _xUnits;
     97        return xUnits_;
    8098    }
    8199    const char *yUnits(void) {
    82         return _yUnits;
     100        return yUnits_;
    83101    }
    84102    const char *zUnits(void) {
    85         return _zUnits;
     103        return zUnits_;
    86104    }
    87105    const char *vUnits(void) {
    88         return _vUnits;
     106        return vUnits_;
    89107    }
    90108    float *values(void) {
    91         return _values;
     109        return values_;
    92110    }
    93111    float *SaveValues(void) {
    94112        float *values;
    95         values = _values;
    96         _values = NULL;
    97         _nValues = 0;
     113        values = values_;
     114        values_ = NULL;
     115        nValues_ = 0;
    98116        return values;
    99117    }
    100118    size_t nValues(void) {
    101         return _nValues;
     119        return nValues_;
    102120    }
    103121    size_t extents(void) {
    104         return _extents;
     122        return extents_;
    105123    }
    106124    void extents(size_t extents) {
    107         _extents = extents;
     125        extents_ = extents;
    108126    }
    109127    int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
    110128    bool isInitialized(void) {
    111         return _initialized;
     129        return initialized_;
    112130    }
    113131};
    114132
    115133class Unirect2d {
    116     size_t _xNum, _yNum;
    117     size_t _nValues;
    118     size_t _extents;
    119 
    120     float _xMin, _xMax;
    121     float _yMin, _yMax;
    122     float _vMin, _vMax;
    123 
    124     char *_xUnits;
    125     char *_yUnits;
    126     char *_vUnits;
    127 
    128     float *_values;
    129     bool _initialized;
     134    size_t xNum_, yNum_;
     135    size_t nValues_;
     136    size_t extents_;
     137
     138    float xMin_, xMax_;
     139    float yMin_, yMax_;
     140    float vMin_, vMax_;
     141
     142    char *xUnits_;
     143    char *yUnits_;
     144    char *vUnits_;
     145
     146    float *values_;
     147    bool initialized_;
    130148
    131149public:
    132150    Unirect2d(void) {
    133         _values = NULL;
    134         _initialized = false;
    135         _xNum = _yNum = 0;
    136         _nValues = 0;
    137         _xUnits = _yUnits = _vUnits = NULL;
     151        values_ = NULL;
     152        initialized_ = false;
     153        xNum_ = yNum_ = 0;
     154        nValues_ = 0;
     155        xUnits_ = yUnits_ = vUnits_ = NULL;
    138156    }
    139157    ~Unirect2d(void) {
    140         if (_values != NULL) {
    141             delete [] _values;
    142         }
    143         if (_xUnits != NULL) {
    144             free(_xUnits);
    145         }
    146         if (_yUnits != NULL) {
    147             free(_yUnits);
    148         }
    149         if (_vUnits != NULL) {
    150             free(_vUnits);
     158        if (values_ != NULL) {
     159            delete [] values_;
     160        }
     161        if (xUnits_ != NULL) {
     162            free(xUnits_);
     163        }
     164        if (yUnits_ != NULL) {
     165            free(yUnits_);
     166        }
     167        if (vUnits_ != NULL) {
     168            free(vUnits_);
    151169        }
    152170    }
    153171    size_t xNum(void) {
    154         return _xNum;
     172        return xNum_;
    155173    }
    156174    size_t yNum(void) {
    157         return _yNum;
     175        return yNum_;
    158176    }
    159177    float xMin(void) {
    160         return _xMin;
     178        return xMin_;
    161179    }
    162180    float yMin(void) {
    163         return _yMin;
     181        return yMin_;
    164182    }
    165183    float xMax(void) {
    166         return _xMax;
     184        return xMax_;
    167185    }
    168186    float yMax(void) {
    169         return _yMax;
     187        return yMax_;
    170188    }
    171189    const char *xUnits(void) {
    172         return _xUnits;
     190        return xUnits_;
    173191    }
    174192    const char *yUnits(void) {
    175         return _yUnits;
     193        return yUnits_;
    176194    }
    177195    const char *vUnits(void) {
    178         return _vUnits;
     196        return vUnits_;
    179197    }
    180198    float *values(void) {
    181         return _values;
     199        return values_;
    182200    }
    183201    float *acceptValues(void) {
    184202        float *values;
    185         values = _values;
    186         _values = NULL;
    187         _nValues = 0;
     203        values = values_;
     204        values_ = NULL;
     205        nValues_ = 0;
    188206        return values;
    189207    }
    190208    size_t nValues(void) {
    191         return _nValues;
     209        return nValues_;
    192210    }
    193211    size_t extents(void) {
    194         return _extents;
     212        return extents_;
    195213    }
    196214    void extents(size_t extents) {
    197         _extents = extents;
     215        extents_ = extents;
    198216    }
    199217    int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
    200218    bool isInitialized(void) {
    201         return _initialized;
     219        return initialized_;
    202220    }
    203221};

  • trunk/packages/vizservers/nanovis/dxReader.cpp

    r1380 r1381  
    3737#include "RpFieldRect3D.h"
    3838#include "RpFieldPrism3D.h"
     39#include <Unirect.h>
    3940
    4041//transfer function headers
    … …  
    7071}
    7172
    72 /*
    73  * Load a 3D vector field from a dx-format file
    74  */
    75 bool
    76 load_vector_stream2(Rappture::Outcome &result, int ivol, size_t length,
    77                     char *string)
     73Rappture::Unirect3d *
     74ReadDxVectorFieldData(Rappture::Outcome &result, size_t length, char *string)
    7875{
    7976    int nx, ny, nz, npts;
    8077    double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
    8178    char *p, *endPtr;
     79
    8280
    8381    dx = dy = dz = 0.0;         // Suppress compiler warning.
    … …  
    114112                result.addError("inconsistent data: expected %d points"
    115113                                " but found %d points", nx*ny*nz, npts);
    116                 return false;
     114                return NULL;
    117115            }
    118116            break;
    … …  
    122120                result.addError("inconsistent data: expected %d points"
    123121                                " but found %d points", nx*ny*nz, npts);
    124                 return false;
     122                return NULL;
    125123            }
    126124            break;
    127125        }
    128126    }
    129     Vector3 physicalMin;
    130     Vector3 physicalMax;
    131 
    132     physicalMin.set(x0, y0, z0);
    133     physicalMax.set(x0 + dx * nx, y0 + dy * ny, z0 + dz * nz);
    134 
    135     // read data points
    136     float* srcdata = new float[nx * ny * nz * 3];
    137     if (p >= endPtr) {
    138         std::cerr << "WARNING: data not found in stream" << std::endl;
    139         return true;
    140     }
    141 #ifdef notdef
    142     double max_x = -1e21, min_x = 1e21;
    143     double max_y = -1e21, min_y = 1e21;
    144     double max_z = -1e21, min_z = 1e21;
    145 #endif
    146     double max_mag = -1e21, min_mag = 1e21;
    147     int nread = 0;
     127    if (npts != nx*ny*nz) {
     128        result.addError("inconsistent data: expected %d points"
     129                        " but found %d points", nx*ny*nz, npts);
     130        return NULL;
     131    }
     132    float *values = new float[npts];
     133    int nValues = 0;
    148134    for (int ix=0; ix < nx; ix++) {
    149135        for (int iy=0; iy < ny; iy++) {
    150136            for (int iz=0; iz < nz; iz++) {
    151137                char *line;
    152                 double vx, vy, vz, vm;
    153 
    154                 if ((p == endPtr) || nread > npts) {
     138                if ((p == endPtr) || (nValues > npts)) {
    155139                    break;
    156140                }
    … …  
    159143                    continue;   // Skip blank or comment lines.
    160144                }
     145                double vx, vy, vz;
    161146                if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) {
    162147                    int nindex = (iz*nx*ny + iy*nx + ix) * 3;
    163                     srcdata[nindex] = vx;
    164                     //if (srcdata[nindex] > max_x) max_x = srcdata[nindex];
    165                     //if (srcdata[nindex] < min_x) min_x = srcdata[nindex];
    166                     ++nindex;
    167                    
    168                     srcdata[nindex] = vy;
    169                     //if (srcdata[nindex] > max_y) max_y = srcdata[nindex];
    170                     //if (srcdata[nindex] < min_y) min_y = srcdata[nindex];
    171                     ++nindex;
    172                    
    173                     srcdata[nindex] = vz;
    174                     //if (srcdata[nindex] > max_z) max_z = srcdata[nindex];
    175                     //if (srcdata[nindex] < min_z) min_z = srcdata[nindex];
    176                    
    177                     vm = sqrt(vx*vx + vy*vy + vz*vz);
    178                     if (vm > max_mag) {
    179                         max_mag = vm;
    180                     }
    181                     if (vm < min_mag) {
    182                         min_mag = vm;
    183                     }
    184                     ++nread;
     148                    values[nindex] = vx;
     149                    values[nindex+1] = vy;
     150                    values[nindex+2] = vz;
     151                    nValues++;
    185152                }
    186153            }
    187154        }
    188155    }
     156    // make sure that we read all of the expected points
     157    if (nValues != npts) {
     158        result.addError("inconsistent data: expected %d points"
     159                        " but found %d points", npts, nValues);
     160        delete values;
     161        return NULL;
     162    }
     163    return new Rappture::Unirect3d(x0, x0 + dx * nx, nx, y0, y0 + dy * ny, ny,
     164                                   z0, z0 + dz * nz, nz, nValues, values);
     165}
     166
     167
     168/*
     169 * Load a 3D vector field from a dx-format file
     170 */
     171bool
     172load_vector_stream2(Rappture::Outcome &result, int ivol, size_t length,
     173                    char *string)
     174{
     175    Rappture::Unirect3d *dataPtr;
     176    dataPtr = ReadDxVectorFieldData(result, length, string);
     177    if (dataPtr == NULL) {
     178        return false;
     179    }
     180    Vector3 physicalMin;
     181    Vector3 physicalMax;
     182
     183    physicalMin.set(dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
     184    physicalMax.set(dataPtr->xMax(), dataPtr->yMax(), dataPtr->zMax());
     185
     186    double max_mag = -DBL_MAX, min_mag = DBL_MAX;
     187    float *values = dataPtr->values();
     188    for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
     189        for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
     190            for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
     191                double vx, vy, vz, vm;
     192                vx = values[0];
     193                vy = values[1];
     194                vz = values[2];
     195                vm = sqrt(vx*vx + vy*vy + vz*vz);
     196                if (vm > max_mag) {
     197                    max_mag = vm;
     198                }
     199                if (vm < min_mag) {
     200                    min_mag = vm;
     201                }
     202                values += 3;
     203            }
     204        }
     205    }
    189206   
    190     // make sure that we read all of the expected points
    191     if (nread != nx*ny*nz) {
    192         result.addError("inconsistent data: expected %d points"
    193                         " but found %d points", nx*ny*nz, npts);
    194         return false;
    195     }
    196    
    197     float *data = new float[4*nx*ny*nz];
    198     memset(data, 0, sizeof(float) * 4 * nx * ny * nz);
    199     fprintf(stderr, "generating %dx%dx%d = %d points\n", nx, ny, nz, nx*ny*nz);
    200 
    201     // generate the uniformly sampled data that we need for a volume
     207    float *data = new float[4*dataPtr->nValues()];
     208    memset(data, 0, sizeof(float) * 4 * dataPtr->nValues());
     209    fprintf(stderr, "generating %dx%dx%d = %d points\n",
     210            dataPtr->xNum(), dataPtr->yNum(), dataPtr->zNum(),
     211            dataPtr->nValues());
     212
    202213    float *destPtr = data;
    203     float *srcPtr = srcdata;
    204     for (int iz=0; iz < nz; iz++) {
    205         for (int iy=0; iy < ny; iy++) {
    206             for (int ix=0; ix < nx; ix++) {
     214    float *srcPtr = dataPtr->values();
     215    for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
     216        for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
     217            for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
    207218                double vx, vy, vz, vm;
    208 
    209                 vx = srcPtr[0];
    210                 vy = srcPtr[1];
    211                 vz = srcPtr[2];
    212                
     219                vx = values[0];
     220                vy = values[1];
     221                vz = values[2];
    213222                vm = sqrt(vx*vx + vy*vy + vz*vz);
    214                
    215223                destPtr[0] = vm / max_mag;
    216224                destPtr[1] = vx /(2.0*max_mag) + 0.5;
    … …  
    224232   
    225233    Volume *volPtr;
    226     volPtr = NanoVis::load_volume(ivol, nx, ny, nz, 4, data, min_mag, max_mag,
    227         0);
    228    
    229     volPtr->xAxis.SetRange(x0, x0 + nx);
    230     volPtr->yAxis.SetRange(y0, y0 + ny);
    231     volPtr->zAxis.SetRange(z0, z0 + nz);
     234    volPtr = NanoVis::load_volume(ivol, dataPtr->xNum(), dataPtr->yNum(),
     235                dataPtr->zNum(), 4, data, min_mag, max_mag, 0);
     236    volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMax());
     237    volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMax());
     238    volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMax());
    232239    volPtr->wAxis.SetRange(min_mag, max_mag);
    233240    volPtr->update_pending = true;
    234241    volPtr->setPhysicalBBox(physicalMin, physicalMax);
    235     delete [] data;
     242    delete dataPtr;
     243    delete data;
    236244    return true;
    237245}
    238246
    239247bool
    240 load_vector_stream(Rappture::Outcome result, int index, std::istream& fin)
     248load_vector_stream(Rappture::Outcome result, int index, size_t length,
     249                    char *string)
    241250{
    242     int dummy, nx, ny, nz, npts;
    243     double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz;
    244     char line[128], type[128], *start;
    245 
    246     dx = dy = dz = 0.0;         // Suppress compiler warning.
    247     x0 = y0 = z0 = 0.0;         // May not have an origin line.
    248     while (!fin.eof()) {
    249         fin.getline(line, sizeof(line) - 1);
    250         if (fin.fail()) {
    251             result.addError("error in data stream");
    252             return false;
    253         }
    254         for (start=&line[0]; *start == ' ' || *start == '\t'; start++)
    255             ;  // skip leading blanks
    256 
    257         if (*start != '#') {  // skip comment lines
    258             if (sscanf(start, "object %d class gridpositions counts %d %d %d", &dummy, &nx, &ny, &nz) == 4) {
    259                 printf("w:%d h:%d d:%d\n", nx, ny, nz);
    260                 // found grid size
    261             } else if (sscanf(start, "origin %lg %lg %lg", &x0, &y0, &z0) == 3) {
    262                 // found origin
    263             } else if (sscanf(start, "delta %lg %lg %lg", &ddx, &ddy, &ddz) == 3) {
    264                 // found one of the delta lines
    265                 if (ddx != 0.0) {
    266                     dx = ddx;
    267                 } else if (ddy != 0.0) {
    268                     dy = ddy;
    269                 } else if (ddz != 0.0) {
    270                     dz = ddz;
    271                 }
    272             } else if (sscanf(start, "object %d class array type %s shape 3 rank 1 items %d data follows", &dummy, type, &npts) == 3) {
    273                 printf("point %d\n", npts);
    274                 if (npts != nx*ny*nz) {
    275                     result.addError("inconsistent data: expected %d points"
    276                                     " but found %d points", nx*ny*nz, npts);
    277                     return false;
    278                 }
    279                 break;
    280             } else if (sscanf(start, "object %d class array type %s rank 0 times %d data follows", &dummy, type, &npts) == 3) {
    281                 if (npts != nx*ny*nz) {
    282                     result.addError("inconsistent data: expected %d points"
    283                                     " but found %d points", nx*ny*nz, npts);
    284                     return false;
    285                 }
    286                 break;
    287             }
    288         }
    289     }
    290 
    291     // read data points
    292     if (!fin.eof()) {
    293         Rappture::Mesh1D xgrid(x0, x0+nx*dx, nx);
    294         Rappture::Mesh1D ygrid(y0, y0+ny*dy, ny);
    295         Rappture::Mesh1D zgrid(z0, z0+nz*dz, nz);
    296         Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
    297         Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
    298         Rappture::FieldRect3D zfield(xgrid, ygrid, zgrid);
    299 
    300         double vx, vy, vz;
    301         int nread = 0;
    302         for (int ix=0; ix < nx; ix++) {
    303             for (int iy=0; iy < ny; iy++) {
    304                 for (int iz=0; iz < nz; iz++) {
    305                     if (fin.eof() || nread > npts) {
    306                         break;
    307                     }
    308                     fin.getline(line,sizeof(line)-1);
    309                     if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) {
    310                         int nindex = iz*nx*ny + iy*nx + ix;
    311                         xfield.define(nindex, vx);
    312                         yfield.define(nindex, vy);
    313                         zfield.define(nindex, vz);
    314                         nread++;
    315                     }
    316                 }
    317             }
    318         }
    319 
    320         // make sure that we read all of the expected points
    321         if (nread != nx*ny*nz) {
    322             result.addError("inconsistent data: expected %d points"
    323                             " but found %d points", nx*ny*nz, npts);
    324             return false;
    325         }
    326 
    327         // figure out a good mesh spacing
    328         int nsample = 30;
    329         dx = xfield.rangeMax(Rappture::xaxis) - xfield.rangeMin(Rappture::xaxis);
    330         dy = xfield.rangeMax(Rappture::yaxis) - xfield.rangeMin(Rappture::yaxis);
    331         dz = xfield.rangeMax(Rappture::zaxis) - xfield.rangeMin(Rappture::zaxis);
    332         double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
    333 
    334         printf("dx:%lf dy:%lf dz:%lf dmin:%lf\n", dx, dy, dz, dmin);
    335 
    336         nx = (int)ceil(dx/dmin);
    337         ny = (int)ceil(dy/dmin);
    338         nz = (int)ceil(dz/dmin);
    339 
     251    Rappture::Unirect3d *dataPtr;
     252    dataPtr = ReadDxVectorFieldData(result, length, string);
     253    if (dataPtr == NULL) {
     254        return false;
     255    }
     256    Vector3 physicalMin;
     257    Vector3 physicalMax;
     258
     259    physicalMin.set(dataPtr->xMin(), dataPtr->yMin(), dataPtr->zMin());
     260    physicalMax.set(dataPtr->xMax(), dataPtr->yMax(), dataPtr->zMax());
     261
     262    Rappture::Mesh1D xgrid(dataPtr->xMin(), dataPtr->yMin(), dataPtr->xNum());
     263    Rappture::Mesh1D ygrid(dataPtr->yMin(), dataPtr->yMax(), dataPtr->yNum());
     264    Rappture::Mesh1D zgrid(dataPtr->zMin(), dataPtr->zMax(), dataPtr->zNum());
     265    Rappture::FieldRect3D xfield(xgrid, ygrid, zgrid);
     266    Rappture::FieldRect3D yfield(xgrid, ygrid, zgrid);
     267    Rappture::FieldRect3D zfield(xgrid, ygrid, zgrid);
     268   
     269    float *values = dataPtr->values();
     270    size_t npts = 0;
     271    for (size_t ix=0; ix < dataPtr->xNum(); ix++) {
     272        for (size_t iy=0; iy < dataPtr->yNum(); iy++) {
     273            for (size_t iz=0; iz < dataPtr->zNum(); iz++) {
     274                xfield.define(npts, values[0]);
     275                yfield.define(npts, values[1]);
     276                zfield.define(npts, values[2]);
     277                npts++;
     278                values += 3;
     279            }
     280        }
     281    }
     282
     283    double dx, dy, dz;
     284    // figure out a good mesh spacing
     285    int nsample = 30;
     286    dx = xfield.rangeMax(Rappture::xaxis) - xfield.rangeMin(Rappture::xaxis);
     287    dy = xfield.rangeMax(Rappture::yaxis) - xfield.rangeMin(Rappture::yaxis);
     288    dz = xfield.rangeMax(Rappture::zaxis) - xfield.rangeMin(Rappture::zaxis);
     289    double dmin = pow((dx*dy*dz)/(nsample*nsample*nsample), 0.333);
     290
     291    printf("dx:%lf dy:%lf dz:%lf dmin:%lf\n", dx, dy, dz, dmin);
     292
     293    size_t nx, ny, nz;
     294    nx = (int)ceil(dx/dmin);
     295    ny = (int)ceil(dy/dmin);
     296    nz = (int)ceil(dz/dmin);
     297   
    340298#ifndef NV40
    341         // must be an even power of 2 for older cards
    342         nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
    343         ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
    344         nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
     299    // must be an even power of 2 for older cards
     300    nx = (int)pow(2.0, ceil(log10((double)nx)/log10(2.0)));
     301    ny = (int)pow(2.0, ceil(log10((double)ny)/log10(2.0)));
     302    nz = (int)pow(2.0, ceil(log10((double)nz)/log10(2.0)));
    345303#endif
    346 
    347         float *data = new float[4*nx*ny*nz];
    348         memset(data, 0, sizeof(float) * 4 * nx * ny * nz);
    349 
    350         std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
    351 
    352         // generate the uniformly sampled data that we need for a volume
    353         double vmin = 1e21;
    354         double vmax = -1e21;
    355         double nzero_min = 0.0;
    356         int ngen = 0;
    357         for (int iz=0; iz < nz; iz++) {
    358             double zval = z0 + iz*dmin;
    359             for (int iy=0; iy < ny; iy++) {
    360                 double yval = y0 + iy*dmin;
    361                 for (int ix=0; ix < nx; ix++) {
    362                     double xval = x0 + ix*dmin;
    363 
    364                     vx = xfield.value(xval,yval,zval);
    365                     vy = yfield.value(xval,yval,zval);
    366                     vz = zfield.value(xval,yval,zval);
    367 
    368                     double vm;
    369                     vm = sqrt(vx*vx + vy*vy + vz*vz);
    370                     if (vm < vmin) {
    371                         vmin = vm;
    372                     } else if (vm > vmax) {
    373                         vmax = vm;
    374                     }
    375                     if ((vm != 0.0f) && (vm < nzero_min)) {
    376                         nzero_min = vm;
    377                     }
    378                     data[ngen++] = vm;
    379                     data[ngen++] = vx;
    380                     data[ngen++] = vy;
    381                     data[ngen++] = vz;
    382                 }
    383             }
    384         }
    385 
    386         ngen = 0;
    387 
    388         // scale should be accounted.
    389         for (ngen=0; ngen < npts; ) {
    390             data[ngen] = data[ngen] / vmax; ++ngen;
    391             data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    392             data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    393             data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
    394         }
    395         Volume *volPtr;
    396         volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
    397                     nzero_min);
    398 
    399         volPtr->xAxis.SetRange(x0, x0 + (nx * dx));
    400         volPtr->yAxis.SetRange(y0, y0 + (ny * dy));
    401         volPtr->zAxis.SetRange(z0, z0 + (nz * dz));
    402         volPtr->wAxis.SetRange(vmin, vmax);
    403         volPtr->update_pending = true;
    404         delete [] data;
    405     } else {
    406         result.addError("WARNING: data not found in stream");
    407         return false;
    408     }
     304   
     305    float *data = new float[4*nx*ny*nz];
     306    memset(data, 0, sizeof(float) * 4 * nx * ny * nz);
     307   
     308    std::cout << "generating " << nx << "x" << ny << "x" << nz << " = " << nx*ny*nz << " points" << std::endl;
     309   
     310    // generate the uniformly sampled data that we need for a volume
     311    double vmin = 1e21;
     312    double vmax = -1e21;
     313    double nzero_min = 0.0;
     314    size_t ngen = 0;
     315    for (size_t iz=0; iz < nz; iz++) {
     316        double zval = dataPtr->zMin() + iz*dmin;
     317        for (size_t iy=0; iy < ny; iy++) {
     318            double yval = dataPtr->yMin() + iy*dmin;
     319            for (size_t ix=0; ix < nx; ix++) {
     320                double xval = dataPtr->xMin() + ix*dmin;
     321                double vx, vy, vz;
     322
     323                vx = xfield.value(xval,yval,zval);
     324                vy = yfield.value(xval,yval,zval);
     325                vz = zfield.value(xval,yval,zval);
     326               
     327                double vm;
     328                vm = sqrt(vx*vx + vy*vy + vz*vz);
     329                if (vm < vmin) {
     330                    vmin = vm;
     331                } else if (vm > vmax) {
     332                    vmax = vm;
     333                }
     334                if ((vm != 0.0f) && (vm < nzero_min)) {
     335                    nzero_min = vm;
     336                }
     337                data[ngen++] = vm;
     338                data[ngen++] = vx;
     339                data[ngen++] = vy;
     340                data[ngen++] = vz;
     341            }
     342        }
     343    }
     344   
     345    ngen = 0;
     346    // scale should be accounted.
     347    for (ngen=0; ngen < npts; /*empty*/) {
     348        data[ngen] = data[ngen] / vmax; ++ngen;
     349        data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
     350        data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
     351        data[ngen] = (data[ngen]/(2.0*vmax) + 0.5); ++ngen;
     352    }
     353    Volume *volPtr;
     354    volPtr = NanoVis::load_volume(index, nx, ny, nz, 4, data, vmin, vmax,
     355                                  nzero_min);
     356   
     357    volPtr->xAxis.SetRange(dataPtr->xMin(), dataPtr->xMin() + (nx * dx));
     358    volPtr->yAxis.SetRange(dataPtr->yMin(), dataPtr->yMin() + (ny * dy));
     359    volPtr->zAxis.SetRange(dataPtr->zMin(), dataPtr->zMin() + (nz * dz));
     360    volPtr->wAxis.SetRange(vmin, vmax);
     361    volPtr->update_pending = true;
     362    delete [] data;
    409363    return true;
    410364}
    … …  
    775729}
    776730
    777 Rappture::Outcome
    778 load_volume_stream(int index, std::iostream& fin)
     731bool
     732load_volume_stream(Rappture::Outcome &result, int index, std::iostream& fin)
    779733{
    780734    printf("load_volume_stream\n");
    781     Rappture::Outcome result;
    782735
    783736    Rappture::MeshTri2D xymesh;
    … …  
    793746        fin.getline(line, sizeof(line) - 1);
    794747        if (fin.fail()) {
    795             return result.error("error in data stream");
     748            result.error("error in data stream");
     749            return false;
    796750        }
    797751        for (start=line; *start == ' ' || *start == '\t'; start++)
    … …  
    851805                    ftri.close();
    852806                } else {
    853                     return result.error("triangularization failed");
     807                    result.error("triangularization failed");
     808                    return false;
    854809                }
    855810                unlink(fpts);
    … …  
    902857                fin.getline(line,sizeof(line)-1);
    903858                if (fin.fail()) {
    904                     return result.error("error reading data points");
     859                    result.addError("error reading data points");
     860                    return false;
    905861                }
    906862                int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
    … …  
    10521008                fin >> dval;
    10531009                if (fin.fail()) {
    1054                     char mesg[256];
    1055                     sprintf(mesg,"after %d of %d points: can't read number",
     1010                    result.addError("after %d of %d points: can't read number",
    10561011                            nread, npts);
    1057                     return result.error(mesg);
     1012                    return false;
    10581013                } else {
    10591014                    int nid = nxy*iz + ixy;
    … …  
    11911146        }
    11921147    } else {
    1193         return result.error("data not found in stream");
     1148        result.error("data not found in stream");
     1149        return false;
    11941150    }
    11951151
    … …  
    12011157    float dz0 = -0.5*dz/dx;
    12021158    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
    1203     return result;
     1159    return true;
    12041160}
    12051161
    1206 Rappture::Outcome
    1207 load_volume_stream_insoo(int index, std::iostream& fin)
     1162
     1163bool
     1164load_volume_stream_insoo(Rappture::Outcome &result, int index,
     1165                         std::iostream& fin)
    12081166{
    12091167    printf("load_volume_stream\n");
    1210     Rappture::Outcome result;
    1211 
     1168 
    12121169    Rappture::MeshTri2D xymesh;
    12131170    int dummy, nx, ny, nz, nxy, npts;
    … …  
    12221179        fin.getline(line, sizeof(line) - 1);
    12231180        if (fin.fail()) {
    1224             return result.error("error in data stream");
     1181            result.error("error in data stream");
     1182            return false;
    12251183        }
    12261184        for (start=line; *start == ' ' || *start == '\t'; start++)
    … …  
    12801238                    ftri.close();
    12811239                } else {
    1282                     return result.error("triangularization failed");
     1240                    result.error("triangularization failed");
     1241                    return false;
    12831242                }
    12841243                unlink(fpts), unlink(fcells);
    … …  
    13301289                fin.getline(line,sizeof(line)-1);
    13311290                if (fin.fail()) {
    1332                     return result.error("error reading data points");
     1291                    result.error("error reading data points");
     1292                    return false;
    13331293                }
    13341294                int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]);
    … …  
    15241484                    sprintf(mesg,"after %d of %d points: can't read number",
    15251485                            nread, npts);
    1526                     return result.error(mesg);
     1486                    result.error(mesg);
     1487                    return false;
    15271488                } else {
    15281489                    int nid = nxy*iz + ixy;
    … …  
    16601621        }
    16611622    } else {
    1662         return result.error("data not found in stream");
     1623        result.error("data not found in stream");
     1624        return false;
    16631625    }
    16641626
    … …  
    16701632    float dz0 = -0.5*dz/dx;
    16711633    NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0));
    1672     return result;
     1634    return true;
    16731635}

  • trunk/packages/vizservers/nanovis/dxReader2.cpp

    r1380 r1381  
    1717 */
    1818bool
    19 load_volume_stream_odx(Rappture::Outcome &outcome, int index, const char *buf,
     19load_volume_stream_odx(Rappture::Outcome &context, int index, const char *buf,
    2020                       int nBytes)
    2121{
    … …  
    2323
    2424    if (nBytes == 0) {
    25         outcome.error("data not found in stream");
     25        context.error("data not found in stream");
    2626        return false;
    2727    }
    … …  
    4040    fclose(f);
    4141    if (nWritten != nBytes) {
    42         outcome.addError("Can't read %d bytes from file \"%s\"\n",
     42        context.addError("Can't read %d bytes from file \"%s\"\n",
    4343                         nBytes, dxfilename);
    4444        return false;
    4545    }
    4646
    47     Rappture::DX dxObj(outcome, dxfilename);
     47    Rappture::DX dxObj(context, dxfilename);
    4848
    4949    if (unlink(dxfilename) != 0) {
    50         outcome.addError("Error deleting dx file: %s\n", dxfilename);
     50        context.addError("Error deleting dx file: %s\n", dxfilename);
     51        return false;
    5152    }
    5253

  • trunk/packages/vizservers/nanovis/nanovis.cpp

    r1380 r1381  
    7373extern void NvInitCG(); // in Shader.cpp
    7474extern bool load_vector_stream2(Rappture::Outcome &result, int index,
    75         std::istream& fin);
     75        size_t length, char *string);
    7676
    7777// Indicates "up" axis:  x=1, y=2, z=3, -x=-1, -y=-2, -z=-3
    … …  
    154154// in Command.cpp
    155155extern Tcl_Interp *initTcl();
    156 
    157 // in dxReader.cpp
    158 extern void load_vector_stream(int index, std::istream& fin);
    159156
    160157float vert[NMESH*NMESH*3];              //particle positions in main memory
    … …  
    18101807{
    18111808    Rappture::Outcome result;
    1812     std::ifstream fdata;
    1813     fdata.open(filename, std::ios::in);
    1814    
     1809    Rappture::Buffer buf;
     1810
     1811    buf.load(filename);
    18151812    int n = NanoVis::n_volumes;
    1816     //fdata.write(buf.bytes(),buf.size());
    1817     if (load_vector_stream2(result, n, fdata)) {
     1813    if (load_vector_stream2(result, n, buf.size(), buf.bytes())) {
    18181814        Volume *volPtr = NanoVis::volume[n];
    18191815        if (volPtr != NULL) {
Note: See TracChangeset for help on using the changeset viewer.