applied wx blit patch # 1275002

svn path=/trunk/matplotlib/; revision=1680

Author: jdh2358

CHANGELOG

@@ -1,5 +1,8 @@
 New entries should be added at the top
 
+
+2005-08-29 Committed Ken's wx blit patch #1275002
+
 2005-08-26 colorbar modifications - now uses contourf instead of imshow
            so that colors used by contourf are displayed correctly.
            Added two new keyword args (cspacing and clabels) that are

examples/animation_blit_wx.py

@@ -0,0 +1,67 @@
+# For detailed comments on animation and the techniqes used here, see
+# the wiki entry
+# http://www.scipy.org/wikis/topical_software/MatplotlibAnimation
+import matplotlib
+matplotlib.use('WXAgg')
+matplotlib.rcParams['toolbar'] = None
+
+import wx
+import sys
+import pylab as p
+import matplotlib.numerix as nx
+import time
+
+
+# allow the user to disable the WXAgg accelerator from the command line
+if '--no-accel' in sys.argv:
+    import matplotlib.backends.backend_wxagg
+    matplotlib.backends.backend_wxagg._use_accelerator(False)
+
+
+ax = p.subplot(111)
+canvas = ax.figure.canvas
+
+
+# create the initial line
+x = nx.arange(0,2*nx.pi,0.01)
+line, = p.plot(x, nx.sin(x), animated=True, lw=2)
+
+# for profiling
+tstart = time.time()
+blit_time = 0.0
+
+def update_line(*args):
+    global blit_time
+
+    if update_line.background is None:
+        update_line.background = canvas.copy_from_bbox(ax.bbox)
+
+    # restore the clean slate background
+    canvas.restore_region(update_line.background)
+    # update the data
+    line.set_ydata(nx.sin(x+update_line.cnt/10.0))  
+    # just draw the animated artist
+    ax.draw_artist(line)
+    # just redraw the axes rectangle
+
+    t = time.time()
+    canvas.blit(ax.bbox) 
+    blit_time += time.time() - t
+
+    if update_line.cnt==200:
+        # print the timing info and quit
+        frame_time = time.time() - tstart
+        print '200 frames: %.2f seconds' % frame_time
+        print '200 blits:  %.2f seconds' % blit_time
+        print
+        print 'FPS: %.2f' % (200/frame_time)
+        print 'BPS: %.2f' % (200/blit_time)
+        sys.exit()
+
+    update_line.cnt += 1
+    wx.WakeUpIdle()
+
+update_line.cnt = 0
+update_line.background = None
+wx.EVT_IDLE(wx.GetApp(), update_line)
+p.show()

lib/matplotlib/__init__.py

@@ -143,7 +143,7 @@
 from __future__ import generators
 
 
-__version__  = '0.84cvs1'
+__version__  = '0.84.cvs.2'
 __revision__ = '$Revision$'
 __date__     = '$Date$'
 
@@ -928,7 +928,7 @@ def rcdefaults():
 _knownBackends = {
     'Agg2':1, 'Agg':1, 'Cairo':1, 'CocoaAgg':1, 'FltkAgg':1, 'GD':1, 'GDK':1,
     'GTK':1, 'GTKAgg':1, 'GTKCairo':1, 'Paint':1, 'PS':1, 'LaTeX':1, 'QtAgg':1,
-    'SVG':1, 'Template':1, 'TkAgg':1, 'WX':1, 'WXAgg':1, }
+    'SVG':1, 'Template':1, 'TkAgg':1, 'WX':1, 'WXAgg':1, 'WXGLAgg':1,}
 
 
 known = _knownBackends.keys()

lib/matplotlib/backends/backend_wx.py

@@ -890,15 +890,16 @@ def Printer_Print(self, event=None):
         self.gui_repaint()
 
 
-    def draw(self):
+    def draw(self, repaint=True):
         """
         Render the figure using RendererWx instance renderer, or using a
         previously defined renderer if none is specified.
         """
         DEBUG_MSG("draw()", 1, self)
         self.renderer = RendererWx(self.bitmap, self.figure.dpi)
         self.figure.draw(self.renderer)
-        self.gui_repaint()
+        if repaint:
+            self.gui_repaint()
 
     def _get_imagesave_wildcards(self):
         'return the wildcard string for the filesave dialog'
@@ -911,16 +912,17 @@ def _get_imagesave_wildcards(self):
                "PNG (*.png)|*.png|"  \
                "XPM (*.xpm)|*.xpm"
 
-    def gui_repaint(self):
+    def gui_repaint(self, drawDC=None):
         """
-        Performs update of the displayed image on the GUI canvas
-
-        MUST NOT be called during a Paint event
+        Performs update of the displayed image on the GUI canvas, using the
+        supplied device context.  If drawDC is None, a ClientDC will be used to
+        redraw the image.
         """
         DEBUG_MSG("gui_repaint()", 1, self)
-        drawDC=wx.ClientDC(self)
+        if drawDC is None:
+            drawDC=wx.ClientDC(self)
+
         drawDC.BeginDrawing()
-        #drawDC.Clear()
         drawDC.DrawBitmap(self.bitmap, 0, 0)
         drawDC.EndDrawing()
 
@@ -1043,27 +1045,9 @@ def _onPaint(self, evt):
         if not self._isRealized:
             self.realize()
         # Render to the bitmap
-        self.draw()
-        # Must use wxPaintDC during paint event
-
-        l,b,w,h = self.figure.bbox.get_bounds()
-        w = int(math.ceil(w))
-        h = int(math.ceil(h))
-
-
-        # I decoupled this from GraphicsContextWx so it would play
-        # nice with wxagg
-        memDC =wx.MemoryDC()
-        memDC.SelectObject(self.bitmap)
-        memDC.SetPen(wx.Pen('BLACK', 1, wx.SOLID))
-
-        drawDC=wx.PaintDC(self)
-
-        drawDC.BeginDrawing()
-        drawDC.Clear()
-        drawDC.Blit(0, 0, w, h, memDC, 0, 0)
-        #drawDC.DrawBitmap(self.bitmap, 0, 0)
-        drawDC.EndDrawing()
+        self.draw(repaint=False)
+        # Update the display using a PaintDC
+        self.gui_repaint(drawDC=wx.PaintDC(self))
         evt.Skip()
 
     def _onSize(self, evt):

lib/matplotlib/backends/backend_wxagg.py

@@ -1,38 +1,33 @@
 from __future__ import division 
 """
 
- backend_wx.py
+ backend_wxagg.py
 
  A wxPython backend for Agg.  This uses the GUI widgets written by
  Jeremy O'Donoghue (jeremy@o-donoghue.com) and the Agg backend by John
  Hunter (jdhunter@ace.bsd.uchicago.edu)
 
- Copyright (C) Jeremy O'Donoghue & John Hunter, 2003-4
+ Copyright (C) 2003-4 Jeremy O'Donoghue & John Hunter
+ Copyright (C) 2005 Illinois Institute of Technology
  
  License: This work is licensed under the matplotlib license( PSF
  compatible). A copy should be included with this source code.
 
 """
 
-import sys, os, os.path, math, StringIO
-from backend_agg import FigureCanvasAgg
-
-from backend_wx import FigureManager
-from backend_wx import FigureManagerWx, FigureCanvasWx, FigureFrameWx, \
-     DEBUG_MSG, NavigationToolbar2Wx
-from backend_wx import error_msg_wx, draw_if_interactive, show, Toolbar, \
-     backend_version
-import backend_wx
-
-from matplotlib.figure import Figure
-from matplotlib import rcParams
-import matplotlib
 import wx
+import matplotlib
+from matplotlib.figure import Figure
+from matplotlib.transforms import Bbox, Point, Value
 
+from backend_agg import FigureCanvasAgg
+import backend_wx
+from backend_wx import FigureManager, FigureManagerWx, FigureCanvasWx, \
+    FigureFrameWx, DEBUG_MSG, NavigationToolbar2Wx, error_msg_wx, \
+    draw_if_interactive, show, Toolbar, backend_version
 
 
 class FigureFrameWxAgg(FigureFrameWx):
-
     def get_canvas(self, fig):
         return FigureCanvasWxAgg(self, -1, fig)
 
@@ -45,7 +40,7 @@ def _get_toolbar(self, statbar):
         else:
             toolbar = None
         return toolbar 
-              
+
 class FigureCanvasWxAgg(FigureCanvasWx,FigureCanvasAgg):
     """
     The FigureCanvas contains the figure and does event handling.
@@ -57,21 +52,47 @@ class FigureCanvasWxAgg(FigureCanvasWx,FigureCanvasAgg):
     size.
     """
 
-
-    def draw(self):
+    def draw(self, repaint=True):
         """
-        Render the figure using agg
+        Render the figure using agg.
         """
         DEBUG_MSG("draw()", 1, self)
         FigureCanvasAgg.draw(self)
-        s = self.tostring_rgb()  
-        w = int(self.renderer.width)
-        h = int(self.renderer.height)
-        image = wx.EmptyImage(w,h)
-        image.SetData(s)
-        self.bitmap = image.ConvertToBitmap()
+
+        self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
+        if repaint:
+            self.gui_repaint()
+
+    def blit(self, bbox=None):
+        """
+        Transfer the region of the agg buffer defined by bbox to the display.
+        If bbox is None, the entire buffer is transferred.
+        """
+        if bbox is None:
+            self.bitmap = _convert_agg_to_wx_bitmap(self.get_renderer(), None)
+            self.gui_repaint()
+            return
+
+        l, b, w, h = bbox.get_bounds()
+        r = l + w
+        t = b + h
+        x = int(l)
+        y = int(self.bitmap.GetHeight() - t)
+
+        srcBmp = _convert_agg_to_wx_bitmap(self.get_renderer(), bbox)
+        srcDC = wx.MemoryDC()
+        srcDC.SelectObject(srcBmp)
+
+        destDC = wx.MemoryDC()
+        destDC.SelectObject(self.bitmap)
+
+        destDC.BeginDrawing()
+        destDC.Blit(x, y, w, h, srcDC, 0, 0)
+        destDC.EndDrawing()
+
+        destDC.SelectObject(wx.NullBitmap)
+        srcDC.SelectObject(wx.NullBitmap)
         self.gui_repaint()
-        
 
     def print_figure(self, filename, dpi=150, facecolor='w',
                      edgecolor='w', orientation='portrait'):
@@ -96,6 +117,7 @@ class NavigationToolbar2WxAgg(NavigationToolbar2Wx):
     def get_canvas(self, frame, fig):
         return FigureCanvasWxAgg(frame, -1, fig)
 
+
 def new_figure_manager(num, *args, **kwargs):
     """
     Create a new figure manager instance
@@ -119,3 +141,96 @@ def new_figure_manager(num, *args, **kwargs):
     return figmgr
 
 
+#
+# agg/wxPython image conversion functions
+#
+
+def _py_convert_agg_to_wx_image(agg, bbox):
+    """
+    Convert the region of the agg buffer bounded by bbox to a wx.Image.  If
+    bbox is None, the entire buffer is converted.
+
+    Note: agg must be a backend_agg.RendererAgg instance.
+    """
+    wPx = agg.width
+    hPx = agg.height
+    image = wx.EmptyImage(wPx, hPx)
+    image.SetData(agg.tostring_rgb())
+
+    if bbox is None:
+        # agg => rgb -> image
+        return image
+    else:
+        # agg => rgb -> image => bitmap => clipped bitmap => image
+        return wx.ImageFromBitmap(_clipped_image_as_bitmap(image, bbox))
+
+
+def _py_convert_agg_to_wx_bitmap(agg, bbox):
+    """
+    Convert the region of the agg buffer bounded by bbox to a wx.Bitmap.  If
+    bbox is None, the entire buffer is converted.
+
+    Note: agg must be a backend_agg.RendererAgg instance.
+    """
+    if bbox is None:
+        # agg => rgb -> image => bitmap
+        return wx.BitmapFromImage(_py_convert_agg_to_wx_image(agg, None))
+    else:
+        # agg => rgb -> image => bitmap => clipped bitmap
+        return _clipped_image_as_bitmap(
+            _py_convert_agg_to_wx_image(agg, None),
+            bbox)
+
+
+def _clipped_image_as_bitmap(image, bbox):
+    """
+    Convert the region of a wx.Image described by bbox to a wx.Bitmap.
+    """
+    l, b, width, height = bbox.get_bounds()
+    r = l + width
+    t = b + height
+
+    srcBmp = wx.BitmapFromImage(image)
+    srcDC = wx.MemoryDC()
+    srcDC.SelectObject(srcBmp)
+
+    destBmp = wx.EmptyBitmap(width, height)
+    destDC = wx.MemoryDC()
+    destDC.SelectObject(destBmp)
+ 
+    destDC.BeginDrawing()
+    x = int(l)
+    y = int(image.GetHeight() - t)
+    destDC.Blit(0, 0, width, height, srcDC, x, y)
+    destDC.EndDrawing()
+
+    srcDC.SelectObject(wx.NullBitmap)
+    destDC.SelectObject(wx.NullBitmap)
+
+    return destBmp
+
+
+def _use_accelerator(state):
+    """
+    Enable or disable the WXAgg accelerator, if it is present.
+    """
+    global _convert_agg_to_wx_image
+    global _convert_agg_to_wx_bitmap
+
+    if state and _wxagg is not None:
+        _convert_agg_to_wx_image  = _wxagg.convert_agg_to_wx_image
+        _convert_agg_to_wx_bitmap = _wxagg.convert_agg_to_wx_bitmap
+    else:
+        _convert_agg_to_wx_image  = _py_convert_agg_to_wx_image
+        _convert_agg_to_wx_bitmap = _py_convert_agg_to_wx_bitmap
+
+
+# try to load the WXAgg accelerator
+try:
+    import _wxagg
+except ImportError:
+    _wxagg = None
+
+# if it's present, use it
+_use_accelerator(True)
+