/[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 1148 - (hide annotations)
Wed May 16 22:45:33 2007 UTC (12 years, 10 months ago) by jongui
File MIME type: text/x-python
File size: 17749 byte(s)
Added the updated files for pyvisi and removed some incorrect reference images.
1 ksteube 1147 """
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 jongui 1148 from constant import Viewport, Color, Arrow, ColorMode, Lut
10 ksteube 1147 from arrow import Arrow2D, Arrow3D
11     from glyph import Glyph3D
12     from outline import Outline
13     from point import MaskPoints
14     from average import CellDataToPointData
15    
16     # 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     """
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     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     """
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 jongui 1148 def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
32     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
33 ksteube 1147 lut = Lut.COLOR, cell_to_point = False, outline = True):
34     """
35     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     @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 jongui 1148 @type arrow: L{Arrow <constant.Arrow>} constant
49     @param arrow: Type of arrow (two dimensional or three dimensional)
50     @type color_mode: L{ColorMode <constant.ColorMode>} constant
51     @param color_mode: Type of color mode
52 ksteube 1147 @type viewport: L{Viewport <constant.Viewport>} constant
53     @param viewport: Viewport in which objects are to be rendered on
54     @type lut : L{Lut <constant.Lut>} constant
55     @param lut: Lookup table color scheme
56     @type cell_to_point: Boolean
57     @param cell_to_point: Converts cell data to point data (by averaging)
58     @type outline: Boolean
59     @param outline: Places an outline around the domain surface
60     """
61    
62 jongui 1148 self.__scene = scene
63     self.__data_collector = data_collector
64     self.__arrow = arrow
65     self.__color_mode = color_mode
66     self.__viewport = viewport
67     self.__lut = lut
68     self.__cell_to_point = cell_to_point
69     self.__outline = outline
70    
71     self.__modified = True # Keeps track whether Velocity has been modified.
72     MaskPoints.__init__(self)
73     Glyph3D.__init__(self)
74     DataSetMapper.__init__(self)
75     Actor3D.__init__(self)
76     scene._addVisualizationModules(self)
77 ksteube 1147
78 jongui 1148 # ----- Outline -----
79 ksteube 1147
80 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
81     # driver.
82     if(self.__outline == True):
83     outline = Outline(self.__data_collector._getDataCollectorOutput())
84     mapper = DataSetMapper()
85     mapper._setupDataSetMapper(outline._getOutlineOutput())
86 ksteube 1147
87 jongui 1148 actor3D = Actor3D()
88     actor3D._setupActor3D(mapper._getDataSetMapper())
89 ksteube 1147 # Default outline color is black.
90 jongui 1148 actor3D.setColor(Color.BLACK)
91 ksteube 1147
92     # Default line width is 1.
93 jongui 1148 actor3D._setLineWidth(1)
94     self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())
95 ksteube 1147
96     # ----- Velocity -----
97    
98     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
99     # before DataSetMapper. If it is done after DataSetMapper, no effect
100     # will take place.
101 jongui 1148 if(self.__lut == Lut.COLOR): # Colored lookup table.
102 ksteube 1147 lookup_table = LookupTable()
103     lookup_table._setTableValue()
104 jongui 1148 elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
105 ksteube 1147 lookup_table = LookupTable()
106     lookup_table._setLookupTableToGreyScale()
107    
108 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
109     c2p = CellDataToPointData(
110     self.__data_collector._getDataCollectorOutput())
111     self._setupMaskPoints(c2p._getCellToPointOutput())
112     elif(self.__cell_to_point == False): # No conversion happens.
113     self._setupMaskPoints(data_collector._getDataCollectorOutput())
114 ksteube 1147
115 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
116 ksteube 1147 Arrow2D.__init__(self)
117 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
118     self._getArrow2DOutput())
119 ksteube 1147 elif(arrow == Arrow.THREE_D): # Use 3D arrows.
120     Arrow3D.__init__(self)
121 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
122     self._getArrow3DOutput())
123 ksteube 1147
124 jongui 1148 self._setupDataSetMapper(self._getGlyph3DOutput(),
125 ksteube 1147 lookup_table._getLookupTable())
126    
127 jongui 1148 self._setupActor3D(self._getDataSetMapper())
128     self.__scene._addActor3D(self.__viewport, self._getActor3D())
129 ksteube 1147
130 jongui 1148 def _isModified(self):
131     """
132     Return whether the Velocity or DataCollector has been modified.
133 ksteube 1147
134 jongui 1148 @rtype: Boolean
135     @return: True or False
136     """
137 ksteube 1147
138 jongui 1148 return self.__modified or self.__data_collector._isModified()
139 ksteube 1147
140 jongui 1148 def _render(self):
141     """
142     Render the velocity.
143     """
144    
145     if (self._isModified() == True):
146     if(self.__data_collector._isScalarSet() == True):
147     self.__data_collector._setActiveScalar()
148     if(self.__data_collector._isVectorSet() == True):
149     self.__data_collector._setActiveVector()
150    
151     # Color velocity by vector.
152     if(self.__color_mode == ColorMode.VECTOR):
153     self._setColorModeByVector()
154     self._setRange(self.__data_collector._getVectorRange())
155     self._setScalarRange(self.__data_collector._getVectorRange())
156     # Color velocity by scalar.
157     elif(self.__color_mode == ColorMode.SCALAR):
158     self._setColorModeByScalar()
159     self._setRange(self.__data_collector._getScalarRange())
160     self._setScalarRange(self.__data_collector._getScalarRange())
161    
162     self.__modified = False
163    
164    
165 ksteube 1147 ###############################################################################
166    
167    
168     from transform import Transform
169     from plane import Plane
170     from cutter import Cutter
171    
172     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
173     # Cutter and MaskPoints were inherited to allow access to
174     # their public methods from the driver.
175     class VelocityOnPlaneCut(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
176     Glyph3D, Transform, Plane, Cutter, MaskPoints):
177     """
178     This class works in a similar way to L{MapOnPlaneCut <map.MapOnPlaneCut>},
179 jongui 1148 except that it shows a vector field using arrows cut using a plane.
180 ksteube 1147 """
181    
182     # The SOUTH_WEST default viewport is used when there is only one viewport.
183     # This saves the user from specifying the viewport when there is only one.
184     # If no lut is specified, the color scheme willbe used.
185     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
186     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
187     lut = Lut.COLOR, cell_to_point = False, outline = True):
188     """
189     Initialise the VelocityOnPlaneCut.
190    
191     @attention: The source can either be point or cell data. If the
192     source is cell data, a conversion to point data may or may not be
193     required, in order for the object to be rendered correctly.
194     If a conversion is needed, the 'cell_to_point' flag must be set to
195     'True', otherwise 'False' (which is the default).
196    
197     @type scene: L{Scene <scene.Scene>} object
198     @param scene: Scene in which objects are to be rendered on
199     @type data_collector: L{DataCollector <datacollector.DataCollector>}
200     object
201     @param data_collector: Deal with source of data for visualisation
202     @type arrow: L{Arrow <constant.Arrow>} constant
203     @param arrow: Type of arrow (two dimensional or three dimensional)
204     @type color_mode: L{ColorMode <constant.ColorMode>} constant
205     @param color_mode: Type of color mode
206     @type viewport: L{Viewport <constant.Viewport>} constant
207     @param viewport: Viewport in which objects are to be rendered on
208     @type lut : L{Lut <constant.Lut>} constant
209     @param lut: Lookup table color scheme
210     @type cell_to_point: Boolean
211     @param cell_to_point: Converts cell data to point data (by averaging)
212     @type outline: Boolean
213     @param outline: Places an outline around the domain surface
214     """
215    
216 jongui 1148 self.__scene = scene
217     self.__data_collector = data_collector
218     self.__arrow = arrow
219     self.__color_mode = color_mode
220     self.__viewport = viewport
221     self.__lut = lut
222     self.__cell_to_point = cell_to_point
223     self.__outline = outline
224    
225     # Keeps track whether VelocityOnPlaneCut has been modified.
226     self.__modified = True
227     Transform.__init__(self)
228     Plane.__init__(self)
229     Cutter.__init__(self)
230     MaskPoints.__init__(self)
231     Glyph3D.__init__(self)
232     DataSetMapper.__init__(self)
233     Actor3D.__init__(self)
234     scene._addVisualizationModules(self)
235 ksteube 1147
236 jongui 1148 # ----- Outline -----
237 ksteube 1147
238 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
239     # driver.
240     if(self.__outline == True):
241     outline = Outline(self.__data_collector._getDataCollectorOutput())
242     mapper = DataSetMapper()
243     mapper._setupDataSetMapper(outline._getOutlineOutput())
244 ksteube 1147
245 jongui 1148 actor3D = Actor3D()
246     actor3D._setupActor3D(mapper._getDataSetMapper())
247 ksteube 1147 # Default outline color is black.
248 jongui 1148 actor3D.setColor(Color.BLACK)
249 ksteube 1147
250     # Default line width is 1.
251 jongui 1148 actor3D._setLineWidth(1)
252     self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())
253 ksteube 1147
254     # ----- Velocity on a cut plane -----
255    
256     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
257     # before DataSetMapper. If it is done after DataSetMapper, no effect
258     # will take place.
259     if(lut == Lut.COLOR): # Colored lookup table.
260     lookup_table = LookupTable()
261     lookup_table._setTableValue()
262     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
263     lookup_table = LookupTable()
264     lookup_table._setLookupTableToGreyScale()
265    
266 jongui 1148 self._setupPlane(self._getTransform())
267 ksteube 1147
268 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
269     c2p = CellDataToPointData(
270     self.__data_collector._getDataCollectorOutput())
271     self._setupCutter(c2p._getCellToPointOutput(), self._getPlane())
272     elif(self.__cell_to_point == False): # No conversion happens.
273     self._setupCutter(self.__data_collector._getDataCollectorOutput(),
274     self._getPlane())
275 ksteube 1147
276 jongui 1148 self._setupMaskPoints(self._getCutterOutput())
277 ksteube 1147
278 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
279 ksteube 1147 Arrow2D.__init__(self)
280 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
281     self._getActor2DOutput())
282     elif(self.__arrow == Arrow.THREE_D): # Use 3D arrows.
283 ksteube 1147 Arrow3D.__init__(self)
284 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
285     self._getArrow3DOutput())
286 ksteube 1147
287 jongui 1148 self._setupDataSetMapper(self._getGlyph3DOutput(),
288 ksteube 1147 lookup_table._getLookupTable())
289    
290 jongui 1148 self._setupActor3D(self._getDataSetMapper())
291     self.__scene._addActor3D(self.__viewport, self._getActor3D())
292    
293     def _isModified(self):
294     """
295     Return whether the VelocityOnPlaneCut or DataCollector has been
296     modified.
297 ksteube 1147
298 jongui 1148 @rtype: Boolean
299     @return: True or False
300     """
301 ksteube 1147
302 jongui 1148 return self.__modified or self.__data_collector._isModified()
303 ksteube 1147
304 jongui 1148 def _render(self):
305     """
306     Render the velocity cut using a plane..
307     """
308 ksteube 1147
309 jongui 1148 if (self._isModified() == True):
310     if(self.__data_collector._isVectorSet() == True):
311     self.__data_collector._setActiveVector()
312     # Color velocity by vector.
313     if(self.__color_mode == ColorMode.VECTOR):
314     self._setColorModeByVector()
315     self._setRange(self.__data_collector._getVectorRange())
316     self._setScalarRange(self.__data_collector._getVectorRange())
317     # Color velocity by scalar.
318     elif(self.__color_mode == ColorMode.SCALAR):
319     self._setColorModeByScalar()
320     self._setRange(self.__data_collector._getScalarRange())
321     self._setScalarRange(self.__data_collector._getScalarRange())
322    
323     self.__modified = False
324    
325    
326 ksteube 1147 ###############################################################################
327    
328    
329     from clipper import Clipper
330    
331     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
332     # Clipper and MaskPoints were inherited to allow access to
333     # their public methods from the driver.
334     class VelocityOnPlaneClip(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
335     Glyph3D, Transform, Plane, Clipper, MaskPoints):
336     """
337     This class works in a similar way to L{MapOnPlaneClip <map.MapOnPlaneClip>}
338     , except that it shows a vector field using arrows clipped using a plane.
339     """
340    
341     # The SOUTH_WEST default viewport is used when there is only one viewport.
342     # This saves the user from specifying the viewport when there is only one.
343     # If no lut is specified, the color scheme will be used.
344     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
345     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
346     lut = Lut.COLOR, cell_to_point = False, outline = True):
347     """
348     Initialise the VelocityOnPlaneClip.
349    
350     @attention: The source can either be point or cell data. If the
351     source is cell data, a conversion to point data may or may not be
352     required, in order for the object to be rendered correctly.
353     If a conversion is needed, the 'cell_to_point' flag must be set to
354     'True', otherwise 'False' (which is the default).
355    
356     @type scene: L{Scene <scene.Scene>} object
357     @param scene: Scene in which objects are to be rendered on
358     @type data_collector: L{DataCollector <datacollector.DataCollector>}
359     object
360     @param data_collector: Deal with source of data for visualisation
361     @type arrow: L{Arrow <constant.Arrow>} constant
362     @param arrow: Type of arrow (two dimensional or three dimensional)
363     @type color_mode: L{ColorMode <constant.ColorMode>} constant
364     @param color_mode: Type of color mode
365     @type viewport: L{Viewport <constant.Viewport>} constant
366     @param viewport: Viewport in which objects are to be rendered on
367     @type lut : L{Lut <constant.Lut>} constant
368     @param lut: Lookup table color scheme
369     @type cell_to_point: Boolean
370     @param cell_to_point: Converts cell data to point data (by averaging)
371     @type outline: Boolean
372     @param outline: Places an outline around the domain surface
373     """
374    
375 jongui 1148 self.__scene = scene
376     self.__data_collector = data_collector
377     self.__arrow = arrow
378     self.__color_mode = color_mode
379     self.__viewport = viewport
380     self.__lut = lut
381     self.__cell_to_point = cell_to_point
382     self.__outline = outline
383    
384     # Keeps track whether VelocityOnPlaneCut has been modified.
385     self.__modified = True
386     Transform.__init__(self)
387     Plane.__init__(self)
388     Clipper.__init__(self)
389     MaskPoints.__init__(self)
390     Glyph3D.__init__(self)
391     DataSetMapper.__init__(self)
392     Actor3D.__init__(self)
393     scene._addVisualizationModules(self)
394 ksteube 1147
395 jongui 1148 # ----- Outline -----
396 ksteube 1147
397 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
398     # driver.
399     if(self.__outline == True):
400     outline = Outline(self.__data_collector._getDataCollectorOutput())
401     mapper = DataSetMapper()
402     mapper._setupDataSetMapper(outline._getOutlineOutput())
403 ksteube 1147
404 jongui 1148 actor3D = Actor3D()
405     actor3D._setupActor3D(mapper._getDataSetMapper())
406 ksteube 1147 # Default outline color is black.
407 jongui 1148 actor3D.setColor(Color.BLACK)
408 ksteube 1147
409     # Default line width is 1.
410 jongui 1148 actor3D._setLineWidth(1)
411     self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())
412 ksteube 1147
413     # ----- Velocity on a clipped plane -----
414    
415     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
416     # before DataSetMapper. If it is done after DataSetMapper, no effect
417     # will take place.
418 jongui 1148 if(self.__lut == Lut.COLOR): # Colored lookup table.
419 ksteube 1147 lookup_table = LookupTable()
420     lookup_table._setTableValue()
421 jongui 1148 elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
422 ksteube 1147 lookup_table = LookupTable()
423     lookup_table._setLookupTableToGreyScale()
424    
425 jongui 1148 self._setupPlane(self._getTransform())
426 ksteube 1147
427 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
428     c2p = CellDataToPointData(
429     self.__data_collector._getDataCollectorOutput())
430     self._setupMaskPoints(c2p._getCellToPointOutput())
431     elif(self.__cell_to_point == False): # No conversion happens.
432     self._setupMaskPoints(
433     self.__data_collector._getDataCollectorOutput())
434 ksteube 1147
435     # NOTE: Glyph3D must come before Clipper. Otherwise clipping may not
436     # work correctly.
437 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
438 ksteube 1147 Arrow2D.__init__(self)
439 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
440     self._getArrow2DOutput())
441     elif(self.__arrow == Arrow.THREE_D): # Use 3D arrows.
442 ksteube 1147 Arrow3D.__init__(self)
443 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
444     self._getArrow3DOutput())
445 ksteube 1147
446 jongui 1148 self._setupClipper(self._getGlyph3DOutput(), self._getPlane())
447     self._setClipFunction()
448 ksteube 1147
449     # NOTE: Clipper must come after Glyph. Otherwise clipping
450     # may not work correctly.
451 jongui 1148 self._setupDataSetMapper(self._getClipperOutput(),
452 ksteube 1147 lookup_table._getLookupTable())
453    
454 jongui 1148 self._setupActor3D(self._getDataSetMapper())
455     self.__scene._addActor3D(self.__viewport, self._getActor3D())
456    
457     def _isModified(self):
458     """
459     Return whether the VelocityOnPlaneClip or DataCollector has been
460     modified.
461 ksteube 1147
462 jongui 1148 @rtype: Boolean
463     @return: True or False
464     """
465 ksteube 1147
466 jongui 1148 return self.__modified or self.__data_collector._isModified()
467    
468     def _render(self):
469     """
470     Render the velocity clip using a plane..
471     """
472    
473     if (self._isModified() == True):
474     if(self.__data_collector._isVectorSet() == True):
475     self.__data_collector._setActiveVector()
476     # Color velocity by vector.
477     if(self.__color_mode == ColorMode.VECTOR):
478     self._setColorModeByVector()
479     self._setRange(self.__data_collector._getVectorRange())
480     self._setScalarRange(self.__data_collector._getVectorRange())
481     # Color velocity by scalar.
482     elif(self.__color_mode == ColorMode.SCALAR):
483     self._setColorModeByScalar()
484     self._setRange(self.__data_collector._getScalarRange())
485     self._setScalarRange(self.__data_collector._getScalarRange())
486    
487     self.__modified = False
488    
489    

  ViewVC Help
Powered by ViewVC 1.1.26