Source Code for Module examples.meshview

  1  #!/usr/bin/env python 
  2   
  3  #! This file is a literate Python program. You can compile the documentation 
  4  #! using mylit (http://pypi.python.org/pypi/mylit/). 
  5  ## title = "glitter Example: Mesh Viewer" 
  6  ## stylesheet = "pygments_style.css" 
  7   
  8  # <h1><i>glitter</i> Example: Mesh Viewer</h1> 
  9   
 10  # <h2>Summary</h2> 
 11   
 12  # This program will open a GLUT window and render a mesh from an <a 
 13  # href="www.hdfgroup.org/HDF5/">HDF5</a> data file. 
 14   
 15  # <img src="meshview.png"> 
 16   
 17  # <h2>Front matter</h2> 
 18   
 19  # <h3>Module docstring</h3> 
 20   
 21  # The module docstring is used as a description of this example in the 
 22  # generated documentation: 
 23  """Simple mesh viewer. 
 24   
 25  @author: Stephan Wenger 
 26  @date: 2012-02-29 
 27  """ 
 28   
 29  # <h3>Imports</h3> 
 30   
 31  # Our scene is going to rotate. The rotating modelview matrix is computed using 
 32  # the sine and cosine functions from the math module: 
 33  from math import sin, cos, pi 
 34   
 35  # <i>glitter</i> uses <a href="http://numpy.scipy.org/">numpy</a> for 
 36  # representation of array data. We will use numpy's <code>random()</code> 
 37  # function to generate random textures: 
 38  from numpy.random import random 
 39   
 40  # We need to read a mesh filename from <code>sys.argv</code>, so import 
 41  # <code>sys</code>. 
 42  import sys 
 43   
 44  # We assume the mesh is stored in a <a 
 45  # href="http://www.hdfgroup.org/HDF5/">HDF5</a> file, so import <a 
 46  # href="h5py.alfven.org"><code>h5py</code></a>. 
 47  import h5py 
 48   
 49  # We can usually import classes and functions contained in <i>glitter</i> 
 50  # submodules directly from glitter: 
 51  from glitter import VertexArray, State, get_default_program 
 52   
 53  # Modules with external dependencies other than numpy, such as platform 
 54  # dependent parts like methods for the generation of an OpenGL context, 
 55  # however, have to be imported from their respective submodules: 
 56  from glitter.contexts.glut import GlutWindow, main_loop, get_elapsed_time 
 57   
 58  # <h2>Main class</h2> 
 59   
 60  # We wrap all the OpenGL interaction in a class. The class will contain an 
 61  # <code>__init__()</code> method to set up all OpenGL objects, any required 
 62  # callback methods, as well as a <code>run()</code> method to trigger execution 
 63  # of the GLUT main loop. 
 64 -class MeshViewer(object): 
 65      # <h3>Initialization</h3> 
 66   
 67      # When a <code>MeshViewer</code> instance is created, we need to 
 68      # initialize a few OpenGL objects. 
 69 -    def __init__(self): 
 70          # First, we create a window; this also creates an OpenGL context. 
 71          self.window = GlutWindow(double=True, multisample=True) 
 72   
 73          # Then, we set the GLUT display callback function which will be defined later. 
 74          self.window.display_callback = self.display 
 75   
 76          # In the OpenGL core profile, there is no such thing as a "standard pipeline" 
 77          # any more. We use the minimalistic <code>defaultpipeline</code> from the 
 78          # <code>glitter.convenience</code> module to create a shader program instead: 
 79          self.shader = get_default_program() 
 80   
 81          # We open the HDF5 file specified on the command line for reading: 
 82          with h5py.File(sys.argv[1], "r") as f: 
 83              # The vertices, colors and indices of the mesh are read from the 
 84              # corresponding datasets in the HDF5 file. Note that the names of the 
 85              # datasets are mere convention. Colors and indices are allowed to be 
 86              # undefined. 
 87              vertices = f["vertices"] 
 88              colors = f.get("colors", None) 
 89              elements = f.get("indices", None) 
 90   
 91              # If no colors were specified, we generate random ones so we can 
 92              # distinguish the triangles without fancy shading. 
 93              if colors is None: 
 94                  colors = random((len(vertices), 3))[:, None, :][:, [0] * vertices.shape[1], :] 
 95   
 96              # Here, we create a vertex array that contains buffers for two vertex array 
 97              # input variables as well as an index array. If <code>elements</code> 
 98              # is <code>None</code>, the vertex array class will draw all vertices 
 99              # in order. 
100              self.vao = VertexArray(vertices, colors, elements=elements) 
101   
102      # <h3>Callback functions</h3> 
103   
104      # <h4>Display function</h4> 
105   
106      # Here we define the display function. It will be called by GLUT whenever the 
107      # screen has to be redrawn. 
108 -    def display(self): 
109          # First we clear the default framebuffer: 
110          self.window.clear() 
111   
112          # To draw the vertex array, we use: 
113          self.vao.draw() 
114   
115          # After all rendering commands have been issued, we swap the back buffer to 
116          # the front, making the rendered image visible all at once: 
117          self.window.swap_buffers() 
118   
119      # <h4>Timer function</h4> 
120   
121      # The animation is controlled by a GLUT timer. The timer callback changes the 
122      # modelview matrix, schedules the next timer event, and causes a screen redraw: 
123 -    def timer(self): 
124          # We first get the elapsed time from GLUT using <code>get_elapsed_time()</code>: 
125          phi = 2 * pi * get_elapsed_time() / 20.0 
126   
127          # We then set the <code>modelview_matrix</code> uniform variable of the 
128          # shader simply by setting an attribute: 
129          self.shader.modelview_matrix = ((cos(phi), 0, sin(phi), 0), (0, 1, 0, 0), (-sin(phi), 0, cos(phi), 0), (0, 0, 0, 1)) 
130   
131          # The following line schedules the next timer event to execute after ten milliseconds. 
132          self.window.add_timer(10, self.timer) 
133   
134          # Finally, we tell GLUT to redraw the screen. 
135          self.window.post_redisplay() 
136   
137      # <h3>Running</h3> 
138       
139      # We will call the <code>run()</code> method later to run the OpenGL code. 
140 -    def run(self): 
141          # To start the animation, we call the timer once; all subsequent timer 
142          # calls will be scheduled by the timer function itself. 
143          self.timer() 
144   
145          # The shader program is bound by using a <code>with</code> statement: 
146          with self.shader: 
147              # The <code>State</code> class encapsulates state changes in the 
148              # context. For example, to enable depth testing for the duration of the 
149              # following function call, we would write: 
150              with State(depth_test=True): 
151                  # With the shader bound and depth testing enabled, we enter the 
152                  # GLUT main loop. 
153                  main_loop() 
154   
155          # When the main loop exits, control is handed back to the script. 
156   
157  # <h2>Main section</h2> 
158   
159  # Finally, if this program is being run from the command line, we instanciate 
160  # the main class and run it. 
161  if __name__ == "__main__": 
162      MeshViewer().run() 
163