WorkingWithThreads

   1 #! /usr/bin/env python
   2 #############################################################################
   3 
   4 """
   5 Mandelbrot program, for no particular reason.
   6 
   7 John Farrell: initial version
   8 Robin Dunn: introduced wxImage.SetData instead of wxBitmapFromData
   9 Ionel Simionescu: used the Numeric package, and rewrote all of the
  10                   computation and data displaying code
  11 Alexander Smishlajev: suggestions on optimising loops and drawing
  12 Markus Gritsch: in-place calculation in the mandelbrot while loop
  13 Mike Fletcher: minor changes
  14 
  15 [06/24/09] Cody Precord: Cleanup, get it working with wxPython2.8,
  16                          fixes for thread safety,
  17                          and fixes for old deprecated/obsolete code.
  18 
  19 """
  20 
  21 import wx
  22 import threading
  23 # TODO update to use numpy instead of old Numeric package
  24 import numpy.oldnumeric as Numeric
  25 
  26 class MandelbrotGenerator:
  27         """Slightly slower mandelbrot generator, this one uses instance
  28         attributes instead of globals and provides for "tiling" display
  29 
  30         """
  31         def __init__(self, width=200, height=200,
  32                      coordinates=((-2.0,-1.5), (1.0,1.5)),
  33                      xdivisor=0, ydivisor=0,
  34                      iterations=255,
  35                      redrawCallback=None,
  36                      statusCallback=None):
  37 
  38             self.width = width
  39             self.height = height
  40             self.coordinates = coordinates
  41 
  42             ### should check for remainders somewhere and be a little
  43             # smarter about valid ranges for divisors (100s of divisions
  44             # in both directions means 10000s of calcs)...
  45             if not xdivisor:
  46                 xdivisor = 1 #width/50 or 1
  47             if not ydivisor:
  48                 ydivisor = 10 #height/50 or 1
  49             self.xdivisor = xdivisor
  50             self.ydivisor = ydivisor
  51             self.redrawCallback = redrawCallback
  52             self.statusCallback = statusCallback or self.printStatus
  53             self.MAX_ITERATIONS = iterations
  54             self.data = Numeric.zeros(width*height)
  55             self.data.shape = (width, height)
  56 
  57             ### Set up tiling info, should really just do all the setup here and use a
  58             ### random choice to decide which tile to compute next
  59             self.currentTile = (-1,0)
  60             self.tileDimensions = ( width/xdivisor, height/ydivisor )
  61             self.tileSize = (width/xdivisor)* (height/ydivisor)
  62             (xa,ya), (xb,yb) = coordinates
  63             self.x_starts = Numeric.arange( xa, xb+((xb-xa)/xdivisor), (xb-xa)/xdivisor)
  64             self.y_starts = Numeric.arange( ya, yb+((yb-ya)/ydivisor), (yb-ya)/ydivisor)
  65 
  66         def DoAllTiles( self ):
  67             while self.DoTile():
  68                 pass
  69 
  70         def DoTile(self, event=None):
  71             """Triggered event to draw a single tile into the data object"""
  72             x_index, y_index = self.currentTile
  73             if x_index < self.xdivisor - 1:
  74                 self.currentTile = x_index, y_index = x_index+1, y_index
  75             elif y_index < self.ydivisor-1:
  76                 self.currentTile = x_index, y_index = 0, y_index+1
  77             else:
  78                 if self.redrawCallback is not None:
  79                     self.redrawCallback(self.data, False)
  80                 return False
  81 
  82             print 'starting iteration', x_index, y_index
  83             coords = ((self.x_starts[x_index],self.y_starts[y_index]),
  84                       (self.x_starts[x_index+1],self.y_starts[y_index+1]),)
  85             part = self._tile( coords )
  86             part.shape = self.tileDimensions[1], self.tileDimensions[0]
  87 
  88             xdiv = self.width / self.xdivisor
  89             ydiv = self.height / self.ydivisor
  90             from_idx = ydiv * y_index
  91             self.data[from_idx : ydiv * (y_index+1), xdiv * x_index: xdiv * (x_index+1), ] = part
  92             if self.redrawCallback:
  93                 self.redrawCallback(self.data, True) # there may be more to do...
  94             return True
  95 
  96         def printStatus(self, *arguments ):
  97             pass #print arguments
  98 
  99         def _tile(self, coordinates):
 100             """Calculate a single tile's value"""
 101             (c, z) = self._setup(coordinates)
 102             iterations = 0
 103             size = self.tileSize
 104             i_no = Numeric.arange(size)       # non-overflow indices
 105             data = self.MAX_ITERATIONS + Numeric.zeros(size)
 106             # initialize the "todo" arrays;
 107             # they will contain just the spots where we still need to iterate
 108             c_ = Numeric.array(c).astype(Numeric.Complex32)
 109             z_ = Numeric.array(z).astype(Numeric.Complex32)
 110             progressMonitor = self.statusCallback
 111 
 112             while (iterations < self.MAX_ITERATIONS) and len(i_no):
 113                 # do the calculations in-place
 114                 Numeric.multiply(z_, z_, z_)
 115                 Numeric.add(z_, c_, z_)
 116                 overflow = Numeric.greater_equal(abs(z_), 2.0)
 117                 not_overflow = Numeric.logical_not(overflow)
 118                 # get the indices where overflow occured
 119                 ####overflowIndices = Numeric.compress(overflow, i_no) # slower
 120                 overflowIndices = Numeric.repeat(i_no, overflow) # faster
 121 
 122                 # set the pixel indices there
 123                 for idx in overflowIndices:
 124                     data[idx] = iterations
 125 
 126                 # compute the new array of non-overflow indices
 127                 i_no = Numeric.repeat(i_no, not_overflow)
 128 
 129                 # update the todo arrays
 130                 c_ = Numeric.repeat(c_, not_overflow)
 131                 z_ = Numeric.repeat(z_, not_overflow)
 132                 iterations = iterations + 1
 133                 progressMonitor(iterations, 100.0 * len(i_no) / size)
 134             return data
 135 
 136         def _setup(self, coordinates):
 137             """setup for processing of a single tile"""
 138             # we use a single array for the real values corresponding to the x coordinates
 139             width, height = self.tileDimensions
 140             diff = coordinates[1][0] - coordinates[0][0]
 141             xs = 0j + (coordinates[0][0] + Numeric.arange(width).astype(Numeric.Float32) * diff / width)
 142 
 143             # we use a single array for the imaginary values corresponding to the y coordinates
 144             diff = coordinates[1][1] - coordinates[0][1]
 145             ys = 1j * (coordinates[0][1] + Numeric.arange(height).astype(Numeric.Float32) * diff / height)
 146 
 147             # we build <c> in direct correpondence with the pixels in the image
 148             c = Numeric.add.outer(ys, xs)
 149             z = Numeric.zeros((height, width)).astype(Numeric.Complex32)
 150 
 151             # use flattened representations for easier handling of array elements
 152             c = Numeric.ravel(c)
 153             z = Numeric.ravel(z)
 154             return (c, z)
 155 
 156 #### GUI ####
 157 class MandelCanvas(wx.Window):
 158     def __init__(self, parent, id=wx.ID_ANY,
 159                  width=600, height=600,
 160                  coordinates=((-2.0,-1.5),(1.0,1.5)),
 161                  weights=(16,1,32), iterations=255,
 162                  xdivisor=0, ydivisor=0):
 163         wx.Window.__init__(self, parent, id)
 164 
 165         # Attributes
 166         self.width  = width
 167         self.height = height
 168         self.coordinates = coordinates
 169         self.weights = weights
 170         self.parent = parent
 171         self.border = (1, 1)
 172         self.bitmap = None
 173         self.colours = Numeric.zeros((iterations + 1, 3))
 174         arangeMax = Numeric.arange(0, iterations + 1)
 175         self.colours[:,0] = Numeric.clip(arangeMax * weights[0], 0, iterations)
 176         self.colours[:,1] = Numeric.clip(arangeMax * weights[1], 0, iterations)
 177         self.colours[:,2] = Numeric.clip(arangeMax * weights[2], 0, iterations)
 178 
 179         self.image = wx.EmptyImage(width, height)
 180         self.bitmap = self.image.ConvertToBitmap()
 181         self.generator = MandelbrotGenerator(width=width, height=height,
 182                                              coordinates=coordinates,
 183                                              redrawCallback=self.dataUpdate,
 184                                              iterations=iterations,
 185                                              xdivisor=xdivisor,
 186                                              ydivisor=ydivisor)
 187 
 188         # Setup
 189         self.SetSize(wx.Size(width, height))
 190         self.SetBackgroundColour(wx.NamedColour("black"))
 191         self.Bind(wx.EVT_PAINT, self.OnPaint)
 192 
 193         # Start generating the image
 194         self.thread = threading.Thread(target=self.generator.DoAllTiles)
 195         self.thread.start()
 196 
 197     def dataUpdate(self, data, more=False):
 198         if more:
 199             data.shape = (self.height, self.width)
 200             # build the pixel values
 201             pixels = Numeric.take(self.colours, data)
 202             # create the image data
 203             bitmap = pixels.astype(Numeric.UnsignedInt8).tostring()
 204 
 205             # create the image itself
 206             def updateGui():
 207                 """Need to do gui operations back on main thread"""
 208                 self.image.SetData(bitmap)
 209                 self.bitmap = self.image.ConvertToBitmap()
 210                 self.Refresh()
 211             wx.CallAfter(updateGui)
 212 
 213     def OnPaint(self, event):
 214         dc = wx.PaintDC(self)
 215         dc.BeginDrawing()
 216         if self.bitmap != None and self.bitmap.IsOk():
 217             dc.DrawBitmap(self.bitmap, 0, 0, False)
 218         dc.EndDrawing()
 219 
 220 class MyFrame(wx.Frame):
 221     def __init__(self, parent, ID, title):
 222         wx.Frame.__init__(self, parent, ID, title)
 223 
 224         self.CreateStatusBar()
 225         self.Centre(wx.BOTH)
 226         mdb = MandelCanvas(self, width=400, height=400, iterations=255)
 227 
 228         # Layout
 229         sizer = wx.BoxSizer(wx.VERTICAL)
 230         sizer.Add(mdb, 0, wx.EXPAND)
 231         self.SetAutoLayout(True)
 232         self.SetInitialSize()
 233 
 234 class MyApp(wx.App):
 235     def OnInit(self):
 236         frame = MyFrame(None, wx.ID_ANY, "Mandelbrot")
 237         frame.Show(True)
 238         self.SetTopWindow(frame)
 239         return True
 240 
 241 if __name__ == '__main__':
 242     app = MyApp(0)
 243     app.MainLoop()

   1     def DisplayThreadMessages( self, msg ) :
   2         """ Receives data from thread and updates the display. """
   3 
   4         msgData = msg.data
   5         if isinstance( msgData, str ) :
   6             self.displayTxtCtrl.WriteText( 'Textual message = [ %s ]\n' % (msgData) )
   7 
   8         elif isinstance( msgData, float ) :
   9             self.displayTxtCtrl.WriteText( '\n' )   # A blank line separator
  10             self.displayTxtCtrl.WriteText( 'Processing time was [ %s ] secs.\n' % (msgData) )
  11 
  12         elif isinstance( msgData, int ) :
  13 
  14             if (msgData == -1) :    # This flag value indicates 'Thread processing has completed'.
  15                 self.btn.Enable()    # The GUI is now ready for another thread to start.
  16                 self.displayTxtCtrl.WriteText( 'Integer ThreadCompletedFlag = [ %d ]\n' % (msgData) )
  17 
  18             else :
  19                 self.displayTxtCtrl.WriteText( 'Integer Calculation Result = [ %d ]\n' % (msgData) )
  20         #end if
  21 
  22     #end def