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, ColorMode
from sphere import Sphere
from normals import Normals
from glyph import  TensorGlyph
from outline import Outline
from point import MaskPoints
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): 
        """
        Initialise the Ellipsoid.

        @attention: The source can either be point or cell data. If the 
        source is cell data, a conversion to point data may or may not be 
        required, in order for the object to be rendered correctly. 
        If a conversion is needed, the 'cell_to_point' flag must be set to 
        'True', otherwise 'False' (which is the default).

        @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 vizualisation
        @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
        """

        self.__scene = scene
        self.__data_collector = data_collector
        self.__viewport = viewport
        self.__lut = lut
        self.__cell_to_point = cell_to_point
        self.__outline = outline

        # Keeps track whether Ellipsoid has been modified.
        self.__modified = True      
        MaskPoints.__init__(self)
        Sphere.__init__(self)
        TensorGlyph.__init__(self) 
        Normals.__init__(self)
        DataSetMapper.__init__(self)
        Actor3D.__init__(self)
        scene._addVisualizationModules(self)

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

        # NOTE: Changes cannot be made to the Outline's properties from the 
        # driver.
        if(self.__outline == True):
            outline = Outline(self.__data_collector._getDataCollectorOutput())
            mapper = DataSetMapper()
            mapper._setupDataSetMapper(outline._getOutlineOutput()) 

            actor3D = Actor3D()
            actor3D._setupActor3D(mapper._getDataSetMapper())
            # Default outline color is black.
            actor3D.setColor(Color.BLACK)

            # Default line width is 1.
            actor3D._setLineWidth(1)
            self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())

        # ----- 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(self.__lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        if(self.__cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(
                    self.__data_collector._getDataCollectorOutput())
            self._setupMaskPoints(c2p._getCellToPointOutput())
        elif(self.__cell_to_point == False): # No conversion happens.   
            self._setupMaskPoints(
                    self.__data_collector._getDataCollectorOutput())

        self._setupTensorGlyph(self._getMaskPointsOutput(), 
                self._getSphereOutput()) 
        self._setupNormals(self._getTensorGlyphOutput())

        self._setupDataSetMapper(self._getNormalsOutput(), 
                lookup_table._getLookupTable())

        self._setupActor3D(self._getDataSetMapper())
        self.__scene._addActor3D(self.__viewport, self._getActor3D())

    def _isModified(self):  
        """
        Return whether the Ellipsoid or DataCollector has been modified.

        @rtype: Boolean
        @return: True or False
        """

        return self.__modified or self.__data_collector._isModified()

    def _render(self):
        """
        Render the ellipsoids.
        """

        if (self._isModified() == True):
            if(self.__data_collector._isScalarSet() == True):
                self.__data_collector._setActiveScalar()
            if(self.__data_collector._isTensorSet() == True):
                self.__data_collector._setActiveTensor()

            self._setScalarRange(self.__data_collector._getScalarRange())
            self.__modified = False


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


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): 
        """
        Initialise the EllipsoidOnPlaneCut.

        @attention: The source can either be point or cell data. If the 
        source is cell data, a conversion to point data may or may not be 
        required, in order for the object to be rendered correctly. 
        If a conversion is needed, the 'cell_to_point' flag must be set to 
        'True', otherwise 'False' (which is the default).

        @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 vizualisation
        @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
        """

        self.__scene = scene
        self.__data_collector = data_collector
        self.__viewport = viewport
        self.__lut = lut
        self.__cell_to_point = cell_to_point
        self.__outline = outline

        # Keeps track whether EllipsoidOnPlaneCut has been modified.
        self.__modified = True      
        Transform.__init__(self)
        Plane.__init__(self)
        Cutter.__init__(self)
        MaskPoints.__init__(self)
        Sphere.__init__(self)
        TensorGlyph.__init__(self) 
        Normals.__init__(self)
        DataSetMapper.__init__(self)
        Actor3D.__init__(self)
        scene._addVisualizationModules(self)

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

        # NOTE: Changes cannot be made to the Outline's properties from the 
        # driver.
        if(self.__outline == True):
            outline = Outline(self.__data_collector._getDataCollectorOutput())
            mapper = DataSetMapper()
            mapper._setupDataSetMapper(outline._getOutlineOutput()) 

            actor3D = Actor3D()
            actor3D._setupActor3D(mapper._getDataSetMapper())
            # Default outline color is black.
            actor3D.setColor(Color.BLACK)

            # Default line width is 1.
            actor3D._setLineWidth(1)
            self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())

        # ----- 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(self.__lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        self._setupPlane(self._getTransform())

        if(self.__cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(
                    self.__data_collector._getDataCollectorOutput())
            self._setupCutter(c2p._getCellToPointOutput(), self._getPlane())    
        elif(self.__cell_to_point == False): # No conversion happens.   
            self._setupCutter(self.__data_collector._getDataCollectorOutput(), 
                    self._getPlane())   

        self._setupMaskPoints(self._getCutterOutput())

        self._setupTensorGlyph(self._getMaskPointsOutput(),
                self._getSphereOutput())
        self._setupNormals(self._getTensorGlyphOutput()) 

        self._setupDataSetMapper(self._getNormalsOutput(), 
                lookup_table._getLookupTable())

        self._setupActor3D(self._getDataSetMapper())
        self.__scene._addActor3D(self.__viewport, self._getActor3D())

    def _isModified(self):  
        """
        Return whether the EllipsoidOnPlaneCut or DataCollector has been 
        modified.

        @rtype: Boolean
        @return: True or False
        """

        return self.__modified or self.__data_collector._isModified()

    def _render(self):
        """
        Render the ellipsoids cut using a plane.
        """

        if (self._isModified() == True):
            if(self.__data_collector._isScalarSet() == True):
                self.__data_collector._setActiveScalar()
            if(self.__data_collector._isTensorSet() == True):
                self.__data_collector._setActiveTensor()
            self._setScalarRange(self.__data_collector._getScalarRange())
            self.__modified = False


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


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): 
        """
        Initialise the EllipsoidOnPlaneClip.

        @attention: The source can either be point or cell data. If the 
        source is cell data, a conversion to point data may or may not be 
        required, in order for the object to be rendered correctly. 
        If a conversion is needed, the 'cell_to_point' flag must be set to 
        'True', otherwise 'False' (which is the default).

        @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
        """

        self.__scene = scene
        self.__data_collector = data_collector
        self.__viewport = viewport
        self.__lut = lut
        self.__cell_to_point = cell_to_point
        self.__outline = outline

        # Keeps track whether EllipsoidOnPlaneClip has been modified.
        self.__modified = True      
        Transform.__init__(self)
        Plane.__init__(self)
        Clipper.__init__(self)
        MaskPoints.__init__(self)
        Sphere.__init__(self)
        TensorGlyph.__init__(self) 
        Normals.__init__(self)
        DataSetMapper.__init__(self)
        Actor3D.__init__(self)
        scene._addVisualizationModules(self)

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

        # NOTE: Changes cannot be made to the Outline's properties from the 
        # driver.
        if(self.__outline == True):
            outline = Outline(self.__data_collector._getDataCollectorOutput())
            mapper = DataSetMapper()
            mapper._setupDataSetMapper(outline._getOutlineOutput()) 

            actor3D = Actor3D()
            actor3D._setupActor3D(mapper._getDataSetMapper())
            # Default outline color is black.
            actor3D.setColor(Color.BLACK)

            # Default line width is 1.
            actor3D._setLineWidth(1)
            self.__scene._addActor3D(self.__viewport, actor3D._getActor3D())

        # ----- 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(self.__lut == Lut.COLOR): # Colored lookup table.
            lookup_table = LookupTable()
            lookup_table._setTableValue()
        elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
            lookup_table = LookupTable()
            lookup_table._setLookupTableToGreyScale()

        self._setupPlane(self._getTransform())

        if(self.__cell_to_point == True): # Converts cell data to point data.
            c2p = CellDataToPointData(
                    self.__data_collector._getDataCollectorOutput())
            self._setupMaskPoints(c2p._getCellToPointOutput())
        elif(self.__cell_to_point == False): # No conversion happens.   
            self._setupMaskPoints(
                    self.__data_collector._getDataCollectorOutput())

        # NOTE: TensorGlyph must come before Clipper. Otherwise clipping
        # may not work correctly.
        self._setupTensorGlyph(self._getMaskPointsOutput(),
                self._getSphereOutput())
        self._setupNormals(self._getTensorGlyphOutput())

        # NOTE: Clipper must come after TensorGlyph. Otherwise clipping
        # may not work correctly.
        self._setupClipper(self._getNormalsOutput(), 
                self._getPlane())   
        self._setClipFunction()

        self._setupDataSetMapper(self._getClipperOutput(), 
                lookup_table._getLookupTable())

        self._setupActor3D(self._getDataSetMapper())
        self.__scene._addActor3D(self.__viewport, self._getActor3D())

    def _isModified(self):  
        """
        Return whether the EllipsoidOnPlaneClip or DataCollector has been 
        modified.

        @rtype: Boolean
        @return: True or False
        """

        return self.__modified or self.__data_collector._isModified()

    def _render(self):
        """
        Render the ellipsoids clip using a plane.
        """

        if (self._isModified() == True):
            if(self.__data_collector._isScalarSet() == True):
                self.__data_collector._setActiveScalar()
            if(self.__data_collector._isTensorSet() == True):
                self.__data_collector._setActiveTensor()
            self._setScalarRange(self.__data_collector._getScalarRange())
            self.__modified = False


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