source: trunk/packages/vizservers/nanovis/ContourLineFilter.cpp @ 1018

Last change on this file since 1018 was 1000, checked in by vrinside, 12 years ago
File size: 8.7 KB
Line 
1
2/*
3 * @note : I refer to 'http://www.codeproject.com/useritems/ScoOterVisualizationPart2.asp'
4 * @note : for this class
5 */
6
7#include "ContourLineFilter.h"
8#include <R2/graphics/R2VertexBuffer.h>
9#include <stdlib.h>
10#include <memory.h>
11#include "Vector4.h"
12#include "Vector3.h"
13
14ContourLineFilter::ContourLineFilter()
15    : _colorMap(0), _top(false)
16{
17}
18
19void 
20ContourLineFilter::clear()
21{
22       
23    ContourLineFilter::ContourLineList::iterator iter;
24    for (iter = _lines.begin(); iter != _lines.end(); ++iter) { 
25        delete (*iter);
26    }
27    _lines.clear();     
28}
29
30R2Geometry* 
31ContourLineFilter::create(float min, float max, int linecount, 
32                          Vector3* vertices, int width, int height)
33{
34    _lines.clear();
35   
36    float transtion = (max - min) / (linecount + 1);
37   
38    float val;
39    int totalNumOfPoints = 0, numOfPoints;
40    for (int i = 1; i <= linecount; ++i) {
41        val = min + i * transtion;
42       
43        ContourLine* c = new ContourLine(val);
44        numOfPoints = c->createLine(width, height, vertices, _top);
45        if (numOfPoints != 0) {
46            totalNumOfPoints += numOfPoints;
47            _lines.push_back(c);
48        } else {
49            delete c;
50        }
51    }
52   
53    Vector3* vertexSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
54    Vector3* colorSet = 0;
55    if (_colorMap) {
56        colorSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
57    }
58   
59    ContourLineFilter::ContourLineList::iterator iter;
60    unsigned int index = 0, colorIndex = 0;
61    for (iter = _lines.begin(); iter != _lines.end(); ++iter, ++colorIndex) {
62        std::list<Vector3>& lines = (*iter)->_points;
63        std::list<Vector3>::iterator iter2;
64        for (iter2 = lines.begin(); iter2 != lines.end(); ++iter2, ++index) {
65            if (_colorMap && (colorIndex < _colorMap->size())) {
66                colorSet[index] = _colorMap->at(colorIndex);
67            } else {
68                //colorSet[index].set((*iter)->_value, (*iter)->_value, (*iter)->_value);
69            }
70            vertexSet[index] = (*iter2);
71        }
72    }
73   
74    R2VertexBuffer* vertexBuffer;
75    vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3, 
76                                      totalNumOfPoints,
77                                      totalNumOfPoints * sizeof(Vector3), 
78                                      vertexSet, false);
79    R2VertexBuffer* colorBuffer = 0;
80    R2Geometry* geometry = 0;
81    if (_colorMap) {
82        colorBuffer  = new R2VertexBuffer(R2VertexBuffer::COLOR4, 
83                                          totalNumOfPoints,
84                                          totalNumOfPoints * sizeof(Vector3), 
85                                          colorSet, false);
86    }
87
88    geometry = new R2Geometry(R2Geometry::LINES, vertexBuffer, colorBuffer, 0);
89    clear();
90    return geometry;
91}
92
93R2Geometry* 
94ContourLineFilter::create(float min, float max, int linecount, 
95                          Vector4* vertices, int width, int height)
96{
97    _lines.clear();
98
99    float transtion = (max - min) / (linecount + 1);
100
101    float val;
102    int totalNumOfPoints = 0, numOfPoints;
103    for (int i = 1; i <= linecount; ++i) {
104        val = min + i * transtion;
105       
106        ContourLine* c = new ContourLine(val);
107        numOfPoints = c->createLine(width, height, vertices, _top);
108        if (numOfPoints != 0) {
109            totalNumOfPoints += numOfPoints;
110            _lines.push_back(c);
111        } else {
112            delete c;
113        }
114    }
115    Vector3* vertexSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
116    Vector3* colorSet = (Vector3*) malloc(sizeof(Vector3) * totalNumOfPoints);
117       
118    ContourLineFilter::ContourLineList::iterator iter;
119    unsigned int index = 0, colorIndex = 0;
120    for (iter = _lines.begin(); iter != _lines.end(); ++iter, ++colorIndex) {
121        std::list<Vector3>& lines = (*iter)->_points;
122        std::list<Vector3>::iterator iter2;
123        for (iter2 = lines.begin(); iter2 != lines.end(); ++iter2, ++index) {
124            if (_colorMap && (colorIndex < _colorMap->size())) {
125                colorSet[index] = _colorMap->at(colorIndex);
126            } else {
127                colorSet[index].set((*iter)->_value, (*iter)->_value, 
128                                    (*iter)->_value);
129            }
130            vertexSet[index] = (*iter2);
131        }
132    }
133    R2VertexBuffer* vertexBuffer;
134    vertexBuffer = new R2VertexBuffer(R2VertexBuffer::POSITION3,
135                                      totalNumOfPoints,
136                                      totalNumOfPoints * sizeof(Vector3), 
137                                      vertexSet, false);
138    R2VertexBuffer* colorBuffer;
139    colorBuffer = new R2VertexBuffer(R2VertexBuffer::COLOR4, totalNumOfPoints,
140                                     totalNumOfPoints * sizeof(Vector3), 
141                                     colorSet, false);
142    R2Geometry* geometry;
143    geometry = new R2Geometry(R2Geometry::LINES, vertexBuffer, colorBuffer, 0);
144    clear();
145    return geometry;
146}
147
148
149ContourLineFilter::ContourLine::ContourLine(float value)
150    : _value(value)
151{
152}
153
154
155int 
156ContourLineFilter::ContourLine::createLine(int width, int height, 
157                                           Vector3* vertices, bool top)
158{
159    _points.clear();
160
161    int hl = height - 1;
162    int wl = width - 1;
163    int index1, index2, index3, index4;
164    for (int i = 0; i < hl; ++i) {
165        for (int j = 0; j < wl; ++j) {
166            index1 = j + i * width;
167            index2 = j + 1 + i * width;
168            index3 = j + 1 + (i + 1) * width;
169            index4 = j + (i + 1) * width;
170           
171            if (isValueWithIn(vertices[index1].y, vertices[index2].y)) 
172                getContourPoint(index1, index2, vertices, width, top);
173            if (isValueWithIn(vertices[index2].y, vertices[index3].y)) 
174                getContourPoint(index2, index3, vertices, width, top);
175            if (isValueWithIn(vertices[index3].y, vertices[index1].y)) 
176                getContourPoint(index3, index1, vertices, width, top);
177           
178            if (isValueWithIn(vertices[index1].y, vertices[index3].y)) 
179                getContourPoint(index1, index3, vertices, width, top);
180            if (isValueWithIn(vertices[index3].y, vertices[index4].y)) 
181                getContourPoint(index3, index4, vertices, width, top);
182            if (isValueWithIn(vertices[index4].y, vertices[index1].y)) 
183                getContourPoint(index4, index1, vertices, width, top);
184        }
185    }
186    return _points.size();
187}
188
189
190int 
191ContourLineFilter::ContourLine::createLine(int width, int height, 
192                                           Vector4* vertices, bool top)
193{
194    _points.clear();
195
196    int hl = height - 1;
197    int wl = width - 1;
198    int index1, index2, index3, index4;
199    for (int i = 0; i < hl; ++i) {
200        for (int j = 0; j < wl; ++j) {
201            index1 = j + i * width;
202            index2 = j + 1 + i * width;
203            index3 = j + 1 + (i + 1) * width;
204            index4 = j + (i + 1) * width;
205           
206            if (isValueWithIn(vertices[index1].y, vertices[index2].y)) 
207                getContourPoint(index1, index2, vertices, width, top);
208            if (isValueWithIn(vertices[index2].y, vertices[index3].y)) 
209                getContourPoint(index2, index3, vertices, width, top);
210            if (isValueWithIn(vertices[index3].y, vertices[index1].y)) 
211                getContourPoint(index3, index1, vertices, width, top);
212           
213            if (isValueWithIn(vertices[index1].y, vertices[index3].y)) 
214                getContourPoint(index1, index3, vertices, width, top);
215            if (isValueWithIn(vertices[index3].y, vertices[index4].y)) 
216                getContourPoint(index3, index4, vertices, width, top);
217            if (isValueWithIn(vertices[index4].y, vertices[index1].y)) 
218                getContourPoint(index4, index1, vertices, width, top);
219        }
220    }
221   
222    return _points.size();
223}
224
225bool 
226ContourLineFilter::ContourLine::isValueWithIn(float val1, float Val2)
227{
228    return ((_value >= val1 && _value <= Val2) || 
229            (_value >= Val2 && _value <= val1));
230}
231
232void 
233ContourLineFilter::ContourLine::getContourPoint(int vertexIndex1, 
234        int vertexIndex2, Vector3* vertices, int width, bool top)
235{
236    float diff = vertices[vertexIndex2].y - vertices[vertexIndex1].y;
237    float t = 0.0;
238    if (diff != 0) {
239            t = (_value - vertices[vertexIndex1].y) / diff; 
240    }
241
242    Vector3 p;
243    p.x = vertices[vertexIndex1].x + t * 
244        (vertices[vertexIndex2].x - vertices[vertexIndex1].x);
245
246    if (top)
247    {
248        p.y = 1.0f;
249    }
250    else
251    {
252    p.y = vertices[vertexIndex1].y + t * 
253        (vertices[vertexIndex2].y - vertices[vertexIndex1].y);
254    }
255
256    p.z = vertices[vertexIndex1].z + t * 
257        (vertices[vertexIndex2].z - vertices[vertexIndex1].z);
258    _points.push_back(p);
259}
260
261void 
262ContourLineFilter::ContourLine::getContourPoint(int vertexIndex1, 
263        int vertexIndex2, Vector4* vertices, int width, bool top)
264{
265    float diff = vertices[vertexIndex2].y - vertices[vertexIndex1].y;
266    float t = 0.0;
267    if (diff != 0) {
268        t = (_value - vertices[vertexIndex1].y) / diff; 
269    }
270
271    Vector3 p;
272    p.x = vertices[vertexIndex1].x + 
273        t * (vertices[vertexIndex2].x - vertices[vertexIndex1].x);
274    if (top)
275    {
276        p.y = 1.0f;
277    }
278    else
279    {
280        p.y = vertices[vertexIndex1].y + 
281            t * (vertices[vertexIndex2].y - vertices[vertexIndex1].y);
282    }
283
284    p.z = vertices[vertexIndex1].z + 
285        t * (vertices[vertexIndex2].z - vertices[vertexIndex1].z);
286    _points.push_back(p);
287}
288
289
290void 
291ContourLineFilter::setColorMap(Vector3Array* colorMap)
292{
293    if (colorMap == _colorMap) {
294        return;
295    }
296    if (colorMap && _colorMap) {
297        if (colorMap->size() != _colorMap->size()) {
298            _colorMap->resize(_colorMap->size());
299        }
300        _colorMap->assign(colorMap->begin(), colorMap->end());
301    } else {
302        delete _colorMap;
303       
304        if (colorMap && colorMap->size()) {     
305            _colorMap = new Vector3Array(colorMap->size());
306            _colorMap->assign(colorMap->begin(), colorMap->end());
307        } else {
308            _colorMap = 0;
309        }
310    }
311}
Note: See TracBrowser for help on using the repository browser.