A Threaded PyQt GUI and Particles

I wrote a post about adding a GUI to your command line interface program. Sometimes people just want to click stuff. If you tried it / implemented it yourself, you'd have seen that the program would have gone from responsive to non-responsive when you hit the run button. Why? Because the program can only do ONE think at a time and frankly, keeping the controls available for clicking at all times, updating the graphics and calculating particle movement do not get along nicely. This post is about making it behave like we expect.

I present to you threading. Specifically for PyQt there is the QThread class which is actually discussed rather nicely in this PyQtWiki and this page by Jo Plaete which I used for inspiration.

What complicates the whole scene is that we need to realize that we have two independant things we want to accomplish: 1) move particles and 2) update the graphics. Both independent of the GUI.

I started by making my own class called BaseThread which subclasses QThread. The code is

	from PyQt4 import QtCore
	class BaseThread(QtCore.QThread):
	def __init__(self):
	QtCore.QThread.__init__(self)
	self.exiting = False
	def __del__(self):
	self.exiting = True
	self.wait()

view raw basethread.py hosted with ❤ by GitHub

where I believe the magic for everything not just crashing and burning is the subtle use of the custom boolean flag exiting (which we will use later) and the use of self.wait() in the __del__ method. Again, for details you should read the blog posts mentioned above.

To come around many of the syncronization problems that arises with threads the Qt framework allows us to use custom signals to make everything talk together. Here is my version of a StepThread which defines the run method (you do NEVER call this explicitly!) and a convenience function called simulate to start a simulation for N steps. The run function emits a custom signal and sleeps for a little while before simulating again.

	from time import sleep
	from PyQt4 import QtCore
	from basethread import BaseThread
	class StepThread(BaseThread):
	def __init__(self):
	BaseThread.__init__(self)
	def simulate(self, nsteps):
	self.nsteps = nsteps
	self.exiting = False
	self.start()
	def run(self):
	while not self.exiting and self.nsteps > 0:
	self.emit( QtCore.SIGNAL('TakeStep()') )
	self.nsteps -= 1
	sleep(0.005)

view raw stepthread.py hosted with ❤ by GitHub

Very similarly we have the DrawThread which emits a signal so we can update the matplotlib surface.

	from time import sleep
	from PyQt4 import QtCore
	from basethread import BaseThread
	class DrawThread(BaseThread):
	def __init__(self):
	BaseThread.__init__(self)
	def run(self):
	while not self.exiting:
	self.emit( QtCore.SIGNAL('DrawCanvas()') )
	sleep(0.05)

view raw drawthread.py hosted with ❤ by GitHub

Notice that it updates less frequently. I have yet to figure out something clever in this regard.

Finally, I had to make some tweaks to the Simulator class (nothing very fancy) to hook up our custom signals.

	from PyQt4 import QtGui, QtCore
	from simulator_ui import Ui_main
	from particlecanvas import ParticleCanvas
	from drawthread import DrawThread
	from stepthread import StepThread
	class MainForm(QtGui.QMainWindow):
	def __init__(self, parent=None):
	QtGui.QWidget.__init__(self,parent)
	self.ui = Ui_main()
	self.ui.setupUi(self)
	self.connect(self.ui.btnSetup, QtCore.SIGNAL("clicked()"), self.on_setup_clicked)
	self.connect(self.ui.btnRun, QtCore.SIGNAL("clicked()"), self.on_run_clicked)
	self.c = ParticleCanvas(self.ui.frame)
	self.pp = DrawThread()
	self.mm = StepThread()
	self.connect( self.pp, QtCore.SIGNAL('DrawCanvas()'), self.c.redraw)
	self.connect( self.mm, QtCore.SIGNAL('TakeStep()'), self.c.move)
	def on_setup_clicked(self):
	self.c.reinitialize(int(self.ui.txtNPart.text()))
	self.mm.exiting = True
	self.pp.start()
	def on_run_clicked(self):
	self.mm.simulate(int(self.ui.txtNSteps.text()))

view raw simulator.py hosted with ❤ by GitHub

What I need now is a video of it and maybe to implement some different potentials instead of only the non-interacting particles. Stay tuned.

The entire code can be downloaded from the latest gist I made.