/[escript]/trunk/pyvisi/py_src/velocity.py
ViewVC logotype

Annotation of /trunk/pyvisi/py_src/velocity.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1093 - (hide annotations)
Sun Apr 15 23:58:53 2007 UTC (13 years, 6 months ago) by jongui
File MIME type: text/x-python
File size: 16789 byte(s)
Fixed a minor bug related to clipping vector and tensor data.
1 jongui 1037 """
2     @author: John NGUI
3     """
4    
5     import vtk
6     from mapper import DataSetMapper
7     from lookuptable import LookupTable
8     from actor import Actor3D
9     from constant import Viewport, Color, Arrow, ColorMode, Lut, VizType
10     from arrow import Arrow2D, Arrow3D
11     from glyph import Glyph3D
12     from outline import Outline
13 jongui 1051 from point import MaskPoints
14 jongui 1043 from average import CellDataToPointData
15 jongui 1037
16 jongui 1051 # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D and
17     # MaskPoints were inherited to allow access to their public
18     # methods from the driver.
19     class Velocity(DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, MaskPoints):
20 jongui 1037 """
21     Class that shows a vector field using arrows. The arrows can either be
22     colored or grey-scaled, depending on the lookup table used. If the arrows
23 jongui 1078 are colored, there are two possible coloring modes, either using vector data
24     or scalar data. Similarly, there are two possible types of
25     arrows, either using two-dimensional or three-dimensional.
26 jongui 1037 """
27    
28     # The SOUTH_WEST default viewport is used when there is only one viewport.
29     # This saves the user from specifying the viewport when there is only one.
30     # If no lut is specified, the color scheme will be used.
31     def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST,
32     color_mode = ColorMode.VECTOR, arrow = Arrow.TWO_D,
33 jongui 1043 lut = Lut.COLOR, cell_to_point = False, outline = True):
34 jongui 1037 """
35 jongui 1075 Initialise the Velocity.
36    
37     @attention: The source can either be point or cell data. If the
38     source is cell data, a conversion to point data may or may not be
39     required, in order for the object to be rendered correctly.
40     If a conversion is needed, the 'cell_to_point' flag must be set to
41     'True', otherwise 'False' (which is the default).
42    
43 jongui 1037 @type scene: L{Scene <scene.Scene>} object
44     @param scene: Scene in which objects are to be rendered on
45     @type data_collector: L{DataCollector <datacollector.DataCollector>}
46     object
47     @param data_collector: Deal with source of data for visualisation
48     @type viewport: L{Viewport <constant.Viewport>} constant
49     @param viewport: Viewport in which objects are to be rendered on
50     @type color_mode: L{ColorMode <constant.ColorMode>} constant
51     @param color_mode: Type of color mode
52     @type arrow: L{Arrow <constant.Arrow>} constant
53     @param arrow: Type of arrow (two dimensional or three dimensional)
54     @type lut : L{Lut <constant.Lut>} constant
55     @param lut: Lookup table color scheme
56 jongui 1043 @type cell_to_point: Boolean
57     @param cell_to_point: Converts cell data to point data (by averaging)
58 jongui 1037 @type outline: Boolean
59     @param outline: Places an outline around the domain surface
60     """
61    
62     # NOTE: Actor3D is inherited and there are two instances declared here.
63     # As a result, when methods from Actor3D is invoked from the driver,
64     # only the methods associated with the latest instance (which in this
65     # case is the Actor3D for the Velocity) can be executed. Actor3D
66     # methods associated with Outline cannot be invoked from the driver.
67     # They can only be called within here, which is why Outline must be
68     # place before Velocity as there is unlikely to be any changes
69     # made to the Outline's Actor3D.
70    
71     # ----- Outline -----
72    
73     if(outline == True):
74     outline = Outline(data_collector._getOutput())
75     DataSetMapper.__init__(self, outline._getOutput())
76    
77     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
78     # Default outline color is black.
79     Actor3D.setColor(self, Color.BLACK)
80    
81     # Default line width is 1.
82     Actor3D._setLineWidth(self, 1)
83     scene._addActor3D(viewport, Actor3D._getActor3D(self))
84    
85     # ----- Velocity -----
86    
87     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
88     # before DataSetMapper. If it is done after DataSetMapper, no effect
89     # will take place.
90     if(lut == Lut.COLOR): # Colored lookup table.
91     lookup_table = LookupTable()
92     lookup_table._setTableValue()
93     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
94     lookup_table = LookupTable()
95     lookup_table._setLookupTableToGreyScale()
96 jongui 1051
97 jongui 1043 if(cell_to_point == True): # Converts cell data to point data.
98     c2p = CellDataToPointData(data_collector._getOutput())
99 jongui 1051 MaskPoints.__init__(self, c2p._getOutput())
100 jongui 1043 elif(cell_to_point == False): # No conversion happens.
101 jongui 1051 MaskPoints.__init__(self, data_collector._getOutput())
102    
103 jongui 1037 if(arrow == Arrow.TWO_D): # Use 2D arrows.
104     Arrow2D.__init__(self)
105 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
106 jongui 1037 Arrow2D._getOutput(self))
107     elif(arrow == Arrow.THREE_D): # Use 3D arrows.
108     Arrow3D.__init__(self)
109 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
110 jongui 1037 Arrow3D._getOutput(self))
111    
112     DataSetMapper.__init__(self, Glyph3D._getOutput(self),
113     lookup_table._getLookupTable())
114    
115     if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
116     Glyph3D._setColorModeByVector(self)
117     Glyph3D._setRange(self, data_collector._getVectorRange())
118     DataSetMapper._setScalarRange(self,
119     data_collector._getVectorRange())
120     data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
121     ColorMode.VECTOR, DataSetMapper._getDataSetMapper(self),
122     Glyph3D._getGlyph3D(self))
123    
124     elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
125     Glyph3D._setColorModeByScalar(self)
126     Glyph3D._setRange(self, data_collector._getScalarRange())
127     DataSetMapper._setScalarRange(self,
128     data_collector._getScalarRange())
129     data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
130     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self),
131     Glyph3D._getGlyph3D(self))
132    
133     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
134     scene._addActor3D(viewport, Actor3D._getActor3D(self))
135    
136    
137     ###############################################################################
138    
139    
140     from transform import Transform
141     from plane import Plane
142     from cutter import Cutter
143    
144     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
145 jongui 1051 # Cutter and MaskPoints were inherited to allow access to
146 jongui 1037 # their public methods from the driver.
147     class VelocityOnPlaneCut(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
148 jongui 1051 Glyph3D, Transform, Plane, Cutter, MaskPoints):
149 jongui 1037 """
150     This class works in a similar way to L{MapOnPlaneCut <map.MapOnPlaneCut>},
151     except that it shows a vector field using arrows on a plane.
152     """
153    
154     # The SOUTH_WEST default viewport is used when there is only one viewport.
155     # This saves the user from specifying the viewport when there is only one.
156     # If no lut is specified, the color scheme willbe used.
157     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
158     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
159 jongui 1051 lut = Lut.COLOR, cell_to_point = False, outline = True):
160 jongui 1037 """
161 jongui 1075 Initialise the VelocityOnPlaneCut.
162    
163     @attention: The source can either be point or cell data. If the
164     source is cell data, a conversion to point data may or may not be
165     required, in order for the object to be rendered correctly.
166     If a conversion is needed, the 'cell_to_point' flag must be set to
167     'True', otherwise 'False' (which is the default).
168    
169 jongui 1037 @type scene: L{Scene <scene.Scene>} object
170     @param scene: Scene in which objects are to be rendered on
171     @type data_collector: L{DataCollector <datacollector.DataCollector>}
172     object
173     @param data_collector: Deal with source of data for visualisation
174     @type arrow: L{Arrow <constant.Arrow>} constant
175     @param arrow: Type of arrow (two dimensional or three dimensional)
176     @type color_mode: L{ColorMode <constant.ColorMode>} constant
177     @param color_mode: Type of color mode
178     @type viewport: L{Viewport <constant.Viewport>} constant
179     @param viewport: Viewport in which objects are to be rendered on
180     @type lut : L{Lut <constant.Lut>} constant
181     @param lut: Lookup table color scheme
182 jongui 1051 @type cell_to_point: Boolean
183     @param cell_to_point: Converts cell data to point data (by averaging)
184 jongui 1037 @type outline: Boolean
185     @param outline: Places an outline around the domain surface
186     """
187    
188     # NOTE: Actor3D is inherited and there are two instances declared here.
189     # As a result, when methods from Actor3D is invoked from the driver,
190     # only the methods associated with the latest instance (which in this
191     # case is the Actor3D for the Velocity) can be executed. Actor3D
192     # methods associated with Outline cannot be invoked from the driver.
193     # They can only be called within here, which is why Outline must be
194     # place before Velocity as there is unlikely to be any changes
195     # made to the Outline's Actor3D.
196    
197     # ----- Outline -----
198    
199     if(outline == True):
200     outline = Outline(data_collector._getOutput())
201     DataSetMapper.__init__(self, outline._getOutput())
202    
203     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
204     # Default outline color is black.
205     Actor3D.setColor(self, Color.BLACK)
206    
207     # Default line width is 1.
208     Actor3D._setLineWidth(self, 1)
209     scene._addActor3D(viewport, Actor3D._getActor3D(self))
210    
211     # ----- Velocity on a cut plane -----
212    
213     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
214     # before DataSetMapper. If it is done after DataSetMapper, no effect
215     # will take place.
216     if(lut == Lut.COLOR): # Colored lookup table.
217     lookup_table = LookupTable()
218     lookup_table._setTableValue()
219     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
220     lookup_table = LookupTable()
221     lookup_table._setLookupTableToGreyScale()
222    
223     Transform.__init__(self)
224     Plane.__init__(self, Transform._getTransform(self))
225    
226 jongui 1051 if(cell_to_point == True): # Converts cell data to point data.
227     c2p = CellDataToPointData(data_collector._getOutput())
228 jongui 1056 Cutter.__init__(self, c2p._getOutput(), Plane._getPlane(self))
229 jongui 1051 elif(cell_to_point == False): # No conversion happens.
230 jongui 1053 Cutter.__init__(self, data_collector._getOutput(),
231     Plane._getPlane(self))
232 jongui 1037
233 jongui 1053 MaskPoints.__init__(self, Cutter._getOutput(self))
234    
235 jongui 1037 if(arrow == Arrow.TWO_D): # Use 2D arrows.
236     Arrow2D.__init__(self)
237 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
238 jongui 1037 Arrow2D._getOutput(self))
239     elif(arrow == Arrow.THREE_D): # Use 3D arrows.
240     Arrow3D.__init__(self)
241 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
242 jongui 1037 Arrow3D._getOutput(self))
243    
244 jongui 1053 DataSetMapper.__init__(self, Glyph3D._getOutput(self),
245 jongui 1037 lookup_table._getLookupTable())
246    
247     if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
248     Glyph3D._setColorModeByVector(self)
249     Glyph3D._setRange(self, data_collector._getVectorRange())
250     DataSetMapper._setScalarRange(self,
251     data_collector._getVectorRange())
252 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
253     ColorMode.VECTOR, DataSetMapper._getDataSetMapper(self),
254     Glyph3D._getGlyph3D(self))
255    
256 jongui 1037 elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
257     Glyph3D._setColorModeByScalar(self)
258 jongui 1043 Glyph3D._setRange(self, data_collector._getScalarRange())
259 jongui 1037 DataSetMapper._setScalarRange(self,
260     data_collector._getScalarRange())
261 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
262     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self),
263     Glyph3D._getGlyph3D(self))
264 jongui 1037
265     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
266     scene._addActor3D(viewport, Actor3D._getActor3D(self))
267    
268    
269     ###############################################################################
270    
271    
272     from clipper import Clipper
273    
274     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
275 jongui 1051 # Clipper and MaskPoints were inherited to allow access to
276 jongui 1037 # their public methods from the driver.
277     class VelocityOnPlaneClip(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
278 jongui 1051 Glyph3D, Transform, Plane, Clipper, MaskPoints):
279 jongui 1037 """
280     This class works in a similar way to L{MapOnPlaneClip <map.MapOnPlaneClip>}
281     , except that it shows a vector field using arrows clipped using a plane.
282     """
283    
284     # The SOUTH_WEST default viewport is used when there is only one viewport.
285     # This saves the user from specifying the viewport when there is only one.
286     # If no lut is specified, the color scheme will be used.
287     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
288     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
289 jongui 1051 lut = Lut.COLOR, cell_to_point = False, outline = True):
290 jongui 1037 """
291 jongui 1075 Initialise the VelocityOnPlaneClip.
292    
293     @attention: The source can either be point or cell data. If the
294     source is cell data, a conversion to point data may or may not be
295     required, in order for the object to be rendered correctly.
296     If a conversion is needed, the 'cell_to_point' flag must be set to
297     'True', otherwise 'False' (which is the default).
298    
299 jongui 1037 @type scene: L{Scene <scene.Scene>} object
300     @param scene: Scene in which objects are to be rendered on
301     @type data_collector: L{DataCollector <datacollector.DataCollector>}
302     object
303     @param data_collector: Deal with source of data for visualisation
304     @type arrow: L{Arrow <constant.Arrow>} constant
305     @param arrow: Type of arrow (two dimensional or three dimensional)
306     @type color_mode: L{ColorMode <constant.ColorMode>} constant
307     @param color_mode: Type of color mode
308     @type viewport: L{Viewport <constant.Viewport>} constant
309     @param viewport: Viewport in which objects are to be rendered on
310     @type lut : L{Lut <constant.Lut>} constant
311     @param lut: Lookup table color scheme
312 jongui 1051 @type cell_to_point: Boolean
313     @param cell_to_point: Converts cell data to point data (by averaging)
314 jongui 1037 @type outline: Boolean
315     @param outline: Places an outline around the domain surface
316     """
317    
318     # NOTE: Actor3D is inherited and there are two instances declared here.
319     # As a result, when methods from Actor3D is invoked from the driver,
320     # only the methods associated with the latest instance (which in this
321     # case is the Actor3D for the Velocity) can be executed. Actor3D
322     # methods associated with Outline cannot be invoked from the driver.
323     # They can only be called within here, which is why Outline must be
324     # place before Velocity as there is unlikely to be any changes
325     # made to the Outline's Actor3D.
326    
327     # ----- Outline -----
328    
329     if(outline == True):
330     outline = Outline(data_collector._getOutput())
331     DataSetMapper.__init__(self, outline._getOutput())
332    
333     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
334     # Default outline color is black.
335     Actor3D.setColor(self, Color.BLACK)
336    
337     # Default line width is 1.
338     Actor3D._setLineWidth(self, 1)
339     scene._addActor3D(viewport, Actor3D._getActor3D(self))
340    
341     # ----- Velocity on a clipped plane -----
342    
343     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
344     # before DataSetMapper. If it is done after DataSetMapper, no effect
345     # will take place.
346     if(lut == Lut.COLOR): # Colored lookup table.
347     lookup_table = LookupTable()
348     lookup_table._setTableValue()
349     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
350     lookup_table = LookupTable()
351     lookup_table._setLookupTableToGreyScale()
352    
353     Transform.__init__(self)
354     Plane.__init__(self, Transform._getTransform(self))
355    
356 jongui 1051 if(cell_to_point == True): # Converts cell data to point data.
357     c2p = CellDataToPointData(data_collector._getOutput())
358 jongui 1093 MaskPoints.__init__(self, c2p._getOutput())
359 jongui 1051 elif(cell_to_point == False): # No conversion happens.
360 jongui 1093 MaskPoints.__init__(self, data_collector._getOutput())
361 jongui 1037
362 jongui 1093 # NOTE: Glyph3D must come before Clipper. Otherwise clipping may not
363     # work correctly.
364 jongui 1037 if(arrow == Arrow.TWO_D): # Use 2D arrows.
365     Arrow2D.__init__(self)
366 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
367 jongui 1037 Arrow2D._getOutput(self))
368     elif(arrow == Arrow.THREE_D): # Use 3D arrows.
369     Arrow3D.__init__(self)
370 jongui 1051 Glyph3D.__init__(self, MaskPoints._getOutput(self),
371 jongui 1037 Arrow3D._getOutput(self))
372    
373 jongui 1093 Clipper.__init__(self, Glyph3D._getOutput(self),
374     Plane._getPlane(self))
375     Clipper._setClipFunction(self)
376    
377     # NOTE: Clipper must come after Glyph. Otherwise clipping
378     # may not work correctly.
379     DataSetMapper.__init__(self, Clipper._getOutput(self),
380 jongui 1037 lookup_table._getLookupTable())
381    
382     if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
383     Glyph3D._setColorModeByVector(self)
384     Glyph3D._setRange(self, data_collector._getVectorRange())
385     DataSetMapper._setScalarRange(self,
386     data_collector._getVectorRange())
387 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
388     ColorMode.VECTOR, DataSetMapper._getDataSetMapper(self),
389     Glyph3D._getGlyph3D(self))
390    
391 jongui 1037 elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
392     Glyph3D._setColorModeByScalar(self)
393 jongui 1043 Glyph3D._setRange(self, data_collector._getScalarRange())
394 jongui 1037 DataSetMapper._setScalarRange(self,
395     data_collector._getScalarRange())
396 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.VELOCITY,
397     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self),
398     Glyph3D._getGlyph3D(self))
399 jongui 1037
400     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
401     scene._addActor3D(viewport, Actor3D._getActor3D(self))

  ViewVC Help
Powered by ViewVC 1.1.26