pyvisi/py_src/scene.py

"""
@author: John NGUI
"""

import vtk
from constant import Renderer, Color, Viewport

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

    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.__JPG = "jpg"
        self.__BMP = "bmp"
        self.__PNM = "pnm"
        self.__PNG = "png"
        self.__TIF = "tif"
        self.__PS  = "ps"
        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.
        """
        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(self.__JPG)):
            return vtk.vtkJPEGWriter() 
        elif(self.__renderer.endswith(self.__BMP)):
            return vtk.vtkBMPWriter() 
        elif(self.__renderer.endswith(self.__PNM)):
            return vtk.vtkPNMWriter()
        elif(self.__renderer.endswith(self.__PNG)):
            return vtk.vtkPNGWriter()
        elif(self.__renderer.endswith(self.__TIF)):
            return vtk.vtkTIFFWriter()
        elif(self.__renderer.endswith(self.__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.

        @type image_name: String
        @param image_name: Name of the saved image.
        """

        # NOTE: Render and Modified must be called everytime before writing 
        # an image. Otherwise, only the first image 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.
        # 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.
        """ 
        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 object
        @param module: Visualization object to be rendered
        """

        self.__visualization_modules.append(module)

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