matplotlib-devel Mailing List for matplotlib (Page 500)

Hi,

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

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

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

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

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

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

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

thanks,
James

from __future__ import division, generators

import math, sys

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

import numerix.ma as ma

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

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

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

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

import matplotlib

if matplotlib._havedate:
    from dates import date_ticker_factory


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

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

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

    """

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


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

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

    chars =3D [c for c in fmt]

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

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

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

    return linestyle, marker, color

class _process_plot_var_args:
    """

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

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

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

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

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

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

        self.count =3D 0

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

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

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


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


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

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

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

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

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

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

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

            return ret

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

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

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

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

        remaining =3D args
        while 1:

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

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


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

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

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

    axisbg is the color of the axis background

    """

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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


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

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

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

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

        Axis Horizontal Line

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

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

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

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

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


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

        Axis Vertical Line

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

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

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

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

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

        """

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


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

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

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

        kwargs are the kwargs to Patch, eg

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

        the terms on the right are aliases

        Return value is the patches.Polygon instance.

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


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

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

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

        kwargs are the kwargs to Patch, eg

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

        the terms on the right are aliases

        return value is the patches.Polygon instance.

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

        """


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

        return p

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

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

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

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


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

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

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


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

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

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

        self._autoscaleon =3D True

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

        self._set_artist_props(self.title)

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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

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

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

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

        width is a scalar that controls the width of the arrows

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


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

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

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

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

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


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



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

        Make a bar plot with rectangles at

          left, left+width, 0, height

        left and height are Numeric arrays.

        Return value is a list of Rectangle patch instances

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

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

            color specifies the color of the bar

            ecolor specifies the color of any errorbar

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


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

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

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

        patches =3D []


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


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

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

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


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

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

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

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

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

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

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

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

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

        x is a Numeric array

        Returns a list of the lines added

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

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

        row, col =3D x.shape

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

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

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

            wisk_x =3D ones(2) * pos

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

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

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

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


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

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

        return lines

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

            BARH(x, y)

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

            Return value is a list of Rectangle patch instances

        Optional arguments

            height - the height (thickness)  of the bar

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

            color specifies the color of the bar

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

            ecolor specifies the color of any errorbar

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

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

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

        patches =3D []


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


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

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

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

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

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

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

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

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

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


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

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

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

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

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

        kwargs are applied to the lines

        Returns the tuple Cxy, freqs

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

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

        return cxy, freqs


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

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

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

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

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

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

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

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

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

        return pxy, freqs

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

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

    def get_renderer_cache(self):
        return self._cachedRenderer

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

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

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

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

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


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


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

        # axis drawing was here, where contourf etc clobbered them

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

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

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

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

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

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

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


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

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

        self._cachedRenderer =3D renderer


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

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

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

        xerr and yerr may be any of:

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

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

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

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

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

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

            capsize is the size of the error bar caps in points

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

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

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

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


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

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

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

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

        l0 =3D None

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

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

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

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

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

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

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

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

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

        self.autoscale_view()

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

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

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

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

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

        Return value is a list of patches that were added

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

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

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

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

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

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


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

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

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

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


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

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


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

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

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

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

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

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

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

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

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


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

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

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


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

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

        The return values is (n, bins, patches)

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


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

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

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

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

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

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

d

After application of Daishi Harada's patch on 0.85, I tried to use it with 
SciPy core SVN from yesterday and get rather strange results:

x = scipy.array( [16.5]*10 )
y = scipy.array( [19.5]*10 )
w = scipy.arange(10)

# This plots a line at 16.0, not 16.5!
pylab.plot( w, x )

# However this works perfectly with a blue box 0-9 x 16.5x19.5
f = pylab.figure()
a = f.add_subplot( 1, 1, 1 )
a.fill( scipy.concatenate((w,w[::-1])), scipy.concatenate((x,y[::-1])) )
f.canvas.draw()

Further, the legend boxes are too large, usually obscuring most of the picture 
with a polygonal patch (such as the one produced by the fill above) or at 
least a half without any polygonal patches.

How can I help debug these issues?

Regards,
Ravi

Sorry about the delay in getting back to you
(I was away for a long weekend and just got
back in today).

On Nov 19, 2005, at 8:22 AM, John Hunter wrote:
>     daishi> This patch allows one to use matplotlib with (just) the
>     daishi> new scipy.
>
> Just for clarification, when you say "just" the new scipy, you mean
> that it works with Numeric, numarray *and* the new scipy, not that it
> works with the new scipy and only the new scipy.

The intent was so that current users of numeric/numarray
wouldn't see any difference at all, but that matplotlib
would build against the new scipy - I believe this is the
case, mod Fernando's fix.

> In the near term, this means that mpl would compile three
> shared object files for each of the three array objects for each
> extension module, which of course will increase compile times and
> binary distribution sizes.

As it currently stands, the patch will build at most *two*
shared objects, because the build logic is basically:

if numarray:
	# numarray build
if (numeric or scipy):
	# numeric or scipy build,
	# with numeric taking precedence.

It shouldn't be difficult to flatten this out to build
three libraries, however. I submitted the patch in its
preliminary form to see whether there was interest in
going this route at all, since I saw the discussion
about the unified/new array interface plan.

Fernando wrote:
> Minor fix needed to avoid unpleasant surprises for users who have the 
> old scipy on their import path:
>
> try:
>     import scipy
>     if hasattr(scipy,'__core_version__'):
>         NUMERIX.append('scipy')
> except ImportError:
>     pass
>
> You want to make sure that you only do this for users of the _new_ 
> scipy, not the old one.

Thanks and sorry about that, this problem
occurred to me over the weekend too.

d

Arg!  One petty thing after another.  Here is a simple script
demonstrating that the last row does not render the SpanSelector, yet
the callback works fine???

------------------------------------
import matplotlib
from matplotlib.widgets import SpanSelector
matplotlib.use('TkAgg')
from pylab import *

s =3D 3
axs =3D [subplot(s,s,i) for i in xrange(1,s**2+1)]
def onselect(x, y): print x, y
[SpanSelector(a, onselect, 'vertical', useblit=3DTrue) for a in axs]
show()
------------------------------------

Any clues as to where to look for this bug?  Sorry to be a hassle, but
I need this specifically to embed in a Tk only app.

Thanks,
     Charlie

On 11/19/05, John Hunter <jdh...@ac...> wrote:
> >>>>> "Charlie" =3D=3D Charlie Moad <cw...@gm...> writes:
>
>     Charlie> Awesome, thanks!  Out of curiousity... did you figure
>     Charlie> this out visually or by comparing with something?
>
> Let's just say I've encountered the flipy bug before :-)
>
> JDH
>

I'm very interested to see how stuff looks on a Mac.  I don't have
access to one, so I'll be looking forward to your results.

I still haven't figured out how to get antialiased lines in EMFs, so
the output doesn't look as good on the screen as all the agg
rendering.  But, if you push the dots per inch high enough in the
savefig() command, it looks decent.  It does have the advantage of
being a vector format, at least, so it resizes well. :)

It's really worked well for me to be able to embed multiple EMFs and
text and tables in an RTF, with everything machine generated by
Python.  Hopefully it works across platforms for you guys.

Rob

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

On Monday 21 November 2005 1:12 pm, Travis Oliphant wrote:
> Darren Dale wrote:
> >Sorry, I've obviously overlooked something, but maybe I have also
> > discovered a bug. I've just removed atlas/blas/lapack, updated scipy_core
> > from svn, removed my build and site-packages/scipy directories, and tried
> > to build scipy_core. Here is a warning message I get toward the end of
> > the build and install processes:
>
> This is definitely a configuration issue.  For some reason, the system
> is picking up BLAS information and therefore trying to compile _dotblas
> for you.   However, it is failing because the libblas file is not found.
>
> Can you show us the output of the start of the build (where SYSTEM INFO
> things are printed).  Or just attach a complete record of the build.
> This might help track down what the configuration issue is.

This was due to an oversight on my end. I used gentoo's package manager to 
completely remove atlas/blas/lapack, and afterwards verified that every 
instance of /usr/lib/libatlas.* had been removed. I did not check that 
libblas.* and liblapack.* had been removed, but I should have. Unfortunately, 
a few broken soft links remained, which scipy found and tried to build 
against. After removing those links, I was able to build scipy_core. How 
embarrassing. I'm sorry for the noise. 

Darren

Rob,
I think you may have just implemented/discovered/unearthed the Holy 
Grail!  This looks fantastic.  We have been fighting with EPS files for 
years and trying to come up with a way to have plots that can be embedded 
in Office documents that look good on the screen for presentations and 
still print well.

The EPS preview image has never worked very well and the resulting files 
almost always had problems when moved from MS Office on the PC to/from the 
Mac.  If your system works well across platforms, that could save the 
engineers here a lot of time.

We'll have to download this and give it a try.  Thanks!
Ted

At 06:03 PM 11/19/2005, Rob McMullen wrote:
>I just submitted a patch to add a new non-interactive backend that
>produces enhanced metafiles, an OpenOffice and Microsoft Windows
>scalable graphics format that can also be embedded in .rtf files.
>
>http://sourceforge.net/tracker/index.php?func=detail&aid=1361839&group_id=80706&atid=560722
>
>The backend is based on my pyemf package that I finally released with
>its first public beta:
>
>http://pyemf.sourceforge.net
>
>The API should be stable -- I'm only planning on adding to it and not
>changing any existing method signatures in the version 2.0.* series.
>
>Oh, and I didn't say so in the patch itself, but I'm happy to donate
>the patch to matplotlib under the default matplotlib license.
>
>Rob
>
>
>-------------------------------------------------------
>This SF.Net email is sponsored by the JBoss Inc.  Get Certified Today
>Register for a JBoss Training Course.  Free Certification Exam
>for All Training Attendees Through End of 2005. For more info visit:
>http://ads.osdn.com/?ad_idv28&alloc_id845&opclick
>_______________________________________________
>Matplotlib-devel mailing list
>Mat...@li...
>https://lists.sourceforge.net/lists/listinfo/matplotlib-devel

Ted Drain     Jet Propulsion Laboratory   ted...@jp...    

Currently implemented for PostScript backend only - the rest ignore the 
command.
I tried to make it in the same style as the rest of Matplotlib iface:
'x' does bidiagonal hatching
'/' does diagonal,
'-' does horizontal,
and so on.
Repeating the hatching symbol increases the density of hatching.

Attached is the diff for version 0.85.
Is there a chance for this thing to be included into the source?

On Sunday 20 November 2005 6:57 pm, Darren Dale wrote:
> On Sunday 20 November 2005 5:47 pm, Robert Kern wrote:
> > Darren Dale wrote:
> > > Will scipy_core ever include something like Numeric's lapack_lite?
> >
> > scipy_core does not depend on ATLAS. It already has lapack_lite.
> >
> > [svk-projects]$ ls scipy_core/scipy/corelib/lapack_lite
> > blas_lite.c         dlapack_lite.c      f2c_lite.c         
> > zlapack_lite.c dlamch.c            f2c.h              
> > lapack_litemodule.c

Sorry, I've obviously overlooked something, but maybe I have also discovered a 
bug. I've just removed atlas/blas/lapack, updated scipy_core from svn, 
removed my build and site-packages/scipy directories, and tried to build 
scipy_core. Here is a warning message I get toward the end of the build and 
install processes:

building 'scipy.lib._dotblas' extension
compiling C sources
i686-pc-linux-gnu-gcc options: '-pthread -fno-strict-aliasing -DNDEBUG -fPIC'
creating build/temp.linux-i686-2.4/scipy/corelib
creating build/temp.linux-i686-2.4/scipy/corelib/blasdot
compile options: '-DNO_ATLAS_INFO=1 -Iscipy/corelib/blasdot 
-Iscipy/base/include -Ibuild/src/scipy/base -Iscipy/base/src 
-I/usr/include/python2.4 -c'
i686-pc-linux-gnu-gcc: scipy/corelib/blasdot/_dotblas.c
/usr/bin/g77 -shared 
build/temp.linux-i686-2.4/scipy/corelib/blasdot/_dotblas.o -L/usr/lib -lblas 
-lg2c -o build/lib.linux-i686-2.4/scipy/lib/_dotblas.so
/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/../../../../i686-pc-linux-gnu/bin/ld: 
cannot find -lblas
collect2: ld returned 1 exit status
/usr/lib/gcc/i686-pc-linux-gnu/3.4.4/../../../../i686-pc-linux-gnu/bin/ld: 
cannot find -lblas
collect2: ld returned 1 exit status
error: Command "/usr/bin/g77 -shared 
build/temp.linux-i686-2.4/scipy/corelib/blasdot/_dotblas.o -L/usr/lib -lblas 
-lg2c -o build/lib.linux-i686-2.4/scipy/lib/_dotblas.so" failed with exit 
status 1

and here I try to import scipy:

In [1]: from scipy import *
---------------------------------------------------------------------------
exceptions.ImportError                               Traceback (most recent 
call last)

/home/darren/<console>

ImportError: No module named scipy

Darren

On Sunday 20 November 2005 5:47 pm, Robert Kern wrote:
> Darren Dale wrote:
> > The last couple of days, I have been thinking about scipy_core's atlas
> > dependency, which might be a big barrier for some. There is this issue
> > with getting the full lapack instead of the truncated version, for
> > example. I don't know how difficult it is to compile atlas, having been
> > screened from the process by gentoo's package manager. The mpl devs have
> > put a lot of effort into making mpl easily accessible to the newbies
> > (remember the backend issues circa 0.50?) so I am concerned about
> > erecting new barriers now. Will scipy_core ever include something like
> > Numeric's lapack_lite?
>
> scipy_core does not depend on ATLAS. It already has lapack_lite.
>
> [svk-projects]$ ls scipy_core/scipy/corelib/lapack_lite
> blas_lite.c         dlapack_lite.c      f2c_lite.c          zlapack_lite.c
> dlamch.c            f2c.h               lapack_litemodule.c

Interesting. A couple days ago I removed atlas, blas and lapack, removed my 
site.cfg, and was unable to install scipy_core. I'll try again, maybe I did 
something wrong.

>>>>> "Vineet" == Vineet Jain <vi...@al...> writes:

    Vineet> Hi, Do you know where I can get the 0.85 package for
    Vineet> ubuntu. I installed the one in:

    Vineet> http://peds-pc311.bsd.uchicago.edu binary/

    Vineet> but that is an older version.

I just updated the repository -- try updating and then reinstalling.

JDH

Darren Dale wrote:

> The last couple of days, I have been thinking about scipy_core's atlas  
> dependency, which might be a big barrier for some. There is this issue with 
> getting the full lapack instead of the truncated version, for example. I 
> don't know how difficult it is to compile atlas, having been screened from 
> the process by gentoo's package manager. The mpl devs have put a lot of 
> effort into making mpl easily accessible to the newbies (remember the backend 
> issues circa 0.50?) so I am concerned about erecting new barriers now. Will 
> scipy_core ever include something like Numeric's lapack_lite?

scipy_core does not depend on ATLAS. It already has lapack_lite.

[svk-projects]$ ls scipy_core/scipy/corelib/lapack_lite
blas_lite.c         dlapack_lite.c      f2c_lite.c          zlapack_lite.c
dlamch.c            f2c.h               lapack_litemodule.c

-- 
Robert Kern
rob...@gm...

"In the fields of hell where the grass grows high
 Are the graves of dreams allowed to die."
  -- Richard Harter

On Sunday 20 November 2005 1:55 am, Travis Oliphant wrote:
> John Hunter wrote:
> >Travis, Perry, Todd and I have been
> >discussing the benefits of changing matplotlib to work *only* with the
> >new scipy, which include faster build times, smaller binaries, less
> >complexity and pushing the community to a single array object.  Since
> >the new array interface works with Numeric 24, recent numarray or the
> >new scipy, *any* of these array packages would work with a matplotlib
> >compiled just for scipy.  We decided to hold off on doing this until
> >scipy installations issues were sorted out even on semi-obscure
> >platforms -- Travis, what's your sense of this?
>
> My sense is that scipy_core installation is working on as many platforms
> as Numeric did.  I'd personally love to see matplotlib move to a single
> scipy core build as soon as possible.  This would encourage even more
> installation and testing of the new scipy core and help us iron out any
> remaining issues even faster.
>
> However, as long as matplotlib users have a sense that this is the
> direction matplotlib is headed, I see nothing wrong with making a
> release with the 3-supported arrays (especially since somebody has done
> all of the work already :-) ), and then making a release after that
> build only with new scipy core.
>
> Just having the ability to build against new scipy will still encourage
> some to make the transition (and that will help with continued testing).

The last couple of days, I have been thinking about scipy_core's atlas  
dependency, which might be a big barrier for some. There is this issue with 
getting the full lapack instead of the truncated version, for example. I 
don't know how difficult it is to compile atlas, having been screened from 
the process by gentoo's package manager. The mpl devs have put a lot of 
effort into making mpl easily accessible to the newbies (remember the backend 
issues circa 0.50?) so I am concerned about erecting new barriers now. Will 
scipy_core ever include something like Numeric's lapack_lite?

As a staff scientist at a national lab, I will be creating tools to aid our 
users in data visualization and analysis. Some of our projects involve 
extensive outreach efforts, involving gradeschool, highschool, and colleges 
around the country. My collaborators don't care if they are using matlab, 
python or whatever, as long as it is easy to use and they can get their 
analysis done.

I suggest that mpl not commit to requiring scipy *instead* of numeric or 
numarray until scipy_core can be built without external math libraries (like 
numarray and Numeric), and has proved to be a piece of cake to install 
on the major os's/distributions known to be used in this community. For 
example, scipy/distutils is still missing a site.cfg.example. I've been around 
long enough to know about site.cfg from scipy-0.3.2, but even so, when I 
build on Gentoo, I still have to edit system_info.py for new scipy to find 
the blas libraries.

I'm impressed with scipy, and hope the numeric/numarray community will adopt 
it quickly. But I don't want to advocate using MPL as a vehicle to force such 
an adoption prematurely.

Respectfully,
Darren

Hi,

 

Do you know where I can get the 0.85 package for ubuntu. I installed the one
in:

 

http://peds-pc311.bsd.uchicago.edu binary/

 

but that is an older version.

 

Thanks,

 

VJ

 

John Hunter wrote:


.....
> So my inclination is to include your patch now, during a transition
> period, and then move over to a new scipy only build, retaining the
> numerix layer so Numeric, numarray and (new) scipy users can continue
> to use mpl transparently.  In particular we need to make sure that
> basemap which uses numarray.ndimage continues to work.
>   
John:

Basemap no longer uses nd_image, I've recoded the interp function in 
pure python, so it should work with scipy_core.

-Jeff

-- 
Jeffrey S. Whitaker         Phone  : (303)497-6313
Meteorologist               FAX    : (303)497-6449
NOAA/OAR/PSD  R/PSD1        Email  : Jef...@no...
325 Broadway                Office : Skaggs Research Cntr 1D-124
Boulder, CO, USA 80303-3328 Web    : http://tinyurl.com/5telg

John Hunter wrote:

>I read over the patch and it looks like you did a very thorough job.
>Thanks!  In the near term, this means that mpl would compile three
>shared object files for each of the three array objects for each
>extension module, which of course will increase compile times and
>binary distribution sizes.  Travis, Perry, Todd and I have been
>discussing the benefits of changing matplotlib to work *only* with the
>new scipy, which include faster build times, smaller binaries, less
>complexity and pushing the community to a single array object.  Since
>the new array interface works with Numeric 24, recent numarray or the
>new scipy, *any* of these array packages would work with a matplotlib
>compiled just for scipy.  We decided to hold off on doing this until
>scipy installations issues were sorted out even on semi-obscure
>platforms -- Travis, what's your sense of this?
>  
>
My sense is that scipy_core installation is working on as many platforms 
as Numeric did.  I'd personally love to see matplotlib move to a single 
scipy core build as soon as possible.  This would encourage even more 
installation and testing of the new scipy core and help us iron out any 
remaining issues even faster. 

However, as long as matplotlib users have a sense that this is the 
direction matplotlib is headed, I see nothing wrong with making a 
release with the 3-supported arrays (especially since somebody has done 
all of the work already :-) ), and then making a release after that 
build only with new scipy core. 

Just having the ability to build against new scipy will still encourage 
some to make the transition (and that will help with continued testing). 

>So my inclination is to include your patch now, during a transition
>period, and then move over to a new scipy only build, retaining the
>numerix layer so Numeric, numarray and (new) scipy users can continue
>to use mpl transparently.  In particular we need to make sure that
>basemap which uses numarray.ndimage continues to work.
>  
>
With the patch already submitted, I think this makes a lot of sense.  
I'd still like to encourage people to help us test scipy core, though.   
While you may still find occasional problems (which are typically fixed 
quickly), the system is working quite well.  The sooner we can merge to 
one array object, the more we will be able to help each other make it a 
better object, and the sooner we will be able to ease the burden of 
third-party packages that use arrays, and eliminate the need for heroic 
efforts like the numerix layer.

Best regards,

-Travis

I just submitted a patch to add a new non-interactive backend that
produces enhanced metafiles, an OpenOffice and Microsoft Windows
scalable graphics format that can also be embedded in .rtf files.

http://sourceforge.net/tracker/index.php?func=3Ddetail&aid=3D1361839&group_=
id=3D80706&atid=3D560722

The backend is based on my pyemf package that I finally released with
its first public beta:

http://pyemf.sourceforge.net

The API should be stable -- I'm only planning on adding to it and not
changing any existing method signatures in the version 2.0.* series.

Oh, and I didn't say so in the patch itself, but I'm happy to donate
the patch to matplotlib under the default matplotlib license.

Rob

John Hunter wrote:
>>>>>>"daishi" == daishi  <da...@eg...> writes:
> 
> 
>     daishi> I've submitted the following:
>     daishi> http://sourceforge.net/tracker/index.php?
>     daishi> func=detail&aid=1360855&group_id=80706&atid=560722
> 
>     daishi> This patch allows one to use matplotlib with (just) the
>     daishi> new scipy.
> 
> Just for clarification, when you say "just" the new scipy, you mean
> that it works with Numeric, numarray *and* the new scipy, not that it
> works with the new scipy and only the new scipy.
> 
> I read over the patch and it looks like you did a very thorough job.
> Thanks!

Minor fix needed to avoid unpleasant surprises for users who have the old 
scipy on their import path:

try:
     import scipy
     if hasattr(scipy,'__core_version__'):
         NUMERIX.append('scipy')
except ImportError:
     pass

You want to make sure that you only do this for users of the _new_ scipy, not 
the old one.

Cheers,

f

>>>>> "daishi" == daishi  <da...@eg...> writes:

    daishi> I've submitted the following:
    daishi> http://sourceforge.net/tracker/index.php?
    daishi> func=detail&aid=1360855&group_id=80706&atid=560722

    daishi> This patch allows one to use matplotlib with (just) the
    daishi> new scipy.

Just for clarification, when you say "just" the new scipy, you mean
that it works with Numeric, numarray *and* the new scipy, not that it
works with the new scipy and only the new scipy.

I read over the patch and it looks like you did a very thorough job.
Thanks!  In the near term, this means that mpl would compile three
shared object files for each of the three array objects for each
extension module, which of course will increase compile times and
binary distribution sizes.  Travis, Perry, Todd and I have been
discussing the benefits of changing matplotlib to work *only* with the
new scipy, which include faster build times, smaller binaries, less
complexity and pushing the community to a single array object.  Since
the new array interface works with Numeric 24, recent numarray or the
new scipy, *any* of these array packages would work with a matplotlib
compiled just for scipy.  We decided to hold off on doing this until
scipy installations issues were sorted out even on semi-obscure
platforms -- Travis, what's your sense of this?

So my inclination is to include your patch now, during a transition
period, and then move over to a new scipy only build, retaining the
numerix layer so Numeric, numarray and (new) scipy users can continue
to use mpl transparently.  In particular we need to make sure that
basemap which uses numarray.ndimage continues to work.

Does this sound like the right approach?

JDH

>>>>> "Charlie" == Charlie Moad <cw...@gm...> writes:

    Charlie> Awesome, thanks!  Out of curiousity... did you figure
    Charlie> this out visually or by comparing with something?

Let's just say I've encountered the flipy bug before :-)

JDH

Awesome, thanks!  Out of curiousity... did you figure this out
visually or by comparing with something?

- Charlie

On 11/18/05, John Hunter <jdh...@ac...> wrote:
> >>>>> "Charlie" =3D=3D Charlie Moad <cw...@gm...> writes:
>
>     Charlie> A challenge to the community! ;) Run the current
>     Charlie> cursor.py example with the TkAgg backend. (blitting
>     Charlie> should be on) i.e.  python cursor.py -dTkAgg
>
>     Charlie> Why does the blitting not update the entire axis?  Any
>     Charlie> help on this is greatly appreciated.
>
> THere was a flipy offset needed in _tkagg.cpp
>
>       int srcheight =3D (int)aggRenderer->get_height();
>       //...
>       desty =3D srcheight-(int)t;
>
> I just commited this to CVS -- take it for a test drive.
>
> Checking in src/_tkagg.cpp;
> /cvsroot/matplotlib/matplotlib/src/_tkagg.cpp,v  <--  _tkagg.cpp
> new revision: 1.10; previous revision: 1.9
>
> JDH
>

I've submitted the following:

	http://sourceforge.net/tracker/index.php? 
func=detail&aid=1360855&group_id=80706&atid=560722

This patch allows one to use matplotlib with (just)
the new scipy.

The matplotlib built with this patch and just
the new scipy passes the examples/backend_driver.py
test with errors only occuring on those tests which
explicitly includes numarray, and a few others which
i believe are unrelated to the patch.

There are some issues with parallel installation.
I have only tested this with a python installation that
has only the new scipy. In principle, this should be
compatible with a parallel installation of scipy and
numarray, but scipy and Numeric will not work, because
I select to build extensions only for one or the other.

d

>>>>> "Charlie" == Charlie Moad <cw...@gm...> writes:

    Charlie> A challenge to the community! ;) Run the current
    Charlie> cursor.py example with the TkAgg backend. (blitting
    Charlie> should be on) i.e.  python cursor.py -dTkAgg

    Charlie> Why does the blitting not update the entire axis?  Any
    Charlie> help on this is greatly appreciated.

THere was a flipy offset needed in _tkagg.cpp

      int srcheight = (int)aggRenderer->get_height();
      //...
      desty = srcheight-(int)t; 

I just commited this to CVS -- take it for a test drive.

Checking in src/_tkagg.cpp;
/cvsroot/matplotlib/matplotlib/src/_tkagg.cpp,v  <--  _tkagg.cpp
new revision: 1.10; previous revision: 1.9

JDH