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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1147 - (hide annotations)
Wed May 16 06:39:11 2007 UTC (13 years, 2 months ago) by ksteube
File MIME type: text/x-python
File size: 13449 byte(s)
Added back in some files that were accidentally deleted.

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

  ViewVC Help
Powered by ViewVC 1.1.26