matplotlib-devel Mailing List for matplotlib

>>>>> "Alex" == Alex Gontmakher <gs...@cs...> writes:
 Alex> Currently implemented for PostScript backend only - the rest
 Alex> ignore the command. I tried to make it in the same style as
 Alex> the rest of Matplotlib iface: 'x' does bidiagonal hatching
 Alex> '/' does diagonal, '-' does horizontal, and so on.
 Alex> Repeating the hatching symbol increases the density of
 Alex> hatching.
 Alex> Attached is the diff for version 0.85. Is there a chance
 Alex> for this thing to be included into the source?
Thanks Alex -- I'm happy to include this but am having trouble
applying your patch. Could you get a fresh CVS checkout, reapply your
changes, and do a 'cvs diff'?
Thanks,
JDH
 Alex> Only in matplotlib-0.85.new: build diff -r
 Alex> matplotlib-0.85/lib/matplotlib/backend_bases.py
 Alex> matplotlib-0.85.new/lib/matplotlib/backend_bases.py 389a390
 >> self._hatch = None
 Alex> 401a403
 >> self._hatch = gc._hatch
 Alex> 549c551,558 < ---
 >> def set_hatch(self, hatch): """ Sets the hatch style for
 >> filling """ self._hatch = hatch def get_hatch(self): return
 >> self._hatch
 Alex> Only in matplotlib-0.85.new/lib/matplotlib:
 Alex> backend_bases.py~ diff -r
 Alex> matplotlib-0.85/lib/matplotlib/backends/backend_ps.py
 Alex> matplotlib-0.85.new/lib/matplotlib/backends/backend_ps.py
 Alex> 148a149,150
 >> self.hatch = None self.hatch_func = False
 Alex> 195a198,260
 >> def set_hatch(self, hatch): """ hatch can be one of: / -
 >> diagonal hatching \ - back diagonal | - vertical - - horizontal
 >> # - crossed X - crossed diagonal letters can be combined, in
 >> which case all the specified hatchings are done if same letter
 >> repeats, it increases the density of hatching in that direction
 >> """ hatches = {'horiz':0, 'vert':0, 'diag1':0, 'diag2':0}
 >> 
 >> for letter in hatch: if (letter == '/'): hatches['diag2'] += 1
 >> elif (letter == '\\'): hatches['diag1'] += 1 elif (letter ==
 >> '|'): hatches['vert'] += 1 elif (letter == '-'):
 >> hatches['horiz'] += 1 elif (letter == '+'): hatches['horiz'] +=
 >> 1 hatches['vert'] += 1 elif (letter == 'x'): hatches['diag1']
 >> += 1 hatches['diag2'] += 1
 >> 
 >> def do_hatch(angle, density): if (density == 0): return "" orig
 >> = """ gsave eoclip %s rotate 0.0 0.0 0.0 0.0 setrgbcolor 0
 >> setlinewidth /gap %d def pathbbox /b exch def /r exch def /t
 >> exch def /l exch def l cvi gap idiv gap mul gap r cvi gap idiv
 >> gap mul {t moveto 0 b t sub rlineto} for stroke grestore """ %
 >> (angle, 12/density) return """ gsave eoclip %s rotate 0.0 0.0
 >> 0.0 0.0 setrgbcolor 0 setlinewidth /hatchgap %d def pathbbox
 >> /hatchb exch def /hatchr exch def /hatcht exch def /hatchl exch
 >> def hatchl cvi hatchgap idiv hatchgap mul hatchgap hatchr cvi
 >> hatchgap idiv hatchgap mul {hatcht moveto 0 hatchb hatcht sub
 >> rlineto} for stroke grestore """ % (angle, 12/density)
 >> self._pswriter.write("gsave\n")
 >> self._pswriter.write(do_hatch(0, hatches['horiz']))
 >> self._pswriter.write(do_hatch(90, hatches['vert']))
 >> self._pswriter.write(do_hatch(45, hatches['diag1']))
 >> self._pswriter.write(do_hatch(-45, hatches['diag2']))
 >> self._pswriter.write("grestore\n")
 >> 
 Alex> 771,772c836,837 < write(ps.strip()) < write("\n") ---
 >> write(ps.strip()) write("\n")
 Alex> 778a844,847
 >> hatch = gc.get_hatch() if (hatch): self.set_hatch(hatch)
 >> 
 Alex> Only in matplotlib-0.85.new/lib/matplotlib/backends:
 Alex> backend_ps.py~ diff -r
 Alex> matplotlib-0.85/lib/matplotlib/patches.py
 Alex> matplotlib-0.85.new/lib/matplotlib/patches.py 30a31
 >> hatch = None,
 Alex> 44a46
 >> self.hatch = hatch
 Alex> 53a56
 >> self.set_hatch(other.get_hatch())
 Alex> 114a118,128
 >> def set_hatch(self, h): """ Set the hatching pattern
 >> 
 >> ACCEPTS: string (can be one of "|,/,,円x,+", or combinations
 >> thereof") """ self.hatch = h
 >> 
 >> def get_hatch(self): 'return the current hatch pattern' return
 >> self.hatch
 Alex> 127a142,143
 >> if self.hatch != None: gc.set_hatch(self.hatch)
 Alex> Only in matplotlib-0.85.new/lib/matplotlib: patches.py~ Only
 Alex> in matplotlib-0.85.new: setupext.pyc Only in
 Alex> matplotlib-0.85/src: _na_backend_agg.cpp Only in
 Alex> matplotlib-0.85/src: _na_backend_gdk.c Only in
 Alex> matplotlib-0.85/src: _na_cntr.c Only in matplotlib-0.85/src:
 Alex> _na_image.cpp Only in matplotlib-0.85/src:
 Alex> _na_transforms.cpp Only in matplotlib-0.85/src:
 Alex> _nc_backend_agg.cpp Only in matplotlib-0.85/src:
 Alex> _nc_backend_gdk.c Only in matplotlib-0.85/src: _nc_cntr.c
 Alex> Only in matplotlib-0.85/src: _nc_image.cpp Only in
 Alex> matplotlib-0.85/src: _nc_transforms.cpp

>>>>> "Rob" == Rob McMullen <rob...@gm...> writes:
 Rob> Oh, and I didn't say so in the patch itself, but I'm happy to
 Rob> donate the patch to matplotlib under the default matplotlib
 Rob> license.
Great Rob -- thanks. This was the first I've heard of EMF but I read
through your web page and it looks interesting. I don't have time
right now to install the prereqs and test, but you may want to grab
the latest CVS mpl and make sure everything is working for you.
You may also want to write a blurb for the release notes, and add a
patch against the matplotlib CVS htdocs and or users guide to explain
EMF and provide pointers to your web site on the mpl site.
Checking in matplotlib/backends/backend_emf.py;
/cvsroot/matplotlib/matplotlib/lib/matplotlib/backends/backend_emf.py,v <-- backend_emf.py
initial revision: 1.1
done
Thanks again,
JDH

John,
> I am weakly inclined to support all three rather than one or the other
> in the interim, if only because it is a nice way to profile scipy core
> versus the old Numeric and because it may be easier to debug what is
> going on when we hit user level snags. But since this is only an
> interim solution I'm not strongly wedded to any approach.
I agree. I think the testing and transition will be easier if all three 
are supported for now. I don't see much downside to doing this.
Eric

>>>>> "John" == John Hunter <jdh...@ac...> writes:
 John> I just committed Daishi's patch to CVS, with Fernando's
 John> modification to catch the new scipy versus old scipy.
Seems there is a problem with "resize"
peds-pc311:~/python/projects/matplotlib/examples> python contour_demo.py --Numeric --verbose-helpful
matplotlib data path /usr/share/matplotlib
$HOME=/home/jdhunter
CONFIGDIR=/home/jdhunter/.matplotlib
loaded rc file /home/jdhunter/.matplotlib/matplotlibrc
matplotlib version 0.85.1.cvs
verbose.level helpful
interactive is False
platform is linux2
numerix Numeric 24.0b2
font search path ['/usr/share/matplotlib']
loaded ttfcache file /home/jdhunter/.matplotlib/ttffont.cache
backend GTKAgg version 2.6.1
Traceback (most recent call last):
 File "contour_demo.py", line 29, in ?
 clabel(CS, inline=1, fontsize=10)
 File "/home/jdhunter/debs/matplotlib/usr//lib/python2.4/site-packages/matplotlib/pylab.py", line 1783, in clabel
 ret = gca().clabel(*args, **kwargs)
 File "/usr/lib/python2.4/site-packages/matplotlib/axes.py", line 1264, in clabel
 return CS.clabel(*args, **kwargs)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 121, in clabel
 self.labels(inline)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 338, in labels
 x,y, rotation, ind = self.locate_label(slc, lw)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 291, in locate_label
 XX = resize(array(linecontour)[:,0],(xsize, ysize))
 File "/usr/lib/python2.4/site-packages/matplotlib/numerix/__init__.py", line 87, in resize
 return a.resize(shape)
ValueError: resize only works on contiguous arrays
and for numarray
peds-pc311:~/python/projects/matplotlib/examples> python contour_demo.py --numarray --verbose-helpful
matplotlib data path /usr/share/matplotlib
$HOME=/home/jdhunter
CONFIGDIR=/home/jdhunter/.matplotlib
loaded rc file /home/jdhunter/.matplotlib/matplotlibrc
matplotlib version 0.85.1.cvs
verbose.level helpful
interactive is False
platform is linux2
numerix numarray 1.3.3
font search path ['/usr/share/matplotlib']
loaded ttfcache file /home/jdhunter/.matplotlib/ttffont.cache
backend GTKAgg version 2.6.1
Traceback (most recent call last):
 File "contour_demo.py", line 29, in ?
 clabel(CS, inline=1, fontsize=10)
 File "/home/jdhunter/debs/matplotlib/usr//lib/python2.4/site-packages/matplotlib/pylab.py", line 1783, in clabel
 ret = gca().clabel(*args, **kwargs)
 File "/usr/lib/python2.4/site-packages/matplotlib/axes.py", line 1264, in clabel
 return CS.clabel(*args, **kwargs)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 121, in clabel
 self.labels(inline)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 338, in labels
 x,y, rotation, ind = self.locate_label(slc, lw)
 File "/usr/lib/python2.4/site-packages/matplotlib/contour.py", line 291, in locate_label
 XX = resize(array(linecontour)[:,0],(xsize, ysize))
 File "/usr/lib/python2.4/site-packages/matplotlib/numerix/__init__.py", line 87, in resize
 return a.resize(shape)
 File "/home/jdhunter/debs/numarray/usr/lib/python2.4/site-packages/numarray/generic.py", line 891, in resize
 self.ravel()
 File "/home/jdhunter/debs/numarray/usr/lib/python2.4/site-packages/numarray/generic.py", line 922, in ravel
 self.setshape((self.nelements(),))
 File "/home/jdhunter/debs/numarray/usr/lib/python2.4/site-packages/numarray/generic.py", line 680, in setshape
 raise TypeError("Can't reshape non-contiguous numarray")
TypeError: Can't reshape non-contiguous numarray
Ditto on finance_demo....
JDH

I just committed Daishi's patch to CVS, with Fernando's modification
to catch the new scipy versus old scipy.
Those of you with semi-pristine boxes might want to try it out to make
sure it is working.
One issue: the patch builds either numarray (if found) and
scipy|numeric (if found but not both) with precedence given to
numeric. Shouldn't it be the other way around, with precedence to
scipy_core over Numeric since if someone has the new scipy presumably
it's an upgrade and should take precedence.
I am weakly inclined to support all three rather than one or the other
in the interim, if only because it is a nice way to profile scipy core
versus the old Numeric and because it may be easier to debug what is
going on when we hit user level snags. But since this is only an
interim solution I'm not strongly wedded to any approach.
Please test and report.
Checking in lib/matplotlib/numerix/__init__.py;
/cvsroot/matplotlib/matplotlib/lib/matplotlib/numerix/__init__.py,v <-- __init__.py
new revision: 1.6; previous revision: 1.5
or later.
JDH

>>>>> "James" == James Casbon <ca...@gm...> writes:
 James> Hi, The logic for displaying a figure on the interactive
 James> backends (eg qt) seems a little strange to me. I imagine
 James> that normally the screen is used as a preview for a figure
 James> that is going to be output on paper, or to png or some
 James> permanent store. Therefore, the interactive output should
 James> resemble the permanent output as much as possible.
 James> Now, when using the QtAgg backend (sorry no time to play
 James> with other backends) setting the figure height or width has
 James> no effect on the size of the figure displayed with show().
 James> It always comes out at 600x400.
Typically you want saved images to be at a higher resolution than the
one on the screen, since most screens are less than 1500x1500 and
often you want a higher resolution setting. That is why the savefig
command takes a dpi parameter, which default to the settin in your rc
file. You could make the screen dpi and the savefig dpi the same in
rc if you want.
I find that when I resize a figure in the GUI window, the aspect ratio
*is* preserved when I save, so the suggestion above should suffice for
you.
JDH

I'm having some trouble with unpickled scipy arrays. The issue shows up when I 
try to plot in matplotlib, but I think it is a scipy problem.
import pickle
import scipy
import pylab
a = scipy.arange(10)
pickle.dump(a,file('temp.p','w'))
b = pickle.load(file('temp.p'))
print type(b), type(scipy.array(b))
pylab.plot(scipy.array(b)) # no error here
pylab.plot(b) # error here
Traceback (most recent call last):
 File "pickletest.py", line 8, in ?
 pylab.plot(b)
 File "/usr/lib64/python2.4/site-packages/matplotlib/pylab.py", line 2055, in 
plot
 ret = gca().plot(*args, **kwargs)
 File "/usr/lib64/python2.4/site-packages/matplotlib/axes.py", line 2636, in 
plot
 for line in self._get_lines(*args, **kwargs):
 File "/usr/lib64/python2.4/site-packages/matplotlib/axes.py", line 267, in 
_grab_next_args
 yield self._plot_1_arg(remaining[0], **kwargs)
 File "/usr/lib64/python2.4/site-packages/matplotlib/axes.py", line 189, in 
_plot_1_arg
 markerfacecolor=color,
 File "/usr/lib64/python2.4/site-packages/matplotlib/lines.py", line 209, in 
__init__
 self.set_data(xdata, ydata)
 File "/usr/lib64/python2.4/site-packages/matplotlib/lines.py", line 265, in 
set_data
 y = ma.ravel(y)
 File "/usr/lib64/python2.4/site-packages/Numeric/MA/MA.py", line 1810, in 
ravel
 d = Numeric.ravel(filled(a))
 File "/usr/lib64/python2.4/site-packages/Numeric/MA/MA.py", line 222, in 
filled
 return Numeric.array(a)
ValueError: cannot handle misaligned or not writeable arrays.
Darren

Eric Firing wrote:
> John,
>
> I have committed to CVS a set of changes that I think will address 
> recent requests by Jordan and Gerald, and will be of more general use 
> as well. From the CHANGELOG:
>
> 2005年11月27日 Multiple changes in cm.py, colors.py, figure.py, image.py,
> contour.py, contour_demo.py; new _cm.py, 
> examples/image_masked.py.
> 1) Separated the color table data from cm.py out into
> a new file, _cm.py, to make it easier to find the actual
> code in cm.py and to add new colormaps. Also added
> some line breaks to the color data dictionaries. Everything
> from _cm.py is imported by cm.py, so the split should be
> transparent.
> 2) Enabled automatic generation of a colormap from
> a list of colors in contour; see modified
> examples/contour_demo.py.
> 3) Support for imshow of a masked array, with the
> ability to specify colors (or no color at all) for
> masked regions, and for regions that are above or
> below the normally mapped region. See
> examples/image_masked.py.
> 4) In support of the above, added two new classes,
> ListedColormap, and no_norm, to colors.py, and modified
> the Colormap class to include common functionality. Added
> a clip kwarg to the normalize class. Reworked color
> handling in contour.py, especially in the ContourLabeller
> mixin.
>
> With one very subtle exception, I don't think any default behaviors 
> have been changed, so the changes should be entirely non-disruptive.
>
> That one exception is that in the original color mapping scheme, the 
> last color was essentially never used. Consider an extreme case: a 
> colormap with two entries. Suppose the image data ranged from 0 to 1. 
> All values except exactly 1.0 were mapped to the first color, and only 
> that upper limit value was mapped to the second color. As I have 
> changed colors.py, values from 0.0 up to 0.5 will get the first color, 
> and values from 0.5 through 1.0 will get the second. I think this is 
> what a user would expect, and the only reason it hasn't mattered is 
> that with 256 colors in a continuous range, one can't see the difference.
>
> The request from Jordan that is addressed here is the desire for 
> precise color control in filled contouring. Now one can specify a 
> list of colors in the "colors" kwarg, and they will be used to 
> generate a colormap, which will then be used by colorbar. This is 
> shown in a second plot added to examples/contourf_demo.py. (Jordan 
> suggested a more extensive refactoring, which may indeed be a good 
> idea; but I wanted to make these simpler changes before trying to 
> think about anything more drastic.)
>
> The request from Gerald was for easy handling of masked arrays in 
> imshow. It was in the context of basemap, which I have not tested 
> yet; but at least for pylab.imshow, the situation is now easy to 
> handle. If changes to basemap are needed, they should be very simple, 
> and I can do them later as needed. I think that the changes to 
> colormapping that I made to support this will be useful much more 
> widely, but I have made no attempt to track down the places where 
> changes will be in order. I may make additional changes to contour, 
> and I know I will need to change colorbar to fully support this. I 
> think colorbar needs some more refactoring anyway, but I can't do it 
> immediately, and I did not want to delay getting the other changes out 
> for testing and, hopefully, productive use.
>
> Eric
Eric: Tried the masked imshow with basemap and it seems to work fine 
(without any modifications to basemap). I've added a new example, 
plotmap_masked.py, that shows how to use mask out the oceans on a map 
using imshow and pcolor. Thanks again!
-Jeff
-- 
Jeffrey S. Whitaker Phone : (303)497-6313
Meteorologist FAX : (303)497-6449
NOAA/OAR/PSD R/PSD1 Email : Jef...@no...
325 Broadway Office : Skaggs Research Cntr 1D-124
Boulder, CO, USA 80303-3328 Web : http://tinyurl.com/5telg

Using the 0.85 package for ubuntu, I get the following error when I run my
application:
 
?
 from matplotlib.dates import date2num, num2date, DateFormatter,
IndexDateFormatter
 File
"/home/jdhunter/debs/matplotlib/usr/lib/python2.4/site-packages/matplotlib/d
ates.py", line 88, in ?
ImportError: No module named pytz
 
Any ideas?
 
Thanks,
 
VJ

Eric,
I played with the changes you've made and the results look great!
Thanks,
Gerald
Eric Firing wrote:
> John,
> 
> I have committed to CVS a set of changes that I think will address 
> recent requests by Jordan and Gerald, and will be of more general use as 
> well. From the CHANGELOG:
> 
> 2005年11月27日 Multiple changes in cm.py, colors.py, figure.py, image.py,
> contour.py, contour_demo.py; new _cm.py, 
> examples/image_masked.py.
> 1) Separated the color table data from cm.py out into
> a new file, _cm.py, to make it easier to find the actual
> code in cm.py and to add new colormaps. Also added
> some line breaks to the color data dictionaries. Everything
> from _cm.py is imported by cm.py, so the split should be
> transparent.
> 2) Enabled automatic generation of a colormap from
> a list of colors in contour; see modified
> examples/contour_demo.py.
> 3) Support for imshow of a masked array, with the
> ability to specify colors (or no color at all) for
> masked regions, and for regions that are above or
> below the normally mapped region. See
> examples/image_masked.py.
> 4) In support of the above, added two new classes,
> ListedColormap, and no_norm, to colors.py, and modified
> the Colormap class to include common functionality. Added
> a clip kwarg to the normalize class. Reworked color
> handling in contour.py, especially in the ContourLabeller
> mixin.
> 
> With one very subtle exception, I don't think any default behaviors have 
> been changed, so the changes should be entirely non-disruptive.
> 
> That one exception is that in the original color mapping scheme, the 
> last color was essentially never used. Consider an extreme case: a 
> colormap with two entries. Suppose the image data ranged from 0 to 1. 
> All values except exactly 1.0 were mapped to the first color, and only 
> that upper limit value was mapped to the second color. As I have 
> changed colors.py, values from 0.0 up to 0.5 will get the first color, 
> and values from 0.5 through 1.0 will get the second. I think this is 
> what a user would expect, and the only reason it hasn't mattered is that 
> with 256 colors in a continuous range, one can't see the difference.
> 
> The request from Jordan that is addressed here is the desire for precise 
> color control in filled contouring. Now one can specify a list of 
> colors in the "colors" kwarg, and they will be used to generate a 
> colormap, which will then be used by colorbar. This is shown in a 
> second plot added to examples/contourf_demo.py. (Jordan suggested a 
> more extensive refactoring, which may indeed be a good idea; but I 
> wanted to make these simpler changes before trying to think about 
> anything more drastic.)
> 
> The request from Gerald was for easy handling of masked arrays in 
> imshow. It was in the context of basemap, which I have not tested yet; 
> but at least for pylab.imshow, the situation is now easy to handle. If 
> changes to basemap are needed, they should be very simple, and I can do 
> them later as needed. I think that the changes to colormapping that I 
> made to support this will be useful much more widely, but I have made no 
> attempt to track down the places where changes will be in order. I may 
> make additional changes to contour, and I know I will need to change 
> colorbar to fully support this. I think colorbar needs some more 
> refactoring anyway, but I can't do it immediately, and I did not want to 
> delay getting the other changes out for testing and, hopefully, 
> productive use.
> 
> Eric
> 
> 
> 

I finally tracked down another flipy type bug. The TkAgg blitting
should be rock solid now.
Thanks,
 Charlie
On 11/22/05, Charlie Moad <cw...@gm...> wrote:
> Arg! One petty thing after another. Here is a simple script
> demonstrating that the last row does not render the SpanSelector, yet
> the callback works fine???
>
> ------------------------------------
> import matplotlib
> from matplotlib.widgets import SpanSelector
> matplotlib.use('TkAgg')
> from pylab import *
>
> s =3D 3
> axs =3D [subplot(s,s,i) for i in xrange(1,s**2+1)]
> def onselect(x, y): print x, y
> [SpanSelector(a, onselect, 'vertical', useblit=3DTrue) for a in axs]
> show()
> ------------------------------------
>
> Any clues as to where to look for this bug? Sorry to be a hassle, but
> I need this specifically to embed in a Tk only app.
>
> Thanks,
> Charlie
>
> On 11/19/05, John Hunter <jdh...@ac...> wrote:
> > >>>>> "Charlie" =3D=3D Charlie Moad <cw...@gm...> writes:
> >
> > Charlie> Awesome, thanks! Out of curiousity... did you figure
> > Charlie> this out visually or by comparing with something?
> >
> > Let's just say I've encountered the flipy bug before :-)
> >
> > JDH
> >
>

Eric Firing wrote:
> John,
>
> I have committed to CVS a set of changes that I think will address 
> recent requests by Jordan and Gerald, and will be of more general use 
> as well. From the CHANGELOG:
>
> 2005年11月27日 Multiple changes in cm.py, colors.py, figure.py, image.py,
> contour.py, contour_demo.py; new _cm.py, 
> examples/image_masked.py.
> 1) Separated the color table data from cm.py out into
> a new file, _cm.py, to make it easier to find the actual
> code in cm.py and to add new colormaps. Also added
> some line breaks to the color data dictionaries. Everything
> from _cm.py is imported by cm.py, so the split should be
> transparent.
> 2) Enabled automatic generation of a colormap from
> a list of colors in contour; see modified
> examples/contour_demo.py.
> 3) Support for imshow of a masked array, with the
> ability to specify colors (or no color at all) for
> masked regions, and for regions that are above or
> below the normally mapped region. See
> examples/image_masked.py.
> 4) In support of the above, added two new classes,
> ListedColormap, and no_norm, to colors.py, and modified
> the Colormap class to include common functionality. Added
> a clip kwarg to the normalize class. Reworked color
> handling in contour.py, especially in the ContourLabeller
> mixin.
>
> With one very subtle exception, I don't think any default behaviors 
> have been changed, so the changes should be entirely non-disruptive.
>
> That one exception is that in the original color mapping scheme, the 
> last color was essentially never used. Consider an extreme case: a 
> colormap with two entries. Suppose the image data ranged from 0 to 1. 
> All values except exactly 1.0 were mapped to the first color, and only 
> that upper limit value was mapped to the second color. As I have 
> changed colors.py, values from 0.0 up to 0.5 will get the first color, 
> and values from 0.5 through 1.0 will get the second. I think this is 
> what a user would expect, and the only reason it hasn't mattered is 
> that with 256 colors in a continuous range, one can't see the difference.
>
> The request from Jordan that is addressed here is the desire for 
> precise color control in filled contouring. Now one can specify a 
> list of colors in the "colors" kwarg, and they will be used to 
> generate a colormap, which will then be used by colorbar. This is 
> shown in a second plot added to examples/contourf_demo.py. (Jordan 
> suggested a more extensive refactoring, which may indeed be a good 
> idea; but I wanted to make these simpler changes before trying to 
> think about anything more drastic.)
>
> The request from Gerald was for easy handling of masked arrays in 
> imshow. It was in the context of basemap, which I have not tested 
> yet; but at least for pylab.imshow, the situation is now easy to 
> handle. If changes to basemap are needed, they should be very simple, 
> and I can do them later as needed. I think that the changes to 
> colormapping that I made to support this will be useful much more 
> widely, but I have made no attempt to track down the places where 
> changes will be in order. I may make additional changes to contour, 
> and I know I will need to change colorbar to fully support this. I 
> think colorbar needs some more refactoring anyway, but I can't do it 
> immediately, and I did not want to delay getting the other changes out 
> for testing and, hopefully, productive use.
>
> Eric
>
Eric: This is fantastic - thanks! I'll try imshow with masked arrays 
and let you know if there are any problems. Should be very useful for 
projections which have some parts hidden, such as orthographic.
-Jeff
-- 
Jeffrey S. Whitaker Phone : (303)497-6313
Meteorologist FAX : (303)497-6449
NOAA/OAR/PSD R/PSD1 Email : Jef...@no...
325 Broadway Office : Skaggs Research Cntr 1D-124
Boulder, CO, USA 80303-3328 Web : http://tinyurl.com/5telg

John,
I think that the following change, from API_CHANGES, is causing trouble:
 made pos=None the default for tick formatters rather than 0 to
 indicate "not supplied"
The symptom is that running (for example) contour_demo.py from the 
command line with gtkagg backend, I often, but not always, get a blast 
of errors like this:
Traceback (most recent call last):
 File 
"/usr/lib/python2.4/site-packages/matplotlib/backends/backend_gtk.py", 
line 188, in motion_notify_event
 FigureCanvasBase.motion_notify_event(self, x, y)
 File "/usr/lib/python2.4/site-packages/matplotlib/backend_bases.py", 
line 797, in motion_notify_event
 func(event)
 File "/usr/lib/python2.4/site-packages/matplotlib/backend_bases.py", 
line 1085, in mouse_move
 try: s = event.inaxes.format_coord(event.xdata, event.ydata)
 File "/usr/lib/python2.4/site-packages/matplotlib/axes.py", line 612, 
in format_coord
 ys = self.format_ydata(y)
 File "/usr/lib/python2.4/site-packages/matplotlib/axes.py", line 605, 
in format_ydata
 val = func(y)
 File "/usr/lib/python2.4/site-packages/matplotlib/ticker.py", line 
152, in format_data
 return self.__call__(value)
 File "/usr/lib/python2.4/site-packages/matplotlib/ticker.py", line 
178, in __call__
 else: return self.seq[pos]
TypeError: list indices must be integers
pos=None would certainly cause this...but I haven't checked it.
(System is stock Mandriva 2006; mpl is CVS.)
Eric

John,
I have committed to CVS a set of changes that I think will address 
recent requests by Jordan and Gerald, and will be of more general use as 
well. From the CHANGELOG:
2005年11月27日 Multiple changes in cm.py, colors.py, figure.py, image.py,
 contour.py, contour_demo.py; new _cm.py, 
examples/image_masked.py.
 1) Separated the color table data from cm.py out into
 a new file, _cm.py, to make it easier to find the actual
 code in cm.py and to add new colormaps. Also added
 some line breaks to the color data dictionaries. Everything
 from _cm.py is imported by cm.py, so the split should be
 transparent.
 2) Enabled automatic generation of a colormap from
 a list of colors in contour; see modified
 examples/contour_demo.py.
 3) Support for imshow of a masked array, with the
 ability to specify colors (or no color at all) for
 masked regions, and for regions that are above or
 below the normally mapped region. See
 examples/image_masked.py.
 4) In support of the above, added two new classes,
 ListedColormap, and no_norm, to colors.py, and modified
 the Colormap class to include common functionality. Added
 a clip kwarg to the normalize class. Reworked color
 handling in contour.py, especially in the ContourLabeller
 mixin.
With one very subtle exception, I don't think any default behaviors have 
been changed, so the changes should be entirely non-disruptive.
That one exception is that in the original color mapping scheme, the 
last color was essentially never used. Consider an extreme case: a 
colormap with two entries. Suppose the image data ranged from 0 to 1. 
All values except exactly 1.0 were mapped to the first color, and only 
that upper limit value was mapped to the second color. As I have 
changed colors.py, values from 0.0 up to 0.5 will get the first color, 
and values from 0.5 through 1.0 will get the second. I think this is 
what a user would expect, and the only reason it hasn't mattered is that 
with 256 colors in a continuous range, one can't see the difference.
The request from Jordan that is addressed here is the desire for precise 
color control in filled contouring. Now one can specify a list of 
colors in the "colors" kwarg, and they will be used to generate a 
colormap, which will then be used by colorbar. This is shown in a 
second plot added to examples/contourf_demo.py. (Jordan suggested a 
more extensive refactoring, which may indeed be a good idea; but I 
wanted to make these simpler changes before trying to think about 
anything more drastic.)
The request from Gerald was for easy handling of masked arrays in 
imshow. It was in the context of basemap, which I have not tested yet; 
but at least for pylab.imshow, the situation is now easy to handle. If 
changes to basemap are needed, they should be very simple, and I can do 
them later as needed. I think that the changes to colormapping that I 
made to support this will be useful much more widely, but I have made no 
attempt to track down the places where changes will be in order. I may 
make additional changes to contour, and I know I will need to change 
colorbar to fully support this. I think colorbar needs some more 
refactoring anyway, but I can't do it immediately, and I did not want to 
delay getting the other changes out for testing and, hopefully, 
productive use.
Eric

On Wednesday 23 November 2005 19:51, da...@eg... wrote:
> Unfortunately, I can't seem to recreate your problem.
The problem is that I have both Numeric[1] and the new scipy installed. When 
both are installed, the Numeric headers are picked up by default during scipy 
compilation. By forcing them to pick up the scipy headers, the problem was 
resolved. But it is a rather strange coincidence that the error results in 
truncated numbers rather than something drastic.
Ravi
[1] Reason: It will be a while before all my Numeric-based libraries are 
ported to the new scipy; porting is trivial, but regression testing takes 
time, especially given that the new scipy C API is not quite stable yet and 
that I haven't yet ported boost.python.numeric to scipy.

Hi,
The logic for displaying a figure on the interactive backends (eg qt)
seems a little strange to me. I imagine that normally the screen is
used as a preview for a figure that is going to be output on paper, or
to png or some permanent store. Therefore, the interactive output
should resemble the permanent output as much as possible.
Now, when using the QtAgg backend (sorry no time to play with other
backends) setting the figure height or width has no effect on the size
of the figure displayed with show(). It always comes out at 600x400.
Further, given that the window can be resized or embedded, ideally
what is displayed should be as good a representation of the figure as
possible. It is not, however. To see this try resizing the window -
fonts sizes, linewidths, etc. stay the same size.
I can make the rendering more realistic using the dpi setting. This
can be achieved using this implementation of resizeEvent (from
backend_qt_agg.py / FigureCanvasQtAgg). The original code is
commented.
 def resizeEvent( self, e ):
 FigureCanvasQT.resizeEvent( self, e )
 w =3D e.size().width()
 h =3D e.size().height()
 if DEBUG: print "FigureCanvasQtAgg.resizeEvent(", w, ",", h, ")"
 #dpival =3D self.figure.dpi.get()
 #winch =3D w/dpival
 #hinch =3D h/dpival
 #self.figure.set_figsize_inches( winch, hinch )
 if w/self.figure.get_figwidth() < h/self.figure.get_figheight():
 self.figure.set_dpi( w/self.figure.get_figwidth() )
 else:
 self.figure.set_dpi( h/self.figure.get_figheight() )
 self.draw()
The original implementation doesn't really do anything to how the
figure is displayed. The new one makes the plot appear how it should
no matter what the window's size.
This is not ideal, however, as if the figure is saved now the dpi will
be wrong. So there are two questions really: is this a better way
for the interactive windows to display? If so, where should this
logic go?
thanks,
James

from __future__ import division, generators
import math, sys
from numerix import absolute, arange, array, asarray, ones, divide,\
 transpose, log, log10, Float, Float32, ravel, zeros,\
 Int16, Int32, Int, Float64, ceil, indices, \
 shape, which, where, sqrt, asum, compress, maximum, minimum
import numerix.ma as ma
import matplotlib.mlab
from artist import Artist, setp
from axis import XAxis, YAxis
from cbook import iterable, is_string_like, flatten, enumerate, \
 allequal, dict_delall, popd, popall, silent_list
from collections import RegularPolyCollection, PolyCollection, =
LineCollection
from colors import colorConverter, normalize, Colormap, =
LinearSegmentedColormap, looks_like_color
import cm
#from cm import ColormapJet, Grayscale, ScalarMappable
from cm import ScalarMappable
from contour import ContourSet
import _image
from ticker import AutoLocator, LogLocator, NullLocator
from ticker import ScalarFormatter, LogFormatter, LogFormatterExponent, =
LogFormatterMathtext, NullFormatter
from image import AxesImage
from legend import Legend
from lines import Line2D, lineStyles, lineMarkers
from matplotlib.mlab import meshgrid, detrend_none, detrend_linear, \
 window_none, window_hanning, linspace, prctile
from matplotlib.numerix.mlab import flipud, amin, amax
from matplotlib import rcParams
from patches import Patch, Rectangle, Circle, Polygon, Arrow, Wedge, =
Shadow, bbox_artist
from table import Table
from text import Text, TextWithDash, _process_text_args
from transforms import Bbox, Point, Value, Affine, =
NonseparableTransformation
from transforms import FuncXY, Func, LOG10, IDENTITY, POLAR
from transforms import get_bbox_transform, unit_bbox, one, origin, zero
from transforms import blend_xy_sep_transform, Interval
from font_manager import FontProperties
import matplotlib
if matplotlib._havedate:
 from dates import date_ticker_factory
def _process_plot_format(fmt):
 """
 Process a matlab(TM) style color/line style format string. Return a
 linestyle, color tuple as a result of the processing. Default
 values are ('-', 'b'). Example format strings include
 'ko' : black circles
 '.b' : blue dots
 'r--' : red dashed lines
 See Line2D.lineStyles and GraphicsContext.colors for all possible
 styles and color format string.
 """
 colors =3D {
 'b' : 1,
 'g' : 1,
 'r' : 1,
 'c' : 1,
 'm' : 1,
 'y' : 1,
 'k' : 1,
 'w' : 1,
 }
 linestyle =3D 'None'
 marker =3D 'None'
 color =3D rcParams['lines.color']
 # handle the multi char special cases and strip them from the
 # string
 if fmt.find('--')>=3D0:
 linestyle =3D '--'
 fmt =3D fmt.replace('--', '')
 if fmt.find('-.')>=3D0:
 linestyle =3D '-.'
 fmt =3D fmt.replace('-.', '')
 chars =3D [c for c in fmt]
 for c in chars:
 if lineStyles.has_key(c):
 if linestyle !=3D 'None':
 raise ValueError, 'Illegal format string "%s"; two =
linestyle symbols' % fmt
 linestyle =3D c
 elif lineMarkers.has_key(c):
 if marker !=3D 'None':
 raise ValueError, 'Illegal format string "%s"; two =
marker symbols' % fmt
 marker =3D c
 elif colors.has_key(c):
 color =3D c
 else:
 err =3D 'Unrecognized character %c in format string' % c
 raise ValueError, err
 if linestyle =3D=3D 'None' and marker =3D=3D 'None':
 linestyle =3D rcParams['lines.linestyle']
 return linestyle, marker, color
class _process_plot_var_args:
 """
 Process variable length arguments to the plot command, so that
 plot commands like the following are supported
 plot(t, s)
 plot(t1, s1, t2, s2)
 plot(t1, s1, 'ko', t2, s2)
 plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3)
 an arbitrary number of x, y, fmt are allowed
 """
 def __init__(self, command=3D'plot'):
 self.command =3D command
 self._clear_color_cycle()
 def _clear_color_cycle(self):
 self.colors =3D ['b','g','r','c','m','y','k']
 # if the default line color is a color format string, move it up
 # in the que
 try: ind =3D self.colors.index(rcParams['lines.color'])
 except ValueError:
 self.firstColor =3D rcParams['lines.color']
 else:
 self.colors[0], self.colors[ind] =3D self.colors[ind], =
self.colors[0]
 self.firstColor =3D self.colors[0]
 self.Ncolors =3D len(self.colors)
 self.count =3D 0
 def __call__(self, *args, **kwargs):
 ret =3D self._grab_next_args(*args, **kwargs)
 return ret
 def set_lineprops(self, line, **kwargs):
 assert self.command =3D=3D 'plot', 'set_lineprops only works =
with "plot"'
 for key, val in kwargs.items():
 funcName =3D "set_%s"%key
 if not hasattr(line,funcName):
 raise TypeError, 'There is no line property "%s"'%key
 func =3D getattr(line,funcName)
 func(val)
 def set_patchprops(self, fill_poly, **kwargs):
 assert self.command =3D=3D 'fill', 'set_patchprops only works =
with "fill"'
 for key, val in kwargs.items():
 funcName =3D "set_%s"%key
 if not hasattr(fill_poly,funcName):
 raise TypeError, 'There is no patch property "%s"'%key
 func =3D getattr(fill_poly,funcName)
 func(val)
 def is_filled(self, marker):
 filled =3D ('o', '^', 'v', '<', '>', 's',
 'd', 'D', 'h', 'H',
 'p')
 return marker in filled
 def _plot_1_arg(self, y, **kwargs):
 assert self.command =3D=3D 'plot', 'fill needs at least 2 =
arguments'
 if self.count=3D=3D0:
 color =3D self.firstColor
 else:
 color =3D self.colors[int(self.count % self.Ncolors)]
 assert(iterable(y))
 try: N=3Dmax(y.shape)
 except AttributeError: N =3D len(y)
 ret =3D Line2D(arange(N), y,
 color =3D color,
 markerfacecolor=3Dcolor,
 )
 self.set_lineprops(ret, **kwargs)
 self.count +=3D 1
 return ret
 def _plot_2_args(self, tup2, **kwargs):
 if is_string_like(tup2[1]):
 assert self.command =3D=3D 'plot', 'fill needs at least 2 =
non-string arguments'
 y, fmt =3D tup2
 assert(iterable(y))
 linestyle, marker, color =3D _process_plot_format(fmt)
 if self.is_filled(marker): mec =3D None # use default
 else: mec =3D color # use current color
 try: N=3Dmax(y.shape)
 except AttributeError: N =3D len(y)
 ret =3D Line2D(xdata=3Darange(N), ydata=3Dy,
 color=3Dcolor, linestyle=3Dlinestyle, =
marker=3Dmarker,
 markerfacecolor=3Dcolor,
 markeredgecolor=3Dmec,
 )
 self.set_lineprops(ret, **kwargs)
 return ret
 else:
 x,y =3D tup2
 #print self.count, self.Ncolors, self.count % self.Ncolors
 assert(iterable(x))
 assert(iterable(y))
 if self.command =3D=3D 'plot':
 c =3D self.colors[self.count % self.Ncolors]
 ret =3D Line2D(x, y,
 color =3D c,
 markerfacecolor =3D c,
 )
 self.set_lineprops(ret, **kwargs)
 self.count +=3D 1
 elif self.command =3D=3D 'fill':
 ret =3D Polygon( zip(x,y), fill=3DTrue, )
 self.set_patchprops(ret, **kwargs)
 return ret
 def _plot_3_args(self, tup3, **kwargs):
 if self.command =3D=3D 'plot':
 x, y, fmt =3D tup3
 assert(iterable(x))
 assert(iterable(y))
 linestyle, marker, color =3D _process_plot_format(fmt)
 if self.is_filled(marker): mec =3D None # use default
 else: mec =3D color # use current color
 ret =3D Line2D(x, y, color=3Dcolor,
 linestyle=3Dlinestyle, marker=3Dmarker,
 markerfacecolor=3Dcolor,
 markeredgecolor=3Dmec,
 )
 self.set_lineprops(ret, **kwargs)
 if self.command =3D=3D 'fill':
 x, y, facecolor =3D tup3
 ret =3D Polygon(zip(x,y),
 facecolor =3D facecolor,
 fill=3DTrue,
 )
 self.set_patchprops(ret, **kwargs)
 return ret
 def _grab_next_args(self, *args, **kwargs):
 remaining =3D args
 while 1:
 if len(remaining)=3D=3D0: return
 if len(remaining)=3D=3D1:
 yield self._plot_1_arg(remaining[0], **kwargs)
 remaining =3D []
 continue
 if len(remaining)=3D=3D2:
 yield self._plot_2_args(remaining, **kwargs)
 remaining =3D []
 continue
 if len(remaining)=3D=3D3:
 if not is_string_like(remaining[2]):
 raise ValueError, 'third arg must be a format =
string'
 yield self._plot_3_args(remaining, **kwargs)
 remaining=3D[]
 continue
 if is_string_like(remaining[2]):
 yield self._plot_3_args(remaining[:3], **kwargs)
 remaining=3Dremaining[3:]
 else:
 yield self._plot_2_args(remaining[:2], **kwargs)
 remaining=3Dremaining[2:]
 #yield self._plot_2_args(remaining[:2])
 #remaining=3Dargs[2:]
BinOpType=3Dtype(zero())
def makeValue(v):
 if type(v) =3D=3D BinOpType:
 return v
 else:
 return Value(v)
class Axes(Artist):
 """
 Emulate matlab's (TM) axes command, creating axes with
 Axes(position=3D[left, bottom, width, height])
 where all the arguments are fractions in [0,1] which specify the
 fraction of the total figure window.
 axisbg is the color of the axis background
 """
 scaled =3D {IDENTITY : 'linear',
 LOG10 : 'log',
 }
 def __init__(self, fig, rect,
 axisbg =3D None, # defaults to rc axes.facecolor
 frameon =3D True,
 sharex=3DNone, # use Axes instance's xaxis info
 sharey=3DNone, # use Axes instance's yaxis info
 label=3D'',
 **kwargs
 ):
 Artist.__init__(self)
 self._position =3D map(makeValue, rect)
 # must be set before set_figure
 self._sharex =3D sharex
 self._sharey =3D sharey
 self.set_label(label)
 self.set_figure(fig)
 # this call may differ for non-sep axes, eg polar
 self._init_axis()
 if axisbg is None: axisbg =3D rcParams['axes.facecolor']
 self._axisbg =3D axisbg
 self._frameon =3D frameon
 self._axisbelow =3D False # todo make me an rcparam
 self._hold =3D rcParams['axes.hold']
 self._connected =3D {} # a dict from events to (id, func)
 self.cla()
 # funcs used to format x and y - fall back on major formatters
 self.fmt_xdata =3D None
 self.fmt_ydata =3D None
 self.set_cursor_props((1,'k')) # set the cursor properties for =
axes
 self._cachedRenderer =3D None
 self.set_navigate(True)
 # aspect ration atribute, and original position
 self._aspect =3D 'normal'
 self._originalPosition =3D self.get_position()
 if len(kwargs): setp(self, **kwargs)
 def _init_axis(self):
 "move this out of __init__ because non-separable axes don't use =
it"
 self.xaxis =3D XAxis(self)
 self.yaxis =3D YAxis(self)
 def set_cursor_props(self, *args):
 """
 Set the cursor property as
 ax.set_cursor_props(linewidth, color) OR
 ax.set_cursor_props((linewidth, color))
 ACCEPTS: a (float, color) tuple
 """
 if len(args)=3D=3D1:
 lw, c =3D args[0]
 elif len(args)=3D=3D2:
 lw, c =3D args
 else:
 raise ValueError('args must be a (linewidth, color) tuple')
 c =3DcolorConverter.to_rgba(c)
 self._cursorProps =3D lw, c
 def get_cursor_props(self):
 """return the cursor props as a linewidth, color tuple where
 linewidth is a float and color is an RGBA tuple"""
 return self._cursorProps
 def set_figure(self, fig):
 """
 Set the Axes figure
 ACCEPTS: a Figure instance
 """
 Artist.set_figure(self, fig)
 l, b, w, h =3D self._position
 xmin =3D fig.bbox.ll().x()
 xmax =3D fig.bbox.ur().x()
 ymin =3D fig.bbox.ll().y()
 ymax =3D fig.bbox.ur().y()
 figw =3D xmax-xmin
 figh =3D ymax-ymin
 self.left =3D l*figw
 self.bottom =3D b*figh
 self.right =3D (l+w)*figw
 self.top =3D (b+h)*figh
 self.bbox =3D Bbox( Point(self.left, self.bottom),
 Point(self.right, self.top ),
 )
 #these will be updated later as data is added
 self._set_lim_and_transforms()
 def _set_lim_and_transforms(self):
 """
 set the dataLim and viewLim BBox attributes and the
 transData and transAxes Transformation attributes
 """
 if self._sharex is not None:
 left=3Dself._sharex.viewLim.ll().x()
 right=3Dself._sharex.viewLim.ur().x()
 else:
 left=3Dzero()
 right=3Done()
 if self._sharey is not None:
 bottom=3Dself._sharey.viewLim.ll().y()
 top=3Dself._sharey.viewLim.ur().y()
 else:
 bottom=3Dzero()
 top=3Done()
 self.viewLim =3D Bbox(Point(left, bottom), Point(right, top))
 self.dataLim =3D unit_bbox()
 self.transData =3D get_bbox_transform(self.viewLim, self.bbox)
 self.transAxes =3D get_bbox_transform(unit_bbox(), self.bbox)
 if self._sharex:
 self.transData.set_funcx(self._sharex.transData.get_funcx())
 if self._sharey:
 self.transData.set_funcy(self._sharey.transData.get_funcy())
 def axhline(self, y=3D0, xmin=3D0, xmax=3D1, **kwargs):
 """
 AXHLINE(y=3D0, xmin=3D0, xmax=3D1, **kwargs)
 Axis Horizontal Line
 Draw a horizontal line at y from xmin to xmax. With the default
 values of xmin=3D0 and xmax=3D1, this line will always span the =
horizontal
 extent of the axes, regardless of the xlim settings, even if you
 change them, eg with the xlim command. That is, the horizontal =
extent
 is in axes coords: 0=3Dleft, 0.5=3Dmiddle, 1.0=3Dright but the y =
location is
 in data coordinates.
 Return value is the Line2D instance. kwargs are the same as =
kwargs to
 plot, and can be used to control the line properties. Eg
 # draw a thick red hline at y=3D0 that spans the xrange
 axhline(linewidth=3D4, color=3D'r')
 # draw a default hline at y=3D1 that spans the xrange
 axhline(y=3D1)
 # draw a default hline at y=3D.5 that spans the the middle =
half of
 # the xrange
 axhline(y=3D.5, xmin=3D0.25, xmax=3D0.75)
 """
 trans =3D blend_xy_sep_transform( self.transAxes, =
self.transData)
 l, =3D self.plot([xmin,xmax], [y,y], transform=3Dtrans, =
**kwargs)
 return l
 def axvline(self, x=3D0, ymin=3D0, ymax=3D1, **kwargs):
 """
 AXVLINE(x=3D0, ymin=3D0, ymax=3D1, **kwargs)
 Axis Vertical Line
 Draw a vertical line at x from ymin to ymax. With the default =
values
 of ymin=3D0 and ymax=3D1, this line will always span the =
vertical extent
 of the axes, regardless of the xlim settings, even if you change =
them,
 eg with the xlim command. That is, the vertical extent is in =
axes
 coords: 0=3Dbottom, 0.5=3Dmiddle, 1.0=3Dtop but the x location =
is in data
 coordinates.
 Return value is the Line2D instance. kwargs are the same as
 kwargs to plot, and can be used to control the line properties. =
Eg
 # draw a thick red vline at x=3D0 that spans the yrange
 l =3D axvline(linewidth=3D4, color=3D'r')
 # draw a default vline at x=3D1 that spans the yrange
 l =3D axvline(x=3D1)
 # draw a default vline at x=3D.5 that spans the the middle =
half of
 # the yrange
 axvline(x=3D.5, ymin=3D0.25, ymax=3D0.75)
 """
 trans =3D blend_xy_sep_transform( self.transData, self.transAxes =
)
 l, =3D self.plot([x,x], [ymin,ymax] , transform=3Dtrans, =
**kwargs)
 return l
 def axhspan(self, ymin, ymax, xmin=3D0, xmax=3D1, **kwargs):
 """
 AXHSPAN(ymin, ymax, xmin=3D0, xmax=3D1, **kwargs)
 Axis Horizontal Span. ycoords are in data units and x
 coords are in axes (relative 0-1) units
 Draw a horizontal span (regtangle) from ymin to ymax. With the
 default values of xmin=3D0 and xmax=3D1, this always span the =
xrange,
 regardless of the xlim settings, even if you change them, eg =
with the
 xlim command. That is, the horizontal extent is in axes coords:
 0=3Dleft, 0.5=3Dmiddle, 1.0=3Dright but the y location is in =
data
 coordinates.
 kwargs are the kwargs to Patch, eg
 antialiased, aa
 linewidth, lw
 edgecolor, ec
 facecolor, fc
 the terms on the right are aliases
 Return value is the patches.Polygon instance.
 #draws a gray rectangle from y=3D0.25-0.75 that spans the =
horizontal
 #extent of the axes
 axhspan(0.25, 0.75, facecolor=3D0.5, alpha=3D0.5)
 """
 trans =3D blend_xy_sep_transform( self.transAxes, self.transData =
 )
 verts =3D (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)
 p =3D Polygon(verts, **kwargs)
 p.set_transform(trans)
 self.add_patch(p)
 return p
 def axvspan(self, xmin, xmax, ymin=3D0, ymax=3D1, **kwargs):
 """
 AXVSPAN(xmin, xmax, ymin=3D0, ymax=3D1, **kwargs)
 axvspan : Axis Vertical Span. xcoords are in data units and y =
coords
 are in axes (relative 0-1) units
 Draw a vertical span (regtangle) from xmin to xmax. With the =
default
 values of ymin=3D0 and ymax=3D1, this always span the yrange, =
regardless
 of the ylim settings, even if you change them, eg with the ylim
 command. That is, the vertical extent is in axes coords: =
0=3Dbottom,
 0.5=3Dmiddle, 1.0=3Dtop but the y location is in data =
coordinates.
 kwargs are the kwargs to Patch, eg
 antialiased, aa
 linewidth, lw
 edgecolor, ec
 facecolor, fc
 the terms on the right are aliases
 return value is the patches.Polygon instance.
 # draw a vertical green translucent rectangle from x=3D1.25 =
to 1.55 that
 # spans the yrange of the axes
 axvspan(1.25, 1.55, facecolor=3D'g', alpha=3D0.5)
 """
 trans =3D blend_xy_sep_transform( self.transData, self.transAxes =
 )
 verts =3D [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, =
ymin)]
 p =3D Polygon(verts, **kwargs)
 p.set_transform(trans)
 self.add_patch(p)
 return p
 def format_xdata(self, x):
 """
 Return x string formatted. This function will use the attribute
 self.fmt_xdata if it is callable, else will fall back on the =
xaxis
 major formatter
 """
 try: return self.fmt_xdata(x)
 except TypeError:
 func =3D self.xaxis.get_major_formatter().format_data
 val =3D func(x)
 return val
 def format_ydata(self, y):
 """
 Return y string formatted. This function will use the attribute
 self.fmt_ydata if it is callable, else will fall back on the =
yaxis
 major formatter
 """
 try: return self.fmt_ydata(y)
 except TypeError:
 func =3D self.yaxis.get_major_formatter().format_data
 val =3D func(y)
 return val
 def format_coord(self, x, y):
 'return a format string formatting the x, y coord'
 =20
 xs =3D self.format_xdata(x)
 ys =3D self.format_ydata(y)
 return 'x=3D%s, y=3D%s'%(xs,ys)
 def has_data(self):
 'return true if any artists have been added to axes'
 return (
 len(self.collections) +
 len(self.images) +
 len(self.lines) +
 len(self.patches))>0
 def _set_artist_props(self, a):
 'set the boilerplate props for artists added to axes'
 a.set_figure(self.figure)
 if not a.is_transform_set():
 a.set_transform(self.transData)
 a.axes =3D self
 def cla(self):
 'Clear the current axes'
 self.xaxis.cla()
 self.yaxis.cla()
 if self._sharex is not None:
 self.xaxis.major =3D self._sharex.xaxis.major
 self.xaxis.minor =3D self._sharex.xaxis.minor
 if self._sharey is not None:
 self.yaxis.major =3D self._sharey.yaxis.major
 self.yaxis.minor =3D self._sharey.yaxis.minor
 self._get_lines =3D _process_plot_var_args()
 self._get_patches_for_fill =3D _process_plot_var_args('fill')
 self._gridOn =3D rcParams['axes.grid']
 self.lines =3D []
 self.patches =3D []
 self.texts =3D [] # text in axis coords
 self.tables =3D []
 self.artists =3D []
 self.images =3D []
 self.legend_ =3D None
 self.collections =3D [] # collection.Collection instances
 self._autoscaleon =3D True
 self.grid(self._gridOn)
 self.title =3D Text(
 x=3D0.5, y=3D1.02, text=3D'',
 =
fontproperties=3DFontProperties(size=3DrcParams['axes.titlesize']),
 verticalalignment=3D'bottom',
 horizontalalignment=3D'center',
 )
 self.title.set_transform(self.transAxes)
 self.title.set_clip_box(None) =20
 self._set_artist_props(self.title)
 self.axesPatch =3D Rectangle(
 xy=3D(0,0), width=3D1, height=3D1,
 facecolor=3Dself._axisbg,
 edgecolor=3DrcParams['axes.edgecolor'],
 )
 self.axesPatch.set_figure(self.figure)
 self.axesPatch.set_transform(self.transAxes)
 self.axesPatch.set_linewidth(rcParams['axes.linewidth'])
 self.axison =3D True
 def add_artist(self, a):
 'Add any artist to the axes'
 self.artists.append(a)
 self._set_artist_props(a)
 def add_collection(self, collection):
 'add a Collection instance to Axes'
 self.collections.append(collection)
 self._set_artist_props(collection)
 collection.set_clip_box(self.bbox)
 def get_images(self):
 'return a list of Axes images contained by the Axes'
 return silent_list('AxesImage', self.images)
 def get_xscale(self):
 'return the xaxis scale string: log or linear'
 return self.scaled[self.transData.get_funcx().get_type()]
 def get_yscale(self):
 'return the yaxis scale string: log or linear'
 return self.scaled[self.transData.get_funcy().get_type()]
 def update_datalim(self, xys):
 'Update the data lim bbox with seq of xy tups'
 # if no data is set currently, the bbox will ignore it's
 # limits and set the bound to be the bounds of the xydata.
 # Otherwise, it will compute the bounds of it's current data
 # and the data in xydata
 self.dataLim.update(xys, not self.has_data())
 def update_datalim_numerix(self, x, y):
 'Update the data lim bbox with seq of xy tups'
 # if no data is set currently, the bbox will ignore it's
 # limits and set the bound to be the bounds of the xydata.
 # Otherwise, it will compute the bounds of it's current data
 # and the data in xydata
 #print type(x), type(y)
 self.dataLim.update_numerix(x, y, not self.has_data())
 def add_line(self, l):
 'Add a line to the list of plot lines'
 self._set_artist_props(l)
 l.set_clip_box(self.bbox)
 xdata =3D l.get_xdata(valid_only=3DTrue)
 ydata =3D l.get_ydata(valid_only=3DTrue)
 if l.get_transform() !=3D self.transData:
 xys =3D self._get_verts_in_data_coords(
 l.get_transform(), zip(xdata, ydata))
 xdata =3D array([x for x,y in xys])
 ydata =3D array([y for x,y in xys])
 self.update_datalim_numerix( xdata, ydata )
 #self.update_datalim(zip(xdata, ydata))
 label =3D l.get_label()
 if not label: l.set_label('line%d'%len(self.lines))
 self.lines.append(l)
 def _get_verts_in_data_coords(self, trans, xys):
 if trans =3D=3D self.transData:
 return xys
 # data is not in axis data units. We must transform it to
 # display and then back to data to get it in data units
 xys =3D trans.seq_xy_tups(xys)
 return [ self.transData.inverse_xy_tup(xy) for xy in xys]
 def add_patch(self, p):
 """
 Add a patch to the list of Axes patches; the clipbox will be
 set to the Axes clipping box. If the transform is not set, it
 wil be set to self.transData.
 """
 self._set_artist_props(p)
 p.set_clip_box(self.bbox)
 xys =3D self._get_verts_in_data_coords(
 p.get_transform(), p.get_verts())
 #for x,y in xys: print x,y
 self.update_datalim(xys)
 self.patches.append(p)
 def add_table(self, tab):
 'Add a table instance to the list of axes tables'
 self._set_artist_props(tab)
 self.tables.append(tab)
 def autoscale_view(self):
 'autoscale the view limits using the data limits'
 # if image data only just use the datalim
 if not self._autoscaleon: return
 if (len(self.images)>0 and
 len(self.lines)=3D=3D0 and
 len(self.patches)=3D=3D0):
 self.set_xlim(self.dataLim.intervalx().get_bounds())
 self.set_ylim(self.dataLim.intervaly().get_bounds())
 return
 locator =3D self.xaxis.get_major_locator()
 self.set_xlim(locator.autoscale())
 locator =3D self.yaxis.get_major_locator()
 self.set_ylim(locator.autoscale())
 if self._aspect =3D=3D 'equal': self.set_aspect('equal')
 def quiver(self, U, V, *args, **kwargs ):
 """
 QUIVER( X, Y, U, V )
 QUIVER( U, V )
 QUIVER( X, Y, U, V, S)
 QUIVER( U, V, S )
 QUIVER( ..., color=3DNone, width=3D1.0, cmap=3DNone,norm=3DNone =
)
 Make a vector plot (U, V) with arrows on a grid (X, Y)
 The optional arguments color and width are used to specify the =
color and width
 of the arrow. color can be an array of colors in which case the =
arrows can be
 colored according to another dataset.
 If cm is specied and color is None, the colormap is used to give =
a color
 according to the vector's length.
 If color is a scalar field, the colormap is used to map the =
scalar to a color
 If a colormap is specified and color is an array of color =
triplets, then the
 colormap is ignored
 width is a scalar that controls the width of the arrows
 if S is specified it is used to scale the vectors. Use S=3D0 to =
disable automatic
 scaling.
 If S!=3D0, vectors are scaled to fit within the grid and then =
are multiplied by S.
 """
 if not self._hold: self.cla()
 do_scale =3D True
 S =3D 1.0
 if len(args)=3D=3D0:
 # ( U, V )
 U =3D asarray(U)
 V =3D asarray(V)
 X,Y =3D meshgrid( arange(U.shape[1]), arange(U.shape[0]) )
 elif len(args)=3D=3D1:
 # ( U, V, S )
 U =3D asarray(U)
 V =3D asarray(V)
 X,Y =3D meshgrid( arange(U.shape[1]), arange(U.shape[0]) )
 S =3D float(args[0])
 do_scale =3D ( S !=3D 0.0 )
 elif len(args)=3D=3D2:
 # ( X, Y, U, V )
 X =3D asarray(U)
 Y =3D asarray(V)
 U =3D asarray(args[0])
 V =3D asarray(args[1])
 elif len(args)=3D=3D3:
 # ( X, Y, U, V )
 X =3D asarray(U)
 Y =3D asarray(V)
 U =3D asarray(args[0])
 V =3D asarray(args[1])
 S =3D float(args[2])
 do_scale =3D ( S !=3D 0.0 )
 assert U.shape =3D=3D V.shape
 assert X.shape =3D=3D Y.shape
 assert U.shape =3D=3D X.shape
 arrows =3D []
 N =3D sqrt( U**2+V**2 )
 if do_scale:
 Nmax =3D maximum.reduce(maximum.reduce(N)) or 1 # account =
for div by zero
 U =3D U*(S/Nmax)
 V =3D V*(S/Nmax)
 N =3D N*Nmax
 alpha =3D kwargs.get('alpha', 1.0)
 width =3D kwargs.get('width', 0.25)
 norm =3D kwargs.get('norm', None)
 cmap =3D kwargs.get('cmap', None)
 vmin =3D kwargs.get('vmin', None)
 vmax =3D kwargs.get('vmax', None)
 color =3D kwargs.get('color', None)
 shading =3D kwargs.get('shading', 'faceted')
 C =3D None
 I,J =3D U.shape
 if color is not None and not looks_like_color(color):
 clr =3D asarray(color)
 if clr.shape=3D=3DU.shape:
 C =3D array([ clr[i,j] for i in xrange(I) for j in =
xrange(J)])
 elif clr.shape =3D=3D () and color:
 # a scalar (1, True,...)
 C =3D array([ N[i,j] for i in xrange(I) for j in =
xrange(J)])
 else:
 color =3D (0.,0.,0.,1.)
 elif color is None:
 color =3D (0.,0.,0.,1.)
 else:
 color =3D colorConverter.to_rgba( color, alpha )
 arrows =3D [ Arrow(X[i,j],Y[i,j],U[i,j],V[i,j],0.1*S =
).get_verts()
 for i in xrange(I) for j in xrange(J) ]
 collection =3D PolyCollection(
 arrows,
 edgecolors =3D 'None',
 facecolors =3D (color,),
 antialiaseds =3D (1,),
 linewidths =3D (width,),
 )
 if C is not None:
 collection.set_array( C )
 else:
 collection.set_facecolor( (color,) )
 collection.set_cmap(cmap)
 collection.set_norm(norm)
 if norm is not None:
 collection.set_clim( vmin, vmax )
 self.add_collection( collection )
 lims =3D asarray(arrows)
 _max =3D maximum.reduce( maximum.reduce( lims ))
 _min =3D minimum.reduce( minimum.reduce( lims ))
 self.update_datalim( [ tuple(_min), tuple(_max) ] )
 self.autoscale_view()
 return arrows
 def bar(self, left, height, width=3D0.8, bottom=3D0,
 color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3
 ):
 """
 BAR(left, height, width=3D0.8, bottom=3D0,
 color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3)
 Make a bar plot with rectangles at
 left, left+width, 0, height
 left and height are Numeric arrays.
 Return value is a list of Rectangle patch instances
 BAR(left, height, width, bottom,
 color, yerr, xerr, capsize, yoff)
 xerr and yerr, if not None, will be used to generate =
errorbars
 on the bar chart
 color specifies the color of the bar
 ecolor specifies the color of any errorbar
 capsize determines the length in points of the error bar =
caps
 The optional arguments color, width and bottom can be either
 scalars or len(x) sequences
 This enables you to use bar as the basis for stacked bar
 charts, or candlestick plots
 """
 if not self._hold: self.cla()
 # left =3D asarray(left) - width/2
 left =3D asarray(left)
 height =3D asarray(height)
 patches =3D []
 # if color looks like a color string, an RGB tuple or a
 # scalar, then repeat it by len(x)
 if (is_string_like(color) or
 (iterable(color) and len(color)=3D=3D3 and len(left)!=3D3) =
or
 not iterable(color)):
 color =3D [color]*len(left)
 if not iterable(bottom):
 bottom =3D array([bottom]*len(left), Float)
 else:
 bottom =3D asarray(bottom)
 if not iterable(width):
 width =3D array([width]*len(left), Float)
 else:
 width =3D asarray(width)
 N =3D len(left)
 assert len(bottom)=3D=3DN, 'bar arg bottom must be len(left)'
 assert len(width)=3D=3DN, 'bar arg width must be len(left) or =
scalar'
 assert len(height)=3D=3DN, 'bar arg height must be len(left) or =
scalar'
 assert len(color)=3D=3DN, 'bar arg color must be len(left) or =
scalar'
 args =3D zip(left, bottom, width, height, color)
 for l, b, w, h, c in args:
 if h<0:
 b +=3D h
 h =3D abs(h)
 r =3D Rectangle(
 xy=3D(l, b), width=3Dw, height=3Dh,
 facecolor=3Dc,
 )
 self.add_patch(r)
 patches.append(r)
 if xerr is not None or yerr is not None:
 self.errorbar(
 left+0.5*width, bottom+height,
 yerr=3Dyerr, xerr=3Dxerr,
 fmt=3DNone, ecolor=3Decolor, capsize=3Dcapsize)
 self.autoscale_view()
 return patches
 def boxplot(self, x, notch=3D0, sym=3D'b+', vert=3D1, whis=3D1.5,
 positions=3DNone, widths=3DNone):
 """
 boxplot(x, notch=3D0, sym=3D'+', vert=3D1, whis=3D1.5,
 positions=3DNone, widths=3DNone)
 Make a box and whisker plot for each column of x.
 The box extends from the lower to upper quartile values
 of the data, with a line at the median. The whiskers
 extend from the box to show the range of the data. Flier
 points are those past the end of the whiskers.
 notch =3D 0 (default) produces a rectangular box plot.
 notch =3D 1 will produce a notched box plot
 sym (default 'b+') is the default symbol for flier points.
 Enter an empty string ('') if you don't want to show fliers.
 vert =3D 1 (default) makes the boxes vertical.
 vert =3D 0 makes horizontal boxes. This seems goofy, but
 that's how Matlab did it.
 whis (default 1.5) defines the length of the whiskers as
 a function of the inner quartile range. They extend to the
 most extreme data point within ( whis*(75%-25%) ) data range.
 positions (default 1,2,...,n) sets the horizontal positions of
 the boxes. The ticks and limits are automatically set to match
 the positions.
 widths is either a scalar or a vector and sets the width of
 each box. The default is 0.5, or 0.15*(distance between extreme
 positions) if that is smaller.
 x is a Numeric array
 Returns a list of the lines added
 """
 if not self._hold: self.cla()
 holdStatus =3D self._hold
 lines =3D []
 x =3D asarray(x)
 # if we've got a vector, reshape it
 rank =3D len(x.shape)
 if 1 =3D=3D rank:
 x.shape =3D -1, 1
 row, col =3D x.shape
 # get some plot info
 if positions is None:
 positions =3D range(1, col + 1)
 if widths is None:
 distance =3D max(positions) - min(positions)
 widths =3D distance * min(0.15, 0.5/distance)
 if isinstance(widths, float) or isinstance(widths, int):
 widths =3D ones((col,), 'd') * widths
 # loop through columns, adding each to plot
 self.hold(True)
 for i,pos in enumerate(positions):
 d =3D x[:,i]
 # get median and quartiles
 q1, med, q3 =3D prctile(d,[25,50,75])
 # get high extreme
 iq =3D q3 - q1
 hi_val =3D q3 + whis*iq
 wisk_hi =3D compress( d <=3D hi_val , d )
 if len(wisk_hi) =3D=3D 0:
 wisk_hi =3D q3
 else:
 wisk_hi =3D max(wisk_hi)
 # get low extreme
 lo_val =3D q1 - whis*iq
 wisk_lo =3D compress( d >=3D lo_val, d )
 if len(wisk_lo) =3D=3D 0:
 wisk_lo =3D q1
 else:
 wisk_lo =3D min(wisk_lo)
 # get fliers - if we are showing them
 flier_hi =3D []
 flier_lo =3D []
 flier_hi_x =3D []
 flier_lo_x =3D []
 if len(sym) !=3D 0:
 flier_hi =3D compress( d > wisk_hi, d )
 flier_lo =3D compress( d < wisk_lo, d )
 flier_hi_x =3D ones(flier_hi.shape[0]) * pos
 flier_lo_x =3D ones(flier_lo.shape[0]) * pos
 # get x locations for fliers, whisker, whisker cap and box =
sides
 box_x_min =3D pos - widths[i] * 0.5
 box_x_max =3D pos + widths[i] * 0.5
 wisk_x =3D ones(2) * pos
 cap_x_min =3D pos - widths[i] * 0.25
 cap_x_max =3D pos + widths[i] * 0.25
 cap_x =3D [cap_x_min, cap_x_max]
 # get y location for median
 med_y =3D [med, med]
 # calculate 'regular' plot
 if notch =3D=3D 0:
 # make our box vectors
 box_x =3D [box_x_min, box_x_max, box_x_max, box_x_min, =
box_x_min ]
 box_y =3D [q1, q1, q3, q3, q1 ]
 # make our median line vectors
 med_x =3D [box_x_min, box_x_max]
 # calculate 'notch' plot
 else:
 notch_max =3D med + 1.57*iq/sqrt(row)
 notch_min =3D med - 1.57*iq/sqrt(row)
 if notch_max > q3:
 notch_max =3D q3
 if notch_min < q1:
 notch_min =3D q1
 # make our notched box vectors
 box_x =3D [box_x_min, box_x_max, box_x_max, cap_x_max, =
box_x_max, box_x_max, box_x_min, box_x_min, cap_x_min, box_x_min, =
box_x_min ]
 box_y =3D [q1, q1, notch_min, med, notch_max, q3, q3, =
notch_max, med, notch_min, q1]
 # make our median line vectors
 med_x =3D [cap_x_min, cap_x_max]
 med_y =3D [med, med]
 # make a vertical plot . . .
 if 1 =3D=3D vert:
 l =3D self.plot(wisk_x, [q1, wisk_lo], 'b--',
 wisk_x, [q3, wisk_hi], 'b--',
 cap_x, [wisk_hi, wisk_hi], 'k-',
 cap_x, [wisk_lo, wisk_lo], 'k-',
 box_x, box_y, 'b-',
 med_x, med_y, 'r-',
 flier_hi_x, flier_hi, sym,
 flier_lo_x, flier_lo, sym )
 lines.extend(l)
 # or perhaps a horizontal plot
 else:
 l =3D self.plot([q1, wisk_lo], wisk_x, 'b--',
 [q3, wisk_hi], wisk_x, 'b--',
 [wisk_hi, wisk_hi], cap_x, 'k-',
 [wisk_lo, wisk_lo], cap_x, 'k-',
 box_y, box_x, 'b-',
 med_y, med_x, 'r-',
 flier_hi, flier_hi_x, sym,
 flier_lo, flier_lo_x, sym )
 lines.extend(l)
 # fix our axes/ticks up a little
 if 1 =3D=3D vert:
 setticks, setlim =3D self.set_xticks, self.set_xlim
 else:
 setticks, setlim =3D self.set_yticks, self.set_ylim
 newlimits =3D min(positions)-0.5, max(positions)+0.5
 setlim(newlimits)
 setticks(positions)
 =20
 # reset hold status
 self.hold(holdStatus)
 return lines
 def barh(self, x, y, height=3D0.8, left=3D0,
 color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3
 ):
 """
 BARH(x, y, height=3D0.8, left=3D0,
 color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3)
 BARH(x, y)
 The y values give the heights of the center of the bars. =
The
 x values give the length of the bars.
 Return value is a list of Rectangle patch instances
 Optional arguments
 height - the height (thickness) of the bar
 left - the x coordinate of the left side of the bar
 color specifies the color of the bar
 xerr and yerr, if not None, will be used to generate =
errorbars
 on the bar chart
 ecolor specifies the color of any errorbar
 capsize determines the length in points of the error bar =
caps
 The optional arguments color, height and left can be either
 scalars or len(x) sequences
 """
 if not self._hold: self.cla()
 # left =3D asarray(left) - width/2
 x =3D asarray(x)
 y =3D asarray(y)
 patches =3D []
 # if color looks like a color string, and RGB tuple or a
 # scalar, then repeat it by len(x)
 if (is_string_like(color) or
 (iterable(color) and len(color)=3D=3D3 and len(left)!=3D3) =
or
 not iterable(color)):
 color =3D [color]*len(x)
 if not iterable(left):
 left =3D array([left]*len(x), Float)
 else:
 left =3D asarray(left)
 if not iterable(height):
 height =3D array([height]*len(x), Float)
 else:
 height =3D asarray(height)
 N =3D len(x)
 assert len(left)=3D=3DN, 'bar arg left must be len(x)'
 assert len(height)=3D=3DN, 'bar arg height must be len(x) or =
scalar'
 assert len(y)=3D=3DN, 'bar arg y must be len(x) or scalar'
 assert len(color)=3D=3DN, 'bar arg color must be len(x) or =
scalar'
 width =3D x
 right =3D left+x
 bottom =3D y - height/2.
 args =3D zip(left, bottom, width, height, color)
 for l, b, w, h, c in args:
 if h<0:
 b +=3D h
 h =3D abs(h)
 r =3D Rectangle(
 xy=3D(l, b), width=3Dw, height=3Dh,
 facecolor=3Dc,
 )
 self.add_patch(r)
 patches.append(r)
 if xerr is not None or yerr is not None:
 self.errorbar(
 right, y,
 yerr=3Dyerr, xerr=3Dxerr,
 fmt=3DNone, ecolor=3Decolor, capsize=3Dcapsize)
 self.autoscale_view()
 return patches
 def clear(self):
 'clear the axes'
 self.cla()
 def clabel(self, CS, *args, **kwargs):
 return CS.clabel(*args, **kwargs)
 clabel.__doc__ =3D ContourSet.clabel.__doc__
 def contour(self, *args, **kwargs):
 kwargs['filled'] =3D False
 return ContourSet(self, *args, **kwargs)
 contour.__doc__ =3D ContourSet.contour_doc
 def contourf(self, *args, **kwargs):
 kwargs['filled'] =3D True
 return ContourSet(self, *args, **kwargs)
 contourf.__doc__ =3D ContourSet.contour_doc
 def cohere(self, x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
 window=3Dwindow_hanning, noverlap=3D0, **kwargs):
 """
 COHERE(x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
 window=3Dwindow_hanning, noverlap=3D0)
 cohere the coherence between x and y. Coherence is the =
normalized
 cross spectral density
 Cxy =3D |Pxy|^2/(Pxx*Pyy)
 The return value is (Cxy, f), where f are the frequencies of the
 coherence vector.
 See the PSD help for a description of the optional parameters.
 kwargs are applied to the lines
 Returns the tuple Cxy, freqs
 Refs: Bendat & Piersol -- Random Data: Analysis and Measurement
 Procedures, John Wiley & Sons (1986)
 """
 if not self._hold: self.cla()
 cxy, freqs =3D matplotlib.mlab.cohere(x, y, NFFT, Fs, detrend, =
window, noverlap)
 self.plot(freqs, cxy, **kwargs)
 self.set_xlabel('Frequency')
 self.set_ylabel('Coherence')
 self.grid(True)
 return cxy, freqs
 def csd(self, x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
 window=3Dwindow_hanning, noverlap=3D0):
 """
 CSD(x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
 window=3Dwindow_hanning, noverlap=3D0)
 The cross spectral density Pxy by Welches average periodogram =
method.
 The vectors x and y are divided into NFFT length segments. Each
 segment is detrended by function detrend and windowed by =
function
 window. The product of the direct FFTs of x and y are averaged =
over
 each segment to compute Pxy, with a scaling to correct for power =
loss
 due to windowing.
 See the PSD help for a description of the optional parameters.
 Returns the tuple Pxy, freqs. Pxy is the cross spectrum =
(complex
 valued), and 10*log10(|Pxy|) is plotted
 Refs:
 Bendat & Piersol -- Random Data: Analysis and Measurement
 Procedures, John Wiley & Sons (1986)
 """
 if not self._hold: self.cla()
 pxy, freqs =3D matplotlib.mlab.csd(x, y, NFFT, Fs, detrend, =
window, noverlap)
 pxy.shape =3D len(freqs),
 # pxy is complex
 self.plot(freqs, 10*log10(absolute(pxy)))
 self.set_xlabel('Frequency')
 self.set_ylabel('Cross Spectrum Magnitude (dB)')
 self.grid(True)
 vmin, vmax =3D self.viewLim.intervaly().get_bounds()
 intv =3D vmax-vmin
 step =3D 10*int(log10(intv))
 ticks =3D arange(math.floor(vmin), math.ceil(vmax)+1, step)
 self.set_yticks(ticks)
 return pxy, freqs
 def draw_artist(self, a):
 """
 This method can only be used after an initial draw which
 caches the renderer. It is used to efficiently update Axes
 data (axis ticks, labels, etc are not updated)
 """
 assert self._cachedRenderer is not None
 a.draw(self._cachedRenderer)
 def redraw_in_frame(self):
 """
 This method can only be used after an initial draw which
 caches the renderer. It is used to efficiently update Axes
 data (axis ticks, labels, etc are not updated)
 """
 assert self._cachedRenderer is not None
 self.draw(self._cachedRenderer, inframe=3DTrue)
 def get_renderer_cache(self):
 return self._cachedRenderer
 def draw(self, renderer=3DNone, inframe=3DFalse):
 "Draw everything (plot lines, axes, labels)"
 if renderer is None:
 renderer =3D self._cachedRenderer
 if renderer is None:
 raise RuntimeError('No renderer defined')
 if not self.get_visible(): return
 renderer.open_group('axes')
 try: self.transData.freeze() # eval the lazy objects
 except ValueError:
 print >> sys.stderr, 'data freeze value error', =
self.get_position(), self.dataLim.get_bounds(), =
self.viewLim.get_bounds()
 raise
 =20
 self.transAxes.freeze() # eval the lazy objects
 if self.axison:
 if self._frameon: self.axesPatch.draw(renderer)
 if len(self.images)=3D=3D1:
 im =3D self.images[0]
 im.draw(renderer)
 elif len(self.images)>1:
 # make a composite image blending alpha
 # list of (_image.Image, ox, oy)
 ims =3D [(im.make_image(),0,0) for im in self.images if =
im.get_visible()]
 im =3D _image.from_images(self.bbox.height(), =
self.bbox.width(), ims)
 im.is_grayscale =3D False
 l, b, w, h =3D self.bbox.get_bounds()
 renderer.draw_image(l, b, im, self.bbox)
 # axis drawing was here, where contourf etc clobbered them
 # draw axes here, so they are on top of most things
 if self._axisbelow:
 if self.axison and not inframe:
 self.xaxis.draw(renderer)
 self.yaxis.draw(renderer)
 artists =3D []
 artists.extend(self.collections)
 artists.extend(self.patches)
 artists.extend(self.lines)
 artists.extend(self.texts)
 # keep track of i to guarantee stable sort for python 2.2
 dsu =3D [ (a.zorder, i, a) for i, a in enumerate(artists)
 if not a.get_animated()]
 dsu.sort()
 for zorder, i, a in dsu:
 a.draw(renderer)
 self.title.draw(renderer)
 if 0: bbox_artist(self.title, renderer)
 # optional artists
 for a in self.artists:
 a.draw(renderer)
 if not self._axisbelow:
 if self.axison and not inframe:
 self.xaxis.draw(renderer)
 self.yaxis.draw(renderer)
 if self.legend_ is not None:
 self.legend_.draw(renderer)
 for table in self.tables:
 table.draw(renderer)
 self.transData.thaw() # release the lazy objects
 self.transAxes.thaw() # release the lazy objects
 renderer.close_group('axes')
 self._cachedRenderer =3D renderer
 def __draw_animate(self):
 # ignore for now; broken
 if self._lastRenderer is None:
 raise RuntimeError('You must first call ax.draw()')
 dsu =3D [(a.zorder, a) for a in self.animated.keys()]
 dsu.sort()
 renderer =3D self._lastRenderer
 renderer.blit()
 for tmp, a in dsu:
 a.draw(renderer)
 def errorbar(self, x, y, yerr=3DNone, xerr=3DNone,
 fmt=3D'b-', ecolor=3DNone, capsize=3D3,
 barsabove=3DFalse, **kwargs):
 """
 ERRORBAR(x, y, yerr=3DNone, xerr=3DNone,
 fmt=3D'b-', ecolor=3DNone, capsize=3D3, =
barsabove=3DFalse)
 Plot x versus y with error deltas in yerr and xerr.
 Vertical errorbars are plotted if yerr is not None
 Horizontal errorbars are plotted if xerr is not None
 xerr and yerr may be any of:
 a rank-0, Nx1 Numpy array - symmetric errorbars +/- value
 an N-element list or tuple - symmetric errorbars +/- value
 a rank-1, Nx2 Numpy array - asymmetric errorbars =
-column1/+column2
 Alternatively, x, y, xerr, and yerr can all be scalars, which
 plots a single error bar at x, y.
 fmt is the plot format symbol for y. if fmt is None, just
 plot the errorbars with no line symbols. This can be useful
 for creating a bar plot with errorbars
 ecolor is a matplotlib color arg which gives the color the
 errorbar lines; if None, use the marker color.
 capsize is the size of the error bar caps in points
 barsabove, if True, will plot the errorbars above the plot =
symbols
 - default is below
 kwargs are passed on to the plot command for the markers.
 So you can add additional key=3Dvalue pairs to control the
 errorbar markers. For example, this code makes big red
 squares with thick green edges
 >>> x,y,yerr =3D rand(3,10)
 >>> errorbar(x, y, yerr, marker=3D's',
 mfc=3D'red', mec=3D'green', ms=3D20, mew=3D4)
 mfc, mec, ms and mew are aliases for the longer property
 names, markerfacecolor, markeredgecolor, markersize and
 markeredgewith.
 Return value is a length 2 tuple. The first element is the
 Line2D instance for the y symbol lines. The second element is
 a list of error bar lines.
 """
 if not self._hold: self.cla()
 # make sure all the args are iterable arrays
 if not iterable(x): x =3D asarray([x])
 else: x =3D asarray(x)
 if not iterable(y): y =3D asarray([y])
 else: y =3D asarray(y)
 if xerr is not None:
 if not iterable(xerr): xerr =3D asarray([xerr])
 else: xerr =3D asarray(xerr)
 if yerr is not None:
 if not iterable(yerr): yerr =3D asarray([yerr])
 else: yerr =3D asarray(yerr)
 l0 =3D None
 if barsabove and fmt is not None:
 l0, =3D self.plot(x,y,fmt,**kwargs)
 caplines =3D []
 barlines =3D []
 if xerr is not None:
 if len(xerr.shape) =3D=3D 1:
 left =3D x-xerr
 right =3D x+xerr
 else:
 left =3D x-xerr[0]
 right =3D x+xerr[1]
 barlines.extend( self.hlines(y, x, left) )
 barlines.extend( self.hlines(y, x, right) )
 caplines.extend( self.plot(left, y, '|', ms=3D2*capsize) )
 caplines.extend( self.plot(right, y, '|', ms=3D2*capsize) )
 if yerr is not None:
 if len(yerr.shape) =3D=3D 1:
 lower =3D y-yerr
 upper =3D y+yerr
 else:
 lower =3D y-yerr[0]
 upper =3D y+yerr[1]
 barlines.extend( self.vlines(x, y, upper ) )
 barlines.extend( self.vlines(x, y, lower ) )
 caplines.extend( self.plot(x, lower, '_', ms=3D2*capsize) )
 caplines.extend( self.plot(x, upper, '_', ms=3D2*capsize) )
 if not barsabove and fmt is not None:
 l0, =3D self.plot(x,y,fmt,**kwargs)
 if ecolor is None and l0 is None:
 ecolor =3D rcParams['lines.color']
 elif ecolor is None:
 ecolor =3D l0.get_color()
 for l in barlines:
 l.set_color(ecolor)
 for l in caplines:
 l.set_color(ecolor)
 l.set_markerfacecolor(ecolor)
 l.set_markeredgecolor(ecolor)
 self.autoscale_view()
 ret =3D silent_list('Line2D errorbar', caplines+barlines)
 return (l0, ret)
 def fill(self, *args, **kwargs):
 """
 FILL(*args, **kwargs)
 plot filled polygons. *args is a variable length argument, =
allowing
 for multiple x,y pairs with an optional color format string; see =
plot
 for details on the argument parsing. For example, all of the
 following are legal, assuming a is the Axis instance:
 ax.fill(x,y) # plot polygon with vertices at x,y
 ax.fill(x,y, 'b' ) # plot polygon with vertices at x,y in =
blue
 An arbitrary number of x, y, color groups can be specified, as =
in
 ax.fill(x1, y1, 'g', x2, y2, 'r')
 Return value is a list of patches that were added
 The same color strings that plot supports are supported by the =
fill
 format string.
 The kwargs that are can be used to set line properties (any
 property that has a set_* method). You can use this to set edge
 color, face color, etc.
 """
 if not self._hold: self.cla()
 patches =3D []
 for poly in self._get_patches_for_fill(*args, **kwargs):
 self.add_patch( poly )
 patches.append( poly )
 self.autoscale_view()
 return patches
 def get_axis_bgcolor(self):
 'Return the axis background color'
 return self._axisbg
 def get_child_artists(self):
 """
 Return a list of artists the axes contains. Deprecated
 """
 artists =3D [self.title, self.axesPatch, self.xaxis, self.yaxis]
 artists.extend(self.lines)
 artists.extend(self.patches)
 artists.extend(self.texts)
 artists.extend(self.collections)
 if self.legend_ is not None:
 artists.append(self.legend_)
 return silent_list('Artist', artists)
 def get_frame(self):
 'Return the axes Rectangle frame'
 return self.axesPatch
 def get_legend(self):
 'Return the Legend instance, or None if no legend is defined'
 return self.legend_
 def get_lines(self):
 'Return a list of lines contained by the Axes'
 return silent_list('Line2D', self.lines)
 def get_xaxis(self):
 'Return the XAxis instance'
 return self.xaxis
 def get_xgridlines(self):
 'Get the x grid lines as a list of Line2D instances'
 return silent_list('Line2D xgridline', =
self.xaxis.get_gridlines())
 def get_xlim(self):
 'Get the x axis range [xmin, xmax]'
 return self.viewLim.intervalx().get_bounds()
 def get_xticklabels(self):
 'Get the xtick labels as a list of Text instances'
 return silent_list('Text xticklabel', =
self.xaxis.get_ticklabels())
 def get_xticklines(self):
 'Get the xtick lines as a list of Line2D instances'
 return silent_list('Text xtickline', self.xaxis.get_ticklines())
 def get_xticks(self):
 'Return the x ticks as a list of locations'
 return self.xaxis.get_ticklocs()
 def get_yaxis(self):
 'Return the YAxis instance'
 return self.yaxis
 def get_ylim(self):
 'Get the y axis range [ymin, ymax]'
 return self.viewLim.intervaly().get_bounds()
 def get_ygridlines(self):
 'Get the y grid lines as a list of Line2D instances'
 return silent_list('Line2D ygridline', =
self.yaxis.get_gridlines())
 def get_yticklabels(self):
 'Get the ytick labels as a list of Text instances'
 return silent_list('Text yticklabel', =
self.yaxis.get_ticklabels())
 def get_yticklines(self):
 'Get the ytick lines as a list of Line2D instances'
 return silent_list('Line2D ytickline', =
self.yaxis.get_ticklines())
 def get_yticks(self):
 'Return the y ticks as a list of locations'
 return self.yaxis.get_ticklocs()
 def get_frame_on(self):
 """
 Get whether the axes rectangle patch is drawn
 """
 return self._frameon
 def get_navigate(self):
 """
 Get whether the axes responds to navigation commands
 """
 return self._navigate
 def get_axisbelow(self):
 """
 Get whether axist below is true or not
 """
 return self._axisbelow
 def get_autoscale_on(self):
 """
 Get whether autoscaling is applied on plot commands
 """
 return self._autoscaleon
 def grid(self, b=3DNone):
 """
 Set the axes grids on or off; b is a boolean
 if b is None, toggle the grid state
 """
 self.xaxis.grid(b)
 self.yaxis.grid(b)
 def hist(self, x, bins=3D10, normed=3D0, bottom=3D0,
 orientation=3D'vertical', width=3DNone, **kwargs):
 """
 HIST(x, bins=3D10, normed=3D0, bottom=3D0, =
orientiation=3D'vertical', **kwargs)
 Compute the histogram of x. bins is either an integer number of
 bins or a sequence giving the bins. x are the data to be =
binned.
 The return values is (n, bins, patches)
 If normed is true, the first element of the return tuple will
 be the counts normalized to form a probability density, ie,
 n/(len(x)*dbin)
 orientation =3D 'horizontal' | 'vertical'. If horizontal, barh
 will be used and the "bottom" kwarg will be the left.
 width: the width of the bars. If None, automatically compute
 the width.
 kwargs are used to update the properties of the
 hist bars
 """
 if not self._hold: self.cla()
 n,bins =3D matplotlib.mlab.hist(x, bins, normed)
 if width is None: width =3D 0.9*(bins[1]-bins[0])
 if orienta...
 
[truncated message content]

On Nov 23, 2005, at 12:20 PM, Ravikiran Rajagopal wrote:
> After application of Daishi Harada's patch on 0.85, I tried to use it 
> with
> SciPy core SVN from yesterday and get rather strange results:
I'm sorry you're having troubles with the patch.
Unfortunately, I can't seem to recreate your problem.
I realize "works for me" isn't a particularly useful
response, but I'm afraid that's the best I can do
for now - and I'll be away again for Thanksgiving
until next week.
FWIW, I'm using the CVS matplotlib with the wx backend,
and the new scipy w/atlas.
d

After application of Daishi Harada's patch on 0.85, I tried to use it with 
SciPy core SVN from yesterday and get rather strange results:
x = scipy.array( [16.5]*10 )
y = scipy.array( [19.5]*10 )
w = scipy.arange(10)
# This plots a line at 16.0, not 16.5!
pylab.plot( w, x )
# However this works perfectly with a blue box 0-9 x 16.5x19.5
f = pylab.figure()
a = f.add_subplot( 1, 1, 1 )
a.fill( scipy.concatenate((w,w[::-1])), scipy.concatenate((x,y[::-1])) )
f.canvas.draw()
Further, the legend boxes are too large, usually obscuring most of the picture 
with a polygonal patch (such as the one produced by the fill above) or at 
least a half without any polygonal patches.
How can I help debug these issues?
Regards,
Ravi

Sorry about the delay in getting back to you
(I was away for a long weekend and just got
back in today).
On Nov 19, 2005, at 8:22 AM, John Hunter wrote:
> daishi> This patch allows one to use matplotlib with (just) the
> daishi> new scipy.
>
> Just for clarification, when you say "just" the new scipy, you mean
> that it works with Numeric, numarray *and* the new scipy, not that it
> works with the new scipy and only the new scipy.
The intent was so that current users of numeric/numarray
wouldn't see any difference at all, but that matplotlib
would build against the new scipy - I believe this is the
case, mod Fernando's fix.
> In the near term, this means that mpl would compile three
> shared object files for each of the three array objects for each
> extension module, which of course will increase compile times and
> binary distribution sizes.
As it currently stands, the patch will build at most *two*
shared objects, because the build logic is basically:
if numarray:
	# numarray build
if (numeric or scipy):
	# numeric or scipy build,
	# with numeric taking precedence.
It shouldn't be difficult to flatten this out to build
three libraries, however. I submitted the patch in its
preliminary form to see whether there was interest in
going this route at all, since I saw the discussion
about the unified/new array interface plan.
Fernando wrote:
> Minor fix needed to avoid unpleasant surprises for users who have the 
> old scipy on their import path:
>
> try:
> import scipy
> if hasattr(scipy,'__core_version__'):
> NUMERIX.append('scipy')
> except ImportError:
> pass
>
> You want to make sure that you only do this for users of the _new_ 
> scipy, not the old one.
Thanks and sorry about that, this problem
occurred to me over the weekend too.
d

Arg! One petty thing after another. Here is a simple script
demonstrating that the last row does not render the SpanSelector, yet
the callback works fine???
------------------------------------
import matplotlib
from matplotlib.widgets import SpanSelector
matplotlib.use('TkAgg')
from pylab import *
s =3D 3
axs =3D [subplot(s,s,i) for i in xrange(1,s**2+1)]
def onselect(x, y): print x, y
[SpanSelector(a, onselect, 'vertical', useblit=3DTrue) for a in axs]
show()
------------------------------------
Any clues as to where to look for this bug? Sorry to be a hassle, but
I need this specifically to embed in a Tk only app.
Thanks,
 Charlie
On 11/19/05, John Hunter <jdh...@ac...> wrote:
> >>>>> "Charlie" =3D=3D Charlie Moad <cw...@gm...> writes:
>
> Charlie> Awesome, thanks! Out of curiousity... did you figure
> Charlie> this out visually or by comparing with something?
>
> Let's just say I've encountered the flipy bug before :-)
>
> JDH
>

I'm very interested to see how stuff looks on a Mac. I don't have
access to one, so I'll be looking forward to your results.
I still haven't figured out how to get antialiased lines in EMFs, so
the output doesn't look as good on the screen as all the agg
rendering. But, if you push the dots per inch high enough in the
savefig() command, it looks decent. It does have the advantage of
being a vector format, at least, so it resizes well. :)
It's really worked well for me to be able to embed multiple EMFs and
text and tables in an RTF, with everything machine generated by
Python. Hopefully it works across platforms for you guys.
Rob
On 11/21/05, Ted Drain <ted...@jp...> wrote:
> Rob,
> I think you may have just implemented/discovered/unearthed the Holy
> Grail! This looks fantastic. We have been fighting with EPS files for
> years and trying to come up with a way to have plots that can be embedded
> in Office documents that look good on the screen for presentations and
> still print well.
>
> The EPS preview image has never worked very well and the resulting files
> almost always had problems when moved from MS Office on the PC to/from th=
e
> Mac. If your system works well across platforms, that could save the
> engineers here a lot of time.
>
> We'll have to download this and give it a try. Thanks!
> Ted
>
> At 06:03 PM 11/19/2005, Rob McMullen wrote:
> >I just submitted a patch to add a new non-interactive backend that
> >produces enhanced metafiles, an OpenOffice and Microsoft Windows
> >scalable graphics format that can also be embedded in .rtf files.
> >
> >http://sourceforge.net/tracker/index.php?func=3Ddetail&aid=3D1361839&gro=
up_id=3D80706&atid=3D560722
> >
> >The backend is based on my pyemf package that I finally released with
> >its first public beta:
> >
> >http://pyemf.sourceforge.net
> >
> >The API should be stable -- I'm only planning on adding to it and not
> >changing any existing method signatures in the version 2.0.* series.
> >
> >Oh, and I didn't say so in the patch itself, but I'm happy to donate
> >the patch to matplotlib under the default matplotlib license.
> >
> >Rob
> >
> >
> >-------------------------------------------------------
> >This SF.Net email is sponsored by the JBoss Inc. Get Certified Today
> >Register for a JBoss Training Course. Free Certification Exam
> >for All Training Attendees Through End of 2005. For more info visit:
> >http://ads.osdn.com/?ad_idv28&alloc_id845&opclick
> >_______________________________________________
> >Matplotlib-devel mailing list
> >Mat...@li...
> >https://lists.sourceforge.net/lists/listinfo/matplotlib-devel
>
> Ted Drain Jet Propulsion Laboratory ted...@jp...
>
>
>
>
> -------------------------------------------------------
> This SF.Net email is sponsored by the JBoss Inc. Get Certified Today
> Register for a JBoss Training Course. Free Certification Exam
> for All Training Attendees Through End of 2005. For more info visit:
> http://ads.osdn.com/?ad_id=3D7628&alloc_id=3D16845&op=3Dclick
> _______________________________________________
> Matplotlib-devel mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-devel
>

On Monday 21 November 2005 1:12 pm, Travis Oliphant wrote:
> Darren Dale wrote:
> >Sorry, I've obviously overlooked something, but maybe I have also
> > discovered a bug. I've just removed atlas/blas/lapack, updated scipy_core
> > from svn, removed my build and site-packages/scipy directories, and tried
> > to build scipy_core. Here is a warning message I get toward the end of
> > the build and install processes:
>
> This is definitely a configuration issue. For some reason, the system
> is picking up BLAS information and therefore trying to compile _dotblas
> for you. However, it is failing because the libblas file is not found.
>
> Can you show us the output of the start of the build (where SYSTEM INFO
> things are printed). Or just attach a complete record of the build.
> This might help track down what the configuration issue is.
This was due to an oversight on my end. I used gentoo's package manager to 
completely remove atlas/blas/lapack, and afterwards verified that every 
instance of /usr/lib/libatlas.* had been removed. I did not check that 
libblas.* and liblapack.* had been removed, but I should have. Unfortunately, 
a few broken soft links remained, which scipy found and tried to build 
against. After removing those links, I was able to build scipy_core. How 
embarrassing. I'm sorry for the noise. 
Darren

Rob,
I think you may have just implemented/discovered/unearthed the Holy 
Grail! This looks fantastic. We have been fighting with EPS files for 
years and trying to come up with a way to have plots that can be embedded 
in Office documents that look good on the screen for presentations and 
still print well.
The EPS preview image has never worked very well and the resulting files 
almost always had problems when moved from MS Office on the PC to/from the 
Mac. If your system works well across platforms, that could save the 
engineers here a lot of time.
We'll have to download this and give it a try. Thanks!
Ted
At 06:03 PM 11/19/2005, Rob McMullen wrote:
>I just submitted a patch to add a new non-interactive backend that
>produces enhanced metafiles, an OpenOffice and Microsoft Windows
>scalable graphics format that can also be embedded in .rtf files.
>
>http://sourceforge.net/tracker/index.php?func=detail&aid=1361839&group_id=80706&atid=560722
>
>The backend is based on my pyemf package that I finally released with
>its first public beta:
>
>http://pyemf.sourceforge.net
>
>The API should be stable -- I'm only planning on adding to it and not
>changing any existing method signatures in the version 2.0.* series.
>
>Oh, and I didn't say so in the patch itself, but I'm happy to donate
>the patch to matplotlib under the default matplotlib license.
>
>Rob
>
>
>-------------------------------------------------------
>This SF.Net email is sponsored by the JBoss Inc. Get Certified Today
>Register for a JBoss Training Course. Free Certification Exam
>for All Training Attendees Through End of 2005. For more info visit:
>http://ads.osdn.com/?ad_idv28&alloc_id845&opclick
>_______________________________________________
>Matplotlib-devel mailing list
>Mat...@li...
>https://lists.sourceforge.net/lists/listinfo/matplotlib-devel
Ted Drain Jet Propulsion Laboratory ted...@jp... 

Currently implemented for PostScript backend only - the rest ignore the 
command.
I tried to make it in the same style as the rest of Matplotlib iface:
'x' does bidiagonal hatching
'/' does diagonal,
'-' does horizontal,
and so on.
Repeating the hatching symbol increases the density of hatching.
Attached is the diff for version 0.85.
Is there a chance for this thing to be included into the source?