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

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

Remove obsolete include

  • Property svn:eol-style set to native
File size: 6.9 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    bool importDx(size_t nComponents, size_t length, char *string);
225
226    bool convert(Unirect2d *dataPtr);
227
228    bool isInitialized()
229    {
230        return _initialized;
231    }
232
233private:
234    void getVectorRange();
235
236    size_t _xNum, _yNum, _zNum;
237    size_t _nValues;
238    size_t _nComponents;
239    float _xMin, _xMax, _yMin, _yMax, _zMin, _zMax;
240    float _xValueMin, _xValueMax;
241    float _yValueMin, _yValueMax;
242    float _zValueMin, _zValueMax;
243    double _magMin, _magMax;                /* Range of magnitudes of vector
244                                             * data. */
245    char *_xUnits;
246    char *_yUnits;
247    char *_zUnits;
248    char *_vUnits;
249
250    float *_values;
251    bool _initialized;
252};
253
254class Unirect2d
255{
256public:
257    Unirect2d(size_t nComponents = 1) :
258        _xNum(0), _yNum(0),
259        _nValues(0),
260        _nComponents(nComponents),
261        _xUnits(NULL), _yUnits(NULL), _vUnits(NULL),
262        _values(NULL),
263        _initialized(false)
264    {
265    }
266
267    ~Unirect2d()
268    {
269        if (_values != NULL) {
270            free(_values);
271        }
272        if (_xUnits != NULL) {
273            free(_xUnits);
274        }
275        if (_yUnits != NULL) {
276            free(_yUnits);
277        }
278        if (_vUnits != NULL) {
279            free(_vUnits);
280        }
281    }
282
283    size_t xNum()
284    {
285        return _xNum;
286    }
287
288    size_t yNum()
289    {
290        return _yNum;
291    }
292
293    float xMin()
294    {
295        return _xMin;
296    }
297
298    float yMin()
299    {
300        return _yMin;
301    }
302
303    float xMax()
304    {
305        return _xMax;
306    }
307
308    float yMax()
309    {
310        return _yMax;
311    }
312
313    const char *xUnits()
314    {
315        return _xUnits;
316    }
317
318    const char *yUnits()
319    {
320        return _yUnits;
321    }
322
323    const char *vUnits()
324    {
325        return _vUnits;
326    }
327
328    float *values()
329    {
330        return _values;
331    }
332
333    float xValueMin()
334    {
335        return _xValueMin;
336    }
337
338    float yValueMin()
339    {
340        return _yValueMin;
341    }
342
343    float xValueMax()
344    {
345        return _xValueMax;
346    }
347
348    float yValueMax()
349    {
350        return _yValueMax;
351    }
352
353    size_t nComponents()
354    {
355        return _nComponents;
356    }
357
358    void getBounds(vrmath::Vector3f& bboxMin,
359                   vrmath::Vector3f& bboxMax) const
360    {
361        bboxMin.set(_xMin, _yMin, 0);
362        bboxMax.set(_xMax, _yMax, 0);
363    }
364
365    float *transferValues()
366    {
367        float *values;
368        values = _values;
369        _values = NULL;
370        _nValues = 0;
371        return values;
372    }
373
374    size_t nValues()
375    {
376        return _nValues;
377    }
378
379    int loadData(Tcl_Interp *interp, int objc, Tcl_Obj *const *objv);
380
381    int parseBuffer(Tcl_Interp *interp, const char *bytes, size_t len);
382
383    bool isInitialized()
384    {
385        return _initialized;
386    }
387
388private:
389    size_t _xNum, _yNum;
390    size_t _nValues;
391    size_t _nComponents;
392
393    float _xMin, _xMax;
394    float _yMin, _yMax;
395    float _xValueMin, _xValueMax;
396    float _yValueMin, _yValueMax;
397
398    char *_xUnits;
399    char *_yUnits;
400    char *_vUnits;
401
402    float *_values;
403    bool _initialized;
404};
405
406}
407
408#endif
Note: See TracBrowser for help on using the repository browser.