pyvisi/py_src/scene.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 constant import Renderer, Color, Viewport, ImageFormat

class Scene:
    """
    Class that defines a scene. A scene is a window in which objects are to 
    be rendered on. Only one scene needs to be created. However, a scene may 
    be divided into four smaller windows called viewports (if needed). 
    Each viewport can render a different object.  

    @attention: If the IV or VRML renderer type is used, then only one 
    viewport can be used (four viewports are not supported for these two 
    cases). 
    """

    def __init__(self, renderer = Renderer.ONLINE, num_viewport = 1, 
            x_size = 1152, y_size = 864):
        """
        Initialise the scene.

        @type renderer: L{Renderer <constant.Renderer>} constant
        @param renderer: Type of renderer 
        @type num_viewport: Number
        @param num_viewport: Number of viewport(s) in the scene. Either 1 or 4 
        @type x_size: Number
        @param x_size: Size of the render window along the x-axis
        @type y_size: Number
        @param y_size: Size of the render window along the y-axis
        """

        self.__renderer = renderer
        self.__num_viewport = num_viewport
        self.__x_size = x_size
        self.__y_size = y_size
        # Stores the visualization modules (i.e. Map, Velocity, Ellipsoid, etc)
        # which needs to be rendered.
        self.__visualization_modules = []

        self.__OFFLINE = "offline"
        self.__VRML = "vrml"
        self.__IV = "iv"
    
        self.__vtk_render_window = vtk.vtkRenderWindow()
        self.__setupScene()
        
    def __setupScene(self):
        """
        Setup the scene.
        """

        self.__createViewport()         
        self.__addRenderer()
        self.setBackground(Color.WHITE) # Default background color is white.


        # Default title bar.
        self.setTitleBar("Earth Systems Science Computational Centre (ESSCC)")
        self.__setSize(self.__x_size, self.__y_size)

        # True for Online rendering.
        if(self.__renderer.startswith(Renderer.ONLINE)): 
            self.__setupOnlineRendering()
            # True for all Online renderers except Renderer.ONLINE.
            if(self.__renderer != Renderer.ONLINE):
                self.__setupWindowToImage()
        # True for Offline rendering.
        elif(self.__renderer.startswith(self.__OFFLINE)): 
            self.__setupOfflineRendering()
            self.__setupWindowToImage()
        # True for Display rendering.
        elif(self.__renderer.startswith(Renderer.DISPLAY)): 
            # True for all Display renderers except Renderer.DISPLAY.
            if(self.__renderer != Renderer.DISPLAY):
                self.__setupWindowToImage()

    def __createViewport(self):
        """
        Create the viewport(s) in the scene.
        """

        # Create the renderer(s) for the viewport(s).
        self.__vtk_renderer = [] 
        for viewport in range(0, self.__num_viewport):
            self.__vtk_renderer.append(vtk.vtkRenderer())
            
        if(self.__num_viewport == 4): 
            # Renderer for the entire scene (background).   
            self.__vtk_renderer_background = vtk.vtkRenderer()

            # Specify the positioning of the four viewports (between 0 and 1).
            self.__vtk_renderer[Viewport.SOUTH_WEST].SetViewport(
                    0.0, 0.0, 0.5, 0.5) 
            self.__vtk_renderer[Viewport.NORTH_WEST].SetViewport(
                    0.0, 0.5013, 0.5, 1)
            self.__vtk_renderer[Viewport.NORTH_EAST].SetViewport(
                    0.501, 0.5013, 1, 1)
            self.__vtk_renderer[Viewport.SOUTH_EAST].SetViewport(
                    0.501, 0.0, 1.0, 0.5)
            
    def setBackground(self, color):
        """
        Set the background color of the scene.

        @type color: L{Color <constant.Color>} constant
        @param color: Scene background color
        """
        
        # Color the entire scene (background) black initially. 
        # This is carried out mainly to have the borders between 
        # the viewports visibly black.
        if(self.__num_viewport == 4): 
            self.__vtk_renderer_background.SetBackground(Color.BLACK)

        for viewport in range(0, self.__num_viewport):
            self.__vtk_renderer[viewport].SetBackground(color)

    def __addRenderer(self):
        """
        Add the renderer(s) to the render window.
        """

        # Add the renderer for the black scene (background).
        if(self.__num_viewport == 4): 
            self.__vtk_render_window.AddRenderer(
                    self.__vtk_renderer_background)

        for viewport in range(0, self.__num_viewport):
            self.__vtk_render_window.AddRenderer(self.__vtk_renderer[viewport])

    def setTitleBar(self, text):
        """
        Set the text on the title bar of the render window.

        @type text: String
        @param text: Text on the title bar
        """

        self.__vtk_render_window.SetWindowName(text)

    def __setSize(self, x_size, y_size):
        """
        Set the size of the render window.

        @type x_size: Number
        @param x_size: Size of the render window along the x-axis
        @type y_size: Number
        @param y_size: Size of the render window along the y-axis
        """

        self.__vtk_render_window.SetSize(x_size, y_size)    

    def __setupOnlineRendering(self):
        """
        Setup the window interactor for online rendering.
        """

        # Associate the window interactor with the render window.
        self.__vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()
        self.__vtk_render_window_interactor.SetRenderWindow(
                self.__vtk_render_window)
        self.__vtk_render_window_interactor.Initialize()

    def __setupOfflineRendering(self):
        """
        Enables the offline rendering (no window comes up).
        """

        # Enables the offscreen rendering.
        self.__vtk_render_window.OffScreenRenderingOn()

    def __setupWindowToImage(self):
        """ 
        Setup the window to image filter to convert the output from the render 
        window into an image, vrml or open inventor file.
        """

        self.__vtk_window_to_image = vtk.vtkWindowToImageFilter()
        self.__vtk_window_to_image.SetInput(self.__vtk_render_window)
        self.__vtk_image_writer = self.__getImageWriter()
        
    def __getImageWriter(self):
        """
        Return the appropriate image writer or exporter based on the 
        specified renderer.

        @rtype: vtkImageWriter or vtkExporter
        @return: Image writer or exporter
        """

        if(self.__renderer.endswith(ImageFormat.JPG)):
            return vtk.vtkJPEGWriter() 
        elif(self.__renderer.endswith(ImageFormat.BMP)):
            return vtk.vtkBMPWriter() 
        elif(self.__renderer.endswith(ImageFormat.PNM)):
            return vtk.vtkPNMWriter()
        elif(self.__renderer.endswith(ImageFormat.PNG)):
            return vtk.vtkPNGWriter()
        elif(self.__renderer.endswith(ImageFormat.TIF)):
            return vtk.vtkTIFFWriter()
        elif(self.__renderer.endswith(ImageFormat.PS)):
            return vtk.vtkPostScriptWriter()
        elif(self.__renderer.endswith(self.__VRML)):
            return vtk.vtkVRMLExporter() # Generates VRML files (.wrl).
        elif(self.__renderer.endswith(self.__IV)):
            return vtk.vtkIVExporter() # Generate OpenInventor files (.iv).
    
    def __saveImage(self, image_name):
        """
        Save the rendered object as an image, vrml or open inventor file.

        @type image_name: String
        @param image_name: Name of the saved image, vrml or open inventor file
        """

        # NOTE: Render and Modified must be called everytime before writing 
        # an image, vrml or open inventor file. Otherwise, only the first 
        # object will always be saved. This is due to the architecture of VTK.
        self.__vtk_render_window.Render()
        self.__vtk_window_to_image.Modified()
        
        # Retrieve the rendered object from the window and convert it into an 
        # image, vrml or open inventor file.
        # True for all writers besides VRML.
        if(not(self.__renderer.endswith(self.__VRML)) and \
                not(self.__renderer.endswith(self.__IV))): 
            self.__vtk_image_writer.SetInput(
                    self.__vtk_window_to_image.GetOutput())
        # True only for VRML and IV.
        elif(self.__renderer.endswith(self.__VRML) or \
                self.__renderer.endswith(self.__IV)):
            self.__vtk_image_writer.SetInput(
                    self.__vtk_render_window)
        self.__vtk_image_writer.SetFileName(image_name)
        self.__vtk_image_writer.Write()     

    def __animate(self):
        """ 
        Animate the rendered object on-the-fly.
        """

        # With Render() ONLY, the rendered object is animated onto the 
        # scene on-the-fly and no interaction can occur.
        self.__vtk_render_window.Render()

    def render(self, image_name = None):
        """
        Render the object using either the online, offline or display mode.

        @type image_name: String
        @param image_name: Name of the saved image, vrml or open inventor file
        """ 

        for i in range(0, len(self.__visualization_modules)):
            self.__visualization_modules[i]._render(self)   
            self.__vtk_render_window.Render()

        self.__vtk_render_window.Render()

        if(self.__renderer.startswith(Renderer.ONLINE)):
            # NOTE: Once Start() is executed, the driver will not further 
            # execute any subsequent codes thereafter unless the 'q' or 
            # 'e' keys are pressed.
            self.__vtk_render_window_interactor.Start()

            # True for all online renderers except Renderer.ONLINE.
            if(self.__renderer != Renderer.ONLINE):
                self.__saveImage(image_name)                    
        # True for all display renderers except Renderer.DISPLAY.
        elif(self.__renderer.startswith(self.__OFFLINE) or 
                self.__renderer != Renderer.DISPLAY):
            self.__saveImage(image_name)                    
    
    def _addActor3D(self, viewport, actor):
        """
        Add the actor3D to the appropriate viewport.

        @type viewport: L{Viewport <constant.Viewport>} constant 
        @param viewport: Viewport in which the actor3D is to be added to 
        @type actor: vtkActor
        @param actor: Actor3D which is to be added to the viewport 
        """

        self.__vtk_renderer[viewport].AddActor(actor)   

    def _addActor2D(self, viewport, actor):
        """
        Add the actor2D to the appropriate viewport.

        @type viewport: L{Viewport <constant.Viewport>} constant 
        @param viewport: Viewport in which the actor2D is to be added to 
        @type actor: vtkActor2D
        @param actor: Actor2D which is to be added to the viewport 
        """

        self.__vtk_renderer[viewport].AddActor2D(actor) 

    def _setActiveCamera(self, viewport, camera):
        """
        Set the camera to the appropriate viewport. 

        @type viewport: L{Viewport <constant.Viewport>} constant 
        @param viewport: Viewport in which the camera is to be added to 
        @type camera: vtkCamera
        @param camera: Camera which is to be assigned to the viewport
        """

        self.__vtk_renderer[viewport].SetActiveCamera(camera)

    def _addLight(self, viewport, light):
        """
        Add the light to the appropriate viewport.

        @type viewport: L{Viewport <constant.Viewport>} constant 
        @param viewport: Viewport in which the camera is to be added to 
        @type light: vtkLight
        @param light: Light which is to be assigned to the viewport
        """

        self.__vtk_renderer[viewport].AddLight(light)

    def _getRenderer(self):
        """
        Return the renderer(s)

        @rtype: List 
        @return: A list of renderer(s)
        """
    
        return self.__vtk_renderer

    def _addVisualizationModules(self, module):
        """
        Store visualization modules (i.e. Map, Velocity, Ellipsoid, etc) 
        which needs to be rendered.
        
        @type module: Visualization modules
        @param module: Visualization modules to be rendered
        """

        self.__visualization_modules.append(module)

1	"""
2	@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	"""
9
10	__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	import vtk
22	from constant import Renderer, Color, Viewport, ImageFormat
23
24	class Scene:
25	"""
26	Class that defines a scene. A scene is a window in which objects are to
27	be rendered on. Only one scene needs to be created. However, a scene may
28	be divided into four smaller windows called viewports (if needed).
29	Each viewport can render a different object.
30
31	@attention: If the IV or VRML renderer type is used, then only one
32	viewport can be used (four viewports are not supported for these two
33	cases).
34	"""
35
36	def __init__(self, renderer = Renderer.ONLINE, num_viewport = 1,
37	x_size = 1152, y_size = 864):
38	"""
39	Initialise the scene.
40
41	@type renderer: L{Renderer <constant.Renderer>} constant
42	@param renderer: Type of renderer
43	@type num_viewport: Number
44	@param num_viewport: Number of viewport(s) in the scene. Either 1 or 4
45	@type x_size: Number
46	@param x_size: Size of the render window along the x-axis
47	@type y_size: Number
48	@param y_size: Size of the render window along the y-axis
49	"""
50
51	self.__renderer = renderer
52	self.__num_viewport = num_viewport
53	self.__x_size = x_size
54	self.__y_size = y_size
55	# Stores the visualization modules (i.e. Map, Velocity, Ellipsoid, etc)
56	# which needs to be rendered.
57	self.__visualization_modules = []
58
59	self.__OFFLINE = "offline"
60	self.__VRML = "vrml"
61	self.__IV = "iv"
62
63	self.__vtk_render_window = vtk.vtkRenderWindow()
64	self.__setupScene()
65
66	def __setupScene(self):
67	"""
68	Setup the scene.
69	"""
70
71	self.__createViewport()
72	self.__addRenderer()
73	self.setBackground(Color.WHITE) # Default background color is white.
74
75
76	# Default title bar.
77	self.setTitleBar("Earth Systems Science Computational Centre (ESSCC)")
78	self.__setSize(self.__x_size, self.__y_size)
79
80	# True for Online rendering.
81	if(self.__renderer.startswith(Renderer.ONLINE)):
82	self.__setupOnlineRendering()
83	# True for all Online renderers except Renderer.ONLINE.
84	if(self.__renderer != Renderer.ONLINE):
85	self.__setupWindowToImage()
86	# True for Offline rendering.
87	elif(self.__renderer.startswith(self.__OFFLINE)):
88	self.__setupOfflineRendering()
89	self.__setupWindowToImage()
90	# True for Display rendering.
91	elif(self.__renderer.startswith(Renderer.DISPLAY)):
92	# True for all Display renderers except Renderer.DISPLAY.
93	if(self.__renderer != Renderer.DISPLAY):
94	self.__setupWindowToImage()
95
96	def __createViewport(self):
97	"""
98	Create the viewport(s) in the scene.
99	"""
100
101	# Create the renderer(s) for the viewport(s).
102	self.__vtk_renderer = []
103	for viewport in range(0, self.__num_viewport):
104	self.__vtk_renderer.append(vtk.vtkRenderer())
105
106	if(self.__num_viewport == 4):
107	# Renderer for the entire scene (background).
108	self.__vtk_renderer_background = vtk.vtkRenderer()
109
110	# Specify the positioning of the four viewports (between 0 and 1).
111	self.__vtk_renderer[Viewport.SOUTH_WEST].SetViewport(
112	0.0, 0.0, 0.5, 0.5)
113	self.__vtk_renderer[Viewport.NORTH_WEST].SetViewport(
114	0.0, 0.5013, 0.5, 1)
115	self.__vtk_renderer[Viewport.NORTH_EAST].SetViewport(
116	0.501, 0.5013, 1, 1)
117	self.__vtk_renderer[Viewport.SOUTH_EAST].SetViewport(
118	0.501, 0.0, 1.0, 0.5)
119
120	def setBackground(self, color):
121	"""
122	Set the background color of the scene.
123
124	@type color: L{Color <constant.Color>} constant
125	@param color: Scene background color
126	"""
127
128	# Color the entire scene (background) black initially.
129	# This is carried out mainly to have the borders between
130	# the viewports visibly black.
131	if(self.__num_viewport == 4):
132	self.__vtk_renderer_background.SetBackground(Color.BLACK)
133
134	for viewport in range(0, self.__num_viewport):
135	self.__vtk_renderer[viewport].SetBackground(color)
136
137	def __addRenderer(self):
138	"""
139	Add the renderer(s) to the render window.
140	"""
141
142	# Add the renderer for the black scene (background).
143	if(self.__num_viewport == 4):
144	self.__vtk_render_window.AddRenderer(
145	self.__vtk_renderer_background)
146
147	for viewport in range(0, self.__num_viewport):
148	self.__vtk_render_window.AddRenderer(self.__vtk_renderer[viewport])
149
150	def setTitleBar(self, text):
151	"""
152	Set the text on the title bar of the render window.
153
154	@type text: String
155	@param text: Text on the title bar
156	"""
157
158	self.__vtk_render_window.SetWindowName(text)
159
160	def __setSize(self, x_size, y_size):
161	"""
162	Set the size of the render window.
163
164	@type x_size: Number
165	@param x_size: Size of the render window along the x-axis
166	@type y_size: Number
167	@param y_size: Size of the render window along the y-axis
168	"""
169
170	self.__vtk_render_window.SetSize(x_size, y_size)
171
172	def __setupOnlineRendering(self):
173	"""
174	Setup the window interactor for online rendering.
175	"""
176
177	# Associate the window interactor with the render window.
178	self.__vtk_render_window_interactor = vtk.vtkRenderWindowInteractor()
179	self.__vtk_render_window_interactor.SetRenderWindow(
180	self.__vtk_render_window)
181	self.__vtk_render_window_interactor.Initialize()
182
183	def __setupOfflineRendering(self):
184	"""
185	Enables the offline rendering (no window comes up).
186	"""
187
188	# Enables the offscreen rendering.
189	self.__vtk_render_window.OffScreenRenderingOn()
190
191	def __setupWindowToImage(self):
192	"""
193	Setup the window to image filter to convert the output from the render
194	window into an image, vrml or open inventor file.
195	"""
196
197	self.__vtk_window_to_image = vtk.vtkWindowToImageFilter()
198	self.__vtk_window_to_image.SetInput(self.__vtk_render_window)
199	self.__vtk_image_writer = self.__getImageWriter()
200
201	def __getImageWriter(self):
202	"""
203	Return the appropriate image writer or exporter based on the
204	specified renderer.
205
206	@rtype: vtkImageWriter or vtkExporter
207	@return: Image writer or exporter
208	"""
209
210	if(self.__renderer.endswith(ImageFormat.JPG)):
211	return vtk.vtkJPEGWriter()
212	elif(self.__renderer.endswith(ImageFormat.BMP)):
213	return vtk.vtkBMPWriter()
214	elif(self.__renderer.endswith(ImageFormat.PNM)):
215	return vtk.vtkPNMWriter()
216	elif(self.__renderer.endswith(ImageFormat.PNG)):
217	return vtk.vtkPNGWriter()
218	elif(self.__renderer.endswith(ImageFormat.TIF)):
219	return vtk.vtkTIFFWriter()
220	elif(self.__renderer.endswith(ImageFormat.PS)):
221	return vtk.vtkPostScriptWriter()
222	elif(self.__renderer.endswith(self.__VRML)):
223	return vtk.vtkVRMLExporter() # Generates VRML files (.wrl).
224	elif(self.__renderer.endswith(self.__IV)):
225	return vtk.vtkIVExporter() # Generate OpenInventor files (.iv).
226
227	def __saveImage(self, image_name):
228	"""
229	Save the rendered object as an image, vrml or open inventor file.
230
231	@type image_name: String
232	@param image_name: Name of the saved image, vrml or open inventor file
233	"""
234
235	# NOTE: Render and Modified must be called everytime before writing
236	# an image, vrml or open inventor file. Otherwise, only the first
237	# object will always be saved. This is due to the architecture of VTK.
238	self.__vtk_render_window.Render()
239	self.__vtk_window_to_image.Modified()
240
241	# Retrieve the rendered object from the window and convert it into an
242	# image, vrml or open inventor file.
243	# True for all writers besides VRML.
244	if(not(self.__renderer.endswith(self.__VRML)) and \
245	not(self.__renderer.endswith(self.__IV))):
246	self.__vtk_image_writer.SetInput(
247	self.__vtk_window_to_image.GetOutput())
248	# True only for VRML and IV.
249	elif(self.__renderer.endswith(self.__VRML) or \
250	self.__renderer.endswith(self.__IV)):
251	self.__vtk_image_writer.SetInput(
252	self.__vtk_render_window)
253	self.__vtk_image_writer.SetFileName(image_name)
254	self.__vtk_image_writer.Write()
255
256	def __animate(self):
257	"""
258	Animate the rendered object on-the-fly.
259	"""
260
261	# With Render() ONLY, the rendered object is animated onto the
262	# scene on-the-fly and no interaction can occur.
263	self.__vtk_render_window.Render()
264
265	def render(self, image_name = None):
266	"""
267	Render the object using either the online, offline or display mode.
268
269	@type image_name: String
270	@param image_name: Name of the saved image, vrml or open inventor file
271	"""
272
273	for i in range(0, len(self.__visualization_modules)):
274	self.__visualization_modules[i]._render(self)
275	self.__vtk_render_window.Render()
276
277	self.__vtk_render_window.Render()
278
279	if(self.__renderer.startswith(Renderer.ONLINE)):
280	# NOTE: Once Start() is executed, the driver will not further
281	# execute any subsequent codes thereafter unless the 'q' or
282	# 'e' keys are pressed.
283	self.__vtk_render_window_interactor.Start()
284
285	# True for all online renderers except Renderer.ONLINE.
286	if(self.__renderer != Renderer.ONLINE):
287	self.__saveImage(image_name)
288	# True for all display renderers except Renderer.DISPLAY.
289	elif(self.__renderer.startswith(self.__OFFLINE) or
290	self.__renderer != Renderer.DISPLAY):
291	self.__saveImage(image_name)
292
293	def _addActor3D(self, viewport, actor):
294	"""
295	Add the actor3D to the appropriate viewport.
296
297	@type viewport: L{Viewport <constant.Viewport>} constant
298	@param viewport: Viewport in which the actor3D is to be added to
299	@type actor: vtkActor
300	@param actor: Actor3D which is to be added to the viewport
301	"""
302
303	self.__vtk_renderer[viewport].AddActor(actor)
304
305	def _addActor2D(self, viewport, actor):
306	"""
307	Add the actor2D to the appropriate viewport.
308
309	@type viewport: L{Viewport <constant.Viewport>} constant
310	@param viewport: Viewport in which the actor2D is to be added to
311	@type actor: vtkActor2D
312	@param actor: Actor2D which is to be added to the viewport
313	"""
314
315	self.__vtk_renderer[viewport].AddActor2D(actor)
316
317	def _setActiveCamera(self, viewport, camera):
318	"""
319	Set the camera to the appropriate viewport.
320
321	@type viewport: L{Viewport <constant.Viewport>} constant
322	@param viewport: Viewport in which the camera is to be added to
323	@type camera: vtkCamera
324	@param camera: Camera which is to be assigned to the viewport
325	"""
326
327	self.__vtk_renderer[viewport].SetActiveCamera(camera)
328
329	def _addLight(self, viewport, light):
330	"""
331	Add the light to the appropriate viewport.
332
333	@type viewport: L{Viewport <constant.Viewport>} constant
334	@param viewport: Viewport in which the camera is to be added to
335	@type light: vtkLight
336	@param light: Light which is to be assigned to the viewport
337	"""
338
339	self.__vtk_renderer[viewport].AddLight(light)
340
341	def _getRenderer(self):
342	"""
343	Return the renderer(s)
344
345	@rtype: List
346	@return: A list of renderer(s)
347	"""
348
349	return self.__vtk_renderer
350
351	def _addVisualizationModules(self, module):
352	"""
353	Store visualization modules (i.e. Map, Velocity, Ellipsoid, etc)
354	which needs to be rendered.
355
356	@type module: Visualization modules
357	@param module: Visualization modules to be rendered
358	"""
359
360	self.__visualization_modules.append(module)
361