from __future__ import division, generators

import math, warnings, new

import numpy as npy

import matplotlib.numerix.npyma as ma

import matplotlib

rcParams = matplotlib.rcParams

from matplotlib import artist as martist

from matplotlib import axis as maxis

from matplotlib import cbook

from matplotlib import collections as mcoll

from matplotlib import colors as mcolors

from matplotlib import contour as mcontour

from matplotlib import dates as mdates

from matplotlib import font_manager

from matplotlib import image as mimage

from matplotlib import legend as mlegend

from matplotlib import lines as mlines

from matplotlib import mlab

from matplotlib import patches as mpatches

from matplotlib import quiver as mquiver

from matplotlib import scale as mscale

from matplotlib import table as mtable

from matplotlib import text as mtext

from matplotlib import ticker as mticker

from matplotlib import transforms as mtransforms

iterable = cbook.iterable

is_string_like = cbook.is_string_like

def delete_masked_points(*args):

"""

Find all masked points in a set of arguments, and return

the arguments with only the unmasked points remaining.

The overall mask is calculated from any masks that are present.

If a mask is found, any argument that does not have the same

dimensions is left unchanged; therefore the argument list may

include arguments that can take string or array values, for

example.

Array arguments must have the same length; masked arguments must

be one-dimensional.

Written as a helper for scatter, but may be more generally

useful.

"""

masks = [ma.getmaskarray(x) for x in args if hasattr(x, 'mask')]

if len(masks) == 0:

return args

mask = reduce(ma.mask_or, masks)

margs = []

for x in args:

if (not is_string_like(x)

and iterable(x)

and len(x) == len(mask)):

if (hasattr(x, 'get_compressed_copy')):

compressed_x = x.get_compressed_copy(mask)

else:

compressed_x = ma.masked_array(x, mask=mask).compressed()

margs.append(compressed_x)

else:

margs.append(x)

return margs

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.

"""

linestyle = None

marker = None

color = None

# Is fmt just a colorspec?

try:

color = mcolors.colorConverter.to_rgb(fmt)

return linestyle, marker, color # Yes.

except ValueError:

pass # No, not just a color.

# handle the multi char special cases and strip them from the

# string

if fmt.find('--')>=0:

linestyle = '--'

fmt = fmt.replace('--', '')

if fmt.find('-.')>=0:

linestyle = '-.'

fmt = fmt.replace('-.', '')

if fmt.find(' ')>=0:

linestyle = 'None'

fmt = fmt.replace(' ', '')

chars = [c for c in fmt]

for c in chars:

if mlines.lineStyles.has_key(c):

if linestyle is not None:

raise ValueError(

'Illegal format string "%s"; two linestyle symbols' % fmt)

linestyle = c

elif mlines.lineMarkers.has_key(c):

if marker is not None:

raise ValueError(

'Illegal format string "%s"; two marker symbols' % fmt)

marker = c

elif mcolors.colorConverter.colors.has_key(c):

if color is not None:

raise ValueError(

'Illegal format string "%s"; two color symbols' % fmt)

color = c

else:

raise ValueError(

'Unrecognized character %c in format string' % c)

if linestyle is None and marker is None:

linestyle = rcParams['lines.linestyle']

if linestyle is None:

linestyle = 'None'

if marker is None:

marker = 'None'

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, axes, command='plot'):

self.axes = axes

self.command = command

self._clear_color_cycle()

def _clear_color_cycle(self):

self.colors = ['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 = self.colors.index(rcParams['lines.color'])

except ValueError:

self.firstColor = rcParams['lines.color']

else:

self.colors[0], self.colors[ind] = self.colors[ind], self.colors[0]

self.firstColor = self.colors[0]

self.Ncolors = len(self.colors)

self.count = 0

def _get_next_cycle_color(self):

if self.count==0:

color = self.firstColor

else:

color = self.colors[int(self.count % self.Ncolors)]

self.count += 1

return color

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

if self.axes.xaxis is not None and self.axes.yaxis is not None:

xunits = kwargs.pop( 'xunits', self.axes.xaxis.units)

yunits = kwargs.pop( 'yunits', self.axes.yaxis.units)

if xunits!=self.axes.xaxis.units:

self.axes.xaxis.set_units(xunits)

if yunits!=self.axes.yaxis.units:

self.axes.yaxis.set_units(yunits)

ret = self._grab_next_args(*args, **kwargs)

return ret

def set_lineprops(self, line, **kwargs):

assert self.command == 'plot', 'set_lineprops only works with "plot"'

for key, val in kwargs.items():

funcName = "set_%s"%key

if not hasattr(line,funcName):

raise TypeError, 'There is no line property "%s"'%key

func = getattr(line,funcName)

func(val)

def set_patchprops(self, fill_poly, **kwargs):

assert self.command == 'fill', 'set_patchprops only works with "fill"'

for key, val in kwargs.items():

funcName = "set_%s"%key

if not hasattr(fill_poly,funcName):

raise TypeError, 'There is no patch property "%s"'%key

func = getattr(fill_poly,funcName)

func(val)

def _xy_from_y(self, y):

if self.axes.yaxis is not None:

b = self.axes.yaxis.update_units(y)

if b: return npy.arange(len(y)), y, False

y = ma.asarray(y)

if len(y.shape) == 1:

y = y[:,npy.newaxis]

nr, nc = y.shape

x = npy.arange(nr)

if len(x.shape) == 1:

x = x[:,npy.newaxis]

return x,y, True

def _xy_from_xy(self, x, y):

if self.axes.xaxis is not None and self.axes.yaxis is not None:

bx = self.axes.xaxis.update_units(x)

by = self.axes.yaxis.update_units(y)

# right now multicol is not supported if either x or y are

# unit enabled but this can be fixed..

if bx or by: return x, y, False

x = ma.asarray(x)

y = ma.asarray(y)

if len(x.shape) == 1:

x = x[:,npy.newaxis]

if len(y.shape) == 1:

y = y[:,npy.newaxis]

nrx, ncx = x.shape

nry, ncy = y.shape

assert nrx == nry, 'Dimensions of x and y are incompatible'

if ncx == ncy:

return x, y, True

if ncx == 1:

x = npy.repeat(x, ncy, axis=1)

if ncy == 1:

y = npy.repeat(y, ncx, axis=1)

assert x.shape == y.shape, 'Dimensions of x and y are incompatible'

return x, y, True

def _plot_1_arg(self, y, **kwargs):

assert self.command == 'plot', 'fill needs at least 2 arguments'

ret = []

x, y, multicol = self._xy_from_y(y)

if multicol:

for j in range(y.shape[1]):

color = self._get_next_cycle_color()

seg = mlines.Line2D(x, y[:,j],

color = color,

axes=self.axes,

)

self.set_lineprops(seg, **kwargs)

ret.append(seg)

else:

color = self._get_next_cycle_color()

seg = mlines.Line2D(x, y,

color = color,

axes=self.axes,

)

self.set_lineprops(seg, **kwargs)

ret.append(seg)

return ret

def _plot_2_args(self, tup2, **kwargs):

ret = []

if is_string_like(tup2[1]):

assert self.command == 'plot', 'fill needs at least 2 non-string arguments'

y, fmt = tup2

x, y, multicol = self._xy_from_y(y)

linestyle, marker, color = _process_plot_format(fmt)

def makeline(x, y):

_color = color

if _color is None:

_color = self._get_next_cycle_color()

seg = mlines.Line2D(x, y,

color=_color,

linestyle=linestyle, marker=marker,

axes=self.axes,

)

self.set_lineprops(seg, **kwargs)

ret.append(seg)

if multicol:

for j in range(y.shape[1]):

makeline(x[:,j], y[:,j])

else:

makeline(x, y)

return ret

else:

x, y = tup2

x, y, multicol = self._xy_from_xy(x, y)

def makeline(x, y):

color = self._get_next_cycle_color()

seg = mlines.Line2D(x, y,

color=color,

axes=self.axes,

)

self.set_lineprops(seg, **kwargs)

ret.append(seg)

def makefill(x, y):

facecolor = self._get_next_cycle_color()

seg = mpatches.Polygon(zip(x, y),

facecolor = facecolor,

fill=True,

)

self.set_patchprops(seg, **kwargs)

ret.append(seg)

if self.command == 'plot': func = makeline

else: func = makefill

if multicol:

for j in range(y.shape[1]):

func(x[:,j], y[:,j])

else:

func(x, y)

return ret

def _plot_3_args(self, tup3, **kwargs):

ret = []

x, y, fmt = tup3

x, y, multicol = self._xy_from_xy(x, y)

linestyle, marker, color = _process_plot_format(fmt)

def makeline(x, y):

_color = color

if _color is None:

_color = self._get_next_cycle_color()

seg = mlines.Line2D(x, y,

color=_color,

linestyle=linestyle, marker=marker,

axes=self.axes,

)

self.set_lineprops(seg, **kwargs)

ret.append(seg)

def makefill(x, y):

facecolor = color

seg = mpatches.Polygon(zip(x, y),

facecolor = facecolor,

fill=True,

)

self.set_patchprops(seg, **kwargs)

ret.append(seg)

if self.command == 'plot': func = makeline

else: func = makefill

if multicol:

for j in range(y.shape[1]):

func(x[:,j], y[:,j])

else:

func(x, y)

return ret

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

remaining = args

while 1:

if len(remaining)==0: return

if len(remaining)==1:

for seg in self._plot_1_arg(remaining[0], **kwargs):

yield seg

remaining = []

continue

if len(remaining)==2:

for seg in self._plot_2_args(remaining, **kwargs):

yield seg

remaining = []

continue

if len(remaining)==3:

if not is_string_like(remaining[2]):

raise ValueError, 'third arg must be a format string'

for seg in self._plot_3_args(remaining, **kwargs):

yield seg

remaining=[]

continue

if is_string_like(remaining[2]):

for seg in self._plot_3_args(remaining[:3], **kwargs):

yield seg

remaining=remaining[3:]

else:

for seg in self._plot_2_args(remaining[:2], **kwargs):

yield seg

remaining=remaining[2:]

class Axes(martist.Artist):

"""

The Axes contains most of the figure elements: Axis, Tick, Line2D,

Text, Polygon etc, and sets the coordinate system

The Axes instance supports callbacks through a callbacks attribute

which is a cbook.CallbackRegistry instance. The events you can

connect to are 'xlim_changed' and 'ylim_changed' and the callback

will be called with func(ax) where ax is the Axes instance

"""

name = "rectilinear"

_shared_x_axes = cbook.Grouper()

_shared_y_axes = cbook.Grouper()

def __str__(self):

return "Axes(%g,%g;%gx%g)" % tuple(self._position.bounds)

def __init__(self, fig, rect,

axisbg = None, # defaults to rc axes.facecolor

frameon = True,

sharex=None, # use Axes instance's xaxis info

sharey=None, # use Axes instance's yaxis info

label='',

**kwargs

):

"""

Build an Axes instance in Figure with

rect=[left, bottom, width,height in Figure coords

adjustable: ['box' | 'datalim']

alpha: the alpha transparency

anchor: ['C', 'SW', 'S', 'SE', 'E', 'NE', 'N', 'NW', 'W']

aspect: ['auto' | 'equal' | aspect_ratio]

autoscale_on: boolean - whether or not to autoscale the viewlim

axis_bgcolor: any matplotlib color - see help(colors)

axisbelow: draw the grids and ticks below the other artists

cursor_props: a (float, color) tuple

figure: a Figure instance

frame_on: a boolean - draw the axes frame

label: the axes label

navigate: True|False

navigate_mode: the navigation toolbar button status: 'PAN', 'ZOOM', or None

position: [left, bottom, width,height in Figure coords

sharex: an Axes instance to share the x-axis with

sharey: an Axes instance to share the y-axis with

title: the title string

visible: a boolean - whether the axes is visible

xlabel: the xlabel

xlim: (xmin, xmax) view limits

xscale: [%(scale)s]

xticklabels: sequence of strings

xticks: sequence of floats

ylabel: the ylabel strings

ylim: (ymin, ymax) view limits

yscale: [%(scale)s]

yticklabels: sequence of strings

yticks: sequence of floats

""" % {'scale': ' | '.join([repr(x) for x in mscale.get_scale_names()])}

martist.Artist.__init__(self)

if isinstance(rect, mtransforms.Bbox):

self._position = rect

else:

self._position = mtransforms.Bbox.from_bounds(*rect)

self._originalPosition = self._position.frozen()

self.set_axes(self)

self.set_aspect('auto')

self.set_adjustable('box')

self.set_anchor('C')

self._sharex = sharex

self._sharey = sharey

if sharex is not None:

self._shared_x_axes.join(self, sharex)

if sharey is not None:

self._shared_y_axes.join(self, 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 = rcParams['axes.facecolor']

self._axisbg = axisbg

self._frameon = frameon

self._axisbelow = rcParams['axes.axisbelow']

self._hold = rcParams['axes.hold']

self._connected = {} # a dict from events to (id, func)

self.cla()

# funcs used to format x and y - fall back on major formatters

self.fmt_xdata = None

self.fmt_ydata = None

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

self._cachedRenderer = None

self.set_navigate(True)

self.set_navigate_mode(None)

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

if self.xaxis is not None:

self._xcid = self.xaxis.callbacks.connect('units finalize', self.relim)

if self.yaxis is not None:

self._ycid = self.yaxis.callbacks.connect('units finalize', self.relim)

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

'get the axes bounding box in display space; args and kwargs are empty'

return self.bbox

def _init_axis(self):

"move this out of __init__ because non-separable axes don't use it"

self.xaxis = maxis.XAxis(self)

self.yaxis = maxis.YAxis(self)

self._update_transScale()

def set_figure(self, fig):

"""

Set the Axes figure

ACCEPTS: a Figure instance

"""

martist.Artist.set_figure(self, fig)

self.bbox = mtransforms.TransformedBbox(self._position, fig.transFigure)

#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

transScale, transData, transLimits and transAxes

transformations.

"""

self.dataLim = mtransforms.Bbox.unit()

self.viewLim = mtransforms.Bbox.unit()

self.transAxes = mtransforms.BboxTransformTo(self.bbox)

# Transforms the x and y axis separately by a scale factor

# It is assumed that this part will have non-linear components

self.transScale = mtransforms.TransformWrapper(mtransforms.IdentityTransform())

# An affine transformation on the data, generally to limit the

# range of the axes

self.transLimits = mtransforms.BboxTransformFrom(

mtransforms.TransformedBbox(self.viewLim, self.transScale))

# The parentheses are important for efficiency here -- they

# group the last two (which are usually affines) separately

# from the first (which, with log-scaling can be non-affine).

self.transData = self.transScale + (self.transLimits + self.transAxes)

self._xaxis_transform = mtransforms.blended_transform_factory(

self.axes.transData, self.axes.transAxes)

self._yaxis_transform = mtransforms.blended_transform_factory(

self.axes.transAxes, self.axes.transData)

def get_xaxis_transform(self):

"""

Get the transformation used for drawing x-axis labels, ticks

and gridlines. The x-direction is in data coordinates and the

y-direction is in axis coordinates.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return self._xaxis_transform

def get_xaxis_text1_transform(self, pad_pixels):

"""

Get the transformation used for drawing x-axis labels, which

will add the given number of pad_pixels between the axes and

the label. The x-direction is in data coordinates and the

y-direction is in axis coordinates. Returns a 3-tuple of the

form:

(transform, valign, halign)

where valign and halign are requested alignments for the text.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return (self._xaxis_transform +

mtransforms.Affine2D().translate(0, -1 * pad_pixels),

"top", "center")

def get_xaxis_text2_transform(self, pad_pixels):

"""

Get the transformation used for drawing the secondary x-axis

labels, which will add the given number of pad_pixels between

the axes and the label. The x-direction is in data

coordinates and the y-direction is in axis coordinates.

Returns a 3-tuple of the form:

(transform, valign, halign)

where valign and halign are requested alignments for the text.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return (self._xaxis_transform +

mtransforms.Affine2D().translate(0, pad_pixels),

"bottom", "center")

def get_yaxis_transform(self):

"""

Get the transformation used for drawing y-axis labels, ticks

and gridlines. The x-direction is in axis coordinates and the

y-direction is in data coordinates.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return self._yaxis_transform

def get_yaxis_text1_transform(self, pad_pixels):

"""

Get the transformation used for drawing y-axis labels, which

will add the given number of pad_pixels between the axes and

the label. The x-direction is in axis coordinates and the

y-direction is in data coordinates. Returns a 3-tuple of the

form:

(transform, valign, halign)

where valign and halign are requested alignments for the text.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return (self._yaxis_transform +

mtransforms.Affine2D().translate(-1 * pad_pixels, 0),

"center", "right")

def get_yaxis_text2_transform(self, pad_pixels):

"""

Get the transformation used for drawing the secondary y-axis

labels, which will add the given number of pad_pixels between

the axes and the label. The x-direction is in axis

coordinates and the y-direction is in data coordinates.

Returns a 3-tuple of the form:

(transform, valign, halign)

where valign and halign are requested alignments for the text.

This transformation is primarily used by the Axis class, and

is meant to be overridden by new kinds of projections that may

need to place axis elements in different locations.

"""

return (self._yaxis_transform +

mtransforms.Affine2D().translate(pad_pixels, 0),

"center", "left")

def _update_transScale(self):

self.transScale.set(

mtransforms.blended_transform_factory(

self.xaxis.get_transform(), self.yaxis.get_transform()))

def get_position(self, original=False):

'Return the a copy of the axes rectangle as a Bbox'

if original:

return self._originalPosition.frozen()

else:

return self._position.frozen()

def set_position(self, pos, which='both'):

"""

Set the axes position with pos = [left, bottom, width, height]

in relative 0,1 coords

There are two position variables: one which is ultimately

used, but which may be modified by apply_aspect, and a second

which is the starting point for apply_aspect.

which = 'active' to change the first;

'original' to change the second;

'both' to change both

ACCEPTS: len(4) sequence of floats, or a Bbox object

"""

if not isinstance(pos, mtransforms.BboxBase):

pos = mtransforms.Bbox.from_bounds(*pos)

if which in ('both', 'active'):

self._position.set(pos)

if which in ('both', 'original'):

self._originalPosition.set(pos)

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 = self

def get_axes_patch(self):

"""

Returns the patch used to draw the background of the axes. It

is also used as the clipping path for any data elements on the

axes.

In the standard axes, this is a rectangle, but in other

projections it may not be.

Intended to be overridden by new projection types.

"""

return mpatches.Rectangle((0.0, 0.0), 1.0, 1.0)

def cla(self):

'Clear the current axes'

self.xaxis.cla()

self.yaxis.cla()

self.set_xscale('linear')

self.set_yscale('linear')

self.ignore_existing_data_limits = True

self.callbacks = cbook.CallbackRegistry(('xlim_changed', 'ylim_changed'))

if self._sharex is not None:

self.xaxis.major = self._sharex.xaxis.major

self.xaxis.minor = self._sharex.xaxis.minor

if self._sharey is not None:

self.yaxis.major = self._sharey.yaxis.major

self.yaxis.minor = self._sharey.yaxis.minor

self._get_lines = _process_plot_var_args(self)

self._get_patches_for_fill = _process_plot_var_args(self, 'fill')

self._gridOn = rcParams['axes.grid']

self.lines = []

self.patches = []

self.texts = []

self.tables = []

self.artists = []

self.images = []

self.legend_ = None

self.collections = [] # collection.Collection instances

self._autoscaleon = True

self.grid(self._gridOn)

props = font_manager.FontProperties(size=rcParams['axes.titlesize'])

self.titleOffsetTrans = mtransforms.Affine2D().translate(0.0, 10.0)

self.title = mtext.Text(

x=0.5, y=1.0, text='',

fontproperties=props,

verticalalignment='bottom',

horizontalalignment='center',

)

self.title.set_transform(self.transAxes + self.titleOffsetTrans)

self.title.set_clip_box(None)

self._set_artist_props(self.title)

self.axesPatch = self.get_axes_patch()

self.axesPatch.set_figure(self.figure)

self.axesPatch.set_facecolor(self._axisbg)

self.axesPatch.set_edgecolor(rcParams['axes.edgecolor'])

self.axesPatch.set_linewidth(rcParams['axes.linewidth'])

self.axesPatch.set_transform(self.transAxes)

self.axesFrame = self.get_axes_patch()

self.axesFrame.set_figure(self.figure)

self.axesFrame.set_facecolor(None)

self.axesFrame.set_edgecolor(rcParams['axes.edgecolor'])

self.axesFrame.set_linewidth(rcParams['axes.linewidth'])

self.axesFrame.set_transform(self.transAxes)

self.axesFrame.set_zorder(2.5)

self.axison = True

self.xaxis.set_clip_path(self.axesPatch)

self.yaxis.set_clip_path(self.axesPatch)

self.titleOffsetTrans.clear()

def clear(self):

'clear the axes'

self.cla()

def ishold(self):

'return the HOLD status of the axes'

return self._hold

def hold(self, b=None):

"""

HOLD(b=None)

Set the hold state. If hold is None (default), toggle the

hold state. Else set the hold state to boolean value b.

Eg

hold() # toggle hold

hold(True) # hold is on

hold(False) # hold is off

When hold is True, subsequent plot commands will be added to

the current axes. When hold is False, the current axes and

figure will be cleared on the next plot command

"""

if b is None: self._hold = not self._hold

else: self._hold = b

def get_aspect(self):

return self._aspect

def set_aspect(self, aspect, adjustable=None, anchor=None):

"""

aspect:

'auto' - automatic; fill position rectangle with data

'normal' - same as 'auto'; deprecated

'equal' - same scaling from data to plot units for x and y

num - a circle will be stretched such that the height

is num times the width. aspect=1 is the same as

aspect='equal'.

adjustable:

'box' - change physical size of axes

'datalim' - change xlim or ylim

anchor:

'C' - centered

'SW' - lower left corner

'S' - middle of bottom edge

'SE' - lower right corner

etc.

ACCEPTS: ['auto' | 'equal' | aspect_ratio]

"""

if aspect in ('normal', 'auto'):

self._aspect = 'auto'

elif aspect == 'equal':

self._aspect = 'equal'

else:

self._aspect = float(aspect) # raise ValueError if necessary

if adjustable is not None:

self.set_adjustable(adjustable)

if anchor is not None:

self.set_anchor(anchor)

def get_adjustable(self):

return self._adjustable

def set_adjustable(self, adjustable):

"""

ACCEPTS: ['box' | 'datalim']

"""

if adjustable in ('box', 'datalim'):

self._adjustable = adjustable

else:

raise ValueError('argument must be "box", or "datalim"')

def get_anchor(self):

return self._anchor

def set_anchor(self, anchor):

"""

ACCEPTS: ['C', 'SW', 'S', 'SE', 'E', 'NE', 'N', 'NW', 'W']

"""

if anchor in mtransforms.Bbox.coefs.keys() or len(anchor) == 2:

self._anchor = anchor

else:

raise ValueError('argument must be among %s' %

', '.join(mtransforms.BBox.coefs.keys()))

def get_data_ratio(self):

"""

Returns the aspect ratio of the raw data.

This method is intended to be overridden by new projection

types.

"""

xmin,xmax = self.get_xbound()

xsize = max(math.fabs(xmax-xmin), 1e-30)

ymin,ymax = self.get_ybound()

ysize = max(math.fabs(ymax-ymin), 1e-30)

return ysize/xsize

def apply_aspect(self, position):

'''

Use self._aspect and self._adjustable to modify the

axes box or the view limits.

'''

aspect = self.get_aspect()

if aspect == 'auto':

self.set_position( position , 'active')

return

if aspect == 'equal':

A = 1

else:

A = aspect

#Ensure at drawing time that any Axes involved in axis-sharing

# does not have its position changed.

if self in self._shared_x_axes or self in self._shared_y_axes:

self._adjustable = 'datalim'

figW,figH = self.get_figure().get_size_inches()

fig_aspect = figH/figW

if self._adjustable == 'box':

box_aspect = A * self.get_data_ratio()

pb = position.frozen()

pb1 = pb.shrunk_to_aspect(box_aspect, pb, fig_aspect)

self.set_position(pb1.anchored(self.get_anchor(), pb), 'active')

return

xmin,xmax = self.get_xbound()

xsize = max(math.fabs(xmax-xmin), 1e-30)

ymin,ymax = self.get_ybound()

ysize = max(math.fabs(ymax-ymin), 1e-30)

l,b,w,h = position.bounds

box_aspect = fig_aspect * (h/w)

data_ratio = box_aspect / A

y_expander = (data_ratio*xsize/ysize - 1.0)

#print 'y_expander', y_expander

# If y_expander > 0, the dy/dx viewLim ratio needs to increase

if abs(y_expander) < 0.005:

#print 'good enough already'

return

dL = self.dataLim

xr = 1.05 * dL.width

yr = 1.05 * dL.height

xmarg = xsize - xr

ymarg = ysize - yr

Ysize = data_ratio * xsize

Xsize = ysize / data_ratio

Xmarg = Xsize - xr

Ymarg = Ysize - yr

xm = 0 # Setting these targets to, e.g., 0.05*xr does not seem to help.

ym = 0

#print 'xmin, xmax, ymin, ymax', xmin, xmax, ymin, ymax

#print 'xsize, Xsize, ysize, Ysize', xsize, Xsize, ysize, Ysize

changex = (self in self._shared_y_axes

and self not in self._shared_x_axes)

changey = (self in self._shared_x_axes

and self not in self._shared_y_axes)

if changex and changey:

warnings.warn("adjustable='datalim' cannot work with shared x and y axes")

return

if changex:

adjust_y = False

else:

#print 'xmarg, ymarg, Xmarg, Ymarg', xmarg, ymarg, Xmarg, Ymarg

if xmarg > xm and ymarg > ym:

adjy = ((Ymarg > 0 and y_expander < 0)

or (Xmarg < 0 and y_expander > 0))

else:

adjy = y_expander > 0

#print 'y_expander, adjy', y_expander, adjy

adjust_y = changey or adjy #(Ymarg > xmarg)

if adjust_y:

yc = 0.5*(ymin+ymax)

y0 = yc - Ysize/2.0

y1 = yc + Ysize/2.0

self.set_ybound((y0, y1))

#print 'New y0, y1:', y0, y1

#print 'New ysize, ysize/xsize', y1-y0, (y1-y0)/xsize

else:

xc = 0.5*(xmin+xmax)

x0 = xc - Xsize/2.0

x1 = xc + Xsize/2.0

self.set_xbound((x0, x1))

#print 'New x0, x1:', x0, x1

#print 'New xsize, ysize/xsize', x1-x0, ysize/(x1-x0)