wxPython/wxPython/lib/wxPlotCanvas.py

   1 """
   2 This is a port of Konrad Hinsen's tkPlotCanvas.py plotting module.
   3 After thinking long and hard I came up with the name "wxPlotCanvas.py".
   4
   5 This file contains two parts; first the re-usable library stuff, then, after
   6 a "if __name__=='__main__'" test, a simple frame and a few default plots
   7 for testing.
   8
   9 Harm van der Heijden, feb 1999
  10
  11 Original comment follows below:
  12 # This module defines a plot widget for Tk user interfaces.
  13 # It supports only elementary line plots at the moment.
  14 # See the example at the end for documentation...
  15 #
  16 # Written by Konrad Hinsen <hinsen@cnrs-orleans.fr>
  17 # With contributions from RajGopal Srinivasan <raj@cherubino.med.jhmi.edu>
  18 # Last revision: 1998-7-28
  19 #
  20 """
  21
  22 from wxPython import wx
  23 import string
  24
  25 # Not everybody will have Numeric, so let's be cool about it...
  26 try:
  27     import Numeric
  28 except:
  29     # bummer!
  30     d = wx.wxMessageDialog(wx.NULL,
  31     """This module requires the Numeric module, which could not be imported.
  32 It probably is not installed (it's not part of the standard Python
  33 distribution). See the Python site (http://www.python.org) for
  34 information on downloading source or binaries.""",
  35     "Numeric not found")
  36     if d.ShowModal() == wx.wxID_CANCEL:
  37         d = wx.wxMessageDialog(wx.NULL, "I kid you not! Pressing Cancel won't help you!", "Not a joke", wx.wxOK)
  38         d.ShowModal()
  39     raise ImportError
  40
  41 #
  42 # Plotting classes...
  43 #
  44 class PolyPoints:
  45
  46     def __init__(self, points, attr):
  47         self.points = Numeric.array(points)
  48         self.scaled = self.points
  49         self.attributes = {}
  50         for name, value in self._attributes.items():
  51             try:
  52                 value = attr[name]
  53             except KeyError: pass
  54             self.attributes[name] = value
  55
  56     def boundingBox(self):
  57         return Numeric.minimum.reduce(self.points), \
  58                Numeric.maximum.reduce(self.points)
  59
  60     def scaleAndShift(self, scale=1, shift=0):
  61         self.scaled = scale*self.points+shift
  62
  63
  64 class PolyLine(PolyPoints):
  65
  66     def __init__(self, points, **attr):
  67         PolyPoints.__init__(self, points, attr)
  68
  69     _attributes = {'color': 'black',
  70                    'width': 1}
  71
  72     def draw(self, dc):
  73         color = self.attributes['color']
  74         width = self.attributes['width']
  75         arguments = []
  76         dc.SetPen(wx.wxPen(wx.wxNamedColour(color), width))
  77         dc.DrawLines(map(tuple,self.scaled))
  78
  79
  80 class PolyMarker(PolyPoints):
  81
  82     def __init__(self, points, **attr):
  83
  84         PolyPoints.__init__(self, points, attr)
  85
  86     _attributes = {'color': 'black',
  87                    'width': 1,
  88                    'fillcolor': None,
  89                    'size': 2,
  90                    'fillstyle': wx.wxSOLID,
  91                    'outline': 'black',
  92                    'marker': 'circle'}
  93
  94     def draw(self, dc):
  95         color = self.attributes['color']
  96         width = self.attributes['width']
  97         size = self.attributes['size']
  98         fillcolor = self.attributes['fillcolor']
  99         fillstyle = self.attributes['fillstyle']
 100         marker = self.attributes['marker']
 101
 102         dc.SetPen(wx.wxPen(wx.wxNamedColour(color),width))
 103         if fillcolor:
 104             dc.SetBrush(wx.wxBrush(wx.wxNamedColour(fillcolor),fillstyle))
 105         else:
 106             dc.SetBrush(wx.wxBrush(wx.wxNamedColour('black'), wx.wxTRANSPARENT))
 107
 108         self._drawmarkers(dc, self.scaled, marker, size)
 109
 110     def _drawmarkers(self, dc, coords, marker,size=1):
 111         f = eval('self._' +marker)
 112         for xc, yc in coords:
 113             f(dc, xc, yc, size)
 114
 115     def _circle(self, dc, xc, yc, size=1):
 116         dc.DrawEllipse(xc-2.5*size,yc-2.5*size,5.*size,5.*size)
 117
 118     def _dot(self, dc, xc, yc, size=1):
 119         dc.DrawPoint(xc,yc)
 120
 121     def _square(self, dc, xc, yc, size=1):
 122         dc.DrawRectangle(xc-2.5*size,yc-2.5*size,5.*size,5.*size)
 123
 124     def _triangle(self, dc, xc, yc, size=1):
 125         dc.DrawPolygon([(-0.5*size*5,0.2886751*size*5),
 126                        (0.5*size*5,0.2886751*size*5),
 127                        (0.0,-0.577350*size*5)],xc,yc)
 128
 129     def _triangle_down(self, dc, xc, yc, size=1):
 130         dc.DrawPolygon([(-0.5*size*5,-0.2886751*size*5),
 131                        (0.5*size*5,-0.2886751*size*5),
 132                        (0.0,0.577350*size*5)],xc,yc)
 133
 134     def _cross(self, dc, xc, yc, size=1):
 135         dc.DrawLine(xc-2.5*size,yc-2.5*size,xc+2.5*size,yc+2.5*size)
 136         dc.DrawLine(xc-2.5*size,yc+2.5*size,xc+2.5*size,yc-2.5*size)
 137
 138     def _plus(self, dc, xc, yc, size=1):
 139         dc.DrawLine(xc-2.5*size,yc,xc+2.5*size,yc)
 140         dc.DrawLine(xc,yc-2.5*size,xc,yc+2.5*size)
 141
 142 class PlotGraphics:
 143
 144     def __init__(self, objects):
 145         self.objects = objects
 146
 147     def boundingBox(self):
 148         p1, p2 = self.objects[0].boundingBox()
 149         for o in self.objects[1:]:
 150             p1o, p2o = o.boundingBox()
 151             p1 = Numeric.minimum(p1, p1o)
 152             p2 = Numeric.maximum(p2, p2o)
 153         return p1, p2
 154
 155     def scaleAndShift(self, scale=1, shift=0):
 156         for o in self.objects:
 157             o.scaleAndShift(scale, shift)
 158
 159     def draw(self, canvas):
 160         for o in self.objects:
 161             o.draw(canvas)
 162
 163     def __len__(self):
 164         return len(self.objects)
 165
 166     def __getitem__(self, item):
 167         return self.objects[item]
 168
 169
 170 class PlotCanvas(wx.wxWindow):
 171
 172     def __init__(self, parent, id = -1):
 173         wx.wxWindow.__init__(self, parent, id, wx.wxPyDefaultPosition, wx.wxPyDefaultSize)
 174         self.border = (1,1)
 175         self.SetClientSizeWH(400,400)
 176         self.SetBackgroundColour(wx.wxNamedColour("white"))
 177
 178         wx.EVT_SIZE(self,self.reconfigure)
 179         wx.EVT_PAINT(self, self.OnPaint)
 180         self._setsize()
 181         self.last_draw = None
 182 #       self.font = self._testFont(font)
 183
 184     def OnPaint(self, event):
 185         pdc = wx.wxPaintDC(self)
 186         if self.last_draw is not None:
 187             apply(self.draw, self.last_draw + (pdc,))
 188
 189     def reconfigure(self, event):
 190         (new_width,new_height) = self.GetClientSizeTuple()
 191         if new_width == self.width and new_height == self.height:
 192             return
 193         self._setsize()
 194         # self.redraw()
 195
 196     def _testFont(self, font):
 197         if font is not None:
 198             bg = self.canvas.cget('background')
 199             try:
 200                 item = CanvasText(self.canvas, 0, 0, anchor=NW,
 201                                   text='0', fill=bg, font=font)
 202                 self.canvas.delete(item)
 203             except TclError:
 204                 font = None
 205         return font
 206
 207     def _setsize(self):
 208         (self.width,self.height) = self.GetClientSizeTuple();
 209         self.plotbox_size = 0.97*Numeric.array([self.width, -self.height])
 210         xo = 0.5*(self.width-self.plotbox_size[0])
 211         yo = self.height-0.5*(self.height+self.plotbox_size[1])
 212         self.plotbox_origin = Numeric.array([xo, yo])
 213
 214     def draw(self, graphics, xaxis = None, yaxis = None, dc = None):
 215         if dc == None: dc = wx.wxClientDC(self)
 216         dc.BeginDrawing()
 217         dc.Clear()
 218         self.last_draw = (graphics, xaxis, yaxis)
 219         p1, p2 = graphics.boundingBox()
 220         xaxis = self._axisInterval(xaxis, p1[0], p2[0])
 221         yaxis = self._axisInterval(yaxis, p1[1], p2[1])
 222         text_width = [0., 0.]
 223         text_height = [0., 0.]
 224         if xaxis is not None:
 225             p1[0] = xaxis[0]
 226             p2[0] = xaxis[1]
 227             xticks = self._ticks(xaxis[0], xaxis[1])
 228             bb = dc.GetTextExtent(xticks[0][1])
 229             text_height[1] = bb[1]
 230             text_width[0] = 0.5*bb[0]
 231             bb = dc.GetTextExtent(xticks[-1][1])
 232             text_width[1] = 0.5*bb[0]
 233         else:
 234             xticks = None
 235         if yaxis is not None:
 236             p1[1] = yaxis[0]
 237             p2[1] = yaxis[1]
 238             yticks = self._ticks(yaxis[0], yaxis[1])
 239             for y in yticks:
 240                 bb = dc.GetTextExtent(y[1])
 241                 text_width[0] = max(text_width[0],bb[0])
 242             h = 0.5*bb[1]
 243             text_height[0] = h
 244             text_height[1] = max(text_height[1], h)
 245         else:
 246             yticks = None
 247         text1 = Numeric.array([text_width[0], -text_height[1]])
 248         text2 = Numeric.array([text_width[1], -text_height[0]])
 249         scale = (self.plotbox_size-text1-text2) / (p2-p1)
 250         shift = -p1*scale + self.plotbox_origin + text1
 251         self._drawAxes(dc, xaxis, yaxis, p1, p2,
 252                        scale, shift, xticks, yticks)
 253         graphics.scaleAndShift(scale, shift)
 254         graphics.draw(dc)
 255         dc.EndDrawing()
 256
 257     def _axisInterval(self, spec, lower, upper):
 258         if spec is None:
 259             return None
 260         if spec == 'minimal':
 261             if lower == upper:
 262                 return lower-0.5, upper+0.5
 263             else:
 264                 return lower, upper
 265         if spec == 'automatic':
 266             range = upper-lower
 267             if range == 0.:
 268                 return lower-0.5, upper+0.5
 269             log = Numeric.log10(range)
 270             power = Numeric.floor(log)
 271             fraction = log-power
 272             if fraction <= 0.05:
 273                 power = power-1
 274             grid = 10.**power
 275             lower = lower - lower % grid
 276             mod = upper % grid
 277             if mod != 0:
 278                 upper = upper - mod + grid
 279             return lower, upper
 280         if type(spec) == type(()):
 281             lower, upper = spec
 282             if lower <= upper:
 283                 return lower, upper
 284             else:
 285                 return upper, lower
 286         raise ValueError, str(spec) + ': illegal axis specification'
 287
 288     def _drawAxes(self, dc, xaxis, yaxis,
 289                   bb1, bb2, scale, shift, xticks, yticks):
 290         dc.SetPen(wx.wxPen(wx.wxNamedColour('BLACK'),1))
 291         if xaxis is not None:
 292             lower, upper = xaxis
 293             text = 1
 294             for y, d in [(bb1[1], -3), (bb2[1], 3)]:
 295                 p1 = scale*Numeric.array([lower, y])+shift
 296                 p2 = scale*Numeric.array([upper, y])+shift
 297                 dc.DrawLine(p1[0],p1[1],p2[0],p2[1])
 298                 for x, label in xticks:
 299                     p = scale*Numeric.array([x, y])+shift
 300                     dc.DrawLine(p[0],p[1],p[0],p[1]+d)
 301                     if text:
 302                         dc.DrawText(label,p[0],p[1])
 303                 text = 0
 304
 305         if yaxis is not None:
 306             lower, upper = yaxis
 307             text = 1
 308             h = dc.GetCharHeight()
 309             for x, d in [(bb1[0], -3), (bb2[0], 3)]:
 310                 p1 = scale*Numeric.array([x, lower])+shift
 311                 p2 = scale*Numeric.array([x, upper])+shift
 312                 dc.DrawLine(p1[0],p1[1],p2[0],p2[1])
 313                 for y, label in yticks:
 314                     p = scale*Numeric.array([x, y])+shift
 315                     dc.DrawLine(p[0],p[1],p[0]-d,p[1])
 316                     if text:
 317                         dc.DrawText(label,p[0]-dc.GetTextExtent(label)[0],
 318                                     p[1]-0.5*h)
 319                 text = 0
 320
 321     def _ticks(self, lower, upper):
 322         ideal = (upper-lower)/7.
 323         log = Numeric.log10(ideal)
 324         power = Numeric.floor(log)
 325         fraction = log-power
 326         factor = 1.
 327         error = fraction
 328         for f, lf in self._multiples:
 329             e = Numeric.fabs(fraction-lf)
 330             if e < error:
 331                 error = e
 332                 factor = f
 333         grid = factor * 10.**power
 334         if power > 3 or power < -3:
 335             format = '%+7.0e'
 336         elif power >= 0:
 337             digits = max(1, int(power))
 338             format = '%' + `digits`+'.0f'
 339         else:
 340             digits = -int(power)
 341             format = '%'+`digits+2`+'.'+`digits`+'f'
 342         ticks = []
 343         t = -grid*Numeric.floor(-lower/grid)
 344         while t <= upper:
 345             ticks.append( (t, format % (t,)) )
 346             t = t + grid
 347         return ticks
 348
 349     _multiples = [(2., Numeric.log10(2.)), (5., Numeric.log10(5.))]
 350
 351     def redraw(self,dc=None):
 352         if self.last_draw is not None:
 353             apply(self.draw, self.last_draw + (dc,))
 354
 355     def clear(self):
 356         self.canvas.delete('all')
 357
 358 #---------------------------------------------------------------------------
 359 # if running standalone...
 360 #
 361 #     ...a sample implementation using the above
 362 #
 363
 364
 365 if __name__ == '__main__':
 366     def _InitObjects():
 367         # 100 points sin function, plotted as green circles
 368         data1 = 2.*Numeric.pi*Numeric.arange(200)/200.
 369         data1.shape = (100, 2)
 370         data1[:,1] = Numeric.sin(data1[:,0])
 371         markers1 = PolyMarker(data1, color='green', marker='circle',size=1)
 372
 373         # 50 points cos function, plotted as red line
 374         data1 = 2.*Numeric.pi*Numeric.arange(100)/100.
 375         data1.shape = (50,2)
 376         data1[:,1] = Numeric.cos(data1[:,0])
 377         lines = PolyLine(data1, color='red')
 378
 379         # A few more points...
 380         pi = Numeric.pi
 381         markers2 = PolyMarker([(0., 0.), (pi/4., 1.), (pi/2, 0.),
 382                               (3.*pi/4., -1)], color='blue',
 383                               fillcolor='green', marker='cross')
 384
 385         return PlotGraphics([markers1, lines, markers2])
 386
 387
 388     class AppFrame(wx.wxFrame):
 389         def __init__(self, parent, id, title):
 390             wx.wxFrame.__init__(self, parent, id, title,
 391                                 wx.wxPyDefaultPosition, wx.wxSize(400, 400))
 392
 393             # Now Create the menu bar and items
 394             self.mainmenu = wx.wxMenuBar()
 395
 396             menu = wx.wxMenu()
 397             menu.Append(200, '&Print...', 'Print the current plot')
 398             wx.EVT_MENU(self, 200, self.OnFilePrint)
 399             menu.Append(209, 'E&xit', 'Enough of this already!')
 400             wx.EVT_MENU(self, 209, self.OnFileExit)
 401             self.mainmenu.Append(menu, '&File')
 402
 403             menu = wx.wxMenu()
 404             menu.Append(210, '&Draw', 'Draw plots')
 405             wx.EVT_MENU(self,210,self.OnPlotDraw)
 406             menu.Append(211, '&Redraw', 'Redraw plots')
 407             wx.EVT_MENU(self,211,self.OnPlotRedraw)
 408             menu.Append(212, '&Clear', 'Clear canvas')
 409             wx.EVT_MENU(self,212,self.OnPlotClear)
 410             self.mainmenu.Append(menu, '&Plot')
 411
 412             menu = wx.wxMenu()
 413             menu.Append(220, '&About', 'About this thing...')
 414             wx.EVT_MENU(self, 220, self.OnHelpAbout)
 415             self.mainmenu.Append(menu, '&Help')
 416
 417             self.SetMenuBar(self.mainmenu)
 418
 419             # A status bar to tell people what's happening
 420             self.CreateStatusBar(1)
 421
 422             self.client = PlotCanvas(self)
 423
 424         def OnFilePrint(self, event):
 425             d = wx.wxMessageDialog(self,
 426 """As of this writing, printing support in wxPython is shaky at best.
 427 Are you sure you want to do this?""", "Danger!", wx.wxYES_NO)
 428             if d.ShowModal() == wx.wxID_YES:
 429                 psdc = wx.wxPostScriptDC("out.ps", wx.TRUE, self)
 430                 self.client.redraw(psdc)
 431
 432         def OnFileExit(self, event):
 433             self.Close()
 434
 435         def OnPlotDraw(self, event):
 436             self.client.draw(_InitObjects(),'automatic','automatic');
 437
 438         def OnPlotRedraw(self,event):
 439             self.client.redraw()
 440
 441         def OnPlotClear(self,event):
 442             self.client.last_draw = None
 443             dc = wx.wxClientDC(self.client)
 444             dc.Clear()
 445
 446         def OnHelpAbout(self, event):
 447             about = wx.wxMessageDialog(self, __doc__, "About...", wx.wxOK)
 448             about.ShowModal()
 449
 450
 451
 452     class MyApp(wx.wxApp):
 453         def OnInit(self):
 454             frame = AppFrame(wx.NULL, -1, "wxPlotCanvas")
 455             frame.Show(wx.TRUE)
 456             self.SetTopWindow(frame)
 457             return wx.TRUE
 458
 459
 460     app = MyApp(0)
 461     app.MainLoop()
 462
 463
 464
 465
 466 #----------------------------------------------------------------------------