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

Last change on this file since 2892 was 2887, checked in by ldelgass, 12 years ago

Remove some redundant traces

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