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

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

Nanovis refactoring to fix problems with scaling and multiple results.
Do rendering in world space to properly place and scale multiple data sets.
Also fix flows to reduce resets of animations. More work toward removing
Cg dependency. Fix panning to convert viewport coords to world coords.

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