matplotlib-users Mailing List for matplotlib (Page 10)

I noticed that the pcolor function uses about twice as much memory as it =
needs to. When creating the list of vertices, you first create the lists =
X1, Y1, X2, Y2, X3, Y3, X4, and Y4, and then combine those lists into =
the "verts" list. I tried to change it to make it not waste memory by =
changing the lines between the line:
mask =3D ma.getmaskarray(C)[0:Nx-1,0:Ny-1]+xymask
and
C =3D compress(ravel(mask=3D=3D0),ravel(ma.filled(C[0:Nx-1,0:Ny-1])))
to the following:
numVertices =3D =
len(compress(ravel(mask=3D=3D0),ravel(ma.filled(X[0:-1,0:-1]))))
verts =3D zeros((numVertices, 4, 2))
verts[:, 0, 0] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(X[0:-1,0:-1])))
verts[:, 0, 1] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(Y[0:-1,0:-1])))
verts[:, 1, 0] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(X[1:,0:-1])))
verts[:, 1, 1] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(Y[1:,0:-1])))
verts[:, 2, 0] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(X[1:,1:])))
verts[:, 2, 1] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(Y[1:,1:])))
verts[:, 3, 0] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(X[0:-1,1:])))
verts[:, 3, 1] =3D =
compress(ravel(mask=3D=3D0),ravel(ma.filled(Y[0:-1,1:])))
However it says that the "array cannot be safely cast to required type" =
on the third line (verts[:, 0, 0] =3D ...). I have no idea why this is =
happening because both arrays are the same length (numVertices). Does =
anyone have any ideas how to fix this problem?
Also, if I do get this working, is there a way to submit it as a patch? =
Having a pcolor function that doesn't use up so much memory might be =
useful for lot of people, not just me.
-Alex Mont

>>>>> "Clovis" == Clovis Goldemberg <cl...@pe...> writes:
 Clovis> The question is: "why isn't the memory collected after
 Clovis> closing the figure?". The real program I developed builds
 Clovis> 5~15 graphic windows and the required memory is very
 Clovis> large.
It is, or it should be. Look at the module _pylab_helpers,
particularly this function which is called when a window is destroyed
 def destroy(num):
 if not Gcf.has_fignum(num): return
 figManager = Gcf.figs[num]
 oldQue = Gcf._activeQue[:]
 Gcf._activeQue = []
 for f in oldQue:
 if f != figManager: Gcf._activeQue.append(f)
 del Gcf.figs[num]
 #print len(Gcf.figs.keys()), len(Gcf._activeQue)
 figManager.destroy()
 gc.collect()
ie, we make an explicit call to the garbage collector when a figure is
destroyed from within pylab. I'm not sure why you are not seeing the
memory freed up, but I believe garbage collection is a bit of a
mystery about what happens where.
I tend to rely on a script called unit/memleak_hawaii3.py which is in
matplotlib CVS to test for memory leaks. Unfortunately this works
only on linux and friends because it uses ps to collect memory usage.
Typically we like to see total memory asymptote out at around 10 to 30
figures and cease climbing. If it climbs monotonically with figure
number, it's indicative of a leak. For reasons beyond me, the memory
consumption doesn't stabilize for the first N figures, where N is an
arbitrary but smallish number. I don't think this has to do with
matplotlib as much as with the python garbage collector.
If you get a chance to test this script on linux, I would be
interested to hear what you find. If someone else knows more about
python's gc, please pipe in.
JDH

Using matplotlib 0.84, python 2.4, scipy 0.3.2, numeric 23.7.
date_demo3.py does not work as is.
Below is a 'diff' file that will create a date_demo3.py that does what I 
think the original intended to do.
------------------------
wjd@plum ~/test $ diff date_demo3.py ../matplotlib_examples/date_demo3.py
8c8
< import datetime
---
 > from datetime import datetime
10c10,12
< from pylab import 
date2num,array,rand,subplot,HourLocator,MinuteLocator,DateFormatter,bar,show
---
 > from matplotlib.dates import intdate
 > from matplotlib.ticker import MinuteLocator, DateFormatter
 > from matplotlib.matlab import *
13,14c15,16
< t0 = datetime.datetime(2004,04,27)
< t = array([date2num(t0+datetime.timedelta(minutes=2*i)) for i in 
range(60)])
---
 > t0 = time.mktime(datetime(2004,04,27).timetuple())
 > t = t0+arange(0, 2*3600, 60) # 2 hours sampled every 2 minute
18c20
< ax.xaxis.set_major_locator( MinuteLocator(byminute=range(0,60,20) ))
---
 > ax.xaxis.set_major_locator( MinuteLocator(20) )
20,21c22
< #1 bar every 2 minutes, bar width = space between bars, 1440 minutes 
per day
< bar(t, s, width=1.0/1440)
---
 > bar(t, s, width=60)
22a24,26
-----------------------------------
Bill

Using matplotlib 0.84, python 2.4, scipy 0.3.2, numeric 23.7
I get errors when running date_demo_rrule.py.
Since the demo scripts are for educational purposes and primarily used 
by newbies, I have a couple of suggestions.
1. Don't use import *, import the specific functions used in the demo. 
I've had problems with this (especially in the interpreter) because many 
Python modules use the same names in their global name space and it's 
easy to inadvertently replace one function with another of the same name 
which introduces bugs that can be difficult to find.
2. Don't import functions from submodules, instead use the submodule 
name when calling the function. It makes it much clearer to see where 
the function came from.
The set function seems to be broken (or it's a typo), I had to replace 
it with the setp function to get the demo to run.
Below it the results of diff between my working version of the demo and 
the original that won't run:
---------------------------------
wjd@plum ~/test $ diff date_demo_rrule.py 
../matplotlib_examples/date_demo_rrule.py
8c8,10
< from pylab import dates, YEARLY, drange, rand, subplot, plot_date, 
setp, show
---
 > from pylab import *
 > from matplotlib.dates import YEARLY, DateFormatter, \
 > rrulewrapper, RRuleLocator, drange
11d12
<
13,15c14,16
< rule = dates.rrulewrapper(YEARLY, byeaster=1, interval=5)
< loc = dates.RRuleLocator(rule)
< formatter = dates.DateFormatter('%m/%d/%y')
---
 > rule = rrulewrapper(YEARLY, byeaster=1, interval=5)
 > loc = RRuleLocator(rule)
 > formatter = DateFormatter('%m/%d/%y')
29c30
< setp(labels, rotation=30, fontsize=10)
---
 > set(labels, rotation=30, fontsize=10)
---------------------------------
Bill

This question is related to memory usage (and garbage collection) with=20
matplotlib.
Some very simple examples are shown below. These results were obtained=20
in a Windows XP
box but some similar results were also observed under Linux. First=20
column shows the memory
allocated just after the execution of the command shown in the second=20
column.
Test #1
Mem Usage Action
3152K Python Command Line Opened
15700K from pylab import *
15700K a =3D arange(0, 10)
19820K figure(1)
19988K plot(a, a)
22288K show()
20100K Memory usage after closing graphic window
Test #2
Mem Usage Action
3148K Python Command Line Opened
15700K from pylab import *
15700K a =3D arange(0, 10)
19820K figure(1)
19988K plot(a, a)
22288K show()
20100K Memory usage after closing graphic window
Test #3
Mem Usage Action
3148K Python Command Line Opened
15700K from pylab import *
19808K figure(1)
19812K a =3D arange(0, 10)
19980K plot(a, a)
22272K show()
20112K Memory usage after closing graphic window
The question is: "why isn't the memory collected after closing the=20
figure?". The real
program I developed builds 5~15 graphic windows and the required memory=20
is very large.
Prof. Clovis Goldemberg
University of S=E3o Paulo

Dear list,
does anyone know an easy way to zoom a part of a canvas and put it in a
new axes, like is done in the demo of axes?
http://matplotlib.sourceforge.net/screenshots/axes_demo_small.png
Regards,
Joost
-- 
Joost van Evert
Information and Communication Theory Group (ICT)
Department of Mediamatica (MM)
Faculty of Electrical Engineering, Mathematics and Computer Science
(EEMCS)
Delft University of Technology (TUD)
Mekelweg 4
Office: HB11.110
2628 CD Delft, 
the Netherlands
Phone: +31 (0) 15 - 27 85436
Mobile: +31 (0) 6 - 41 11 56 84
Email: j.g...@ew...
Url: http://ict.ewi.tudelft.nl/~joost