matplotlib-devel Mailing List for matplotlib

Hi,

The logic for displaying a figure on the interactive backends (eg qt)
seems a little strange to me.  I imagine that normally the screen is
used as a preview for a figure that is going to be output on paper, or
to png or some permanent store.  Therefore, the interactive output
should resemble the permanent output as much as possible.

Now, when using the QtAgg backend (sorry no time to play with other
backends) setting the figure height or width has no effect on the size
of the figure displayed with show().  It always comes out at 600x400.

Further, given that the window can be resized or embedded, ideally
what is displayed should be as good a representation of the figure as
possible.  It is not, however.  To see this try resizing the window -
fonts sizes, linewidths, etc. stay the same size.

I can make the rendering more realistic using the dpi setting.  This
can be achieved using this implementation of resizeEvent (from
backend_qt_agg.py / FigureCanvasQtAgg).  The original code is
commented.

   def resizeEvent( self, e ):
       FigureCanvasQT.resizeEvent( self, e )
       w =3D e.size().width()
       h =3D e.size().height()
       if DEBUG: print "FigureCanvasQtAgg.resizeEvent(", w, ",", h, ")"
       #dpival =3D self.figure.dpi.get()
       #winch =3D w/dpival
       #hinch =3D h/dpival
       #self.figure.set_figsize_inches( winch, hinch )
       if w/self.figure.get_figwidth() < h/self.figure.get_figheight():
               self.figure.set_dpi( w/self.figure.get_figwidth() )
       else:
               self.figure.set_dpi( h/self.figure.get_figheight() )
       self.draw()

The original implementation doesn't really do anything to how the
figure is displayed.  The new one makes the plot appear how it should
no matter what the window's size.

This is not ideal, however, as if the figure is saved now the dpi will
be wrong.  So there are two questions really:  is this a better way
for the interactive windows to display?  If so, where should this
logic go?

thanks,
James

from __future__ import division, generators

import math, sys

from numerix import absolute, arange, array, asarray, ones, divide,\
     transpose, log, log10, Float, Float32, ravel, zeros,\
     Int16, Int32, Int, Float64, ceil, indices, \
     shape, which, where, sqrt, asum, compress, maximum, minimum

import numerix.ma as ma

import matplotlib.mlab
from artist import Artist, setp
from axis import XAxis, YAxis
from cbook import iterable, is_string_like, flatten, enumerate, \
     allequal, dict_delall, popd, popall, silent_list
from collections import RegularPolyCollection, PolyCollection, =
LineCollection
from colors import colorConverter, normalize, Colormap, =
LinearSegmentedColormap, looks_like_color
import cm
#from cm import ColormapJet, Grayscale, ScalarMappable
from cm import ScalarMappable
from contour import ContourSet
import _image
from ticker import AutoLocator, LogLocator, NullLocator
from ticker import ScalarFormatter, LogFormatter, LogFormatterExponent, =
LogFormatterMathtext, NullFormatter

from image import AxesImage
from legend import Legend
from lines import Line2D, lineStyles, lineMarkers

from matplotlib.mlab import meshgrid, detrend_none, detrend_linear, \
     window_none, window_hanning, linspace, prctile
from matplotlib.numerix.mlab import flipud, amin, amax

from matplotlib import rcParams
from patches import Patch, Rectangle, Circle, Polygon, Arrow, Wedge, =
Shadow, bbox_artist
from table import Table
from text import Text, TextWithDash, _process_text_args
from transforms import Bbox, Point, Value, Affine, =
NonseparableTransformation
from transforms import  FuncXY, Func, LOG10, IDENTITY, POLAR
from transforms import get_bbox_transform, unit_bbox, one, origin, zero
from transforms import blend_xy_sep_transform, Interval
from font_manager import FontProperties

import matplotlib

if matplotlib._havedate:
    from dates import date_ticker_factory


def _process_plot_format(fmt):
    """
    Process a matlab(TM) style color/line style format string.  Return a
    linestyle, color tuple as a result of the processing.  Default
    values are ('-', 'b').  Example format strings include

    'ko'    : black circles
    '.b'    : blue dots
    'r--'   : red dashed lines

    See Line2D.lineStyles and GraphicsContext.colors for all possible
    styles and color format string.

    """

    colors =3D {
        'b' : 1,
        'g' : 1,
        'r' : 1,
        'c' : 1,
        'm' : 1,
        'y' : 1,
        'k' : 1,
        'w' : 1,
        }


    linestyle =3D 'None'
    marker =3D 'None'
    color =3D rcParams['lines.color']

    # handle the multi char special cases and strip them from the
    # string
    if fmt.find('--')>=3D0:
        linestyle =3D '--'
        fmt =3D fmt.replace('--', '')
    if fmt.find('-.')>=3D0:
        linestyle =3D '-.'
        fmt =3D fmt.replace('-.', '')

    chars =3D [c for c in fmt]

    for c in chars:
        if lineStyles.has_key(c):
            if linestyle !=3D 'None':
                raise ValueError, 'Illegal format string "%s"; two =
linestyle symbols' % fmt

            linestyle =3D c
        elif lineMarkers.has_key(c):
            if marker !=3D 'None':
                raise ValueError, 'Illegal format string "%s"; two =
marker symbols' % fmt
            marker =3D c
        elif colors.has_key(c):
            color =3D c
        else:
            err =3D 'Unrecognized character %c in format string' % c
            raise ValueError, err

    if linestyle =3D=3D 'None' and marker =3D=3D 'None':
        linestyle =3D rcParams['lines.linestyle']

    return linestyle, marker, color

class _process_plot_var_args:
    """

    Process variable length arguments to the plot command, so that
    plot commands like the following are supported

      plot(t, s)
      plot(t1, s1, t2, s2)
      plot(t1, s1, 'ko', t2, s2)
      plot(t1, s1, 'ko', t2, s2, 'r--', t3, e3)

    an arbitrary number of x, y, fmt are allowed
    """

    def __init__(self, command=3D'plot'):
        self.command =3D command
        self._clear_color_cycle()

    def _clear_color_cycle(self):
        self.colors =3D ['b','g','r','c','m','y','k']
        # if the default line color is a color format string, move it up
        # in the que
        try: ind =3D self.colors.index(rcParams['lines.color'])
        except ValueError:
            self.firstColor =3D rcParams['lines.color']
        else:
            self.colors[0], self.colors[ind] =3D self.colors[ind], =
self.colors[0]
            self.firstColor =3D self.colors[0]

        self.Ncolors =3D len(self.colors)

        self.count =3D 0

    def __call__(self, *args, **kwargs):
        ret =3D  self._grab_next_args(*args, **kwargs)
        return ret

    def set_lineprops(self, line, **kwargs):
        assert self.command =3D=3D 'plot', 'set_lineprops only works =
with "plot"'
        for key, val in kwargs.items():
            funcName =3D "set_%s"%key
            if not hasattr(line,funcName):
                raise TypeError, 'There is no line property "%s"'%key
            func =3D getattr(line,funcName)
            func(val)

    def set_patchprops(self, fill_poly, **kwargs):
        assert self.command =3D=3D 'fill', 'set_patchprops only works =
with "fill"'
        for key, val in kwargs.items():
            funcName =3D "set_%s"%key
            if not hasattr(fill_poly,funcName):
                raise TypeError, 'There is no patch property "%s"'%key
            func =3D getattr(fill_poly,funcName)
            func(val)


    def is_filled(self, marker):
        filled =3D ('o', '^', 'v', '<', '>', 's',
                  'd', 'D', 'h', 'H',
                  'p')
        return marker in filled


    def _plot_1_arg(self, y, **kwargs):
        assert self.command =3D=3D 'plot', 'fill needs at least 2 =
arguments'
        if self.count=3D=3D0:
            color =3D self.firstColor
        else:
            color =3D self.colors[int(self.count % self.Ncolors)]

        assert(iterable(y))
        try: N=3Dmax(y.shape)
        except AttributeError: N =3D len(y)
        ret =3D  Line2D(arange(N), y,
                      color =3D color,
                      markerfacecolor=3Dcolor,
                      )
        self.set_lineprops(ret, **kwargs)
        self.count +=3D 1
        return ret

    def _plot_2_args(self, tup2, **kwargs):
        if is_string_like(tup2[1]):

            assert self.command =3D=3D 'plot', 'fill needs at least 2 =
non-string arguments'
            y, fmt =3D tup2
            assert(iterable(y))
            linestyle, marker, color =3D _process_plot_format(fmt)

            if self.is_filled(marker): mec =3D None # use default
            else: mec =3D color                     # use current color
            try: N=3Dmax(y.shape)
            except AttributeError: N =3D len(y)

            ret =3D  Line2D(xdata=3Darange(N), ydata=3Dy,
                          color=3Dcolor, linestyle=3Dlinestyle, =
marker=3Dmarker,
                          markerfacecolor=3Dcolor,
                          markeredgecolor=3Dmec,
                          )
            self.set_lineprops(ret, **kwargs)
            return ret
        else:

            x,y =3D tup2
            #print self.count, self.Ncolors, self.count % self.Ncolors
            assert(iterable(x))
            assert(iterable(y))
            if self.command =3D=3D 'plot':
                c =3D self.colors[self.count % self.Ncolors]
                ret =3D  Line2D(x, y,
                              color =3D c,
                              markerfacecolor =3D c,
                              )
                self.set_lineprops(ret, **kwargs)
                self.count +=3D 1
            elif self.command =3D=3D 'fill':
                ret =3D Polygon( zip(x,y), fill=3DTrue, )
                self.set_patchprops(ret, **kwargs)

            return ret

    def _plot_3_args(self, tup3, **kwargs):
        if self.command =3D=3D 'plot':
            x, y, fmt =3D tup3
            assert(iterable(x))
            assert(iterable(y))

            linestyle, marker, color =3D _process_plot_format(fmt)
            if self.is_filled(marker): mec =3D None # use default
            else: mec =3D color                     # use current color

            ret =3D Line2D(x, y, color=3Dcolor,
                         linestyle=3Dlinestyle, marker=3Dmarker,
                         markerfacecolor=3Dcolor,
                         markeredgecolor=3Dmec,
                         )
            self.set_lineprops(ret, **kwargs)
        if self.command =3D=3D 'fill':
            x, y, facecolor =3D tup3
            ret =3D Polygon(zip(x,y),
                          facecolor =3D facecolor,
                          fill=3DTrue,
                          )
            self.set_patchprops(ret, **kwargs)
        return ret

    def _grab_next_args(self, *args, **kwargs):

        remaining =3D args
        while 1:

            if len(remaining)=3D=3D0: return
            if len(remaining)=3D=3D1:
                yield self._plot_1_arg(remaining[0], **kwargs)
                remaining =3D []
                continue
            if len(remaining)=3D=3D2:
                yield self._plot_2_args(remaining, **kwargs)
                remaining =3D []
                continue
            if len(remaining)=3D=3D3:
                if not is_string_like(remaining[2]):
                    raise ValueError, 'third arg must be a format =
string'
                yield self._plot_3_args(remaining, **kwargs)
                remaining=3D[]
                continue
            if is_string_like(remaining[2]):
                yield self._plot_3_args(remaining[:3], **kwargs)
                remaining=3Dremaining[3:]
            else:
                yield self._plot_2_args(remaining[:2], **kwargs)
                remaining=3Dremaining[2:]
            #yield self._plot_2_args(remaining[:2])
            #remaining=3Dargs[2:]

BinOpType=3Dtype(zero())
def makeValue(v):
    if type(v) =3D=3D BinOpType:
        return v
    else:
        return Value(v)


class Axes(Artist):
    """
    Emulate matlab's (TM) axes command, creating axes with

       Axes(position=3D[left, bottom, width, height])

    where all the arguments are fractions in [0,1] which specify the
    fraction of the total figure window.

    axisbg is the color of the axis background

    """

    scaled =3D {IDENTITY : 'linear',
              LOG10 : 'log',
              }
    def __init__(self, fig, rect,
                 axisbg =3D None, # defaults to rc axes.facecolor
                 frameon =3D True,
                 sharex=3DNone, # use Axes instance's xaxis info
                 sharey=3DNone, # use Axes instance's yaxis info
                 label=3D'',
                 **kwargs
                 ):
        Artist.__init__(self)
        self._position =3D map(makeValue, rect)
        # must be set before set_figure
        self._sharex =3D sharex
        self._sharey =3D sharey
        self.set_label(label)
        self.set_figure(fig)

        # this call may differ for non-sep axes, eg polar
        self._init_axis()


        if axisbg is None: axisbg =3D rcParams['axes.facecolor']
        self._axisbg =3D axisbg
        self._frameon =3D frameon
        self._axisbelow =3D False  # todo make me an rcparam

        self._hold =3D rcParams['axes.hold']
        self._connected =3D {} # a dict from events to (id, func)
        self.cla()

        # funcs used to format x and y - fall back on major formatters
        self.fmt_xdata =3D None
        self.fmt_ydata =3D None

        self.set_cursor_props((1,'k')) # set the cursor properties for =
axes

        self._cachedRenderer =3D None
        self.set_navigate(True)

        # aspect ration atribute, and original position
        self._aspect =3D 'normal'
        self._originalPosition =3D self.get_position()

        if len(kwargs): setp(self, **kwargs)

    def _init_axis(self):
        "move this out of __init__ because non-separable axes don't use =
it"
        self.xaxis =3D XAxis(self)
        self.yaxis =3D YAxis(self)

    def set_cursor_props(self, *args):
        """
        Set the cursor property as
        ax.set_cursor_props(linewidth, color)  OR
        ax.set_cursor_props((linewidth, color))

        ACCEPTS: a (float, color) tuple
        """
        if len(args)=3D=3D1:
            lw, c =3D args[0]
        elif len(args)=3D=3D2:
            lw, c =3D args
        else:
            raise ValueError('args must be a (linewidth, color) tuple')
        c =3DcolorConverter.to_rgba(c)
        self._cursorProps =3D lw, c

    def get_cursor_props(self):
        """return the cursor props as a linewidth, color tuple where
        linewidth is a float and color is an RGBA tuple"""
        return self._cursorProps

    def set_figure(self, fig):
        """
        Set the Axes figure

        ACCEPTS: a Figure instance
        """
        Artist.set_figure(self, fig)

        l, b, w, h =3D self._position
        xmin =3D fig.bbox.ll().x()
        xmax =3D fig.bbox.ur().x()
        ymin =3D fig.bbox.ll().y()
        ymax =3D fig.bbox.ur().y()
        figw =3D xmax-xmin
        figh =3D ymax-ymin
        self.left   =3D  l*figw
        self.bottom =3D  b*figh
        self.right  =3D  (l+w)*figw
        self.top    =3D  (b+h)*figh


        self.bbox =3D Bbox( Point(self.left, self.bottom),
                          Point(self.right, self.top ),
                          )
        #these will be updated later as data is added
        self._set_lim_and_transforms()

    def _set_lim_and_transforms(self):
        """
        set the dataLim and viewLim BBox attributes and the
        transData and transAxes Transformation attributes
        """


        if self._sharex is not None:
            left=3Dself._sharex.viewLim.ll().x()
            right=3Dself._sharex.viewLim.ur().x()
        else:
            left=3Dzero()
            right=3Done()
        if self._sharey is not None:
            bottom=3Dself._sharey.viewLim.ll().y()
            top=3Dself._sharey.viewLim.ur().y()
        else:
            bottom=3Dzero()
            top=3Done()

        self.viewLim =3D Bbox(Point(left, bottom), Point(right, top))
        self.dataLim =3D unit_bbox()


        self.transData =3D get_bbox_transform(self.viewLim, self.bbox)
        self.transAxes =3D get_bbox_transform(unit_bbox(), self.bbox)

        if self._sharex:
            self.transData.set_funcx(self._sharex.transData.get_funcx())

        if self._sharey:
            self.transData.set_funcy(self._sharey.transData.get_funcy())

    def axhline(self, y=3D0, xmin=3D0, xmax=3D1, **kwargs):
        """
        AXHLINE(y=3D0, xmin=3D0, xmax=3D1, **kwargs)

        Axis Horizontal Line

        Draw a horizontal line at y from xmin to xmax.  With the default
        values of xmin=3D0 and xmax=3D1, this line will always span the =
horizontal
        extent of the axes, regardless of the xlim settings, even if you
        change them, eg with the xlim command.  That is, the horizontal =
extent
        is in axes coords: 0=3Dleft, 0.5=3Dmiddle, 1.0=3Dright but the y =
location is
        in data coordinates.

        Return value is the Line2D instance.  kwargs are the same as =
kwargs to
        plot, and can be used to control the line properties.  Eg

          # draw a thick red hline at y=3D0 that spans the xrange
          axhline(linewidth=3D4, color=3D'r')

          # draw a default hline at y=3D1 that spans the xrange
          axhline(y=3D1)

          # draw a default hline at y=3D.5 that spans the the middle =
half of
          # the xrange
          axhline(y=3D.5, xmin=3D0.25, xmax=3D0.75)
        """
        trans =3D blend_xy_sep_transform( self.transAxes, =
self.transData)
        l, =3D self.plot([xmin,xmax], [y,y], transform=3Dtrans, =
**kwargs)
        return l


    def axvline(self, x=3D0, ymin=3D0, ymax=3D1, **kwargs):
        """
        AXVLINE(x=3D0, ymin=3D0, ymax=3D1, **kwargs)

        Axis Vertical Line

        Draw a vertical line at x from ymin to ymax.  With the default =
values
        of ymin=3D0 and ymax=3D1, this line will always span the =
vertical extent
        of the axes, regardless of the xlim settings, even if you change =
them,
        eg with the xlim command.  That is, the vertical extent is in =
axes
        coords: 0=3Dbottom, 0.5=3Dmiddle, 1.0=3Dtop but the x location =
is in data
        coordinates.

        Return value is the Line2D instance.  kwargs are the same as
        kwargs to plot, and can be used to control the line properties.  =
Eg

            # draw a thick red vline at x=3D0 that spans the yrange
            l =3D axvline(linewidth=3D4, color=3D'r')

            # draw a default vline at x=3D1 that spans the yrange
            l =3D axvline(x=3D1)

            # draw a default vline at x=3D.5 that spans the the middle =
half of
            # the yrange
            axvline(x=3D.5, ymin=3D0.25, ymax=3D0.75)

        """

        trans =3D blend_xy_sep_transform( self.transData, self.transAxes =
)
        l, =3D self.plot([x,x], [ymin,ymax] , transform=3Dtrans, =
**kwargs)
        return l


    def axhspan(self, ymin, ymax, xmin=3D0, xmax=3D1, **kwargs):
        """
        AXHSPAN(ymin, ymax, xmin=3D0, xmax=3D1, **kwargs)

        Axis Horizontal Span.  ycoords are in data units and x
        coords are in axes (relative 0-1) units

        Draw a horizontal span (regtangle) from ymin to ymax.  With the
        default values of xmin=3D0 and xmax=3D1, this always span the =
xrange,
        regardless of the xlim settings, even if you change them, eg =
with the
        xlim command.  That is, the horizontal extent is in axes coords:
        0=3Dleft, 0.5=3Dmiddle, 1.0=3Dright but the y location is in =
data
        coordinates.

        kwargs are the kwargs to Patch, eg

          antialiased, aa
          linewidth,   lw
          edgecolor,   ec
          facecolor,   fc

        the terms on the right are aliases

        Return value is the patches.Polygon instance.

            #draws a gray rectangle from y=3D0.25-0.75 that spans the =
horizontal
            #extent of the axes
            axhspan(0.25, 0.75, facecolor=3D0.5, alpha=3D0.5)
        """
        trans =3D blend_xy_sep_transform( self.transAxes, self.transData =
 )
        verts =3D (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)
        p =3D Polygon(verts, **kwargs)
        p.set_transform(trans)
        self.add_patch(p)
        return p


    def axvspan(self, xmin, xmax, ymin=3D0, ymax=3D1, **kwargs):
        """
        AXVSPAN(xmin, xmax, ymin=3D0, ymax=3D1, **kwargs)

        axvspan : Axis Vertical Span.  xcoords are in data units and y =
coords
        are in axes (relative 0-1) units

        Draw a vertical span (regtangle) from xmin to xmax.  With the =
default
        values of ymin=3D0 and ymax=3D1, this always span the yrange, =
regardless
        of the ylim settings, even if you change them, eg with the ylim
        command.  That is, the vertical extent is in axes coords: =
0=3Dbottom,
        0.5=3Dmiddle, 1.0=3Dtop but the y location is in data =
coordinates.

        kwargs are the kwargs to Patch, eg

          antialiased, aa
          linewidth,   lw
          edgecolor,   ec
          facecolor,   fc

        the terms on the right are aliases

        return value is the patches.Polygon instance.

            # draw a vertical green translucent rectangle from x=3D1.25 =
to 1.55 that
            # spans the yrange of the axes
            axvspan(1.25, 1.55, facecolor=3D'g', alpha=3D0.5)

        """


        trans =3D blend_xy_sep_transform( self.transData, self.transAxes =
  )
        verts =3D [(xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, =
ymin)]
        p =3D Polygon(verts, **kwargs)
        p.set_transform(trans)
        self.add_patch(p)

        return p

    def format_xdata(self, x):
        """
        Return x string formatted.  This function will use the attribute
        self.fmt_xdata if it is callable, else will fall back on the =
xaxis
        major formatter
        """
        try: return self.fmt_xdata(x)
        except TypeError:
            func =3D self.xaxis.get_major_formatter().format_data
            val =3D func(x)
            return val

    def format_ydata(self, y):
        """
        Return y string formatted.  This function will use the attribute
        self.fmt_ydata if it is callable, else will fall back on the =
yaxis
        major formatter
        """
        try: return self.fmt_ydata(y)
        except TypeError:
            func =3D self.yaxis.get_major_formatter().format_data
            val =3D  func(y)
            return val

    def format_coord(self, x, y):
        'return a format string formatting the x, y coord'
       =20
        xs =3D self.format_xdata(x)
        ys =3D self.format_ydata(y)
        return  'x=3D%s, y=3D%s'%(xs,ys)

    def has_data(self):
        'return true if any artists have been added to axes'
        return (
            len(self.collections) +
            len(self.images) +
            len(self.lines) +
            len(self.patches))>0


    def _set_artist_props(self, a):
        'set the boilerplate props for artists added to axes'
        a.set_figure(self.figure)
        if not a.is_transform_set():
            a.set_transform(self.transData)
        a.axes =3D self

    def cla(self):
        'Clear the current axes'

        self.xaxis.cla()
        self.yaxis.cla()


        if self._sharex is not None:
            self.xaxis.major =3D self._sharex.xaxis.major
            self.xaxis.minor =3D self._sharex.xaxis.minor
        if self._sharey is not None:
            self.yaxis.major =3D self._sharey.yaxis.major
            self.yaxis.minor =3D self._sharey.yaxis.minor

        self._get_lines =3D _process_plot_var_args()
        self._get_patches_for_fill =3D _process_plot_var_args('fill')

        self._gridOn =3D rcParams['axes.grid']
        self.lines =3D []
        self.patches =3D []
        self.texts =3D []     # text in axis coords
        self.tables =3D []
        self.artists =3D []
        self.images =3D []
        self.legend_ =3D None
        self.collections =3D []  # collection.Collection instances

        self._autoscaleon =3D True

        self.grid(self._gridOn)
        self.title =3D  Text(
            x=3D0.5, y=3D1.02, text=3D'',
            =
fontproperties=3DFontProperties(size=3DrcParams['axes.titlesize']),
            verticalalignment=3D'bottom',
            horizontalalignment=3D'center',
            )
        self.title.set_transform(self.transAxes)
        self.title.set_clip_box(None)       =20

        self._set_artist_props(self.title)

        self.axesPatch =3D Rectangle(
            xy=3D(0,0), width=3D1, height=3D1,
            facecolor=3Dself._axisbg,
            edgecolor=3DrcParams['axes.edgecolor'],
            )
        self.axesPatch.set_figure(self.figure)
        self.axesPatch.set_transform(self.transAxes)
        self.axesPatch.set_linewidth(rcParams['axes.linewidth'])
        self.axison =3D True

    def add_artist(self, a):
        'Add any artist to the axes'
        self.artists.append(a)
        self._set_artist_props(a)

    def add_collection(self, collection):
        'add a Collection instance to Axes'
        self.collections.append(collection)
        self._set_artist_props(collection)
        collection.set_clip_box(self.bbox)

    def get_images(self):
        'return a list of Axes images contained by the Axes'
        return silent_list('AxesImage', self.images)

    def get_xscale(self):
        'return the xaxis scale string: log or linear'
        return self.scaled[self.transData.get_funcx().get_type()]

    def get_yscale(self):
        'return the yaxis scale string: log or linear'
        return self.scaled[self.transData.get_funcy().get_type()]

    def update_datalim(self, xys):
        'Update the data lim bbox with seq of xy tups'
        # if no data is set currently, the bbox will ignore it's
        # limits and set the bound to be the bounds of the xydata.
        # Otherwise, it will compute the bounds of it's current data
        # and the data in xydata
        self.dataLim.update(xys, not self.has_data())


    def update_datalim_numerix(self, x, y):
        'Update the data lim bbox with seq of xy tups'
        # if no data is set currently, the bbox will ignore it's
        # limits and set the bound to be the bounds of the xydata.
        # Otherwise, it will compute the bounds of it's current data
        # and the data in xydata
        #print type(x), type(y)
        self.dataLim.update_numerix(x, y, not self.has_data())

    def add_line(self, l):
        'Add a line to the list of plot lines'
        self._set_artist_props(l)
        l.set_clip_box(self.bbox)
        xdata =3D l.get_xdata(valid_only=3DTrue)
        ydata =3D l.get_ydata(valid_only=3DTrue)

        if l.get_transform() !=3D self.transData:
            xys =3D self._get_verts_in_data_coords(
                l.get_transform(), zip(xdata, ydata))
            xdata =3D array([x for x,y in xys])
            ydata =3D array([y for x,y in xys])

        self.update_datalim_numerix( xdata, ydata )
        #self.update_datalim(zip(xdata, ydata))
        label =3D l.get_label()
        if not label: l.set_label('line%d'%len(self.lines))
        self.lines.append(l)

    def _get_verts_in_data_coords(self, trans, xys):
        if trans =3D=3D self.transData:
            return xys
        # data is not in axis data units.  We must transform it to
        # display and then back to data to get it in data units
        xys =3D trans.seq_xy_tups(xys)
        return [ self.transData.inverse_xy_tup(xy) for xy in xys]

    def add_patch(self, p):
        """
        Add a patch to the list of Axes patches; the clipbox will be
        set to the Axes clipping box.  If the transform is not set, it
        wil be set to self.transData.
        """

        self._set_artist_props(p)
        p.set_clip_box(self.bbox)
        xys =3D self._get_verts_in_data_coords(
            p.get_transform(), p.get_verts())
        #for x,y in xys: print x,y
        self.update_datalim(xys)
        self.patches.append(p)

    def add_table(self, tab):
        'Add a table instance to the list of axes tables'
        self._set_artist_props(tab)
        self.tables.append(tab)


    def autoscale_view(self):
        'autoscale the view limits using the data limits'
        # if image data only just use the datalim

        if not self._autoscaleon: return
        if (len(self.images)>0 and
            len(self.lines)=3D=3D0 and
            len(self.patches)=3D=3D0):

            self.set_xlim(self.dataLim.intervalx().get_bounds())

            self.set_ylim(self.dataLim.intervaly().get_bounds())
            return


        locator =3D self.xaxis.get_major_locator()
        self.set_xlim(locator.autoscale())
        locator =3D self.yaxis.get_major_locator()
        self.set_ylim(locator.autoscale())

        if self._aspect =3D=3D 'equal': self.set_aspect('equal')

    def quiver(self, U, V, *args, **kwargs ):
        """
        QUIVER( X, Y, U, V )
        QUIVER( U, V )
        QUIVER( X, Y, U, V, S)
        QUIVER( U, V, S )
        QUIVER( ..., color=3DNone, width=3D1.0, cmap=3DNone,norm=3DNone =
)

        Make a vector plot (U, V) with arrows on a grid (X, Y)

        The optional arguments color and width are used to specify the =
color and width
        of the arrow. color can be an array of colors in which case the =
arrows can be
        colored according to another dataset.

        If cm is specied and color is None, the colormap is used to give =
a color
        according to the vector's length.

        If color is a scalar field, the colormap is used to map the =
scalar to a color
        If a colormap is specified and color is an array of color =
triplets, then the
        colormap is ignored

        width is a scalar that controls the width of the arrows

        if S is specified it is used to scale the vectors. Use S=3D0 to =
disable automatic
        scaling.
        If S!=3D0, vectors are scaled to fit within the grid and then =
are multiplied by S.


        """
        if not self._hold: self.cla()
        do_scale =3D True
        S =3D 1.0
        if len(args)=3D=3D0:
            # ( U, V )
            U =3D asarray(U)
            V =3D asarray(V)
            X,Y =3D meshgrid( arange(U.shape[1]), arange(U.shape[0]) )
        elif len(args)=3D=3D1:
            # ( U, V, S )
            U =3D asarray(U)
            V =3D asarray(V)
            X,Y =3D meshgrid( arange(U.shape[1]), arange(U.shape[0]) )
            S =3D float(args[0])
            do_scale =3D ( S !=3D 0.0 )
        elif len(args)=3D=3D2:
            # ( X, Y, U, V )
            X =3D asarray(U)
            Y =3D asarray(V)
            U =3D asarray(args[0])
            V =3D asarray(args[1])
        elif len(args)=3D=3D3:
            # ( X, Y, U, V )
            X =3D asarray(U)
            Y =3D asarray(V)
            U =3D asarray(args[0])
            V =3D asarray(args[1])
            S =3D float(args[2])
            do_scale =3D ( S !=3D 0.0 )

        assert U.shape =3D=3D V.shape
        assert X.shape =3D=3D Y.shape
        assert U.shape =3D=3D X.shape

        arrows =3D []
        N =3D sqrt( U**2+V**2 )
        if do_scale:
            Nmax =3D maximum.reduce(maximum.reduce(N)) or 1 # account =
for div by zero
            U =3D U*(S/Nmax)
            V =3D V*(S/Nmax)
            N =3D N*Nmax

        alpha =3D kwargs.get('alpha', 1.0)
        width =3D kwargs.get('width', 0.25)
        norm =3D kwargs.get('norm', None)
        cmap =3D kwargs.get('cmap', None)
        vmin =3D kwargs.get('vmin', None)
        vmax =3D kwargs.get('vmax', None)
        color =3D kwargs.get('color', None)
        shading =3D kwargs.get('shading', 'faceted')

        C =3D None
        I,J =3D U.shape
        if color is not None and not looks_like_color(color):
            clr =3D asarray(color)
            if clr.shape=3D=3DU.shape:
                C =3D array([ clr[i,j] for i in xrange(I)  for j in =
xrange(J)])
            elif clr.shape =3D=3D () and color:
                # a scalar (1, True,...)
                C =3D array([ N[i,j] for i in xrange(I)  for j in =
xrange(J)])
            else:
                color =3D (0.,0.,0.,1.)
        elif color is None:
            color =3D (0.,0.,0.,1.)
        else:
            color =3D colorConverter.to_rgba( color, alpha )


        arrows =3D [ Arrow(X[i,j],Y[i,j],U[i,j],V[i,j],0.1*S =
).get_verts()
                   for i in xrange(I) for j in xrange(J) ]
        collection =3D PolyCollection(
            arrows,
            edgecolors =3D 'None',
            facecolors =3D (color,),
            antialiaseds =3D (1,),
            linewidths =3D (width,),
            )
        if C is not None:
            collection.set_array( C )
        else:
            collection.set_facecolor( (color,) )
        collection.set_cmap(cmap)
        collection.set_norm(norm)
        if norm is not None:
            collection.set_clim( vmin, vmax )
        self.add_collection( collection )
        lims =3D asarray(arrows)
        _max =3D maximum.reduce( maximum.reduce( lims ))
        _min =3D minimum.reduce( minimum.reduce( lims ))
        self.update_datalim( [ tuple(_min), tuple(_max) ] )
        self.autoscale_view()
        return arrows



    def bar(self, left, height, width=3D0.8, bottom=3D0,
            color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3
            ):
        """
        BAR(left, height, width=3D0.8, bottom=3D0,
            color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3)

        Make a bar plot with rectangles at

          left, left+width, 0, height

        left and height are Numeric arrays.

        Return value is a list of Rectangle patch instances

        BAR(left, height, width, bottom,
            color, yerr, xerr, capsize, yoff)

            xerr and yerr, if not None, will be used to generate =
errorbars
              on the bar chart

            color specifies the color of the bar

            ecolor specifies the color of any errorbar

            capsize determines the length in points of the error bar =
caps


        The optional arguments color, width and bottom can be either
        scalars or len(x) sequences

        This enables you to use bar as the basis for stacked bar
        charts, or candlestick plots
        """
        if not self._hold: self.cla()

        # left =3D asarray(left) - width/2
        left =3D asarray(left)
        height =3D asarray(height)

        patches =3D []


        # if color looks like a color string, an RGB tuple or a
        # scalar, then repeat it by len(x)
        if (is_string_like(color) or
            (iterable(color) and len(color)=3D=3D3 and len(left)!=3D3) =
or
            not iterable(color)):
            color =3D [color]*len(left)


        if not iterable(bottom):
            bottom =3D array([bottom]*len(left), Float)
        else:
            bottom =3D asarray(bottom)
        if not iterable(width):
            width =3D array([width]*len(left), Float)
        else:
            width =3D asarray(width)

        N =3D len(left)
        assert len(bottom)=3D=3DN, 'bar arg bottom must be len(left)'
        assert len(width)=3D=3DN, 'bar arg width must be len(left) or =
scalar'
        assert len(height)=3D=3DN, 'bar arg height must be len(left) or =
scalar'
        assert len(color)=3D=3DN, 'bar arg color must be len(left) or =
scalar'

        args =3D zip(left, bottom, width, height, color)
        for l, b, w, h, c in args:
            if h<0:
                b +=3D h
                h =3D abs(h)
            r =3D Rectangle(
                xy=3D(l, b), width=3Dw, height=3Dh,
                facecolor=3Dc,
                )
            self.add_patch(r)
            patches.append(r)


        if xerr is not None or yerr is not None:
            self.errorbar(
                left+0.5*width, bottom+height,
                yerr=3Dyerr, xerr=3Dxerr,
                fmt=3DNone, ecolor=3Decolor, capsize=3Dcapsize)
        self.autoscale_view()
        return patches

    def boxplot(self, x, notch=3D0, sym=3D'b+', vert=3D1, whis=3D1.5,
                positions=3DNone, widths=3DNone):
        """
        boxplot(x, notch=3D0, sym=3D'+', vert=3D1, whis=3D1.5,
                positions=3DNone, widths=3DNone)

        Make a box and whisker plot for each column of x.
        The box extends from the lower to upper quartile values
        of the data, with a line at the median.  The whiskers
        extend from the box to show the range of the data.  Flier
        points are those past the end of the whiskers.

        notch =3D 0 (default) produces a rectangular box plot.
        notch =3D 1 will produce a notched box plot

        sym (default 'b+') is the default symbol for flier points.
        Enter an empty string ('') if you don't want to show fliers.

        vert =3D 1 (default) makes the boxes vertical.
        vert =3D 0 makes horizontal boxes.  This seems goofy, but
        that's how Matlab did it.

        whis (default 1.5) defines the length of the whiskers as
        a function of the inner quartile range.  They extend to the
        most extreme data point within ( whis*(75%-25%) ) data range.

        positions (default 1,2,...,n) sets the horizontal positions of
        the boxes. The ticks and limits are automatically set to match
        the positions.

        widths is either a scalar or a vector and sets the width of
        each box. The default is 0.5, or 0.15*(distance between extreme
        positions) if that is smaller.

        x is a Numeric array

        Returns a list of the lines added

        """
        if not self._hold: self.cla()
        holdStatus =3D self._hold
        lines =3D []
        x =3D asarray(x)

        # if we've got a vector, reshape it
        rank =3D len(x.shape)
        if 1 =3D=3D rank:
            x.shape =3D -1, 1

        row, col =3D x.shape

        # get some plot info
        if positions is None:
            positions =3D range(1, col + 1)
        if widths is None:
            distance =3D max(positions) - min(positions)
            widths =3D distance * min(0.15, 0.5/distance)
        if isinstance(widths, float) or isinstance(widths, int):
            widths =3D ones((col,), 'd') * widths

        # loop through columns, adding each to plot
        self.hold(True)
        for i,pos in enumerate(positions):
            d =3D x[:,i]
            # get median and quartiles
            q1, med, q3 =3D prctile(d,[25,50,75])
            # get high extreme
            iq =3D q3 - q1
            hi_val =3D q3 + whis*iq
            wisk_hi =3D compress( d <=3D hi_val , d )
            if len(wisk_hi) =3D=3D 0:
                wisk_hi =3D q3
            else:
                wisk_hi =3D max(wisk_hi)
            # get low extreme
            lo_val =3D q1 - whis*iq
            wisk_lo =3D compress( d >=3D lo_val, d )
            if len(wisk_lo) =3D=3D 0:
                wisk_lo =3D q1
            else:
                wisk_lo =3D min(wisk_lo)
            # get fliers - if we are showing them
            flier_hi =3D []
            flier_lo =3D []
            flier_hi_x =3D []
            flier_lo_x =3D []
            if len(sym) !=3D 0:
                flier_hi =3D compress( d > wisk_hi, d )
                flier_lo =3D compress( d < wisk_lo, d )
                flier_hi_x =3D ones(flier_hi.shape[0]) * pos
                flier_lo_x =3D ones(flier_lo.shape[0]) * pos

            # get x locations for fliers, whisker, whisker cap and box =
sides
            box_x_min =3D pos - widths[i] * 0.5
            box_x_max =3D pos + widths[i] * 0.5

            wisk_x =3D ones(2) * pos

            cap_x_min =3D pos - widths[i] * 0.25
            cap_x_max =3D pos + widths[i] * 0.25
            cap_x =3D [cap_x_min, cap_x_max]

            # get y location for median
            med_y =3D [med, med]

            # calculate 'regular' plot
            if notch =3D=3D 0:
                # make our box vectors
                box_x =3D [box_x_min, box_x_max, box_x_max, box_x_min, =
box_x_min ]
                box_y =3D [q1, q1, q3, q3, q1 ]
                # make our median line vectors
                med_x =3D [box_x_min, box_x_max]
            # calculate 'notch' plot
            else:
                notch_max =3D med + 1.57*iq/sqrt(row)
                notch_min =3D med - 1.57*iq/sqrt(row)
                if notch_max > q3:
                    notch_max =3D q3
                if notch_min < q1:
                    notch_min =3D q1
                # make our notched box vectors
                box_x =3D [box_x_min, box_x_max, box_x_max, cap_x_max, =
box_x_max, box_x_max, box_x_min, box_x_min, cap_x_min, box_x_min, =
box_x_min ]
                box_y =3D [q1, q1, notch_min, med, notch_max, q3, q3, =
notch_max, med, notch_min, q1]
                # make our median line vectors
                med_x =3D [cap_x_min, cap_x_max]
                med_y =3D [med, med]

            # make a vertical plot . . .
            if 1 =3D=3D vert:
                l =3D self.plot(wisk_x, [q1, wisk_lo], 'b--',
                              wisk_x, [q3, wisk_hi], 'b--',
                              cap_x, [wisk_hi, wisk_hi], 'k-',
                              cap_x, [wisk_lo, wisk_lo], 'k-',
                              box_x, box_y, 'b-',
                              med_x, med_y, 'r-',
                              flier_hi_x, flier_hi, sym,
                              flier_lo_x, flier_lo, sym )
                lines.extend(l)
            # or perhaps a horizontal plot
            else:
                l =3D self.plot([q1, wisk_lo], wisk_x, 'b--',
                              [q3, wisk_hi], wisk_x, 'b--',
                              [wisk_hi, wisk_hi], cap_x, 'k-',
                              [wisk_lo, wisk_lo], cap_x, 'k-',
                              box_y, box_x, 'b-',
                              med_y, med_x, 'r-',
                              flier_hi, flier_hi_x, sym,
                              flier_lo, flier_lo_x, sym )
                lines.extend(l)


        # fix our axes/ticks up a little
        if 1 =3D=3D vert:
            setticks, setlim =3D self.set_xticks, self.set_xlim
        else:
            setticks, setlim =3D self.set_yticks, self.set_ylim

        newlimits =3D min(positions)-0.5, max(positions)+0.5
        setlim(newlimits)
        setticks(positions)
           =20
        # reset hold status
        self.hold(holdStatus)

        return lines

    def barh(self, x, y, height=3D0.8, left=3D0,
            color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3
            ):
        """
        BARH(x, y, height=3D0.8, left=3D0,
             color=3D'b', yerr=3DNone, xerr=3DNone, ecolor=3D'k', =
capsize=3D3)

            BARH(x, y)

            The y values give the heights of the center of the bars.  =
The
            x values give the length of the bars.

            Return value is a list of Rectangle patch instances

        Optional arguments

            height - the height (thickness)  of the bar

            left  - the x coordinate of the left side of the bar

            color specifies the color of the bar

            xerr and yerr, if not None, will be used to generate =
errorbars
            on the bar chart

            ecolor specifies the color of any errorbar

            capsize determines the length in points of the error bar =
caps

        The optional arguments color, height and left can be either
        scalars or len(x) sequences
        """
        if not self._hold: self.cla()

        # left =3D asarray(left) - width/2
        x =3D asarray(x)
        y =3D asarray(y)

        patches =3D []


        # if color looks like a color string, and RGB tuple or a
        # scalar, then repeat it by len(x)
        if (is_string_like(color) or
            (iterable(color) and len(color)=3D=3D3 and len(left)!=3D3) =
or
            not iterable(color)):
            color =3D [color]*len(x)


        if not iterable(left):
            left =3D array([left]*len(x), Float)
        else:
            left =3D asarray(left)
        if not iterable(height):
            height =3D array([height]*len(x), Float)
        else:
            height =3D asarray(height)

        N =3D len(x)
        assert len(left)=3D=3DN, 'bar arg left must be len(x)'
        assert len(height)=3D=3DN, 'bar arg height must be len(x) or =
scalar'
        assert len(y)=3D=3DN, 'bar arg y must be len(x) or scalar'
        assert len(color)=3D=3DN, 'bar arg color must be len(x) or =
scalar'

        width =3D x
        right =3D left+x
        bottom =3D y - height/2.

        args =3D zip(left, bottom, width, height, color)
        for l, b, w, h, c in args:
            if h<0:
                b +=3D h
                h =3D abs(h)
            r =3D Rectangle(
                xy=3D(l, b), width=3Dw, height=3Dh,
                facecolor=3Dc,
                )
            self.add_patch(r)
            patches.append(r)

        if xerr is not None or yerr is not None:
            self.errorbar(
                right, y,
                yerr=3Dyerr, xerr=3Dxerr,
                fmt=3DNone, ecolor=3Decolor, capsize=3Dcapsize)
        self.autoscale_view()
        return patches

    def clear(self):
        'clear the axes'
        self.cla()

    def clabel(self, CS, *args, **kwargs):
        return CS.clabel(*args, **kwargs)
    clabel.__doc__ =3D ContourSet.clabel.__doc__

    def contour(self, *args, **kwargs):
        kwargs['filled'] =3D False
        return ContourSet(self, *args, **kwargs)
    contour.__doc__ =3D ContourSet.contour_doc

    def contourf(self, *args, **kwargs):
        kwargs['filled'] =3D True
        return ContourSet(self, *args, **kwargs)
    contourf.__doc__ =3D ContourSet.contour_doc


    def cohere(self, x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
               window=3Dwindow_hanning, noverlap=3D0, **kwargs):
        """
        COHERE(x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
              window=3Dwindow_hanning, noverlap=3D0)

        cohere the coherence between x and y.  Coherence is the =
normalized
        cross spectral density

          Cxy =3D |Pxy|^2/(Pxx*Pyy)

        The return value is (Cxy, f), where f are the frequencies of the
        coherence vector.

        See the PSD help for a description of the optional parameters.

        kwargs are applied to the lines

        Returns the tuple Cxy, freqs

        Refs: Bendat & Piersol -- Random Data: Analysis and Measurement
          Procedures, John Wiley & Sons (1986)
        """
        if not self._hold: self.cla()
        cxy, freqs =3D matplotlib.mlab.cohere(x, y, NFFT, Fs, detrend, =
window, noverlap)

        self.plot(freqs, cxy, **kwargs)
        self.set_xlabel('Frequency')
        self.set_ylabel('Coherence')
        self.grid(True)

        return cxy, freqs


    def csd(self, x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
            window=3Dwindow_hanning, noverlap=3D0):
        """
        CSD(x, y, NFFT=3D256, Fs=3D2, detrend=3Ddetrend_none,
            window=3Dwindow_hanning, noverlap=3D0)

        The cross spectral density Pxy by Welches average periodogram =
method.
        The vectors x and y are divided into NFFT length segments.  Each
        segment is detrended by function detrend and windowed by =
function
        window.  The product of the direct FFTs of x and y are averaged =
over
        each segment to compute Pxy, with a scaling to correct for power =
loss
        due to windowing.

        See the PSD help for a description of the optional parameters.

        Returns the tuple Pxy, freqs.  Pxy is the cross spectrum =
(complex
        valued), and 10*log10(|Pxy|) is plotted

        Refs:
          Bendat & Piersol -- Random Data: Analysis and Measurement
            Procedures, John Wiley & Sons (1986)

        """
        if not self._hold: self.cla()
        pxy, freqs =3D matplotlib.mlab.csd(x, y, NFFT, Fs, detrend, =
window, noverlap)
        pxy.shape =3D len(freqs),
        # pxy is complex

        self.plot(freqs, 10*log10(absolute(pxy)))
        self.set_xlabel('Frequency')
        self.set_ylabel('Cross Spectrum Magnitude (dB)')
        self.grid(True)
        vmin, vmax =3D self.viewLim.intervaly().get_bounds()

        intv =3D vmax-vmin
        step =3D 10*int(log10(intv))

        ticks =3D arange(math.floor(vmin), math.ceil(vmax)+1, step)
        self.set_yticks(ticks)

        return pxy, freqs

    def draw_artist(self, a):
        """
        This method can only be used after an initial draw which
        caches the renderer.  It is used to efficiently update Axes
        data (axis ticks, labels, etc are not updated)
        """
        assert self._cachedRenderer is not None
        a.draw(self._cachedRenderer)

    def redraw_in_frame(self):
        """
        This method can only be used after an initial draw which
        caches the renderer.  It is used to efficiently update Axes
        data (axis ticks, labels, etc are not updated)
        """
        assert self._cachedRenderer is not None
        self.draw(self._cachedRenderer, inframe=3DTrue)

    def get_renderer_cache(self):
        return self._cachedRenderer

    def draw(self, renderer=3DNone, inframe=3DFalse):
        "Draw everything (plot lines, axes, labels)"
        if renderer is None:
            renderer =3D self._cachedRenderer

        if renderer is None:
            raise RuntimeError('No renderer defined')
        if not self.get_visible(): return
        renderer.open_group('axes')

        try: self.transData.freeze()  # eval the lazy objects
        except ValueError:
            print >> sys.stderr, 'data freeze value error', =
self.get_position(), self.dataLim.get_bounds(), =
self.viewLim.get_bounds()
            raise
       =20
        self.transAxes.freeze()  # eval the lazy objects
        if self.axison:
            if self._frameon: self.axesPatch.draw(renderer)

        if len(self.images)=3D=3D1:
            im =3D self.images[0]
            im.draw(renderer)
        elif len(self.images)>1:

            # make a composite image blending alpha
            # list of (_image.Image, ox, oy)


            ims =3D [(im.make_image(),0,0) for im in self.images if =
im.get_visible()]


            im =3D _image.from_images(self.bbox.height(), =
self.bbox.width(), ims)
            im.is_grayscale =3D False
            l, b, w, h =3D self.bbox.get_bounds()
            renderer.draw_image(l, b, im, self.bbox)

        # axis drawing was here, where contourf etc clobbered them

        # draw axes here, so they are on top of most things
        if self._axisbelow:
            if self.axison and not inframe:
                self.xaxis.draw(renderer)
                self.yaxis.draw(renderer)

        artists =3D []
        artists.extend(self.collections)
        artists.extend(self.patches)
        artists.extend(self.lines)
        artists.extend(self.texts)

        # keep track of i to guarantee stable sort for python 2.2
        dsu =3D [ (a.zorder, i, a) for i, a in enumerate(artists)
                if not a.get_animated()]
        dsu.sort()

        for zorder, i, a in dsu:
            a.draw(renderer)

        self.title.draw(renderer)
        if 0: bbox_artist(self.title, renderer)
        # optional artists
        for a in self.artists:
            a.draw(renderer)

        if not self._axisbelow:
            if self.axison and not inframe:
                self.xaxis.draw(renderer)
                self.yaxis.draw(renderer)

        if self.legend_ is not None:
            self.legend_.draw(renderer)


        for table in self.tables:
            table.draw(renderer)

        self.transData.thaw()  # release the lazy objects
        self.transAxes.thaw()  # release the lazy objects
        renderer.close_group('axes')

        self._cachedRenderer =3D renderer


    def __draw_animate(self):
        # ignore for now; broken
        if self._lastRenderer is None:
            raise RuntimeError('You must first call ax.draw()')
        dsu =3D [(a.zorder, a) for a in self.animated.keys()]
        dsu.sort()
        renderer =3D self._lastRenderer
        renderer.blit()
        for tmp, a in dsu:
            a.draw(renderer)

    def errorbar(self, x, y, yerr=3DNone, xerr=3DNone,
                 fmt=3D'b-', ecolor=3DNone, capsize=3D3,
                 barsabove=3DFalse, **kwargs):
        """
        ERRORBAR(x, y, yerr=3DNone, xerr=3DNone,
                 fmt=3D'b-', ecolor=3DNone, capsize=3D3, =
barsabove=3DFalse)

        Plot x versus y with error deltas in yerr and xerr.
        Vertical errorbars are plotted if yerr is not None
        Horizontal errorbars are plotted if xerr is not None

        xerr and yerr may be any of:

            a rank-0, Nx1 Numpy array  - symmetric errorbars +/- value

            an N-element list or tuple - symmetric errorbars +/- value

            a rank-1, Nx2 Numpy array  - asymmetric errorbars =
-column1/+column2

        Alternatively, x, y, xerr, and yerr can all be scalars, which
        plots a single error bar at x, y.

            fmt is the plot format symbol for y.  if fmt is None, just
            plot the errorbars with no line symbols.  This can be useful
            for creating a bar plot with errorbars

            ecolor is a matplotlib color arg which gives the color the
            errorbar lines; if None, use the marker color.

            capsize is the size of the error bar caps in points

            barsabove, if True, will plot the errorbars above the plot =
symbols
            - default is below

            kwargs are passed on to the plot command for the markers.
              So you can add additional key=3Dvalue pairs to control the
              errorbar markers.  For example, this code makes big red
              squares with thick green edges

              >>> x,y,yerr =3D rand(3,10)
              >>> errorbar(x, y, yerr, marker=3D's',
                           mfc=3D'red', mec=3D'green', ms=3D20, mew=3D4)

             mfc, mec, ms and mew are aliases for the longer property
             names, markerfacecolor, markeredgecolor, markersize and
             markeredgewith.


        Return value is a length 2 tuple.  The first element is the
        Line2D instance for the y symbol lines.  The second element is
        a list of error bar lines.
        """
        if not self._hold: self.cla()
        # make sure all the args are iterable arrays
        if not iterable(x): x =3D asarray([x])
        else: x =3D asarray(x)

        if not iterable(y): y =3D asarray([y])
        else: y =3D asarray(y)

        if xerr is not None:
            if not iterable(xerr): xerr =3D asarray([xerr])
            else: xerr =3D asarray(xerr)

        if yerr is not None:
            if not iterable(yerr): yerr =3D asarray([yerr])
            else: yerr =3D asarray(yerr)

        l0 =3D None

        if barsabove and fmt is not None:
            l0, =3D self.plot(x,y,fmt,**kwargs)

        caplines =3D []
        barlines =3D []

        if xerr is not None:
            if len(xerr.shape) =3D=3D 1:
                left  =3D x-xerr
                right =3D x+xerr
            else:
                left  =3D x-xerr[0]
                right =3D x+xerr[1]

            barlines.extend( self.hlines(y, x, left) )
            barlines.extend( self.hlines(y, x, right) )
            caplines.extend( self.plot(left, y, '|', ms=3D2*capsize) )
            caplines.extend( self.plot(right, y, '|', ms=3D2*capsize) )

        if yerr is not None:
            if len(yerr.shape) =3D=3D 1:
                lower =3D y-yerr
                upper =3D y+yerr
            else:
                lower =3D y-yerr[0]
                upper =3D y+yerr[1]

            barlines.extend( self.vlines(x, y, upper ) )
            barlines.extend( self.vlines(x, y, lower ) )
            caplines.extend( self.plot(x, lower, '_', ms=3D2*capsize) )
            caplines.extend( self.plot(x, upper, '_', ms=3D2*capsize) )

        if not barsabove and fmt is not None:
            l0, =3D self.plot(x,y,fmt,**kwargs)

        if ecolor is None and l0 is None:
            ecolor =3D rcParams['lines.color']
        elif ecolor is None:
            ecolor =3D l0.get_color()

        for l in barlines:
            l.set_color(ecolor)
        for l in caplines:
            l.set_color(ecolor)
            l.set_markerfacecolor(ecolor)
            l.set_markeredgecolor(ecolor)

        self.autoscale_view()

        ret =3D silent_list('Line2D errorbar', caplines+barlines)
        return (l0, ret)

    def fill(self, *args, **kwargs):
        """
        FILL(*args, **kwargs)

        plot filled polygons.  *args is a variable length argument, =
allowing
        for multiple x,y pairs with an optional color format string; see =
plot
        for details on the argument parsing.  For example, all of the
        following are legal, assuming a is the Axis instance:

          ax.fill(x,y)            # plot polygon with vertices at x,y
          ax.fill(x,y, 'b' )      # plot polygon with vertices at x,y in =
blue

        An arbitrary number of x, y, color groups can be specified, as =
in
          ax.fill(x1, y1, 'g', x2, y2, 'r')

        Return value is a list of patches that were added

        The same color strings that plot supports are supported by the =
fill
        format string.

        The kwargs that are can be used to set line properties (any
        property that has a set_* method).  You can use this to set edge
        color, face color, etc.
        """
        if not self._hold: self.cla()
        patches =3D []
        for poly in self._get_patches_for_fill(*args, **kwargs):
            self.add_patch( poly )
            patches.append( poly )
        self.autoscale_view()
        return patches

    def get_axis_bgcolor(self):
        'Return the axis background color'
        return self._axisbg

    def get_child_artists(self):
        """
        Return a list of artists the axes contains.  Deprecated
        """
        artists =3D [self.title, self.axesPatch, self.xaxis, self.yaxis]
        artists.extend(self.lines)
        artists.extend(self.patches)
        artists.extend(self.texts)
        artists.extend(self.collections)
        if self.legend_ is not None:
            artists.append(self.legend_)
        return silent_list('Artist', artists)

    def get_frame(self):
        'Return the axes Rectangle frame'
        return self.axesPatch

    def get_legend(self):
        'Return the Legend instance, or None if no legend is defined'
        return self.legend_


    def get_lines(self):
        'Return a list of lines contained by the Axes'
        return silent_list('Line2D', self.lines)

    def get_xaxis(self):
        'Return the XAxis instance'
        return self.xaxis

    def get_xgridlines(self):
        'Get the x grid lines as a list of Line2D instances'
        return silent_list('Line2D xgridline', =
self.xaxis.get_gridlines())

    def get_xlim(self):
        'Get the x axis range [xmin, xmax]'
        return self.viewLim.intervalx().get_bounds()


    def get_xticklabels(self):
        'Get the xtick labels as a list of Text instances'
        return silent_list('Text xticklabel', =
self.xaxis.get_ticklabels())

    def get_xticklines(self):
        'Get the xtick lines as a list of Line2D instances'
        return silent_list('Text xtickline', self.xaxis.get_ticklines())


    def get_xticks(self):
        'Return the x ticks as a list of locations'
        return self.xaxis.get_ticklocs()

    def get_yaxis(self):
        'Return the YAxis instance'
        return self.yaxis

    def get_ylim(self):
        'Get the y axis range [ymin, ymax]'
        return self.viewLim.intervaly().get_bounds()

    def get_ygridlines(self):
        'Get the y grid lines as a list of Line2D instances'
        return silent_list('Line2D ygridline', =
self.yaxis.get_gridlines())

    def get_yticklabels(self):
        'Get the ytick labels as a list of Text instances'
        return silent_list('Text yticklabel', =
self.yaxis.get_ticklabels())

    def get_yticklines(self):
        'Get the ytick lines as a list of Line2D instances'
        return silent_list('Line2D ytickline', =
self.yaxis.get_ticklines())

    def get_yticks(self):
        'Return the y ticks as a list of locations'
        return self.yaxis.get_ticklocs()

    def get_frame_on(self):
        """
        Get whether the axes rectangle patch is drawn
        """
        return self._frameon

    def get_navigate(self):
        """
        Get whether the axes responds to navigation commands
        """
        return self._navigate


    def get_axisbelow(self):
        """
        Get whether axist below is true or not
        """
        return self._axisbelow

    def get_autoscale_on(self):
        """
        Get whether autoscaling is applied on plot commands
        """
        return self._autoscaleon

    def grid(self, b=3DNone):
        """
        Set the axes grids on or off; b is a boolean
        if b is None, toggle the grid state
        """
        self.xaxis.grid(b)
        self.yaxis.grid(b)


    def hist(self, x, bins=3D10, normed=3D0, bottom=3D0,
             orientation=3D'vertical', width=3DNone, **kwargs):
        """
        HIST(x, bins=3D10, normed=3D0, bottom=3D0, =
orientiation=3D'vertical', **kwargs)

        Compute the histogram of x.  bins is either an integer number of
        bins or a sequence giving the bins.  x are the data to be =
binned.

        The return values is (n, bins, patches)

        If normed is true, the first element of the return tuple will
        be the counts normalized to form a probability density, ie,
        n/(len(x)*dbin)


        orientation =3D 'horizontal' | 'vertical'.  If horizontal, barh
        will be used and the "bottom" kwarg will be the left.

        width: the width of the bars.  If None, automatically compute
        the width.

        kwargs are used to update the properties of the
        hist bars
        """
        if not self._hold: self.cla()
        n,bins =3D matplotlib.mlab.hist(x, bins, normed)
        if width is None: width =3D 0.9*(bins[1]-bins[0])
        if orienta...
 
[truncated message content]

On Nov 23, 2005, at 12:20 PM, Ravikiran Rajagopal wrote:
> After application of Daishi Harada's patch on 0.85, I tried to use it 
> with
> SciPy core SVN from yesterday and get rather strange results:

I'm sorry you're having troubles with the patch.
Unfortunately, I can't seem to recreate your problem.
I realize "works for me" isn't a particularly useful
response, but I'm afraid that's the best I can do
for now - and I'll be away again for Thanksgiving
until next week.

FWIW, I'm using the CVS matplotlib with the wx backend,
and the new scipy w/atlas.

d