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

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

Remove some more Rappture deps from 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 <RpBuffer.h>
15
16#include <vrmath/Vector3f.h>
17
18#include "Trace.h"
19
20namespace nv {
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, const char *bytes, size_t len);
225
226    bool importDx(size_t nComponents, size_t length, char *string);
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.