- Timestamp:
- Apr 4, 2009, 7:51:31 PM (15 years ago)
- Location:
- trunk/packages/vizservers/nanovis
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/packages/vizservers/nanovis/Command.cpp
r1380 r1381 92 92 extern Texture2D* plane[10]; 93 93 94 bool load_volume_stream(Rappture::Outcome &status, int index,94 extern bool load_volume_stream(Rappture::Outcome &status, int index, 95 95 std::iostream& fin); 96 bool load_volume_stream_odx(Rappture::Outcome &status, int index,96 extern bool load_volume_stream_odx(Rappture::Outcome &status, int index, 97 97 const char *buf, int nBytes); 98 98 extern bool load_volume_stream2(Rappture::Outcome &status, int index, 99 99 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 103 101 extern bool load_vector_stream(Rappture::Outcome &result, int index, 104 s td::istream& fin);102 size_t length, char *bytes); 105 103 extern bool load_vector_stream2(Rappture::Outcome &result, int index, 106 104 size_t length, char *bytes); … … 108 106 Rappture::Unirect3d &data); 109 107 108 extern 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); 110 111 // Tcl interpreter for incoming messages 111 112 … … 691 692 unsigned int flags; 692 693 694 if (buf.size() <= 0) { 695 fprintf(stderr, "encoded DX buffer is empty\n"); 696 } 693 697 flags = RPENC_Z|RPENC_B64|RPENC_HDR; 694 698 if (!Rappture::encoding::decode(err, buf, flags)) { … … 698 702 return TCL_ERROR; 699 703 } 704 if (buf.size() <= 0) { 705 fprintf(stderr, "decoded DX buffer is empty\n"); 706 } 700 707 } 701 708 return TCL_OK; -
trunk/packages/vizservers/nanovis/Unirect.cpp
r1365 r1381 115 115 } 116 116 } else if ((c == 'u') && (strcmp(string, "units") == 0)) { 117 _vUnits= strdup(Tcl_GetString(objv[i+1]));117 vUnits_ = strdup(Tcl_GetString(objv[i+1])); 118 118 } else if ((c == 'o') && (strcmp(string, "order") == 0)) { 119 119 Tcl_Obj **axes; … … 180 180 } 181 181 182 _values= values;183 _nValues= nValues;184 _extents= extents;182 values_ = values; 183 nValues_ = nValues; 184 extents_ = extents; 185 185 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]; 191 191 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]; 197 197 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]; 203 203 if (units[axis1] != NULL) { 204 _zUnits= strdup(units[axis1]);205 } 206 _initialized= true;204 zUnits_ = strdup(units[axis1]); 205 } 206 initialized_ = true; 207 207 return TCL_OK; 208 208 } … … 225 225 axis[1] = 0; /* Y-axis */ 226 226 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; 244 244 245 245 int i; … … 251 251 c = string[0]; 252 252 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) { 254 254 return TCL_ERROR; 255 255 } 256 256 } 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) { 258 258 return TCL_ERROR; 259 259 } … … 268 268 return TCL_ERROR; 269 269 } 270 _xNum= n;270 xNum_ = n; 271 271 } else if ((c == 'x') && (strcmp(string, "xunits") == 0)) { 272 _xUnits= strdup(Tcl_GetString(objv[i+1]));272 xUnits_ = strdup(Tcl_GetString(objv[i+1])); 273 273 } 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) { 275 275 return TCL_ERROR; 276 276 } 277 277 } 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) { 279 279 return TCL_ERROR; 280 280 } … … 289 289 return TCL_ERROR; 290 290 } 291 _yNum= n;291 yNum_ = n; 292 292 } else if ((c == 'y') && (strcmp(string, "yunits") == 0)) { 293 _yUnits= strdup(Tcl_GetString(objv[i+1]));293 yUnits_ = strdup(Tcl_GetString(objv[i+1])); 294 294 } else if ((c == 'v') && (strcmp(string, "values") == 0)) { 295 295 Tcl_Obj **vobj; … … 304 304 return TCL_ERROR; 305 305 } 306 _nValues= n;307 _values = new float[_nValues];306 nValues_ = n; 307 values_ = new float[nValues_]; 308 308 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) { 311 311 return TCL_ERROR; 312 312 } 313 313 } 314 314 } else if ((c == 'u') && (strcmp(string, "units") == 0)) { 315 _vUnits= strdup(Tcl_GetString(objv[i+1]));315 vUnits_ = strdup(Tcl_GetString(objv[i+1])); 316 316 } else if ((c == 'e') && (strcmp(string, "extents") == 0)) { 317 317 int n; … … 325 325 return TCL_ERROR; 326 326 } 327 _extents= n;327 extents_ = n; 328 328 } else if ((c == 'a') && (strcmp(string, "axisorder") == 0)) { 329 329 Tcl_Obj **order; … … 350 350 } 351 351 } 352 if ( _values== NULL) {352 if (values_ == NULL) { 353 353 Tcl_AppendResult(interp, "missing \"values\" key", (char *)NULL); 354 354 return TCL_ERROR; 355 355 } 356 if ( _nValues != (_xNum * _yNum * _extents)) {356 if (nValues_ != (xNum_ * yNum_ * extents_)) { 357 357 Tcl_AppendResult(interp, 358 358 "wrong number of values: must be xnum*ynum*extents", … … 362 362 363 363 fprintf(stderr, "generating %dx%dx%d = %d points\n", 364 _xNum, _yNum, _extents, _xNum * _yNum * _extents);364 xNum_, yNum_, extents_, xNum_ * yNum_ * extents_); 365 365 366 366 #ifndef notdef … … 371 371 float *data, *dp; 372 372 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++) { 375 375 size_t x; 376 376 377 for (x = 0; x < _xNum; x++) {377 for (x = 0; x < xNum_; x++) { 378 378 size_t i, v; 379 379 380 380 /* 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]; 384 384 } 385 dp += _extents;385 dp += extents_; 386 386 } 387 387 } 388 delete [] _values;389 _values= data;388 delete [] values_; 389 values_ = data; 390 390 } 391 391 #endif 392 _initialized= true;392 initialized_ = true; 393 393 return TCL_OK; 394 394 } -
trunk/packages/vizservers/nanovis/Unirect.h
r1365 r1381 7 7 8 8 class 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_; 25 25 26 26 public: 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 27 45 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; 33 51 } 34 52 ~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_); 49 67 } 50 68 } 51 69 size_t xNum(void) { 52 return _xNum;70 return xNum_; 53 71 } 54 72 size_t yNum(void) { 55 return _yNum;73 return yNum_; 56 74 } 57 75 size_t zNum(void) { 58 return _zNum;76 return zNum_; 59 77 } 60 78 float xMin(void) { 61 return _xMin;79 return xMin_; 62 80 } 63 81 float yMin(void) { 64 return _yMin;82 return yMin_; 65 83 } 66 84 float zMin(void) { 67 return _zMin;85 return zMin_; 68 86 } 69 87 float xMax(void) { 70 return _xMax;88 return xMax_; 71 89 } 72 90 float yMax(void) { 73 return _yMax;91 return yMax_; 74 92 } 75 93 float zMax(void) { 76 return _zMax;94 return zMax_; 77 95 } 78 96 const char *xUnits(void) { 79 return _xUnits;97 return xUnits_; 80 98 } 81 99 const char *yUnits(void) { 82 return _yUnits;100 return yUnits_; 83 101 } 84 102 const char *zUnits(void) { 85 return _zUnits;103 return zUnits_; 86 104 } 87 105 const char *vUnits(void) { 88 return _vUnits;106 return vUnits_; 89 107 } 90 108 float *values(void) { 91 return _values;109 return values_; 92 110 } 93 111 float *SaveValues(void) { 94 112 float *values; 95 values = _values;96 _values= NULL;97 _nValues= 0;113 values = values_; 114 values_ = NULL; 115 nValues_ = 0; 98 116 return values; 99 117 } 100 118 size_t nValues(void) { 101 return _nValues;119 return nValues_; 102 120 } 103 121 size_t extents(void) { 104 return _extents;122 return extents_; 105 123 } 106 124 void extents(size_t extents) { 107 _extents= extents;125 extents_ = extents; 108 126 } 109 127 int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv); 110 128 bool isInitialized(void) { 111 return _initialized;129 return initialized_; 112 130 } 113 131 }; 114 132 115 133 class 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_; 130 148 131 149 public: 132 150 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; 138 156 } 139 157 ~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_); 151 169 } 152 170 } 153 171 size_t xNum(void) { 154 return _xNum;172 return xNum_; 155 173 } 156 174 size_t yNum(void) { 157 return _yNum;175 return yNum_; 158 176 } 159 177 float xMin(void) { 160 return _xMin;178 return xMin_; 161 179 } 162 180 float yMin(void) { 163 return _yMin;181 return yMin_; 164 182 } 165 183 float xMax(void) { 166 return _xMax;184 return xMax_; 167 185 } 168 186 float yMax(void) { 169 return _yMax;187 return yMax_; 170 188 } 171 189 const char *xUnits(void) { 172 return _xUnits;190 return xUnits_; 173 191 } 174 192 const char *yUnits(void) { 175 return _yUnits;193 return yUnits_; 176 194 } 177 195 const char *vUnits(void) { 178 return _vUnits;196 return vUnits_; 179 197 } 180 198 float *values(void) { 181 return _values;199 return values_; 182 200 } 183 201 float *acceptValues(void) { 184 202 float *values; 185 values = _values;186 _values= NULL;187 _nValues= 0;203 values = values_; 204 values_ = NULL; 205 nValues_ = 0; 188 206 return values; 189 207 } 190 208 size_t nValues(void) { 191 return _nValues;209 return nValues_; 192 210 } 193 211 size_t extents(void) { 194 return _extents;212 return extents_; 195 213 } 196 214 void extents(size_t extents) { 197 _extents= extents;215 extents_ = extents; 198 216 } 199 217 int LoadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv); 200 218 bool isInitialized(void) { 201 return _initialized;219 return initialized_; 202 220 } 203 221 }; -
trunk/packages/vizservers/nanovis/dxReader.cpp
r1380 r1381 37 37 #include "RpFieldRect3D.h" 38 38 #include "RpFieldPrism3D.h" 39 #include <Unirect.h> 39 40 40 41 //transfer function headers … … 70 71 } 71 72 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) 73 Rappture::Unirect3d * 74 ReadDxVectorFieldData(Rappture::Outcome &result, size_t length, char *string) 78 75 { 79 76 int nx, ny, nz, npts; 80 77 double x0, y0, z0, dx, dy, dz, ddx, ddy, ddz; 81 78 char *p, *endPtr; 79 82 80 83 81 dx = dy = dz = 0.0; // Suppress compiler warning. … … 114 112 result.addError("inconsistent data: expected %d points" 115 113 " but found %d points", nx*ny*nz, npts); 116 return false;114 return NULL; 117 115 } 118 116 break; … … 122 120 result.addError("inconsistent data: expected %d points" 123 121 " but found %d points", nx*ny*nz, npts); 124 return false;122 return NULL; 125 123 } 126 124 break; 127 125 } 128 126 } 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; 148 134 for (int ix=0; ix < nx; ix++) { 149 135 for (int iy=0; iy < ny; iy++) { 150 136 for (int iz=0; iz < nz; iz++) { 151 137 char *line; 152 double vx, vy, vz, vm; 153 154 if ((p == endPtr) || nread > npts) { 138 if ((p == endPtr) || (nValues > npts)) { 155 139 break; 156 140 } … … 159 143 continue; // Skip blank or comment lines. 160 144 } 145 double vx, vy, vz; 161 146 if (sscanf(line, "%lg %lg %lg", &vx, &vy, &vz) == 3) { 162 147 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++; 185 152 } 186 153 } 187 154 } 188 155 } 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 */ 171 bool 172 load_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 } 189 206 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 202 213 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++) { 207 218 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]; 213 222 vm = sqrt(vx*vx + vy*vy + vz*vz); 214 215 223 destPtr[0] = vm / max_mag; 216 224 destPtr[1] = vx /(2.0*max_mag) + 0.5; … … 224 232 225 233 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()); 232 239 volPtr->wAxis.SetRange(min_mag, max_mag); 233 240 volPtr->update_pending = true; 234 241 volPtr->setPhysicalBBox(physicalMin, physicalMax); 235 delete [] data; 242 delete dataPtr; 243 delete data; 236 244 return true; 237 245 } 238 246 239 247 bool 240 load_vector_stream(Rappture::Outcome result, int index, std::istream& fin) 248 load_vector_stream(Rappture::Outcome result, int index, size_t length, 249 char *string) 241 250 { 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 340 298 #ifndef NV40 341 342 343 344 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))); 345 303 #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; 409 363 return true; 410 364 } … … 775 729 } 776 730 777 Rappture::Outcome 778 load_volume_stream( int index, std::iostream& fin)731 bool 732 load_volume_stream(Rappture::Outcome &result, int index, std::iostream& fin) 779 733 { 780 734 printf("load_volume_stream\n"); 781 Rappture::Outcome result;782 735 783 736 Rappture::MeshTri2D xymesh; … … 793 746 fin.getline(line, sizeof(line) - 1); 794 747 if (fin.fail()) { 795 return result.error("error in data stream"); 748 result.error("error in data stream"); 749 return false; 796 750 } 797 751 for (start=line; *start == ' ' || *start == '\t'; start++) … … 851 805 ftri.close(); 852 806 } else { 853 return result.error("triangularization failed"); 807 result.error("triangularization failed"); 808 return false; 854 809 } 855 810 unlink(fpts); … … 902 857 fin.getline(line,sizeof(line)-1); 903 858 if (fin.fail()) { 904 return result.error("error reading data points"); 859 result.addError("error reading data points"); 860 return false; 905 861 } 906 862 int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]); … … 1052 1008 fin >> dval; 1053 1009 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", 1056 1011 nread, npts); 1057 return result.error(mesg);1012 return false; 1058 1013 } else { 1059 1014 int nid = nxy*iz + ixy; … … 1191 1146 } 1192 1147 } else { 1193 return result.error("data not found in stream"); 1148 result.error("data not found in stream"); 1149 return false; 1194 1150 } 1195 1151 … … 1201 1157 float dz0 = -0.5*dz/dx; 1202 1158 NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0)); 1203 return result;1159 return true; 1204 1160 } 1205 1161 1206 Rappture::Outcome 1207 load_volume_stream_insoo(int index, std::iostream& fin) 1162 1163 bool 1164 load_volume_stream_insoo(Rappture::Outcome &result, int index, 1165 std::iostream& fin) 1208 1166 { 1209 1167 printf("load_volume_stream\n"); 1210 Rappture::Outcome result; 1211 1168 1212 1169 Rappture::MeshTri2D xymesh; 1213 1170 int dummy, nx, ny, nz, nxy, npts; … … 1222 1179 fin.getline(line, sizeof(line) - 1); 1223 1180 if (fin.fail()) { 1224 return result.error("error in data stream"); 1181 result.error("error in data stream"); 1182 return false; 1225 1183 } 1226 1184 for (start=line; *start == ' ' || *start == '\t'; start++) … … 1280 1238 ftri.close(); 1281 1239 } else { 1282 return result.error("triangularization failed"); 1240 result.error("triangularization failed"); 1241 return false; 1283 1242 } 1284 1243 unlink(fpts), unlink(fcells); … … 1330 1289 fin.getline(line,sizeof(line)-1); 1331 1290 if (fin.fail()) { 1332 return result.error("error reading data points"); 1291 result.error("error reading data points"); 1292 return false; 1333 1293 } 1334 1294 int n = sscanf(line, "%lg %lg %lg %lg %lg %lg", &dval[0], &dval[1], &dval[2], &dval[3], &dval[4], &dval[5]); … … 1524 1484 sprintf(mesg,"after %d of %d points: can't read number", 1525 1485 nread, npts); 1526 return result.error(mesg); 1486 result.error(mesg); 1487 return false; 1527 1488 } else { 1528 1489 int nid = nxy*iz + ixy; … … 1660 1621 } 1661 1622 } else { 1662 return result.error("data not found in stream"); 1623 result.error("data not found in stream"); 1624 return false; 1663 1625 } 1664 1626 … … 1670 1632 float dz0 = -0.5*dz/dx; 1671 1633 NanoVis::volume[index]->move(Vector3(dx0, dy0, dz0)); 1672 return result;1634 return true; 1673 1635 } -
trunk/packages/vizservers/nanovis/dxReader2.cpp
r1380 r1381 17 17 */ 18 18 bool 19 load_volume_stream_odx(Rappture::Outcome & outcome, int index, const char *buf,19 load_volume_stream_odx(Rappture::Outcome &context, int index, const char *buf, 20 20 int nBytes) 21 21 { … … 23 23 24 24 if (nBytes == 0) { 25 outcome.error("data not found in stream");25 context.error("data not found in stream"); 26 26 return false; 27 27 } … … 40 40 fclose(f); 41 41 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", 43 43 nBytes, dxfilename); 44 44 return false; 45 45 } 46 46 47 Rappture::DX dxObj( outcome, dxfilename);47 Rappture::DX dxObj(context, dxfilename); 48 48 49 49 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; 51 52 } 52 53 -
trunk/packages/vizservers/nanovis/nanovis.cpp
r1380 r1381 73 73 extern void NvInitCG(); // in Shader.cpp 74 74 extern bool load_vector_stream2(Rappture::Outcome &result, int index, 75 s td::istream& fin);75 size_t length, char *string); 76 76 77 77 // Indicates "up" axis: x=1, y=2, z=3, -x=-1, -y=-2, -z=-3 … … 154 154 // in Command.cpp 155 155 extern Tcl_Interp *initTcl(); 156 157 // in dxReader.cpp158 extern void load_vector_stream(int index, std::istream& fin);159 156 160 157 float vert[NMESH*NMESH*3]; //particle positions in main memory … … 1810 1807 { 1811 1808 Rappture::Outcome result; 1812 std::ifstream fdata;1813 fdata.open(filename, std::ios::in); 1814 1809 Rappture::Buffer buf; 1810 1811 buf.load(filename); 1815 1812 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())) { 1818 1814 Volume *volPtr = NanoVis::volume[n]; 1819 1815 if (volPtr != NULL) {
Note: See TracChangeset
for help on using the changeset viewer.