source: nanovis/trunk/Unirect.h @ 4822

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

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