matplotlib-users Mailing List for matplotlib

Hi Everyone,
This week I started looking into saving my work to a pickled file so I 
could reload them later and retain their names. In Matlab, all or some 
variables in a workspace can be saved to a .mat file, and it seems 
possible to do this with Python. comp.lang.python gave me some ideas, 
and I wonder if this would be useful to matplotlib.
The primary problems, as I see them, are:
1) all objects are not picklable
2) a variable's class must be defined before instantiating by unpickling
3) others that I am not aware of (well, there's always that)
Have you guys looked into a way to save variables from an interactive 
session? I'm sure there is an easier way; my not-too-Pythonic solution 
looks like:
import shelve
myvars = {}
for key in vars().keys():
 myvar = vars()[key]
 if str(type(myvar)) == "<type 'module'>": print "can't pickle <type 
'module'>"
 elif: str(type(myvar)) == "<type 'function'>": print "can't pickle 
<type 'function'>"
 elif: str(type(myvar)) == "<type 'unpicklable'>": print "can't 
pickle <type 'module'>"
 else: myvars.update({key:myvar})
s = shelve.open('myvars.mpl',protocol=-1)
s.update(myvars)
s.close()
and reloading the data:
import shelve
s = shelve.open('myvars.mpl')
for key in s.keys():
	try:
		vars().update({key:s[key]})
	except:
		print type(s[key]), ' is not currently defined.'
What do you think? A try/except PicklingError might be possiblem, but according to the pickling docs, an unspecified number of bytes may have been written to the file before the 
PicklingError exception is raised.
Also, is there any interest in saving figures as pickled objects, to be reloaded like Matlab's .fig files? 
Darren
-- 
Darren S. Dale
dd...@co...
PGP public key available

>>>>> "Jin-chung" == Jin-chung Hsu <hs...@st...> writes:
 Jin-chung> One would expect the following will fill up the plot
 Jin-chung> window:
 >>>> n=zeros(20000) n[::2]=1 plot(n)
 Jin-chung> The plot "stops" a little more than half way, as if it
 Jin-chung> "runs out of ink".
 Jin-chung> It happens on Linux as well as Solaris, using either
 Jin-chung> numarray and Numeric, and both TkAgg and GTKAgg, but
 Jin-chung> not GTK. Is this due to some AGG limitation?
Hi Jin-chung,
This is indeed an agg problem. It is not a limitation in the sense of
'n is too large'. It looks like a bug in agg but it is too early to
say.
For example, this is OK
 >>> plot(n)
 >>> ax.set_ylim((-2,2))
as is 
 >>> plot(n, 'o')
or
 >>> plot(rand(20000))
Ie, the problem seems to occur when plotting solid lines where many of
the y values are similar, but is not a problem with the length of n,
per se.
I was able to reproduce the bug in pure agg c++ and posted to the agg
mailing list. Maxim (agg author) is on vacation, but I suspect he'll
provide some insight when he returns.
Thanks for letting me know,
JDH

On Wed, 2004年07月28日 at 14:11, John Hunter wrote:
> >>>>> "Mark" == Mark Engelhardt <ma...@st...> writes:
> 
> Mark> Hi, I am not in interactive mode, I am writing scripts that
> Mark> handle a bunch of data and then plot it all. However, when
> Mark> show() is called, the script stops and waits for all the
> Mark> windows it opens to be closed before continuing. What I was
> Mark> hoping for was a way to have the plots be drawn in windows
> Mark> that were no longer hooked into the script, such that the
> Mark> script could continue running (to completion) regardless of
> Mark> what happened to the open windows. I did try 'draw()',
> Mark> which does not appear to open any new windows.
> 
> Hi Mark, 
> 
> Thanks for the explanation. Now I understand what you are trying to
> do. You are right about draw, all it does is redraw an existing
> figure, eg if you have changed some data in it.
Hi,
I think I recall I observed the requested behavior (i.e. get hand back
in interractive window or script after a show()) in previous version of
matplotlib.
I remember this cause reproducing this non-blocking behavior of show()
has proven to be a little bit hard to reproduce when developing FltkAgg
backend (I have done it using thread, and it works, so a solution would
be to use this backend when it is integrated).
But with TkAgg and GTKAgg, cvs version, on linux, it does not work
anymore (i.e. show() do not return hand, as mentioned)
I tested some earlier version (0.54 on windows, TkAgg) to see if I have
so false souvenir, but it indeed work as Mark want (i.e. show() is
non-blocking )...So I guess something has changed in the show()
mechanism since, maybe to deal with the new event mechanism?
Best regards,
Greg.

>>>>> "Mark" == Mark Engelhardt <ma...@st...> writes:
 Mark> Hi, I am not in interactive mode, I am writing scripts that
 Mark> handle a bunch of data and then plot it all. However, when
 Mark> show() is called, the script stops and waits for all the
 Mark> windows it opens to be closed before continuing. What I was
 Mark> hoping for was a way to have the plots be drawn in windows
 Mark> that were no longer hooked into the script, such that the
 Mark> script could continue running (to completion) regardless of
 Mark> what happened to the open windows. I did try 'draw()',
 Mark> which does not appear to open any new windows.
Hi Mark, 
Thanks for the explanation. Now I understand what you are trying to
do. You are right about draw, all it does is redraw an existing
figure, eg if you have changed some data in it.
You have to get a little bit into the GTK API / event handling
mechanism to do this right. One way is to use the full blown gtk API
with matplotlib, as in examples/embedding_in_gtk*.py.
The easier way is to just use as much of the API as you need, and take
over the function of the backend 'show' function. You'll be doing an
end run around the matplotlib.matlab figure manager, which means some
of these won't work (like gcf, close, etc.). That's OK, because you
won't be using the matplotlib.matlab interface. Do not import
matplotlib.matlab with this approach as the result is undefined!
There are a few things you need to do
 * Define function(s) / class(es) which create your figures
 * Define a main function which call these functions as necessary.
 Return False from this function
 * Add main to the gtk idle handler. Returning False in 'main' will
 cause this function to be called only once.
 * Start the gtk mainloop yourself. After gtk is started, your
 'main' function will be called and you're off to the races.
 * If there is something you want from matplotlib.matlab, say the
 'axis' command, just look at the src code to see how axis is
 implemented with the matplotlib API and make those calls yourself.
You may want to spend some time with the pygtk class reference at
http://www.pygtk.org/pygtk2reference/gtk-class-reference.html and the
matplotlib class reference at
http://matplotlib.sourceforge.net/classdocs.html. In the example
below
 * canvas inherits from gtk.DrawingArea and
 backends.FigureCanvasGTK (which in turn derives from 
 backend_bases.FigureCanvasBase)
 * manager is a backends.backend_gtk.FigureManagerGTK
 which inherits from backend_bases.FigureManagerBase
 * manager.window is a gtk.Window() (you can also hide or close this
 window with pygtk API calls)
 * ax is a axes.Subplot which inherits from axes.Axes
Here is an example
#!/usr/bin/env python
import matplotlib
matplotlib.use('GTKAgg')
from matplotlib.backends.backend_gtkagg import new_figure_manager
from matplotlib.numerix import *
import gtk
def main(*args):
 manager1 = new_figure_manager(1)
 canvas1 = manager1.canvas
 fig1 = canvas1.figure
 ax1 = fig1.add_subplot(111)
 ax1.plot([1,2,3])
 manager1.window.show() # non blocking
 manager2 = new_figure_manager(2)
 canvas2 = manager2.canvas
 fig2 = canvas2.figure
 ax2 = fig2.add_subplot(111)
 ax2.plot([6,5,4])
 manager2.window.show()
 return False
gtk.idle_add(main)
gtk.mainloop()

Hi,
I am not in interactive mode, I am writing scripts that handle a bunch 
of data and then plot it all. However, when show() is called, the 
script stops and waits for all the windows it opens to be closed before 
continuing. What I was hoping for was a way to have the plots be drawn 
in windows that were no longer hooked into the script, such that the 
script could continue running (to completion) regardless of what 
happened to the open windows. I did try 'draw()', which does not 
appear to open any new windows.
In answer to your questions, here are the relevant lines from my 
.matplotlibrc:
backend : GTKAgg # the default backend
numerix : numarray #Numeric # Numeric or numarray
interactive : False # see 
http://matplotlib.sourceforge.net/interactive.htm
Thanks for everyone's help on subplot positioning (or avoidance ;)) - 
I'll take a look.
- Mark
On Jul 26, 2004, at 2:06 PM, John Hunter wrote:
> Mark> 2. Is there a way to make the 'show()' command execute so
> Mark> that the script keeps running (instead of waiting for the
> Mark> windows to be closed), and to have the output persist past
> Mark> the end of the run?
>
> You should only call show once per script. I repeat, you should only
> call show once per script -
> http://matplotlib.sourceforge.net/faq.html#SHOW
>
> matplotlib-0.60.2 has a "draw" command to force a canvas redraw. This
> is non blocking. Earlier versions allow you to do, equivalently,
> get_current_fig_manager().canvas.draw(). Does this do what you want?
> I am not sure what you are after when you write "have the output
> persist past the end of the run". Launch the python interpreter?
>
> Please let me know what backend you are using and explain a bit more
> what it is you are trying to do. Are you running in interactive mode?
>
> JDH
>

 > Which backend are you using? Chris Fuller submitted a tk widget for
 > just this purpose -
 > http://sourceforge.net/mailarchive/message.php?msg_id=8901913. It
 > would be fairly easy to port to other GUIs. It"s on the list of things
 > to do, but I haven"t had time. Other than that, your best option is
 > to manually set the axes size, eg using the "axes" command or calling
the fig_layout.py module is quite agnostic w.r.t. backend, the included demo
(layout_demo.py) is where TkAgg is invoked. The only dependency is on the figure
object itself, so there should be no problem using this functionality with any
backend. The embedded documentation should get you started.
You may need to use matlab.gcf() to get this figure object, if you are not using
the object oriented interface (for instance, interactively)
Chris