matplotlib-devel Mailing List for matplotlib

I've been thinking that the SciPy '04 conference 
http://www.scipy.org/wikis/scipy04/ on September 2-3 might be a good 
opportunity for some of us to meet in person and contribute to our 
favorite plotting library via a code sprint.
Unfortunately, it seems the "official" scipy code sprints have been 
canceled.
However, I'm a post-doc at Caltech, so I could organize a venue 
independent of the official conference.
So:
1) is anyone interested in participating in a matplotlib code sprint?
2) what day is best for you?
By the way, the earlybird registration date has been delayed a bit, so 
there's still time to get the reduced fee. Furthermore, there are 
apparently several more spots open for speakers, so please consider 
submitting an abstract.
Personally, I probably won't be available in the days immediately before 
the conference (Wednesday, for example), but could participate on the 
Saturday immediately after the conference. However, although I'll be 
sad to miss it, if Wednesday is best, I think I could arrange for a 
lab-mate to let participants in to the venue.
Cheers!
Andrew

I just checked (after spending all day solving network problem :-() what
effect the re-use of Agg buffer optimisation has on FltkAgg backend:
 Classic TkAgg: 9.98 FPS
 Improved TkAgg: 9.98 FPS
 classic FltkAgg: 16.1 FPS
 Improved FltkAgg: 17.2 FPS
I also installed pyGtk to be able to test the framerate I gor on may
computer:
 Classic GTKAgg: 16 FPS
 Modified GTKAgg (avoid switch backend, which make my re-use of agg
buffer impossible, use multiple inheritance instead): 16 FPS
 Improved modified GTKAgg: 16.8 FPS
And finaly, to have a complete picture, I tried Tk without blitting (as
explained in a previous message)
	classic TkAgg without blit: 14.3 FPS
	improved TkAgg without blit: 16 FPS
There is various strange things in these benchmarks: 
first I was not able to reproduce the (very small but reproductible)
advantage I observed yesterday for Agg buffer re-use optimization in the
TkAgg backend...It is observable in the FltkAgg and TkAgg backend,
though...and even more so in the TkAgg without blitting one...Maybe this
is maked by the blitting time in the normal TkAgg, though, so this does
not disturb me too much...
Next, I do not observe the high performance of the GTKAgg backend here,
on the contrary the FPS it gives me are in line with the Fltk ones, and
even with Tk when we get rid of the slow blitting...This is quite
surprising...
On the other hand, I have less trouble understanding these results than
the higher GTKAgg performance you report, so to be really complete I
tried an bare Agg rendering:
Just use the same example as my light dynamic plot (mode animation), but
with a matplotlib.use("Agg") and a 
while True: 
 updatefig()
loop instead of idle callback...
Here are the timings:
Classic Agg: 19 FPS (or, better said, RenderingPerSecond)
Optimized Agg: 20.55 RPS
So this confirm what I have observed on the various *Agg backends, which
in summary would be:
-Optimization of Agg, to reuse buffer if possible: Gain from 8% to 0%,
depending on the backend (max on Agg, small to non existent on TkAgg).
It depends also on the complexity of the rendering, the gain will be
higher when simple drawings are done, and minimal when very complex
figures are drawn...This could help for memory leak maybe, though...and
as you will see is a very minimal hack...
Performance of the various *Agg backends, using Agg as reference and a
very simple dynamic plot (for the new reuse Agg buffer scheme, current
"new Agg every draw" should be very similar):
 TkAgg: 49% (ouch!)
 TkAgg without blit: 78%
 GTKAgg: 82%
 FltkAgg: 84%
So Fltk and GTK are fast (the 20 % overhead is due to transfer to screen
buffer, double buffering, and callbacks/idle mechanisms, I guess, no way
to get better than that)
TkInter is a slower toolkit, mainly cause of blit, and also for other
reasons it seems.
Only remaining mystery (but it is a big one!) is why you observe very
different things for GTKAgg? Is it a GTK version problem? A compilation
option? This is really surprising, given the bare Agg test give me RPS
in line with my FPS...Only thing I can think of is a option during Agg
compile that decrease the performance of my Agg somehow...
 
You will find included a tar.gz of all the files I modified (including
small examples and my FltkAgg backend - even if it is not too usefull
before pyfltk has been updated)...If you need any more information or
want to discuss this, I would be glad to help :-)
PS: I forward this to matplotlib-devel, without the attachment: I do not
know if the mailinglist would accept such a thing...

The embedding of TrueType fonts in Postscript files has been add to CVS 
during the past week. This enhancement should work for both regular 
text and math text, so the text that you see on the screen should be the 
same in Postscript. This change should be transparent to all users, i.e. 
no additional font files are needed. The TTF is encoded on-the-fly and 
embedded in the PS file when it is written.
Please give it a try and let me know of any problems or anomalies.
 -- Paul
-- 
Paul Barrett, PhD Space Telescope Science Institute
Phone: 410-338-4475 ESS/Science Software Branch
FAX: 410-338-4767 Baltimore, MD 21218