Hello everybody,
we are looking for the best way to plot a waterfall diagram in
Matplotlib. The 2 functions which could be used
to do that are (as far as I have found) imshow and pcolormesh. Here is a
small script that use both to compare the output:
-----------------
from pylab import *
delta = 0.2
x = arange(-3.0, 3.0, delta)
y = arange(-2.0, 2.0, delta)
X, Y = meshgrid(x, y)
Z1 = bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
Z2 = bivariate_normal(X, Y, 1.5, 0.5, 1, 1)
# difference of Gaussians
Z = 10.0 * (Z2 - Z1)
figure(1)
im = imshow(Z,extent=(-3,3,-2,2))
CS = contour(X, -Y, Z, 6,
colors='k', # negative contours will be dashed by default
)
clabel(CS, fontsize=9, inline=1)
title('Using imshow')
figure(2)
im = pcolormesh(X,-Y,Z)
CS = contour(X, -Y, Z, 6,
colors='k', # negative contours will be dashed by default
)
clabel(CS, fontsize=9, inline=1)
title('Using pcolormesh')
show()
---------------------
The problem is that we need some of the flexibility of pcolormesh (which
is able to map the matrix of value on any deformed mesh), while
we would like to use the interpolations available in imshow (which
explain why the imshow version is much "smoother" than the pcolormesh
one).
In fact, what would be needed is not the full flexibility of pacolormesh
(which can map the grid to any kind of shape), we "only" have to deal
with rectangular grids
with irregularly spaced x- and y- graduations.
Is there a drawing function in Matplotlib which would be able to work
with such a rectangular non-uniform grid?
And if not, what about an extension of imshow which would work as this:
im = imshow(Z,x_gridpos=x, y_gridpos=y) #specify explicitely the
position of the grid's node, instead of giving the extend and assuming
uniform spacing.
Longer term, would a pcolormesh accepting interpolation be possible? The
current behavior, averaging the color of the grids node to get a uniform
cell color,
is quite rough except for a large number of cells...And even then, it
soon shows when you zoom in...
The best would be to allow the same interpolations as in imshow (or a
subset of it), and also allows to use interpolation before colormap
lookup (or after),
like in Matlab. Indeed, Matlab allows to finely tune interpolation by
specifying Gouraud (interpolation after color
lookup)/Phong(interpolation before color lookup, i.e. for each pixel).
Phong is usually much better but also more CPU intensive. Phong is
especially when using discrete colormap, producing banded colors
equivalent to countour lines, while Gouraud does not work in those
cases.
Of course, the performance will be impacted by some of those
interpolation options, which would degrade performance in animations for
example.... but I think that having the different options available
would be very useful, it allows to have the highest map quality, or have
a "quick and dirty" map depending on situation (grid spacing, type of
map, animation or not, ...).
Best regards,
Greg.
-------------------------------------------------------------------------
This SF.Net email is sponsored by the Moblin Your Move Developer's challenge
Build the coolest Linux based applications with Moblin SDK & win great prizes
Grand prize is a trip for two to an Open Source event anywhere in the world
http://moblin-contest.org/redirect.php?banner_id=100&url=/
_______________________________________________
Matplotlib-users mailing list
Matplotlib-users@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/matplotlib-users
