pyvisi/py_src/velocity.py

"""
@author: John NGUI
"""

import vtk
from mapper import DataSetMapper
from lookuptable import LookupTable
from actor import Actor3D
from constant import Viewport, Color, Arrow, ColorMode, Lut
from arrow import Arrow2D, Arrow3D
from glyph import  Glyph3D
from outline import Outline
from probe import Probe
from point import StructuredPoints 

# NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, StructuredPoints and
# Probe were inherited to allow access to their public methods from the driver.
class Velocity(DataSetMapper, Actor3D, Arrow2D, Arrow3D,  Glyph3D, StructuredPoints, Probe):
    """
    Class that show a vector field using arrows.    
    """
    
    # 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 vector field is specified, the first encountered in the file will
    # be loaded automatically.
    def __init__(self, scene, data_collector, vector = None, 
            viewport = Viewport.SOUTH_WEST, outline = True, 
            arrow = Arrow.TWO_D, color_mode = ColorMode.VECTOR, 
            lut = Lut.COLOR): 

        """
        @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 vector: String
        @param vector: Vector field to load from the source file
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which the object is to be rendered on
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        @type arrow: L{Arrow <constant.Arrow>} constant 
        @param arrow: Type of arrow (two dimensional or three dimensional)
        @type color_mode: L{ColorMode <constant.ColorMode>} constant
        @param color_mode: Type of color mode
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        """

        # 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 Velocity) 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 Velocity as there is unlikely to be any changes
        # made to the Outline's Actor3D.

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

        if(outline == True):
            #outline = Outline(Glyph3D._getOutput(self))
            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))


        # ----- Velocity -----

        if(vector != None):
            data_collector._setActiveVector(vector)

        # 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()

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


        if(arrow == Arrow.TWO_D): # Use 2D arrows.
            Arrow2D.__init__(self)
            #Glyph3D.__init__(self, data_collector._getOutput(), 
            Glyph3D.__init__(self, Probe._getOutput(self), 
            #Glyph3D.__init__(self, MaskPoints._getOutput(self), 
                    Arrow2D._getOutput(self), data_collector._getScalarRange()) 
        elif(arrow == Arrow.THREE_D): # Use 3D arrows.
            Arrow3D.__init__(self)
            #Glyph3D.__init__(self, data_collector._getOutput(), 
            Glyph3D.__init__(self, Probe._getOutput(self), 
            #Glyph3D.__init__(self, MaskPoints._getOutput(self), 
                    Arrow3D._getOutput(self), data_collector._getScalarRange()) 

        DataSetMapper.__init__(self, Glyph3D._getOutput(self), 
                lookup_table._getLookupTable())

        if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
            Glyph3D._setColorModeByVector(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getVectorRange())
        elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
            Glyph3D._setColorModeByScalar(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getScalarRange())

        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, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
# Cutter, StructuredPoints and  Probe were inherited to allow access to 
# their public methods from the driver.
class VelocityOnPlaneCut(DataSetMapper, Actor3D, Arrow2D, Arrow3D,  
        Glyph3D, Transform, Plane, Cutter, StructuredPoints, Probe):
    """
    Class that show a vector field using arrows on 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 vector field is specified, the first encountered in the file will
    # be loaded automatically.
    def __init__(self, scene, data_collector, vector = None, 
            viewport = Viewport.SOUTH_WEST, outline = True, 
            arrow = Arrow.THREE_D, color_mode = ColorMode.VECTOR,
            lut = Lut.COLOR): 

        """
        @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 vector: String
        @param vector: Vector field to load from the source file
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which the object is to be rendered on
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        @type arrow: L{Arrow <constant.Arrow>} constant 
        @param arrow: Type of arrow (two dimensional or three dimensional)
        @type color_mode: L{ColorMode <constant.ColorMode>} constant
        @param color_mode: Type of color mode
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        """

        # 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 Velocity) 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 Velocity as there is unlikely to be any changes
        # made to the Outline's Actor3D.

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

        if(outline == True):
            #outline = Outline(Glyph3D._getOutput(self))
            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))


        # ----- Velocity on a cut plane -----

        if(vector != None):
            data_collector._setActiveVector(vector)

        # 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))

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

        if(arrow == Arrow.TWO_D): # Use 2D arrows.
            Arrow2D.__init__(self)
            Glyph3D.__init__(self, Cutter._getOutput(self), 
                    #Arrow2D._getOutput(self), data_collector._getVectorRange()) 
                    Arrow2D._getOutput(self), data_collector._getScalarRange()) 
        elif(arrow == Arrow.THREE_D): # Use 3D arrows.
            Arrow3D.__init__(self)
            Glyph3D.__init__(self, Cutter._getOutput(self), 
                    #Arrow3D._getOutput(self), data_collector._getVectorRange()) 
                    Arrow3D._getOutput(self), data_collector._getScalarRange()) 

        DataSetMapper.__init__(self, Glyph3D._getOutput(self), 
                lookup_table._getLookupTable())

        if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
            Glyph3D._setColorModeByVector(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getVectorRange())
        elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
            Glyph3D._setColorModeByScalar(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getScalarRange())

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


from clipper import Clipper

# NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
# Clipper, StructuredPoints and Probe  were inherited to allow access to 
# their public methods from the driver.
class VelocityOnPlaneClip(DataSetMapper, Actor3D, Arrow2D, Arrow3D,  
        Glyph3D, Transform, Plane, Clipper, StructuredPoints, Probe):
    """
    Class that show a vector field using arrows on a clipped 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 vector field is specified, the first encountered in the file will
    # be loaded automatically.
    def __init__(self, scene, data_collector, vector = None, 
            viewport = Viewport.SOUTH_WEST, outline = True, 
            arrow = Arrow.THREE_D, color_mode = ColorMode.VECTOR, 
            lut = Lut.COLOR): 

        """
        @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 vector: String
        @param vector: Vector field to load from the source file
        @type viewport: L{Viewport <constant.Viewport>} constant
        @param viewport: Viewport in which the object is to be rendered on
        @type outline: Boolean
        @param outline: Places an outline around the domain surface
        @type arrow: L{Arrow <constant.Arrow>} constant 
        @param arrow: Type of arrow (two dimensional or three dimensional)
        @type color_mode: L{ColorMode <constant.ColorMode>} constant
        @param color_mode: Type of color mode
        @type lut : L{Lut <constant.Lut>} constant
        @param lut: Lookup table color scheme
        """

        # 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 Velocity) 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 Velocity as there is unlikely to be any changes
        # made to the Outline's Actor3D.

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

        if(outline == True):
            #outline = Outline(Glyph3D._getOutput(self))
            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))


        # ----- Velocity on a clipped plane -----

        if(vector != None):
            data_collector._setActiveVector(vector)

        # 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))

        #MaskPoints.__init__(self, data_collector._getOutput())

        # NOTE: Glyph3D must come before Clipper. Otherwise, the output will
        # be incorrect.
        if(arrow == Arrow.TWO_D): # Use 2D arrows.
            Arrow2D.__init__(self)
            #Glyph3D.__init__(self, data_collector._getOutput(), 
            Glyph3D.__init__(self, Probe._getOutput(self), 
            #Glyph3D.__init__(self, MaskPoints._getOutput(self), 
                    Arrow2D._getOutput(self), data_collector._getScalarRange()) 
        elif(arrow == Arrow.THREE_D): # Use 3D arrows.
            Arrow3D.__init__(self)
            #Glyph3D.__init__(self, data_collector._getOutput(), 
            Glyph3D.__init__(self, Probe._getOutput(self), 
            #Glyph3D.__init__(self, MaskPoints._getOutput(self), 
                    Arrow3D._getOutput(self), data_collector._getScalarRange()) 

        
        # NOTE: Clipper must come after Glyph3D. Otherwise, the output will
        # be incorrect.
        Clipper.__init__(self, Glyph3D._getOutput(self), 
                Plane._getPlane(self))  
        Clipper._setClipFunction(self)

        DataSetMapper.__init__(self, Clipper._getOutput(self), 
                lookup_table._getLookupTable())

        if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
            Glyph3D._setColorModeByVector(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getVectorRange())
        elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
            Glyph3D._setColorModeByScalar(self)
            DataSetMapper._setScalarRange(self, 
                    data_collector._getScalarRange())

        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, Arrow, ColorMode, Lut
10	from arrow import Arrow2D, Arrow3D
11	from glyph import Glyph3D
12	from outline import Outline
13	from probe import Probe
14	from point import StructuredPoints
15
16	# NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, StructuredPoints and
17	# Probe were inherited to allow access to their public methods from the driver.
18	class Velocity(DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, StructuredPoints, Probe):
19	"""
20	Class that show a vector field using arrows.
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 vector field is specified, the first encountered in the file will
26	# be loaded automatically.
27	def __init__(self, scene, data_collector, vector = None,
28	viewport = Viewport.SOUTH_WEST, outline = True,
29	arrow = Arrow.TWO_D, color_mode = ColorMode.VECTOR,
30	lut = Lut.COLOR):
31
32	"""
33	@type scene: L{Scene <scene.Scene>} object
34	@param scene: Scene in which objects are to be rendered on
35	@type data_collector: L{DataCollector <datacollector.DataCollector>}
36	object
37	@param data_collector: Deal with source of data for visualisation
38	@type vector: String
39	@param vector: Vector field to load from the source file
40	@type viewport: L{Viewport <constant.Viewport>} constant
41	@param viewport: Viewport in which the object is to be rendered on
42	@type outline: Boolean
43	@param outline: Places an outline around the domain surface
44	@type arrow: L{Arrow <constant.Arrow>} constant
45	@param arrow: Type of arrow (two dimensional or three dimensional)
46	@type color_mode: L{ColorMode <constant.ColorMode>} constant
47	@param color_mode: Type of color mode
48	@type lut : L{Lut <constant.Lut>} constant
49	@param lut: Lookup table color scheme
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 Velocity) 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 be
58	# place before Velocity 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(Glyph3D._getOutput(self))
65	outline = Outline(data_collector._getOutput())
66	DataSetMapper.__init__(self, outline._getOutput())
67
68	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
69	# Default outline color is black.
70	Actor3D.setColor(self, Color.BLACK)
71	# Default line width is 1.
72	Actor3D._setLineWidth(self, 1)
73	scene._addActor3D(viewport, Actor3D._getActor3D(self))
74
75
76	# ----- Velocity -----
77
78	if(vector != None):
79	data_collector._setActiveVector(vector)
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	StructuredPoints.__init__(self, data_collector._getOutput())
92	Probe.__init__(self, data_collector._getOutput(),
93	StructuredPoints._getStructuredPoints(self))
94
95
96	if(arrow == Arrow.TWO_D): # Use 2D arrows.
97	Arrow2D.__init__(self)
98	#Glyph3D.__init__(self, data_collector._getOutput(),
99	Glyph3D.__init__(self, Probe._getOutput(self),
100	#Glyph3D.__init__(self, MaskPoints._getOutput(self),
101	Arrow2D._getOutput(self), data_collector._getScalarRange())
102	elif(arrow == Arrow.THREE_D): # Use 3D arrows.
103	Arrow3D.__init__(self)
104	#Glyph3D.__init__(self, data_collector._getOutput(),
105	Glyph3D.__init__(self, Probe._getOutput(self),
106	#Glyph3D.__init__(self, MaskPoints._getOutput(self),
107	Arrow3D._getOutput(self), data_collector._getScalarRange())
108
109	DataSetMapper.__init__(self, Glyph3D._getOutput(self),
110	lookup_table._getLookupTable())
111
112	if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
113	Glyph3D._setColorModeByVector(self)
114	DataSetMapper._setScalarRange(self,
115	data_collector._getVectorRange())
116	elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
117	Glyph3D._setColorModeByScalar(self)
118	DataSetMapper._setScalarRange(self,
119	data_collector._getScalarRange())
120
121	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
122	scene._addActor3D(viewport, Actor3D._getActor3D(self))
123
124
125	from transform import Transform
126	from plane import Plane
127	from cutter import Cutter
128
129	# NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
130	# Cutter, StructuredPoints and Probe were inherited to allow access to
131	# their public methods from the driver.
132	class VelocityOnPlaneCut(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
133	Glyph3D, Transform, Plane, Cutter, StructuredPoints, Probe):
134	"""
135	Class that show a vector field using arrows on a plane.
136	"""
137
138	# The SOUTH_WEST default viewport is used when there is only one viewport.
139	# This saves the user from specifying the viewport when there is only one.
140	# If no vector field is specified, the first encountered in the file will
141	# be loaded automatically.
142	def __init__(self, scene, data_collector, vector = None,
143	viewport = Viewport.SOUTH_WEST, outline = True,
144	arrow = Arrow.THREE_D, color_mode = ColorMode.VECTOR,
145	lut = Lut.COLOR):
146
147	"""
148	@type scene: L{Scene <scene.Scene>} object
149	@param scene: Scene in which objects are to be rendered on
150	@type data_collector: L{DataCollector <datacollector.DataCollector>}
151	object
152	@param data_collector: Deal with source of data for visualisation
153	@type vector: String
154	@param vector: Vector field to load from the source file
155	@type viewport: L{Viewport <constant.Viewport>} constant
156	@param viewport: Viewport in which the object is to be rendered on
157	@type outline: Boolean
158	@param outline: Places an outline around the domain surface
159	@type arrow: L{Arrow <constant.Arrow>} constant
160	@param arrow: Type of arrow (two dimensional or three dimensional)
161	@type color_mode: L{ColorMode <constant.ColorMode>} constant
162	@param color_mode: Type of color mode
163	@type lut : L{Lut <constant.Lut>} constant
164	@param lut: Lookup table color scheme
165	"""
166
167	# NOTE: Actor3D is inherited and there are two instances declared here.
168	# As a result, when methods from Actor3D is invoked from the driver,
169	# only the methods associated with the latest instance (which in this
170	# case is the Actor3D for the Velocity) can be executed. Actor3D
171	# methods associated with Outline cannot be invoked from the driver.
172	# They can only be called within here, which is why Outline must be
173	# place before Velocity as there is unlikely to be any changes
174	# made to the Outline's Actor3D.
175
176	# ----- Outline -----
177
178	if(outline == True):
179	#outline = Outline(Glyph3D._getOutput(self))
180	outline = Outline(data_collector._getOutput())
181	DataSetMapper.__init__(self, outline._getOutput())
182
183	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
184	# Default outline color is black.
185	Actor3D.setColor(self, Color.BLACK)
186	# Default line width is 1.
187	Actor3D._setLineWidth(self, 1)
188	scene._addActor3D(viewport, Actor3D._getActor3D(self))
189
190
191	# ----- Velocity on a cut plane -----
192
193	if(vector != None):
194	data_collector._setActiveVector(vector)
195
196	# NOTE: Lookup table color mapping (color or grey scale) MUST be set
197	# before DataSetMapper. If it is done after DataSetMapper, no effect
198	# will take place.
199	if(lut == Lut.COLOR): # Colored lookup table.
200	lookup_table = LookupTable()
201	lookup_table._setTableValue()
202	elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
203	lookup_table = LookupTable()
204	lookup_table._setLookupTableToGreyScale()
205
206	Transform.__init__(self)
207	Plane.__init__(self, Transform._getTransform(self))
208
209	StructuredPoints.__init__(self, data_collector._getOutput())
210	Probe.__init__(self, data_collector._getOutput(),
211	StructuredPoints._getStructuredPoints(self))
212
213	Cutter.__init__(self, Probe._getOutput(self),
214	#Cutter.__init__(self, data_collector._getOutput(),
215	Plane._getPlane(self))
216
217	if(arrow == Arrow.TWO_D): # Use 2D arrows.
218	Arrow2D.__init__(self)
219	Glyph3D.__init__(self, Cutter._getOutput(self),
220	#Arrow2D._getOutput(self), data_collector._getVectorRange())
221	Arrow2D._getOutput(self), data_collector._getScalarRange())
222	elif(arrow == Arrow.THREE_D): # Use 3D arrows.
223	Arrow3D.__init__(self)
224	Glyph3D.__init__(self, Cutter._getOutput(self),
225	#Arrow3D._getOutput(self), data_collector._getVectorRange())
226	Arrow3D._getOutput(self), data_collector._getScalarRange())
227
228	DataSetMapper.__init__(self, Glyph3D._getOutput(self),
229	lookup_table._getLookupTable())
230
231	if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
232	Glyph3D._setColorModeByVector(self)
233	DataSetMapper._setScalarRange(self,
234	data_collector._getVectorRange())
235	elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
236	Glyph3D._setColorModeByScalar(self)
237	DataSetMapper._setScalarRange(self,
238	data_collector._getScalarRange())
239
240	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
241	scene._addActor3D(viewport, Actor3D._getActor3D(self))
242
243
244	from clipper import Clipper
245
246	# NOTE: DataSetMapper, Actor3D, Arrow2D, Arrow3D, Glyph3D, Transform, Plane,
247	# Clipper, StructuredPoints and Probe were inherited to allow access to
248	# their public methods from the driver.
249	class VelocityOnPlaneClip(DataSetMapper, Actor3D, Arrow2D, Arrow3D,
250	Glyph3D, Transform, Plane, Clipper, StructuredPoints, Probe):
251	"""
252	Class that show a vector field using arrows on a clipped plane.
253	"""
254
255	# The SOUTH_WEST default viewport is used when there is only one viewport.
256	# This saves the user from specifying the viewport when there is only one.
257	# If no vector field is specified, the first encountered in the file will
258	# be loaded automatically.
259	def __init__(self, scene, data_collector, vector = None,
260	viewport = Viewport.SOUTH_WEST, outline = True,
261	arrow = Arrow.THREE_D, color_mode = ColorMode.VECTOR,
262	lut = Lut.COLOR):
263
264	"""
265	@type scene: L{Scene <scene.Scene>} object
266	@param scene: Scene in which objects are to be rendered on
267	@type data_collector: L{DataCollector <datacollector.DataCollector>}
268	object
269	@param data_collector: Deal with source of data for visualisation
270	@type vector: String
271	@param vector: Vector field to load from the source file
272	@type viewport: L{Viewport <constant.Viewport>} constant
273	@param viewport: Viewport in which the object is to be rendered on
274	@type outline: Boolean
275	@param outline: Places an outline around the domain surface
276	@type arrow: L{Arrow <constant.Arrow>} constant
277	@param arrow: Type of arrow (two dimensional or three dimensional)
278	@type color_mode: L{ColorMode <constant.ColorMode>} constant
279	@param color_mode: Type of color mode
280	@type lut : L{Lut <constant.Lut>} constant
281	@param lut: Lookup table color scheme
282	"""
283
284	# NOTE: Actor3D is inherited and there are two instances declared here.
285	# As a result, when methods from Actor3D is invoked from the driver,
286	# only the methods associated with the latest instance (which in this
287	# case is the Actor3D for the Velocity) can be executed. Actor3D
288	# methods associated with Outline cannot be invoked from the driver.
289	# They can only be called within here, which is why Outline must be
290	# place before Velocity as there is unlikely to be any changes
291	# made to the Outline's Actor3D.
292
293	# ----- Outline -----
294
295	if(outline == True):
296	#outline = Outline(Glyph3D._getOutput(self))
297	outline = Outline(data_collector._getOutput())
298	DataSetMapper.__init__(self, outline._getOutput())
299
300	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
301	# Default outline color is black.
302	Actor3D.setColor(self, Color.BLACK)
303	# Default line width is 1.
304	Actor3D._setLineWidth(self, 1)
305	scene._addActor3D(viewport, Actor3D._getActor3D(self))
306
307
308	# ----- Velocity on a clipped plane -----
309
310	if(vector != None):
311	data_collector._setActiveVector(vector)
312
313	# NOTE: Lookup table color mapping (color or grey scale) MUST be set
314	# before DataSetMapper. If it is done after DataSetMapper, no effect
315	# will take place.
316	if(lut == Lut.COLOR): # Colored lookup table.
317	lookup_table = LookupTable()
318	lookup_table._setTableValue()
319	elif(lut == Lut.GREY_SCALE): # Grey scaled lookup table.
320	lookup_table = LookupTable()
321	lookup_table._setLookupTableToGreyScale()
322
323	Transform.__init__(self)
324	Plane.__init__(self, Transform._getTransform(self))
325
326	StructuredPoints.__init__(self, data_collector._getOutput())
327	Probe.__init__(self, data_collector._getOutput(),
328	StructuredPoints._getStructuredPoints(self))
329
330	#MaskPoints.__init__(self, data_collector._getOutput())
331
332	# NOTE: Glyph3D must come before Clipper. Otherwise, the output will
333	# be incorrect.
334	if(arrow == Arrow.TWO_D): # Use 2D arrows.
335	Arrow2D.__init__(self)
336	#Glyph3D.__init__(self, data_collector._getOutput(),
337	Glyph3D.__init__(self, Probe._getOutput(self),
338	#Glyph3D.__init__(self, MaskPoints._getOutput(self),
339	Arrow2D._getOutput(self), data_collector._getScalarRange())
340	elif(arrow == Arrow.THREE_D): # Use 3D arrows.
341	Arrow3D.__init__(self)
342	#Glyph3D.__init__(self, data_collector._getOutput(),
343	Glyph3D.__init__(self, Probe._getOutput(self),
344	#Glyph3D.__init__(self, MaskPoints._getOutput(self),
345	Arrow3D._getOutput(self), data_collector._getScalarRange())
346
347
348	# NOTE: Clipper must come after Glyph3D. Otherwise, the output will
349	# be incorrect.
350	Clipper.__init__(self, Glyph3D._getOutput(self),
351	Plane._getPlane(self))
352	Clipper._setClipFunction(self)
353
354	DataSetMapper.__init__(self, Clipper._getOutput(self),
355	lookup_table._getLookupTable())
356
357	if(color_mode == ColorMode.VECTOR): # Color velocity by vector.
358	Glyph3D._setColorModeByVector(self)
359	DataSetMapper._setScalarRange(self,
360	data_collector._getVectorRange())
361	elif(color_mode == ColorMode.SCALAR): # Color velocity by scalar.
362	Glyph3D._setColorModeByScalar(self)
363	DataSetMapper._setScalarRange(self,
364	data_collector._getScalarRange())
365
366	Actor3D.__init__(self, DataSetMapper._getDataSetMapper(self))
367	scene._addActor3D(viewport, Actor3D._getActor3D(self))