from __future__ import (absolute_import, division, print_function,

unicode_literals)

import six

from six.moves import reduce, xrange, zip, zip_longest

import math

import warnings

import numpy as np

from numpy import ma

import matplotlib

rcParams = matplotlib.rcParams

import matplotlib.cbook as cbook

from matplotlib.cbook import _string_to_bool, mplDeprecation

import matplotlib.collections as mcoll

import matplotlib.colors as mcolors

import matplotlib.contour as mcontour

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

from matplotlib import 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.path as mpath

import matplotlib.patches as mpatches

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

import matplotlib.transforms as mtrans

from matplotlib.container import BarContainer, ErrorbarContainer, StemContainer

from matplotlib.axes._base import _AxesBase

from matplotlib.axes._base import _process_plot_format

iterable = cbook.iterable

is_string_like = cbook.is_string_like

is_sequence_of_strings = cbook.is_sequence_of_strings

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

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

class Axes(_AxesBase):

"""

The :class:`Axes` contains most of the figure elements:

:class:`~matplotlib.axis.Axis`, :class:`~matplotlib.axis.Tick`,

:class:`~matplotlib.lines.Line2D`, :class:`~matplotlib.text.Text`,

:class:`~matplotlib.patches.Polygon`, etc., and sets the

coordinate system.

The :class:`Axes` instance supports callbacks through a callbacks

attribute which is a :class:`~matplotlib.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 :class:`Axes` instance.

"""

### Labelling, legend and texts

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.

"""

try:

title = {'left': self._left_title,

'center': self.title,

'right': self._right_title}[loc.lower()]

except KeyError:

raise ValueError("'%s' is not a valid location" % loc)

return title.get_text()

@docstring.dedent_interpd

def set_title(self, label, fontdict=None, loc="center", **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'],

'verticalalignment': 'baseline',

'horizontalalignment': loc}

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

Which title to set, defaults to 'center'

Returns

-------

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

The matplotlib text instance representing the title

Other parameters

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

kwargs : text properties

Other keyword arguments are text properties, see

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

properties.

"""

try:

title = {'left': self._left_title,

'center': self.title,

'right': self._right_title}[loc.lower()]

except KeyError:

raise ValueError("'%s' is not a valid location" % loc)

default = {

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

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

'verticalalignment': 'baseline',

'horizontalalignment': loc.lower()}

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()

@docstring.dedent_interpd

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

"""

Set the label for the xaxis.

Parameters

----------

xlabel : string

x label

labelpad : scalar, optional, default: None

spacing in points between the label and the x-axis

Other parameters

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

kwargs : `~matplotlib.text.Text` properties

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()

@docstring.dedent_interpd

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

"""

Set the label for the yaxis

Parameters

----------

ylabel : string

y label

labelpad : scalar, optional, default: None

spacing in points between the label and the x-axis

Other parameters

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

kwargs : `~matplotlib.text.Text` properties

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(self, legend_handler_map=None):

"""

Return a generator of artists that can be used as handles in

a legend.

"""

handles_original = (self.lines + self.patches +

self.collections + self.containers)

handler_map = mlegend.Legend.get_default_handler_map()

if legend_handler_map is not None:

handler_map = handler_map.copy()

handler_map.update(legend_handler_map)

has_handler = mlegend.Legend.get_legend_handler

for handle in handles_original:

label = handle.get_label()

if label != '_nolegend_' and has_handler(handler_map, handle):

yield handle

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)

"""

handles = []

labels = []

for handle in self._get_legend_handles(legend_handler_map):

label = handle.get_label()

if label and not label.startswith('_'):

handles.append(handle)

labels.append(label)

return handles, labels

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

"""

Places a legend on the axes.

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'])

However, in order to keep the "label" and the legend element

instance together, it is preferable to specify the label either at

artist creation, or by calling the

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

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

# Overwrite the label by calling the method.

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 :meth:`legend` without

any arguments and without setting the labels manually will result in

no legend being drawn.

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

----------

loc : int or string or pair of floats, default: 0

The location of the legend. Possible codes are:

=============== =============

Location String Location Code

=============== =============

'best' 0

'upper right' 1

'upper left' 2

'lower left' 3

'lower right' 4

'right' 5

'center left' 6

'center right' 7

'lower center' 8

'upper center' 9

'center' 10

=============== =============

Alternatively can be a 2-tuple giving ``x, y`` of the lower-left

corner of the legend in axes coordinates (in which case

``bbox_to_anchor`` will be ignored).

bbox_to_anchor : :class:`matplotlib.transforms.BboxBase` instance \

or tuple of floats

Specify any arbitrary location for the legend in `bbox_transform`

coordinates (default Axes coordinates).

For example, to put the legend's upper right hand corner in the

center of the axes the following keywords can be used::

loc='upper right', bbox_to_anchor=(0.5, 0.5)

ncol : integer

The number of columns that the legend has. Default is 1.

prop : None or :class:`matplotlib.font_manager.FontProperties` or dict

The font properties of the legend. If None (default), the current

:data:`matplotlib.rcParams` will be used.

fontsize : int or float or {'xx-small', 'x-small', 'small', 'medium',\

'large', 'x-large', 'xx-large'}

Controls the font size of the legend. If the value is numeric the

size will be the absolute font size in points. String values are

relative to the current default font size. This argument is only

used if `prop` is not specified.

numpoints : None or int

The number of marker points in the legend when creating a legend

entry for a line/:class:`matplotlib.lines.Line2D`.

Default is ``None`` which will take the value from the

``legend.numpoints`` :data:`rcParam<matplotlib.rcParams>`.

scatterpoints : None or int

The number of marker points in the legend when creating a legend

entry for a scatter plot/

:class:`matplotlib.collections.PathCollection`.

Default is ``None`` which will take the value from the

``legend.scatterpoints`` :data:`rcParam<matplotlib.rcParams>`.

scatteryoffsets : iterable of floats

The vertical offset (relative to the font size) for the markers

created for a scatter plot legend entry. 0.0 is at the base the

legend text, and 1.0 is at the top. To draw all markers at the

same height, set to ``[0.5]``. Default ``[0.375, 0.5, 0.3125]``.

markerscale : None or int or float

The relative size of legend markers compared with the originally

drawn ones. Default is ``None`` which will take the value from

the ``legend.markerscale`` :data:`rcParam <matplotlib.rcParams>`.

frameon : None or bool

Control whether a frame should be drawn around the legend.

Default is ``None`` which will take the value from the

``legend.frameon`` :data:`rcParam<matplotlib.rcParams>`.

fancybox : None or bool

Control whether round edges should be enabled around

the :class:`~matplotlib.patches.FancyBboxPatch` which

makes up the legend's background.

Default is ``None`` which will take the value from the

``legend.fancybox`` :data:`rcParam<matplotlib.rcParams>`.

shadow : None or bool

Control whether to draw a shadow behind the legend.

Default is ``None`` which will take the value from the

``legend.shadow`` :data:`rcParam<matplotlib.rcParams>`.

framealpha : None or float

Control the alpha transparency of the legend's frame.

Default is ``None`` which will take the value from the

``legend.framealpha`` :data:`rcParam<matplotlib.rcParams>`.

mode : {"expand", None}

If `mode` is set to ``"expand"`` the legend will be horizontally

expanded to fill the axes area (or `bbox_to_anchor` if defines

the legend's size).

bbox_transform : None or :class:`matplotlib.transforms.Transform`

The transform for the bounding box (`bbox_to_anchor`). For a value

of ``None`` (default) the Axes'

:data:`~matplotlib.axes.Axes.transAxes` transform will be used.

title : str or None

The legend's title. Default is no title (``None``).

borderpad : float or None

The fractional whitespace inside the legend border.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.borderpad`` :data:`rcParam<matplotlib.rcParams>`.

labelspacing : float or None

The vertical space between the legend entries.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.labelspacing`` :data:`rcParam<matplotlib.rcParams>`.

handlelength : float or None

The length of the legend handles.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.handlelength`` :data:`rcParam<matplotlib.rcParams>`.

handletextpad : float or None

The pad between the legend handle and text.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.handletextpad`` :data:`rcParam<matplotlib.rcParams>`.

borderaxespad : float or None

The pad between the axes and legend border.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.borderaxespad`` :data:`rcParam<matplotlib.rcParams>`.

columnspacing : float or None

The spacing between columns.

Measured in font-size units.

Default is ``None`` which will take the value from the

``legend.columnspacing`` :data:`rcParam<matplotlib.rcParams>`.

handler_map : dict or None

The custom dictionary mapping instances or types to a legend

handler. This `handler_map` updates the default handler map

found at :func:`matplotlib.legend.Legend.get_legend_handler_map`.

Notes

-----

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

See :ref:`plotting-guide-legend` for details.

Examples

--------

.. plot:: mpl_examples/api/legend_demo.py

"""

handlers = kwargs.get('handler_map', {}) or {}

# Support handles and labels being passed as keywords.

handles = kwargs.pop('handles', None)

labels = kwargs.pop('labels', None)

if handles is not None and labels is None:

labels = [handle.get_label() for handle in handles]

for label, handle in zip(labels[:], handles[:]):

if label.startswith('_'):

warnings.warn('The handle {!r} has a label of {!r} which '

'cannot be automatically added to the '

'legend.'.format(handle, label))

labels.remove(label)

handles.remove(handle)

elif labels is not None and handles is None:

# Get as many handles as there are labels.

handles = [handle for handle, _

in zip(self._get_legend_handles(handlers), labels)]

# No arguments - automatically detect labels and handles.

elif len(args) == 0:

handles, labels = self.get_legend_handles_labels(handlers)

if not handles:

warnings.warn("No labelled objects found. "

"Use label='...' kwarg on individual plots.")

return None

# One argument. User defined labels - automatic handle detection.

elif len(args) == 1:

labels, = args

# Get as many handles as there are labels.

handles = [handle for handle, _

in zip(self._get_legend_handles(handlers), labels)]

# Two arguments. Either:

# * user defined handles and labels

# * user defined labels and location (deprecated)

elif len(args) == 2:

if is_string_like(args[1]) or isinstance(args[1], int):

cbook.warn_deprecated('1.4', 'The "loc" positional argument '

'to legend is deprecated. Please use '

'the "loc" keyword instead.')

labels, loc = args

handles = [handle for handle, _

in zip(self._get_legend_handles(handlers), labels)]

kwargs['loc'] = loc

else:

handles, labels = args

# Three arguments. User defined handles, labels and

# location (deprecated).

elif len(args) == 3:

cbook.warn_deprecated('1.4', 'The "loc" positional argument '

'to legend is deprecated. Please '

'use the "loc" keyword instead.')

handles, labels, loc = args

kwargs['loc'] = loc

else:

raise TypeError('Invalid arguments to legend.')

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

self.legend_._remove_method = lambda h: setattr(self, 'legend_', None)

return self.legend_

def text(self, x, y, s, fontdict=None,

withdash=False, **kwargs):

"""

Add text to the axes.

Add text in string `s` to axis at location `x`, `y`, data

coordinates.

Parameters

----------

x, y : scalars

data coordinates

s : string

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.

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))

"""

default = {

'verticalalignment': 'baseline',

'horizontalalignment': 'left',

'transform': self.transData,

'clip_on': False}

# 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:

t = mtext.TextWithDash(

x=x, y=y, text=s)

else:

t = mtext.Text(

x=x, y=y, text=s)

self._set_artist_props(t)

t.update(default)

if fontdict is not None:

t.update(fontdict)

t.update(kwargs)

self.texts.append(t)

t._remove_method = lambda h: self.texts.remove(h)

t.set_clip_path(self.patch)

return t

@docstring.dedent_interpd

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

"""

Create an annotation: a piece of text referring to a data

point.

Parameters

----------

s : string

label

xy : (x, y)

position of element to annotate

xytext : (x, y) , optional, default: None

position of the label `s`

xycoords : string, optional, default: "data"

string that indicates what type of coordinates `xy` is. Examples:

"figure points", "figure pixels", "figure fraction", "axes

points", .... See `matplotlib.text.Annotation` for more details.

textcoords : string, optional

string that indicates what type of coordinates `text` is. Examples:

"figure points", "figure pixels", "figure fraction", "axes

points", .... See `matplotlib.text.Annotation` for more details.

Default is None.

arrowprops : `matplotlib.lines.Line2D` properties, optional

Dictionary of line properties for the arrow that connects

the annotation to the point. If the dictionnary has a key

`arrowstyle`, a `~matplotlib.patches.FancyArrowPatch`

instance is created and drawn. See

`matplotlib.text.Annotation` for more details on valid

options. Default is None.

Returns

-------

a : `~matplotlib.text.Annotation`

Notes

-----

%(Annotation)s

Examples

--------

.. plot:: mpl_examples/pylab_examples/annotation_demo2.py

"""

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

a.set_transform(mtransforms.IdentityTransform())

self._set_artist_props(a)

if 'clip_on' in kwargs:

a.set_clip_path(self.patch)

self.texts.append(a)

a._remove_method = lambda h: self.texts.remove(h)

return a

#### 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

-------

`~matplotlib.lines.Line2D`

Notes

-----

kwargs are the same as kwargs to plot, and can be

used to control the line properties. e.g.,

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 the middle half of

the xrange::

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

Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,

with the exception of 'transform':

%(Line2D)s

See also

--------

axhspan : for example plot and source code

"""

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.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 far left of the plot, 1 the

far right of the plot.

ymax : 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

-------

`~matplotlib.lines.Line2D`

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 the middle half of

the yrange::

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

Valid kwargs are :class:`~matplotlib.lines.Line2D` properties,

with the exception of 'transform':

%(Line2D)s

See also

--------

axhspan : for example plot and source code

"""

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.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.

Call signature::

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

*y* coords are in data units and *x* coords are in axes (relative

0-1) units.

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.

Return value is a :class:`matplotlib.patches.Polygon`

instance.

Examples:

* draw a gray rectangle from *y* = 0.25-0.75 that spans the

horizontal extent of the axes::

>>> axhspan(0.25, 0.75, facecolor='0.5', alpha=0.5)

Valid kwargs are :class:`~matplotlib.patches.Polygon` properties:

%(Polygon)s

**Example:**

.. plot:: mpl_examples/pylab_examples/axhspan_demo.py

"""

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.autoscale_view(scalex=False)

return p

@docstring.dedent_interpd

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

"""

Add a vertical span (rectangle) across the axes.

Call signature::

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

*x* coords are in data units and *y* coords are in axes (relative

0-1) units.

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 *y* location is in data coordinates.

Return value is the :class:`matplotlib.patches.Polygon`

instance.

Examples:

* draw a vertical green translucent rectangle from x=1.25 to 1.55 that

spans the yrange of the axes::

>>> axvspan(1.25, 1.55, facecolor='g', alpha=0.5)

Valid kwargs are :class:`~matplotlib.patches.Polygon`

properties:

%(Polygon)s

.. seealso::

:meth:`axhspan`

for example plot and source code

"""

trans = self.get_xaxis_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.autoscale_view(scaley=False)

return p

@docstring.dedent

def hlines(self, y, xmin, xmax, colors='k', linestyles='solid',

label='', **kwargs):

"""

Plot horizontal lines at each `y` from `xmin` to `xmax`.

Parameters

----------

y : scalar or sequence of scalar

y-indexes where to plot the lines.

xmin, xmax : scalar or 1D array_like

Respective beginning and end of each line. If scalars are

provided, all lines will have same length.

colors : array_like of colors, optional, default: 'k'

linestyles : ['solid' | 'dashed' | 'dashdot' | 'dotted'], optional

label : string, optional, default: ''

Returns

-------

lines : `~matplotlib.collections.LineCollection`

Other parameters

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

kwargs : `~matplotlib.collections.LineCollection` properties.

See also

--------

vlines : vertical lines

Examples

--------

.. plot:: mpl_examples/pylab_examples/vline_hline_demo.py

"""

# We do the conversion first since not all unitized data is uniform

# process the unit information

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

y = self.convert_yunits(y)

xmin = self.convert_xunits(xmin)

xmax = self.convert_xunits(xmax)

if not iterable(y):

y = [y]

if not iterable(xmin):

xmin = [xmin]

if not iterable(xmax):

xmax = [xmax]

y = np.ravel(y)

xmin = np.resize(xmin, y.shape)

xmax = np.resize(xmax, y.shape)

verts = [((thisxmin, thisy), (thisxmax, thisy))

for thisxmin, thisxmax, thisy in zip(xmin, xmax, y)]

coll = mcoll.LineCollection(verts, colors=colors,

linestyles=linestyles, label=label)

self.add_collection(coll, autolim=False)

coll.update(kwargs)

if len(y) > 0:

minx = min(xmin.min(), xmax.min())

maxx = max(xmin.max(), xmax.max())

miny = y.min()

maxy = y.max()

corners = (minx, miny), (maxx, maxy)

self.update_datalim(corners)

self.autoscale_view()

return coll

@docstring.dedent_interpd

def vlines(self, x, ymin, ymax, colors='k', linestyles='solid',

label='', **kwargs):

"""

Plot vertical lines.

Plot vertical lines at each `x` from `ymin` to `ymax`.

Parameters

----------

x : scalar or 1D array_like

x-indexes where to plot the lines.

ymin, ymax : scalar or 1D array_like

Respective beginning and end of each line. If scalars are