pyvisi/py_src/ellipsoid.py

"""
@author: John NGUI
"""

import vtk
from mapper import DataSetMapper
from lookuptable import LookupTable
from actor import Actor3D
from constant import Viewport, Color, Lut, VizType, ColorMode
from sphere import Sphere
from normals import Normals
from glyph import  TensorGlyph
from outline import Outline
from point import StructuredPoints, MaskPoints
from probe import Probe
from average import CellDataToPointData

# NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph 
# and MaskPoints  were inherited to allow access to their 
# public methods from the driver.
class Ellipsoid(DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph, 
        MaskPoints):
    """
    Class that shows a tensor field using ellipsoids. The ellipsoids can either
    be colored or grey-scaled, depending on the lookup table used.
    """

    # The SOUTH_WEST default viewport is used when there is only one viewport.
    # This saves the user from specifying the viewport when there is only one.
    # If no lut is specified, the color scheme will be used. 
    def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST, 
            lut = Lut.COLOR, cell_to_point = False, outline = True): 
        """
        @type scene: L{Scene <scene.Scene>} object
        @param scene: Scene in which objects are to be rendered on
        @type data_collector: L{DataCollector <datacollector.DataCollector>}
                object
        @param data_collector: Deal with source of data for visualisation
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which objects are to be rendered on
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        @type cell_to_point: Boolean
        @param cell_to_point: Converts cell data to point data (by averaging)
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        """

        # NOTE: Actor3D is inherited and there are two instances declared here.
        # As a result, when methods from Actor3D is invoked from the driver,
        # only the methods associated with the latest instance (which in this
        # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
        # methods associated with Outline cannot be invoked from the driver.
        # They can only be called within here, which is why Outline must be
        # place before Ellipsoid as there is unlikely to be any changes
        # made to the Outline's Actor3D.

        # ----- Outline -----

        if(outline == True):
            outline = Outline(data_collector._getOutput())
            DataSetMapper.__init__(self, outline._getOutput())

            Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
            # Default outline color is black.
            Actor3D.setColor(self, Color.BLACK)

            # Default line width is 1.
            Actor3D._setLineWidth(self, 1)
            scene._addActor3D(viewport, Actor3D._getActor3D(self))

        # ----- Ellipsoid -----

        # NOTE: Lookup table color mapping (color or grey scale) MUST be set
        # before DataSetMapper. If it is done after DataSetMapper, no effect
        # will take place.
        if(lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        if(cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(data_collector._getOutput())
            MaskPoints.__init__(self, c2p._getOutput())
        elif(cell_to_point == False): # No conversion happens.  
            MaskPoints.__init__(self, data_collector._getOutput())

        Sphere.__init__(self)
        TensorGlyph.__init__(self, MaskPoints._getOutput(self), 
                Sphere._getOutput(self)) 
        Normals.__init__(self, TensorGlyph._getOutput(self))

        DataSetMapper.__init__(self, Normals._getOutput(self), 
                lookup_table._getLookupTable())
        DataSetMapper._setScalarRange(self, data_collector._getScalarRange())

        data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
                ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))

        Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
        scene._addActor3D(viewport, Actor3D._getActor3D(self))


###############################################################################


from transform import Transform
from plane import Plane
from cutter import Cutter

# NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph, Transform, Plane,
# Cutter and MaskPoints were inherited to allow access to 
# their public methods from the driver.
class EllipsoidOnPlaneCut(DataSetMapper, Actor3D, Sphere, Normals,  
        TensorGlyph, Transform, Plane, Cutter, MaskPoints):
    """
    This class works in a similar way to L{MapOnPlaneCut <map.MapOnPlaneCut>},
    except that it shows a tensor field using ellipsoids cut using a plane.
    """

    # The SOUTH_WEST default viewport is used when there is only one viewport.
    # This saves the user from specifying the viewport when there is only one.
    # If no lut is specified, the color scheme will be used. 
    def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST, 
            lut = Lut.COLOR, cell_to_point = False, outline = True): 
        """
        @type scene: L{Scene <scene.Scene>} object
        @param scene: Scene in which objects are to be rendered on
        @type data_collector: L{DataCollector <datacollector.DataCollector>}
                object
        @param data_collector: Deal with source of data for visualisation
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which objects are to be rendered on
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        @type cell_to_point: Boolean
        @param cell_to_point: Converts cell data to point data (by averaging)
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        """

        # NOTE: Actor3D is inherited and there are two instances declared here.
        # As a result, when methods from Actor3D is invoked from the driver,
        # only the methods associated with the latest instance (which in this
        # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
        # methods associated with Outline cannot be invoked from the driver.
        # They can only be called within here, which is why Outline must be
        # place before Ellipsoid as there is unlikely to be any changes
        # made to the Outline's Actor3D.

        # ----- Outline -----

        if(outline == True):
            outline = Outline(data_collector._getOutput())
            DataSetMapper.__init__(self, outline._getOutput())

            Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
            # Default outline color is black.
            Actor3D.setColor(self, Color.BLACK)

            # Default line width is 1.
            Actor3D._setLineWidth(self, 1)
            scene._addActor3D(viewport, Actor3D._getActor3D(self))

        # ----- Ellipsoid on a cut plane -----

        # NOTE: Lookup table color mapping (color or grey scale) MUST be set
        # before DataSetMapper. If it is done after DataSetMapper, no effect
        # will take place.
        if(lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        Transform.__init__(self)    
        Plane.__init__(self, Transform._getTransform(self))

        #StructuredPoints.__init__(self, data_collector._getOutput())
        #Probe.__init__(self, data_collector._getOutput(),
        #       StructuredPoints._getStructuredPoints(self))

        if(cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(data_collector._getOutput())
            Cutter.__init__(self, c2p._getOutput(), Plane._getPlane(self))  
        elif(cell_to_point == False): # No conversion happens.  
            Cutter.__init__(self, data_collector._getOutput(), 
                    Plane._getPlane(self))  

        MaskPoints.__init__(self, Cutter._getOutput(self))

        #Cutter.__init__(self, Probe._getOutput(self), 
        #       Plane._getPlane(self))  

        Sphere.__init__(self)

        #TensorGlyph.__init__(self, Cutter._getOutput(self),
        TensorGlyph.__init__(self, MaskPoints._getOutput(self),
                Sphere._getOutput(self))
        Normals.__init__(self, TensorGlyph._getOutput(self)) 

        DataSetMapper.__init__(self, Normals._getOutput(self), 
                lookup_table._getLookupTable())
        DataSetMapper._setScalarRange(self, data_collector._getScalarRange())

        data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
                ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))

        Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
        scene._addActor3D(viewport, Actor3D._getActor3D(self))


###############################################################################


from clipper import Clipper

# NOTE: DataSetMapper, Actor3D, Sphere, Normals, TensorGlyph, Transform, Plane,
# Clipper and MaskPoints were inherited to allow access to 
# their public methods from the driver.
class EllipsoidOnPlaneClip(DataSetMapper, Actor3D, Sphere, Normals,  
    TensorGlyph, Transform, Plane, Clipper, MaskPoints):
    """
    This class works in a similar way to L{MapOnPlaneClip <map.MapOnPlaneClip>},
    except that it shows a tensor field using ellipsoids clipped using a plane.
    """

    # The SOUTH_WEST default viewport is used when there is only one viewport.
    # This saves the user from specifying the viewport when there is only one.
    # If no lut is specified, the color scheme will be used. 
    def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST, 
            lut = Lut.COLOR, cell_to_point = False, outline = True): 
        """
        @type scene: L{Scene <scene.Scene>} object
        @param scene: Scene in which objects are to be rendered on
        @type data_collector: L{DataCollector <datacollector.DataCollector>}
                object
        @param data_collector: Deal with source of data for visualisation
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which object are to be rendered on
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        @type cell_to_point: Boolean
        @param cell_to_point: Converts cell data to point data (by averaging)
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        """

        # NOTE: Actor3D is inherited and there are two instances declared here.
        # As a result, when methods from Actor3D is invoked from the driver,
        # only the methods associated with the latest instance (which in this
        # case is the Actor3D for the Ellipsoid) can be executed. Actor3D
        # methods associated with Outline cannot be invoked from the driver.
        # They can only be called within here, which is why Outline must be
        # place before Ellipsoid as there is unlikely to be any changes
        # made to the Outline's Actor3D.

        # ----- Outline -----

        if(outline == True):
            outline = Outline(data_collector._getOutput())
            DataSetMapper.__init__(self, outline._getOutput())

            Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
            # Default outline color is black.
            Actor3D.setColor(self, Color.BLACK)

            # Default line width is 1.
            Actor3D._setLineWidth(self, 1)
            scene._addActor3D(viewport, Actor3D._getActor3D(self))

        # ----- Ellipsoid on a clipped plane -----

        # NOTE: Lookup table color mapping (color or grey scale) MUST be set
        # before DataSetMapper. If it is done after DataSetMapper, no effect
        # will take place.
        if(lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        Transform.__init__(self)    
        Plane.__init__(self, Transform._getTransform(self))

        if(cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(data_collector._getOutput())
            Clipper.__init__(self, c2p._getOutput(), 
                    Plane._getPlane(self))  
            Clipper._setClipFunction(self)
        elif(cell_to_point == False): # No conversion happens.  
            Clipper.__init__(self, data_collector._getOutput(), 
                    Plane._getPlane(self))  
            Clipper._setClipFunction(self)

        MaskPoints.__init__(self, Clipper._getOutput(self))

        Sphere.__init__(self)
        TensorGlyph.__init__(self, MaskPoints._getOutput(self),
                Sphere._getOutput(self))

        Normals.__init__(self, TensorGlyph._getOutput(self))

        DataSetMapper.__init__(self, Normals._getOutput(self), 
            lookup_table._getLookupTable())
        DataSetMapper._setScalarRange(self, data_collector._getScalarRange())

        data_collector._paramForUpdatingMultipleSources(VizType.ELLIPSOID,
                ColorMode.SCALAR, DataSetMapper._getDataSetMapper(self))

        Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
        scene._addActor3D(viewport, Actor3D._getActor3D(self))

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