source: trunk/packages/vizservers/nanovis/Unirect.h @ 3935

Last change on this file since 3935 was 3935, checked in by ldelgass, 6 years ago

First pass at loading VTK vector data for flows in nanovis

  • Property svn:eol-style set to native
File size: 7.0 KB
Line 
1/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2/*
3 * Copyright (C) 2004-2013  HUBzero Foundation, LLC
4 *
5 * Author: George A. Howlett <gah@purdue.edu>
6 */
7#ifndef RAPPTURE_UNIRECT_H
8#define RAPPTURE_UNIRECT_H
9
10#include <float.h>
11
12#include <tcl.h>
13
14#include <rappture.h>
15
16#include <vrmath/Vector3f.h>
17
18#include "Trace.h"
19
20namespace Rappture {
21
22class Unirect2d;
23
24class Unirect3d
25{
26public:
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, size_t nComponents) :
31        _xNum(xNum), _yNum(yNum), _zNum(zNum), 
32        _nValues(nValues), 
33        _nComponents(nComponents),
34        _xMin(xMin), _xMax(xMax), 
35        _yMin(yMin), _yMax(yMax), 
36        _zMin(zMin), _zMax(zMax),
37        _xValueMin(FLT_MAX), _xValueMax(-FLT_MAX),
38        _yValueMin(FLT_MAX), _yValueMax(-FLT_MAX),
39        _zValueMin(FLT_MAX), _zValueMax(-FLT_MAX),
40        _magMin(DBL_MAX), _magMax(-DBL_MAX),
41        _xUnits(NULL), _yUnits(NULL), _zUnits(NULL), _vUnits(NULL),
42        _values(NULL),
43        _initialized(false)
44    {
45        _initialized = true;
46    }
47
48    Unirect3d(size_t nComponents = 1) :
49        _nValues(0), 
50        _nComponents(nComponents),
51        _xValueMin(FLT_MAX), _xValueMax(-FLT_MAX),
52        _yValueMin(FLT_MAX), _yValueMax(-FLT_MAX),
53        _zValueMin(FLT_MAX), _zValueMax(-FLT_MAX),
54        _magMin(DBL_MAX), _magMax(-DBL_MAX),
55        _xUnits(NULL), _yUnits(NULL), _zUnits(NULL), _vUnits(NULL),
56        _values(NULL),
57        _initialized(false)
58    {
59        _nComponents = nComponents;
60    }
61
62    ~Unirect3d()
63    {
64        if (_values != NULL) {
65            free(_values);
66        }
67        if (_xUnits != NULL) {
68            free(_xUnits);
69        }
70        if (_yUnits != NULL) {
71            free(_yUnits);
72        }
73        if (_zUnits != NULL) {
74            free(_zUnits);
75        }
76        if (_vUnits != NULL) {
77            free(_vUnits);
78        }
79    }
80
81    size_t xNum()
82    {
83        return _xNum;
84    }
85
86    size_t yNum()
87    {
88        return _yNum;
89    }
90
91    size_t zNum()
92    {
93        return _zNum;
94    }
95
96    float xMin()
97    {
98        return _xMin;
99    }
100
101    float yMin()
102    {
103        return _yMin;
104    }
105
106    float zMin()
107    {
108        return _zMin;
109    }
110
111    float xMax()
112    {
113        return _xMax;
114    }
115
116    float yMax()
117    {
118        return _yMax;
119    }
120
121    float zMax()
122    {
123        return _zMax;
124    }
125
126    float xValueMin()
127    {
128        return _xValueMin;
129    }
130
131    float yValueMin()
132    {
133        return _yValueMin;
134    }
135
136    float zValueMin()
137    {
138        return _zValueMin;
139    }
140
141    float xValueMax()
142    {
143        return _xValueMax;
144    }
145
146    float yValueMax()
147    {
148        return _yValueMax;
149    }
150
151    float zValueMax()
152    {
153        return _zValueMax;
154    }
155
156    size_t nComponents()
157    {
158        return _nComponents;
159    }
160
161    const char *xUnits()
162    {
163        return _xUnits;
164    }
165
166    const char *yUnits()
167    {
168        return _yUnits;
169    }
170    const char *zUnits()
171    {
172        return _zUnits;
173    }
174
175    const char *vUnits()
176    {
177        return _vUnits;
178    }
179
180    const float *values()
181    {
182        return _values;
183    }
184
185    double magMin()
186    {
187        if (_magMin == DBL_MAX) {
188            getVectorRange();
189        }
190        return _magMin;
191    }
192
193    double magMax()
194    {
195        if (_magMax == -DBL_MAX) {
196            getVectorRange();
197        }
198        return _magMax;
199    }
200
201    void getBounds(vrmath::Vector3f& bboxMin,
202                   vrmath::Vector3f& bboxMax) const
203    {
204        bboxMin.set(_xMin, _yMin, _zMin);
205        bboxMax.set(_xMax, _yMax, _zMax);
206    }
207
208    const float *SaveValues()
209    {
210        float *values;
211        values = _values;
212        _values = NULL;
213        _nValues = 0;
214        return values;
215    }
216
217    size_t nValues()
218    {
219        return _nValues;
220    }
221
222    int loadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
223
224    int parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf);
225
226    bool importDx(Rappture::Outcome &result, size_t nComponents, 
227                  size_t length, char *string);
228
229    bool convert(Unirect2d *dataPtr);
230
231    bool isInitialized()
232    {
233        return _initialized;
234    }
235
236private:
237    void getVectorRange();
238
239    size_t _xNum, _yNum, _zNum;
240    size_t _nValues;
241    size_t _nComponents;
242    float _xMin, _xMax, _yMin, _yMax, _zMin, _zMax;
243    float _xValueMin, _xValueMax;
244    float _yValueMin, _yValueMax;
245    float _zValueMin, _zValueMax;
246    double _magMin, _magMax;                /* Range of magnitudes of vector
247                                             * data. */
248    char *_xUnits;
249    char *_yUnits;
250    char *_zUnits;
251    char *_vUnits;
252
253    float *_values;
254    bool _initialized;
255};
256
257class Unirect2d
258{
259public:
260    Unirect2d(size_t nComponents = 1) :
261        _xNum(0), _yNum(0),
262        _nValues(0),
263        _nComponents(nComponents),
264        _xUnits(NULL), _yUnits(NULL), _vUnits(NULL),
265        _values(NULL),
266        _initialized(false)
267    {
268    }
269
270    ~Unirect2d()
271    {
272        if (_values != NULL) {
273            free(_values);
274        }
275        if (_xUnits != NULL) {
276            free(_xUnits);
277        }
278        if (_yUnits != NULL) {
279            free(_yUnits);
280        }
281        if (_vUnits != NULL) {
282            free(_vUnits);
283        }
284    }
285
286    size_t xNum()
287    {
288        return _xNum;
289    }
290
291    size_t yNum()
292    {
293        return _yNum;
294    }
295
296    float xMin()
297    {
298        return _xMin;
299    }
300
301    float yMin()
302    {
303        return _yMin;
304    }
305
306    float xMax()
307    {
308        return _xMax;
309    }
310
311    float yMax()
312    {
313        return _yMax;
314    }
315
316    const char *xUnits()
317    {
318        return _xUnits;
319    }
320
321    const char *yUnits()
322    {
323        return _yUnits;
324    }
325
326    const char *vUnits()
327    {
328        return _vUnits;
329    }
330
331    float *values()
332    {
333        return _values;
334    }
335
336    float xValueMin()
337    {
338        return _xValueMin;
339    }
340
341    float yValueMin()
342    {
343        return _yValueMin;
344    }
345
346    float xValueMax()
347    {
348        return _xValueMax;
349    }
350
351    float yValueMax()
352    {
353        return _yValueMax;
354    }
355
356    size_t nComponents()
357    {
358        return _nComponents;
359    }
360
361    void getBounds(vrmath::Vector3f& bboxMin,
362                   vrmath::Vector3f& bboxMax) const
363    {
364        bboxMin.set(_xMin, _yMin, 0);
365        bboxMax.set(_xMax, _yMax, 0);
366    }
367
368    float *transferValues()
369    {
370        float *values;
371        values = _values;
372        _values = NULL;
373        _nValues = 0;
374        return values;
375    }
376
377    size_t nValues()
378    {
379        return _nValues;
380    }
381
382    int loadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
383
384    int parseBuffer(Tcl_Interp *interp, Rappture::Buffer &buf);
385
386    bool isInitialized()
387    {
388        return _initialized;
389    }
390
391private:
392    size_t _xNum, _yNum;
393    size_t _nValues;
394    size_t _nComponents;
395
396    float _xMin, _xMax;
397    float _yMin, _yMax;
398    float _xValueMin, _xValueMax;
399    float _yValueMin, _yValueMax;
400
401    char *_xUnits;
402    char *_yUnits;
403    char *_vUnits;
404
405    float *_values;
406    bool _initialized;
407};
408
409}
410
411#endif
Note: See TracBrowser for help on using the repository browser.