Re: [Matplotlib-users] dynamic image demo: suggestions sought

[John H. <jdh...@ac...>]

>>>>> "John" == John Hunter <jdh...@ac...> writes:

    John> Haven't had a chance to test your example yet but hopefully
    John> I can take a look tomorrow.  I haven't done much memory leak
    John> testing against the _image module yet so this will be a good
    John> opportunity.  I very recently rewrote _image.cpp using cxx.
    John> I trust you have a fresh CVS checkout?

Hi Andrew - found and fixed the memory leak.  Can't really call it a
leak - more like a "memory gusher".  This was in the agg (and image)
module "to string" methods.  In my tests, the leak went from 600k per
frame to approx 600 bytes per frame, which is on par for what I see in
other agg memory leak tests.

I made a number of comments in your example to point out places where
you probably should be using matplotlib a little differently - most of
these I flagged with my initials so you can search for them.  Modified
script is below.  

After you get the script in the final form you want and purge the
comments and memory reporting stuff where appropriate, please add it
to CVS.

I liked the example so much I made an analogous one dynamic_image_gtk.
It's faster than wxagg (13FPS vs 4FPS on my system) which is not
surprising since gtkagg has extension code to transfer agg to the GUI
canvas, and doesn't flicker.  Very nice!  I would really like to get
that wxagg flicker problem figured out, and the extension code
added...  Did I hear you volunteering to be the wxagg maintainer :-)?

#!/usr/bin/env python
"""
Copyright (C) 2003-2004 Jeremy O'Donoghue and others
 
License: This work is licensed under the PSF. A copy should be included
with this source code, and is also available at
http://www.python.org/psf/license.html

"""
import sys, time, os, gc

import matplotlib
matplotlib.use('WXAgg')

# jdh: you need to control Numeric vs numarray with numerix, otherwise
# matplotlib may be using numeric under the hood and while you are
# using numarray and this isn't efficient.  Also, if you use
# numerix=numarray, it is important to compile matplotlib for numarray
# by setting NUMERIX = 'numarray' in setup.py before building
from matplotlib import rcParams
rcParams['numerix'] = 'numarray'


# jdh: you can import cm directly, you don't need to go via
# matplotlib.matlab
import matplotlib.cm as cm

from matplotlib.backends.backend_wxagg import Toolbar, FigureCanvasWxAgg

# jdh: you don't need a figure manager in the GUI - this class was
# designed for the matlab interface

from matplotlib.figure import Figure
import matplotlib.numerix as numerix
from wxPython.wx import *


TIMER_ID = wxNewId()

# jdh: use this function, or something similar, when reporting a
# memory leak
def report_memory(i):
    pid = os.getpid()
    a2 = os.popen('ps -p %d -o rss,sz' % pid).readlines()
    print i, '  ', a2[1],
    return int(a2[1].split()[0])

class PlotFigure(wxFrame):

    def __init__(self):
        wxFrame.__init__(self, None, -1, "Test embedded wxFigure")

        self.fig = Figure((5,4), 75)
        self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
        self.toolbar = Toolbar(self.canvas)
        self.toolbar.Realize()

        # On Windows, default frame size behaviour is incorrect
        # you don't need this under Linux
        tw, th = self.toolbar.GetSizeTuple()
        fw, fh = self.canvas.GetSizeTuple()
        self.toolbar.SetSize(wxSize(fw, th))

        # Create a figure manager to manage things

        # Now put all into a sizer
        sizer = wxBoxSizer(wxVERTICAL)
        # This way of adding to sizer allows resizing
        sizer.Add(self.canvas, 1, wxLEFT|wxTOP|wxGROW)
        # Best to allow the toolbar to resize!
        sizer.Add(self.toolbar, 0, wxGROW)
        self.SetSizer(sizer)
        self.Fit()
        EVT_TIMER(self, TIMER_ID, self.onTimer)
        self.cnt = 0

    def init_plot_data(self):
        # jdh you can add a subplot directly from the fig rather than
        # the fig manager
        a = self.fig.add_subplot(111)
        self.x = numerix.arange(120.0)*2*numerix.pi/120.0
        self.x.resize((100,120))
        self.y = numerix.arange(100.0)*2*numerix.pi/100.0
        self.y.resize((120,100))
        self.y = numerix.transpose(self.y)
        z = numerix.sin(self.x) + numerix.cos(self.y)
        self.im = a.imshow( z, cmap=cm.jet)#, interpolation='nearest')



    def GetToolBar(self):
        # You will need to override GetToolBar if you are using an 
        # unmanaged toolbar in your frame
        return self.toolbar
		
    def onTimer(self, evt):
        self.x += numerix.pi/15
        self.y += numerix.pi/20
        z = numerix.sin(self.x) + numerix.cos(self.y)
        self.im.set_array(z)
        self.canvas.draw()
        #self.canvas.gui_repaint()  # jdh wxagg_draw calls this already

        val = report_memory(self.cnt)
        if self.cnt==1:
            self.start = val # skip cnt=0
            self.tstart = time.time()
        elif self.cnt==50:
            end = val
            print 'Average memory consumed per loop: %1.4f\n' % ((end-self.start)/float(self.cnt))
            print 'FPS', self.cnt/(time.time() - self.tstart)
            sys.exit()
            
        self.cnt += 1
        gc.collect()
        
    def onEraseBackground(self, evt):
        # this is supposed to prevent redraw flicker on some X servers...
        pass
        
if __name__ == '__main__':
    app = wxPySimpleApp()
    frame = PlotFigure()
    frame.init_plot_data()
    
    # Initialise the timer - wxPython requires this to be connected to the
    # receivicng event handler
    t = wxTimer(frame, TIMER_ID)
    t.Start(200)
    
    frame.Show()
    app.MainLoop()