Source Code for Module examples.qt

  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: Qt" 
  6  ## stylesheet = "pygments_style.css" 
  7   
  8  # <h1><i>glitter</i> Example: Qt</h1> 
  9   
 10  # <h2>Summary</h2> 
 11   
 12  # This program will show a Qt application to display meshes. 
 13   
 14  # <img src="qt.png"> 
 15   
 16  # <h2>Front matter</h2> 
 17   
 18  # <h3>Module docstring</h3> 
 19   
 20  # The module docstring is used as a description of this example in the 
 21  # generated documentation: 
 22  """Example for Qt (PySide) interaction. 
 23   
 24  @author: Stephan Wenger 
 25  @date: 2012-03-16 
 26  """ 
 27   
 28  # <h3>Imports</h3> 
 29   
 30  # Some math functions are required for mouse interaction: 
 31  from math import sqrt, exp 
 32   
 33  # We use <a href="http://www.pyside.org/">PySide</a> for <a 
 34  # href="http://qt.nokia.com/">Qt</a> interaction: 
 35  from PySide import QtCore, QtGui 
 36   
 37  # Note that we did not import the <code>QtOpenGL</code> package. Instead, we 
 38  # will use a Qt OpenGL widget that doubles as a <i>glitter</i> 
 39  # <code>Context</code>: 
 40  from glitter.contexts.qt import QtWidget 
 41  # If you'd rather use an existing Qt OpenGL context, 
 42  # <code>QtContextWrapper</code> provides an alternative solution. 
 43   
 44  # Since there are no more build-in matrices in the OpenGL core profile, we use 
 45  # <i>glitter</i>'s matrix constructors. <i>glitter</i> also provides a method 
 46  # for loading meshes from files that we will use: 
 47  from glitter import rotation_matrix, scale_matrix, identity_matrix, load_mesh 
 48   
 49  # <h2>Qt GUI</h2> 
 50   
 51  # <h3>Qt OpenGL Widget</h3> 
 52   
 53  # OpenGL rendering in Qt is through an OpenGL widget. Instead of subclassing 
 54  # <code>QGLWidget</code> directly, we inherit from <i>glitter</i>'s 
 55  # <code>QtWidget</code> which acts as a <i>glitter</i> <code>Context</code>. 
 56  # This not only provides us with a convenient interface for changing OpenGL 
 57  # state, it also ensures that the correct context is made active whenever 
 58  # OpenGL commands are issued. 
 59 -class Canvas(QtWidget): 
 60      # <h4>Initialization</h4> 
 61      # The canvas will store a mesh to display, a modelview matrix that can be 
 62      # changed by moving the mouse, and a helper variable for the mouse 
 63      # interaction: 
 64 -    def __init__(self, parent=None): 
 65          super(Canvas, self).__init__(parent) 
 66          self.mesh = None 
 67          self.modelview_matrix = identity_matrix() 
 68          self.lastPos = QtCore.QPoint() 
 69   
 70      # The size of the canvas is specified by overriding <code>sizeHint()</code>: 
 71 -    def sizeHint(self): 
 72          return QtCore.QSize(512, 512) 
 73   
 74      # When the user requests loading a mesh via the menu system, we create a 
 75      # <code>Pipeline</code> containing the mesh vertices and an appropriate 
 76      # shader, all with a single call to <code>load_mesh()</code> from the 
 77      # <code>glitter.convenience</code> module. Also, we can pass additional 
 78      # parameters to the <code>Pipeline</code> constructor. In this case, we 
 79      # want depth testing to be enabled whenever the pipeline is executed, so we 
 80      # pass <code>depth_text=True</code>: 
 81 -    def loadMesh(self, filename): 
 82          self.mesh = load_mesh(filename, context=self, depth_test=True) 
 83          # Note that we pass the canvas as the <code>context</code> parameter to 
 84          # make sure the pipeline is created in the correct context. This is 
 85          # necessary because in a real-world application, we cannot be sure that 
 86          # the canvas context is currently active. 
 87   
 88          # When the mesh is loaded, we ask Qt to redraw the OpenGL screen: 
 89          self.updateGL() 
 90   
 91      # <h4>Mouse interaction</h4> 
 92      # The viewpoint can be changed by moving the mouse with a button pressed: 
 93      # left button rotates, right button zooms. 
 94   
 95      # When a mouse button is pressed, we store the position where it was 
 96      # pressed: 
 97 -    def mousePressEvent(self, event): 
 98          self.lastPos = QtCore.QPoint(event.pos()) 
 99   
100      # When the mouse is moved, we take action according to the type of the 
101      # pressed button: 
102 -    def mouseMoveEvent(self, event): 
103          # First, we compute the mouse movement since the last time we processed 
104          # a mouse event. If there was no movement (which does happen from time 
105          # to time), we exit early to avoid division by zero later on: 
106          dx, dy = event.x() - self.lastPos.x(), event.y() - self.lastPos.y() 
107          if dx == dy == 0: 
108              return 
109   
110          # If the left mouse button is down, we rotate the modelview matrix 
111          # about an axis within the image plane that is perpendicular to the 
112          # direction of mouse movement. The amount of rotation is proportional 
113          # to the distance travelled. Then we cause a screen redraw by calling 
114          # <code>updateGL()</code>. 
115          elif event.buttons() & QtCore.Qt.LeftButton: 
116              self.modelview_matrix *= rotation_matrix(-sqrt(dx ** 2 + dy ** 2), (dy, dx, 0.0), degrees=True) 
117              self.updateGL() 
118   
119          # If the right mouse button is down, we scale the modelview matrix 
120          # dependent on the vertical mouse movement.  Again, a screen redraw is 
121          # triggered by calling <code>updateGL()</code>. 
122          elif event.buttons() & QtCore.Qt.RightButton: 
123              self.modelview_matrix *= scale_matrix(exp(-0.01 * dy)) 
124              self.updateGL() 
125   
126          # Finally, the mouse position is stored for processing of the following 
127          # mouse event. 
128          self.lastPos = QtCore.QPoint(event.pos()) 
129   
130      # <h4>OpenGL interaction</h4> 
131   
132      # Whenever the canvas is resized (also on creation), we set the viewport 
133      # (which is actually a <i>glitter</i> <code>Context</code> property) to the 
134      # full window and change the projection matrix such that it encompasses the 
135      # whole range from -1 to +1: 
136 -    def resizeGL(self, w, h): 
137          self.viewport = (0, 0, w, h) 
138          self.projection_matrix = scale_matrix(h / float(w) if w > h else 1.0, w / float(h) if h > w else 1.0, 0.4) 
139   
140      # The <code>paintGL()</code> method is called by Qt whenever the canvas 
141      # needs to be redrawn: 
142 -    def paintGL(self): 
143          # First, we clear the canvas using <code>Context.clear()</code>. 
144          self.clear() 
145   
146          # Then, if a mesh pipeline has been loaded, we draw it with the 
147          # <code>modelview_matrix</code> uniform set. The pipeline binds the 
148          # vertex array and the shader, sets the depth test we requested 
149          # earlier, draws the vertex array, and resets all modified state: 
150          if self.mesh is not None: 
151              self.mesh.draw_with(modelview_matrix=self.projection_matrix * self.modelview_matrix) 
152   
153      # Finally, when the user requests resetting the view via the menu system, 
154      # we create a clean modelview matrix and update the screen: 
155 -    def resetView(self): 
156          self.modelview_matrix = identity_matrix() 
157          self.updateGL() 
158   
159  # <h3>Qt Main Window</h3> 
160   
161  # The OpenGL widget will be displayed within a <code>QMainWindow</code> that 
162  # provides menus, keyboard shortcuts, and many other amenities: 
163 -class MainWindow(QtGui.QMainWindow): 
164      # <h4>Initialization</h4> 
165 -    def __init__(self, parent=None): 
166          super(MainWindow, self).__init__(parent) 
167   
168          # First, we create an instance of the <code>Canvas</code> class we 
169          # defined previously and make it the main widget in the window: 
170          self.canvas = Canvas() 
171          self.setCentralWidget(self.canvas) 
172   
173          # Then, we create menus and keyboard shortcuts for opening meshes, 
174          # resetting the view, and exiting the program: 
175          self.fileMenu = self.menuBar().addMenu("&File") 
176          self.fileOpenMeshAction = QtGui.QAction(u"&Open Mesh\u2026", self) 
177          self.fileOpenMeshAction.setShortcut(QtGui.QKeySequence(QtCore.Qt.Key_O)) 
178          self.fileOpenMeshAction.triggered.connect(self.fileOpenMesh) 
179          self.fileMenu.addAction(self.fileOpenMeshAction) 
180          self.fileMenu.addSeparator() 
181          self.fileQuitAction = QtGui.QAction("&Quit", self) 
182          self.fileQuitAction.setShortcut(QtGui.QKeySequence(QtCore.Qt.Key_Escape)) 
183          self.fileQuitAction.triggered.connect(self.close) 
184          self.fileMenu.addAction(self.fileQuitAction) 
185   
186          self.viewMenu = self.menuBar().addMenu("&View") 
187          self.viewResetAction = QtGui.QAction("&Reset", self) 
188          self.viewResetAction.setShortcut(QtGui.QKeySequence(QtCore.Qt.Key_R)) 
189          self.viewResetAction.triggered.connect(self.canvas.resetView) 
190          self.viewMenu.addAction(self.viewResetAction) 
191   
192      # <h4>File loading</h4> 
193      # When the file open action is triggered via the menu or a keyboard 
194      # shortcut, we display a dialog for selecting a file. If a file is 
195      # selected, we tell the canvas to load a mesh from it. 
196 -    def fileOpenMesh(self, filename=None): 
197          if filename is None: 
198              dialog = QtGui.QFileDialog(self, "Open Mesh") 
199              dialog.setNameFilters(["%s files (*.%s)" % (x.upper(), x) for x in load_mesh.supported_formats]) 
200              dialog.setViewMode(QtGui.QFileDialog.Detail) 
201              dialog.setAcceptMode(QtGui.QFileDialog.AcceptOpen) 
202              dialog.setFileMode(QtGui.QFileDialog.ExistingFile) 
203              if dialog.exec_(): 
204                  filename = dialog.selectedFiles()[0] 
205          if filename is not None: 
206              self.canvas.loadMesh(filename) 
207   
208  # <h2>Main section</h2> 
209  # Finally, if this program is being run from the command line, we create a 
210  # <code>QApplication</code>, show a <code>MainWindow</code> instance and run 
211  # the Qt main loop. 
212  if __name__ == "__main__": 
213      import sys 
214      app = QtGui.QApplication(sys.argv) 
215      mainWindow = MainWindow() 
216      mainWindow.show() 
217      sys.exit(app.exec_()) 
218   
219  # When the main window is closed, the application will exit cleanly. 
220