matplotlib-users Mailing List for matplotlib

John Hunter wrote:
>>>>>> "Peter" == Peter Groszkowski <pgr...@ge...> writes:
>>>>>
>
> Peter> I use Hardy's multiquadric interpolation to to do the math,
> Peter> then use imshow (or pcolor) to make a surface map. I only
> Peter> have data for the 120 points (where the circle are - those
> Peter> are actuators), and interpolate the rest.
>
> Peter> If people are interested, I can clean up the code a little
> Peter> and post it.
>
> This sounds pretty close to matlab's griddata function. 
Yup. That's the functionality I needed. As it says in MATLAB docstrig 
below, GRIDDATA uses Delaunay triangulation however.
> It would be
> very nice to have this in matplotlib.mlab, perhaps as a wrapper to
> some core scipy functionality, which could be conditionally imported.
> What requirements does your code have -- pure python, extension code,
> scipy, numarray?
>
The interpolating is done all in python with the use of Numeric (this is 
what I have been using, and what my matplotlib installation uses - maybe 
will upgrade to numarray one of these days). Performance wise, It's not 
very practical for a very large number of points N as it has to solve a 
NxN system (my N=120 and takes ~2.3seconds on a P4 3.2Ghz with 2GB ram - 
cant remember how long MATLAB's griddata took). Maybe numarray would be 
faster?!
The drawing of the mirror, actuators, etc is done using matplotlibs 
imshow(), plot() and fill() - all very straight forward.
I will post the code in the next few days when I have a minute to clean 
it up a litte.
Cheers,
--
Peter Groszkowski Gemini Observatory
Tel: +1 808 9742509 670 N. A'ohoku Place
Fax: +1 808 9359235 Hilo, Hawai'i 96720, USA
> Here is the matlab docstring, FYI
>
> GRIDDATA Data gridding and surface fitting.
> ZI = GRIDDATA(X,Y,Z,XI,YI) fits a surface of the form Z = F(X,Y)
> to the data in the (usually) nonuniformly-spaced vectors (X,Y,Z)
> GRIDDATA interpolates this surface at the points specified by
> (XI,YI) to produce ZI. The surface always goes through the data
> points. XI and YI are usually a uniform grid (as produced by
> MESHGRID) and is where GRIDDATA gets its name.
>
> XI can be a row vector, in which case it specifies a matrix with
> constant columns. Similarly, YI can be a column vector and it
> specifies a matrix with constant rows.
>
> [XI,YI,ZI] = GRIDDATA(X,Y,Z,XI,YI) also returns the XI and YI
> formed this way (the results of [XI,YI] = MESHGRID(XI,YI)).
>
> [...] = GRIDDATA(...,'method') where 'method' is one of
> 'linear' - Triangle-based linear interpolation (default).
> 'cubic' - Triangle-based cubic interpolation.
> 'nearest' - Nearest neighbor interpolation.
> 'v4' - MATLAB 4 griddata method.
> defines the type of surface fit to the data. The 'cubic' and 'v4'
> methods produce smooth surfaces while 'linear' and 'nearest' have
> discontinuities in the first and zero-th derivative respectively. All
> the methods except 'v4' are based on a Delaunay triangulation of the
> data.
>
> See also GRIDDATA3, GRIDDATAN, DELAUNAY, INTERP2, MESHGRID.
>
>
>
>

>>>>> "Matt" == Matt Newville <new...@ca...> writes:
 Matt> For me, this block (run twice for a plot()) typically takes
 Matt> at least 50% of the plot time. Commenting out the
 Matt> tick.draw(renderer) and the following two 'extent' lines
 Matt> roughly doubles the drawing rate (though no grid or ticks
 Matt> are shown). I was surprised by this, but have not tracked it
 Matt> down much beyond this. I'm not using mathtext in the labels
 Matt> and had only standard numerical Tick labels in this example.
 Matt> I don't know if this is applicable to the slowness of the
 Matt> contour plots or error bars or if collections would help
 Matt> here. But it doesn't seem like tick drawing should be the
 Matt> bottleneck. Anyway, this seems like a simple place to test
 Matt> in other situations, and may be a good place to look for
 Matt> possible optimizations.
This is a known bottleneck. Text layout is non-trivial in matplotlib.
Put it this way: you don't get multiline text with arbitrary rotation,
font properties, horizontal, vertical, and multiline alignment for
free. Take a look at matplotlib.text.Text._get_layout.
I do cache the layout information because I've seen this performance
hit on animated demos before. But if your text properties are
changing, caching doesn't help. The cache key is returned by
Text.get_prop_tup.
It is probably worthwhile to run your animation through the profiler
so we can get a better idea of where exactly the problems are. I
think the matrix multiplication that _get_layout uses for rotations is
slow. It would be possible to special case the most common case
(rotation angle = 0) for some speedups, but the code is already fairly
hairy so I've been resisting special casing it.
FYI, the wxagg backend uses string methods to transfer the agg image
to the canvas. tk and gtk use extension code. fltk uses a python
buffer object. I investigated the latter for wxagg but couldn't make
it work. You may want to look into FigureCanvasWxAgg.draw to see if
you can do this image transfer faster, possibly adding some extension
code. If you do go the extension code route, I suggest you try/except
the import on your extension code and fall back on the string method
already in place.
Oh, I added "newville" to the list of CVS developers. Everyone,
welcome Matt, the new wx maintainer!
JDH

John Hunter Wrote:
> >>>>> "Chris" == Chris Barker <Chr...@no...> writes:
> 
> Chris> Perry Greenfield wrote:
> 
> >>> Actually, I believe that the low level contour engine we are
> >>> using supports this. It takes 2-d arrays for both x and y that
> >>> represent the x and y coordinates of the array being contoured
> >>> and generates plotting points based on those x and y
> >>> arrays. These arrays allow for irregular grids.
> 
> Chris> completely irregular? or only orthogonal structured
> Chris> grids. From your description, it sounds like the
> Chris> later. Could it take an unstructured set of (x,y,z) points
> Chris> and contour the z values?
> 
> The latter, I believe. The contouring routine was implemented by
> Nadia Dencheva (CCd on this mail) and is based on a gist routine. You
Yes, the latter. For an unstructured set some other approach would be
needed. Sorry if I misunderstood. I thought what was being discussed
was irregular spacings rather than irregular organization.
Perry

>>>>> "Eric" == Eric Emsellem <ems...@ob...> writes:
 Eric> Hi, 1. slow plot 2. cursor issue 3. key press event !
 Eric> ------- 1/ Here is the piece of code which is quite slow I
 Eric> think. Compared to pgplot this is a factor of more than
 Eric> 10. It does first draw a default plot (0,1 ?) and then
 Eric> overplot on it for each subplot.
 Eric> for this particular case I have 10 subplots. The slices are
 Eric> made of about 10-20 points each only (stored in a 3D array
 Eric> which is 48x5x20 points). I hope this answers the
 Eric> question. Sorry for the ''specifics''.
Plots of this size should be extremely fast - you should be able to
plot arrays 10 times this big with good performance. From your
description "It does first draw a default plot ..and then overplot on
it for each subplot." it sounds like you may have interactive mode
turned on. This would kill your performance in a case like this,
because the entire figure would be redrawn with the update of every
single plotting command. See
http://matplotlib.sourceforge.net/interactive.html and
http://matplotlib.sourceforge.net/faq.html#SHOW .
To definitively determine what mode you are in, run your script with 
 > python simple_plot.py --verbose-helpful
and verify that 'interactive is False'. Fernando Perez's ipython has
support for running scripts from the interactive shell, turning off
interactive mode for the duration of the run, and then restoring it.
If this doesn't solve your problem please
 - post your entire script
 - report the output of verbose-helpful (requires matplotlib 0.64)
 - what is your platform, machine specs, etc?
 - how are you running the script (IDE, from the command prompt, etc)
JDH

>>>>> "Peter" == Peter Groszkowski <pgr...@ge...> writes:
 Peter> I use Hardy's multiquadric interpolation to to do the math,
 Peter> then use imshow (or pcolor) to make a surface map. I only
 Peter> have data for the 120 points (where the circle are - those
 Peter> are actuators), and interpolate the rest.
 Peter> If people are interested, I can clean up the code a little
 Peter> and post it.
This sounds pretty close to matlab's griddata function. It would be
very nice to have this in matplotlib.mlab, perhaps as a wrapper to
some core scipy functionality, which could be conditionally imported.
What requirements does your code have -- pure python, extension code,
scipy, numarray?
Here is the matlab docstring, FYI
 GRIDDATA Data gridding and surface fitting.
 ZI = GRIDDATA(X,Y,Z,XI,YI) fits a surface of the form Z = F(X,Y)
 to the data in the (usually) nonuniformly-spaced vectors (X,Y,Z)
 GRIDDATA interpolates this surface at the points specified by
 (XI,YI) to produce ZI. The surface always goes through the data
 points. XI and YI are usually a uniform grid (as produced by
 MESHGRID) and is where GRIDDATA gets its name.
 
 XI can be a row vector, in which case it specifies a matrix with
 constant columns. Similarly, YI can be a column vector and it
 specifies a matrix with constant rows.
 
 [XI,YI,ZI] = GRIDDATA(X,Y,Z,XI,YI) also returns the XI and YI
 formed this way (the results of [XI,YI] = MESHGRID(XI,YI)).
 
 [...] = GRIDDATA(...,'method') where 'method' is one of
 'linear' - Triangle-based linear interpolation (default).
 'cubic' - Triangle-based cubic interpolation.
 'nearest' - Nearest neighbor interpolation.
 'v4' - MATLAB 4 griddata method.
 defines the type of surface fit to the data. The 'cubic' and 'v4'
 methods produce smooth surfaces while 'linear' and 'nearest' have
 discontinuities in the first and zero-th derivative respectively. All
 the methods except 'v4' are based on a Delaunay triangulation of the
 data.
 
 See also GRIDDATA3, GRIDDATAN, DELAUNAY, INTERP2, MESHGRID.

>>>>> "Chris" == Chris Barker <Chr...@no...> writes:
 Chris> Perry Greenfield wrote:
 >>> Actually, I believe that the low level contour engine we are
 >>> using supports this. It takes 2-d arrays for both x and y that
 >>> represent the x and y coordinates of the array being contoured
 >>> and generates plotting points based on those x and y
 >>> arrays. These arrays allow for irregular grids.
 Chris> completely irregular? or only orthogonal structured
 Chris> grids. From your description, it sounds like the
 Chris> later. Could it take an unstructured set of (x,y,z) points
 Chris> and contour the z values?
The latter, I believe. The contouring routine was implemented by
Nadia Dencheva (CCd on this mail) and is based on a gist routine. You
can read more about the core routine at
http://scipy.net/cgi-bin/viewcvsx.cgi/*checkout*/scipy1/xplt/src/gist/gcntr.c?rev=HEAD&content-type=text/plain.
The contour routines have been checked into CVS. A simple example can
be found in examples/contour_demo.py in CVS. We have some rudimentary
support for labeling (auto-legend and/or brute-force use of the text
command). It would be nice to develop a point and click labeling
widget and/or an auto-labeling routine. Contributors of course always
welcome!
JDH

>>>>> "Humufr" == Humufr <hu...@ya...> writes:
 Humufr> Hello, I have a problem to plot some data.
 Humufr> I use "plot" to plot some data and "scatter" for other. I
 Humufr> obtain a plot whith the point trace with "scatter" are
 Humufr> behind the points from "plot". I tried to change the order
 Humufr> in the script but that change nothing. Do you know how to
 Humufr> do this? (I want use scatter because I want have a
 Humufr> specific size for this points)
I just added the long awaited zorder attribute to the Artist base
class in CVS, originally discussed here
http://sourceforge.net/mailarchive/message.php?msg_id=9363527.
There is a new example examples/zorder_demo.py that shows you how to
set the zorder. I'll include it below.
It will be in the next release, probably early next week
 #!/usr/bin/env python
 """
 The default drawing order for axes is patches, lines, text. This
 order is determined by the zorder attribute. The following default
 are set
 Artist Z-order
 Patch / PatchCollection 1
 Line2D / LineCollection 2
 Text 3
 You can change the order for individual artists by setting the zorder.
 In the fist subplot below, the lines are drawn above the patch
 collection from the scatter, which is the default.
 In the subplot below, the order is reversed
 """
 from pylab import *
 x = rand(20); y = rand(20)
 subplot(211)
 plot(x, y, 'r', lw=3)
 scatter(x,y,s=120)
 subplot(212)
 plot(x, y, 'r', zorder=1, lw=3)
 scatter(x,y,s=120, zorder=2)
 show()

>>>>> "Arnold" == Arnold Moene <arn...@wu...> writes:
 Arnold> Dear all, At the moment I'm heavily using the scatter plot
 Arnold> (great!). But if I want to add a color bar (with the
 Arnold> command colorbar(), directly following the call to
 Arnold> scatter) to explain the meaning of the colors of the
 Arnold> patches, matplotlib (0.64) refuses to make a colorbar with
 Arnold> the following message:
I Arnold, thanks for alerting me to this problem. This was a bug, and
is now fixed in CVS. I should be releasing a new version of
matplotlib next week which has these changes plus more.
JDH

I have a few scripts that call show() multiple times.
(Why? Well I had pedagogical reasons: I like one
graph to come up at a time in class, in the order
I wish, with no other "distractions".)
These scripts work as I wish if run with execfile() from the
(default Python) interpreter prompt. (I.e., the first
figure is displayed, and when I close it the next is
displayed, etc.) If executed from the cmd line however they
fail:
 Fatal Python error: PyEval_RestoreThread: NULL tstate
 abnormal program termination
Can I add something to the scripts so that they behave
as I wish if executed from a cmd line? (Am I wrong to
believe this used to work until recently; say last
version number or so?)
Aside from my wishes, should the script fail in this
fashion (rather than being more gracefully rejected)?
I realize we have been warned against using show()
multiple times ...
Somewhat related:
can I control the order in which figures are displayed
when the show() command is given, or will the highest
numbered figure always display on top?
Thank you,
Alan Isaac
Win 2000, Python 2.3.3, MatPlotLib 0.63