matplotlib-users — Discussion related to using matplotlib

Re: [Matplotlib-users] specifying NaN color when using imshow

[John H. <jdh...@ac...>]

>>>>> "Gerald" == Gerald John M Manipon <Ger...@jp...> writes:

    Gerald> Hello, I'm trying to plot some grid data using basemap and
    Gerald> imshow however haven't figured out how to specify the
    Gerald> color for nan values.  For example, in my data, valid
    Gerald> values range from 0.0-10.0.  I've assigned -9999.0 and
    Gerald> 1e30 to the missing values and when I imshow (setting
    Gerald> vmin=0.0, vmax=10.0), the missing values show up in the
    Gerald> low and high end of the spectrum, respectively.  Is there
    Gerald> a way to do this?

See the archives for a post by Danny Shevitz and followups in the
thread "obscure colormapping issue related to quantization"

http://article.gmane.org/gmane.comp.python.matplotlib.general/2856/match=obscure+colormapping+issue+related+to+quantization

Basically, you want to write a custom normalization and colormapping
instance, and recipe code is posted in the thread linked above.

JDH

Re: [Matplotlib-users] Incompatibility between Linux and XP

[John H. <jdh...@ac...>]

>>>>> "Alan" == Alan Jackson <aja...@op...> writes:
    Alan> to show the failure, I thought I would ask to see of there
    Alan> are known incompatibilities between Linux and XP that might
    Alan> be causing my problem.

No, none that I am aware of.  I suggest you come up with that demo
script.


JDH

Re: [Matplotlib-users] savefig problems with matplotlib

[John H. <jdh...@ac...>]

>>>>> "James" == James Landry <jwl...@gm...> writes:

    James> When it doesn't work, a dialog box opens with this message

    James> Save figure failure: None: Interrupted system call

What backend are you using?  I have seen something like this on GTK*.
I'm pretty sure it is a threading problem.  Basically, we need a
backend dependent thread-safe way to make system calls.  Not a trivial
task.  I've posted a thread about this to the pygtk mailing list a few
months ago, but have yet to find a reliable recipe.  gtk gurus, please
advise.

In the meantime, you may want to try a different GUI backend, eg,
tkagg.  If this helps, let us know, because it will help determine
that this is indeed your problem.


JDH

Re: [Matplotlib-users] savefig problems with matplotlib

[James L. <jwl...@gm...>]

Thanks for the suggestion Jose.  I installed the new version and the same
problem appeared again.  I'm getting some ideas though.  When I tried it
again by uncommenting the rc line, it worked the first time but not the
second.  Doesn't it cache some of the information?  Could that be the
problem?

James Landry

On 11/25/05, Jos=E9 Matos <jao...@gm...> wrote:
>
> On 25/11/05, James Landry <jwl...@gm...> wrote:
> > I have intermittent problems with the savefig('foo.eps') command when I
> am
> > using my native LaTeX interpreter to produce eps files.  The really
> > frustrating thing is that it is intermittent.  Sometimes I can save a
> file
> > that looks fine and sometimes I can't.
> >
> >  My box is running Fedora Core 4 and kernel 2.6.14.
> >
> >  I have the following rpms:
> >  python-2.4.1-2
> >  ipython-0.6.15-1.fc4
> >  python-tools-2.4.1-2
> >  python-matplotlib-0.84-1.fc4
> >  python-numeric-23.7-2
>
>   Probably it is irrelevant to this problem and it does not help here
> but notice that 0.85 is available from extras.
>



--
James W. Landry
jwl...@gm...

[Matplotlib-users] savefig problems with matplotlib

[James L. <jwl...@gm...>]

I have intermittent problems with the savefig('foo.eps') command when I am
using my native LaTeX interpreter to produce eps files.  The really
frustrating thing is that it is intermittent.  Sometimes I can save a file
that looks fine and sometimes I can't.

My box is running Fedora Core 4 and kernel 2.6.14.

I have the following rpms:
python-2.4.1-2
ipython-0.6.15-1.fc4
python-tools-2.4.1-2
python-matplotlib-0.84-1.fc4
python-numeric-23.7-2

Fedora has an out of date ghostscript 7.07, so I installed
ghostscript-8.51from source into /usr/local, but not the fonts, since
they seemed
unnecessary.

As long as I don't use

rc('text', usetex=3DTrue)

I'm ok, but whenever I turn it on, it doesn't work consistently.

Here's some sample code to demonstrate the problem.  If I comment out the r=
c
line, it works fine.

#!/usr/bin/env python

from matplotlib import rc
from matplotlib.numerix import arange, cos, pi
from pylab import *

forces =3D [1, 2, 3, 4]
pofn =3D [.2, .09, .01, .005]

rc('text', usetex=3DTrue)
figure(1)
semilogy(forces,pofn,'k')
xlabel(r'$f_n =3D F_n/\langle F_n \rangle$')
ylabel(r'$P(f_n)$')
axis([0,5,.001,1])

savefig('mtest1.eps')

However, if I run it as is, then I get the following:

[jwlandry@merrimac hopper]$ ./mat-test.py --verbose-helpful
matplotlib data path /usr/share/matplotlib
$HOME=3D/home/jwlandry
CONFIGDIR=3D/home/jwlandry/.matplotlib
loaded rc file /home/jwlandry/.matplotlib/matplotlibrc
matplotlib version 0.84
verbose.level helpful
interactive is False
platform is linux2
numerix Numeric 23.7
font search path ['/usr/share/matplotlib']
loaded ttfcache file /home/jwlandry/.matplotlib/ttffont.cache
backend GTK version 2.6.2

This is dvips(k) 5.95a Copyright 2005 Radical Eye Software (
www.radicaleye.com)
' TeX output 2005.11.25:1645' -> e0dab64d0b15f2821ec713a6e7903ff4.ps
<tex.pro><psfrag.pro><texps.pro><special.pro><color.pro>. <cmr8.pfb>
<cmsy8.pfb><cmsy10.pfb><cmmi8.pfb><cmmi10.pfb><cmr10.pfb>[1
<e0dab64d0b15f2821ec713a6e7903ff4.eps>]

When it doesn't work, a dialog box opens with this message

Save figure failure:
None: Interrupted system call


Help!

James Landry


--
James W. Landry
jwl...@gm...

Re: [Matplotlib-users] Incompatibility between Linux and XP

[Alan J. <aja...@op...>]

Wasn't that simple... sigh. I'll keep looking.

On Fri, 25 Nov 2005 10:17:57 +0100
"phi...@ho..." <phi...@ho...> wrote:

> Hi Alan,
> 
> You'll see Python exceptions are obvious enough.
> 
> Here it looks like windows doesn't support the ".1".
> Try 0.1 instead.
> 
> Hope it will solve the problem. ;-)
> Regards,
> Philippe Collet
> 
> >Message: 6
> >Date: Thu, 24 Nov 2005 22:16:48 -0600
> >From: Alan Jackson <aja...@op...>
> >To: mat...@li...
> >Subject: [Matplotlib-users] Incompatibility between Linux and XP
> >
> >I'm a new python user, basically trying to learn python using matplotlib
> >for a little project.
> >
> >My code works fine on Linux, but it fails on Windows XP. I'm running
> >the latest version of Matplotlib and SciPy python, 2.3.3.
> >
> >Before I go to a lot of effort to build a small demo program to show the
> >failure, I thought I would ask to see of there are known incompatibilities
> >between Linux and XP that might be causing my problem.
> >
> >The line of code that seems to precipitate the failure is :
> >
> >self.Cax_c = figtext(0.84, .1, '000')
> >
> >that gives an error on Windows XP of :
> >
> >.....matplotlib\text.py", line 665 in set_text
> >TypeError: This doesn't look like a string: '0.0'
> >
> >Thanks!
> >
> 
> 
> 
> -------------------------------------------------------
> This SF.net email is sponsored by: Splunk Inc. Do you grep through log files
> for problems?  Stop!  Download the new AJAX search engine that makes
> searching your log files as easy as surfing the  web.  DOWNLOAD SPLUNK!
> http://ads.osdn.com/?ad_id=7637&alloc_id=16865&op=click
> _______________________________________________
> Matplotlib-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users


-- 
-----------------------------------------------------------------------
| Alan K. Jackson            | To see a World in a Grain of Sand      |
| al...@aj...          | And a Heaven in a Wild Flower,         |
| www.ajackson.org           | Hold Infinity in the palm of your hand |
| Houston, Texas             | And Eternity in an hour. - Blake       |
-----------------------------------------------------------------------

[Matplotlib-users] Plot bug with zoom and symbols (segfault)

[Xavier G. <gn...@ob...>]

Hi,

Here is a testcase :

a=range(10)
b=rand(10)
plot(a,b,'x')
axis([0.,1e-7,0.,1.])

Segmentation fault

This test have been done with last matplotlib version (0.85) and TkAgg
backend + python2.3.
I haven't had time to look at the code for now but it sounds like a
"divide by zero + malloc" in the code computing the symbol possition on
the image.

Ok, this is a wired corner case but I have a real testcase (too long to
be posted here) where this crash occurs.

I also have tested without symbols :
 
a=range(10)
b=rand(10)
plot(a,b)
axis([0.,1e-7,0.,1.])


and the result looks good and no crash occurs.

Thanks for your job  on matplotlib :)
Xavier.

 

Re: [Matplotlib-users] Incompatibility between Linux and XP

[<phi...@ho...>]

Hi Alan,

You'll see Python exceptions are obvious enough.

Here it looks like windows doesn't support the ".1".
Try 0.1 instead.

Hope it will solve the problem. ;-)
Regards,
Philippe Collet

>Message: 6
>Date: Thu, 24 Nov 2005 22:16:48 -0600
>From: Alan Jackson <aja...@op...>
>To: mat...@li...
>Subject: [Matplotlib-users] Incompatibility between Linux and XP
>
>I'm a new python user, basically trying to learn python using matplotlib
>for a little project.
>
>My code works fine on Linux, but it fails on Windows XP. I'm running
>the latest version of Matplotlib and SciPy python, 2.3.3.
>
>Before I go to a lot of effort to build a small demo program to show the
>failure, I thought I would ask to see of there are known incompatibilities
>between Linux and XP that might be causing my problem.
>
>The line of code that seems to precipitate the failure is :
>
>self.Cax_c = figtext(0.84, .1, '000')
>
>that gives an error on Windows XP of :
>
>.....matplotlib\text.py", line 665 in set_text
>TypeError: This doesn't look like a string: '0.0'
>
>Thanks!
>

[Matplotlib-users] Incompatibility between Linux and XP

[Alan J. <aja...@op...>]

I'm a new python user, basically trying to learn python using matplotlib
for a little project.

My code works fine on Linux, but it fails on Windows XP. I'm running
the latest version of Matplotlib and SciPy python, 2.3.3.

Before I go to a lot of effort to build a small demo program to show the
failure, I thought I would ask to see of there are known incompatibilities
between Linux and XP that might be causing my problem.

The line of code that seems to precipitate the failure is :

self.Cax_c = figtext(0.84, .1, '000')

that gives an error on Windows XP of :

.....matplotlib\text.py", line 665 in set_text
TypeError: This doesn't look like a string: '0.0'

Thanks!

-- 
-----------------------------------------------------------------------
| Alan K. Jackson            | To see a World in a Grain of Sand      |
| al...@aj...          | And a Heaven in a Wild Flower,         |
| www.ajackson.org           | Hold Infinity in the palm of your hand |
| Houston, Texas             | And Eternity in an hour. - Blake       |
-----------------------------------------------------------------------

Re: POTENTIAL SPAM: [Matplotlib-users] ipython -pylab: 2 warnings, 1 due to matplotlibrc, other to GtkDeprec

[Fernando P. <Fer...@co...>]

Eric Emsellem wrote:
> Hi,
> I finally got all softs installed (Atlas, scipy which was a real pain, 
> etc). Matplotlib is installing ok now, but I get two types of warnings 
> when I do "ipython -pylab":
> 1/ seems that some lines in my matplotlibrc are wrong? (but I see the 
> same lines in the matplotlibrc on the web)
> 2/ a GtkDeprecationWarning ==> gtk.timeout_add is deprecated...
> 
> The second one was already posted some time ago and was "supposed to go 
> away with ipython 0.6.15" but this is what I am using right now, so... ?

I think the fix was actually post-15, so for now just ignore it, or grab svn 
ipython which does contain the fix.

Cheers,

f

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[<jao...@gm...>]

On 23/11/05, Chris Barker <Chr...@no...> wrote:
> Jos=E9 Matos wrote:
> >   What problems did you had with the version present in Extras?
>
> It turns out that my problem is that those packages didn't exist when I
> installed core 4, which was pretty soon after it was released.

  That is fair. :-)

> However, now that I've got you on line, atlas does not provide a
> complete lapack implementation. What's the easiest way to get a complete
> implementation, with as much optimized as possible?

  Quentin Spencer (the packager)  send several messages explaining the deta=
ils.
One place where I have found it was here, there was also another
message to fedora extras mailing list.
http://www.octave.org/mailing-lists/help-octave/2005/3803

  There he explains some of reasoning in package and also how to build
a customized
local package. Notice that  other packages, i.e. blas and lapack, are
prepared to
work with a custom package.

> Also, I note that there are versions for SSE, SSE2, and 3dnow. do you
> know a good source for figuring out which of these a given processor
> has, and what if you have both 3dnow and SSE2?

  That is explained above. For now the package follows the same scheme
as debian.
One goal is that later the package chooses on real time the best
version to use, using ld
to find the right version  depending on the arch used.

> -Chris
>
>
>
> --
> Christopher Barker, Ph.D.
> Oceanographer
>
> NOAA/OR&R/HAZMAT         (206) 526-6959   voice
> 7600 Sand Point Way NE   (206) 526-6329   fax
> Seattle, WA  98115       (206) 526-6317   main reception
>
> Chr...@no...
>


--
Jos=E9 Matos

Re: [Matplotlib-users] ipython -pylab: 2 warnings, 1 due to matplotlibrc, other to GtkDeprec

[Darren D. <dd...@co...>]

Hi Eric,

Take a look at the new matplotlibrc that is included mpl. tick rc options have 
recently been moved to independent xtick and ytick options. The gtk warning 
you can ignore.

Darren

On Thursday 24 November 2005 6:39 am, Eric Emsellem wrote:
> Hi,
> I finally got all softs installed (Atlas, scipy which was a real pain,
> etc). Matplotlib is installing ok now, but I get two types of warnings
> when I do "ipython -pylab":
> 1/ seems that some lines in my matplotlibrc are wrong? (but I see the
> same lines in the matplotlibrc on the web)
> 2/ a GtkDeprecationWarning ==> gtk.timeout_add is deprecated...
>
> The second one was already posted some time ago and was "supposed to go
> away with ipython 0.6.15" but this is what I am using right now, so... ?
>
> If anybody has a clue on these two items.
> thanks in advance.
> Attached is my matplotlibrc, and below the output of what I get when
> launching ipython -pylab.
>
> thanks
>
> Eric
> Summary config: Linux Suse10.0, python2.4.1, matplotlib-0.85, ipython
> 0.6.15,
> ==============
> # ipython -pylab
>
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "lines.data_clipping" on line 56 in /home/emsellem/
> .matplotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.major.size" on line 143 in /home/emsellem/.ma
> tplotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.minor.size" on line 144 in /home/emsellem/.ma
> tplotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.major.pad" on line 145 in /home/emsellem/.mat
> plotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.minor.pad" on line 146 in /home/emsellem/.mat
> plotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.color" on line 147 in /home/emsellem/.matplot
> lib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> /usr/lib/python2.4/site-packages/matplotlib/__init__.py:843:
> UserWarning: Bad key "tick.labelsize" on line 148 in /home/emsellem/.mat
> plotlib/matplotlibrc
>   warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
> loaded rc file /home/emsellem/.matplotlib/matplotlibrc
> matplotlib version 0.85
> verbose.level helpful
> interactive is False
> platform is linux2
> numerix numarray 1.4.1
> font search path ['/usr/share/matplotlib']
> $HOME=/home/emsellem
> CONFIGDIR=/home/emsellem/.matplotlib
> loaded ttfcache file /home/emsellem/.matplotlib/ttffont.cache
> matplotlib data path /usr/share/matplotlib
> backend GTKAgg version 2.8.0
> /usr/lib/python2.4/site-packages/IPython/Shell.py:627:
> GtkDeprecationWarning: gtk.timeout_add is deprecated, use
> gobject.timeout_add                   instead
>   self.gtk.timeout_add(self.TIMEOUT, self.on_timer)
> Python 2.4.1 (#1, Sep 13 2005, 00:39:20)
> Type "copyright", "credits" or "license" for more information.
>
> IPython 0.6.15 -- An enhanced Interactive Python.

-- 
Darren S. Dale, Ph.D.
dd...@co...

[Matplotlib-users] ipython -pylab: 2 warnings, 1 due to matplotlibrc, other to GtkDeprec

[Eric E. <ems...@ob...>]

Hi,
I finally got all softs installed (Atlas, scipy which was a real pain, 
etc). Matplotlib is installing ok now, but I get two types of warnings 
when I do "ipython -pylab":
1/ seems that some lines in my matplotlibrc are wrong? (but I see the 
same lines in the matplotlibrc on the web)
2/ a GtkDeprecationWarning ==> gtk.timeout_add is deprecated...

The second one was already posted some time ago and was "supposed to go 
away with ipython 0.6.15" but this is what I am using right now, so... ?

If anybody has a clue on these two items.
thanks in advance.
Attached is my matplotlibrc, and below the output of what I get when 
launching ipython -pylab.

thanks

Eric
Summary config: Linux Suse10.0, python2.4.1, matplotlib-0.85, ipython 
0.6.15,
==============
# ipython -pylab

/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "lines.data_clipping" on line 56 in /home/emsellem/
.matplotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.major.size" on line 143 in /home/emsellem/.ma
tplotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.minor.size" on line 144 in /home/emsellem/.ma
tplotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.major.pad" on line 145 in /home/emsellem/.mat
plotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.minor.pad" on line 146 in /home/emsellem/.mat
plotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.color" on line 147 in /home/emsellem/.matplot
lib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
/usr/lib/python2.4/site-packages/matplotlib/__init__.py:843: 
UserWarning: Bad key "tick.labelsize" on line 148 in /home/emsellem/.mat
plotlib/matplotlibrc
  warnings.warn('Bad key "%s" on line %d in %s' % (key, cnt, fname))
loaded rc file /home/emsellem/.matplotlib/matplotlibrc
matplotlib version 0.85
verbose.level helpful
interactive is False
platform is linux2
numerix numarray 1.4.1
font search path ['/usr/share/matplotlib']
$HOME=/home/emsellem
CONFIGDIR=/home/emsellem/.matplotlib
loaded ttfcache file /home/emsellem/.matplotlib/ttffont.cache
matplotlib data path /usr/share/matplotlib
backend GTKAgg version 2.8.0
/usr/lib/python2.4/site-packages/IPython/Shell.py:627: 
GtkDeprecationWarning: gtk.timeout_add is deprecated, use 
gobject.timeout_add                   instead
  self.gtk.timeout_add(self.TIMEOUT, self.on_timer)
Python 2.4.1 (#1, Sep 13 2005, 00:39:20)
Type "copyright", "credits" or "license" for more information.

IPython 0.6.15 -- An enhanced Interactive Python.

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Christian K. <ck...@ho...>]

Eric Emsellem wrote:
> Hi,
> trying to install matplotlib 0.85 on python 2.4 (Suse 10.0), I get :
> 
> ===> cannot find tcl/tk headers. giving up.
> 
> this is annoying and I cannot find much on the web to help me there. I
> have checked my libraries and soft (including the "devel") and think I
> have everything updated right.
> 
> It is probably a simple pb, so if anybody has a  hint there;
> 
> thanks in advance.
> 
> Eric
> P.S.: by the way, upgrading my Linux (Suse 10.0) and therefore getting
> python 2.4, I have now to reinstall everything from scratch (python
> modules) and this is a REAL pain (for example ATLAS which takes ages and
> so on). It means for me that I cannot work before having all back to
> normal (all modules working such as ppgplot, gnuplot-py, Numeric,
> numarray, Scipy, matplotlib, etc, etc). And I am not even sure this will
> compile with Python 2.4. Anybody knows a way out of this?

I was wrong about the tk/tcl issues. It is not solved by installing the devel
rpms. So you could do what Arndt proposed or live without the tk backend by
setting BUILD_TKAGG=0.
Anyway I just wanted to tell that building scipy from svn and matplotlib 0.85
was really straightforward on SuSE 10.0 with gcc4 and python2.4. Concerning the
ATLAS libs: I built them once some years ago and since that time I used them on
every freshly installed system without problems as long as the architecture was
the same (P4 32 bit). Probably the optimization suffers a bit by doing so but I
don't care that much for speed. If you like I can send you the ATLAS binaries.

Regards, Christian

[Matplotlib-users] Test results

[Alexander M. <ale...@co...>]

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]

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Chris B. <Chr...@no...>]

José Matos wrote:
>   What problems did you had with the version present in Extras?

It turns out that my problem is that those packages didn't exist when I 
installed core 4, which was pretty soon after it was released.

However, now that I've got you on line, atlas does not provide a 
complete lapack implementation. What's the easiest way to get a complete 
implementation, with as much optimized as possible?

Also, I note that there are versions for SSE, SSE2, and 3dnow. do you 
know a good source for figuring out which of these a given processor 
has, and what if you have both 3dnow and SSE2?

-Chris



-- 
Christopher Barker, Ph.D.
Oceanographer
                                     		
NOAA/OR&R/HAZMAT         (206) 526-6959   voice
7600 Sand Point Way NE   (206) 526-6329   fax
Seattle, WA  98115       (206) 526-6317   main reception

Chr...@no...

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[<jao...@gm...>]

On 23/11/05, Chris Barker <Chr...@no...> wrote:
> Arnd Baecker wrote:
> > Another option is too choose debian (or ubuntu, ...) as distribution.
>
> Gentoo is quite friendly to python, atlas, etc as well, once you've got
> a basic system installed. I've also had luck with Fedora Core 4, though
> I was very surprised NOT to find good atlas rpms.

  What problems did you had with the version present in Extras?
  I am just curious, and the feedback is important to improve it. Note that=
 I am
not the packager but I am clearly interested in good implementation of atla=
s for
fedora.

> --
> Christopher Barker, Ph.D.
> Oceanographer
>
> NOAA/OR&R/HAZMAT         (206) 526-6959   voice
> 7600 Sand Point Way NE   (206) 526-6329   fax
> Seattle, WA  98115       (206) 526-6317   main reception
>
> Chr...@no...

--
Jos=E9 Matos

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Chris B. <Chr...@no...>]

Arnd Baecker wrote:
> Another option is too choose debian (or ubuntu, ...) as distribution.

Gentoo is quite friendly to python, atlas, etc as well, once you've got 
a basic system installed. I've also had luck with Fedora Core 4, though 
I was very surprised NOT to find good atlas rpms.

Eric Emsellem wrote:

> P.S.: by the way, upgrading my Linux (Suse 10.0) and therefore getting 
> python 2.4, I have now to reinstall everything from scratch (python 
> modules) and this is a REAL pain

Yes, it sure is. Did the upgrade remove your python2.3 installation? If 
not, you should be able to just use "python2.3" at the command line and 
in your #! lines, and keep using the old install while you work on 
getting everything you need into 2.4.

I always put a versioned python in my #! lines:

#!/usr/bin/env python2.3

So that I can install a new python, and still have any scripts I've got 
working just keep working.

If the Suse upgrade did remove python2.3 -- shame on Suse.

-Chris



-- 
Christopher Barker, Ph.D.
Oceanographer
                                     		
NOAA/OR&R/HAZMAT         (206) 526-6959   voice
7600 Sand Point Way NE   (206) 526-6329   fax
Seattle, WA  98115       (206) 526-6317   main reception

Chr...@no...

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Ryan K. <rya...@gm...>]

I am running matplotlib and scipy on ubuntu and it really was pretty
straight forward to install.

But you may be tied to SUSE for other reasons or the idea of a
complete reinstall may be completely unacceptable.

ATLAS and BLAS and LAPACK are all available as precompiled packages on ubun=
tu.

Ryan

On 11/23/05, Arnd Baecker <arn...@we...> wrote:
> Hi Eric,
>
> installation issues can be frustrating - most of us have been
> through what you encounter at the momemt (at least once ;-).
> Don't give up! Some ideas below (I will also send you my
> full install notes off-list - see also:
> http://www.scipy.org/mailinglists/mailman?fn=3Dscipy-dev/2005-November/00=
3949.html
> )
>
> On Wed, 23 Nov 2005, Eric Emsellem wrote:
>
> > Hi,
> > trying to install matplotlib 0.85 on python 2.4 (Suse 10.0), I get :
> >
> > =3D=3D=3D> cannot find tcl/tk headers. giving up.
> >
> > this is annoying and I cannot find much on the web to help me there. I
> > have checked my libraries and soft (including the "devel") and think I
> > have everything updated right.
> >
> > It is probably a simple pb, so if anybody has a  hint there;
>
> In my notes for the installation under SUSE 10.0 I have:
>
> In setupext.py change:
>
> def find_tcltk():
>
>       [...]
>
>       #o.tk_inc=3D"/usr/include/"
>       o.tcl_inc=3D"/usr/include/"
>
>       if not os.path.exists(o.tcl_inc):
>           print 'cannot find tcl/tk headers. giving up.'
>           sys.exit()
>   return o
>
> Not sure if this will help you.
>
> > thanks in advance.
> >
> > Eric
> > P.S.: by the way, upgrading my Linux (Suse 10.0) and therefore getting
> > python 2.4, I have now to reinstall everything from scratch (python
> > modules) and this is a REAL pain (for example ATLAS which takes ages an=
d
> > so on).
>
> ATLAS is surely the worst. Does any SUSE expert know,
> whether there are ATLAS packages available?
>
> For downloads of precompiled ATLAS see:
>   http://www.scipy.org/download/atlasbinaries/linux/
>
>
> > It means for me that I cannot work before having all back to
> > normal (all modules working such as ppgplot, gnuplot-py, Numeric,
> > numarray, Scipy, matplotlib, etc, etc). And I am not even sure this wil=
l
> > compile with Python 2.4. Anybody knows a way out of this?
>
> Compilation of all these (don't know about ppgplot) worked
> fine for me on SUSE 10.0 (even with 64 Bit, with kind help from the
> sciy mailing list) and does not take too long.
>
> Another option is too choose debian (or ubuntu, ...) as distribution.
> If you want to have up-to-date matplotlib, you can either compile
> them yourself or try use use some of the pre-built ones
> (eg. by John for ubuntu). Also for current scipy you will
> have to install it yourself.
> But ATLAS and basically anything else you might need is
> avaible as .deb.
>
> Good luck,
>
> Arnd
>
>
>
> -------------------------------------------------------
> 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-users mailing list
> Mat...@li...
> https://lists.sourceforge.net/lists/listinfo/matplotlib-users
>

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Arnd B. <arn...@we...>]

Hi Eric,

installation issues can be frustrating - most of us have been
through what you encounter at the momemt (at least once ;-).
Don't give up! Some ideas below (I will also send you my
full install notes off-list - see also:
http://www.scipy.org/mailinglists/mailman?fn=scipy-dev/2005-November/003949.html
)

On Wed, 23 Nov 2005, Eric Emsellem wrote:

> Hi,
> trying to install matplotlib 0.85 on python 2.4 (Suse 10.0), I get :
>
> ===> cannot find tcl/tk headers. giving up.
>
> this is annoying and I cannot find much on the web to help me there. I
> have checked my libraries and soft (including the "devel") and think I
> have everything updated right.
>
> It is probably a simple pb, so if anybody has a  hint there;

In my notes for the installation under SUSE 10.0 I have:

In setupext.py change:

def find_tcltk():

      [...]

      #o.tk_inc="/usr/include/"
      o.tcl_inc="/usr/include/"

      if not os.path.exists(o.tcl_inc):
          print 'cannot find tcl/tk headers. giving up.'
          sys.exit()
  return o

Not sure if this will help you.

> thanks in advance.
>
> Eric
> P.S.: by the way, upgrading my Linux (Suse 10.0) and therefore getting
> python 2.4, I have now to reinstall everything from scratch (python
> modules) and this is a REAL pain (for example ATLAS which takes ages and
> so on).

ATLAS is surely the worst. Does any SUSE expert know,
whether there are ATLAS packages available?

For downloads of precompiled ATLAS see:
  http://www.scipy.org/download/atlasbinaries/linux/


> It means for me that I cannot work before having all back to
> normal (all modules working such as ppgplot, gnuplot-py, Numeric,
> numarray, Scipy, matplotlib, etc, etc). And I am not even sure this will
> compile with Python 2.4. Anybody knows a way out of this?

Compilation of all these (don't know about ppgplot) worked
fine for me on SUSE 10.0 (even with 64 Bit, with kind help from the
sciy mailing list) and does not take too long.

Another option is too choose debian (or ubuntu, ...) as distribution.
If you want to have up-to-date matplotlib, you can either compile
them yourself or try use use some of the pre-built ones
(eg. by John for ubuntu). Also for current scipy you will
have to install it yourself.
But ATLAS and basically anything else you might need is
avaible as .deb.

Good luck,

Arnd

Re: [Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Christian K. <ck...@us...>]

Eric Emsellem wrote:
> Hi,
> trying to install matplotlib 0.85 on python 2.4 (Suse 10.0), I get :
> 
> ===> cannot find tcl/tk headers. giving up.

On SuSE this should be fixed by installing
tk-devel and tcl-devel

Christian

[Matplotlib-users] matplotlib 0.85 on python 2.4 installation problem : "cannot find tcl/tk headers. giving up."

[Eric E. <ems...@ob...>]

Hi,
trying to install matplotlib 0.85 on python 2.4 (Suse 10.0), I get :

===> cannot find tcl/tk headers. giving up.

this is annoying and I cannot find much on the web to help me there. I 
have checked my libraries and soft (including the "devel") and think I 
have everything updated right.

It is probably a simple pb, so if anybody has a  hint there;

thanks in advance.

Eric
P.S.: by the way, upgrading my Linux (Suse 10.0) and therefore getting 
python 2.4, I have now to reinstall everything from scratch (python 
modules) and this is a REAL pain (for example ATLAS which takes ages and 
so on). It means for me that I cannot work before having all back to 
normal (all modules working such as ppgplot, gnuplot-py, Numeric, 
numarray, Scipy, matplotlib, etc, etc). And I am not even sure this will 
compile with Python 2.4. Anybody knows a way out of this?

-- 
===============================================================
Observatoire de Lyon                 ems...@ob...
9 av. Charles-Andre                      tel: +33 4 78 86 83 84
69561 Saint-Genis Laval Cedex            fax: +33 4 78 86 83 86
France               http://www-obs.univ-lyon1.fr/eric.emsellem
===============================================================

[Matplotlib-users] specifying NaN color when using imshow

[Gerald J. M. M. <Ger...@jp...>]

Hello,

I'm trying to plot some grid data using basemap and imshow however
haven't figured out how to specify the color for nan values.
For example, in my data, valid values range from 0.0-10.0.  I've
assigned -9999.0 and 1e30 to the missing values and when I imshow
(setting vmin=0.0, vmax=10.0), the missing values show up in the
low and high end of the spectrum, respectively.  Is there a way
to do this?

Thanks,

Gerald

[Matplotlib-users] widgets during plot interaction

[Charlie M. <cw...@gm...>]

Can anybody think of a good way to disable a widget (specifically
SpanSelector) during plot interaction from the toolbar?  It seems
wrong when you are panning and the SpanSelector is triggering over and
over.  Is there a trivial way to detect the state of the toolbar?

Thanks,
     Charlie

[Matplotlib-users] Bug with matplotlib-0.85 and numarray-1.4.1 on Python 2.4.2

[Randewijk P-J <pjr...@su...>]

If I say:

my_array =3D -my_other_array

I get the correct result.

However, if I say:

my_array =3D +my_other_array

Weired things happen...

It worked fine using numarray-1.3.3...

Part of my code looks as follows:

...
#Input current as a function of the output current
ia=3D0
ib=3D-iA
ic=3D+iA

iip_cbb=3Dsqrt(2.0/3)*(ia+ib*exp(-2j*pi/3)+ic*exp(+2j*pi/3))
...


The error code I get is:
>>>
Traceback (most recent call last):
File "C:\My Documents\My PhD\Python\helle\helle.py",
line 229, in ?

iip_cbb=3Dsqrt(2.0/3)*(ia+ib*exp(-2j*pi/3)+ic*exp(+2j*pi/3))
TypeError: unsupported operand type(s) for *: 'dict'
and 'complex'
>>>

I then "debuged" the results:

>>> ia
0
>>> ib
array([ -2.30940108e+02, -2.30061311e+02,
-2.27431609e+02,
-2.23071014e+02, -2.17012715e+02,
-2.09302818e+02,
-2.00000000e+02, -1.89175061e+02,
-1.76910386e+02,
...
2.23071014e+02, 2.27431609e+02,
2.30061311e+02,
2.30940108e+02])

It looks fine.

But the supprise was:
>>> ic
{'WE': WE, 'draw_if_interactive': <function
draw_if_interactive at 0x01914EF0>, 'show': <function
show at 0x01914F30>, 'text': <function text at
0x019C16B0>, 'hist': <function hist at 0x019C1130>,
'get_plot_commands': <function get_plot_commands at
0x019BD230>, 'entropy': <function entropy at
0x0178EEF0>, 'rot90': <function rot90 at 0x01763570>,
'rot': <function rot at 0x019C64B0>, 'find': <function
find at 0x01792030>, 'ptp': <function ptp at
0x017636B0>, 'contourf': <function contourf at
0x019BEE70>, 'Int32': Int32, 'inverse': <function
inverse at 0x01763E70>, 'randn': <function randn at
0x017633F0>, 'savefig': <function savefig at
0x019BE530>, 'title': <function title at 0x019BE930>,
'popd': <function popd at 0x017755B0>, 'putmask':
<function putmask at 0x00EB06F0>, 'PolarAxes': <class
matplotlib.axes.PolarAxes at 0x0190E120>, 'swapaxes':
<function swapaxes at 0x00EB1BF0>, 'blackman':
<function blackman at 0x01763A30>, 'center_matrix':
<function center_matrix at 0x017923B0>, 'norm':
<function norm at 0x01792A30>, 'vABr': array([
3.00000000e+02, 2.91878510e+02, 2.81491031e+02,
2.68872055e+02, 2.54073166e+02,
2.37162701e+02,
...
with lots and lots of garbage in between, ending with
...
l', 'ytick.labelsize': 'small', 'ps.papersize': 'a4',
'image.origin': 'upper'}, 'compress': <function
compress at 0x00EB1DB0>, 'UInt8': UInt8, 'amap':
<function amap at 0x01792870>, 'multiply': <UFunc:
'multiply'>, 'amax': <function max at 0x01763630>,
'delaxes': <function delaxes at 0x019BE270>,
'logical_not': <UFunc: 'logical_not'>, 'phib':
-2.0943951023931953, 'asum': <built-in method reduce of
_BinaryUFunc object at 0x01032288>, 'FixedLocator':
<class matplotlib.ticker.FixedLocator at 0x0187FD80>,
'detrend': <function detrend at 0x0178EB70>, 'Float':
Float64, 'base_repr': <function base_repr at
0x01792AF0>, 'hsv': <function hsv at 0x019C18B0>,
'orth': <function orth at 0x01792230>, 'hamming':
<function hamming at 0x01763AF0>, 'axvspan': <function
axvspan at 0x019BEDB0>, 'FuncFormatter': <class
matplotlib.ticker.FuncFormatter at 0x0187FBD0>, 'dot':
<built-in function dot>}
>>>

...
ic=3D(+iA)
...

Gives the same result...

Most of the garbage looks like matplotlib stuff...

I know the solution is to say:

...
ic=3DiA
...

without the "+", but this is a bug somewhere...

Kind regards,

Peter-Jan