matplotlib-users Mailing List for matplotlib

Hi all,
I have a fix for the problem mentioned. In the latest release, subdir
matploblib-0.60.2/matplotlib/matlab.py line 542 there is a bug. It should
read:
cax.set_yticklabels([tickfmt%tick for tick in cticks])
instead of
cax.set_yticklabels(['%1.1f'%tick for tick in cticks])
so as to take advantage of the optional input parameter tickfmt (format
specifier) for the colorbar labels. With this change, the colorbar labels
come out fine and adjust properly according to the input format specifier.
Thanks,
Curtis

>>>>> "Malte" =3D=3D Malte Marquarding <Mal...@cs...> write=
s:
 Malte> Hi, I am trying to use a script interacively. It basically
 Malte> needs to do the following.
 Malte> * do some work * plot() * Ask whether to keep the data
 Malte> plotted or not etc.
 Malte> This should be done (initially) at the command line using
 Malte> raw_read(). I don't want to close the plot window to get
 Malte> back to the prompt. In terms of a GUI this would be easy
 Malte> as the dialog would run in the same thread as the plot
 Malte> window. But interactive.py doesn't seem to be the
 Malte> solution.
The best solution for interactive plots is to use the tkagg backend
with interactive set to True in your rc file. Use a standard python
shell or better yet, ipython. Ie, your rc file should have the
settings
backend : TkAgg # the default backend
interactive : True =20
You can then plot interactively from the shell, and get your prompt
back after each command. Fernando Perez has made some preliminary
extensions for ipython to support interactive use of matplotlib for
TkAgg and may be making an extension for GTKAgg. Very nice for
interactive use. Available from
 http://ipython.scipy.org/
For the 'pylab' extensiosn, save the two files included at the end of
this email to your ~/.ipython dir and start ipython with
 > ipython -p pylab
 Malte> BTW, I am running 0.54.2 as I can't get 0.60.2 to compile
 Malte> under debian stable.
Please build with=20
 > python setup.py build > build.out=20
and post the results to the matplotlib-devel list.
Cheers,
JDH
### begin pylab
# -*- Mode: Shell-Script -*- Not really, but it shows comments correctly
#************************************************************************=
***
# Configuration file for ipython -- ipythonrc format
#
# The format of this file is one of 'key value' lines.
# Lines containing only whitespace at the beginning and then a # are igno=
red
# as comments. But comments can NOT be put on lines with data.
#************************************************************************=
***
# If this file is found in the user's ~/.ipython directory as ipythonrc-p=
ylab,
# it can be loaded by calling passing the '-profile pylab' (or '-p pylab'=
)
# option to IPython.
# This profile load modules which turn IPython into a very capable enviro=
nment
# for numerical work, as compatible with Matlab as possible.
# Load the user's basic configuration
include ipythonrc
# Load all additional matlab-like functionality from Numeric and matplotl=
ib
execfile matplotlib_load.py
### end pylab
### begin matplotlib_load.py
# -*- coding: iso-8859-1 -*-
"""matlab-like functionality based on matplotlib and Numeric's MLab.
Load these modules and configure them for interactive use"""
#************************************************************************=
*****
# Copyright (C) 2004 Fernando P=C3=A9rez. <fp...@co...>
#
# Distributed under the terms of the GNU Lesser General Public License (=
LGPL)
#
# This code is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# The full text of the LGPL is available at:
#
# http://www.gnu.org/copyleft/lesser.html
#************************************************************************=
*****
__author__ =3D 'Fernando P=C3=A9rez. <fp...@co...>'
__license__=3D 'LGPL'
# Set matplotlib in interactive mode with the TkAgg backend
# THESE MUST BE THE FIRST MATPLOTLIB COMMANDS CALLED!
import matplotlib
matplotlib.use('TkAgg')
matplotlib.interactive(True)
# Now we can continue...
# Load these by themselves so that 'help MODULE' works
import matplotlib.matlab as matlab
# MA (MaskedArray) modifies the Numeric printing mechanism so that huge a=
rrays
# are only summarized and not printed (which could freeze the machine for=
 a
# _long_ time).
import MA
# Bring all of the numeric and plotting commands to the toplevel namespac=
e
from IPython.numutils import *
from matplotlib.matlab import *
print """Welcome to pylab, a matlab-like python environment.
 help(Numeric) -> help on NumPy, Python's basic numerical library.
 help(matlab) -> help on matlab compatible commands from matplotlib.
 help(plotting) -> help on plotting commands.
 """
### end matplotlib_load.py

>>>>> "Vineet" == Vineet Jain <vi...@al...> writes:
 Vineet> 1. I added the following at the end of the script just
 Vineet> before show savefig("filename")
 Vineet> It works however the intereactive mode still comes up. How
 Vineet> can I generate the image file without having the
 Vineet> interactive window come up.
Hi Vineet,
This is because you are using the TkAgg backend. This is the default
backend for win32 users. You set the default backend in your
.matplotlibrc file, which is located in
C:\python23\share\matplotlib\.matplotlibrc for a standard win32
install. For pure image generation, you probably want to choose Agg
as the default backend. There are a number of ways of setting the
backend at runtime, as described at
http://matplotlib.sourceforge.net/backends.html
 Vineet> 2. figure(1, facecolor=figBG) What is this used for? Is it
 Vineet> for the interactive charting? I can still generate charts
 Vineet> to file with this commented.
Here is a little background. You can use the functions figure,
subplot, and axes to explicitly control this figure and axes creation.
If you don't use them, defaults will be issued for you. Let's take a
look at what happens under the hood when you issue the commands
 >>> from matplotlib.matlab import *
 >>> plot([1,2,3])
When plot is called, the matlab interface makes a call to gca() "get
current axes" to get a reference to the current axes. gca in turn,
makes a call to gcf() to get a reference to the current figure. gcf,
finding that no figure has been created, creates the default figure
with figure() and returns it. gca will then return the current axes
of that figure if it exists, or create the default axes
subplot(111) if it does not. Thus the code above is equivalent
to
 >>> from matplotlib.matlab import *
 >>> figure()
 >>> subplot(111)
 >>> plot([1,2,3])
The only time you need to manually call figure, subplot and axes are
when 1) you want to manage multiple figures and axes, or 2) you want
to change the default parameters (sizes, locations, colors, etc).
 Vineet> 3. Where and how do you set the overall size of the chart
 Vineet> ( in inches or pixels)
The figsize kwarg to figure sets the figure size in inches. The dpi
specifies the dots per inch. The figure width in pixels is thus the
figsize width component time the dpi. You can set these as kwargs to
the figure command - see
http://matplotlib.sf.net/matplotlib.matlab.html#-figure or by setting
the defaults in your rc file in the section
 ### FIGURE
 figure.figsize : 8, 6 # figure size in inches
 figure.dpi : 80 # figure dots per inch
 figure.facecolor : 0.75 # figure facecolor; 0.75 is scalar gray
 figure.edgecolor : w # figure edgecolor; w is white
Note that the rc allows different defaults for savefig, which are
given by
 savefig.dpi : 100 # figure dots per inch
 savefig.facecolor : w # figure facecolor; 0.75 is scalar gray
 savefig.edgecolor : w # figure edgecolor; w is white
Cheers,
JDH

>>>>> "Darren" == Darren Dale <dd...@co...> writes:
 Darren> Hi everyone, Now that I have become an intermediate python
 Darren> programmer, I want to learn how to build some GUIs. I am
 Darren> trying to decide between WX and GTK, and was hoping to get
 Darren> input from this list specifically.
There is some information here -
http://matplotlib.sourceforge.net/faq.html#WHICHBACKEND
Here's my 2c
Use a *Agg backend, either TkAgg, WXAgg or GTKAgg. This way you'll
always be assured of having the most complete feature set. All
produce identical figures since they use Agg.
Of those three, there are tradeoffs.
GTK
 A great choice if your deploying on linux and win32 only. A word of
 caution thought: win32 support is becoming more problematic now that
 dropline gtk runtime installers are no longer supported. OS X is
 more difficult unless your users use fink. Steve Chaplin maintains
 the GTK backend and is very active keeping the code consistent with
 different pygtk releases etc. The application I develop with
 matplotlib uses GTKAgg, so yes, developer support is good. I
 primarily develop this application on linux and deploy on win32 (all
 my users only know windows) and it has been quite successful and
 non-problematic. GTKAgg is also currently the fastest backend for
 dynamic (animated) images.
 
Tk
 A good choice if you want the greatest likelihood of it working
 across all platforms with minimal extra dependencies. Excellent
 support from Todd Miller and stsci. The only two downsides, in my
 opinion, are 1) that the widgets aren't so nice and 2) TkAgg is a
 bit slow (1.5-3x slower than GTKAgg) for dynamic images because the
 transfer from agg to the tk canvas is slow - this is mostly out of
 our control.
WX
 As you noted a very popular platform, native widgets, etc. Can be a
 tough install on OS X and linux, but works great for win32 (eg
 enthought edition). Support is a problem with no active maintainer,
 though I do what I can. If you use WXAgg, support is less of a
 problem since the widget interface is fairly stable. If you need
 dynamic images, this will currently be slower than GTKAgg since I
 use string methods to transfer the agg image buffer to the wx
 canvas, but at some point I would like to write some wx extension
 code for this purpose. A number of people with good knowledge of
 matplotlib internals use wx for application development and I think
 are fairly satisfied.
FLTK
 Gregory Lielens has developed a FLTK backend, though it is not yet
 in CVS. Early reports are that it is quite fast, as we would hope,
 from the name.
JDH
 

>>>>> "Stephen" == Stephen Walton <ste...@cs...> writes:
 Stephen> On Mon, 2004年07月19日 at 10:28, John Hunter wrote:
 >> As for resetting the axes to the original view, redraw would
 >> not have done that. In the next generation toolbar, I might be
 >> able to add a button to support that. It already has a forward
 >> / back button to navigate between previous views.
 Stephen> Er, it does? I don't see them, at least not with either
 Stephen> the default backend on FC1, which I'm guessing is GTK,
 Stephen> nor with the TkAgg one.
Sorry for the confusion - when I sat "it already has...", I'm
referring to the next generation toolbar that is under development in
CVS. Only GTK and GTKAgg have a prototype version of the new toolbar
in CVS. 
For the record, the default backend in the src distributions (*.tar.gz
and *.zip) is GTKAgg. For win32, the default backend in TkAgg.
 Stephen> Incidentally, the on line .matplotlibrc example file
 Stephen> still has the "toolbar" keyword, which is gone, and is
 Stephen> missing the "datapath" one.
Which rc file are you referring to? There is no reference to the
toolbar option in the 0.60.2 release, though it is in CVS and on the
web (should fix that one, though it is listed as experimental). The
datapath was intentionally omitted - it exists for those who want use
it to set the data path but for most users the default is OK. I just
changed this in my dev tree to include a commented out reference to it
to alert users that it is there.
Thanks,
JDH

Hi everyone. Hope you don't mind mail out of the blue,
but I've just discovered matplotlib, and am hoping
to use it to plot some time series data (progress
of our project over time). One thing I can't seem
to find is a way to control the format and content
of the tick labels on the X and Y axes. The data I
have is monthly from 1999 to the present, so I'd like
to set X tick labels to be "1999-Jan", "-Feb", and so
on. I tried following the link in the tutorial to
"figure.html#Axes", but it 404'd, and my experiments
using "set(gca(), 'xticklabels', [...stuff...])" are
not doing what I'd hoped.
Similarly, the Y data runs from -600 to about +24,000
(yes, some months we go backward ;-). Right now,
matplotlib is switching to scientific notation when it
hits 1.000e+04 (10,000). Any hints?
Thanks,
Greg Wilson
Hewlett-Packard=20

On 2004年7月19日, John Hunter wrote:
> >>>>> "Arnd" == Arnd Baecker <arn...@we...> writes:
[...]
> Arnd> 1) I would like to know if there is an equivalent to the
> Arnd> scipy.xplt.mouse command which (in its simplest form) waits
> Arnd> for a mouse click and returns its coordinates:
>
> Arnd> Example: #------------------------------------- from
> Arnd> scipy.xplt import * x=arange(0.0,1.0,0.1) plg(x*x,x)
> Arnd> m=mouse(1,-1,"click with the mouse") print "x,y=",m[0],m[1]
> Arnd> #-------------------------------------
[...]
>
> For some time, we've provided basic cross GUI event handling with the
> canvas.connect method. Todd Miller had the idea to port the gtk
> connect interface to Tk. For example, the demo coords_demo.py runs
> unchanged on TkAgg and GTKAgg. This is only a partial implementation,
> and in CVS I've extended it a bit more. The new method is called
> mpl_connect, and you will be able to do, across GUIs, calls like
>
> def on_move(event):
> # get the x and y coords
> x, y = event.x, event.y
> ...snip...
>
> canvas.mpl_connect('motion_notify_event', on_move)
>
>
> I plan to provide the motion notify, on click, and key press events,
> and provide some extra positional information in the events, namely
> canvas coordinate location and axes coordinate location. The backend
> will handle things like flipy so the script can ignore it. I'm in the
> process of designing a better toolbar and am using this cross-GUI
> event handling to minimize the burden of implementing the toolbar in
> the various backends.
>
> In order to do something like the
>
> m = mouse(1,-1,"click with the mouse")
> print "x,y=",m[0],m[1]
>
> example, it would be necessary to implement some cross gui blocking
> capability, so that the execution of the script is halted until the
> block is removed. I don't see this as a major problem, but will
> require some input from people with experience on the not-GTK GUIs.
> It's probably not be necessary, though, since it's only a few more
> keystrokes to do
>
> def on_click(event): print 'x, y =', event.x, event.y
> canvas.mpl_connect(''button_press_event', on_click)
>
> This should be ready by the 0.61 release.
Excellent - that sounds really good!
Still I think that maybe the variant with blocking is
useful as well: I am having our students in mind
which were quite happy and sucessfull with scipy.xplt
(in particular also those who had no previous programming
experience.) Introducing them to event driven ``design''
already in the second excercise might be burdoning them
too much (but maybe I am wrong).
> BTW, as a wx expert,
> perhaps you have a code snippet I can use which calls the event
> Connect and Disconnect methods directly. I'm currently trying to
> figure this out for the wx implementation of mpl_connect and
> mpl_disconnect.
I am definitively no wx expert - a lot of the stuff I learned
from looking at Chris Barker's and Gordon Williams' code
and the wxPython demo. So I also don't have an example here.
(It only rings a bell that Chris maybe had some discussion
on this on the wxPython mailing list - I think it
was about creating custom events - maybe
there is an example in Chris' FloatCanvas?
Ok, I just had a _quick_ look and at the beginning
of FloatCanvas.py
( http://home.comcast.net/~chrishbarker/FloatCanvas/ )
there are a couple of window.Connect.
Maybe this helps...
Anyway, if you did not succeed by Friday let me know
and I will try to have a look over the week-end.
> Arnd> 2) For one set of applications I would like to be able to
> Arnd> plot several times 1000 points (or more). Optimally would
> Arnd> be to plot one point after another to get a dynamical
> Arnd> impression. In the application I have in mind there would
> Arnd> be no need to store these points (ie zooming is not
> Arnd> necessary) which normally degrades performance. Presently
> Arnd> for me the solution for this type of things is our
> Arnd> PlottingCanvas for wxPython, see
> Arnd> http://www.physik.tu-dresden.de/~baecker/python/plot.html
> Arnd> and there the StandardMap.py example.
>
> There is a lot of interest in making dynamical plotting more
> efficient. Currently, the entire figure is redrawn with each frame
> update, which is clearly not ideal for dynamic figures in which only a
> portion needs to be redrawn. I'm interested in making some changes to
> better support "real time" data acquisition, where the quotes mean
> "fast enough to handle most use cases".
Personally I am a bit sceptic, if it is possible to
cater for all needs (super-fast vs. zooming/redraw of stored data, ...),
sureley not at the same time but maybe a
reasonable comprise is possible ;-).
> My current thought is to support drawing to subsections of the agg
> canvas, eg, so that a single axes, line or patch could be updated
> without updating the entire figure canvas. To support this, each
> object would need to know it's rectangular extent (done), take a
> snapshot of the background canvas before drawing (to be done) and know
> how to render itself to canvas (done). In addition, agg and the
> backends would need to be extended to allow drawing of subregions of
> the canvas, which should be fairly easy. By calling the right
> combination of store_background, draw and erase, you could get much
> faster dynamic plots.
Thinking of the example I have in mind, where not untypically
up to 100 x 10000 points are plotted (or even more)
storing each point as an object + further information
might (presumably will) slow things down and cause memory problems
(that's what occurred for me with Tkinter).
Anyway, in September we have a student who will
set up a couple of examples and then we will see
if things are fast enough (for us ;-)...
> The current implementation (redrawing the entire figure) is pretty
> fast on a fast machine, but needs to be faster.
>
> How do you do this in PlottingCanvas? Do simply add objects to the
> canvas
Yes (with the usual double-buffering)
so for example for a circle we just call
 self.ScreenDC.DrawCircle(x, y, pointsize)
 self.BufferDC.DrawCircle(x, y, pointsize)
and the border color and fill color of the circle are
initialized before and only once for a sequence of successive points.
Also (in the case of wx) it helps a lot if the
drawing context (DC) is only initialized once
for a sequence of successive points.
Nikolai (Hlubek) measured the speed increase to be
 factor 2 for wx.wxClientDC(self)
 factor 10 for wx.wxBufferedDC(wx.wxClientDC(self), self._Buffer)
> and redraw the entire canvas if you need to remove an object,
Well, in the fastest mode of operation we don't
allow for removal of objects/resizing the canvas and things like that...
> or do you support selective erasing and removal of objects?
No. What the PlottingCanvas does provide though
is the possibility to ``move'' an object over
a ``background'' plot - see AnnularBilliard.py
where a ball is moving inside a two-dimensional billiard
(click in the right window to specify the initial condition
and move the slider upwards to increas the speed of
the ball a bit).
In another mode of operation we enable storing
of all data points (with the corresponding speed penalty).
This then allows to zoom in and redraw those data.
Despite some optimizations, plotting with wx
is still not as fast as for example with pgplot
(wherever the bottlenecks are ;-).
Best,
Arnd

On 2004年7月19日, Malte Marquarding wrote:
> I have sarge (with a few unstable bits and pieces)
> It 'shouldn't' be dependent on "unstable".
>
> You can always see what extra libs it wants and decide then if you wnat
> it or not.
>
> Cheers,
> Malte.
Indeed it works without any problems - the only
additional requirement from http://mentors.debian.net/
was python-ttfquery_1.0.0_all.deb
(it also requested
fonttools, python-gd python2.3-xml libgd2-xpm libgd-tools,
all available in testing.)
Many thanks,
Arnd
> Arnd Baecker wrote:
>
> >
> >
> >Before I screw up my installation ;-)
> > - did anyone successfully use these on sarge (debian testing)?
> > - and/or are there deb's available for sarge?
> >
> >Many thanks,
> >
> >Arnd
> >
> >
>
>
>
> -------------------------------------------------------
> This SF.Net email is sponsored by BEA Weblogic Workshop
> FREE Java Enterprise J2EE developer tools!
> Get your free copy of BEA WebLogic Workshop 8.1 today.
> http://ads.osdn.com/?ad_id=4721&alloc_id=10040&op=click
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Hi,
I am trying to use a script interacively. It basically needs to do the 
following.
* do some work
* plot()
* Ask whether to keep the data plotted or not
etc.
This should be done (initially) at the command line using raw_read().
I don't want to close the plot window to get back to the prompt.
In terms of a GUI this would be easy as the dialog would run in the same 
thread as the plot window.
But interactive.py doesn't seem to be the solution.
BTW, I am running 0.54.2 as I can't get 0.60.2 to compile under debian 
stable.

1. I added the following at the end of the script just before show
savefig("filename")
It works however the intereactive mode still comes up. How can I generate
the image file without having the interactive window come up.
2. figure(1, facecolor=figBG)
What is this used for? Is it for the interactive charting? I can still
generate charts to file with this commented.
3. Where and how do you set the overall size of the chart ( in inches or
pixels)
Thanks,
Vineet