source: nanovis/branches/1.1/Unirect.h @ 4804

Last change on this file since 4804 was 3502, checked in by ldelgass, 7 years ago

Add basic VTK structured points reader to nanovis, update copyright dates.

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