/[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 1197 - (hide annotations)
Mon Jun 18 02:08:34 2007 UTC (13 years, 1 month ago) by jongui
File MIME type: text/x-python
File size: 20332 byte(s)
Update the way movies are generated. Please refer to the examples. 

The user can now either specify the image range(first and last images inclusive):
mov.imageRange(input_directory = PYVISI_EXAMPLE_IMAGES_PATH,
        first_image = IMAGE_NAME + "000938.jpg",
		last_image = IMAGE_NAME + "000948.jpg")
mov.makeMovie(os.path.join(PYVISI_EXAMPLE_IMAGES_PATH, "movie.mpg"))

or the user can specify a list of images:

lst = ['image1.jpg', 'image5.jpg', 'image7.jpg]
mov.imageList(input_directory = PYVISI_EXAMPLE_IMAGES_PATH, image_list = lst)
mov.makeMovie(os.path.join(PYVISI_EXAMPLE_IMAGES_PATH, "movie.mpg"))


1 ksteube 1147 """
2 jongui 1197 @var __author__: name of author
3     @var __copyright__: copyrights
4     @var __license__: licence agreement
5     @var __url__: url entry point on documentation
6     @var __version__: version
7     @var __date__: date of the version
8 ksteube 1147 """
9    
10 jongui 1197 __author__="John Ngui, john.ngui@uq.edu.au"
11     __copyright__=""" Copyright (c) 2006 by ACcESS MNRF
12     http://www.access.edu.au
13     Primary Business: Queensland, Australia"""
14     __license__="""Licensed under the Open Software License version 3.0
15     http://www.opensource.org/licenses/osl-3.0.php"""
16     __url__="http://www.iservo.edu.au/esys"
17     __version__="$Revision$"
18     __date__="$Date$"
19    
20    
21 ksteube 1147 import vtk
22     from mapper import DataSetMapper
23     from lookuptable import LookupTable
24     from actor import Actor3D
25 jongui 1148 from constant import Viewport, Color, Arrow, ColorMode, Lut
26 ksteube 1147 from arrow import Arrow2D, Arrow3D
27     from glyph import Glyph3D
28     from outline import Outline
29     from point import MaskPoints
30     from average import CellDataToPointData
31    
32     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D and
33     # MaskPoints were inherited to allow access to their public
34     # methods from the driver.
35     class Velocity(DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, MaskPoints):
36     """
37     Class that shows a vector field using arrows. The arrows can either be
38     colored or grey-scaled, depending on the lookup table used. If the arrows
39     are colored, there are two possible coloring modes, either using vector data
40     or scalar data. Similarly, there are two possible types of
41     arrows, either using two-dimensional or three-dimensional.
42     """
43    
44     # The SOUTH_WEST default viewport is used when there is only one viewport.
45     # This saves the user from specifying the viewport when there is only one.
46     # If no lut is specified, the color scheme will be used.
47 jongui 1148 def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
48     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
49 ksteube 1147 lut = Lut.COLOR, cell_to_point = False, outline = True):
50     """
51     Initialise the Velocity.
52    
53     @attention: The source can either be point or cell data. If the
54     source is cell data, a conversion to point data may or may not be
55     required, in order for the object to be rendered correctly.
56     If a conversion is needed, the 'cell_to_point' flag must be set to
57     'True', otherwise 'False' (which is the default).
58    
59     @type scene: L{Scene <scene.Scene>} object
60     @param scene: Scene in which objects are to be rendered on
61     @type data_collector: L{DataCollector <datacollector.DataCollector>}
62     object
63     @param data_collector: Deal with source of data for visualisation
64 jongui 1148 @type arrow: L{Arrow <constant.Arrow>} constant
65     @param arrow: Type of arrow (two dimensional or three dimensional)
66     @type color_mode: L{ColorMode <constant.ColorMode>} constant
67     @param color_mode: Type of color mode
68 ksteube 1147 @type viewport: L{Viewport <constant.Viewport>} constant
69     @param viewport: Viewport in which objects are to be rendered on
70     @type lut : L{Lut <constant.Lut>} constant
71     @param lut: Lookup table color scheme
72     @type cell_to_point: Boolean
73     @param cell_to_point: Converts cell data to point data (by averaging)
74     @type outline: Boolean
75     @param outline: Places an outline around the domain surface
76     """
77    
78 jongui 1148 self.__data_collector = data_collector
79     self.__arrow = arrow
80     self.__color_mode = color_mode
81     self.__viewport = viewport
82     self.__lut = lut
83     self.__cell_to_point = cell_to_point
84     self.__outline = outline
85    
86     self.__modified = True # Keeps track whether Velocity has been modified.
87     MaskPoints.__init__(self)
88     Glyph3D.__init__(self)
89     DataSetMapper.__init__(self)
90     Actor3D.__init__(self)
91     scene._addVisualizationModules(self)
92 ksteube 1147
93 jongui 1148 # ----- Outline -----
94 ksteube 1147
95 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
96     # driver.
97     if(self.__outline == True):
98     outline = Outline(self.__data_collector._getDataCollectorOutput())
99     mapper = DataSetMapper()
100     mapper._setupDataSetMapper(outline._getOutlineOutput())
101 ksteube 1147
102 jongui 1148 actor3D = Actor3D()
103     actor3D._setupActor3D(mapper._getDataSetMapper())
104 ksteube 1147 # Default outline color is black.
105 jongui 1148 actor3D.setColor(Color.BLACK)
106 ksteube 1147
107     # Default line width is 1.
108 jongui 1148 actor3D._setLineWidth(1)
109 jongui 1158 scene._addActor3D(self.__viewport, actor3D._getActor3D())
110 ksteube 1147
111     # ----- Velocity -----
112    
113     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
114     # before DataSetMapper. If it is done after DataSetMapper, no effect
115     # will take place.
116 jongui 1148 if(self.__lut == Lut.COLOR): # Colored lookup table.
117 ksteube 1147 lookup_table = LookupTable()
118     lookup_table._setTableValue()
119 jongui 1148 elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
120 ksteube 1147 lookup_table = LookupTable()
121     lookup_table._setLookupTableToGreyScale()
122    
123 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
124     c2p = CellDataToPointData(
125     self.__data_collector._getDataCollectorOutput())
126     self._setupMaskPoints(c2p._getCellToPointOutput())
127     elif(self.__cell_to_point == False): # No conversion happens.
128     self._setupMaskPoints(data_collector._getDataCollectorOutput())
129 ksteube 1147
130 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
131 ksteube 1147 Arrow2D.__init__(self)
132 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
133     self._getArrow2DOutput())
134 ksteube 1147 elif(arrow == Arrow.THREE_D): # Use 3D arrows.
135     Arrow3D.__init__(self)
136 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
137     self._getArrow3DOutput())
138 ksteube 1147
139 jongui 1148 self._setupDataSetMapper(self._getGlyph3DOutput(),
140 ksteube 1147 lookup_table._getLookupTable())
141    
142 jongui 1148 self._setupActor3D(self._getDataSetMapper())
143 jongui 1158 scene._addActor3D(self.__viewport, self._getActor3D())
144 ksteube 1147
145 jongui 1148 def _isModified(self):
146     """
147     Return whether the Velocity or DataCollector has been modified.
148 ksteube 1147
149 jongui 1148 @rtype: Boolean
150     @return: True or False
151     """
152 ksteube 1147
153 jongui 1148 return self.__modified or self.__data_collector._isModified()
154 ksteube 1147
155 jongui 1158 def _render(self, scene):
156 jongui 1148 """
157     Render the velocity.
158 jongui 1158
159     @type scene: L{Scene <scene.Scene>} object
160     @param scene: Scene in which objects are to be rendered on
161 jongui 1148 """
162    
163     if (self._isModified() == True):
164     if(self.__data_collector._isScalarSet() == True):
165     self.__data_collector._setActiveScalar()
166     if(self.__data_collector._isVectorSet() == True):
167     self.__data_collector._setActiveVector()
168    
169     # Color velocity by vector.
170     if(self.__color_mode == ColorMode.VECTOR):
171     self._setColorModeByVector()
172 jongui 1189
173     # self._isScalarRangeSet checks whether the scalar range has
174     # been specified by the user. If it has, then the scalar range
175     # read from the source will be ignored.
176     if(not(self._isScalarRangeSet())):
177     self._setRange(self.__data_collector._getVectorRange())
178     self._setScalarRange(\
179     self.__data_collector._getVectorRange())
180     else:
181     self._setRange(self._getDataSetMapperRange())
182    
183 jongui 1148 # Color velocity by scalar.
184     elif(self.__color_mode == ColorMode.SCALAR):
185     self._setColorModeByScalar()
186    
187 jongui 1189 # self._isScalarRangeSet checks whether the scalar range has
188     # been specified by the user. If it has, then the scalar range
189     # read from the source will be ignored.
190     if(not(self._isScalarRangeSet())):
191     self._setRange(self.__data_collector._getScalarRange())
192     self._setScalarRange(\
193     self.__data_collector._getScalarRange())
194     else:
195     self._setRange(self._getDataSetMapperRange())
196    
197 jongui 1148 self.__modified = False
198    
199    
200 ksteube 1147 ###############################################################################
201    
202    
203     from transform import Transform
204     from plane import Plane
205     from cutter import Cutter
206    
207     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
208     # Cutter and MaskPoints were inherited to allow access to
209     # their public methods from the driver.
210     class VelocityOnPlaneCut(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
211     Glyph3D, Transform, Plane, Cutter, MaskPoints):
212     """
213     This class works in a similar way to L{MapOnPlaneCut <map.MapOnPlaneCut>},
214 jongui 1148 except that it shows a vector field using arrows cut using a plane.
215 ksteube 1147 """
216    
217     # The SOUTH_WEST default viewport is used when there is only one viewport.
218     # This saves the user from specifying the viewport when there is only one.
219     # If no lut is specified, the color scheme willbe used.
220     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
221     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
222     lut = Lut.COLOR, cell_to_point = False, outline = True):
223     """
224     Initialise the VelocityOnPlaneCut.
225    
226     @attention: The source can either be point or cell data. If the
227     source is cell data, a conversion to point data may or may not be
228     required, in order for the object to be rendered correctly.
229     If a conversion is needed, the 'cell_to_point' flag must be set to
230     'True', otherwise 'False' (which is the default).
231    
232     @type scene: L{Scene <scene.Scene>} object
233     @param scene: Scene in which objects are to be rendered on
234     @type data_collector: L{DataCollector <datacollector.DataCollector>}
235     object
236     @param data_collector: Deal with source of data for visualisation
237     @type arrow: L{Arrow <constant.Arrow>} constant
238     @param arrow: Type of arrow (two dimensional or three dimensional)
239     @type color_mode: L{ColorMode <constant.ColorMode>} constant
240     @param color_mode: Type of color mode
241     @type viewport: L{Viewport <constant.Viewport>} constant
242     @param viewport: Viewport in which objects are to be rendered on
243     @type lut : L{Lut <constant.Lut>} constant
244     @param lut: Lookup table color scheme
245     @type cell_to_point: Boolean
246     @param cell_to_point: Converts cell data to point data (by averaging)
247     @type outline: Boolean
248     @param outline: Places an outline around the domain surface
249     """
250    
251 jongui 1148 self.__data_collector = data_collector
252     self.__arrow = arrow
253     self.__color_mode = color_mode
254     self.__viewport = viewport
255     self.__lut = lut
256     self.__cell_to_point = cell_to_point
257     self.__outline = outline
258    
259     # Keeps track whether VelocityOnPlaneCut has been modified.
260     self.__modified = True
261     Transform.__init__(self)
262     Plane.__init__(self)
263     Cutter.__init__(self)
264     MaskPoints.__init__(self)
265     Glyph3D.__init__(self)
266     DataSetMapper.__init__(self)
267     Actor3D.__init__(self)
268     scene._addVisualizationModules(self)
269 ksteube 1147
270 jongui 1148 # ----- Outline -----
271 ksteube 1147
272 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
273     # driver.
274     if(self.__outline == True):
275     outline = Outline(self.__data_collector._getDataCollectorOutput())
276     mapper = DataSetMapper()
277     mapper._setupDataSetMapper(outline._getOutlineOutput())
278 ksteube 1147
279 jongui 1148 actor3D = Actor3D()
280     actor3D._setupActor3D(mapper._getDataSetMapper())
281 ksteube 1147 # Default outline color is black.
282 jongui 1148 actor3D.setColor(Color.BLACK)
283 ksteube 1147
284     # Default line width is 1.
285 jongui 1148 actor3D._setLineWidth(1)
286 jongui 1158 scene._addActor3D(self.__viewport, actor3D._getActor3D())
287 ksteube 1147
288     # ----- Velocity on a cut plane -----
289    
290     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
291     # before DataSetMapper. If it is done after DataSetMapper, no effect
292     # will take place.
293     if(lut == Lut.COLOR): # Colored lookup table.
294     lookup_table = LookupTable()
295     lookup_table._setTableValue()
296     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
297     lookup_table = LookupTable()
298     lookup_table._setLookupTableToGreyScale()
299    
300 jongui 1148 self._setupPlane(self._getTransform())
301 ksteube 1147
302 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
303     c2p = CellDataToPointData(
304     self.__data_collector._getDataCollectorOutput())
305     self._setupCutter(c2p._getCellToPointOutput(), self._getPlane())
306     elif(self.__cell_to_point == False): # No conversion happens.
307     self._setupCutter(self.__data_collector._getDataCollectorOutput(),
308     self._getPlane())
309 ksteube 1147
310 jongui 1148 self._setupMaskPoints(self._getCutterOutput())
311 ksteube 1147
312 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
313 ksteube 1147 Arrow2D.__init__(self)
314 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
315     self._getActor2DOutput())
316     elif(self.__arrow == Arrow.THREE_D): # Use 3D arrows.
317 ksteube 1147 Arrow3D.__init__(self)
318 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
319     self._getArrow3DOutput())
320 ksteube 1147
321 jongui 1148 self._setupDataSetMapper(self._getGlyph3DOutput(),
322 ksteube 1147 lookup_table._getLookupTable())
323    
324 jongui 1148 self._setupActor3D(self._getDataSetMapper())
325 jongui 1158 scene._addActor3D(self.__viewport, self._getActor3D())
326 jongui 1148
327     def _isModified(self):
328     """
329     Return whether the VelocityOnPlaneCut or DataCollector has been
330     modified.
331 ksteube 1147
332 jongui 1148 @rtype: Boolean
333     @return: True or False
334     """
335 ksteube 1147
336 jongui 1148 return self.__modified or self.__data_collector._isModified()
337 ksteube 1147
338 jongui 1158 def _render(self, scene):
339 jongui 1148 """
340 jongui 1158 Render the velocity cut using a plane.
341    
342     @type scene: L{Scene <scene.Scene>} object
343     @param scene: Scene in which objects are to be rendered on
344 jongui 1148 """
345 ksteube 1147
346 jongui 1148 if (self._isModified() == True):
347     if(self.__data_collector._isVectorSet() == True):
348     self.__data_collector._setActiveVector()
349     # Color velocity by vector.
350     if(self.__color_mode == ColorMode.VECTOR):
351     self._setColorModeByVector()
352 jongui 1189
353     # self._isScalarRangeSet checks whether the scalar range has
354     # been specified by the user. If it has, then the scalar range
355     # read from the source will be ignored.
356     if(not(self._isScalarRangeSet())):
357     self._setRange(self.__data_collector._getVectorRange())
358     self._setScalarRange(\
359     self.__data_collector._getVectorRange())
360     else:
361     self._setRange(self._getDataSetMapperRange())
362    
363 jongui 1148 # Color velocity by scalar.
364     elif(self.__color_mode == ColorMode.SCALAR):
365     self._setColorModeByScalar()
366    
367 jongui 1189 # self._isScalarRangeSet checks whether the scalar range has
368     # been specified by the user. If it has, then the scalar range
369     # read from the source will be ignored.
370     if(not(self._isScalarRangeSet())):
371     self._setRange(self.__data_collector._getScalarRange())
372     self._setScalarRange(\
373     self.__data_collector._getScalarRange())
374     else:
375     self._setRange(self._getDataSetMapperRange())
376    
377 jongui 1148 self.__modified = False
378    
379    
380 ksteube 1147 ###############################################################################
381    
382    
383     from clipper import Clipper
384    
385     # NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
386     # Clipper and MaskPoints were inherited to allow access to
387     # their public methods from the driver.
388     class VelocityOnPlaneClip(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
389     Glyph3D, Transform, Plane, Clipper, MaskPoints):
390     """
391     This class works in a similar way to L{MapOnPlaneClip <map.MapOnPlaneClip>}
392     , except that it shows a vector field using arrows clipped using a plane.
393     """
394    
395     # The SOUTH_WEST default viewport is used when there is only one viewport.
396     # This saves the user from specifying the viewport when there is only one.
397     # If no lut is specified, the color scheme will be used.
398     def __init__(self, scene, data_collector, arrow = Arrow.TWO_D,
399     color_mode = ColorMode.VECTOR, viewport = Viewport.SOUTH_WEST,
400     lut = Lut.COLOR, cell_to_point = False, outline = True):
401     """
402     Initialise the VelocityOnPlaneClip.
403    
404     @attention: The source can either be point or cell data. If the
405     source is cell data, a conversion to point data may or may not be
406     required, in order for the object to be rendered correctly.
407     If a conversion is needed, the 'cell_to_point' flag must be set to
408     'True', otherwise 'False' (which is the default).
409    
410     @type scene: L{Scene <scene.Scene>} object
411     @param scene: Scene in which objects are to be rendered on
412     @type data_collector: L{DataCollector <datacollector.DataCollector>}
413     object
414     @param data_collector: Deal with source of data for visualisation
415     @type arrow: L{Arrow <constant.Arrow>} constant
416     @param arrow: Type of arrow (two dimensional or three dimensional)
417     @type color_mode: L{ColorMode <constant.ColorMode>} constant
418     @param color_mode: Type of color mode
419     @type viewport: L{Viewport <constant.Viewport>} constant
420     @param viewport: Viewport in which objects are to be rendered on
421     @type lut : L{Lut <constant.Lut>} constant
422     @param lut: Lookup table color scheme
423     @type cell_to_point: Boolean
424     @param cell_to_point: Converts cell data to point data (by averaging)
425     @type outline: Boolean
426     @param outline: Places an outline around the domain surface
427     """
428    
429 jongui 1148 self.__data_collector = data_collector
430     self.__arrow = arrow
431     self.__color_mode = color_mode
432     self.__viewport = viewport
433     self.__lut = lut
434     self.__cell_to_point = cell_to_point
435     self.__outline = outline
436    
437     # Keeps track whether VelocityOnPlaneCut has been modified.
438     self.__modified = True
439     Transform.__init__(self)
440     Plane.__init__(self)
441     Clipper.__init__(self)
442     MaskPoints.__init__(self)
443     Glyph3D.__init__(self)
444     DataSetMapper.__init__(self)
445     Actor3D.__init__(self)
446     scene._addVisualizationModules(self)
447 ksteube 1147
448 jongui 1148 # ----- Outline -----
449 ksteube 1147
450 jongui 1148 # NOTE: Changes cannot be made to the Outline's properties from the
451     # driver.
452     if(self.__outline == True):
453     outline = Outline(self.__data_collector._getDataCollectorOutput())
454     mapper = DataSetMapper()
455     mapper._setupDataSetMapper(outline._getOutlineOutput())
456 ksteube 1147
457 jongui 1148 actor3D = Actor3D()
458     actor3D._setupActor3D(mapper._getDataSetMapper())
459 ksteube 1147 # Default outline color is black.
460 jongui 1148 actor3D.setColor(Color.BLACK)
461 ksteube 1147
462     # Default line width is 1.
463 jongui 1148 actor3D._setLineWidth(1)
464 jongui 1158 scene._addActor3D(self.__viewport, actor3D._getActor3D())
465 ksteube 1147
466     # ----- Velocity on a clipped plane -----
467    
468     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
469     # before DataSetMapper. If it is done after DataSetMapper, no effect
470     # will take place.
471 jongui 1148 if(self.__lut == Lut.COLOR): # Colored lookup table.
472 ksteube 1147 lookup_table = LookupTable()
473     lookup_table._setTableValue()
474 jongui 1148 elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
475 ksteube 1147 lookup_table = LookupTable()
476     lookup_table._setLookupTableToGreyScale()
477    
478 jongui 1148 self._setupPlane(self._getTransform())
479 ksteube 1147
480 jongui 1148 if(self.__cell_to_point == True): # Converts cell data to point data.
481     c2p = CellDataToPointData(
482     self.__data_collector._getDataCollectorOutput())
483     self._setupMaskPoints(c2p._getCellToPointOutput())
484     elif(self.__cell_to_point == False): # No conversion happens.
485     self._setupMaskPoints(
486     self.__data_collector._getDataCollectorOutput())
487 ksteube 1147
488     # NOTE: Glyph3D must come before Clipper. Otherwise clipping may not
489     # work correctly.
490 jongui 1148 if(self.__arrow == Arrow.TWO_D): # Use 2D arrows.
491 ksteube 1147 Arrow2D.__init__(self)
492 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
493     self._getArrow2DOutput())
494     elif(self.__arrow == Arrow.THREE_D): # Use 3D arrows.
495 ksteube 1147 Arrow3D.__init__(self)
496 jongui 1148 self._setupGlyph3D(self._getMaskPointsOutput(),
497     self._getArrow3DOutput())
498 ksteube 1147
499 jongui 1148 self._setupClipper(self._getGlyph3DOutput(), self._getPlane())
500     self._setClipFunction()
501 ksteube 1147
502     # NOTE: Clipper must come after Glyph. Otherwise clipping
503     # may not work correctly.
504 jongui 1148 self._setupDataSetMapper(self._getClipperOutput(),
505 ksteube 1147 lookup_table._getLookupTable())
506    
507 jongui 1148 self._setupActor3D(self._getDataSetMapper())
508 jongui 1158 scene._addActor3D(self.__viewport, self._getActor3D())
509 jongui 1148
510     def _isModified(self):
511     """
512     Return whether the VelocityOnPlaneClip or DataCollector has been
513     modified.
514 ksteube 1147
515 jongui 1148 @rtype: Boolean
516     @return: True or False
517     """
518 ksteube 1147
519 jongui 1148 return self.__modified or self.__data_collector._isModified()
520    
521 jongui 1158 def _render(self, scene):
522 jongui 1148 """
523     Render the velocity clip using a plane..
524 jongui 1158
525     @type scene: L{Scene <scene.Scene>} object
526     @param scene: Scene in which objects are to be rendered on
527 jongui 1148 """
528    
529     if (self._isModified() == True):
530     if(self.__data_collector._isVectorSet() == True):
531     self.__data_collector._setActiveVector()
532     # Color velocity by vector.
533     if(self.__color_mode == ColorMode.VECTOR):
534     self._setColorModeByVector()
535 jongui 1189
536     # self._isScalarRangeSet checks whether the scalar range has
537     # been specified by the user. If it has, then the scalar range
538     # read from the source will be ignored.
539     if(not(self._isScalarRangeSet())):
540     self._setRange(self.__data_collector._getVectorRange())
541     self._setScalarRange(\
542     self.__data_collector._getVectorRange())
543     else:
544     self._setRange(self._getDataSetMapperRange())
545    
546 jongui 1148 # Color velocity by scalar.
547     elif(self.__color_mode == ColorMode.SCALAR):
548     self._setColorModeByScalar()
549    
550 jongui 1189 # self._isScalarRangeSet checks whether the scalar range has
551     # been specified by the user. If it has, then the scalar range
552     # read from the source will be ignored.
553     if(not(self._isScalarRangeSet())):
554     self._setRange(self.__data_collector._getScalarRange())
555     self._setScalarRange(\
556     self.__data_collector._getScalarRange())
557     else:
558     self._setRange(self._getDataSetMapperRange())
559    
560 jongui 1148 self.__modified = False
561    
562    

  ViewVC Help
Powered by ViewVC 1.1.26