matplotlib-users Mailing List for matplotlib

Why do you want to "fork" the process? If you just run it in the 
background it should have the desired effect:
<begin tst.py>
from pylab import *
x = linspace(-10,10,100) # or load data from a file.
y = sin(x)
plot(x,y)
show()
<end tst.py>
$ python tst.py&
Process remains in background running until the user closes the plot 
window, at which point it terminates.
Michael.
On 7 Jul 2008, at 2:30 PM, James K. Gruetzner wrote:
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> I'm not sure if this is the right venue for this question. I've 
> searched the
> archives, but without success so far. If this is covered there (or 
> elsewhere
> on the web), I'd apprciate a pointer to it so it doesn't duplicate 
> bandwidth
> here.
>
> Anyway, what I'd like to do is have a python script which reads 
> data from a
> file, displays an image/plot/whatever made from the data, and then 
> exits,
> keeping the image displayed.
>
> I'm running Fedora 8, python 2.5.1, and matplotlib 0.91.2-1.fc8 
> from the yum
> repository. Backend is set to GTKAgg in my matplotlibrc file.
>
> My initial attempt used the "double fork" method from the python 
> cookbook:
>
> - -------------Code follows----------------------
> if __name__ == "__main__":
>
> #From Python Cookbook
> try:
> pid = os.fork()
> if pid > 0:
> # Exit first parent
> sys.exit(0)
> except OSError, e:
> print >>sys.stderr, "fork #1 failed: %d (%s)" %(e.errno, 
> e.strerror)
> sys.exit(1)
>
> # Decouple from parent environment
> #os.chdir("/")
> os.setsid()
> os.umask(0)
>
> # Do second fork
> try:
> pid = os.fork()
> if pid > 0:
> # Exit from second parent; print eventual PID before exiting
> print "Image PID %d" % pid
> sys.exit(0)
> except OSError, e:
> print >>sys.stderr, "fork #2 failed: %d (%s)"%(e.errno, 
> e.strerror)
> sys.exit(1)
>
> # Start the main loop to display image
> main()
>
> - --------------END CODE--------------------------------------
>
> The main() function reads the values appropriately into the 
> variable "myarr",
> and then calls imshow and show:
>
> - ------------ Code follows -------------------
> :
> :
> pylab.imshow(myarr)
> pylab.show()
> - --------------END CODE--------------------------------------
>
> . . . and then exits.
>
> All works well until I try to kill the figure/image by clicking on 
> the X in
> the upper-right corner. It disappears alright, but the process 
> remains
> running, and I have to manually kill it with the kill -SIGTERM 
> <pid> command.
>
> I'd like the process to die when I close the window.
>
> I'm really an application programmer, not a system programmer, and 
> usually
> don't delve this deeply into process management, so I'm probably doing
> something extremely ignorant. Help is appreciated.
>
> Thanks!
>
> James
>
>
> -----BEGIN PGP SIGNATURE-----
> Version: GnuPG v1.4.7 (GNU/Linux)
>
> iD8DBQFIcor8xOXthSHeGJIRAm/aAKC/SPQzocHigz2glpvtBJc0BcMU3ACfUTe0
> PM0fby8/z3YJcAj+Llb++ho=
> =NgA/
> -----END PGP SIGNATURE-----
>
>
> ---------------------------------------------------------------------- 
> ---
> Sponsored by: SourceForge.net Community Choice Awards: VOTE NOW!
> Studies have shown that voting for your favorite open source project,
> along with a healthy diet, reduces your potential for chronic lameness
> and boredom. Vote Now at http://www.sourceforge.net/community/cca08
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
I'm not sure if this is the right venue for this question. I've searched the 
archives, but without success so far. If this is covered there (or elsewhere 
on the web), I'd apprciate a pointer to it so it doesn't duplicate bandwidth 
here. 
Anyway, what I'd like to do is have a python script which reads data from a 
file, displays an image/plot/whatever made from the data, and then exits, 
keeping the image displayed. 
I'm running Fedora 8, python 2.5.1, and matplotlib 0.91.2-1.fc8 from the yum 
repository. Backend is set to GTKAgg in my matplotlibrc file. 
My initial attempt used the "double fork" method from the python cookbook:
- -------------Code follows----------------------
 if __name__ == "__main__":
 #From Python Cookbook
 try:
 pid = os.fork()
 if pid > 0:
 # Exit first parent
 sys.exit(0)
 except OSError, e:
 print >>sys.stderr, "fork #1 failed: %d (%s)" %(e.errno, e.strerror)
 sys.exit(1)
 # Decouple from parent environment
 #os.chdir("/")
 os.setsid()
 os.umask(0)
 # Do second fork
 try:
 pid = os.fork()
 if pid > 0:
 # Exit from second parent; print eventual PID before exiting
 print "Image PID %d" % pid
 sys.exit(0)
 except OSError, e:
 print >>sys.stderr, "fork #2 failed: %d (%s)"%(e.errno, e.strerror)
 sys.exit(1)
 # Start the main loop to display image
 main()
 
- --------------END CODE--------------------------------------
The main() function reads the values appropriately into the variable "myarr",
and then calls imshow and show:
- ------------ Code follows -------------------
 :
 :
 pylab.imshow(myarr)
 pylab.show()
- --------------END CODE--------------------------------------
. . . and then exits. 
All works well until I try to kill the figure/image by clicking on the X in 
the upper-right corner. It disappears alright, but the process remains 
running, and I have to manually kill it with the kill -SIGTERM <pid> command.
I'd like the process to die when I close the window. 
I'm really an application programmer, not a system programmer, and usually 
don't delve this deeply into process management, so I'm probably doing 
something extremely ignorant. Help is appreciated.
Thanks!
 James
 
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.7 (GNU/Linux)
iD8DBQFIcor8xOXthSHeGJIRAm/aAKC/SPQzocHigz2glpvtBJc0BcMU3ACfUTe0
PM0fby8/z3YJcAj+Llb++ho=
=NgA/
-----END PGP SIGNATURE-----

hello,
> why is it actually not possible to do something like the following piece 
> of code?
> ioff()
> plot commands
> draw()
> ion()
actually, i did some test now (modification of the example 
http://www.scipy.org/Cookbook/Matplotlib/Animations site):
from pylab import *
ioff()
x = arange(0,2*pi,0.01) # x-array
line, = plot(x,sin(x))
draw()
displays nothing, then
ion()
for i in arange(1,200):
 line.set_ydata(sin(x+i/10.0)) # update the data
 draw() # redraw the canvas
displays nothing as well, but shows the same 'lag' as when running the 
whole code in interactive mode. that means that the data is processed, 
the graphics is plotted, just the window is not displayed.
i thought that ioff() is present exactly for this purpose. 
unfortunately, the documentation page
http://matplotlib.sourceforge.net/interactive.html
shows only an example where an image file is produced first with ioff(), 
the figure is closed and something is then displayed with ion().
when i later issue another plot() command (i.e., plot(random(20), 
random(20)), it is displayed and shows also the last part of the sin(x) 
plot...
the thing i want to achieve is maybe impossible - i'd just love to know 
why, or what am i doing wrong... i'm very grateful for any hints.
best,
lubos
-- 
Lubos _@_"
http://www.lubos.vrbka.net

I think this was just an oversight in the refactoring of transformations 
for 0.98. This should work now in SVN r5716. Look here if you want to 
patch your local copy -->
http://matplotlib.svn.sourceforge.net/viewvc/matplotlib?view=rev&revision=5716
Cheers,
Mike
Matthew Turk wrote:
> Hi there,
>
> I'm attempting to port some code over to matplotlib 0.98.x.
> Previously, I was able to do something like:
>
> axes_object.pcolormesh(x,y,v)
> axes_object.set_xscale('log')
> axes_object.set_yscale('log')
>
> and then save the figure. However, now this fails because the
> sequence of transformations it applies is not affine. (assert
> transform.is_affine in collections.py:QuadMesh.) If I want to have
> the same effect -- a log-spaced pcolormesh -- what is the appropriate
> sequence of calls? I'd like to avoid pre-applying the log and
> plotting on a linear-scale plot, as the code also overplots analytic
> functions in the same figure.
>
> Thanks!
>
> -Matt
>
> -------------------------------------------------------------------------
> Sponsored by: SourceForge.net Community Choice Awards: VOTE NOW!
> Studies have shown that voting for your favorite open source project,
> along with a healthy diet, reduces your potential for chronic lameness
> and boredom. Vote Now at http://www.sourceforge.net/community/cca08
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
> 
-- 
Michael Droettboom
Science Software Branch
Operations and Engineering Division
Space Telescope Science Institute
Operated by AURA for NASA

Hello,
I would like to get periodically updated plots: the data set grows at
some rate (5 numbers/sec) and I would like to update all plots I have
(may be multiple) once in 5 seconds, for example.
I thought of storing Figure objects after creating the plots, then
launch separate thread that would wake up every 5 seconds, copy data
from the source arrays to the Line2D instances (set_data(...)) and call
Figure.draw(..) to update the plot.
I have a few questions to that:
1. Would it be possible to do only shallow copy of the arrays that are
being plotted so that on redrawing the figure, chanes in the datasets
would be picked up automatically? If not, is Line2D.set_data(...) the
right approach?
2. How can I trigger autoscaling of the figure so that all data can be
displayed? Like the one happening when the figure is first drawn; in the
_ideal_ case deynamic autoscaling would be effected only if the graph
has the default zoom level, so that user-zoom is not reset at every redraw.
3. How do I iterate over all Figure instances (and, consequently, Line2D
instances) that are being displayed? Currently, I store Line2D's that
are returned by pylab.plot(...) to acces them later, but I think there
must be a better way,
I hope I was able to clearly express my problem. Do not hesitate to ask
for more information. Best regards,
Vaclav

hi,
> you can avoid (auto-)rescaling in matplotlib:
> -------------------------------------------------------------------------------------------------------
> import pylab
> ax = pylab.subplot(111, autoscale_on=False)
> # or for an already existing axes instance 'ax' : ax.set_autoscale_on(False)
> --------------------------------------------------------------------------------------------------------
this is exactly what i wanted, thanks!
> If you want to plot in background you have to skip interactive mode (up to my 
> knowledge). If you nevertheless would like to change the results you can use 
> pylab.show() as last line in your script and change you data via 
> event-control - something like:
> --------------------------------------------------------------------------------------
> def function(event):
> if event.key == "c":
> pylab.cla()
> elif event.key == "u":
> # update the data
> pass
> pylab.connect("key_press_event", function)
> pylab.show()
> ----------------------------------------------------------------------------------------
i don't know if i understand this correctly, but i think i cannot use 
this approach. i need to update the plot several times during the script 
(showing progress of an iterative procedure) - but pylab.show() causes 
the program to halt (until the window is closed).
why is it actually not possible to do something like the following piece 
of code?
ioff()
plot commands
draw()
ion()
best,
lubos
-- 
Lubos _@_"
http://www.lubos.vrbka.net

Hi lubos,
you can avoid (auto-)rescaling in matplotlib:
-------------------------------------------------------------------------------------------------------
import pylab
ax = pylab.subplot(111, autoscale_on=False)
# or for an already existing axes instance 'ax' : ax.set_autoscale_on(False)
--------------------------------------------------------------------------------------------------------
If you want to plot in background you have to skip interactive mode (up to my 
knowledge). If you nevertheless would like to change the results you can use 
pylab.show() as last line in your script and change you data via 
event-control - something like:
--------------------------------------------------------------------------------------
def function(event):
 if event.key == "c":
 pylab.cla()
 elif event.key == "u":
 # update the data
 pass
pylab.connect("key_press_event", function)
pylab.show()
----------------------------------------------------------------------------------------
best regards 
Matthias
On Monday 07 July 2008 14:57:30 Lubos Vrbka wrote:
> hi guys,
>
> is it somehow possible to force matplotlib (pylab) not to rescale the
> axes while adding some data to an existing plot? currently i have to do
> in a cycle (simplified example):
> for (all data):
> p_U_ij.append(pylab.plot(r, data)
> pylab.xlim((0, 10))
> pylab.ylim((-5,10))
>
> because after pylab.plot the plot axes are rescaled according to the
> data read in. i'd prefer setting it beforehand (with xlim, ylim) and
> then to do only pylab.plot in the cycle:
>
> pylab.xlim((0, 10))
> pylam.ylim((-5, 10))
> for (all data):
> p_U_ij.append(pylab.plot(r, data)
>
> is it somehow possible? even better would be to do the plotting in the
> background (not showing the window until the plotting is completely
> finished) - but i wasn't succesful in doing that. i'm using interactive
> mode because after creation of all plots using the code above, i'm
> updating the graphics during the calculation...
>
> thanks for any hints!
>
> best,
> lubos

hi guys,
is it somehow possible to force matplotlib (pylab) not to rescale the 
axes while adding some data to an existing plot? currently i have to do 
in a cycle (simplified example):
for (all data):
 p_U_ij.append(pylab.plot(r, data)
 pylab.xlim((0, 10))
 pylab.ylim((-5,10))
because after pylab.plot the plot axes are rescaled according to the 
data read in. i'd prefer setting it beforehand (with xlim, ylim) and 
then to do only pylab.plot in the cycle:
pylab.xlim((0, 10))
pylam.ylim((-5, 10))
for (all data):
 p_U_ij.append(pylab.plot(r, data)
is it somehow possible? even better would be to do the plotting in the 
background (not showing the window until the plotting is completely 
finished) - but i wasn't succesful in doing that. i'm using interactive 
mode because after creation of all plots using the code above, i'm 
updating the graphics during the calculation...
thanks for any hints!
best,
lubos
-- 
Lubos _@_"
http://www.lubos.vrbka.net

Hello,
I've recently used the toolbar from wxAgg backend:
from matplotlib.backends.backend_wx import NavigationToolbar2Wx
 
I've got a problem when trying to freeze my app now because I get this
message when trying to invoke the toolbar:
 
Traceback (most recent call last):
 File "CommandPanel.pyo", line 80, in OnOpenFile
 File "AnalystPanel.pyo", line 33, in addPanel
 File "Filter.pyo", line 50, in createWidget
 File "A1Filter.pyo", line 70, in fillWidget
 File "matplotlib\backends\backend_wx.pyo", line 1548, in __init__
 File "matplotlib\backend_bases.pyo", line 1524, in __init__
 File "matplotlib\backends\backend_wx.pyo", line 1570, in _init_toolbar
 File "matplotlib\backends\backend_wx.pyo", line 1405, in _load_bitmap
IOError: Could not find bitmap file "mpl-data\images\home.png"; dying
 
It is really strange because I've put this in my setup.py:
import matplotlib
data_files = matplotlib.get_py2exe_datafiles()
 
So there is a directory mpl-data/images so should work.
(other files are well found like fonts etc.)
Any guys has had this issue? (Matplotlib 0.98.1)
 
Laurent
 

Eric Firing wrote:
> Robert Cimrman wrote:
>> Eric Firing wrote:
>>> I'm not sure if this is addressing your situation, but the simplest 
>>> way to adjust all font sizes is to use the rcParams dictionary, 
>>> either directly or via the matplotlibrc file. If the default font 
>>> sizes for various items are specified using "medium", "large", etc, 
>>> instead of with numerical values in points, then everything can be 
>>> scaled by changing the single value, font.size, which is the point 
>>> size corresponding to "medium".
>>
>> Yes, this certainly works, but only for future plots, no? Or it works 
>> also if a figure already exists and I want to play with the sizes to 
>> get something that looks nice?
> 
> You are correct, it is for future plots, not for interactive 
> experimentation with font sizes. An alternative, though, is to make a 
> very simple script with a test plot using rcParams, run that repeatedly 
> as needed to tune the values, and then use those values when making the 
> plots you want to keep.
Yep. That, or accessing the object properties specific for a given 
figure, as posted in my first message. I am by no means saying that the 
rcParams way is not sufficient, I just wanted to elaborate a bit on the 
findobj idea, as an alternative...
Thanks for your feedback,
r.