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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1075 - (hide annotations)
Tue Apr 3 02:47:39 2007 UTC (13 years, 6 months ago) by jongui
File MIME type: text/x-python
File size: 13378 byte(s)
Some minor cleanup.
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, Lut, VizType, ColorMode
10     from sphere import Sphere
11     from normals import Normals
12     from glyph import TensorGlyph
13     from outline import Outline
14 jongui 1057 from point import MaskPoints
15 jongui 1054 from average import CellDataToPointData
16 jongui 1037
17 jongui 1054 # NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph
18     # and MaskPoints were inherited to allow access to their
19 jongui 1037 # public methods from the driver.
20     class Ellipsoid(DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph,
21 jongui 1054 MaskPoints):
22 jongui 1037 """
23     Class that shows a tensor field using ellipsoids. The ellipsoids can either
24     be colored or grey-scaled, depending on the lookup table used.
25     """
26    
27     # The SOUTH_WEST default viewport is used when there is only one viewport.
28     # This saves the user from specifying the viewport when there is only one.
29     # If no lut is specified, the color scheme will be used.
30     def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST,
31 jongui 1054 lut = Lut.COLOR, cell_to_point = False, outline = True):
32 jongui 1037 """
33 jongui 1075 Initialise the Ellipsoid.
34    
35     @attention: The source can either be point or cell data. If the
36     source is cell data, a conversion to point data may or may not be
37     required, in order for the object to be rendered correctly.
38     If a conversion is needed, the 'cell_to_point' flag must be set to
39     'True', otherwise 'False' (which is the default).
40    
41 jongui 1037 @type scene: L{Scene <scene.Scene>} object
42     @param scene: Scene in which objects are to be rendered on
43     @type data_collector: L{DataCollector <datacollector.DataCollector>}
44     object
45     @param data_collector: Deal with source of data for visualisation
46     @type viewport: L{Viewport <constant.Viewport>} constant
47     @param viewport: Viewport in which objects are to be rendered on
48     @type lut : L{Lut <constant.Lut>} constant
49     @param lut: Lookup table color scheme
50 jongui 1054 @type cell_to_point: Boolean
51     @param cell_to_point: Converts cell data to point data (by averaging)
52 jongui 1037 @type outline: Boolean
53     @param outline: Places an outline around the domain surface
54     """
55    
56     # NOTE: Actor3D is inherited and there are two instances declared here.
57     # As a result, when methods from Actor3D is invoked from the driver,
58     # only the methods associated with the latest instance (which in this
59     # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
60     # methods associated with Outline cannot be invoked from the driver.
61     # They can only be called within here, which is why Outline must be
62     # place before Ellipsoid as there is unlikely to be any changes
63     # made to the Outline's Actor3D.
64    
65     # ----- Outline -----
66    
67     if(outline == True):
68     outline = Outline(data_collector._getOutput())
69     DataSetMapper.__init__(self, outline._getOutput())
70    
71     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
72     # Default outline color is black.
73     Actor3D.setColor(self, Color.BLACK)
74    
75     # Default line width is 1.
76     Actor3D._setLineWidth(self, 1)
77     scene._addActor3D(viewport, Actor3D._getActor3D(self))
78    
79     # ----- Ellipsoid -----
80    
81     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
82     # before DataSetMapper. If it is done after DataSetMapper, no effect
83     # will take place.
84     if(lut == Lut.COLOR): # Colored lookup table.
85     lookup_table = LookupTable()
86     lookup_table._setTableValue()
87     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
88     lookup_table = LookupTable()
89     lookup_table._setLookupTableToGreyScale()
90    
91 jongui 1054 if(cell_to_point == True): # Converts cell data to point data.
92     c2p = CellDataToPointData(data_collector._getOutput())
93     MaskPoints.__init__(self, c2p._getOutput())
94     elif(cell_to_point == False): # No conversion happens.
95     MaskPoints.__init__(self, data_collector._getOutput())
96    
97 jongui 1037 Sphere.__init__(self)
98 jongui 1054 TensorGlyph.__init__(self, MaskPoints._getOutput(self),
99 jongui 1037 Sphere._getOutput(self))
100     Normals.__init__(self, TensorGlyph._getOutput(self))
101    
102     DataSetMapper.__init__(self, Normals._getOutput(self),
103     lookup_table._getLookupTable())
104     DataSetMapper._setScalarRange(self, data_collector._getScalarRange())
105    
106     data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
107     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))
108    
109     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
110     scene._addActor3D(viewport, Actor3D._getActor3D(self))
111    
112    
113     ###############################################################################
114    
115    
116     from transform import Transform
117     from plane import Plane
118     from cutter import Cutter
119    
120     # NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph, Transform, Plane,
121 jongui 1056 # Cutter and MaskPoints were inherited to allow access to
122 jongui 1037 # their public methods from the driver.
123     class EllipsoidOnPlaneCut(DataSetMapper, Actor3D, Sphere, Normals,
124 jongui 1056 TensorGlyph, Transform, Plane, Cutter, MaskPoints):
125 jongui 1037 """
126     This class works in a similar way to L{MapOnPlaneCut <map.MapOnPlaneCut>},
127     except that it shows a tensor field using ellipsoids cut using a plane.
128     """
129    
130     # The SOUTH_WEST default viewport is used when there is only one viewport.
131     # This saves the user from specifying the viewport when there is only one.
132     # If no lut is specified, the color scheme will be used.
133     def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST,
134 jongui 1056 lut = Lut.COLOR, cell_to_point = False, outline = True):
135 jongui 1037 """
136 jongui 1075 Initialise the EllipsoidOnPlaneCut.
137    
138     @attention: The source can either be point or cell data. If the
139     source is cell data, a conversion to point data may or may not be
140     required, in order for the object to be rendered correctly.
141     If a conversion is needed, the 'cell_to_point' flag must be set to
142     'True', otherwise 'False' (which is the default).
143    
144 jongui 1037 @type scene: L{Scene <scene.Scene>} object
145     @param scene: Scene in which objects are to be rendered on
146     @type data_collector: L{DataCollector <datacollector.DataCollector>}
147     object
148     @param data_collector: Deal with source of data for visualisation
149     @type viewport: L{Viewport <constant.Viewport>} constant
150     @param viewport: Viewport in which objects are to be rendered on
151     @type lut : L{Lut <constant.Lut>} constant
152     @param lut: Lookup table color scheme
153 jongui 1056 @type cell_to_point: Boolean
154     @param cell_to_point: Converts cell data to point data (by averaging)
155 jongui 1037 @type outline: Boolean
156     @param outline: Places an outline around the domain surface
157     """
158    
159     # NOTE: Actor3D is inherited and there are two instances declared here.
160     # As a result, when methods from Actor3D is invoked from the driver,
161     # only the methods associated with the latest instance (which in this
162     # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
163     # methods associated with Outline cannot be invoked from the driver.
164     # They can only be called within here, which is why Outline must be
165     # place before Ellipsoid as there is unlikely to be any changes
166     # made to the Outline's Actor3D.
167    
168     # ----- Outline -----
169    
170     if(outline == True):
171     outline = Outline(data_collector._getOutput())
172     DataSetMapper.__init__(self, outline._getOutput())
173    
174     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
175     # Default outline color is black.
176     Actor3D.setColor(self, Color.BLACK)
177    
178     # Default line width is 1.
179     Actor3D._setLineWidth(self, 1)
180     scene._addActor3D(viewport, Actor3D._getActor3D(self))
181    
182     # ----- Ellipsoid on a cut plane -----
183    
184     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
185     # before DataSetMapper. If it is done after DataSetMapper, no effect
186     # will take place.
187     if(lut == Lut.COLOR): # Colored lookup table.
188     lookup_table = LookupTable()
189     lookup_table._setTableValue()
190     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
191     lookup_table = LookupTable()
192     lookup_table._setLookupTableToGreyScale()
193    
194     Transform.__init__(self)
195     Plane.__init__(self, Transform._getTransform(self))
196    
197 jongui 1056 if(cell_to_point == True): # Converts cell data to point data.
198     c2p = CellDataToPointData(data_collector._getOutput())
199     Cutter.__init__(self, c2p._getOutput(), Plane._getPlane(self))
200     elif(cell_to_point == False): # No conversion happens.
201     Cutter.__init__(self, data_collector._getOutput(),
202     Plane._getPlane(self))
203    
204     MaskPoints.__init__(self, Cutter._getOutput(self))
205    
206 jongui 1037 Sphere.__init__(self)
207    
208 jongui 1056 TensorGlyph.__init__(self, MaskPoints._getOutput(self),
209 jongui 1037 Sphere._getOutput(self))
210     Normals.__init__(self, TensorGlyph._getOutput(self))
211    
212 jongui 1057
213    
214    
215 jongui 1037 DataSetMapper.__init__(self, Normals._getOutput(self),
216     lookup_table._getLookupTable())
217     DataSetMapper._setScalarRange(self, data_collector._getScalarRange())
218    
219 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
220     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))
221    
222 jongui 1037 Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
223     scene._addActor3D(viewport, Actor3D._getActor3D(self))
224    
225    
226     ###############################################################################
227    
228    
229     from clipper import Clipper
230    
231     # NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph, Transform, Plane,
232 jongui 1056 # Clipper and MaskPoints were inherited to allow access to
233 jongui 1037 # their public methods from the driver.
234     class EllipsoidOnPlaneClip(DataSetMapper, Actor3D, Sphere, Normals,
235 jongui 1056 TensorGlyph, Transform, Plane, Clipper, MaskPoints):
236 jongui 1037 """
237     This class works in a similar way to L{MapOnPlaneClip <map.MapOnPlaneClip>},
238     except that it shows a tensor field using ellipsoids clipped using a plane.
239     """
240    
241     # The SOUTH_WEST default viewport is used when there is only one viewport.
242     # This saves the user from specifying the viewport when there is only one.
243     # If no lut is specified, the color scheme will be used.
244     def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST,
245 jongui 1056 lut = Lut.COLOR, cell_to_point = False, outline = True):
246 jongui 1037 """
247 jongui 1075 Initialise the EllipsoidOnPlaneClip.
248    
249     @attention: The source can either be point or cell data. If the
250     source is cell data, a conversion to point data may or may not be
251     required, in order for the object to be rendered correctly.
252     If a conversion is needed, the 'cell_to_point' flag must be set to
253     'True', otherwise 'False' (which is the default).
254    
255 jongui 1037 @type scene: L{Scene <scene.Scene>} object
256     @param scene: Scene in which objects are to be rendered on
257     @type data_collector: L{DataCollector <datacollector.DataCollector>}
258     object
259     @param data_collector: Deal with source of data for visualisation
260     @type viewport: L{Viewport <constant.Viewport>} constant
261     @param viewport: Viewport in which object are to be rendered on
262     @type lut : L{Lut <constant.Lut>} constant
263     @param lut: Lookup table color scheme
264 jongui 1056 @type cell_to_point: Boolean
265     @param cell_to_point: Converts cell data to point data (by averaging)
266 jongui 1037 @type outline: Boolean
267     @param outline: Places an outline around the domain surface
268     """
269    
270     # NOTE: Actor3D is inherited and there are two instances declared here.
271     # As a result, when methods from Actor3D is invoked from the driver,
272     # only the methods associated with the latest instance (which in this
273     # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
274     # methods associated with Outline cannot be invoked from the driver.
275     # They can only be called within here, which is why Outline must be
276     # place before Ellipsoid as there is unlikely to be any changes
277     # made to the Outline's Actor3D.
278    
279     # ----- Outline -----
280    
281     if(outline == True):
282     outline = Outline(data_collector._getOutput())
283     DataSetMapper.__init__(self, outline._getOutput())
284    
285     Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
286     # Default outline color is black.
287     Actor3D.setColor(self, Color.BLACK)
288    
289     # Default line width is 1.
290     Actor3D._setLineWidth(self, 1)
291     scene._addActor3D(viewport, Actor3D._getActor3D(self))
292    
293     # ----- Ellipsoid on a clipped plane -----
294    
295     # NOTE: Lookup table color mapping (color or grey scale) MUST be set
296     # before DataSetMapper. If it is done after DataSetMapper, no effect
297     # will take place.
298     if(lut == Lut.COLOR): # Colored lookup table.
299     lookup_table = LookupTable()
300     lookup_table._setTableValue()
301     elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
302     lookup_table = LookupTable()
303     lookup_table._setLookupTableToGreyScale()
304    
305     Transform.__init__(self)
306     Plane.__init__(self, Transform._getTransform(self))
307    
308 jongui 1056 if(cell_to_point == True): # Converts cell data to point data.
309     c2p = CellDataToPointData(data_collector._getOutput())
310     Clipper.__init__(self, c2p._getOutput(),
311     Plane._getPlane(self))
312     Clipper._setClipFunction(self)
313     elif(cell_to_point == False): # No conversion happens.
314     Clipper.__init__(self, data_collector._getOutput(),
315     Plane._getPlane(self))
316     Clipper._setClipFunction(self)
317 jongui 1037
318 jongui 1056 MaskPoints.__init__(self, Clipper._getOutput(self))
319    
320 jongui 1037 Sphere.__init__(self)
321 jongui 1056 TensorGlyph.__init__(self, MaskPoints._getOutput(self),
322 jongui 1037 Sphere._getOutput(self))
323    
324     Normals.__init__(self, TensorGlyph._getOutput(self))
325    
326 jongui 1056 DataSetMapper.__init__(self, Normals._getOutput(self),
327 jongui 1037 lookup_table._getLookupTable())
328     DataSetMapper._setScalarRange(self, data_collector._getScalarRange())
329    
330 jongui 1043 data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
331     ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))
332    
333 jongui 1037 Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
334     scene._addActor3D(viewport, Actor3D._getActor3D(self))
335    

  ViewVC Help
Powered by ViewVC 1.1.26