pyvisi/py_src/carpet.py

"""
@var __author__: name of author
@var __copyright__: copyrights
@var __license__: licence agreement
@var __url__: url entry point on documentation
@var __version__: version
@var __date__: date of the version
"""

__author__="John Ngui, john.ngui@uq.edu.au"
__copyright__="""  Copyright (c) 2006 by ACcESS MNRF
                    http://www.access.edu.au
                Primary Business: Queensland, Australia"""
__license__="""Licensed under the Open Software License version 3.0
             http://www.opensource.org/licenses/osl-3.0.php"""
__url__="http://www.iservo.edu.au/esys"
__version__="$Revision$"
__date__="$Date$"


import vtk
from mapper import DataSetMapper
from lookuptable import LookupTable
from actor import Actor3D
from constant import Viewport, Color, Lut, WarpMode, ColorMode
from warp import Warp
from outline import Outline
from transform import Transform
from plane import Plane
from cutter import Cutter
from average import CellDataToPointData

# NOTE: DataSetMapper, Actor3D, Warp, Transform, Plane and Cutter  were 
# inherited to allow access to their public methods from the driver.
class Carpet(DataSetMapper, Actor3D, Warp, Transform, Plane, Cutter):
    """
    Class that shows a scalar field on a plane deformated along the normal.
    """

    # 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 warp_mode is specified, the data will be deformated using scalar
    # data. If no lut is specified, the color scheme will be used. 
    def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST, 
            warp_mode = WarpMode.SCALAR, lut = Lut.COLOR, 
            cell_to_point = False, outline = True):
        """
        Initialise the Carpet.

        @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). On occasions, an
        inaccurate object may be rendered from cell data even after conversion.

        @attention:  When 3D data is used, a cut will be performed on the 
        scalar field using a 
        plane before deformation occurs on the plane. However, if 2D data is 
        used a cut will NOT be performed and deformation will instead occur 
        immediately on the scalar field.  Pyvisi distinguishes 2D from 3D data 
        by retrieving the 
        length of the z-axis. A 2D data is assumed to have a z-axis length of 
        zero 
        while a 3D data is assumed to have a z-axis length of non-zero. 
        There are 
        exceptions to these rules where some 2D data may have a non-zero 
        z-axis length. However, such exceptions are not taken into account 
        at this stage.

        @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
        @param warp_mode: L{WarpMode <constant.WarpMode>} constant
        @type warp_mode: Mode in which to deform the scalar field 
        @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.__data_collector = data_collector
        self.__viewport = viewport
        self.__warp_mode = warp_mode
        self.__lut = lut
        self.__cell_to_point = cell_to_point
        self.__outline = outline
        
        # Keeps track whether Carpet has been modified.
        self.__modified = True 
        Transform.__init__(self)    
        Plane.__init__(self)
        Cutter.__init__(self)
        Warp.__init__(self, self.__warp_mode)
        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)
            scene._addActor3D(self.__viewport, actor3D._getActor3D())

        # ----- Carpet -----

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

        self._setupPlane(self._getTransform())

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

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

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

    def _render(self, scene):
        """
        Render the carpet.

        @type scene: L{Scene <scene.Scene>} object
        @param scene: Scene in which objects are to be rendered on
        """

        # This entire 'if' section had to be moved from the __init__ method
        # due to the use of 'GetBounds()'. A source (i.e. xml file) must be
        # supplied before 'GetBounds()' is able to return the correct value
        # when executed. This is to accommodate for lazy evaluation.
        if(self.__modified):
            # Get the bounds of the object in the form of
            # (xmin, xmax, ymin, ymax, zmin, zmax).
            bounds = \
                    self.__data_collector._getDataCollectorOutput().GetBounds()
            # Length of the z-axis (max - min). Assumption is made that if the
            # length of the z-axis is equal to zero, the the data set is 2D.
            # Otherwise, the data set is 3D. However, there are exceptions 
            # to this rule as some 2D data sets may have a z-axis length 
            # of non-zero, but such exceptions are not taken into account here.
            z_axis_length = bounds[5] - bounds[4]

            if(self.__cell_to_point == True): #Convert cell data to point data.
                c2p = CellDataToPointData(\
                        self.__data_collector._getDataCollectorOutput())
                if(z_axis_length != 0): # A cutter is used for 3D data.
                    self._setupCutter(c2p._getCellToPointOutput(), \
                            self._getPlane())   
                    self._setupWarp(self._getCutterOutput())
                elif(z_axis_length == 0): # A cutter is not used for 2D data.
                    self._setupWarp(c2p._getCellToPointOutput())

            elif(self.__cell_to_point == False): # No conversion happens.   
                if(z_axis_length != 0): # A cutter is used for 3D data.
                    self._setupCutter(\
                            self.__data_collector._getDataCollectorOutput(), \
                            self._getPlane())   
                    self._setupWarp(self._getCutterOutput())
                elif(z_axis_length == 0): # A cutter is not used for 2D data.
                    self._setupWarp(
                            self.__data_collector._getDataCollectorOutput())

            self._setupDataSetMapper(self._getWarpOutput(),
                    self.__lookup_table._getLookupTable())

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


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

            # self._isScalarRangeSet checks whether the scalar range has been
            # specified by the user. If it has, then the scalar range
            # read from the source will be ignored.
            if(not(self._isScalarRangeSet())): 
                self._setScalarRange(self.__data_collector._getScalarRange())
            self.__modified = False


1	ksteube	1147	"""
2	jongui	1197	@var __author__: name of author
3			@var __copyright__: copyrights
4			@var __license__: licence agreement
5			@var __url__: url entry point on documentation
6			@var __version__: version
7			@var __date__: date of the version
8	ksteube	1147	"""
9
10	jongui	1197	__author__="John Ngui, john.ngui@uq.edu.au"
11			__copyright__=""" Copyright (c) 2006 by ACcESS MNRF
12			http://www.access.edu.au
13			Primary Business: Queensland, Australia"""
14			__license__="""Licensed under the Open Software License version 3.0
15			http://www.opensource.org/licenses/osl-3.0.php"""
16			__url__="http://www.iservo.edu.au/esys"
17			__version__="$Revision$"
18			__date__="$Date$"
19
20
21	ksteube	1147	import vtk
22			from mapper import DataSetMapper
23			from lookuptable import LookupTable
24			from actor import Actor3D
25	jongui	1148	from constant import Viewport, Color, Lut, WarpMode, ColorMode
26	ksteube	1147	from warp import Warp
27			from outline import Outline
28			from transform import Transform
29			from plane import Plane
30			from cutter import Cutter
31			from average import CellDataToPointData
32
33			# NOTE: DataSetMapper, Actor3D, Warp, Transform, Plane and Cutter were
34			# inherited to allow access to their public methods from the driver.
35			class Carpet(DataSetMapper, Actor3D, Warp, Transform, Plane, Cutter):
36			"""
37			Class that shows a scalar field on a plane deformated along the normal.
38			"""
39
40			# The SOUTH_WEST default viewport is used when there is only one viewport.
41			# This saves the user from specifying the viewport when there is only one.
42			# If no warp_mode is specified, the data will be deformated using scalar
43			# data. If no lut is specified, the color scheme will be used.
44			def __init__(self, scene, data_collector, viewport = Viewport.SOUTH_WEST,
45			warp_mode = WarpMode.SCALAR, lut = Lut.COLOR,
46			cell_to_point = False, outline = True):
47			"""
48			Initialise the Carpet.
49
50			@attention: The source can either be point or cell data. If the
51			source is cell data, a conversion to point data may or may not be
52			required, in order for the object to be rendered correctly.
53			If a conversion is needed, the 'cell_to_point' flag must be set to
54	jongui	1199	'True', otherwise 'False' (which is the default). On occasions, an
55			inaccurate object may be rendered from cell data even after conversion.
56	ksteube	1147
57	jongui	1209	@attention: When 3D data is used, a cut will be performed on the
58			scalar field using a
59			plane before deformation occurs on the plane. However, if 2D data is
60			used a cut will NOT be performed and deformation will instead occur
61			immediately on the scalar field. Pyvisi distinguishes 2D from 3D data
62			by retrieving the
63			length of the z-axis. A 2D data is assumed to have a z-axis length of
64			zero
65			while a 3D data is assumed to have a z-axis length of non-zero.
66			There are
67			exceptions to these rules where some 2D data may have a non-zero
68			z-axis length. However, such exceptions are not taken into account
69			at this stage.
70
71	ksteube	1147	@type scene: L{Scene <scene.Scene>} object
72			@param scene: Scene in which objects are to be rendered on
73			@type data_collector: L{DataCollector <datacollector.DataCollector>}
74			object
75			@param data_collector: Deal with source of data for visualisation
76			@type viewport: L{Viewport <constant.Viewport>} constant
77			@param viewport: Viewport in which objects are to be rendered on
78			@param warp_mode: L{WarpMode <constant.WarpMode>} constant
79			@type warp_mode: Mode in which to deform the scalar field
80			@type lut : L{Lut <constant.Lut>} constant
81			@param lut: Lookup table color scheme
82			@type cell_to_point: Boolean
83			@param cell_to_point: Converts cell data to point data (by averaging)
84			@type outline: Boolean
85			@param outline: Places an outline around the domain surface
86			"""
87
88	jongui	1148	self.__data_collector = data_collector
89			self.__viewport = viewport
90			self.__warp_mode = warp_mode
91			self.__lut = lut
92			self.__cell_to_point = cell_to_point
93			self.__outline = outline
94
95			# Keeps track whether Carpet has been modified.
96			self.__modified = True
97			Transform.__init__(self)
98			Plane.__init__(self)
99			Cutter.__init__(self)
100			Warp.__init__(self, self.__warp_mode)
101			DataSetMapper.__init__(self)
102			Actor3D.__init__(self)
103			scene._addVisualizationModules(self)
104	ksteube	1147
105			# ----- Outline -----
106
107	jongui	1148	# NOTE: Changes cannot be made to the Outline's properties from the
108			# driver.
109			if(self.__outline == True):
110			outline = Outline(self.__data_collector._getDataCollectorOutput())
111			mapper = DataSetMapper()
112			mapper._setupDataSetMapper(outline._getOutlineOutput())
113	ksteube	1147
114	jongui	1148	actor3D = Actor3D()
115			actor3D._setupActor3D(mapper._getDataSetMapper())
116	ksteube	1147	# Default outline color is black.
117	jongui	1148	actor3D.setColor(Color.BLACK)
118	ksteube	1147
119			# Default line width is 1.
120	jongui	1148	actor3D._setLineWidth(1)
121	jongui	1158	scene._addActor3D(self.__viewport, actor3D._getActor3D())
122	ksteube	1147
123			# ----- Carpet -----
124
125			# NOTE: Lookup table color mapping (color or grey scale) MUST be set
126			# before DataSetMapper. If it is done after DataSetMapper, no effect
127			# will take place.
128	jongui	1148	if(self.__lut == Lut.COLOR): # Colored lookup table.
129	jongui	1209	self.__lookup_table = LookupTable()
130			self.__lookup_table._setTableValue()
131	jongui	1148	elif(self.__lut == Lut.GREY_SCALE): # Grey scaled lookup table.
132	jongui	1209	self.__lookup_table = LookupTable()
133			self.__lookup_table._setLookupTableToGreyScale()
134	ksteube	1147
135	jongui	1148	self._setupPlane(self._getTransform())
136	jongui	1207
137	jongui	1148	def _isModified(self):
138			"""
139			Return whether the Carpet or DataCollector has been modified.
140	ksteube	1147
141	jongui	1148	@rtype: Boolean
142			@return: True or False
143			"""
144
145			return self.__modified or self.__data_collector._isModified()
146
147	jongui	1158	def _render(self, scene):
148	jongui	1148	"""
149			Render the carpet.
150	jongui	1158
151			@type scene: L{Scene <scene.Scene>} object
152			@param scene: Scene in which objects are to be rendered on
153	jongui	1148	"""
154
155	jongui	1209	# This entire 'if' section had to be moved from the __init__ method
156			# due to the use of 'GetBounds()'. A source (i.e. xml file) must be
157			# supplied before 'GetBounds()' is able to return the correct value
158			# when executed. This is to accommodate for lazy evaluation.
159	jongui	1208	if(self.__modified):
160			# Get the bounds of the object in the form of
161			# (xmin, xmax, ymin, ymax, zmin, zmax).
162	jongui	1210	bounds = \
163			self.__data_collector._getDataCollectorOutput().GetBounds()
164	jongui	1208	# Length of the z-axis (max - min). Assumption is made that if the
165			# length of the z-axis is equal to zero, the the data set is 2D.
166	jongui	1209	# Otherwise, the data set is 3D. However, there are exceptions
167			# to this rule as some 2D data sets may have a z-axis length
168			# of non-zero, but such exceptions are not taken into account here.
169	jongui	1208	z_axis_length = bounds[5] - bounds[4]
170
171	jongui	1210	if(self.__cell_to_point == True): #Convert cell data to point data.
172	jongui	1208	c2p = CellDataToPointData(\
173			self.__data_collector._getDataCollectorOutput())
174			if(z_axis_length != 0): # A cutter is used for 3D data.
175			self._setupCutter(c2p._getCellToPointOutput(), \
176			self._getPlane())
177			self._setupWarp(self._getCutterOutput())
178			elif(z_axis_length == 0): # A cutter is not used for 2D data.
179			self._setupWarp(c2p._getCellToPointOutput())
180	jongui	1210
181	jongui	1208	elif(self.__cell_to_point == False): # No conversion happens.
182			if(z_axis_length != 0): # A cutter is used for 3D data.
183			self._setupCutter(\
184			self.__data_collector._getDataCollectorOutput(), \
185			self._getPlane())
186			self._setupWarp(self._getCutterOutput())
187			elif(z_axis_length == 0): # A cutter is not used for 2D data.
188			self._setupWarp(
189			self.__data_collector._getDataCollectorOutput())
190
191			self._setupDataSetMapper(self._getWarpOutput(),
192	jongui	1209	self.__lookup_table._getLookupTable())
193	jongui	1208
194			self._setupActor3D(self._getDataSetMapper())
195			scene._addActor3D(self.__viewport, self._getActor3D())
196
197
198	jongui	1148	if (self._isModified() == True):
199			if(self.__data_collector._isScalarSet() == True):
200			self.__data_collector._setActiveScalar()
201	jongui	1189
202			# self._isScalarRangeSet checks whether the scalar range has been
203			# specified by the user. If it has, then the scalar range
204			# read from the source will be ignored.
205			if(not(self._isScalarRangeSet())):
206			self._setScalarRange(self.__data_collector._getScalarRange())
207	jongui	1148	self.__modified = False
208
209
210	jongui	1208