import collections.abc

import functools

import itertools

import logging

import math

from numbers import Number

import numpy as np

from numpy import ma

import matplotlib.category as _ # <-registers a category unit converter

import matplotlib.cbook as cbook

import matplotlib.collections as mcoll

import matplotlib.colors as mcolors

import matplotlib.contour as mcontour

import matplotlib.dates as _ # <-registers a date unit converter

import matplotlib.docstring as docstring

import matplotlib.image as mimage

import matplotlib.legend as mlegend

import matplotlib.lines as mlines

import matplotlib.markers as mmarkers

import matplotlib.mlab as mlab

import matplotlib.patches as mpatches

import matplotlib.path as mpath

import matplotlib.quiver as mquiver

import matplotlib.stackplot as mstack

import matplotlib.streamplot as mstream

import matplotlib.table as mtable

import matplotlib.text as mtext

import matplotlib.ticker as mticker

import matplotlib.transforms as mtransforms

import matplotlib.tri as mtri

from matplotlib import _preprocess_data, rcParams

from matplotlib.axes._base import _AxesBase, _process_plot_format

from matplotlib.axes._secondary_axes import SecondaryAxis

from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer

try:

from numpy.lib.histograms import (

histogram_bin_edges as _histogram_bin_edges)

except ImportError:

# this function is new in np 1.15

def _histogram_bin_edges(arr, bins, range=None, weights=None):

# this in True for 1D arrays, and False for None and str

if np.ndim(bins) == 1:

return bins

if isinstance(bins, str):

# rather than backporting the internals, just do the full

# computation. If this is too slow for users, they can

# update numpy, or pick a manual number of bins

return np.histogram(arr, bins, range, weights)[1]

else:

if bins is None:

# hard-code numpy's default

bins = 10

if range is None:

range = np.min(arr), np.max(arr)

return np.linspace(*range, bins + 1)

_log = logging.getLogger(__name__)

def _make_inset_locator(bounds, trans, parent):

"""

Helper function to locate inset axes, used in

`.Axes.inset_axes`.

A locator gets used in `Axes.set_aspect` to override the default

locations... It is a function that takes an axes object and

a renderer and tells `set_aspect` where it is to be placed.

Here *rect* is a rectangle [l, b, w, h] that specifies the

location for the axes in the transform given by *trans* on the

*parent*.

"""

_bounds = mtransforms.Bbox.from_bounds(*bounds)

_trans = trans

_parent = parent

def inset_locator(ax, renderer):

bbox = _bounds

bb = mtransforms.TransformedBbox(bbox, _trans)

tr = _parent.figure.transFigure.inverted()

bb = mtransforms.TransformedBbox(bb, tr)

return bb

return inset_locator

# The axes module contains all the wrappers to plotting functions.

# All the other methods should go in the _AxesBase class.

class Axes(_AxesBase):

"""

The `Axes` contains most of the figure elements: `~.axis.Axis`,

`~.axis.Tick`, `~.lines.Line2D`, `~.text.Text`, `~.patches.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.

Attributes

----------

dataLim : `.Bbox`

The bounding box enclosing all data displayed in the Axes.

viewLim : `.Bbox`

The view limits in data coordinates.

"""

### Labelling, legend and texts

@cbook.deprecated("3.1")

@property

def aname(self):

return 'Axes'

def get_title(self, loc="center"):

"""

Get an axes title.

Get one of the three available axes titles. The available titles

are positioned above the axes in the center, flush with the left

edge, and flush with the right edge.

Parameters

----------

loc : {'center', 'left', 'right'}, str, optional

Which title to get, defaults to 'center'.

Returns

-------

title : str

The title text string.

"""

titles = {'left': self._left_title,

'center': self.title,

'right': self._right_title}

title = cbook._check_getitem(titles, loc=loc.lower())

return title.get_text()

def set_title(self, label, fontdict=None, loc=None, pad=None,

**kwargs):

"""

Set a title for the axes.

Set one of the three available axes titles. The available titles

are positioned above the axes in the center, flush with the left

edge, and flush with the right edge.

Parameters

----------

label : str

Text to use for the title

fontdict : dict

A dictionary controlling the appearance of the title text,

the default *fontdict* is::

{'fontsize': rcParams['axes.titlesize'],

'fontweight' : rcParams['axes.titleweight'],

'color' : rcParams['axes.titlecolor'],

'verticalalignment': 'baseline',

'horizontalalignment': loc}

loc : {'center', 'left', 'right'}, str, optional

Which title to set.

If *None*, defaults to :rc:`axes.titlelocation`.

pad : float

The offset of the title from the top of the axes, in points.

If *None*, defaults to :rc:`axes.titlepad`.

Returns

-------

text : :class:`~matplotlib.text.Text`

The matplotlib text instance representing the title

Other Parameters

----------------

**kwargs : `~matplotlib.text.Text` properties

Other keyword arguments are text properties, see

:class:`~matplotlib.text.Text` for a list of valid text

properties.

"""

if loc is None:

loc = rcParams['axes.titlelocation']

titles = {'left': self._left_title,

'center': self.title,

'right': self._right_title}

title = cbook._check_getitem(titles, loc=loc.lower())

default = {

'fontsize': rcParams['axes.titlesize'],

'fontweight': rcParams['axes.titleweight'],

'verticalalignment': 'baseline',

'horizontalalignment': loc.lower()}

titlecolor = rcParams['axes.titlecolor']

if not cbook._str_lower_equal(titlecolor, 'auto'):

default["color"] = titlecolor

if pad is None:

pad = rcParams['axes.titlepad']

self._set_title_offset_trans(float(pad))

title.set_text(label)

title.update(default)

if fontdict is not None:

title.update(fontdict)

title.update(kwargs)

return title

def get_xlabel(self):

"""

Get the xlabel text string.

"""

label = self.xaxis.get_label()

return label.get_text()

def set_xlabel(self, xlabel, fontdict=None, labelpad=None, **kwargs):

"""

Set the label for the x-axis.

Parameters

----------

xlabel : str

The label text.

labelpad : scalar, optional, default: None

Spacing in points from the axes bounding box including ticks

and tick labels.

Other Parameters

----------------

**kwargs : `.Text` properties

`.Text` properties control the appearance of the label.

See also

--------

text : for information on how override and the optional args work

"""

if labelpad is not None:

self.xaxis.labelpad = labelpad

return self.xaxis.set_label_text(xlabel, fontdict, **kwargs)

def get_ylabel(self):

"""

Get the ylabel text string.

"""

label = self.yaxis.get_label()

return label.get_text()

def set_ylabel(self, ylabel, fontdict=None, labelpad=None, **kwargs):

"""

Set the label for the y-axis.

Parameters

----------

ylabel : str

The label text.

labelpad : scalar, optional, default: None

Spacing in points from the axes bounding box including ticks

and tick labels.

Other Parameters

----------------

**kwargs : `.Text` properties

`.Text` properties control the appearance of the label.

See also

--------

text : for information on how override and the optional args work

"""

if labelpad is not None:

self.yaxis.labelpad = labelpad

return self.yaxis.set_label_text(ylabel, fontdict, **kwargs)

def get_legend_handles_labels(self, legend_handler_map=None):

"""

Return handles and labels for legend

``ax.legend()`` is equivalent to ::

h, l = ax.get_legend_handles_labels()

ax.legend(h, l)

"""

# pass through to legend.

handles, labels = mlegend._get_legend_handles_labels([self],

legend_handler_map)

return handles, labels

@docstring.dedent_interpd

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

"""

Place a legend on the axes.

Call signatures::

legend()

legend(labels)

legend(handles, labels)

The call signatures correspond to three different ways how to use

this method.

**1. Automatic detection of elements to be shown in the legend**

The elements to be added to the legend are automatically determined,

when you do not pass in any extra arguments.

In this case, the labels are taken from the artist. You can specify

them either at artist creation or by calling the

:meth:`~.Artist.set_label` method on the artist::

line, = ax.plot([1, 2, 3], label='Inline label')

ax.legend()

or::

line, = ax.plot([1, 2, 3])

line.set_label('Label via method')

ax.legend()

Specific lines can be excluded from the automatic legend element

selection by defining a label starting with an underscore.

This is default for all artists, so calling `Axes.legend` without

any arguments and without setting the labels manually will result in

no legend being drawn.

**2. Labeling existing plot elements**

To make a legend for lines which already exist on the axes

(via plot for instance), simply call this function with an iterable

of strings, one for each legend item. For example::

ax.plot([1, 2, 3])

ax.legend(['A simple line'])

Note: This way of using is discouraged, because the relation between

plot elements and labels is only implicit by their order and can

easily be mixed up.

**3. Explicitly defining the elements in the legend**

For full control of which artists have a legend entry, it is possible

to pass an iterable of legend artists followed by an iterable of

legend labels respectively::

legend((line1, line2, line3), ('label1', 'label2', 'label3'))

Parameters

----------

handles : sequence of `.Artist`, optional

A list of Artists (lines, patches) to be added to the legend.

Use this together with *labels*, if you need full control on what

is shown in the legend and the automatic mechanism described above

is not sufficient.

The length of handles and labels should be the same in this

case. If they are not, they are truncated to the smaller length.

labels : list of str, optional

A list of labels to show next to the artists.

Use this together with *handles*, if you need full control on what

is shown in the legend and the automatic mechanism described above

is not sufficient.

Other Parameters

----------------

%(_legend_kw_doc)s

Returns

-------

legend : `~matplotlib.legend.Legend`

Notes

-----

Not all kinds of artist are supported by the legend command. See

:doc:`/tutorials/intermediate/legend_guide` for details.

Examples

--------

.. plot:: gallery/text_labels_and_annotations/legend.py

"""

handles, labels, extra_args, kwargs = mlegend._parse_legend_args(

[self],

*args,

**kwargs)

if len(extra_args):

raise TypeError('legend only accepts two non-keyword arguments')

self.legend_ = mlegend.Legend(self, handles, labels, **kwargs)

self.legend_._remove_method = self._remove_legend

return self.legend_

def _remove_legend(self, legend):

self.legend_ = None

def inset_axes(self, bounds, *, transform=None, zorder=5,

**kwargs):

"""

Add a child inset axes to this existing axes.

Warnings

--------

This method is experimental as of 3.0, and the API may change.

Parameters

----------

bounds : [x0, y0, width, height]

Lower-left corner of inset axes, and its width and height.

transform : `.Transform`

Defaults to `ax.transAxes`, i.e. the units of *rect* are in

axes-relative coordinates.

zorder : number

Defaults to 5 (same as `.Axes.legend`). Adjust higher or lower

to change whether it is above or below data plotted on the

parent axes.

**kwargs

Other keyword arguments are passed on to the `.Axes` child axes.

Returns

-------

ax

The created `~.axes.Axes` instance.

Examples

--------

This example makes two inset axes, the first is in axes-relative

coordinates, and the second in data-coordinates::

fig, ax = plt.subplots()

ax.plot(range(10))

axin1 = ax.inset_axes([0.8, 0.1, 0.15, 0.15])

axin2 = ax.inset_axes(

[5, 7, 2.3, 2.3], transform=ax.transData)

"""

if transform is None:

transform = self.transAxes

label = kwargs.pop('label', 'inset_axes')

# This puts the rectangle into figure-relative coordinates.

inset_locator = _make_inset_locator(bounds, transform, self)

bb = inset_locator(None, None)

inset_ax = Axes(self.figure, bb.bounds, zorder=zorder,

label=label, **kwargs)

# this locator lets the axes move if in data coordinates.

# it gets called in `ax.apply_aspect() (of all places)

inset_ax.set_axes_locator(inset_locator)

self.add_child_axes(inset_ax)

return inset_ax

def indicate_inset(self, bounds, inset_ax=None, *, transform=None,

facecolor='none', edgecolor='0.5', alpha=0.5,

zorder=4.99, **kwargs):

"""

Add an inset indicator to the axes. This is a rectangle on the plot

at the position indicated by *bounds* that optionally has lines that

connect the rectangle to an inset axes (`.Axes.inset_axes`).

Warnings

--------

This method is experimental as of 3.0, and the API may change.

Parameters

----------

bounds : [x0, y0, width, height]

Lower-left corner of rectangle to be marked, and its width

and height.

inset_ax : `.Axes`

An optional inset axes to draw connecting lines to. Two lines are

drawn connecting the indicator box to the inset axes on corners

chosen so as to not overlap with the indicator box.

transform : `.Transform`

Transform for the rectangle co-ordinates. Defaults to

`ax.transAxes`, i.e. the units of *rect* are in axes-relative

coordinates.

facecolor : Matplotlib color

Facecolor of the rectangle (default 'none').

edgecolor : Matplotlib color

Color of the rectangle and color of the connecting lines. Default

is '0.5'.

alpha : float

Transparency of the rectangle and connector lines. Default is 0.5.

zorder : float

Drawing order of the rectangle and connector lines. Default is 4.99

(just below the default level of inset axes).

**kwargs

Other keyword arguments are passed on to the rectangle patch.

Returns

-------

rectangle_patch : `.patches.Rectangle`

The indicator frame.

connector_lines : 4-tuple of `.patches.ConnectionPatch`

The four connector lines connecting to (lower_left, upper_left,

lower_right upper_right) corners of *inset_ax*. Two lines are

set with visibility to *False*, but the user can set the

visibility to True if the automatic choice is not deemed correct.

"""

# to make the axes connectors work, we need to apply the aspect to

# the parent axes.

self.apply_aspect()

if transform is None:

transform = self.transData

label = kwargs.pop('label', 'indicate_inset')

x, y, width, height = bounds

rectangle_patch = mpatches.Rectangle(

(x, y), width, height,

facecolor=facecolor, edgecolor=edgecolor, alpha=alpha,

zorder=zorder, label=label, transform=transform, **kwargs)

self.add_patch(rectangle_patch)

connects = []

if inset_ax is not None:

# connect the inset_axes to the rectangle

for xy_inset_ax in [(0, 0), (0, 1), (1, 0), (1, 1)]:

# inset_ax positions are in axes coordinates

# The 0, 1 values define the four edges if the inset_ax

# lower_left, upper_left, lower_right upper_right.

ex, ey = xy_inset_ax

if self.xaxis.get_inverted():

ex = 1 - ex

if self.yaxis.get_inverted():

ey = 1 - ey

xy_data = x + ex * width, y + ey * height

p = mpatches.ConnectionPatch(

xyA=xy_inset_ax, coordsA=inset_ax.transAxes,

xyB=xy_data, coordsB=self.transData,

arrowstyle="-", zorder=zorder,

edgecolor=edgecolor, alpha=alpha)

connects.append(p)

self.add_patch(p)

# decide which two of the lines to keep visible....

pos = inset_ax.get_position()

bboxins = pos.transformed(self.figure.transFigure)

rectbbox = mtransforms.Bbox.from_bounds(

*bounds

).transformed(transform)

x0 = rectbbox.x0 < bboxins.x0

x1 = rectbbox.x1 < bboxins.x1

y0 = rectbbox.y0 < bboxins.y0

y1 = rectbbox.y1 < bboxins.y1

connects[0].set_visible(x0 ^ y0)

connects[1].set_visible(x0 == y1)

connects[2].set_visible(x1 == y0)

connects[3].set_visible(x1 ^ y1)

return rectangle_patch, tuple(connects) if connects else None

def indicate_inset_zoom(self, inset_ax, **kwargs):

"""

Add an inset indicator rectangle to the axes based on the axis

limits for an *inset_ax* and draw connectors between *inset_ax*

and the rectangle.

Warnings

--------

This method is experimental as of 3.0, and the API may change.

Parameters

----------

inset_ax : `.Axes`

Inset axes to draw connecting lines to. Two lines are

drawn connecting the indicator box to the inset axes on corners

chosen so as to not overlap with the indicator box.

**kwargs

Other keyword arguments are passed on to `.Axes.indicate_inset`

Returns

-------

rectangle_patch : `.Patches.Rectangle`

Rectangle artist.

connector_lines : 4-tuple of `.Patches.ConnectionPatch`

Each of four connector lines coming from the rectangle drawn on

this axis, in the order lower left, upper left, lower right,

upper right.

Two are set with visibility to *False*, but the user can

set the visibility to *True* if the automatic choice is not deemed

correct.

"""

xlim = inset_ax.get_xlim()

ylim = inset_ax.get_ylim()

rect = (xlim[0], ylim[0], xlim[1] - xlim[0], ylim[1] - ylim[0])

return self.indicate_inset(rect, inset_ax, **kwargs)

@docstring.dedent_interpd

def secondary_xaxis(self, location, *, functions=None, **kwargs):

"""

Add a second x-axis to this axes.

For example if we want to have a second scale for the data plotted on

the xaxis.

%(_secax_docstring)s

Examples

--------

The main axis shows frequency, and the secondary axis shows period.

.. plot::

fig, ax = plt.subplots()

ax.loglog(range(1, 360, 5), range(1, 360, 5))

ax.set_xlabel('frequency [Hz]')

def invert(x):

return 1 / x

secax = ax.secondary_xaxis('top', functions=(invert, invert))

secax.set_xlabel('Period [s]')

plt.show()

"""

if (location in ['top', 'bottom'] or isinstance(location, Number)):

secondary_ax = SecondaryAxis(self, 'x', location, functions,

**kwargs)

self.add_child_axes(secondary_ax)

return secondary_ax

else:

raise ValueError('secondary_xaxis location must be either '

'a float or "top"/"bottom"')

@docstring.dedent_interpd

def secondary_yaxis(self, location, *, functions=None, **kwargs):

"""

Add a second y-axis to this axes.

For example if we want to have a second scale for the data plotted on

the yaxis.

%(_secax_docstring)s

Examples

--------

Add a secondary axes that converts from radians to degrees

.. plot::

fig, ax = plt.subplots()

ax.plot(range(1, 360, 5), range(1, 360, 5))

ax.set_ylabel('degrees')

secax = ax.secondary_yaxis('right', functions=(np.deg2rad,

np.rad2deg))

secax.set_ylabel('radians')

"""

if location in ['left', 'right'] or isinstance(location, Number):

secondary_ax = SecondaryAxis(self, 'y', location,

functions, **kwargs)

self.add_child_axes(secondary_ax)

return secondary_ax

else:

raise ValueError('secondary_yaxis location must be either '

'a float or "left"/"right"')

@cbook._delete_parameter("3.1", "withdash")

def text(self, x, y, s, fontdict=None, withdash=False, **kwargs):

"""

Add text to the axes.

Add the text *s* to the axes at location *x*, *y* in data coordinates.

Parameters

----------

x, y : scalars

The position to place the text. By default, this is in data

coordinates. The coordinate system can be changed using the

*transform* parameter.

s : str

The text.

fontdict : dictionary, optional, default: None

A dictionary to override the default text properties. If fontdict

is None, the defaults are determined by your rc parameters.

withdash : boolean, optional, default: False

Creates a `~matplotlib.text.TextWithDash` instance instead of a

`~matplotlib.text.Text` instance.

Returns

-------

text : `.Text`

The created `.Text` instance.

Other Parameters

----------------

**kwargs : `~matplotlib.text.Text` properties.

Other miscellaneous text parameters.

Examples

--------

Individual keyword arguments can be used to override any given

parameter::

>>> text(x, y, s, fontsize=12)

The default transform specifies that text is in data coords,

alternatively, you can specify text in axis coords ((0, 0) is

lower-left and (1, 1) is upper-right). The example below places

text in the center of the axes::

>>> text(0.5, 0.5, 'matplotlib', horizontalalignment='center',

... verticalalignment='center', transform=ax.transAxes)

You can put a rectangular box around the text instance (e.g., to

set a background color) by using the keyword *bbox*. *bbox* is

a dictionary of `~matplotlib.patches.Rectangle`

properties. For example::

>>> text(x, y, s, bbox=dict(facecolor='red', alpha=0.5))

"""

if fontdict is None:

fontdict = {}

effective_kwargs = {

'verticalalignment': 'baseline',

'horizontalalignment': 'left',

'transform': self.transData,

'clip_on': False,

**fontdict,

**kwargs,

}

# At some point if we feel confident that TextWithDash

# is robust as a drop-in replacement for Text and that

# the performance impact of the heavier-weight class

# isn't too significant, it may make sense to eliminate

# the withdash kwarg and simply delegate whether there's

# a dash to TextWithDash and dashlength.

if (withdash

and withdash is not cbook.deprecation._deprecated_parameter):

t = mtext.TextWithDash(x, y, text=s)

else:

t = mtext.Text(x, y, text=s)

t.update(effective_kwargs)

t.set_clip_path(self.patch)

self._add_text(t)

return t

@docstring.dedent_interpd

def annotate(self, s, xy, *args, **kwargs):

a = mtext.Annotation(s, xy, *args, **kwargs)

a.set_transform(mtransforms.IdentityTransform())

if 'clip_on' in kwargs:

a.set_clip_path(self.patch)

self._add_text(a)

return a

annotate.__doc__ = mtext.Annotation.__init__.__doc__

#### Lines and spans

@docstring.dedent_interpd

def axhline(self, y=0, xmin=0, xmax=1, **kwargs):

"""

Add a horizontal line across the axis.

Parameters

----------

y : scalar, optional, default: 0

y position in data coordinates of the horizontal line.

xmin : scalar, optional, default: 0

Should be between 0 and 1, 0 being the far left of the plot, 1 the

far right of the plot.

xmax : scalar, optional, default: 1

Should be between 0 and 1, 0 being the far left of the plot, 1 the

far right of the plot.

Returns

-------

line : `~matplotlib.lines.Line2D`

Other Parameters

----------------

**kwargs

Valid keyword arguments are `.Line2D` properties, with the

exception of 'transform':

%(_Line2D_docstr)s

See also

--------

hlines : Add horizontal lines in data coordinates.

axhspan : Add a horizontal span (rectangle) across the axis.

Examples

--------

* draw a thick red hline at 'y' = 0 that spans the xrange::

>>> axhline(linewidth=4, color='r')

* draw a default hline at 'y' = 1 that spans the xrange::

>>> axhline(y=1)

* draw a default hline at 'y' = .5 that spans the middle half of

the xrange::

>>> axhline(y=.5, xmin=0.25, xmax=0.75)

"""

if "transform" in kwargs:

raise ValueError(

"'transform' is not allowed as a kwarg;"

+ "axhline generates its own transform.")

ymin, ymax = self.get_ybound()

# We need to strip away the units for comparison with

# non-unitized bounds

self._process_unit_info(ydata=y, kwargs=kwargs)

yy = self.convert_yunits(y)

scaley = (yy < ymin) or (yy > ymax)

trans = self.get_yaxis_transform(which='grid')

l = mlines.Line2D([xmin, xmax], [y, y], transform=trans, **kwargs)

self.add_line(l)

self._request_autoscale_view(scalex=False, scaley=scaley)

return l

@docstring.dedent_interpd

def axvline(self, x=0, ymin=0, ymax=1, **kwargs):

"""

Add a vertical line across the axes.

Parameters

----------

x : scalar, optional, default: 0

x position in data coordinates of the vertical line.

ymin : scalar, optional, default: 0

Should be between 0 and 1, 0 being the bottom of the plot, 1 the

top of the plot.

ymax : scalar, optional, default: 1

Should be between 0 and 1, 0 being the bottom of the plot, 1 the

top of the plot.

Returns

-------

line : `~matplotlib.lines.Line2D`

Other Parameters

----------------

**kwargs

Valid keyword arguments are `.Line2D` properties, with the

exception of 'transform':

%(_Line2D_docstr)s

Examples

--------

* draw a thick red vline at *x* = 0 that spans the yrange::

>>> axvline(linewidth=4, color='r')

* draw a default vline at *x* = 1 that spans the yrange::

>>> axvline(x=1)

* draw a default vline at *x* = .5 that spans the middle half of

the yrange::

>>> axvline(x=.5, ymin=0.25, ymax=0.75)

See also

--------

vlines : Add vertical lines in data coordinates.

axvspan : Add a vertical span (rectangle) across the axis.

"""

if "transform" in kwargs:

raise ValueError(

"'transform' is not allowed as a kwarg;"

+ "axvline generates its own transform.")

xmin, xmax = self.get_xbound()

# We need to strip away the units for comparison with

# non-unitized bounds

self._process_unit_info(xdata=x, kwargs=kwargs)

xx = self.convert_xunits(x)

scalex = (xx < xmin) or (xx > xmax)

trans = self.get_xaxis_transform(which='grid')

l = mlines.Line2D([x, x], [ymin, ymax], transform=trans, **kwargs)

self.add_line(l)

self._request_autoscale_view(scalex=scalex, scaley=False)

return l

@docstring.dedent_interpd

def axhspan(self, ymin, ymax, xmin=0, xmax=1, **kwargs):

"""

Add a horizontal span (rectangle) across the axis.

Draw a horizontal span (rectangle) from *ymin* to *ymax*.

With the default values of *xmin* = 0 and *xmax* = 1, this

always spans the xrange, regardless of the xlim settings, even

if you change them, e.g., with the :meth:`set_xlim` command.

That is, the horizontal extent is in axes coords: 0=left,

0.5=middle, 1.0=right but the *y* location is in data

coordinates.

Parameters

----------

ymin : float

Lower limit of the horizontal span in data units.

ymax : float

Upper limit of the horizontal span in data units.

xmin : float, optional, default: 0

Lower limit of the vertical span in axes (relative

0-1) units.

xmax : float, optional, default: 1

Upper limit of the vertical span in axes (relative

0-1) units.

Returns

-------

Polygon : `~matplotlib.patches.Polygon`

Other Parameters

----------------

**kwargs : `~matplotlib.patches.Polygon` properties.

%(Polygon)s

See Also

--------

axvspan : Add a vertical span across the axes.

"""

trans = self.get_yaxis_transform(which='grid')

# process the unit information

self._process_unit_info([xmin, xmax], [ymin, ymax], kwargs=kwargs)

# first we need to strip away the units

xmin, xmax = self.convert_xunits([xmin, xmax])

ymin, ymax = self.convert_yunits([ymin, ymax])

verts = (xmin, ymin), (xmin, ymax), (xmax, ymax), (xmax, ymin)

p = mpatches.Polygon(verts, **kwargs)

p.set_transform(trans)

self.add_patch(p)

self._request_autoscale_view(scalex=False)

return p

def axvspan(self, xmin, xmax, ymin=0, ymax=1, **kwargs):

"""

Add a vertical span (rectangle) across the axes.

Draw a vertical span (rectangle) from *xmin* to *xmax*. With

the default values of *ymin* = 0 and *ymax* = 1. This always

spans the yrange, regardless of the ylim settings, even if you

change them, e.g., with the :meth:`set_ylim` command. That is,

the vertical extent is in axes coords: 0=bottom, 0.5=middle,

1.0=top but the x location is in data coordinates.

Parameters

----------

xmin : scalar

Number indicating the first X-axis coordinate of the vertical

span rectangle in data units.

xmax : scalar

Number indicating the second X-axis coordinate of the vertical

span rectangle in data units.

ymin : scalar, optional

Number indicating the first Y-axis coordinate of the vertical