forked from 170010011/fr
6467 lines
206 KiB
Python
6467 lines
206 KiB
Python
from collections import namedtuple
|
|
import datetime
|
|
from decimal import Decimal
|
|
import io
|
|
from itertools import product
|
|
import platform
|
|
from types import SimpleNamespace
|
|
try:
|
|
from contextlib import nullcontext
|
|
except ImportError:
|
|
from contextlib import ExitStack as nullcontext # Py3.6.
|
|
|
|
import dateutil.tz
|
|
|
|
import numpy as np
|
|
from numpy import ma
|
|
from cycler import cycler
|
|
import pytest
|
|
|
|
import matplotlib
|
|
import matplotlib as mpl
|
|
from matplotlib.testing.decorators import (
|
|
image_comparison, check_figures_equal, remove_ticks_and_titles)
|
|
import matplotlib.colors as mcolors
|
|
import matplotlib.dates as mdates
|
|
import matplotlib.font_manager as mfont_manager
|
|
import matplotlib.markers as mmarkers
|
|
import matplotlib.patches as mpatches
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib.ticker as mticker
|
|
import matplotlib.transforms as mtransforms
|
|
from numpy.testing import (
|
|
assert_allclose, assert_array_equal, assert_array_almost_equal)
|
|
from matplotlib import rc_context
|
|
from matplotlib.cbook import MatplotlibDeprecationWarning
|
|
|
|
# Note: Some test cases are run twice: once normally and once with labeled data
|
|
# These two must be defined in the same test function or need to have
|
|
# different baseline images to prevent race conditions when pytest runs
|
|
# the tests with multiple threads.
|
|
|
|
|
|
def test_get_labels():
|
|
fig, ax = plt.subplots()
|
|
ax.set_xlabel('x label')
|
|
ax.set_ylabel('y label')
|
|
assert ax.get_xlabel() == 'x label'
|
|
assert ax.get_ylabel() == 'y label'
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_label_loc_vertical(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label', loc='top')
|
|
ax.set_xlabel('X Label', loc='right')
|
|
cbar = fig_test.colorbar(sc)
|
|
cbar.set_label("Z Label", loc='top')
|
|
|
|
ax = fig_ref.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label', y=1, ha='right')
|
|
ax.set_xlabel('X Label', x=1, ha='right')
|
|
cbar = fig_ref.colorbar(sc)
|
|
cbar.set_label("Z Label", y=1, ha='right')
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_label_loc_horizontal(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label', loc='bottom')
|
|
ax.set_xlabel('X Label', loc='left')
|
|
cbar = fig_test.colorbar(sc, orientation='horizontal')
|
|
cbar.set_label("Z Label", loc='left')
|
|
|
|
ax = fig_ref.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label', y=0, ha='left')
|
|
ax.set_xlabel('X Label', x=0, ha='left')
|
|
cbar = fig_ref.colorbar(sc, orientation='horizontal')
|
|
cbar.set_label("Z Label", x=0, ha='left')
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_label_loc_rc(fig_test, fig_ref):
|
|
with matplotlib.rc_context({"xaxis.labellocation": "right",
|
|
"yaxis.labellocation": "top"}):
|
|
ax = fig_test.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label')
|
|
ax.set_xlabel('X Label')
|
|
cbar = fig_test.colorbar(sc, orientation='horizontal')
|
|
cbar.set_label("Z Label")
|
|
|
|
ax = fig_ref.subplots()
|
|
sc = ax.scatter([1, 2], [1, 2], c=[1, 2])
|
|
ax.set_ylabel('Y Label', y=1, ha='right')
|
|
ax.set_xlabel('X Label', x=1, ha='right')
|
|
cbar = fig_ref.colorbar(sc, orientation='horizontal')
|
|
cbar.set_label("Z Label", x=1, ha='right')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_acorr(fig_test, fig_ref):
|
|
np.random.seed(19680801)
|
|
Nx = 512
|
|
x = np.random.normal(0, 1, Nx).cumsum()
|
|
maxlags = Nx-1
|
|
|
|
fig_test, ax_test = plt.subplots()
|
|
ax_test.acorr(x, maxlags=maxlags)
|
|
|
|
fig_ref, ax_ref = plt.subplots()
|
|
# Normalized autocorrelation
|
|
norm_auto_corr = np.correlate(x, x, mode="full")/np.dot(x, x)
|
|
lags = np.arange(-maxlags, maxlags+1)
|
|
norm_auto_corr = norm_auto_corr[Nx-1-maxlags:Nx+maxlags]
|
|
ax_ref.vlines(lags, [0], norm_auto_corr)
|
|
ax_ref.axhline(y=0, xmin=0, xmax=1)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_spy(fig_test, fig_ref):
|
|
np.random.seed(19680801)
|
|
a = np.ones(32 * 32)
|
|
a[:16 * 32] = 0
|
|
np.random.shuffle(a)
|
|
a = a.reshape((32, 32))
|
|
|
|
axs_test = fig_test.subplots(2)
|
|
axs_test[0].spy(a)
|
|
axs_test[1].spy(a, marker=".", origin="lower")
|
|
|
|
axs_ref = fig_ref.subplots(2)
|
|
axs_ref[0].imshow(a, cmap="gray_r", interpolation="nearest")
|
|
axs_ref[0].xaxis.tick_top()
|
|
axs_ref[1].plot(*np.nonzero(a)[::-1], ".", markersize=10)
|
|
axs_ref[1].set(
|
|
aspect=1, xlim=axs_ref[0].get_xlim(), ylim=axs_ref[0].get_ylim()[::-1])
|
|
for ax in axs_ref:
|
|
ax.xaxis.set_ticks_position("both")
|
|
|
|
|
|
def test_spy_invalid_kwargs():
|
|
fig, ax = plt.subplots()
|
|
for unsupported_kw in [{'interpolation': 'nearest'},
|
|
{'marker': 'o', 'linestyle': 'solid'}]:
|
|
with pytest.raises(TypeError):
|
|
ax.spy(np.eye(3, 3), **unsupported_kw)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_matshow(fig_test, fig_ref):
|
|
mpl.style.use("mpl20")
|
|
a = np.random.rand(32, 32)
|
|
fig_test.add_subplot().matshow(a)
|
|
ax_ref = fig_ref.add_subplot()
|
|
ax_ref.imshow(a)
|
|
ax_ref.xaxis.tick_top()
|
|
ax_ref.xaxis.set_ticks_position('both')
|
|
|
|
|
|
@image_comparison(['formatter_ticker_001',
|
|
'formatter_ticker_002',
|
|
'formatter_ticker_003',
|
|
'formatter_ticker_004',
|
|
'formatter_ticker_005',
|
|
])
|
|
def test_formatter_ticker():
|
|
import matplotlib.testing.jpl_units as units
|
|
units.register()
|
|
|
|
# This should affect the tick size. (Tests issue #543)
|
|
matplotlib.rcParams['lines.markeredgewidth'] = 30
|
|
|
|
# This essentially test to see if user specified labels get overwritten
|
|
# by the auto labeler functionality of the axes.
|
|
xdata = [x*units.sec for x in range(10)]
|
|
ydata1 = [(1.5*y - 0.5)*units.km for y in range(10)]
|
|
ydata2 = [(1.75*y - 1.0)*units.km for y in range(10)]
|
|
|
|
ax = plt.figure().subplots()
|
|
ax.set_xlabel("x-label 001")
|
|
|
|
ax = plt.figure().subplots()
|
|
ax.set_xlabel("x-label 001")
|
|
ax.plot(xdata, ydata1, color='blue', xunits="sec")
|
|
|
|
ax = plt.figure().subplots()
|
|
ax.set_xlabel("x-label 001")
|
|
ax.plot(xdata, ydata1, color='blue', xunits="sec")
|
|
ax.set_xlabel("x-label 003")
|
|
|
|
ax = plt.figure().subplots()
|
|
ax.plot(xdata, ydata1, color='blue', xunits="sec")
|
|
ax.plot(xdata, ydata2, color='green', xunits="hour")
|
|
ax.set_xlabel("x-label 004")
|
|
|
|
# See SF bug 2846058
|
|
# https://sourceforge.net/tracker/?func=detail&aid=2846058&group_id=80706&atid=560720
|
|
ax = plt.figure().subplots()
|
|
ax.plot(xdata, ydata1, color='blue', xunits="sec")
|
|
ax.plot(xdata, ydata2, color='green', xunits="hour")
|
|
ax.set_xlabel("x-label 005")
|
|
ax.autoscale_view()
|
|
|
|
|
|
def test_funcformatter_auto_formatter():
|
|
def _formfunc(x, pos):
|
|
return ''
|
|
|
|
ax = plt.figure().subplots()
|
|
|
|
assert ax.xaxis.isDefault_majfmt
|
|
assert ax.xaxis.isDefault_minfmt
|
|
assert ax.yaxis.isDefault_majfmt
|
|
assert ax.yaxis.isDefault_minfmt
|
|
|
|
ax.xaxis.set_major_formatter(_formfunc)
|
|
|
|
assert not ax.xaxis.isDefault_majfmt
|
|
assert ax.xaxis.isDefault_minfmt
|
|
assert ax.yaxis.isDefault_majfmt
|
|
assert ax.yaxis.isDefault_minfmt
|
|
|
|
targ_funcformatter = mticker.FuncFormatter(_formfunc)
|
|
|
|
assert isinstance(ax.xaxis.get_major_formatter(),
|
|
mticker.FuncFormatter)
|
|
|
|
assert ax.xaxis.get_major_formatter().func == targ_funcformatter.func
|
|
|
|
|
|
def test_strmethodformatter_auto_formatter():
|
|
formstr = '{x}_{pos}'
|
|
|
|
ax = plt.figure().subplots()
|
|
|
|
assert ax.xaxis.isDefault_majfmt
|
|
assert ax.xaxis.isDefault_minfmt
|
|
assert ax.yaxis.isDefault_majfmt
|
|
assert ax.yaxis.isDefault_minfmt
|
|
|
|
ax.yaxis.set_minor_formatter(formstr)
|
|
|
|
assert ax.xaxis.isDefault_majfmt
|
|
assert ax.xaxis.isDefault_minfmt
|
|
assert ax.yaxis.isDefault_majfmt
|
|
assert not ax.yaxis.isDefault_minfmt
|
|
|
|
targ_strformatter = mticker.StrMethodFormatter(formstr)
|
|
|
|
assert isinstance(ax.yaxis.get_minor_formatter(),
|
|
mticker.StrMethodFormatter)
|
|
|
|
assert ax.yaxis.get_minor_formatter().fmt == targ_strformatter.fmt
|
|
|
|
|
|
@image_comparison(["twin_axis_locators_formatters"])
|
|
def test_twin_axis_locators_formatters():
|
|
vals = np.linspace(0, 1, num=5, endpoint=True)
|
|
locs = np.sin(np.pi * vals / 2.0)
|
|
|
|
majl = plt.FixedLocator(locs)
|
|
minl = plt.FixedLocator([0.1, 0.2, 0.3])
|
|
|
|
fig = plt.figure()
|
|
ax1 = fig.add_subplot(1, 1, 1)
|
|
ax1.plot([0.1, 100], [0, 1])
|
|
ax1.yaxis.set_major_locator(majl)
|
|
ax1.yaxis.set_minor_locator(minl)
|
|
ax1.yaxis.set_major_formatter(plt.FormatStrFormatter('%08.2lf'))
|
|
ax1.yaxis.set_minor_formatter(plt.FixedFormatter(['tricks', 'mind',
|
|
'jedi']))
|
|
|
|
ax1.xaxis.set_major_locator(plt.LinearLocator())
|
|
ax1.xaxis.set_minor_locator(plt.FixedLocator([15, 35, 55, 75]))
|
|
ax1.xaxis.set_major_formatter(plt.FormatStrFormatter('%05.2lf'))
|
|
ax1.xaxis.set_minor_formatter(plt.FixedFormatter(['c', '3', 'p', 'o']))
|
|
ax1.twiny()
|
|
ax1.twinx()
|
|
|
|
|
|
def test_twinx_cla():
|
|
fig, ax = plt.subplots()
|
|
ax2 = ax.twinx()
|
|
ax3 = ax2.twiny()
|
|
plt.draw()
|
|
assert not ax2.xaxis.get_visible()
|
|
assert not ax2.patch.get_visible()
|
|
ax2.cla()
|
|
ax3.cla()
|
|
|
|
assert not ax2.xaxis.get_visible()
|
|
assert not ax2.patch.get_visible()
|
|
assert ax2.yaxis.get_visible()
|
|
|
|
assert ax3.xaxis.get_visible()
|
|
assert not ax3.patch.get_visible()
|
|
assert not ax3.yaxis.get_visible()
|
|
|
|
assert ax.xaxis.get_visible()
|
|
assert ax.patch.get_visible()
|
|
assert ax.yaxis.get_visible()
|
|
|
|
|
|
@pytest.mark.parametrize('twin', ('x', 'y'))
|
|
@check_figures_equal(extensions=['png'], tol=0.19)
|
|
def test_twin_logscale(fig_test, fig_ref, twin):
|
|
twin_func = f'twin{twin}' # test twinx or twiny
|
|
set_scale = f'set_{twin}scale'
|
|
x = np.arange(1, 100)
|
|
|
|
# Change scale after twinning.
|
|
ax_test = fig_test.add_subplot(2, 1, 1)
|
|
ax_twin = getattr(ax_test, twin_func)()
|
|
getattr(ax_test, set_scale)('log')
|
|
ax_twin.plot(x, x)
|
|
|
|
# Twin after changing scale.
|
|
ax_test = fig_test.add_subplot(2, 1, 2)
|
|
getattr(ax_test, set_scale)('log')
|
|
ax_twin = getattr(ax_test, twin_func)()
|
|
ax_twin.plot(x, x)
|
|
|
|
for i in [1, 2]:
|
|
ax_ref = fig_ref.add_subplot(2, 1, i)
|
|
getattr(ax_ref, set_scale)('log')
|
|
ax_ref.plot(x, x)
|
|
|
|
# This is a hack because twinned Axes double-draw the frame.
|
|
# Remove this when that is fixed.
|
|
Path = matplotlib.path.Path
|
|
fig_ref.add_artist(
|
|
matplotlib.patches.PathPatch(
|
|
Path([[0, 0], [0, 1],
|
|
[0, 1], [1, 1],
|
|
[1, 1], [1, 0],
|
|
[1, 0], [0, 0]],
|
|
[Path.MOVETO, Path.LINETO] * 4),
|
|
transform=ax_ref.transAxes,
|
|
facecolor='none',
|
|
edgecolor=mpl.rcParams['axes.edgecolor'],
|
|
linewidth=mpl.rcParams['axes.linewidth'],
|
|
capstyle='projecting'))
|
|
|
|
remove_ticks_and_titles(fig_test)
|
|
remove_ticks_and_titles(fig_ref)
|
|
|
|
|
|
@image_comparison(['twin_autoscale.png'])
|
|
def test_twinx_axis_scales():
|
|
x = np.array([0, 0.5, 1])
|
|
y = 0.5 * x
|
|
x2 = np.array([0, 1, 2])
|
|
y2 = 2 * x2
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_axes((0, 0, 1, 1), autoscalex_on=False, autoscaley_on=False)
|
|
ax.plot(x, y, color='blue', lw=10)
|
|
|
|
ax2 = plt.twinx(ax)
|
|
ax2.plot(x2, y2, 'r--', lw=5)
|
|
|
|
ax.margins(0, 0)
|
|
ax2.margins(0, 0)
|
|
|
|
|
|
def test_twin_inherit_autoscale_setting():
|
|
fig, ax = plt.subplots()
|
|
ax_x_on = ax.twinx()
|
|
ax.set_autoscalex_on(False)
|
|
ax_x_off = ax.twinx()
|
|
|
|
assert ax_x_on.get_autoscalex_on()
|
|
assert not ax_x_off.get_autoscalex_on()
|
|
|
|
ax_y_on = ax.twiny()
|
|
ax.set_autoscaley_on(False)
|
|
ax_y_off = ax.twiny()
|
|
|
|
assert ax_y_on.get_autoscaley_on()
|
|
assert not ax_y_off.get_autoscaley_on()
|
|
|
|
|
|
def test_inverted_cla():
|
|
# GitHub PR #5450. Setting autoscale should reset
|
|
# axes to be non-inverted.
|
|
# plotting an image, then 1d graph, axis is now down
|
|
fig = plt.figure(0)
|
|
ax = fig.gca()
|
|
# 1. test that a new axis is not inverted per default
|
|
assert not ax.xaxis_inverted()
|
|
assert not ax.yaxis_inverted()
|
|
img = np.random.random((100, 100))
|
|
ax.imshow(img)
|
|
# 2. test that a image axis is inverted
|
|
assert not ax.xaxis_inverted()
|
|
assert ax.yaxis_inverted()
|
|
# 3. test that clearing and plotting a line, axes are
|
|
# not inverted
|
|
ax.cla()
|
|
x = np.linspace(0, 2*np.pi, 100)
|
|
ax.plot(x, np.cos(x))
|
|
assert not ax.xaxis_inverted()
|
|
assert not ax.yaxis_inverted()
|
|
|
|
# 4. autoscaling should not bring back axes to normal
|
|
ax.cla()
|
|
ax.imshow(img)
|
|
plt.autoscale()
|
|
assert not ax.xaxis_inverted()
|
|
assert ax.yaxis_inverted()
|
|
|
|
# 5. two shared axes. Inverting the master axis should invert the shared
|
|
# axes; clearing the master axis should bring axes in shared
|
|
# axes back to normal.
|
|
ax0 = plt.subplot(211)
|
|
ax1 = plt.subplot(212, sharey=ax0)
|
|
ax0.yaxis.set_inverted(True)
|
|
assert ax1.yaxis_inverted()
|
|
ax1.plot(x, np.cos(x))
|
|
ax0.cla()
|
|
assert not ax1.yaxis_inverted()
|
|
ax1.cla()
|
|
# 6. clearing the nonmaster should not touch limits
|
|
ax0.imshow(img)
|
|
ax1.plot(x, np.cos(x))
|
|
ax1.cla()
|
|
assert ax.yaxis_inverted()
|
|
|
|
# clean up
|
|
plt.close(fig)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_minorticks_on_rcParams_both(fig_test, fig_ref):
|
|
with matplotlib.rc_context({"xtick.minor.visible": True,
|
|
"ytick.minor.visible": True}):
|
|
ax_test = fig_test.subplots()
|
|
ax_test.plot([0, 1], [0, 1])
|
|
ax_ref = fig_ref.subplots()
|
|
ax_ref.plot([0, 1], [0, 1])
|
|
ax_ref.minorticks_on()
|
|
|
|
|
|
@image_comparison(["autoscale_tiny_range"], remove_text=True)
|
|
def test_autoscale_tiny_range():
|
|
# github pull #904
|
|
fig, axs = plt.subplots(2, 2)
|
|
for i, ax in enumerate(axs.flat):
|
|
y1 = 10**(-11 - i)
|
|
ax.plot([0, 1], [1, 1 + y1])
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_autoscale_tight():
|
|
fig, ax = plt.subplots(1, 1)
|
|
ax.plot([1, 2, 3, 4])
|
|
ax.autoscale(enable=True, axis='x', tight=False)
|
|
ax.autoscale(enable=True, axis='y', tight=True)
|
|
assert_allclose(ax.get_xlim(), (-0.15, 3.15))
|
|
assert_allclose(ax.get_ylim(), (1.0, 4.0))
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_autoscale_log_shared():
|
|
# related to github #7587
|
|
# array starts at zero to trigger _minpos handling
|
|
x = np.arange(100, dtype=float)
|
|
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
|
|
ax1.loglog(x, x)
|
|
ax2.semilogx(x, x)
|
|
ax1.autoscale(tight=True)
|
|
ax2.autoscale(tight=True)
|
|
plt.draw()
|
|
lims = (x[1], x[-1])
|
|
assert_allclose(ax1.get_xlim(), lims)
|
|
assert_allclose(ax1.get_ylim(), lims)
|
|
assert_allclose(ax2.get_xlim(), lims)
|
|
assert_allclose(ax2.get_ylim(), (x[0], x[-1]))
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_use_sticky_edges():
|
|
fig, ax = plt.subplots()
|
|
ax.imshow([[0, 1], [2, 3]], origin='lower')
|
|
assert_allclose(ax.get_xlim(), (-0.5, 1.5))
|
|
assert_allclose(ax.get_ylim(), (-0.5, 1.5))
|
|
ax.use_sticky_edges = False
|
|
ax.autoscale()
|
|
xlim = (-0.5 - 2 * ax._xmargin, 1.5 + 2 * ax._xmargin)
|
|
ylim = (-0.5 - 2 * ax._ymargin, 1.5 + 2 * ax._ymargin)
|
|
assert_allclose(ax.get_xlim(), xlim)
|
|
assert_allclose(ax.get_ylim(), ylim)
|
|
# Make sure it is reversible:
|
|
ax.use_sticky_edges = True
|
|
ax.autoscale()
|
|
assert_allclose(ax.get_xlim(), (-0.5, 1.5))
|
|
assert_allclose(ax.get_ylim(), (-0.5, 1.5))
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_sticky_shared_axes(fig_test, fig_ref):
|
|
# Check that sticky edges work whether they are set in an axes that is a
|
|
# "master" in a share, or an axes that is a "follower".
|
|
Z = np.arange(15).reshape(3, 5)
|
|
|
|
ax0 = fig_test.add_subplot(211)
|
|
ax1 = fig_test.add_subplot(212, sharex=ax0)
|
|
ax1.pcolormesh(Z)
|
|
|
|
ax0 = fig_ref.add_subplot(212)
|
|
ax1 = fig_ref.add_subplot(211, sharex=ax0)
|
|
ax0.pcolormesh(Z)
|
|
|
|
|
|
@image_comparison(['offset_points'], remove_text=True)
|
|
def test_basic_annotate():
|
|
# Setup some data
|
|
t = np.arange(0.0, 5.0, 0.01)
|
|
s = np.cos(2.0*np.pi * t)
|
|
|
|
# Offset Points
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, autoscale_on=False, xlim=(-1, 5), ylim=(-3, 5))
|
|
line, = ax.plot(t, s, lw=3, color='purple')
|
|
|
|
ax.annotate('local max', xy=(3, 1), xycoords='data',
|
|
xytext=(3, 3), textcoords='offset points')
|
|
|
|
|
|
def test_annotate_parameter_warn():
|
|
fig, ax = plt.subplots()
|
|
with pytest.warns(MatplotlibDeprecationWarning,
|
|
match=r"The \'s\' parameter of annotate\(\) "
|
|
"has been renamed \'text\'"):
|
|
ax.annotate(s='now named text', xy=(0, 1))
|
|
|
|
|
|
@image_comparison(['arrow_simple.png'], remove_text=True)
|
|
def test_arrow_simple():
|
|
# Simple image test for ax.arrow
|
|
# kwargs that take discrete values
|
|
length_includes_head = (True, False)
|
|
shape = ('full', 'left', 'right')
|
|
head_starts_at_zero = (True, False)
|
|
# Create outer product of values
|
|
kwargs = product(length_includes_head, shape, head_starts_at_zero)
|
|
|
|
fig, axs = plt.subplots(3, 4)
|
|
for i, (ax, kwarg) in enumerate(zip(axs.flat, kwargs)):
|
|
ax.set_xlim(-2, 2)
|
|
ax.set_ylim(-2, 2)
|
|
# Unpack kwargs
|
|
(length_includes_head, shape, head_starts_at_zero) = kwarg
|
|
theta = 2 * np.pi * i / 12
|
|
# Draw arrow
|
|
ax.arrow(0, 0, np.sin(theta), np.cos(theta),
|
|
width=theta/100,
|
|
length_includes_head=length_includes_head,
|
|
shape=shape,
|
|
head_starts_at_zero=head_starts_at_zero,
|
|
head_width=theta / 10,
|
|
head_length=theta / 10)
|
|
|
|
|
|
def test_arrow_empty():
|
|
_, ax = plt.subplots()
|
|
# Create an empty FancyArrow
|
|
ax.arrow(0, 0, 0, 0, head_length=0)
|
|
|
|
|
|
def test_arrow_in_view():
|
|
_, ax = plt.subplots()
|
|
ax.arrow(1, 1, 1, 1)
|
|
assert ax.get_xlim() == (0.8, 2.2)
|
|
assert ax.get_ylim() == (0.8, 2.2)
|
|
|
|
|
|
def test_annotate_default_arrow():
|
|
# Check that we can make an annotation arrow with only default properties.
|
|
fig, ax = plt.subplots()
|
|
ann = ax.annotate("foo", (0, 1), xytext=(2, 3))
|
|
assert ann.arrow_patch is None
|
|
ann = ax.annotate("foo", (0, 1), xytext=(2, 3), arrowprops={})
|
|
assert ann.arrow_patch is not None
|
|
|
|
|
|
@image_comparison(['fill_units.png'], savefig_kwarg={'dpi': 60})
|
|
def test_fill_units():
|
|
import matplotlib.testing.jpl_units as units
|
|
units.register()
|
|
|
|
# generate some data
|
|
t = units.Epoch("ET", dt=datetime.datetime(2009, 4, 27))
|
|
value = 10.0 * units.deg
|
|
day = units.Duration("ET", 24.0 * 60.0 * 60.0)
|
|
dt = np.arange('2009-04-27', '2009-04-29', dtype='datetime64[D]')
|
|
dtn = mdates.date2num(dt)
|
|
|
|
fig = plt.figure()
|
|
|
|
# Top-Left
|
|
ax1 = fig.add_subplot(221)
|
|
ax1.plot([t], [value], yunits='deg', color='red')
|
|
ind = [0, 0, 1, 1]
|
|
ax1.fill(dtn[ind], [0.0, 0.0, 90.0, 0.0], 'b')
|
|
# Top-Right
|
|
ax2 = fig.add_subplot(222)
|
|
ax2.plot([t], [value], yunits='deg', color='red')
|
|
ax2.fill([t, t, t + day, t + day],
|
|
[0.0, 0.0, 90.0, 0.0], 'b')
|
|
# Bottom-Left
|
|
ax3 = fig.add_subplot(223)
|
|
ax3.plot([t], [value], yunits='deg', color='red')
|
|
ax3.fill(dtn[ind],
|
|
[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],
|
|
'b')
|
|
# Bottom-Right
|
|
ax4 = fig.add_subplot(224)
|
|
ax4.plot([t], [value], yunits='deg', color='red')
|
|
ax4.fill([t, t, t + day, t + day],
|
|
[0 * units.deg, 0 * units.deg, 90 * units.deg, 0 * units.deg],
|
|
facecolor="blue")
|
|
fig.autofmt_xdate()
|
|
|
|
|
|
@image_comparison(['single_point', 'single_point'])
|
|
def test_single_point():
|
|
# Issue #1796: don't let lines.marker affect the grid
|
|
matplotlib.rcParams['lines.marker'] = 'o'
|
|
matplotlib.rcParams['axes.grid'] = True
|
|
|
|
plt.figure()
|
|
plt.subplot(211)
|
|
plt.plot([0], [0], 'o')
|
|
|
|
plt.subplot(212)
|
|
plt.plot([1], [1], 'o')
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {'a': [0], 'b': [1]}
|
|
|
|
plt.figure()
|
|
plt.subplot(211)
|
|
plt.plot('a', 'a', 'o', data=data)
|
|
|
|
plt.subplot(212)
|
|
plt.plot('b', 'b', 'o', data=data)
|
|
|
|
|
|
@image_comparison(['single_date.png'], style='mpl20')
|
|
def test_single_date():
|
|
|
|
# use former defaults to match existing baseline image
|
|
plt.rcParams['axes.formatter.limits'] = -7, 7
|
|
dt = mdates.date2num(np.datetime64('0000-12-31'))
|
|
|
|
time1 = [721964.0]
|
|
data1 = [-65.54]
|
|
|
|
fig, ax = plt.subplots(2, 1)
|
|
ax[0].plot_date(time1 + dt, data1, 'o', color='r')
|
|
ax[1].plot(time1, data1, 'o', color='r')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_shaped_data(fig_test, fig_ref):
|
|
row = np.arange(10).reshape((1, -1))
|
|
col = np.arange(0, 100, 10).reshape((-1, 1))
|
|
|
|
axs = fig_test.subplots(2)
|
|
axs[0].plot(row) # Actually plots nothing (columns are single points).
|
|
axs[1].plot(col) # Same as plotting 1d.
|
|
|
|
axs = fig_ref.subplots(2)
|
|
# xlim from the implicit "x=0", ylim from the row datalim.
|
|
axs[0].set(xlim=(-.06, .06), ylim=(0, 9))
|
|
axs[1].plot(col.ravel())
|
|
|
|
|
|
def test_structured_data():
|
|
# support for structured data
|
|
pts = np.array([(1, 1), (2, 2)], dtype=[("ones", float), ("twos", float)])
|
|
|
|
# this should not read second name as a format and raise ValueError
|
|
axs = plt.figure().subplots(2)
|
|
axs[0].plot("ones", "twos", data=pts)
|
|
axs[1].plot("ones", "twos", "r", data=pts)
|
|
|
|
|
|
@image_comparison(['aitoff_proj'], extensions=["png"],
|
|
remove_text=True, style='mpl20')
|
|
def test_aitoff_proj():
|
|
"""
|
|
Test aitoff projection ref.:
|
|
https://github.com/matplotlib/matplotlib/pull/14451
|
|
"""
|
|
x = np.linspace(-np.pi, np.pi, 20)
|
|
y = np.linspace(-np.pi / 2, np.pi / 2, 20)
|
|
X, Y = np.meshgrid(x, y)
|
|
|
|
fig, ax = plt.subplots(figsize=(8, 4.2),
|
|
subplot_kw=dict(projection="aitoff"))
|
|
ax.grid()
|
|
ax.plot(X.flat, Y.flat, 'o', markersize=4)
|
|
|
|
|
|
@image_comparison(['axvspan_epoch'])
|
|
def test_axvspan_epoch():
|
|
import matplotlib.testing.jpl_units as units
|
|
units.register()
|
|
|
|
# generate some data
|
|
t0 = units.Epoch("ET", dt=datetime.datetime(2009, 1, 20))
|
|
tf = units.Epoch("ET", dt=datetime.datetime(2009, 1, 21))
|
|
dt = units.Duration("ET", units.day.convert("sec"))
|
|
|
|
ax = plt.gca()
|
|
plt.axvspan(t0, tf, facecolor="blue", alpha=0.25)
|
|
ax.set_xlim(t0 - 5.0*dt, tf + 5.0*dt)
|
|
|
|
|
|
@image_comparison(['axhspan_epoch'], tol=0.02)
|
|
def test_axhspan_epoch():
|
|
import matplotlib.testing.jpl_units as units
|
|
units.register()
|
|
|
|
# generate some data
|
|
t0 = units.Epoch("ET", dt=datetime.datetime(2009, 1, 20))
|
|
tf = units.Epoch("ET", dt=datetime.datetime(2009, 1, 21))
|
|
dt = units.Duration("ET", units.day.convert("sec"))
|
|
|
|
ax = plt.gca()
|
|
ax.axhspan(t0, tf, facecolor="blue", alpha=0.25)
|
|
ax.set_ylim(t0 - 5.0*dt, tf + 5.0*dt)
|
|
|
|
|
|
@image_comparison(['hexbin_extent.png', 'hexbin_extent.png'], remove_text=True)
|
|
def test_hexbin_extent():
|
|
# this test exposes sf bug 2856228
|
|
fig, ax = plt.subplots()
|
|
data = (np.arange(2000) / 2000).reshape((2, 1000))
|
|
x, y = data
|
|
|
|
ax.hexbin(x, y, extent=[.1, .3, .6, .7])
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"x": x, "y": y}
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.hexbin("x", "y", extent=[.1, .3, .6, .7], data=data)
|
|
|
|
|
|
@image_comparison(['hexbin_empty.png'], remove_text=True)
|
|
def test_hexbin_empty():
|
|
# From #3886: creating hexbin from empty dataset raises ValueError
|
|
ax = plt.gca()
|
|
ax.hexbin([], [])
|
|
|
|
|
|
def test_hexbin_pickable():
|
|
# From #1973: Test that picking a hexbin collection works
|
|
fig, ax = plt.subplots()
|
|
data = (np.arange(200) / 200).reshape((2, 100))
|
|
x, y = data
|
|
hb = ax.hexbin(x, y, extent=[.1, .3, .6, .7], picker=-1)
|
|
mouse_event = SimpleNamespace(x=400, y=300)
|
|
assert hb.contains(mouse_event)[0]
|
|
|
|
|
|
@image_comparison(['hexbin_log.png'], style='mpl20')
|
|
def test_hexbin_log():
|
|
# Issue #1636 (and also test log scaled colorbar)
|
|
np.random.seed(19680801)
|
|
n = 100000
|
|
x = np.random.standard_normal(n)
|
|
y = 2.0 + 3.0 * x + 4.0 * np.random.standard_normal(n)
|
|
y = np.power(2, y * 0.5)
|
|
|
|
fig, ax = plt.subplots()
|
|
h = ax.hexbin(x, y, yscale='log', bins='log')
|
|
plt.colorbar(h)
|
|
|
|
|
|
def test_inverted_limits():
|
|
# Test gh:1553
|
|
# Calling invert_xaxis prior to plotting should not disable autoscaling
|
|
# while still maintaining the inverted direction
|
|
fig, ax = plt.subplots()
|
|
ax.invert_xaxis()
|
|
ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])
|
|
|
|
assert ax.get_xlim() == (4, -5)
|
|
assert ax.get_ylim() == (-3, 5)
|
|
plt.close()
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.invert_yaxis()
|
|
ax.plot([-5, -3, 2, 4], [1, 2, -3, 5])
|
|
|
|
assert ax.get_xlim() == (-5, 4)
|
|
assert ax.get_ylim() == (5, -3)
|
|
|
|
# Test inverting nonlinear axes.
|
|
fig, ax = plt.subplots()
|
|
ax.set_yscale("log")
|
|
ax.set_ylim(10, 1)
|
|
assert ax.get_ylim() == (10, 1)
|
|
|
|
|
|
@image_comparison(['nonfinite_limits'])
|
|
def test_nonfinite_limits():
|
|
x = np.arange(0., np.e, 0.01)
|
|
# silence divide by zero warning from log(0)
|
|
with np.errstate(divide='ignore'):
|
|
y = np.log(x)
|
|
x[len(x)//2] = np.nan
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, y)
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
@pytest.mark.parametrize('plot_fun',
|
|
['scatter', 'plot', 'fill_between'])
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_limits_empty_data(plot_fun, fig_test, fig_ref):
|
|
# Check that plotting empty data doesn't change autoscaling of dates
|
|
x = np.arange("2010-01-01", "2011-01-01", dtype="datetime64[D]")
|
|
|
|
ax_test = fig_test.subplots()
|
|
ax_ref = fig_ref.subplots()
|
|
|
|
getattr(ax_test, plot_fun)([], [])
|
|
|
|
for ax in [ax_test, ax_ref]:
|
|
getattr(ax, plot_fun)(x, range(len(x)), color='C0')
|
|
|
|
|
|
@image_comparison(['imshow', 'imshow'], remove_text=True, style='mpl20')
|
|
def test_imshow():
|
|
# use former defaults to match existing baseline image
|
|
matplotlib.rcParams['image.interpolation'] = 'nearest'
|
|
# Create a NxN image
|
|
N = 100
|
|
(x, y) = np.indices((N, N))
|
|
x -= N//2
|
|
y -= N//2
|
|
r = np.sqrt(x**2+y**2-x*y)
|
|
|
|
# Create a contour plot at N/4 and extract both the clip path and transform
|
|
fig, ax = plt.subplots()
|
|
ax.imshow(r)
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"r": r}
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.imshow("r", data=data)
|
|
|
|
|
|
@image_comparison(['imshow_clip'], style='mpl20')
|
|
def test_imshow_clip():
|
|
# As originally reported by Gellule Xg <gellule.xg@free.fr>
|
|
# use former defaults to match existing baseline image
|
|
matplotlib.rcParams['image.interpolation'] = 'nearest'
|
|
|
|
# Create a NxN image
|
|
N = 100
|
|
(x, y) = np.indices((N, N))
|
|
x -= N//2
|
|
y -= N//2
|
|
r = np.sqrt(x**2+y**2-x*y)
|
|
|
|
# Create a contour plot at N/4 and extract both the clip path and transform
|
|
fig, ax = plt.subplots()
|
|
|
|
c = ax.contour(r, [N/4])
|
|
x = c.collections[0]
|
|
clip_path = x.get_paths()[0]
|
|
clip_transform = x.get_transform()
|
|
|
|
clip_path = mtransforms.TransformedPath(clip_path, clip_transform)
|
|
|
|
# Plot the image clipped by the contour
|
|
ax.imshow(r, clip_path=clip_path)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_imshow_norm_vminvmax(fig_test, fig_ref):
|
|
"""Parameters vmin, vmax should be ignored if norm is given."""
|
|
a = [[1, 2], [3, 4]]
|
|
ax = fig_ref.subplots()
|
|
ax.imshow(a, vmin=0, vmax=5)
|
|
ax = fig_test.subplots()
|
|
with pytest.warns(MatplotlibDeprecationWarning,
|
|
match="Passing parameters norm and vmin/vmax "
|
|
"simultaneously is deprecated."):
|
|
ax.imshow(a, norm=mcolors.Normalize(-10, 10), vmin=0, vmax=5)
|
|
|
|
|
|
@image_comparison(['polycollection_joinstyle'], remove_text=True)
|
|
def test_polycollection_joinstyle():
|
|
# Bug #2890979 reported by Matthew West
|
|
fig, ax = plt.subplots()
|
|
verts = np.array([[1, 1], [1, 2], [2, 2], [2, 1]])
|
|
c = mpl.collections.PolyCollection([verts], linewidths=40)
|
|
ax.add_collection(c)
|
|
ax.set_xbound(0, 3)
|
|
ax.set_ybound(0, 3)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'x, y1, y2', [
|
|
(np.zeros((2, 2)), 3, 3),
|
|
(np.arange(0.0, 2, 0.02), np.zeros((2, 2)), 3),
|
|
(np.arange(0.0, 2, 0.02), 3, np.zeros((2, 2)))
|
|
], ids=[
|
|
'2d_x_input',
|
|
'2d_y1_input',
|
|
'2d_y2_input'
|
|
]
|
|
)
|
|
def test_fill_between_input(x, y1, y2):
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.fill_between(x, y1, y2)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'y, x1, x2', [
|
|
(np.zeros((2, 2)), 3, 3),
|
|
(np.arange(0.0, 2, 0.02), np.zeros((2, 2)), 3),
|
|
(np.arange(0.0, 2, 0.02), 3, np.zeros((2, 2)))
|
|
], ids=[
|
|
'2d_y_input',
|
|
'2d_x1_input',
|
|
'2d_x2_input'
|
|
]
|
|
)
|
|
def test_fill_betweenx_input(y, x1, x2):
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.fill_betweenx(y, x1, x2)
|
|
|
|
|
|
@image_comparison(['fill_between_interpolate'], remove_text=True)
|
|
def test_fill_between_interpolate():
|
|
x = np.arange(0.0, 2, 0.02)
|
|
y1 = np.sin(2*np.pi*x)
|
|
y2 = 1.2*np.sin(4*np.pi*x)
|
|
|
|
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)
|
|
ax1.plot(x, y1, x, y2, color='black')
|
|
ax1.fill_between(x, y1, y2, where=y2 >= y1, facecolor='white', hatch='/',
|
|
interpolate=True)
|
|
ax1.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',
|
|
interpolate=True)
|
|
|
|
# Test support for masked arrays.
|
|
y2 = np.ma.masked_greater(y2, 1.0)
|
|
# Test that plotting works for masked arrays with the first element masked
|
|
y2[0] = np.ma.masked
|
|
ax2.plot(x, y1, x, y2, color='black')
|
|
ax2.fill_between(x, y1, y2, where=y2 >= y1, facecolor='green',
|
|
interpolate=True)
|
|
ax2.fill_between(x, y1, y2, where=y2 <= y1, facecolor='red',
|
|
interpolate=True)
|
|
|
|
|
|
@image_comparison(['fill_between_interpolate_decreasing'],
|
|
style='mpl20', remove_text=True)
|
|
def test_fill_between_interpolate_decreasing():
|
|
p = np.array([724.3, 700, 655])
|
|
t = np.array([9.4, 7, 2.2])
|
|
prof = np.array([7.9, 6.6, 3.8])
|
|
|
|
fig, ax = plt.subplots(figsize=(9, 9))
|
|
|
|
ax.plot(t, p, 'tab:red')
|
|
ax.plot(prof, p, 'k')
|
|
|
|
ax.fill_betweenx(p, t, prof, where=prof < t,
|
|
facecolor='blue', interpolate=True, alpha=0.4)
|
|
ax.fill_betweenx(p, t, prof, where=prof > t,
|
|
facecolor='red', interpolate=True, alpha=0.4)
|
|
|
|
ax.set_xlim(0, 30)
|
|
ax.set_ylim(800, 600)
|
|
|
|
|
|
# test_symlog and test_symlog2 used to have baseline images in all three
|
|
# formats, but the png and svg baselines got invalidated by the removal of
|
|
# minor tick overstriking.
|
|
@image_comparison(['symlog.pdf'])
|
|
def test_symlog():
|
|
x = np.array([0, 1, 2, 4, 6, 9, 12, 24])
|
|
y = np.array([1000000, 500000, 100000, 100, 5, 0, 0, 0])
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, y)
|
|
ax.set_yscale('symlog')
|
|
ax.set_xscale('linear')
|
|
ax.set_ylim(-1, 10000000)
|
|
|
|
|
|
@image_comparison(['symlog2.pdf'], remove_text=True)
|
|
def test_symlog2():
|
|
# Numbers from -50 to 50, with 0.1 as step
|
|
x = np.arange(-50, 50, 0.001)
|
|
|
|
fig, axs = plt.subplots(5, 1)
|
|
for ax, linthresh in zip(axs, [20., 2., 1., 0.1, 0.01]):
|
|
ax.plot(x, x)
|
|
ax.set_xscale('symlog', linthresh=linthresh)
|
|
ax.grid(True)
|
|
axs[-1].set_ylim(-0.1, 0.1)
|
|
|
|
|
|
def test_pcolorargs_5205():
|
|
# Smoketest to catch issue found in gh:5205
|
|
x = [-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5]
|
|
y = [-1.5, -1.25, -1.0, -0.75, -0.5, -0.25, 0,
|
|
0.25, 0.5, 0.75, 1.0, 1.25, 1.5]
|
|
X, Y = np.meshgrid(x, y)
|
|
Z = np.hypot(X, Y)
|
|
|
|
plt.pcolor(Z)
|
|
plt.pcolor(list(Z))
|
|
plt.pcolor(x, y, Z[:-1, :-1])
|
|
plt.pcolor(X, Y, list(Z[:-1, :-1]))
|
|
|
|
|
|
@image_comparison(['pcolormesh'], remove_text=True)
|
|
def test_pcolormesh():
|
|
n = 12
|
|
x = np.linspace(-1.5, 1.5, n)
|
|
y = np.linspace(-1.5, 1.5, n*2)
|
|
X, Y = np.meshgrid(x, y)
|
|
Qx = np.cos(Y) - np.cos(X)
|
|
Qz = np.sin(Y) + np.sin(X)
|
|
Qx = (Qx + 1.1)
|
|
Z = np.hypot(X, Y) / 5
|
|
Z = (Z - Z.min()) / Z.ptp()
|
|
|
|
# The color array can include masked values:
|
|
Zm = ma.masked_where(np.abs(Qz) < 0.5 * np.max(Qz), Z)
|
|
|
|
fig, (ax1, ax2, ax3) = plt.subplots(1, 3)
|
|
ax1.pcolormesh(Qx, Qz, Z[:-1, :-1], lw=0.5, edgecolors='k')
|
|
ax2.pcolormesh(Qx, Qz, Z[:-1, :-1], lw=2, edgecolors=['b', 'w'])
|
|
ax3.pcolormesh(Qx, Qz, Z, shading="gouraud")
|
|
|
|
|
|
@image_comparison(['pcolormesh_alpha'], extensions=["png", "pdf"],
|
|
remove_text=True)
|
|
def test_pcolormesh_alpha():
|
|
n = 12
|
|
X, Y = np.meshgrid(
|
|
np.linspace(-1.5, 1.5, n),
|
|
np.linspace(-1.5, 1.5, n*2)
|
|
)
|
|
Qx = X
|
|
Qy = Y + np.sin(X)
|
|
Z = np.hypot(X, Y) / 5
|
|
Z = (Z - Z.min()) / Z.ptp()
|
|
vir = plt.get_cmap("viridis", 16)
|
|
# make another colormap with varying alpha
|
|
colors = vir(np.arange(16))
|
|
colors[:, 3] = 0.5 + 0.5*np.sin(np.arange(16))
|
|
cmap = mcolors.ListedColormap(colors)
|
|
|
|
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
|
|
for ax in ax1, ax2, ax3, ax4:
|
|
ax.add_patch(mpatches.Rectangle(
|
|
(0, -1.5), 1.5, 3, facecolor=[.7, .1, .1, .5], zorder=0
|
|
))
|
|
# ax1, ax2: constant alpha
|
|
ax1.pcolormesh(Qx, Qy, Z[:-1, :-1], cmap=vir, alpha=0.4,
|
|
shading='flat', zorder=1)
|
|
ax2.pcolormesh(Qx, Qy, Z, cmap=vir, alpha=0.4, shading='gouraud', zorder=1)
|
|
# ax3, ax4: alpha from colormap
|
|
ax3.pcolormesh(Qx, Qy, Z[:-1, :-1], cmap=cmap, shading='flat', zorder=1)
|
|
ax4.pcolormesh(Qx, Qy, Z, cmap=cmap, shading='gouraud', zorder=1)
|
|
|
|
|
|
@image_comparison(['pcolormesh_datetime_axis.png'],
|
|
remove_text=False, style='mpl20')
|
|
def test_pcolormesh_datetime_axis():
|
|
fig = plt.figure()
|
|
fig.subplots_adjust(hspace=0.4, top=0.98, bottom=.15)
|
|
base = datetime.datetime(2013, 1, 1)
|
|
x = np.array([base + datetime.timedelta(days=d) for d in range(21)])
|
|
y = np.arange(21)
|
|
z1, z2 = np.meshgrid(np.arange(20), np.arange(20))
|
|
z = z1 * z2
|
|
plt.subplot(221)
|
|
plt.pcolormesh(x[:-1], y[:-1], z[:-1, :-1])
|
|
plt.subplot(222)
|
|
plt.pcolormesh(x, y, z)
|
|
x = np.repeat(x[np.newaxis], 21, axis=0)
|
|
y = np.repeat(y[:, np.newaxis], 21, axis=1)
|
|
plt.subplot(223)
|
|
plt.pcolormesh(x[:-1, :-1], y[:-1, :-1], z[:-1, :-1])
|
|
plt.subplot(224)
|
|
plt.pcolormesh(x, y, z)
|
|
for ax in fig.get_axes():
|
|
for label in ax.get_xticklabels():
|
|
label.set_ha('right')
|
|
label.set_rotation(30)
|
|
|
|
|
|
@image_comparison(['pcolor_datetime_axis.png'],
|
|
remove_text=False, style='mpl20')
|
|
def test_pcolor_datetime_axis():
|
|
fig = plt.figure()
|
|
fig.subplots_adjust(hspace=0.4, top=0.98, bottom=.15)
|
|
base = datetime.datetime(2013, 1, 1)
|
|
x = np.array([base + datetime.timedelta(days=d) for d in range(21)])
|
|
y = np.arange(21)
|
|
z1, z2 = np.meshgrid(np.arange(20), np.arange(20))
|
|
z = z1 * z2
|
|
plt.subplot(221)
|
|
plt.pcolor(x[:-1], y[:-1], z[:-1, :-1])
|
|
plt.subplot(222)
|
|
plt.pcolor(x, y, z)
|
|
x = np.repeat(x[np.newaxis], 21, axis=0)
|
|
y = np.repeat(y[:, np.newaxis], 21, axis=1)
|
|
plt.subplot(223)
|
|
plt.pcolor(x[:-1, :-1], y[:-1, :-1], z[:-1, :-1])
|
|
plt.subplot(224)
|
|
plt.pcolor(x, y, z)
|
|
for ax in fig.get_axes():
|
|
for label in ax.get_xticklabels():
|
|
label.set_ha('right')
|
|
label.set_rotation(30)
|
|
|
|
|
|
def test_pcolorargs():
|
|
n = 12
|
|
x = np.linspace(-1.5, 1.5, n)
|
|
y = np.linspace(-1.5, 1.5, n*2)
|
|
X, Y = np.meshgrid(x, y)
|
|
Z = np.hypot(X, Y) / 5
|
|
|
|
_, ax = plt.subplots()
|
|
with pytest.raises(TypeError):
|
|
ax.pcolormesh(y, x, Z)
|
|
with pytest.raises(TypeError):
|
|
ax.pcolormesh(X, Y, Z.T)
|
|
with pytest.raises(TypeError):
|
|
ax.pcolormesh(x, y, Z[:-1, :-1], shading="gouraud")
|
|
with pytest.raises(TypeError):
|
|
ax.pcolormesh(X, Y, Z[:-1, :-1], shading="gouraud")
|
|
x[0] = np.NaN
|
|
with pytest.raises(ValueError):
|
|
ax.pcolormesh(x, y, Z[:-1, :-1])
|
|
with np.errstate(invalid='ignore'):
|
|
x = np.ma.array(x, mask=(x < 0))
|
|
with pytest.raises(ValueError):
|
|
ax.pcolormesh(x, y, Z[:-1, :-1])
|
|
# Expect a warning with non-increasing coordinates
|
|
x = [359, 0, 1]
|
|
y = [-10, 10]
|
|
X, Y = np.meshgrid(x, y)
|
|
Z = np.zeros(X.shape)
|
|
with pytest.warns(UserWarning,
|
|
match='are not monotonically increasing or decreasing'):
|
|
ax.pcolormesh(X, Y, Z, shading='auto')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_pcolornearest(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x = np.arange(0, 10)
|
|
y = np.arange(0, 3)
|
|
np.random.seed(19680801)
|
|
Z = np.random.randn(2, 9)
|
|
ax.pcolormesh(x, y, Z, shading='flat')
|
|
|
|
ax = fig_ref.subplots()
|
|
# specify the centers
|
|
x2 = x[:-1] + np.diff(x) / 2
|
|
y2 = y[:-1] + np.diff(y) / 2
|
|
ax.pcolormesh(x2, y2, Z, shading='nearest')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_pcolornearestunits(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x = [datetime.datetime.fromtimestamp(x * 3600) for x in range(10)]
|
|
y = np.arange(0, 3)
|
|
np.random.seed(19680801)
|
|
Z = np.random.randn(2, 9)
|
|
ax.pcolormesh(x, y, Z, shading='flat')
|
|
|
|
ax = fig_ref.subplots()
|
|
# specify the centers
|
|
x2 = [datetime.datetime.fromtimestamp((x + 0.5) * 3600) for x in range(9)]
|
|
y2 = y[:-1] + np.diff(y) / 2
|
|
ax.pcolormesh(x2, y2, Z, shading='nearest')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_pcolordropdata(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x = np.arange(0, 10)
|
|
y = np.arange(0, 4)
|
|
np.random.seed(19680801)
|
|
Z = np.random.randn(3, 9)
|
|
# fake dropping the data
|
|
ax.pcolormesh(x[:-1], y[:-1], Z[:-1, :-1], shading='flat')
|
|
|
|
ax = fig_ref.subplots()
|
|
# test dropping the data...
|
|
x2 = x[:-1]
|
|
y2 = y[:-1]
|
|
with pytest.warns(MatplotlibDeprecationWarning):
|
|
ax.pcolormesh(x2, y2, Z, shading='flat')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_pcolorauto(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x = np.arange(0, 10)
|
|
y = np.arange(0, 4)
|
|
np.random.seed(19680801)
|
|
Z = np.random.randn(3, 9)
|
|
ax.pcolormesh(x, y, Z, shading='auto')
|
|
|
|
ax = fig_ref.subplots()
|
|
# specify the centers
|
|
x2 = x[:-1] + np.diff(x) / 2
|
|
y2 = y[:-1] + np.diff(y) / 2
|
|
ax.pcolormesh(x2, y2, Z, shading='auto')
|
|
|
|
|
|
@image_comparison(['canonical'])
|
|
def test_canonical():
|
|
fig, ax = plt.subplots()
|
|
ax.plot([1, 2, 3])
|
|
|
|
|
|
@image_comparison(['arc_angles.png'], remove_text=True, style='default')
|
|
def test_arc_angles():
|
|
# Ellipse parameters
|
|
w = 2
|
|
h = 1
|
|
centre = (0.2, 0.5)
|
|
scale = 2
|
|
|
|
fig, axs = plt.subplots(3, 3)
|
|
for i, ax in enumerate(axs.flat):
|
|
theta2 = i * 360 / 9
|
|
theta1 = theta2 - 45
|
|
|
|
ax.add_patch(mpatches.Ellipse(centre, w, h, alpha=0.3))
|
|
ax.add_patch(mpatches.Arc(centre, w, h, theta1=theta1, theta2=theta2))
|
|
# Straight lines intersecting start and end of arc
|
|
ax.plot([scale * np.cos(np.deg2rad(theta1)) + centre[0],
|
|
centre[0],
|
|
scale * np.cos(np.deg2rad(theta2)) + centre[0]],
|
|
[scale * np.sin(np.deg2rad(theta1)) + centre[1],
|
|
centre[1],
|
|
scale * np.sin(np.deg2rad(theta2)) + centre[1]])
|
|
|
|
ax.set_xlim(-scale, scale)
|
|
ax.set_ylim(-scale, scale)
|
|
|
|
# This looks the same, but it triggers a different code path when it
|
|
# gets large enough.
|
|
w *= 10
|
|
h *= 10
|
|
centre = (centre[0] * 10, centre[1] * 10)
|
|
scale *= 10
|
|
|
|
|
|
@image_comparison(['arc_ellipse'], remove_text=True)
|
|
def test_arc_ellipse():
|
|
xcenter, ycenter = 0.38, 0.52
|
|
width, height = 1e-1, 3e-1
|
|
angle = -30
|
|
|
|
theta = np.deg2rad(np.arange(360))
|
|
x = width / 2. * np.cos(theta)
|
|
y = height / 2. * np.sin(theta)
|
|
|
|
rtheta = np.deg2rad(angle)
|
|
R = np.array([
|
|
[np.cos(rtheta), -np.sin(rtheta)],
|
|
[np.sin(rtheta), np.cos(rtheta)]])
|
|
|
|
x, y = np.dot(R, np.array([x, y]))
|
|
x += xcenter
|
|
y += ycenter
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(211, aspect='auto')
|
|
ax.fill(x, y, alpha=0.2, facecolor='yellow', edgecolor='yellow',
|
|
linewidth=1, zorder=1)
|
|
|
|
e1 = mpatches.Arc((xcenter, ycenter), width, height,
|
|
angle=angle, linewidth=2, fill=False, zorder=2)
|
|
|
|
ax.add_patch(e1)
|
|
|
|
ax = fig.add_subplot(212, aspect='equal')
|
|
ax.fill(x, y, alpha=0.2, facecolor='green', edgecolor='green', zorder=1)
|
|
e2 = mpatches.Arc((xcenter, ycenter), width, height,
|
|
angle=angle, linewidth=2, fill=False, zorder=2)
|
|
|
|
ax.add_patch(e2)
|
|
|
|
|
|
@image_comparison(['markevery'], remove_text=True)
|
|
def test_markevery():
|
|
x = np.linspace(0, 10, 100)
|
|
y = np.sin(x) * np.sqrt(x/10 + 0.5)
|
|
|
|
# check marker only plot
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(x, y, 'o', label='default')
|
|
ax.plot(x, y, 'd', markevery=None, label='mark all')
|
|
ax.plot(x, y, 's', markevery=10, label='mark every 10')
|
|
ax.plot(x, y, '+', markevery=(5, 20), label='mark every 5 starting at 10')
|
|
ax.legend()
|
|
|
|
|
|
@image_comparison(['markevery_line'], remove_text=True)
|
|
def test_markevery_line():
|
|
x = np.linspace(0, 10, 100)
|
|
y = np.sin(x) * np.sqrt(x/10 + 0.5)
|
|
|
|
# check line/marker combos
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(x, y, '-o', label='default')
|
|
ax.plot(x, y, '-d', markevery=None, label='mark all')
|
|
ax.plot(x, y, '-s', markevery=10, label='mark every 10')
|
|
ax.plot(x, y, '-+', markevery=(5, 20), label='mark every 5 starting at 10')
|
|
ax.legend()
|
|
|
|
|
|
@image_comparison(['markevery_linear_scales'], remove_text=True)
|
|
def test_markevery_linear_scales():
|
|
cases = [None,
|
|
8,
|
|
(30, 8),
|
|
[16, 24, 30], [0, -1],
|
|
slice(100, 200, 3),
|
|
0.1, 0.3, 1.5,
|
|
(0.0, 0.1), (0.45, 0.1)]
|
|
|
|
cols = 3
|
|
gs = matplotlib.gridspec.GridSpec(len(cases) // cols + 1, cols)
|
|
|
|
delta = 0.11
|
|
x = np.linspace(0, 10 - 2 * delta, 200) + delta
|
|
y = np.sin(x) + 1.0 + delta
|
|
|
|
for i, case in enumerate(cases):
|
|
row = (i // cols)
|
|
col = i % cols
|
|
plt.subplot(gs[row, col])
|
|
plt.title('markevery=%s' % str(case))
|
|
plt.plot(x, y, 'o', ls='-', ms=4, markevery=case)
|
|
|
|
|
|
@image_comparison(['markevery_linear_scales_zoomed'], remove_text=True)
|
|
def test_markevery_linear_scales_zoomed():
|
|
cases = [None,
|
|
8,
|
|
(30, 8),
|
|
[16, 24, 30], [0, -1],
|
|
slice(100, 200, 3),
|
|
0.1, 0.3, 1.5,
|
|
(0.0, 0.1), (0.45, 0.1)]
|
|
|
|
cols = 3
|
|
gs = matplotlib.gridspec.GridSpec(len(cases) // cols + 1, cols)
|
|
|
|
delta = 0.11
|
|
x = np.linspace(0, 10 - 2 * delta, 200) + delta
|
|
y = np.sin(x) + 1.0 + delta
|
|
|
|
for i, case in enumerate(cases):
|
|
row = (i // cols)
|
|
col = i % cols
|
|
plt.subplot(gs[row, col])
|
|
plt.title('markevery=%s' % str(case))
|
|
plt.plot(x, y, 'o', ls='-', ms=4, markevery=case)
|
|
plt.xlim((6, 6.7))
|
|
plt.ylim((1.1, 1.7))
|
|
|
|
|
|
@image_comparison(['markevery_log_scales'], remove_text=True)
|
|
def test_markevery_log_scales():
|
|
cases = [None,
|
|
8,
|
|
(30, 8),
|
|
[16, 24, 30], [0, -1],
|
|
slice(100, 200, 3),
|
|
0.1, 0.3, 1.5,
|
|
(0.0, 0.1), (0.45, 0.1)]
|
|
|
|
cols = 3
|
|
gs = matplotlib.gridspec.GridSpec(len(cases) // cols + 1, cols)
|
|
|
|
delta = 0.11
|
|
x = np.linspace(0, 10 - 2 * delta, 200) + delta
|
|
y = np.sin(x) + 1.0 + delta
|
|
|
|
for i, case in enumerate(cases):
|
|
row = (i // cols)
|
|
col = i % cols
|
|
plt.subplot(gs[row, col])
|
|
plt.title('markevery=%s' % str(case))
|
|
plt.xscale('log')
|
|
plt.yscale('log')
|
|
plt.plot(x, y, 'o', ls='-', ms=4, markevery=case)
|
|
|
|
|
|
@image_comparison(['markevery_polar'], style='default', remove_text=True)
|
|
def test_markevery_polar():
|
|
cases = [None,
|
|
8,
|
|
(30, 8),
|
|
[16, 24, 30], [0, -1],
|
|
slice(100, 200, 3),
|
|
0.1, 0.3, 1.5,
|
|
(0.0, 0.1), (0.45, 0.1)]
|
|
|
|
cols = 3
|
|
gs = matplotlib.gridspec.GridSpec(len(cases) // cols + 1, cols)
|
|
|
|
r = np.linspace(0, 3.0, 200)
|
|
theta = 2 * np.pi * r
|
|
|
|
for i, case in enumerate(cases):
|
|
row = (i // cols)
|
|
col = i % cols
|
|
plt.subplot(gs[row, col], polar=True)
|
|
plt.title('markevery=%s' % str(case))
|
|
plt.plot(theta, r, 'o', ls='-', ms=4, markevery=case)
|
|
|
|
|
|
@image_comparison(['marker_edges'], remove_text=True)
|
|
def test_marker_edges():
|
|
x = np.linspace(0, 1, 10)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(x, np.sin(x), 'y.', ms=30.0, mew=0, mec='r')
|
|
ax.plot(x+0.1, np.sin(x), 'y.', ms=30.0, mew=1, mec='r')
|
|
ax.plot(x+0.2, np.sin(x), 'y.', ms=30.0, mew=2, mec='b')
|
|
|
|
|
|
@image_comparison(['bar_tick_label_single.png', 'bar_tick_label_single.png'])
|
|
def test_bar_tick_label_single():
|
|
# From 2516: plot bar with array of string labels for x axis
|
|
ax = plt.gca()
|
|
ax.bar(0, 1, align='edge', tick_label='0')
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"a": 0, "b": 1}
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax = plt.gca()
|
|
ax.bar("a", "b", align='edge', tick_label='0', data=data)
|
|
|
|
|
|
def test_nan_bar_values():
|
|
fig, ax = plt.subplots()
|
|
ax.bar([0, 1], [np.nan, 4])
|
|
|
|
|
|
def test_bar_ticklabel_fail():
|
|
fig, ax = plt.subplots()
|
|
ax.bar([], [])
|
|
|
|
|
|
@image_comparison(['bar_tick_label_multiple.png'])
|
|
def test_bar_tick_label_multiple():
|
|
# From 2516: plot bar with array of string labels for x axis
|
|
ax = plt.gca()
|
|
ax.bar([1, 2.5], [1, 2], width=[0.2, 0.5], tick_label=['a', 'b'],
|
|
align='center')
|
|
|
|
|
|
@image_comparison(['bar_tick_label_multiple_old_label_alignment.png'])
|
|
def test_bar_tick_label_multiple_old_alignment():
|
|
# Test that the alignment for class is backward compatible
|
|
matplotlib.rcParams["ytick.alignment"] = "center"
|
|
ax = plt.gca()
|
|
ax.bar([1, 2.5], [1, 2], width=[0.2, 0.5], tick_label=['a', 'b'],
|
|
align='center')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_bar_decimal_center(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x0 = [1.5, 8.4, 5.3, 4.2]
|
|
y0 = [1.1, 2.2, 3.3, 4.4]
|
|
x = [Decimal(x) for x in x0]
|
|
y = [Decimal(y) for y in y0]
|
|
# Test image - vertical, align-center bar chart with Decimal() input
|
|
ax.bar(x, y, align='center')
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.bar(x0, y0, align='center')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_barh_decimal_center(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
x0 = [1.5, 8.4, 5.3, 4.2]
|
|
y0 = [1.1, 2.2, 3.3, 4.4]
|
|
x = [Decimal(x) for x in x0]
|
|
y = [Decimal(y) for y in y0]
|
|
# Test image - horizontal, align-center bar chart with Decimal() input
|
|
ax.barh(x, y, height=[0.5, 0.5, 1, 1], align='center')
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.barh(x0, y0, height=[0.5, 0.5, 1, 1], align='center')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_bar_decimal_width(fig_test, fig_ref):
|
|
x = [1.5, 8.4, 5.3, 4.2]
|
|
y = [1.1, 2.2, 3.3, 4.4]
|
|
w0 = [0.7, 1.45, 1, 2]
|
|
w = [Decimal(i) for i in w0]
|
|
# Test image - vertical bar chart with Decimal() width
|
|
ax = fig_test.subplots()
|
|
ax.bar(x, y, width=w, align='center')
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.bar(x, y, width=w0, align='center')
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_barh_decimal_height(fig_test, fig_ref):
|
|
x = [1.5, 8.4, 5.3, 4.2]
|
|
y = [1.1, 2.2, 3.3, 4.4]
|
|
h0 = [0.7, 1.45, 1, 2]
|
|
h = [Decimal(i) for i in h0]
|
|
# Test image - horizontal bar chart with Decimal() height
|
|
ax = fig_test.subplots()
|
|
ax.barh(x, y, height=h, align='center')
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.barh(x, y, height=h0, align='center')
|
|
|
|
|
|
def test_bar_color_none_alpha():
|
|
ax = plt.gca()
|
|
rects = ax.bar([1, 2], [2, 4], alpha=0.3, color='none', edgecolor='r')
|
|
for rect in rects:
|
|
assert rect.get_facecolor() == (0, 0, 0, 0)
|
|
assert rect.get_edgecolor() == (1, 0, 0, 0.3)
|
|
|
|
|
|
def test_bar_edgecolor_none_alpha():
|
|
ax = plt.gca()
|
|
rects = ax.bar([1, 2], [2, 4], alpha=0.3, color='r', edgecolor='none')
|
|
for rect in rects:
|
|
assert rect.get_facecolor() == (1, 0, 0, 0.3)
|
|
assert rect.get_edgecolor() == (0, 0, 0, 0)
|
|
|
|
|
|
@image_comparison(['barh_tick_label.png'])
|
|
def test_barh_tick_label():
|
|
# From 2516: plot barh with array of string labels for y axis
|
|
ax = plt.gca()
|
|
ax.barh([1, 2.5], [1, 2], height=[0.2, 0.5], tick_label=['a', 'b'],
|
|
align='center')
|
|
|
|
|
|
def test_bar_timedelta():
|
|
"""Smoketest that bar can handle width and height in delta units."""
|
|
fig, ax = plt.subplots()
|
|
ax.bar(datetime.datetime(2018, 1, 1), 1.,
|
|
width=datetime.timedelta(hours=3))
|
|
ax.bar(datetime.datetime(2018, 1, 1), 1.,
|
|
xerr=datetime.timedelta(hours=2),
|
|
width=datetime.timedelta(hours=3))
|
|
fig, ax = plt.subplots()
|
|
ax.barh(datetime.datetime(2018, 1, 1), 1,
|
|
height=datetime.timedelta(hours=3))
|
|
ax.barh(datetime.datetime(2018, 1, 1), 1,
|
|
height=datetime.timedelta(hours=3),
|
|
yerr=datetime.timedelta(hours=2))
|
|
fig, ax = plt.subplots()
|
|
ax.barh([datetime.datetime(2018, 1, 1), datetime.datetime(2018, 1, 1)],
|
|
np.array([1, 1.5]),
|
|
height=datetime.timedelta(hours=3))
|
|
ax.barh([datetime.datetime(2018, 1, 1), datetime.datetime(2018, 1, 1)],
|
|
np.array([1, 1.5]),
|
|
height=[datetime.timedelta(hours=t) for t in [1, 2]])
|
|
ax.broken_barh([(datetime.datetime(2018, 1, 1),
|
|
datetime.timedelta(hours=1))],
|
|
(10, 20))
|
|
|
|
|
|
def test_boxplot_dates_pandas(pd):
|
|
# smoke test for boxplot and dates in pandas
|
|
data = np.random.rand(5, 2)
|
|
years = pd.date_range('1/1/2000',
|
|
periods=2, freq=pd.DateOffset(years=1)).year
|
|
plt.figure()
|
|
plt.boxplot(data, positions=years)
|
|
|
|
|
|
def test_bar_pandas(pd):
|
|
# Smoke test for pandas
|
|
df = pd.DataFrame(
|
|
{'year': [2018, 2018, 2018],
|
|
'month': [1, 1, 1],
|
|
'day': [1, 2, 3],
|
|
'value': [1, 2, 3]})
|
|
df['date'] = pd.to_datetime(df[['year', 'month', 'day']])
|
|
|
|
monthly = df[['date', 'value']].groupby(['date']).sum()
|
|
dates = monthly.index
|
|
forecast = monthly['value']
|
|
baseline = monthly['value']
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.bar(dates, forecast, width=10, align='center')
|
|
ax.plot(dates, baseline, color='orange', lw=4)
|
|
|
|
|
|
def test_bar_pandas_indexed(pd):
|
|
# Smoke test for indexed pandas
|
|
df = pd.DataFrame({"x": [1., 2., 3.], "width": [.2, .4, .6]},
|
|
index=[1, 2, 3])
|
|
fig, ax = plt.subplots()
|
|
ax.bar(df.x, 1., width=df.width)
|
|
|
|
|
|
def test_pandas_minimal_plot(pd):
|
|
# smoke test that series and index objcets do not warn
|
|
x = pd.Series([1, 2], dtype="float64")
|
|
plt.plot(x, x)
|
|
plt.plot(x.index, x)
|
|
plt.plot(x)
|
|
plt.plot(x.index)
|
|
|
|
|
|
@image_comparison(['hist_log'], remove_text=True)
|
|
def test_hist_log():
|
|
data0 = np.linspace(0, 1, 200)**3
|
|
data = np.concatenate([1 - data0, 1 + data0])
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist(data, fill=False, log=True)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_hist_log_2(fig_test, fig_ref):
|
|
axs_test = fig_test.subplots(2, 3)
|
|
axs_ref = fig_ref.subplots(2, 3)
|
|
for i, histtype in enumerate(["bar", "step", "stepfilled"]):
|
|
# Set log scale, then call hist().
|
|
axs_test[0, i].set_yscale("log")
|
|
axs_test[0, i].hist(1, 1, histtype=histtype)
|
|
# Call hist(), then set log scale.
|
|
axs_test[1, i].hist(1, 1, histtype=histtype)
|
|
axs_test[1, i].set_yscale("log")
|
|
# Use hist(..., log=True).
|
|
for ax in axs_ref[:, i]:
|
|
ax.hist(1, 1, log=True, histtype=histtype)
|
|
|
|
|
|
def test_hist_log_barstacked():
|
|
fig, axs = plt.subplots(2)
|
|
axs[0].hist([[0], [0, 1]], 2, histtype="barstacked")
|
|
axs[0].set_yscale("log")
|
|
axs[1].hist([0, 0, 1], 2, histtype="barstacked")
|
|
axs[1].set_yscale("log")
|
|
fig.canvas.draw()
|
|
assert axs[0].get_ylim() == axs[1].get_ylim()
|
|
|
|
|
|
@image_comparison(['hist_bar_empty.png'], remove_text=True)
|
|
def test_hist_bar_empty():
|
|
# From #3886: creating hist from empty dataset raises ValueError
|
|
ax = plt.gca()
|
|
ax.hist([], histtype='bar')
|
|
|
|
|
|
@image_comparison(['hist_step_empty.png'], remove_text=True)
|
|
def test_hist_step_empty():
|
|
# From #3886: creating hist from empty dataset raises ValueError
|
|
ax = plt.gca()
|
|
ax.hist([], histtype='step')
|
|
|
|
|
|
@image_comparison(['hist_step_filled.png'], remove_text=True)
|
|
def test_hist_step_filled():
|
|
np.random.seed(0)
|
|
x = np.random.randn(1000, 3)
|
|
n_bins = 10
|
|
|
|
kwargs = [{'fill': True}, {'fill': False}, {'fill': None}, {}]*2
|
|
types = ['step']*4+['stepfilled']*4
|
|
fig, axs = plt.subplots(nrows=2, ncols=4)
|
|
|
|
for kg, _type, ax in zip(kwargs, types, axs.flat):
|
|
ax.hist(x, n_bins, histtype=_type, stacked=True, **kg)
|
|
ax.set_title('%s/%s' % (kg, _type))
|
|
ax.set_ylim(bottom=-50)
|
|
|
|
patches = axs[0, 0].patches
|
|
assert all(p.get_facecolor() == p.get_edgecolor() for p in patches)
|
|
|
|
|
|
@image_comparison(['hist_density.png'])
|
|
def test_hist_density():
|
|
np.random.seed(19680801)
|
|
data = np.random.standard_normal(2000)
|
|
fig, ax = plt.subplots()
|
|
ax.hist(data, density=True)
|
|
|
|
|
|
def test_hist_unequal_bins_density():
|
|
# Test correct behavior of normalized histogram with unequal bins
|
|
# https://github.com/matplotlib/matplotlib/issues/9557
|
|
rng = np.random.RandomState(57483)
|
|
t = rng.randn(100)
|
|
bins = [-3, -1, -0.5, 0, 1, 5]
|
|
mpl_heights, _, _ = plt.hist(t, bins=bins, density=True)
|
|
np_heights, _ = np.histogram(t, bins=bins, density=True)
|
|
assert_allclose(mpl_heights, np_heights)
|
|
|
|
|
|
def test_hist_datetime_datasets():
|
|
data = [[datetime.datetime(2017, 1, 1), datetime.datetime(2017, 1, 1)],
|
|
[datetime.datetime(2017, 1, 1), datetime.datetime(2017, 1, 2)]]
|
|
fig, ax = plt.subplots()
|
|
ax.hist(data, stacked=True)
|
|
ax.hist(data, stacked=False)
|
|
|
|
|
|
@pytest.mark.parametrize("bins_preprocess",
|
|
[mpl.dates.date2num,
|
|
lambda bins: bins,
|
|
lambda bins: np.asarray(bins).astype('datetime64')],
|
|
ids=['date2num', 'datetime.datetime',
|
|
'np.datetime64'])
|
|
def test_hist_datetime_datasets_bins(bins_preprocess):
|
|
data = [[datetime.datetime(2019, 1, 5), datetime.datetime(2019, 1, 11),
|
|
datetime.datetime(2019, 2, 1), datetime.datetime(2019, 3, 1)],
|
|
[datetime.datetime(2019, 1, 11), datetime.datetime(2019, 2, 5),
|
|
datetime.datetime(2019, 2, 18), datetime.datetime(2019, 3, 1)]]
|
|
|
|
date_edges = [datetime.datetime(2019, 1, 1), datetime.datetime(2019, 2, 1),
|
|
datetime.datetime(2019, 3, 1)]
|
|
|
|
fig, ax = plt.subplots()
|
|
_, bins, _ = ax.hist(data, bins=bins_preprocess(date_edges), stacked=True)
|
|
np.testing.assert_allclose(bins, mpl.dates.date2num(date_edges))
|
|
|
|
_, bins, _ = ax.hist(data, bins=bins_preprocess(date_edges), stacked=False)
|
|
np.testing.assert_allclose(bins, mpl.dates.date2num(date_edges))
|
|
|
|
|
|
@pytest.mark.parametrize('data, expected_number_of_hists',
|
|
[([], 1),
|
|
([[]], 1),
|
|
([[], []], 2)])
|
|
def test_hist_with_empty_input(data, expected_number_of_hists):
|
|
hists, _, _ = plt.hist(data)
|
|
hists = np.asarray(hists)
|
|
|
|
if hists.ndim == 1:
|
|
assert 1 == expected_number_of_hists
|
|
else:
|
|
assert hists.shape[0] == expected_number_of_hists
|
|
|
|
|
|
@pytest.mark.parametrize("histtype, zorder",
|
|
[("bar", mpl.patches.Patch.zorder),
|
|
("step", mpl.lines.Line2D.zorder),
|
|
("stepfilled", mpl.patches.Patch.zorder)])
|
|
def test_hist_zorder(histtype, zorder):
|
|
ax = plt.figure().add_subplot()
|
|
ax.hist([1, 2], histtype=histtype)
|
|
assert ax.patches
|
|
for patch in ax.patches:
|
|
assert patch.get_zorder() == zorder
|
|
|
|
|
|
def contour_dat():
|
|
x = np.linspace(-3, 5, 150)
|
|
y = np.linspace(-3, 5, 120)
|
|
z = np.cos(x) + np.sin(y[:, np.newaxis])
|
|
return x, y, z
|
|
|
|
|
|
@image_comparison(['contour_hatching'], remove_text=True, style='mpl20')
|
|
def test_contour_hatching():
|
|
x, y, z = contour_dat()
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.contourf(x, y, z, 7, hatches=['/', '\\', '//', '-'],
|
|
cmap=plt.get_cmap('gray'),
|
|
extend='both', alpha=0.5)
|
|
|
|
|
|
@image_comparison(['contour_colorbar'], style='mpl20')
|
|
def test_contour_colorbar():
|
|
x, y, z = contour_dat()
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
cs = ax.contourf(x, y, z, levels=np.arange(-1.8, 1.801, 0.2),
|
|
cmap=plt.get_cmap('RdBu'),
|
|
vmin=-0.6,
|
|
vmax=0.6,
|
|
extend='both')
|
|
cs1 = ax.contour(x, y, z, levels=np.arange(-2.2, -0.599, 0.2),
|
|
colors=['y'],
|
|
linestyles='solid',
|
|
linewidths=2)
|
|
cs2 = ax.contour(x, y, z, levels=np.arange(0.6, 2.2, 0.2),
|
|
colors=['c'],
|
|
linewidths=2)
|
|
cbar = fig.colorbar(cs, ax=ax)
|
|
cbar.add_lines(cs1)
|
|
cbar.add_lines(cs2, erase=False)
|
|
|
|
|
|
@image_comparison(['hist2d', 'hist2d'], remove_text=True, style='mpl20')
|
|
def test_hist2d():
|
|
np.random.seed(0)
|
|
# make it not symmetric in case we switch x and y axis
|
|
x = np.random.randn(100)*2+5
|
|
y = np.random.randn(100)-2
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist2d(x, y, bins=10, rasterized=True)
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"x": x, "y": y}
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist2d("x", "y", bins=10, data=data, rasterized=True)
|
|
|
|
|
|
@image_comparison(['hist2d_transpose'], remove_text=True, style='mpl20')
|
|
def test_hist2d_transpose():
|
|
np.random.seed(0)
|
|
# make sure the output from np.histogram is transposed before
|
|
# passing to pcolorfast
|
|
x = np.array([5]*100)
|
|
y = np.random.randn(100)-2
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist2d(x, y, bins=10, rasterized=True)
|
|
|
|
|
|
def test_hist2d_density():
|
|
x, y = np.random.random((2, 100))
|
|
ax = plt.figure().subplots()
|
|
for obj in [ax, plt]:
|
|
obj.hist2d(x, y, density=True)
|
|
|
|
|
|
class TestScatter:
|
|
@image_comparison(['scatter'], style='mpl20', remove_text=True)
|
|
def test_scatter_plot(self):
|
|
data = {"x": np.array([3, 4, 2, 6]), "y": np.array([2, 5, 2, 3]),
|
|
"c": ['r', 'y', 'b', 'lime'], "s": [24, 15, 19, 29],
|
|
"c2": ['0.5', '0.6', '0.7', '0.8']}
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.scatter(data["x"] - 1., data["y"] - 1., c=data["c"], s=data["s"])
|
|
ax.scatter(data["x"] + 1., data["y"] + 1., c=data["c2"], s=data["s"])
|
|
ax.scatter("x", "y", c="c", s="s", data=data)
|
|
|
|
@image_comparison(['scatter_marker.png'], remove_text=True)
|
|
def test_scatter_marker(self):
|
|
fig, (ax0, ax1, ax2) = plt.subplots(ncols=3)
|
|
ax0.scatter([3, 4, 2, 6], [2, 5, 2, 3],
|
|
c=[(1, 0, 0), 'y', 'b', 'lime'],
|
|
s=[60, 50, 40, 30],
|
|
edgecolors=['k', 'r', 'g', 'b'],
|
|
marker='s')
|
|
ax1.scatter([3, 4, 2, 6], [2, 5, 2, 3],
|
|
c=[(1, 0, 0), 'y', 'b', 'lime'],
|
|
s=[60, 50, 40, 30],
|
|
edgecolors=['k', 'r', 'g', 'b'],
|
|
marker=mmarkers.MarkerStyle('o', fillstyle='top'))
|
|
# unit area ellipse
|
|
rx, ry = 3, 1
|
|
area = rx * ry * np.pi
|
|
theta = np.linspace(0, 2 * np.pi, 21)
|
|
verts = np.column_stack([np.cos(theta) * rx / area,
|
|
np.sin(theta) * ry / area])
|
|
ax2.scatter([3, 4, 2, 6], [2, 5, 2, 3],
|
|
c=[(1, 0, 0), 'y', 'b', 'lime'],
|
|
s=[60, 50, 40, 30],
|
|
edgecolors=['k', 'r', 'g', 'b'],
|
|
marker=verts)
|
|
|
|
@image_comparison(['scatter_2D'], remove_text=True, extensions=['png'])
|
|
def test_scatter_2D(self):
|
|
x = np.arange(3)
|
|
y = np.arange(2)
|
|
x, y = np.meshgrid(x, y)
|
|
z = x + y
|
|
fig, ax = plt.subplots()
|
|
ax.scatter(x, y, c=z, s=200, edgecolors='face')
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_decimal(self, fig_test, fig_ref):
|
|
x0 = np.array([1.5, 8.4, 5.3, 4.2])
|
|
y0 = np.array([1.1, 2.2, 3.3, 4.4])
|
|
x = np.array([Decimal(i) for i in x0])
|
|
y = np.array([Decimal(i) for i in y0])
|
|
c = ['r', 'y', 'b', 'lime']
|
|
s = [24, 15, 19, 29]
|
|
# Test image - scatter plot with Decimal() input
|
|
ax = fig_test.subplots()
|
|
ax.scatter(x, y, c=c, s=s)
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.scatter(x0, y0, c=c, s=s)
|
|
|
|
def test_scatter_color(self):
|
|
# Try to catch cases where 'c' kwarg should have been used.
|
|
with pytest.raises(ValueError):
|
|
plt.scatter([1, 2], [1, 2], color=[0.1, 0.2])
|
|
with pytest.raises(ValueError):
|
|
plt.scatter([1, 2, 3], [1, 2, 3], color=[1, 2, 3])
|
|
|
|
def test_scatter_size_arg_size(self):
|
|
x = np.arange(4)
|
|
with pytest.raises(ValueError):
|
|
plt.scatter(x, x, x[1:])
|
|
with pytest.raises(ValueError):
|
|
plt.scatter(x[1:], x[1:], x)
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_invalid_color(self, fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
cmap = plt.get_cmap("viridis", 16)
|
|
cmap.set_bad("k", 1)
|
|
# Set a nonuniform size to prevent the last call to `scatter` (plotting
|
|
# the invalid points separately in fig_ref) from using the marker
|
|
# stamping fast path, which would result in slightly offset markers.
|
|
ax.scatter(range(4), range(4),
|
|
c=[1, np.nan, 2, np.nan], s=[1, 2, 3, 4],
|
|
cmap=cmap, plotnonfinite=True)
|
|
ax = fig_ref.subplots()
|
|
cmap = plt.get_cmap("viridis", 16)
|
|
ax.scatter([0, 2], [0, 2], c=[1, 2], s=[1, 3], cmap=cmap)
|
|
ax.scatter([1, 3], [1, 3], s=[2, 4], color="k")
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_no_invalid_color(self, fig_test, fig_ref):
|
|
# With plotninfinite=False we plot only 2 points.
|
|
ax = fig_test.subplots()
|
|
cmap = plt.get_cmap("viridis", 16)
|
|
cmap.set_bad("k", 1)
|
|
ax.scatter(range(4), range(4),
|
|
c=[1, np.nan, 2, np.nan], s=[1, 2, 3, 4],
|
|
cmap=cmap, plotnonfinite=False)
|
|
ax = fig_ref.subplots()
|
|
ax.scatter([0, 2], [0, 2], c=[1, 2], s=[1, 3], cmap=cmap)
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_norm_vminvmax(self, fig_test, fig_ref):
|
|
"""Parameters vmin, vmax should be ignored if norm is given."""
|
|
x = [1, 2, 3]
|
|
ax = fig_ref.subplots()
|
|
ax.scatter(x, x, c=x, vmin=0, vmax=5)
|
|
ax = fig_test.subplots()
|
|
with pytest.warns(MatplotlibDeprecationWarning,
|
|
match="Passing parameters norm and vmin/vmax "
|
|
"simultaneously is deprecated."):
|
|
ax.scatter(x, x, c=x, norm=mcolors.Normalize(-10, 10),
|
|
vmin=0, vmax=5)
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_single_point(self, fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
ax.scatter(1, 1, c=1)
|
|
ax = fig_ref.subplots()
|
|
ax.scatter([1], [1], c=[1])
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_different_shapes(self, fig_test, fig_ref):
|
|
x = np.arange(10)
|
|
ax = fig_test.subplots()
|
|
ax.scatter(x, x.reshape(2, 5), c=x.reshape(5, 2))
|
|
ax = fig_ref.subplots()
|
|
ax.scatter(x.reshape(5, 2), x, c=x.reshape(2, 5))
|
|
|
|
# Parameters for *test_scatter_c*. NB: assuming that the
|
|
# scatter plot will have 4 elements. The tuple scheme is:
|
|
# (*c* parameter case, exception regexp key or None if no exception)
|
|
params_test_scatter_c = [
|
|
# single string:
|
|
('0.5', None),
|
|
# Single letter-sequences
|
|
(["rgby"], "conversion"),
|
|
# Special cases
|
|
("red", None),
|
|
("none", None),
|
|
(None, None),
|
|
(["r", "g", "b", "none"], None),
|
|
# Non-valid color spec (FWIW, 'jaune' means yellow in French)
|
|
("jaune", "conversion"),
|
|
(["jaune"], "conversion"), # wrong type before wrong size
|
|
(["jaune"]*4, "conversion"),
|
|
# Value-mapping like
|
|
([0.5]*3, None), # should emit a warning for user's eyes though
|
|
([0.5]*4, None), # NB: no warning as matching size allows mapping
|
|
([0.5]*5, "shape"),
|
|
# list of strings:
|
|
(['0.5', '0.4', '0.6', '0.7'], None),
|
|
(['0.5', 'red', '0.6', 'C5'], None),
|
|
(['0.5', 0.5, '0.6', 'C5'], "conversion"),
|
|
# RGB values
|
|
([[1, 0, 0]], None),
|
|
([[1, 0, 0]]*3, "shape"),
|
|
([[1, 0, 0]]*4, None),
|
|
([[1, 0, 0]]*5, "shape"),
|
|
# RGBA values
|
|
([[1, 0, 0, 0.5]], None),
|
|
([[1, 0, 0, 0.5]]*3, "shape"),
|
|
([[1, 0, 0, 0.5]]*4, None),
|
|
([[1, 0, 0, 0.5]]*5, "shape"),
|
|
# Mix of valid color specs
|
|
([[1, 0, 0, 0.5]]*3 + [[1, 0, 0]], None),
|
|
([[1, 0, 0, 0.5], "red", "0.0"], "shape"),
|
|
([[1, 0, 0, 0.5], "red", "0.0", "C5"], None),
|
|
([[1, 0, 0, 0.5], "red", "0.0", "C5", [0, 1, 0]], "shape"),
|
|
# Mix of valid and non valid color specs
|
|
([[1, 0, 0, 0.5], "red", "jaune"], "conversion"),
|
|
([[1, 0, 0, 0.5], "red", "0.0", "jaune"], "conversion"),
|
|
([[1, 0, 0, 0.5], "red", "0.0", "C5", "jaune"], "conversion"),
|
|
]
|
|
|
|
@pytest.mark.parametrize('c_case, re_key', params_test_scatter_c)
|
|
def test_scatter_c(self, c_case, re_key):
|
|
def get_next_color():
|
|
return 'blue' # currently unused
|
|
|
|
xsize = 4
|
|
# Additional checking of *c* (introduced in #11383).
|
|
REGEXP = {
|
|
"shape": "^'c' argument has [0-9]+ elements", # shape mismatch
|
|
"conversion": "^'c' argument must be a color", # bad vals
|
|
}
|
|
|
|
if re_key is None:
|
|
mpl.axes.Axes._parse_scatter_color_args(
|
|
c=c_case, edgecolors="black", kwargs={}, xsize=xsize,
|
|
get_next_color_func=get_next_color)
|
|
else:
|
|
with pytest.raises(ValueError, match=REGEXP[re_key]):
|
|
mpl.axes.Axes._parse_scatter_color_args(
|
|
c=c_case, edgecolors="black", kwargs={}, xsize=xsize,
|
|
get_next_color_func=get_next_color)
|
|
|
|
@pytest.mark.style('default')
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_scatter_single_color_c(self, fig_test, fig_ref):
|
|
rgb = [[1, 0.5, 0.05]]
|
|
rgba = [[1, 0.5, 0.05, .5]]
|
|
|
|
# set via color kwarg
|
|
ax_ref = fig_ref.subplots()
|
|
ax_ref.scatter(np.ones(3), range(3), color=rgb)
|
|
ax_ref.scatter(np.ones(4)*2, range(4), color=rgba)
|
|
|
|
# set via broadcasting via c
|
|
ax_test = fig_test.subplots()
|
|
ax_test.scatter(np.ones(3), range(3), c=rgb)
|
|
ax_test.scatter(np.ones(4)*2, range(4), c=rgba)
|
|
|
|
def test_scatter_linewidths(self):
|
|
x = np.arange(5)
|
|
|
|
fig, ax = plt.subplots()
|
|
for i in range(3):
|
|
pc = ax.scatter(x, np.full(5, i), c=f'C{i}', marker='x', s=100,
|
|
linewidths=i + 1)
|
|
assert pc.get_linewidths() == i + 1
|
|
|
|
pc = ax.scatter(x, np.full(5, 3), c='C3', marker='x', s=100,
|
|
linewidths=[*range(1, 5), None])
|
|
assert_array_equal(pc.get_linewidths(),
|
|
[*range(1, 5), mpl.rcParams['lines.linewidth']])
|
|
|
|
|
|
def _params(c=None, xsize=2, *, edgecolors=None, **kwargs):
|
|
return (c, edgecolors, kwargs if kwargs is not None else {}, xsize)
|
|
_result = namedtuple('_result', 'c, colors')
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'params, expected_result',
|
|
[(_params(),
|
|
_result(c='b', colors=np.array([[0, 0, 1, 1]]))),
|
|
(_params(c='r'),
|
|
_result(c='r', colors=np.array([[1, 0, 0, 1]]))),
|
|
(_params(c='r', colors='b'),
|
|
_result(c='r', colors=np.array([[1, 0, 0, 1]]))),
|
|
# color
|
|
(_params(color='b'),
|
|
_result(c='b', colors=np.array([[0, 0, 1, 1]]))),
|
|
(_params(color=['b', 'g']),
|
|
_result(c=['b', 'g'], colors=np.array([[0, 0, 1, 1], [0, .5, 0, 1]]))),
|
|
])
|
|
def test_parse_scatter_color_args(params, expected_result):
|
|
def get_next_color():
|
|
return 'blue' # currently unused
|
|
|
|
c, colors, _edgecolors = mpl.axes.Axes._parse_scatter_color_args(
|
|
*params, get_next_color_func=get_next_color)
|
|
assert c == expected_result.c
|
|
assert_allclose(colors, expected_result.colors)
|
|
|
|
del _params
|
|
del _result
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
'kwargs, expected_edgecolors',
|
|
[(dict(), None),
|
|
(dict(c='b'), None),
|
|
(dict(edgecolors='r'), 'r'),
|
|
(dict(edgecolors=['r', 'g']), ['r', 'g']),
|
|
(dict(edgecolor='r'), 'r'),
|
|
(dict(edgecolors='face'), 'face'),
|
|
(dict(edgecolors='none'), 'none'),
|
|
(dict(edgecolor='r', edgecolors='g'), 'r'),
|
|
(dict(c='b', edgecolor='r', edgecolors='g'), 'r'),
|
|
(dict(color='r'), 'r'),
|
|
(dict(color='r', edgecolor='g'), 'g'),
|
|
])
|
|
def test_parse_scatter_color_args_edgecolors(kwargs, expected_edgecolors):
|
|
def get_next_color():
|
|
return 'blue' # currently unused
|
|
|
|
c = kwargs.pop('c', None)
|
|
edgecolors = kwargs.pop('edgecolors', None)
|
|
_, _, result_edgecolors = \
|
|
mpl.axes.Axes._parse_scatter_color_args(
|
|
c, edgecolors, kwargs, xsize=2, get_next_color_func=get_next_color)
|
|
assert result_edgecolors == expected_edgecolors
|
|
|
|
|
|
def test_parse_scatter_color_args_error():
|
|
def get_next_color():
|
|
return 'blue' # currently unused
|
|
|
|
with pytest.raises(ValueError,
|
|
match="RGBA values should be within 0-1 range"):
|
|
c = np.array([[0.1, 0.2, 0.7], [0.2, 0.4, 1.4]]) # value > 1
|
|
mpl.axes.Axes._parse_scatter_color_args(
|
|
c, None, kwargs={}, xsize=2, get_next_color_func=get_next_color)
|
|
|
|
|
|
def test_as_mpl_axes_api():
|
|
# tests the _as_mpl_axes api
|
|
from matplotlib.projections.polar import PolarAxes
|
|
|
|
class Polar:
|
|
def __init__(self):
|
|
self.theta_offset = 0
|
|
|
|
def _as_mpl_axes(self):
|
|
# implement the matplotlib axes interface
|
|
return PolarAxes, {'theta_offset': self.theta_offset}
|
|
|
|
prj = Polar()
|
|
prj2 = Polar()
|
|
prj2.theta_offset = np.pi
|
|
prj3 = Polar()
|
|
|
|
# testing axes creation with plt.axes
|
|
ax = plt.axes([0, 0, 1, 1], projection=prj)
|
|
assert type(ax) == PolarAxes
|
|
ax_via_gca = plt.gca(projection=prj)
|
|
assert ax_via_gca is ax
|
|
plt.close()
|
|
|
|
# testing axes creation with gca
|
|
ax = plt.gca(projection=prj)
|
|
assert type(ax) == mpl.axes._subplots.subplot_class_factory(PolarAxes)
|
|
ax_via_gca = plt.gca(projection=prj)
|
|
assert ax_via_gca is ax
|
|
# try getting the axes given a different polar projection
|
|
with pytest.warns(UserWarning) as rec:
|
|
ax_via_gca = plt.gca(projection=prj2)
|
|
assert len(rec) == 1
|
|
assert 'Requested projection is different' in str(rec[0].message)
|
|
assert ax_via_gca is not ax
|
|
assert ax.get_theta_offset() == 0
|
|
assert ax_via_gca.get_theta_offset() == np.pi
|
|
# try getting the axes given an == (not is) polar projection
|
|
with pytest.warns(UserWarning):
|
|
ax_via_gca = plt.gca(projection=prj3)
|
|
assert len(rec) == 1
|
|
assert 'Requested projection is different' in str(rec[0].message)
|
|
assert ax_via_gca is ax
|
|
plt.close()
|
|
|
|
# testing axes creation with subplot
|
|
ax = plt.subplot(121, projection=prj)
|
|
assert type(ax) == mpl.axes._subplots.subplot_class_factory(PolarAxes)
|
|
plt.close()
|
|
|
|
|
|
def test_pyplot_axes():
|
|
# test focusing of Axes in other Figure
|
|
fig1, ax1 = plt.subplots()
|
|
fig2, ax2 = plt.subplots()
|
|
plt.sca(ax1)
|
|
assert ax1 is plt.gca()
|
|
assert fig1 is plt.gcf()
|
|
plt.close(fig1)
|
|
plt.close(fig2)
|
|
|
|
|
|
@image_comparison(['log_scales'])
|
|
def test_log_scales():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.plot(np.log(np.linspace(0.1, 100)))
|
|
ax.set_yscale('log', base=5.5)
|
|
ax.invert_yaxis()
|
|
ax.set_xscale('log', base=9.0)
|
|
|
|
|
|
def test_log_scales_no_data():
|
|
_, ax = plt.subplots()
|
|
ax.set(xscale="log", yscale="log")
|
|
ax.xaxis.set_major_locator(mticker.MultipleLocator(1))
|
|
assert ax.get_xlim() == ax.get_ylim() == (1, 10)
|
|
|
|
|
|
def test_log_scales_invalid():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.set_xscale('log')
|
|
with pytest.warns(UserWarning, match='Attempted to set non-positive'):
|
|
ax.set_xlim(-1, 10)
|
|
ax.set_yscale('log')
|
|
with pytest.warns(UserWarning, match='Attempted to set non-positive'):
|
|
ax.set_ylim(-1, 10)
|
|
|
|
|
|
@image_comparison(['stackplot_test_image', 'stackplot_test_image'])
|
|
def test_stackplot():
|
|
fig = plt.figure()
|
|
x = np.linspace(0, 10, 10)
|
|
y1 = 1.0 * x
|
|
y2 = 2.0 * x + 1
|
|
y3 = 3.0 * x + 2
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.stackplot(x, y1, y2, y3)
|
|
ax.set_xlim((0, 10))
|
|
ax.set_ylim((0, 70))
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"x": x, "y1": y1, "y2": y2, "y3": y3}
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.stackplot("x", "y1", "y2", "y3", data=data)
|
|
ax.set_xlim((0, 10))
|
|
ax.set_ylim((0, 70))
|
|
|
|
|
|
@image_comparison(['stackplot_test_baseline'], remove_text=True)
|
|
def test_stackplot_baseline():
|
|
np.random.seed(0)
|
|
|
|
def layers(n, m):
|
|
a = np.zeros((m, n))
|
|
for i in range(n):
|
|
for j in range(5):
|
|
x = 1 / (.1 + np.random.random())
|
|
y = 2 * np.random.random() - .5
|
|
z = 10 / (.1 + np.random.random())
|
|
a[:, i] += x * np.exp(-((np.arange(m) / m - y) * z) ** 2)
|
|
return a
|
|
|
|
d = layers(3, 100)
|
|
d[50, :] = 0 # test for fixed weighted wiggle (issue #6313)
|
|
|
|
fig, axs = plt.subplots(2, 2)
|
|
|
|
axs[0, 0].stackplot(range(100), d.T, baseline='zero')
|
|
axs[0, 1].stackplot(range(100), d.T, baseline='sym')
|
|
axs[1, 0].stackplot(range(100), d.T, baseline='wiggle')
|
|
axs[1, 1].stackplot(range(100), d.T, baseline='weighted_wiggle')
|
|
|
|
|
|
def _bxp_test_helper(
|
|
stats_kwargs={}, transform_stats=lambda s: s, bxp_kwargs={}):
|
|
np.random.seed(937)
|
|
logstats = mpl.cbook.boxplot_stats(
|
|
np.random.lognormal(mean=1.25, sigma=1., size=(37, 4)), **stats_kwargs)
|
|
fig, ax = plt.subplots()
|
|
if bxp_kwargs.get('vert', True):
|
|
ax.set_yscale('log')
|
|
else:
|
|
ax.set_xscale('log')
|
|
# Work around baseline images generate back when bxp did not respect the
|
|
# boxplot.boxprops.linewidth rcParam when patch_artist is False.
|
|
if not bxp_kwargs.get('patch_artist', False):
|
|
mpl.rcParams['boxplot.boxprops.linewidth'] = \
|
|
mpl.rcParams['lines.linewidth']
|
|
ax.bxp(transform_stats(logstats), **bxp_kwargs)
|
|
|
|
|
|
@image_comparison(['bxp_baseline.png'],
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_baseline():
|
|
_bxp_test_helper()
|
|
|
|
|
|
@image_comparison(['bxp_rangewhis.png'],
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_rangewhis():
|
|
_bxp_test_helper(stats_kwargs=dict(whis=[0, 100]))
|
|
|
|
|
|
@image_comparison(['bxp_percentilewhis.png'],
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_percentilewhis():
|
|
_bxp_test_helper(stats_kwargs=dict(whis=[5, 95]))
|
|
|
|
|
|
@image_comparison(['bxp_with_xlabels.png'],
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_with_xlabels():
|
|
def transform(stats):
|
|
for s, label in zip(stats, list('ABCD')):
|
|
s['label'] = label
|
|
return stats
|
|
|
|
_bxp_test_helper(transform_stats=transform)
|
|
|
|
|
|
@image_comparison(['bxp_horizontal.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default',
|
|
tol=0.1)
|
|
def test_bxp_horizontal():
|
|
_bxp_test_helper(bxp_kwargs=dict(vert=False))
|
|
|
|
|
|
@image_comparison(['bxp_with_ylabels.png'],
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default',
|
|
tol=0.1)
|
|
def test_bxp_with_ylabels():
|
|
def transform(stats):
|
|
for s, label in zip(stats, list('ABCD')):
|
|
s['label'] = label
|
|
return stats
|
|
|
|
_bxp_test_helper(transform_stats=transform, bxp_kwargs=dict(vert=False))
|
|
|
|
|
|
@image_comparison(['bxp_patchartist.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_patchartist():
|
|
_bxp_test_helper(bxp_kwargs=dict(patch_artist=True))
|
|
|
|
|
|
@image_comparison(['bxp_custompatchartist.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 100},
|
|
style='default')
|
|
def test_bxp_custompatchartist():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
patch_artist=True,
|
|
boxprops=dict(facecolor='yellow', edgecolor='green', ls=':')))
|
|
|
|
|
|
@image_comparison(['bxp_customoutlier.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_customoutlier():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
flierprops=dict(linestyle='none', marker='d', mfc='g')))
|
|
|
|
|
|
@image_comparison(['bxp_withmean_custompoint.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_showcustommean():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
showmeans=True,
|
|
meanprops=dict(linestyle='none', marker='d', mfc='green'),
|
|
))
|
|
|
|
|
|
@image_comparison(['bxp_custombox.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_custombox():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
boxprops=dict(linestyle='--', color='b', lw=3)))
|
|
|
|
|
|
@image_comparison(['bxp_custommedian.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_custommedian():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
medianprops=dict(linestyle='--', color='b', lw=3)))
|
|
|
|
|
|
@image_comparison(['bxp_customcap.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_customcap():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
capprops=dict(linestyle='--', color='g', lw=3)))
|
|
|
|
|
|
@image_comparison(['bxp_customwhisker.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_customwhisker():
|
|
_bxp_test_helper(bxp_kwargs=dict(
|
|
whiskerprops=dict(linestyle='-', color='m', lw=3)))
|
|
|
|
|
|
@image_comparison(['bxp_withnotch.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_shownotches():
|
|
_bxp_test_helper(bxp_kwargs=dict(shownotches=True))
|
|
|
|
|
|
@image_comparison(['bxp_nocaps.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_nocaps():
|
|
_bxp_test_helper(bxp_kwargs=dict(showcaps=False))
|
|
|
|
|
|
@image_comparison(['bxp_nobox.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_nobox():
|
|
_bxp_test_helper(bxp_kwargs=dict(showbox=False))
|
|
|
|
|
|
@image_comparison(['bxp_no_flier_stats.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_no_flier_stats():
|
|
def transform(stats):
|
|
for s in stats:
|
|
s.pop('fliers', None)
|
|
return stats
|
|
|
|
_bxp_test_helper(transform_stats=transform,
|
|
bxp_kwargs=dict(showfliers=False))
|
|
|
|
|
|
@image_comparison(['bxp_withmean_point.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_showmean():
|
|
_bxp_test_helper(bxp_kwargs=dict(showmeans=True, meanline=False))
|
|
|
|
|
|
@image_comparison(['bxp_withmean_line.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_showmeanasline():
|
|
_bxp_test_helper(bxp_kwargs=dict(showmeans=True, meanline=True))
|
|
|
|
|
|
@image_comparison(['bxp_scalarwidth.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_scalarwidth():
|
|
_bxp_test_helper(bxp_kwargs=dict(widths=.25))
|
|
|
|
|
|
@image_comparison(['bxp_customwidths.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_customwidths():
|
|
_bxp_test_helper(bxp_kwargs=dict(widths=[0.10, 0.25, 0.65, 0.85]))
|
|
|
|
|
|
@image_comparison(['bxp_custompositions.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_bxp_custompositions():
|
|
_bxp_test_helper(bxp_kwargs=dict(positions=[1, 5, 6, 7]))
|
|
|
|
|
|
def test_bxp_bad_widths():
|
|
with pytest.raises(ValueError):
|
|
_bxp_test_helper(bxp_kwargs=dict(widths=[1]))
|
|
|
|
|
|
def test_bxp_bad_positions():
|
|
with pytest.raises(ValueError):
|
|
_bxp_test_helper(bxp_kwargs=dict(positions=[2, 3]))
|
|
|
|
|
|
@image_comparison(['boxplot', 'boxplot'], tol=1.28, style='default')
|
|
def test_boxplot():
|
|
# Randomness used for bootstrapping.
|
|
np.random.seed(937)
|
|
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig, ax = plt.subplots()
|
|
|
|
ax.boxplot([x, x], bootstrap=10000, notch=1)
|
|
ax.set_ylim((-30, 30))
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"x": [x, x]}
|
|
fig, ax = plt.subplots()
|
|
ax.boxplot("x", bootstrap=10000, notch=1, data=data)
|
|
ax.set_ylim((-30, 30))
|
|
|
|
|
|
@image_comparison(['boxplot_sym2.png'], remove_text=True, style='default')
|
|
def test_boxplot_sym2():
|
|
# Randomness used for bootstrapping.
|
|
np.random.seed(937)
|
|
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig, [ax1, ax2] = plt.subplots(1, 2)
|
|
|
|
ax1.boxplot([x, x], bootstrap=10000, sym='^')
|
|
ax1.set_ylim((-30, 30))
|
|
|
|
ax2.boxplot([x, x], bootstrap=10000, sym='g')
|
|
ax2.set_ylim((-30, 30))
|
|
|
|
|
|
@image_comparison(['boxplot_sym.png'],
|
|
remove_text=True,
|
|
savefig_kwarg={'dpi': 40},
|
|
style='default')
|
|
def test_boxplot_sym():
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig, ax = plt.subplots()
|
|
|
|
ax.boxplot([x, x], sym='gs')
|
|
ax.set_ylim((-30, 30))
|
|
|
|
|
|
@image_comparison(['boxplot_autorange_false_whiskers.png',
|
|
'boxplot_autorange_true_whiskers.png'],
|
|
style='default')
|
|
def test_boxplot_autorange_whiskers():
|
|
# Randomness used for bootstrapping.
|
|
np.random.seed(937)
|
|
|
|
x = np.ones(140)
|
|
x = np.hstack([0, x, 2])
|
|
|
|
fig1, ax1 = plt.subplots()
|
|
ax1.boxplot([x, x], bootstrap=10000, notch=1)
|
|
ax1.set_ylim((-5, 5))
|
|
|
|
fig2, ax2 = plt.subplots()
|
|
ax2.boxplot([x, x], bootstrap=10000, notch=1, autorange=True)
|
|
ax2.set_ylim((-5, 5))
|
|
|
|
|
|
def _rc_test_bxp_helper(ax, rc_dict):
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
with matplotlib.rc_context(rc_dict):
|
|
ax.boxplot([x, x])
|
|
return ax
|
|
|
|
|
|
@image_comparison(['boxplot_rc_parameters'],
|
|
savefig_kwarg={'dpi': 100}, remove_text=True,
|
|
tol=1, style='default')
|
|
def test_boxplot_rc_parameters():
|
|
# Randomness used for bootstrapping.
|
|
np.random.seed(937)
|
|
|
|
fig, ax = plt.subplots(3)
|
|
|
|
rc_axis0 = {
|
|
'boxplot.notch': True,
|
|
'boxplot.whiskers': [5, 95],
|
|
'boxplot.bootstrap': 10000,
|
|
|
|
'boxplot.flierprops.color': 'b',
|
|
'boxplot.flierprops.marker': 'o',
|
|
'boxplot.flierprops.markerfacecolor': 'g',
|
|
'boxplot.flierprops.markeredgecolor': 'b',
|
|
'boxplot.flierprops.markersize': 5,
|
|
'boxplot.flierprops.linestyle': '--',
|
|
'boxplot.flierprops.linewidth': 2.0,
|
|
|
|
'boxplot.boxprops.color': 'r',
|
|
'boxplot.boxprops.linewidth': 2.0,
|
|
'boxplot.boxprops.linestyle': '--',
|
|
|
|
'boxplot.capprops.color': 'c',
|
|
'boxplot.capprops.linewidth': 2.0,
|
|
'boxplot.capprops.linestyle': '--',
|
|
|
|
'boxplot.medianprops.color': 'k',
|
|
'boxplot.medianprops.linewidth': 2.0,
|
|
'boxplot.medianprops.linestyle': '--',
|
|
}
|
|
|
|
rc_axis1 = {
|
|
'boxplot.vertical': False,
|
|
'boxplot.whiskers': [0, 100],
|
|
'boxplot.patchartist': True,
|
|
}
|
|
|
|
rc_axis2 = {
|
|
'boxplot.whiskers': 2.0,
|
|
'boxplot.showcaps': False,
|
|
'boxplot.showbox': False,
|
|
'boxplot.showfliers': False,
|
|
'boxplot.showmeans': True,
|
|
'boxplot.meanline': True,
|
|
|
|
'boxplot.meanprops.color': 'c',
|
|
'boxplot.meanprops.linewidth': 2.0,
|
|
'boxplot.meanprops.linestyle': '--',
|
|
|
|
'boxplot.whiskerprops.color': 'r',
|
|
'boxplot.whiskerprops.linewidth': 2.0,
|
|
'boxplot.whiskerprops.linestyle': '-.',
|
|
}
|
|
dict_list = [rc_axis0, rc_axis1, rc_axis2]
|
|
for axis, rc_axis in zip(ax, dict_list):
|
|
_rc_test_bxp_helper(axis, rc_axis)
|
|
|
|
assert (matplotlib.patches.PathPatch in
|
|
[type(t) for t in ax[1].get_children()])
|
|
|
|
|
|
@image_comparison(['boxplot_with_CIarray.png'],
|
|
remove_text=True, savefig_kwarg={'dpi': 40}, style='default')
|
|
def test_boxplot_with_CIarray():
|
|
# Randomness used for bootstrapping.
|
|
np.random.seed(937)
|
|
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
CIs = np.array([[-1.5, 3.], [-1., 3.5]])
|
|
|
|
# show a boxplot with Matplotlib medians and confidence intervals, and
|
|
# another with manual values
|
|
ax.boxplot([x, x], bootstrap=10000, usermedians=[None, 1.0],
|
|
conf_intervals=CIs, notch=1)
|
|
ax.set_ylim((-30, 30))
|
|
|
|
|
|
@image_comparison(['boxplot_no_inverted_whisker.png'],
|
|
remove_text=True, savefig_kwarg={'dpi': 40}, style='default')
|
|
def test_boxplot_no_weird_whisker():
|
|
x = np.array([3, 9000, 150, 88, 350, 200000, 1400, 960],
|
|
dtype=np.float64)
|
|
ax1 = plt.axes()
|
|
ax1.boxplot(x)
|
|
ax1.set_yscale('log')
|
|
ax1.yaxis.grid(False, which='minor')
|
|
ax1.xaxis.grid(False)
|
|
|
|
|
|
def test_boxplot_bad_medians():
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.boxplot(x, usermedians=[1, 2])
|
|
with pytest.raises(ValueError):
|
|
ax.boxplot([x, x], usermedians=[[1, 2], [1, 2]])
|
|
|
|
|
|
def test_boxplot_bad_ci():
|
|
x = np.linspace(-7, 7, 140)
|
|
x = np.hstack([-25, x, 25])
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.boxplot([x, x], conf_intervals=[[1, 2]])
|
|
with pytest.raises(ValueError):
|
|
ax.boxplot([x, x], conf_intervals=[[1, 2], [1]])
|
|
|
|
|
|
def test_boxplot_zorder():
|
|
x = np.arange(10)
|
|
fix, ax = plt.subplots()
|
|
assert ax.boxplot(x)['boxes'][0].get_zorder() == 2
|
|
assert ax.boxplot(x, zorder=10)['boxes'][0].get_zorder() == 10
|
|
|
|
|
|
def test_boxplot_marker_behavior():
|
|
plt.rcParams['lines.marker'] = 's'
|
|
plt.rcParams['boxplot.flierprops.marker'] = 'o'
|
|
plt.rcParams['boxplot.meanprops.marker'] = '^'
|
|
fig, ax = plt.subplots()
|
|
test_data = np.arange(100)
|
|
test_data[-1] = 150 # a flier point
|
|
bxp_handle = ax.boxplot(test_data, showmeans=True)
|
|
for bxp_lines in ['whiskers', 'caps', 'boxes', 'medians']:
|
|
for each_line in bxp_handle[bxp_lines]:
|
|
# Ensure that the rcParams['lines.marker'] is overridden by ''
|
|
assert each_line.get_marker() == ''
|
|
|
|
# Ensure that markers for fliers and means aren't overridden with ''
|
|
assert bxp_handle['fliers'][0].get_marker() == 'o'
|
|
assert bxp_handle['means'][0].get_marker() == '^'
|
|
|
|
|
|
@image_comparison(['boxplot_mod_artists_after_plotting.png'],
|
|
remove_text=True, savefig_kwarg={'dpi': 40}, style='default')
|
|
def test_boxplot_mod_artist_after_plotting():
|
|
x = [0.15, 0.11, 0.06, 0.06, 0.12, 0.56, -0.56]
|
|
fig, ax = plt.subplots()
|
|
bp = ax.boxplot(x, sym="o")
|
|
for key in bp:
|
|
for obj in bp[key]:
|
|
obj.set_color('green')
|
|
|
|
|
|
@image_comparison(['violinplot_vert_baseline.png',
|
|
'violinplot_vert_baseline.png'])
|
|
def test_vert_violinplot_baseline():
|
|
# First 9 digits of frac(sqrt(2))
|
|
np.random.seed(414213562)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax = plt.axes()
|
|
ax.violinplot(data, positions=range(4), showmeans=0, showextrema=0,
|
|
showmedians=0)
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"d": data}
|
|
fig, ax = plt.subplots()
|
|
ax = plt.axes()
|
|
ax.violinplot("d", positions=range(4), showmeans=0, showextrema=0,
|
|
showmedians=0, data=data)
|
|
|
|
|
|
@image_comparison(['violinplot_vert_showmeans.png'])
|
|
def test_vert_violinplot_showmeans():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(3))
|
|
np.random.seed(732050807)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=1, showextrema=0,
|
|
showmedians=0)
|
|
|
|
|
|
@image_comparison(['violinplot_vert_showextrema.png'])
|
|
def test_vert_violinplot_showextrema():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(5))
|
|
np.random.seed(236067977)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=0, showextrema=1,
|
|
showmedians=0)
|
|
|
|
|
|
@image_comparison(['violinplot_vert_showmedians.png'])
|
|
def test_vert_violinplot_showmedians():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(7))
|
|
np.random.seed(645751311)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=0, showextrema=0,
|
|
showmedians=1)
|
|
|
|
|
|
@image_comparison(['violinplot_vert_showall.png'])
|
|
def test_vert_violinplot_showall():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(11))
|
|
np.random.seed(316624790)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=1, showextrema=1,
|
|
showmedians=1,
|
|
quantiles=[[0.1, 0.9], [0.2, 0.8], [0.3, 0.7], [0.4, 0.6]])
|
|
|
|
|
|
@image_comparison(['violinplot_vert_custompoints_10.png'])
|
|
def test_vert_violinplot_custompoints_10():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(13))
|
|
np.random.seed(605551275)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=0, showextrema=0,
|
|
showmedians=0, points=10)
|
|
|
|
|
|
@image_comparison(['violinplot_vert_custompoints_200.png'])
|
|
def test_vert_violinplot_custompoints_200():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(17))
|
|
np.random.seed(123105625)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), showmeans=0, showextrema=0,
|
|
showmedians=0, points=200)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_baseline.png'])
|
|
def test_horiz_violinplot_baseline():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(19))
|
|
np.random.seed(358898943)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=0,
|
|
showextrema=0, showmedians=0)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_showmedians.png'])
|
|
def test_horiz_violinplot_showmedians():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(23))
|
|
np.random.seed(795831523)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=0,
|
|
showextrema=0, showmedians=1)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_showmeans.png'])
|
|
def test_horiz_violinplot_showmeans():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(29))
|
|
np.random.seed(385164807)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=1,
|
|
showextrema=0, showmedians=0)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_showextrema.png'])
|
|
def test_horiz_violinplot_showextrema():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(31))
|
|
np.random.seed(567764362)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=0,
|
|
showextrema=1, showmedians=0)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_showall.png'])
|
|
def test_horiz_violinplot_showall():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(37))
|
|
np.random.seed(82762530)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=1,
|
|
showextrema=1, showmedians=1,
|
|
quantiles=[[0.1, 0.9], [0.2, 0.8], [0.3, 0.7], [0.4, 0.6]])
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_custompoints_10.png'])
|
|
def test_horiz_violinplot_custompoints_10():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(41))
|
|
np.random.seed(403124237)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=0,
|
|
showextrema=0, showmedians=0, points=10)
|
|
|
|
|
|
@image_comparison(['violinplot_horiz_custompoints_200.png'])
|
|
def test_horiz_violinplot_custompoints_200():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(43))
|
|
np.random.seed(557438524)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
ax.violinplot(data, positions=range(4), vert=False, showmeans=0,
|
|
showextrema=0, showmedians=0, points=200)
|
|
|
|
|
|
def test_violinplot_bad_positions():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(47))
|
|
np.random.seed(855654600)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
with pytest.raises(ValueError):
|
|
ax.violinplot(data, positions=range(5))
|
|
|
|
|
|
def test_violinplot_bad_widths():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(53))
|
|
np.random.seed(280109889)
|
|
data = [np.random.normal(size=100) for i in range(4)]
|
|
with pytest.raises(ValueError):
|
|
ax.violinplot(data, positions=range(4), widths=[1, 2, 3])
|
|
|
|
|
|
def test_violinplot_bad_quantiles():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(73))
|
|
np.random.seed(544003745)
|
|
data = [np.random.normal(size=100)]
|
|
|
|
# Different size quantile list and plots
|
|
with pytest.raises(ValueError):
|
|
ax.violinplot(data, quantiles=[[0.1, 0.2], [0.5, 0.7]])
|
|
|
|
|
|
def test_violinplot_outofrange_quantiles():
|
|
ax = plt.axes()
|
|
# First 9 digits of frac(sqrt(79))
|
|
np.random.seed(888194417)
|
|
data = [np.random.normal(size=100)]
|
|
|
|
# Quantile value above 100
|
|
with pytest.raises(ValueError):
|
|
ax.violinplot(data, quantiles=[[0.1, 0.2, 0.3, 1.05]])
|
|
|
|
# Quantile value below 0
|
|
with pytest.raises(ValueError):
|
|
ax.violinplot(data, quantiles=[[-0.05, 0.2, 0.3, 0.75]])
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_violinplot_single_list_quantiles(fig_test, fig_ref):
|
|
# Ensures quantile list for 1D can be passed in as single list
|
|
# First 9 digits of frac(sqrt(83))
|
|
np.random.seed(110433579)
|
|
data = [np.random.normal(size=100)]
|
|
|
|
# Test image
|
|
ax = fig_test.subplots()
|
|
ax.violinplot(data, quantiles=[0.1, 0.3, 0.9])
|
|
|
|
# Reference image
|
|
ax = fig_ref.subplots()
|
|
ax.violinplot(data, quantiles=[[0.1, 0.3, 0.9]])
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_violinplot_pandas_series(fig_test, fig_ref, pd):
|
|
np.random.seed(110433579)
|
|
s1 = pd.Series(np.random.normal(size=7), index=[9, 8, 7, 6, 5, 4, 3])
|
|
s2 = pd.Series(np.random.normal(size=9), index=list('ABCDEFGHI'))
|
|
s3 = pd.Series(np.random.normal(size=11))
|
|
fig_test.subplots().violinplot([s1, s2, s3])
|
|
fig_ref.subplots().violinplot([s1.values, s2.values, s3.values])
|
|
|
|
|
|
def test_manage_xticks():
|
|
_, ax = plt.subplots()
|
|
ax.set_xlim(0, 4)
|
|
old_xlim = ax.get_xlim()
|
|
np.random.seed(0)
|
|
y1 = np.random.normal(10, 3, 20)
|
|
y2 = np.random.normal(3, 1, 20)
|
|
ax.boxplot([y1, y2], positions=[1, 2], manage_ticks=False)
|
|
new_xlim = ax.get_xlim()
|
|
assert_array_equal(old_xlim, new_xlim)
|
|
|
|
|
|
def test_boxplot_not_single():
|
|
fig, ax = plt.subplots()
|
|
ax.boxplot(np.random.rand(100), positions=[3])
|
|
ax.boxplot(np.random.rand(100), positions=[5])
|
|
fig.canvas.draw()
|
|
assert ax.get_xlim() == (2.5, 5.5)
|
|
assert list(ax.get_xticks()) == [3, 5]
|
|
assert [t.get_text() for t in ax.get_xticklabels()] == ["3", "5"]
|
|
|
|
|
|
def test_tick_space_size_0():
|
|
# allow font size to be zero, which affects ticks when there is
|
|
# no other text in the figure.
|
|
plt.plot([0, 1], [0, 1])
|
|
matplotlib.rcParams.update({'font.size': 0})
|
|
b = io.BytesIO()
|
|
plt.savefig(b, dpi=80, format='raw')
|
|
|
|
|
|
@image_comparison(['errorbar_basic', 'errorbar_mixed', 'errorbar_basic'])
|
|
def test_errorbar():
|
|
x = np.arange(0.1, 4, 0.5)
|
|
y = np.exp(-x)
|
|
|
|
yerr = 0.1 + 0.2*np.sqrt(x)
|
|
xerr = 0.1 + yerr
|
|
|
|
# First illustrate basic pyplot interface, using defaults where possible.
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.errorbar(x, y, xerr=0.2, yerr=0.4)
|
|
ax.set_title("Simplest errorbars, 0.2 in x, 0.4 in y")
|
|
|
|
# Now switch to a more OO interface to exercise more features.
|
|
fig, axs = plt.subplots(nrows=2, ncols=2, sharex=True)
|
|
ax = axs[0, 0]
|
|
ax.errorbar(x, y, yerr=yerr, fmt='o')
|
|
ax.set_title('Vert. symmetric')
|
|
|
|
# With 4 subplots, reduce the number of axis ticks to avoid crowding.
|
|
ax.locator_params(nbins=4)
|
|
|
|
ax = axs[0, 1]
|
|
ax.errorbar(x, y, xerr=xerr, fmt='o', alpha=0.4)
|
|
ax.set_title('Hor. symmetric w/ alpha')
|
|
|
|
ax = axs[1, 0]
|
|
ax.errorbar(x, y, yerr=[yerr, 2*yerr], xerr=[xerr, 2*xerr], fmt='--o')
|
|
ax.set_title('H, V asymmetric')
|
|
|
|
ax = axs[1, 1]
|
|
ax.set_yscale('log')
|
|
# Here we have to be careful to keep all y values positive:
|
|
ylower = np.maximum(1e-2, y - yerr)
|
|
yerr_lower = y - ylower
|
|
|
|
ax.errorbar(x, y, yerr=[yerr_lower, 2*yerr], xerr=xerr,
|
|
fmt='o', ecolor='g', capthick=2)
|
|
ax.set_title('Mixed sym., log y')
|
|
|
|
fig.suptitle('Variable errorbars')
|
|
|
|
# Reuse the first testcase from above for a labeled data test
|
|
data = {"x": x, "y": y}
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.errorbar("x", "y", xerr=0.2, yerr=0.4, data=data)
|
|
ax.set_title("Simplest errorbars, 0.2 in x, 0.4 in y")
|
|
|
|
|
|
def test_errorbar_colorcycle():
|
|
|
|
f, ax = plt.subplots()
|
|
x = np.arange(10)
|
|
y = 2*x
|
|
|
|
e1, _, _ = ax.errorbar(x, y, c=None)
|
|
e2, _, _ = ax.errorbar(x, 2*y, c=None)
|
|
ln1, = ax.plot(x, 4*y)
|
|
|
|
assert mcolors.to_rgba(e1.get_color()) == mcolors.to_rgba('C0')
|
|
assert mcolors.to_rgba(e2.get_color()) == mcolors.to_rgba('C1')
|
|
assert mcolors.to_rgba(ln1.get_color()) == mcolors.to_rgba('C2')
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_errorbar_cycle_ecolor(fig_test, fig_ref):
|
|
x = np.arange(0.1, 4, 0.5)
|
|
y = [np.exp(-x+n) for n in range(4)]
|
|
|
|
axt = fig_test.subplots()
|
|
axr = fig_ref.subplots()
|
|
|
|
for yi, color in zip(y, ['C0', 'C1', 'C2', 'C3']):
|
|
axt.errorbar(x, yi, yerr=(yi * 0.25), linestyle='-',
|
|
marker='o', ecolor='black')
|
|
axr.errorbar(x, yi, yerr=(yi * 0.25), linestyle='-',
|
|
marker='o', color=color, ecolor='black')
|
|
|
|
|
|
def test_errorbar_shape():
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
|
|
x = np.arange(0.1, 4, 0.5)
|
|
y = np.exp(-x)
|
|
yerr1 = 0.1 + 0.2*np.sqrt(x)
|
|
yerr = np.vstack((yerr1, 2*yerr1)).T
|
|
xerr = 0.1 + yerr
|
|
|
|
with pytest.raises(ValueError):
|
|
ax.errorbar(x, y, yerr=yerr, fmt='o')
|
|
with pytest.raises(ValueError):
|
|
ax.errorbar(x, y, xerr=xerr, fmt='o')
|
|
with pytest.raises(ValueError):
|
|
ax.errorbar(x, y, yerr=yerr, xerr=xerr, fmt='o')
|
|
|
|
|
|
@image_comparison(['errorbar_limits'])
|
|
def test_errorbar_limits():
|
|
x = np.arange(0.5, 5.5, 0.5)
|
|
y = np.exp(-x)
|
|
xerr = 0.1
|
|
yerr = 0.2
|
|
ls = 'dotted'
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
|
|
# standard error bars
|
|
plt.errorbar(x, y, xerr=xerr, yerr=yerr, ls=ls, color='blue')
|
|
|
|
# including upper limits
|
|
uplims = np.zeros_like(x)
|
|
uplims[[1, 5, 9]] = True
|
|
plt.errorbar(x, y+0.5, xerr=xerr, yerr=yerr, uplims=uplims, ls=ls,
|
|
color='green')
|
|
|
|
# including lower limits
|
|
lolims = np.zeros_like(x)
|
|
lolims[[2, 4, 8]] = True
|
|
plt.errorbar(x, y+1.0, xerr=xerr, yerr=yerr, lolims=lolims, ls=ls,
|
|
color='red')
|
|
|
|
# including upper and lower limits
|
|
plt.errorbar(x, y+1.5, marker='o', ms=8, xerr=xerr, yerr=yerr,
|
|
lolims=lolims, uplims=uplims, ls=ls, color='magenta')
|
|
|
|
# including xlower and xupper limits
|
|
xerr = 0.2
|
|
yerr = np.full_like(x, 0.2)
|
|
yerr[[3, 6]] = 0.3
|
|
xlolims = lolims
|
|
xuplims = uplims
|
|
lolims = np.zeros_like(x)
|
|
uplims = np.zeros_like(x)
|
|
lolims[[6]] = True
|
|
uplims[[3]] = True
|
|
plt.errorbar(x, y+2.1, marker='o', ms=8, xerr=xerr, yerr=yerr,
|
|
xlolims=xlolims, xuplims=xuplims, uplims=uplims,
|
|
lolims=lolims, ls='none', mec='blue', capsize=0,
|
|
color='cyan')
|
|
ax.set_xlim((0, 5.5))
|
|
ax.set_title('Errorbar upper and lower limits')
|
|
|
|
|
|
def test_errobar_nonefmt():
|
|
# Check that passing 'none' as a format still plots errorbars
|
|
x = np.arange(5)
|
|
y = np.arange(5)
|
|
|
|
plotline, _, barlines = plt.errorbar(x, y, xerr=1, yerr=1, fmt='none')
|
|
assert plotline is None
|
|
for errbar in barlines:
|
|
assert np.all(errbar.get_color() == mcolors.to_rgba('C0'))
|
|
|
|
|
|
@image_comparison(['errorbar_with_prop_cycle.png'],
|
|
style='mpl20', remove_text=True)
|
|
def test_errorbar_with_prop_cycle():
|
|
_cycle = cycler(ls=['--', ':'], marker=['s', 's'], mfc=['k', 'w'])
|
|
plt.rc("axes", prop_cycle=_cycle)
|
|
fig, ax = plt.subplots()
|
|
ax.errorbar(x=[2, 4, 10], y=[3, 2, 4], yerr=0.5)
|
|
ax.errorbar(x=[2, 4, 10], y=[6, 4, 2], yerr=0.5)
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_errorbar_offsets(fig_test, fig_ref):
|
|
x = np.linspace(0, 1, 15)
|
|
y = x * (1-x)
|
|
yerr = y/6
|
|
|
|
ax_ref = fig_ref.subplots()
|
|
ax_test = fig_test.subplots()
|
|
|
|
for color, shift in zip('rgbk', [0, 0, 2, 7]):
|
|
y += .02
|
|
|
|
# Using feature in question
|
|
ax_test.errorbar(x, y, yerr, errorevery=(shift, 4),
|
|
capsize=4, c=color)
|
|
|
|
# Using manual errorbars
|
|
# n.b. errorbar draws the main plot at z=2.1 by default
|
|
ax_ref.plot(x, y, c=color, zorder=2.1)
|
|
ax_ref.errorbar(x[shift::4], y[shift::4], yerr[shift::4],
|
|
capsize=4, c=color, fmt='none')
|
|
|
|
|
|
@image_comparison(['hist_stacked_stepfilled', 'hist_stacked_stepfilled'])
|
|
def test_hist_stacked_stepfilled():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
d2 = np.linspace(0, 10, 50)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist((d1, d2), histtype="stepfilled", stacked=True)
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"x": (d1, d2)}
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist("x", histtype="stepfilled", stacked=True, data=data)
|
|
|
|
|
|
@image_comparison(['hist_offset'])
|
|
def test_hist_offset():
|
|
# make some data
|
|
d1 = np.linspace(0, 10, 50)
|
|
d2 = np.linspace(1, 3, 20)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist(d1, bottom=5)
|
|
ax.hist(d2, bottom=15)
|
|
|
|
|
|
@image_comparison(['hist_step.png'], remove_text=True)
|
|
def test_hist_step():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist(d1, histtype="step")
|
|
ax.set_ylim(0, 10)
|
|
ax.set_xlim(-1, 5)
|
|
|
|
|
|
@image_comparison(['hist_step_horiz.png'])
|
|
def test_hist_step_horiz():
|
|
# make some data
|
|
d1 = np.linspace(0, 10, 50)
|
|
d2 = np.linspace(1, 3, 20)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist((d1, d2), histtype="step", orientation="horizontal")
|
|
|
|
|
|
@image_comparison(['hist_stacked_weights'])
|
|
def test_hist_stacked_weighted():
|
|
# make some data
|
|
d1 = np.linspace(0, 10, 50)
|
|
d2 = np.linspace(1, 3, 20)
|
|
w1 = np.linspace(0.01, 3.5, 50)
|
|
w2 = np.linspace(0.05, 2., 20)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist((d1, d2), weights=(w1, w2), histtype="stepfilled", stacked=True)
|
|
|
|
|
|
@pytest.mark.parametrize("use_line_collection", [True, False],
|
|
ids=['w/ line collection', 'w/o line collection'])
|
|
@image_comparison(['stem.png'], style='mpl20', remove_text=True)
|
|
def test_stem(use_line_collection):
|
|
x = np.linspace(0.1, 2 * np.pi, 100)
|
|
args = (x, np.cos(x))
|
|
# Label is a single space to force a legend to be drawn, but to avoid any
|
|
# text being drawn
|
|
kwargs = dict(linefmt='C2-.', markerfmt='k+', basefmt='C1-.',
|
|
label=' ', use_line_collection=use_line_collection)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.stem(*args, **kwargs)
|
|
|
|
ax.legend()
|
|
|
|
|
|
def test_stem_args():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
|
|
x = list(range(10))
|
|
y = list(range(10))
|
|
|
|
# Test the call signatures
|
|
ax.stem(y)
|
|
ax.stem(x, y)
|
|
ax.stem(x, y, 'r--')
|
|
ax.stem(x, y, 'r--', basefmt='b--')
|
|
|
|
|
|
def test_stem_dates():
|
|
fig, ax = plt.subplots(1, 1)
|
|
xs = [dateutil.parser.parse("2013-9-28 11:00:00"),
|
|
dateutil.parser.parse("2013-9-28 12:00:00")]
|
|
ys = [100, 200]
|
|
ax.stem(xs, ys, "*-")
|
|
|
|
|
|
@image_comparison(['hist_stacked_stepfilled_alpha'])
|
|
def test_hist_stacked_stepfilled_alpha():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
d2 = np.linspace(0, 10, 50)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist((d1, d2), histtype="stepfilled", stacked=True, alpha=0.5)
|
|
|
|
|
|
@image_comparison(['hist_stacked_step'])
|
|
def test_hist_stacked_step():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
d2 = np.linspace(0, 10, 50)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist((d1, d2), histtype="step", stacked=True)
|
|
|
|
|
|
@image_comparison(['hist_stacked_normed'])
|
|
def test_hist_stacked_density():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
d2 = np.linspace(0, 10, 50)
|
|
fig, ax = plt.subplots()
|
|
ax.hist((d1, d2), stacked=True, density=True)
|
|
|
|
|
|
@image_comparison(['hist_step_bottom.png'], remove_text=True)
|
|
def test_hist_step_bottom():
|
|
# make some data
|
|
d1 = np.linspace(1, 3, 20)
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist(d1, bottom=np.arange(10), histtype="stepfilled")
|
|
|
|
|
|
def test_hist_stepfilled_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data = [0, 0, 1, 1, 1, 2]
|
|
_, _, (polygon, ) = plt.hist(data,
|
|
bins=bins,
|
|
histtype='stepfilled')
|
|
xy = [[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 1], [3, 1],
|
|
[3, 0], [2, 0], [2, 0], [1, 0], [1, 0], [0, 0]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_step_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data = [0, 0, 1, 1, 1, 2]
|
|
_, _, (polygon, ) = plt.hist(data,
|
|
bins=bins,
|
|
histtype='step')
|
|
xy = [[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 1], [3, 1], [3, 0]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_stepfilled_bottom_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data = [0, 0, 1, 1, 1, 2]
|
|
_, _, (polygon, ) = plt.hist(data,
|
|
bins=bins,
|
|
bottom=[1, 2, 1.5],
|
|
histtype='stepfilled')
|
|
xy = [[0, 1], [0, 3], [1, 3], [1, 5], [2, 5], [2, 2.5], [3, 2.5],
|
|
[3, 1.5], [2, 1.5], [2, 2], [1, 2], [1, 1], [0, 1]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_step_bottom_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data = [0, 0, 1, 1, 1, 2]
|
|
_, _, (polygon, ) = plt.hist(data,
|
|
bins=bins,
|
|
bottom=[1, 2, 1.5],
|
|
histtype='step')
|
|
xy = [[0, 1], [0, 3], [1, 3], [1, 5], [2, 5], [2, 2.5], [3, 2.5], [3, 1.5]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_stacked_stepfilled_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data_1 = [0, 0, 1, 1, 1, 2]
|
|
data_2 = [0, 1, 2]
|
|
_, _, patches = plt.hist([data_1, data_2],
|
|
bins=bins,
|
|
stacked=True,
|
|
histtype='stepfilled')
|
|
|
|
assert len(patches) == 2
|
|
|
|
polygon, = patches[0]
|
|
xy = [[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 1], [3, 1],
|
|
[3, 0], [2, 0], [2, 0], [1, 0], [1, 0], [0, 0]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
polygon, = patches[1]
|
|
xy = [[0, 2], [0, 3], [1, 3], [1, 4], [2, 4], [2, 2], [3, 2],
|
|
[3, 1], [2, 1], [2, 3], [1, 3], [1, 2], [0, 2]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_stacked_step_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data_1 = [0, 0, 1, 1, 1, 2]
|
|
data_2 = [0, 1, 2]
|
|
_, _, patches = plt.hist([data_1, data_2],
|
|
bins=bins,
|
|
stacked=True,
|
|
histtype='step')
|
|
|
|
assert len(patches) == 2
|
|
|
|
polygon, = patches[0]
|
|
xy = [[0, 0], [0, 2], [1, 2], [1, 3], [2, 3], [2, 1], [3, 1], [3, 0]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
polygon, = patches[1]
|
|
xy = [[0, 2], [0, 3], [1, 3], [1, 4], [2, 4], [2, 2], [3, 2], [3, 1]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_stacked_stepfilled_bottom_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data_1 = [0, 0, 1, 1, 1, 2]
|
|
data_2 = [0, 1, 2]
|
|
_, _, patches = plt.hist([data_1, data_2],
|
|
bins=bins,
|
|
stacked=True,
|
|
bottom=[1, 2, 1.5],
|
|
histtype='stepfilled')
|
|
|
|
assert len(patches) == 2
|
|
|
|
polygon, = patches[0]
|
|
xy = [[0, 1], [0, 3], [1, 3], [1, 5], [2, 5], [2, 2.5], [3, 2.5],
|
|
[3, 1.5], [2, 1.5], [2, 2], [1, 2], [1, 1], [0, 1]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
polygon, = patches[1]
|
|
xy = [[0, 3], [0, 4], [1, 4], [1, 6], [2, 6], [2, 3.5], [3, 3.5],
|
|
[3, 2.5], [2, 2.5], [2, 5], [1, 5], [1, 3], [0, 3]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
def test_hist_stacked_step_bottom_geometry():
|
|
bins = [0, 1, 2, 3]
|
|
data_1 = [0, 0, 1, 1, 1, 2]
|
|
data_2 = [0, 1, 2]
|
|
_, _, patches = plt.hist([data_1, data_2],
|
|
bins=bins,
|
|
stacked=True,
|
|
bottom=[1, 2, 1.5],
|
|
histtype='step')
|
|
|
|
assert len(patches) == 2
|
|
|
|
polygon, = patches[0]
|
|
xy = [[0, 1], [0, 3], [1, 3], [1, 5], [2, 5], [2, 2.5], [3, 2.5], [3, 1.5]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
polygon, = patches[1]
|
|
xy = [[0, 3], [0, 4], [1, 4], [1, 6], [2, 6], [2, 3.5], [3, 3.5], [3, 2.5]]
|
|
assert_array_equal(polygon.get_xy(), xy)
|
|
|
|
|
|
@image_comparison(['hist_stacked_bar'])
|
|
def test_hist_stacked_bar():
|
|
# make some data
|
|
d = [[100, 100, 100, 100, 200, 320, 450, 80, 20, 600, 310, 800],
|
|
[20, 23, 50, 11, 100, 420], [120, 120, 120, 140, 140, 150, 180],
|
|
[60, 60, 60, 60, 300, 300, 5, 5, 5, 5, 10, 300],
|
|
[555, 555, 555, 30, 30, 30, 30, 30, 100, 100, 100, 100, 30, 30],
|
|
[30, 30, 30, 30, 400, 400, 400, 400, 400, 400, 400, 400]]
|
|
colors = [(0.5759849696758961, 1.0, 0.0), (0.0, 1.0, 0.350624650815206),
|
|
(0.0, 1.0, 0.6549834156005998), (0.0, 0.6569064625276622, 1.0),
|
|
(0.28302699607823545, 0.0, 1.0), (0.6849123462299822, 0.0, 1.0)]
|
|
labels = ['green', 'orange', ' yellow', 'magenta', 'black']
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist(d, bins=10, histtype='barstacked', align='mid', color=colors,
|
|
label=labels)
|
|
ax.legend(loc='upper right', bbox_to_anchor=(1.0, 1.0), ncol=1)
|
|
|
|
|
|
def test_hist_emptydata():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.hist([[], range(10), range(10)], histtype="step")
|
|
|
|
|
|
def test_hist_labels():
|
|
# test singleton labels OK
|
|
fig, ax = plt.subplots()
|
|
l = ax.hist([0, 1], label=0)
|
|
assert l[2][0].get_label() == '0'
|
|
l = ax.hist([0, 1], label=[0])
|
|
assert l[2][0].get_label() == '0'
|
|
l = ax.hist([0, 1], label=None)
|
|
assert l[2][0].get_label() == '_nolegend_'
|
|
l = ax.hist([0, 1], label='0')
|
|
assert l[2][0].get_label() == '0'
|
|
l = ax.hist([0, 1], label='00')
|
|
assert l[2][0].get_label() == '00'
|
|
|
|
|
|
@image_comparison(['transparent_markers'], remove_text=True)
|
|
def test_transparent_markers():
|
|
np.random.seed(0)
|
|
data = np.random.random(50)
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(data, 'D', mfc='none', markersize=100)
|
|
|
|
|
|
@image_comparison(['rgba_markers'], remove_text=True)
|
|
def test_rgba_markers():
|
|
fig, axs = plt.subplots(ncols=2)
|
|
rcolors = [(1, 0, 0, 1), (1, 0, 0, 0.5)]
|
|
bcolors = [(0, 0, 1, 1), (0, 0, 1, 0.5)]
|
|
alphas = [None, 0.2]
|
|
kw = dict(ms=100, mew=20)
|
|
for i, alpha in enumerate(alphas):
|
|
for j, rcolor in enumerate(rcolors):
|
|
for k, bcolor in enumerate(bcolors):
|
|
axs[i].plot(j+1, k+1, 'o', mfc=bcolor, mec=rcolor,
|
|
alpha=alpha, **kw)
|
|
axs[i].plot(j+1, k+3, 'x', mec=rcolor, alpha=alpha, **kw)
|
|
for ax in axs:
|
|
ax.axis([-1, 4, 0, 5])
|
|
|
|
|
|
@image_comparison(['mollweide_grid'], remove_text=True)
|
|
def test_mollweide_grid():
|
|
# test that both horizontal and vertical gridlines appear on the Mollweide
|
|
# projection
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, projection='mollweide')
|
|
ax.grid()
|
|
|
|
|
|
def test_mollweide_forward_inverse_closure():
|
|
# test that the round-trip Mollweide forward->inverse transformation is an
|
|
# approximate identity
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, projection='mollweide')
|
|
|
|
# set up 1-degree grid in longitude, latitude
|
|
lon = np.linspace(-np.pi, np.pi, 360)
|
|
lat = np.linspace(-np.pi / 2.0, np.pi / 2.0, 180)
|
|
lon, lat = np.meshgrid(lon, lat)
|
|
ll = np.vstack((lon.flatten(), lat.flatten())).T
|
|
|
|
# perform forward transform
|
|
xy = ax.transProjection.transform(ll)
|
|
|
|
# perform inverse transform
|
|
ll2 = ax.transProjection.inverted().transform(xy)
|
|
|
|
# compare
|
|
np.testing.assert_array_almost_equal(ll, ll2, 3)
|
|
|
|
|
|
def test_mollweide_inverse_forward_closure():
|
|
# test that the round-trip Mollweide inverse->forward transformation is an
|
|
# approximate identity
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111, projection='mollweide')
|
|
|
|
# set up grid in x, y
|
|
x = np.linspace(0, 1, 500)
|
|
x, y = np.meshgrid(x, x)
|
|
xy = np.vstack((x.flatten(), y.flatten())).T
|
|
|
|
# perform inverse transform
|
|
ll = ax.transProjection.inverted().transform(xy)
|
|
|
|
# perform forward transform
|
|
xy2 = ax.transProjection.transform(ll)
|
|
|
|
# compare
|
|
np.testing.assert_array_almost_equal(xy, xy2, 3)
|
|
|
|
|
|
@image_comparison(['test_alpha'], remove_text=True)
|
|
def test_alpha():
|
|
np.random.seed(0)
|
|
data = np.random.random(50)
|
|
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
|
|
# alpha=.5 markers, solid line
|
|
ax.plot(data, '-D', color=[1, 0, 0], mfc=[1, 0, 0, .5],
|
|
markersize=20, lw=10)
|
|
|
|
# everything solid by kwarg
|
|
ax.plot(data + 2, '-D', color=[1, 0, 0, .5], mfc=[1, 0, 0, .5],
|
|
markersize=20, lw=10,
|
|
alpha=1)
|
|
|
|
# everything alpha=.5 by kwarg
|
|
ax.plot(data + 4, '-D', color=[1, 0, 0], mfc=[1, 0, 0],
|
|
markersize=20, lw=10,
|
|
alpha=.5)
|
|
|
|
# everything alpha=.5 by colors
|
|
ax.plot(data + 6, '-D', color=[1, 0, 0, .5], mfc=[1, 0, 0, .5],
|
|
markersize=20, lw=10)
|
|
|
|
# alpha=.5 line, solid markers
|
|
ax.plot(data + 8, '-D', color=[1, 0, 0, .5], mfc=[1, 0, 0],
|
|
markersize=20, lw=10)
|
|
|
|
|
|
@image_comparison(['eventplot', 'eventplot'], remove_text=True)
|
|
def test_eventplot():
|
|
np.random.seed(0)
|
|
|
|
data1 = np.random.random([32, 20]).tolist()
|
|
data2 = np.random.random([6, 20]).tolist()
|
|
data = data1 + data2
|
|
num_datasets = len(data)
|
|
|
|
colors1 = [[0, 1, .7]] * len(data1)
|
|
colors2 = [[1, 0, 0],
|
|
[0, 1, 0],
|
|
[0, 0, 1],
|
|
[1, .75, 0],
|
|
[1, 0, 1],
|
|
[0, 1, 1]]
|
|
colors = colors1 + colors2
|
|
|
|
lineoffsets1 = 12 + np.arange(0, len(data1)) * .33
|
|
lineoffsets2 = [-15, -3, 1, 1.5, 6, 10]
|
|
lineoffsets = lineoffsets1.tolist() + lineoffsets2
|
|
|
|
linelengths1 = [.33] * len(data1)
|
|
linelengths2 = [5, 2, 1, 1, 3, 1.5]
|
|
linelengths = linelengths1 + linelengths2
|
|
|
|
fig = plt.figure()
|
|
axobj = fig.add_subplot(111)
|
|
colls = axobj.eventplot(data, colors=colors, lineoffsets=lineoffsets,
|
|
linelengths=linelengths)
|
|
|
|
num_collections = len(colls)
|
|
assert num_collections == num_datasets
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"pos": data, "c": colors, "lo": lineoffsets, "ll": linelengths}
|
|
fig = plt.figure()
|
|
axobj = fig.add_subplot(111)
|
|
colls = axobj.eventplot("pos", colors="c", lineoffsets="lo",
|
|
linelengths="ll", data=data)
|
|
num_collections = len(colls)
|
|
assert num_collections == num_datasets
|
|
|
|
|
|
@image_comparison(['test_eventplot_defaults.png'], remove_text=True)
|
|
def test_eventplot_defaults():
|
|
"""
|
|
test that eventplot produces the correct output given the default params
|
|
(see bug #3728)
|
|
"""
|
|
np.random.seed(0)
|
|
|
|
data1 = np.random.random([32, 20]).tolist()
|
|
data2 = np.random.random([6, 20]).tolist()
|
|
data = data1 + data2
|
|
|
|
fig = plt.figure()
|
|
axobj = fig.add_subplot(111)
|
|
axobj.eventplot(data)
|
|
|
|
|
|
@pytest.mark.parametrize(('colors'), [
|
|
('0.5',), # string color with multiple characters: not OK before #8193 fix
|
|
('tab:orange', 'tab:pink', 'tab:cyan', 'bLacK'), # case-insensitive
|
|
('red', (0, 1, 0), None, (1, 0, 1, 0.5)), # a tricky case mixing types
|
|
])
|
|
def test_eventplot_colors(colors):
|
|
"""Test the *colors* parameter of eventplot. Inspired by issue #8193."""
|
|
data = [[i] for i in range(4)] # 4 successive events of different nature
|
|
|
|
# Build the list of the expected colors
|
|
expected = [c if c is not None else 'C0' for c in colors]
|
|
# Convert the list into an array of RGBA values
|
|
# NB: ['rgbk'] is not a valid argument for to_rgba_array, while 'rgbk' is.
|
|
if len(expected) == 1:
|
|
expected = expected[0]
|
|
expected = np.broadcast_to(mcolors.to_rgba_array(expected), (len(data), 4))
|
|
|
|
fig, ax = plt.subplots()
|
|
if len(colors) == 1: # tuple with a single string (like '0.5' or 'rgbk')
|
|
colors = colors[0]
|
|
collections = ax.eventplot(data, colors=colors)
|
|
|
|
for coll, color in zip(collections, expected):
|
|
assert_allclose(coll.get_color(), color)
|
|
|
|
|
|
@image_comparison(['test_eventplot_problem_kwargs.png'], remove_text=True)
|
|
def test_eventplot_problem_kwargs(recwarn):
|
|
"""
|
|
test that 'singular' versions of LineCollection props raise an
|
|
IgnoredKeywordWarning rather than overriding the 'plural' versions (e.g.
|
|
to prevent 'color' from overriding 'colors', see issue #4297)
|
|
"""
|
|
np.random.seed(0)
|
|
|
|
data1 = np.random.random([20]).tolist()
|
|
data2 = np.random.random([10]).tolist()
|
|
data = [data1, data2]
|
|
|
|
fig = plt.figure()
|
|
axobj = fig.add_subplot(111)
|
|
|
|
axobj.eventplot(data,
|
|
colors=['r', 'b'],
|
|
color=['c', 'm'],
|
|
linewidths=[2, 1],
|
|
linewidth=[1, 2],
|
|
linestyles=['solid', 'dashed'],
|
|
linestyle=['dashdot', 'dotted'])
|
|
|
|
# check that three IgnoredKeywordWarnings were raised
|
|
assert len(recwarn) == 3
|
|
assert all(issubclass(wi.category, MatplotlibDeprecationWarning)
|
|
for wi in recwarn)
|
|
|
|
|
|
def test_empty_eventplot():
|
|
fig, ax = plt.subplots(1, 1)
|
|
ax.eventplot([[]], colors=[(0.0, 0.0, 0.0, 0.0)])
|
|
plt.draw()
|
|
|
|
|
|
@pytest.mark.parametrize('data', [[[]], [[], [0, 1]], [[0, 1], []]])
|
|
@pytest.mark.parametrize(
|
|
'orientation', ['_empty', 'vertical', 'horizontal', None, 'none'])
|
|
def test_eventplot_orientation(data, orientation):
|
|
"""Introduced when fixing issue #6412."""
|
|
opts = {} if orientation == "_empty" else {'orientation': orientation}
|
|
fig, ax = plt.subplots(1, 1)
|
|
with (pytest.warns(MatplotlibDeprecationWarning)
|
|
if orientation in [None, 'none'] else nullcontext()):
|
|
ax.eventplot(data, **opts)
|
|
plt.draw()
|
|
|
|
|
|
@image_comparison(['marker_styles.png'], remove_text=True)
|
|
def test_marker_styles():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
for y, marker in enumerate(sorted(matplotlib.markers.MarkerStyle.markers,
|
|
key=lambda x: str(type(x))+str(x))):
|
|
ax.plot((y % 2)*5 + np.arange(10)*10, np.ones(10)*10*y, linestyle='',
|
|
marker=marker, markersize=10+y/5, label=marker)
|
|
|
|
|
|
@image_comparison(['rc_markerfill.png'])
|
|
def test_markers_fillstyle_rcparams():
|
|
fig, ax = plt.subplots()
|
|
x = np.arange(7)
|
|
for idx, (style, marker) in enumerate(
|
|
[('top', 's'), ('bottom', 'o'), ('none', '^')]):
|
|
matplotlib.rcParams['markers.fillstyle'] = style
|
|
ax.plot(x+idx, marker=marker)
|
|
|
|
|
|
@image_comparison(['vertex_markers.png'], remove_text=True)
|
|
def test_vertex_markers():
|
|
data = list(range(10))
|
|
marker_as_tuple = ((-1, -1), (1, -1), (1, 1), (-1, 1))
|
|
marker_as_list = [(-1, -1), (1, -1), (1, 1), (-1, 1)]
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(data, linestyle='', marker=marker_as_tuple, mfc='k')
|
|
ax.plot(data[::-1], linestyle='', marker=marker_as_list, mfc='b')
|
|
ax.set_xlim([-1, 10])
|
|
ax.set_ylim([-1, 10])
|
|
|
|
|
|
@image_comparison(['vline_hline_zorder', 'errorbar_zorder'],
|
|
tol=0 if platform.machine() == 'x86_64' else 0.02)
|
|
def test_eb_line_zorder():
|
|
x = list(range(10))
|
|
|
|
# First illustrate basic pyplot interface, using defaults where possible.
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.plot(x, lw=10, zorder=5)
|
|
ax.axhline(1, color='red', lw=10, zorder=1)
|
|
ax.axhline(5, color='green', lw=10, zorder=10)
|
|
ax.axvline(7, color='m', lw=10, zorder=7)
|
|
ax.axvline(2, color='k', lw=10, zorder=3)
|
|
|
|
ax.set_title("axvline and axhline zorder test")
|
|
|
|
# Now switch to a more OO interface to exercise more features.
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
x = list(range(10))
|
|
y = np.zeros(10)
|
|
yerr = list(range(10))
|
|
ax.errorbar(x, y, yerr=yerr, zorder=5, lw=5, color='r')
|
|
for j in range(10):
|
|
ax.axhline(j, lw=5, color='k', zorder=j)
|
|
ax.axhline(-j, lw=5, color='k', zorder=j)
|
|
|
|
ax.set_title("errorbar zorder test")
|
|
|
|
|
|
@check_figures_equal()
|
|
def test_axline(fig_test, fig_ref):
|
|
ax = fig_test.subplots()
|
|
ax.set(xlim=(-1, 1), ylim=(-1, 1))
|
|
ax.axline((0, 0), (1, 1))
|
|
ax.axline((0, 0), (1, 0), color='C1')
|
|
ax.axline((0, 0.5), (1, 0.5), color='C2')
|
|
# slopes
|
|
ax.axline((-0.7, -0.5), slope=0, color='C3')
|
|
ax.axline((1, -0.5), slope=-0.5, color='C4')
|
|
ax.axline((-0.5, 1), slope=float('inf'), color='C5')
|
|
|
|
ax = fig_ref.subplots()
|
|
ax.set(xlim=(-1, 1), ylim=(-1, 1))
|
|
ax.plot([-1, 1], [-1, 1])
|
|
ax.axhline(0, color='C1')
|
|
ax.axhline(0.5, color='C2')
|
|
# slopes
|
|
ax.axhline(-0.5, color='C3')
|
|
ax.plot([-1, 1], [0.5, -0.5], color='C4')
|
|
ax.axvline(-0.5, color='C5')
|
|
|
|
|
|
def test_axline_args():
|
|
"""Exactly one of *xy2* and *slope* must be specified."""
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(TypeError):
|
|
ax.axline((0, 0)) # missing second parameter
|
|
with pytest.raises(TypeError):
|
|
ax.axline((0, 0), (1, 1), slope=1) # redundant parameters
|
|
ax.set_xscale('log')
|
|
with pytest.raises(TypeError):
|
|
ax.axline((0, 0), slope=1)
|
|
ax.set_xscale('linear')
|
|
ax.set_yscale('log')
|
|
with pytest.raises(TypeError):
|
|
ax.axline((0, 0), slope=1)
|
|
|
|
|
|
@image_comparison(['vlines_basic', 'vlines_with_nan', 'vlines_masked'],
|
|
extensions=['png'])
|
|
def test_vlines():
|
|
# normal
|
|
x1 = [2, 3, 4, 5, 7]
|
|
y1 = [2, -6, 3, 8, 2]
|
|
fig1, ax1 = plt.subplots()
|
|
ax1.vlines(x1, 0, y1, colors='g', linewidth=5)
|
|
|
|
# GH #7406
|
|
x2 = [2, 3, 4, 5, 6, 7]
|
|
y2 = [2, -6, 3, 8, np.nan, 2]
|
|
fig2, (ax2, ax3, ax4) = plt.subplots(nrows=3, figsize=(4, 8))
|
|
ax2.vlines(x2, 0, y2, colors='g', linewidth=5)
|
|
|
|
x3 = [2, 3, 4, 5, 6, 7]
|
|
y3 = [np.nan, 2, -6, 3, 8, 2]
|
|
ax3.vlines(x3, 0, y3, colors='r', linewidth=3, linestyle='--')
|
|
|
|
x4 = [2, 3, 4, 5, 6, 7]
|
|
y4 = [np.nan, 2, -6, 3, 8, np.nan]
|
|
ax4.vlines(x4, 0, y4, colors='k', linewidth=2)
|
|
|
|
# tweak the x-axis so we can see the lines better
|
|
for ax in [ax1, ax2, ax3, ax4]:
|
|
ax.set_xlim(0, 10)
|
|
|
|
# check that the y-lims are all automatically the same
|
|
assert ax1.get_ylim() == ax2.get_ylim()
|
|
assert ax1.get_ylim() == ax3.get_ylim()
|
|
assert ax1.get_ylim() == ax4.get_ylim()
|
|
|
|
fig3, ax5 = plt.subplots()
|
|
x5 = np.ma.masked_equal([2, 4, 6, 8, 10, 12], 8)
|
|
ymin5 = np.ma.masked_equal([0, 1, -1, 0, 2, 1], 2)
|
|
ymax5 = np.ma.masked_equal([13, 14, 15, 16, 17, 18], 18)
|
|
ax5.vlines(x5, ymin5, ymax5, colors='k', linewidth=2)
|
|
ax5.set_xlim(0, 15)
|
|
|
|
|
|
def test_vlines_default():
|
|
fig, ax = plt.subplots()
|
|
with mpl.rc_context({'lines.color': 'red'}):
|
|
lines = ax.vlines(0.5, 0, 1)
|
|
assert mpl.colors.same_color(lines.get_color(), 'red')
|
|
|
|
|
|
@image_comparison(['hlines_basic', 'hlines_with_nan', 'hlines_masked'],
|
|
extensions=['png'])
|
|
def test_hlines():
|
|
# normal
|
|
y1 = [2, 3, 4, 5, 7]
|
|
x1 = [2, -6, 3, 8, 2]
|
|
fig1, ax1 = plt.subplots()
|
|
ax1.hlines(y1, 0, x1, colors='g', linewidth=5)
|
|
|
|
# GH #7406
|
|
y2 = [2, 3, 4, 5, 6, 7]
|
|
x2 = [2, -6, 3, 8, np.nan, 2]
|
|
fig2, (ax2, ax3, ax4) = plt.subplots(nrows=3, figsize=(4, 8))
|
|
ax2.hlines(y2, 0, x2, colors='g', linewidth=5)
|
|
|
|
y3 = [2, 3, 4, 5, 6, 7]
|
|
x3 = [np.nan, 2, -6, 3, 8, 2]
|
|
ax3.hlines(y3, 0, x3, colors='r', linewidth=3, linestyle='--')
|
|
|
|
y4 = [2, 3, 4, 5, 6, 7]
|
|
x4 = [np.nan, 2, -6, 3, 8, np.nan]
|
|
ax4.hlines(y4, 0, x4, colors='k', linewidth=2)
|
|
|
|
# tweak the y-axis so we can see the lines better
|
|
for ax in [ax1, ax2, ax3, ax4]:
|
|
ax.set_ylim(0, 10)
|
|
|
|
# check that the x-lims are all automatically the same
|
|
assert ax1.get_xlim() == ax2.get_xlim()
|
|
assert ax1.get_xlim() == ax3.get_xlim()
|
|
assert ax1.get_xlim() == ax4.get_xlim()
|
|
|
|
fig3, ax5 = plt.subplots()
|
|
y5 = np.ma.masked_equal([2, 4, 6, 8, 10, 12], 8)
|
|
xmin5 = np.ma.masked_equal([0, 1, -1, 0, 2, 1], 2)
|
|
xmax5 = np.ma.masked_equal([13, 14, 15, 16, 17, 18], 18)
|
|
ax5.hlines(y5, xmin5, xmax5, colors='k', linewidth=2)
|
|
ax5.set_ylim(0, 15)
|
|
|
|
|
|
def test_hlines_default():
|
|
fig, ax = plt.subplots()
|
|
with mpl.rc_context({'lines.color': 'red'}):
|
|
lines = ax.hlines(0.5, 0, 1)
|
|
assert mpl.colors.same_color(lines.get_color(), 'red')
|
|
|
|
|
|
@pytest.mark.parametrize('data', [[1, 2, 3, np.nan, 5],
|
|
np.ma.masked_equal([1, 2, 3, 4, 5], 4)])
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_lines_with_colors(fig_test, fig_ref, data):
|
|
test_colors = ['red', 'green', 'blue', 'purple', 'orange']
|
|
fig_test.add_subplot(2, 1, 1).vlines(data, 0, 1,
|
|
colors=test_colors, linewidth=5)
|
|
fig_test.add_subplot(2, 1, 2).hlines(data, 0, 1,
|
|
colors=test_colors, linewidth=5)
|
|
|
|
expect_xy = [1, 2, 3, 5]
|
|
expect_color = ['red', 'green', 'blue', 'orange']
|
|
fig_ref.add_subplot(2, 1, 1).vlines(expect_xy, 0, 1,
|
|
colors=expect_color, linewidth=5)
|
|
fig_ref.add_subplot(2, 1, 2).hlines(expect_xy, 0, 1,
|
|
colors=expect_color, linewidth=5)
|
|
|
|
|
|
@image_comparison(['step_linestyle', 'step_linestyle'], remove_text=True)
|
|
def test_step_linestyle():
|
|
x = y = np.arange(10)
|
|
|
|
# First illustrate basic pyplot interface, using defaults where possible.
|
|
fig, ax_lst = plt.subplots(2, 2)
|
|
ax_lst = ax_lst.flatten()
|
|
|
|
ln_styles = ['-', '--', '-.', ':']
|
|
|
|
for ax, ls in zip(ax_lst, ln_styles):
|
|
ax.step(x, y, lw=5, linestyle=ls, where='pre')
|
|
ax.step(x, y + 1, lw=5, linestyle=ls, where='mid')
|
|
ax.step(x, y + 2, lw=5, linestyle=ls, where='post')
|
|
ax.set_xlim([-1, 5])
|
|
ax.set_ylim([-1, 7])
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"X": x, "Y0": y, "Y1": y+1, "Y2": y+2}
|
|
fig, ax_lst = plt.subplots(2, 2)
|
|
ax_lst = ax_lst.flatten()
|
|
ln_styles = ['-', '--', '-.', ':']
|
|
for ax, ls in zip(ax_lst, ln_styles):
|
|
ax.step("X", "Y0", lw=5, linestyle=ls, where='pre', data=data)
|
|
ax.step("X", "Y1", lw=5, linestyle=ls, where='mid', data=data)
|
|
ax.step("X", "Y2", lw=5, linestyle=ls, where='post', data=data)
|
|
ax.set_xlim([-1, 5])
|
|
ax.set_ylim([-1, 7])
|
|
|
|
|
|
@image_comparison(['mixed_collection'], remove_text=True)
|
|
def test_mixed_collection():
|
|
# First illustrate basic pyplot interface, using defaults where possible.
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
|
|
c = mpatches.Circle((8, 8), radius=4, facecolor='none', edgecolor='green')
|
|
|
|
# PDF can optimize this one
|
|
p1 = mpl.collections.PatchCollection([c], match_original=True)
|
|
p1.set_offsets([[0, 0], [24, 24]])
|
|
p1.set_linewidths([1, 5])
|
|
|
|
# PDF can't optimize this one, because the alpha of the edge changes
|
|
p2 = mpl.collections.PatchCollection([c], match_original=True)
|
|
p2.set_offsets([[48, 0], [-32, -16]])
|
|
p2.set_linewidths([1, 5])
|
|
p2.set_edgecolors([[0, 0, 0.1, 1.0], [0, 0, 0.1, 0.5]])
|
|
|
|
ax.patch.set_color('0.5')
|
|
ax.add_collection(p1)
|
|
ax.add_collection(p2)
|
|
|
|
ax.set_xlim(0, 16)
|
|
ax.set_ylim(0, 16)
|
|
|
|
|
|
def test_subplot_key_hash():
|
|
ax = plt.subplot(np.int32(5), np.int64(1), 1)
|
|
ax.twinx()
|
|
assert ax.get_subplotspec().get_geometry() == (5, 1, 0, 0)
|
|
|
|
|
|
@image_comparison(
|
|
["specgram_freqs.png", "specgram_freqs_linear.png",
|
|
"specgram_noise.png", "specgram_noise_linear.png"],
|
|
remove_text=True, tol=0.07, style="default")
|
|
def test_specgram():
|
|
"""Test axes.specgram in default (psd) mode."""
|
|
|
|
# use former defaults to match existing baseline image
|
|
matplotlib.rcParams['image.interpolation'] = 'nearest'
|
|
|
|
n = 1000
|
|
Fs = 10.
|
|
|
|
fstims = [[Fs/4, Fs/5, Fs/11], [Fs/4.7, Fs/5.6, Fs/11.9]]
|
|
NFFT_freqs = int(10 * Fs / np.min(fstims))
|
|
x = np.arange(0, n, 1/Fs)
|
|
y_freqs = np.concatenate(
|
|
np.sin(2 * np.pi * np.multiply.outer(fstims, x)).sum(axis=1))
|
|
|
|
NFFT_noise = int(10 * Fs / 11)
|
|
np.random.seed(0)
|
|
y_noise = np.concatenate([np.random.standard_normal(n), np.random.rand(n)])
|
|
|
|
all_sides = ["default", "onesided", "twosided"]
|
|
for y, NFFT in [(y_freqs, NFFT_freqs), (y_noise, NFFT_noise)]:
|
|
noverlap = NFFT // 2
|
|
pad_to = int(2 ** np.ceil(np.log2(NFFT)))
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides)
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides,
|
|
scale="linear", norm=matplotlib.colors.LogNorm())
|
|
|
|
|
|
@image_comparison(
|
|
["specgram_magnitude_freqs.png", "specgram_magnitude_freqs_linear.png",
|
|
"specgram_magnitude_noise.png", "specgram_magnitude_noise_linear.png"],
|
|
remove_text=True, tol=0.07, style="default")
|
|
def test_specgram_magnitude():
|
|
"""Test axes.specgram in magnitude mode."""
|
|
|
|
# use former defaults to match existing baseline image
|
|
matplotlib.rcParams['image.interpolation'] = 'nearest'
|
|
|
|
n = 1000
|
|
Fs = 10.
|
|
|
|
fstims = [[Fs/4, Fs/5, Fs/11], [Fs/4.7, Fs/5.6, Fs/11.9]]
|
|
NFFT_freqs = int(100 * Fs / np.min(fstims))
|
|
x = np.arange(0, n, 1/Fs)
|
|
y = np.sin(2 * np.pi * np.multiply.outer(fstims, x)).sum(axis=1)
|
|
y[:, -1] = 1
|
|
y_freqs = np.hstack(y)
|
|
|
|
NFFT_noise = int(10 * Fs / 11)
|
|
np.random.seed(0)
|
|
y_noise = np.concatenate([np.random.standard_normal(n), np.random.rand(n)])
|
|
|
|
all_sides = ["default", "onesided", "twosided"]
|
|
for y, NFFT in [(y_freqs, NFFT_freqs), (y_noise, NFFT_noise)]:
|
|
noverlap = NFFT // 2
|
|
pad_to = int(2 ** np.ceil(np.log2(NFFT)))
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides, mode="magnitude")
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides, mode="magnitude",
|
|
scale="linear", norm=matplotlib.colors.LogNorm())
|
|
|
|
|
|
@image_comparison(
|
|
["specgram_angle_freqs.png", "specgram_phase_freqs.png",
|
|
"specgram_angle_noise.png", "specgram_phase_noise.png"],
|
|
remove_text=True, tol=0.07, style="default")
|
|
def test_specgram_angle():
|
|
"""Test axes.specgram in angle and phase modes."""
|
|
|
|
# use former defaults to match existing baseline image
|
|
matplotlib.rcParams['image.interpolation'] = 'nearest'
|
|
|
|
n = 1000
|
|
Fs = 10.
|
|
|
|
fstims = [[Fs/4, Fs/5, Fs/11], [Fs/4.7, Fs/5.6, Fs/11.9]]
|
|
NFFT_freqs = int(10 * Fs / np.min(fstims))
|
|
x = np.arange(0, n, 1/Fs)
|
|
y = np.sin(2 * np.pi * np.multiply.outer(fstims, x)).sum(axis=1)
|
|
y[:, -1] = 1
|
|
y_freqs = np.hstack(y)
|
|
|
|
NFFT_noise = int(10 * Fs / 11)
|
|
np.random.seed(0)
|
|
y_noise = np.concatenate([np.random.standard_normal(n), np.random.rand(n)])
|
|
|
|
all_sides = ["default", "onesided", "twosided"]
|
|
for y, NFFT in [(y_freqs, NFFT_freqs), (y_noise, NFFT_noise)]:
|
|
noverlap = NFFT // 2
|
|
pad_to = int(2 ** np.ceil(np.log2(NFFT)))
|
|
for mode in ["angle", "phase"]:
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides, mode=mode)
|
|
with pytest.raises(ValueError):
|
|
ax.specgram(y, NFFT=NFFT, Fs=Fs, noverlap=noverlap,
|
|
pad_to=pad_to, sides=sides, mode=mode,
|
|
scale="dB")
|
|
|
|
|
|
def test_specgram_fs_none():
|
|
"""Test axes.specgram when Fs is None, should not throw error."""
|
|
spec, freqs, t, im = plt.specgram(np.ones(300), Fs=None, scale='linear')
|
|
xmin, xmax, freq0, freq1 = im.get_extent()
|
|
assert xmin == 32 and xmax == 96
|
|
|
|
|
|
@image_comparison(
|
|
["psd_freqs.png", "csd_freqs.png", "psd_noise.png", "csd_noise.png"],
|
|
remove_text=True, tol=0.002)
|
|
def test_psd_csd():
|
|
n = 10000
|
|
Fs = 100.
|
|
|
|
fstims = [[Fs/4, Fs/5, Fs/11], [Fs/4.7, Fs/5.6, Fs/11.9]]
|
|
NFFT_freqs = int(1000 * Fs / np.min(fstims))
|
|
x = np.arange(0, n, 1/Fs)
|
|
ys_freqs = np.sin(2 * np.pi * np.multiply.outer(fstims, x)).sum(axis=1)
|
|
|
|
NFFT_noise = int(1000 * Fs / 11)
|
|
np.random.seed(0)
|
|
ys_noise = [np.random.standard_normal(n), np.random.rand(n)]
|
|
|
|
all_kwargs = [{"sides": "default"},
|
|
{"sides": "onesided", "return_line": False},
|
|
{"sides": "twosided", "return_line": True}]
|
|
for ys, NFFT in [(ys_freqs, NFFT_freqs), (ys_noise, NFFT_noise)]:
|
|
noverlap = NFFT // 2
|
|
pad_to = int(2 ** np.ceil(np.log2(NFFT)))
|
|
for ax, kwargs in zip(plt.figure().subplots(3), all_kwargs):
|
|
ret = ax.psd(np.concatenate(ys), NFFT=NFFT, Fs=Fs,
|
|
noverlap=noverlap, pad_to=pad_to, **kwargs)
|
|
assert len(ret) == 2 + kwargs.get("return_line", False)
|
|
ax.set(xlabel="", ylabel="")
|
|
for ax, kwargs in zip(plt.figure().subplots(3), all_kwargs):
|
|
ret = ax.csd(*ys, NFFT=NFFT, Fs=Fs,
|
|
noverlap=noverlap, pad_to=pad_to, **kwargs)
|
|
assert len(ret) == 2 + kwargs.get("return_line", False)
|
|
ax.set(xlabel="", ylabel="")
|
|
|
|
|
|
@image_comparison(
|
|
["magnitude_spectrum_freqs_linear.png",
|
|
"magnitude_spectrum_freqs_dB.png",
|
|
"angle_spectrum_freqs.png",
|
|
"phase_spectrum_freqs.png",
|
|
"magnitude_spectrum_noise_linear.png",
|
|
"magnitude_spectrum_noise_dB.png",
|
|
"angle_spectrum_noise.png",
|
|
"phase_spectrum_noise.png"],
|
|
remove_text=True)
|
|
def test_spectrum():
|
|
n = 10000
|
|
Fs = 100.
|
|
|
|
fstims1 = [Fs/4, Fs/5, Fs/11]
|
|
NFFT = int(1000 * Fs / min(fstims1))
|
|
pad_to = int(2 ** np.ceil(np.log2(NFFT)))
|
|
|
|
x = np.arange(0, n, 1/Fs)
|
|
y_freqs = ((np.sin(2 * np.pi * np.outer(x, fstims1)) * 10**np.arange(3))
|
|
.sum(axis=1))
|
|
np.random.seed(0)
|
|
y_noise = np.hstack([np.random.standard_normal(n), np.random.rand(n)]) - .5
|
|
|
|
all_sides = ["default", "onesided", "twosided"]
|
|
kwargs = {"Fs": Fs, "pad_to": pad_to}
|
|
for y in [y_freqs, y_noise]:
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
spec, freqs, line = ax.magnitude_spectrum(y, sides=sides, **kwargs)
|
|
ax.set(xlabel="", ylabel="")
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
spec, freqs, line = ax.magnitude_spectrum(y, sides=sides, **kwargs,
|
|
scale="dB")
|
|
ax.set(xlabel="", ylabel="")
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
spec, freqs, line = ax.angle_spectrum(y, sides=sides, **kwargs)
|
|
ax.set(xlabel="", ylabel="")
|
|
for ax, sides in zip(plt.figure().subplots(3), all_sides):
|
|
spec, freqs, line = ax.phase_spectrum(y, sides=sides, **kwargs)
|
|
ax.set(xlabel="", ylabel="")
|
|
|
|
|
|
@image_comparison(['twin_spines.png'], remove_text=True)
|
|
def test_twin_spines():
|
|
|
|
def make_patch_spines_invisible(ax):
|
|
ax.set_frame_on(True)
|
|
ax.patch.set_visible(False)
|
|
for sp in ax.spines.values():
|
|
sp.set_visible(False)
|
|
|
|
fig = plt.figure(figsize=(4, 3))
|
|
fig.subplots_adjust(right=0.75)
|
|
|
|
host = fig.add_subplot(111)
|
|
par1 = host.twinx()
|
|
par2 = host.twinx()
|
|
|
|
# Offset the right spine of par2. The ticks and label have already been
|
|
# placed on the right by twinx above.
|
|
par2.spines["right"].set_position(("axes", 1.2))
|
|
# Having been created by twinx, par2 has its frame off, so the line of
|
|
# its detached spine is invisible. First, activate the frame but make
|
|
# the patch and spines invisible.
|
|
make_patch_spines_invisible(par2)
|
|
# Second, show the right spine.
|
|
par2.spines["right"].set_visible(True)
|
|
|
|
p1, = host.plot([0, 1, 2], [0, 1, 2], "b-")
|
|
p2, = par1.plot([0, 1, 2], [0, 3, 2], "r-")
|
|
p3, = par2.plot([0, 1, 2], [50, 30, 15], "g-")
|
|
|
|
host.set_xlim(0, 2)
|
|
host.set_ylim(0, 2)
|
|
par1.set_ylim(0, 4)
|
|
par2.set_ylim(1, 65)
|
|
|
|
host.yaxis.label.set_color(p1.get_color())
|
|
par1.yaxis.label.set_color(p2.get_color())
|
|
par2.yaxis.label.set_color(p3.get_color())
|
|
|
|
tkw = dict(size=4, width=1.5)
|
|
host.tick_params(axis='y', colors=p1.get_color(), **tkw)
|
|
par1.tick_params(axis='y', colors=p2.get_color(), **tkw)
|
|
par2.tick_params(axis='y', colors=p3.get_color(), **tkw)
|
|
host.tick_params(axis='x', **tkw)
|
|
|
|
|
|
@image_comparison(['twin_spines_on_top.png', 'twin_spines_on_top.png'],
|
|
remove_text=True)
|
|
def test_twin_spines_on_top():
|
|
matplotlib.rcParams['axes.linewidth'] = 48.0
|
|
matplotlib.rcParams['lines.linewidth'] = 48.0
|
|
|
|
fig = plt.figure()
|
|
ax1 = fig.add_subplot(1, 1, 1)
|
|
|
|
data = np.array([[1000, 1100, 1200, 1250],
|
|
[310, 301, 360, 400]])
|
|
|
|
ax2 = ax1.twinx()
|
|
|
|
ax1.plot(data[0], data[1]/1E3, color='#BEAED4')
|
|
ax1.fill_between(data[0], data[1]/1E3, color='#BEAED4', alpha=.8)
|
|
|
|
ax2.plot(data[0], data[1]/1E3, color='#7FC97F')
|
|
ax2.fill_between(data[0], data[1]/1E3, color='#7FC97F', alpha=.5)
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"i": data[0], "j": data[1]/1E3}
|
|
fig = plt.figure()
|
|
ax1 = fig.add_subplot(1, 1, 1)
|
|
ax2 = ax1.twinx()
|
|
ax1.plot("i", "j", color='#BEAED4', data=data)
|
|
ax1.fill_between("i", "j", color='#BEAED4', alpha=.8, data=data)
|
|
ax2.plot("i", "j", color='#7FC97F', data=data)
|
|
ax2.fill_between("i", "j", color='#7FC97F', alpha=.5, data=data)
|
|
|
|
|
|
@pytest.mark.parametrize("grid_which, major_visible, minor_visible", [
|
|
("both", True, True),
|
|
("major", True, False),
|
|
("minor", False, True),
|
|
])
|
|
def test_rcparam_grid_minor(grid_which, major_visible, minor_visible):
|
|
mpl.rcParams.update({"axes.grid": True, "axes.grid.which": grid_which})
|
|
fig, ax = plt.subplots()
|
|
fig.canvas.draw()
|
|
assert all(tick.gridline.get_visible() == major_visible
|
|
for tick in ax.xaxis.majorTicks)
|
|
assert all(tick.gridline.get_visible() == minor_visible
|
|
for tick in ax.xaxis.minorTicks)
|
|
|
|
|
|
def test_grid():
|
|
fig, ax = plt.subplots()
|
|
ax.grid()
|
|
fig.canvas.draw()
|
|
assert ax.xaxis.majorTicks[0].gridline.get_visible()
|
|
ax.grid(visible=False)
|
|
fig.canvas.draw()
|
|
assert not ax.xaxis.majorTicks[0].gridline.get_visible()
|
|
ax.grid(visible=True)
|
|
fig.canvas.draw()
|
|
assert ax.xaxis.majorTicks[0].gridline.get_visible()
|
|
ax.grid()
|
|
fig.canvas.draw()
|
|
assert not ax.xaxis.majorTicks[0].gridline.get_visible()
|
|
|
|
|
|
def test_vline_limit():
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.axvline(0.5)
|
|
ax.plot([-0.1, 0, 0.2, 0.1])
|
|
(ymin, ymax) = ax.get_ylim()
|
|
assert_allclose(ax.get_ylim(), (-.1, .2))
|
|
|
|
|
|
def test_empty_shared_subplots():
|
|
# empty plots with shared axes inherit limits from populated plots
|
|
fig, axs = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True)
|
|
axs[0].plot([1, 2, 3], [2, 4, 6])
|
|
x0, x1 = axs[1].get_xlim()
|
|
y0, y1 = axs[1].get_ylim()
|
|
assert x0 <= 1
|
|
assert x1 >= 3
|
|
assert y0 <= 2
|
|
assert y1 >= 6
|
|
|
|
|
|
def test_shared_with_aspect_1():
|
|
# allow sharing one axis
|
|
for adjustable in ['box', 'datalim']:
|
|
fig, axs = plt.subplots(nrows=2, sharex=True)
|
|
axs[0].set_aspect(2, adjustable=adjustable, share=True)
|
|
assert axs[1].get_aspect() == 2
|
|
assert axs[1].get_adjustable() == adjustable
|
|
|
|
fig, axs = plt.subplots(nrows=2, sharex=True)
|
|
axs[0].set_aspect(2, adjustable=adjustable)
|
|
assert axs[1].get_aspect() == 'auto'
|
|
|
|
|
|
def test_shared_with_aspect_2():
|
|
# Share 2 axes only with 'box':
|
|
fig, axs = plt.subplots(nrows=2, sharex=True, sharey=True)
|
|
axs[0].set_aspect(2, share=True)
|
|
axs[0].plot([1, 2], [3, 4])
|
|
axs[1].plot([3, 4], [1, 2])
|
|
plt.draw() # Trigger apply_aspect().
|
|
assert axs[0].get_xlim() == axs[1].get_xlim()
|
|
assert axs[0].get_ylim() == axs[1].get_ylim()
|
|
|
|
|
|
def test_shared_with_aspect_3():
|
|
# Different aspect ratios:
|
|
for adjustable in ['box', 'datalim']:
|
|
fig, axs = plt.subplots(nrows=2, sharey=True)
|
|
axs[0].set_aspect(2, adjustable=adjustable)
|
|
axs[1].set_aspect(0.5, adjustable=adjustable)
|
|
axs[0].plot([1, 2], [3, 4])
|
|
axs[1].plot([3, 4], [1, 2])
|
|
plt.draw() # Trigger apply_aspect().
|
|
assert axs[0].get_xlim() != axs[1].get_xlim()
|
|
assert axs[0].get_ylim() == axs[1].get_ylim()
|
|
fig_aspect = fig.bbox_inches.height / fig.bbox_inches.width
|
|
for ax in axs:
|
|
p = ax.get_position()
|
|
box_aspect = p.height / p.width
|
|
lim_aspect = ax.viewLim.height / ax.viewLim.width
|
|
expected = fig_aspect * box_aspect / lim_aspect
|
|
assert round(expected, 4) == round(ax.get_aspect(), 4)
|
|
|
|
|
|
@pytest.mark.parametrize('twin', ('x', 'y'))
|
|
def test_twin_with_aspect(twin):
|
|
fig, ax = plt.subplots()
|
|
# test twinx or twiny
|
|
ax_twin = getattr(ax, 'twin{}'.format(twin))()
|
|
ax.set_aspect(5)
|
|
ax_twin.set_aspect(2)
|
|
assert_array_equal(ax.bbox.extents,
|
|
ax_twin.bbox.extents)
|
|
|
|
|
|
def test_relim_visible_only():
|
|
x1 = (0., 10.)
|
|
y1 = (0., 10.)
|
|
x2 = (-10., 20.)
|
|
y2 = (-10., 30.)
|
|
|
|
fig = matplotlib.figure.Figure()
|
|
ax = fig.add_subplot(111)
|
|
ax.plot(x1, y1)
|
|
assert ax.get_xlim() == x1
|
|
assert ax.get_ylim() == y1
|
|
l = ax.plot(x2, y2)
|
|
assert ax.get_xlim() == x2
|
|
assert ax.get_ylim() == y2
|
|
l[0].set_visible(False)
|
|
assert ax.get_xlim() == x2
|
|
assert ax.get_ylim() == y2
|
|
|
|
ax.relim(visible_only=True)
|
|
ax.autoscale_view()
|
|
|
|
assert ax.get_xlim() == x1
|
|
assert ax.get_ylim() == y1
|
|
|
|
|
|
def test_text_labelsize():
|
|
"""
|
|
tests for issue #1172
|
|
"""
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.tick_params(labelsize='large')
|
|
ax.tick_params(direction='out')
|
|
|
|
|
|
@image_comparison(['pie_default.png'])
|
|
def test_pie_default():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
fig1, ax1 = plt.subplots(figsize=(8, 6))
|
|
ax1.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90)
|
|
|
|
|
|
@image_comparison(['pie_linewidth_0', 'pie_linewidth_0', 'pie_linewidth_0'],
|
|
extensions=['png'])
|
|
def test_pie_linewidth_0():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0})
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
# Reuse testcase from above for a labeled data test
|
|
data = {"l": labels, "s": sizes, "c": colors, "ex": explode}
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
ax.pie("s", explode="ex", labels="l", colors="c",
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0}, data=data)
|
|
ax.axis('equal')
|
|
|
|
# And again to test the pyplot functions which should also be able to be
|
|
# called with a data kwarg
|
|
plt.figure()
|
|
plt.pie("s", explode="ex", labels="l", colors="c",
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0}, data=data)
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_center_radius.png'])
|
|
def test_pie_center_radius():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0}, center=(1, 2), radius=1.5)
|
|
|
|
plt.annotate("Center point", xy=(1, 2), xytext=(1, 1.5),
|
|
arrowprops=dict(arrowstyle="->",
|
|
connectionstyle="arc3"))
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_linewidth_2.png'])
|
|
def test_pie_linewidth_2():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 2})
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_ccw_true.png'])
|
|
def test_pie_ccw_true():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
counterclock=True)
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_frame_grid.png'])
|
|
def test_pie_frame_grid():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
# only "explode" the 2nd slice (i.e. 'Hogs')
|
|
explode = (0, 0.1, 0, 0)
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0},
|
|
frame=True, center=(2, 2))
|
|
|
|
plt.pie(sizes[::-1], explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0},
|
|
frame=True, center=(5, 2))
|
|
|
|
plt.pie(sizes, explode=explode[::-1], labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
wedgeprops={'linewidth': 0},
|
|
frame=True, center=(3, 5))
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_rotatelabels_true.png'])
|
|
def test_pie_rotatelabels_true():
|
|
# The slices will be ordered and plotted counter-clockwise.
|
|
labels = 'Hogwarts', 'Frogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90,
|
|
rotatelabels=True)
|
|
# Set aspect ratio to be equal so that pie is drawn as a circle.
|
|
plt.axis('equal')
|
|
|
|
|
|
@image_comparison(['pie_no_label.png'])
|
|
def test_pie_nolabel_but_legend():
|
|
labels = 'Frogs', 'Hogs', 'Dogs', 'Logs'
|
|
sizes = [15, 30, 45, 10]
|
|
colors = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']
|
|
explode = (0, 0.1, 0, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
|
|
plt.pie(sizes, explode=explode, labels=labels, colors=colors,
|
|
autopct='%1.1f%%', shadow=True, startangle=90, labeldistance=None,
|
|
rotatelabels=True)
|
|
plt.axis('equal')
|
|
plt.ylim(-1.2, 1.2)
|
|
plt.legend()
|
|
|
|
|
|
def test_pie_textprops():
|
|
data = [23, 34, 45]
|
|
labels = ["Long name 1", "Long name 2", "Long name 3"]
|
|
|
|
textprops = dict(horizontalalignment="center",
|
|
verticalalignment="top",
|
|
rotation=90,
|
|
rotation_mode="anchor",
|
|
size=12, color="red")
|
|
|
|
_, texts, autopct = plt.gca().pie(data, labels=labels, autopct='%.2f',
|
|
textprops=textprops)
|
|
for labels in [texts, autopct]:
|
|
for tx in labels:
|
|
assert tx.get_ha() == textprops["horizontalalignment"]
|
|
assert tx.get_va() == textprops["verticalalignment"]
|
|
assert tx.get_rotation() == textprops["rotation"]
|
|
assert tx.get_rotation_mode() == textprops["rotation_mode"]
|
|
assert tx.get_size() == textprops["size"]
|
|
assert tx.get_color() == textprops["color"]
|
|
|
|
|
|
def test_pie_get_negative_values():
|
|
# Test the ValueError raised when feeding negative values into axes.pie
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.pie([5, 5, -3], explode=[0, .1, .2])
|
|
|
|
|
|
def test_normalize_kwarg_warn_pie():
|
|
fig, ax = plt.subplots()
|
|
with pytest.warns(MatplotlibDeprecationWarning):
|
|
ax.pie(x=[0], normalize=None)
|
|
|
|
|
|
def test_normalize_kwarg_pie():
|
|
fig, ax = plt.subplots()
|
|
x = [0.3, 0.3, 0.1]
|
|
t1 = ax.pie(x=x, normalize=True)
|
|
assert abs(t1[0][-1].theta2 - 360.) < 1e-3
|
|
t2 = ax.pie(x=x, normalize=False)
|
|
assert abs(t2[0][-1].theta2 - 360.) > 1e-3
|
|
|
|
|
|
@image_comparison(['set_get_ticklabels.png'])
|
|
def test_set_get_ticklabels():
|
|
# test issue 2246
|
|
fig, ax = plt.subplots(2)
|
|
ha = ['normal', 'set_x/yticklabels']
|
|
|
|
ax[0].plot(np.arange(10))
|
|
ax[0].set_title(ha[0])
|
|
|
|
ax[1].plot(np.arange(10))
|
|
ax[1].set_title(ha[1])
|
|
|
|
# set ticklabel to 1 plot in normal way
|
|
ax[0].set_xticks(range(10))
|
|
ax[0].set_yticks(range(10))
|
|
ax[0].set_xticklabels(['a', 'b', 'c', 'd'] + 6 * [''])
|
|
ax[0].set_yticklabels(['11', '12', '13', '14'] + 6 * [''])
|
|
|
|
# set ticklabel to the other plot, expect the 2 plots have same label
|
|
# setting pass get_ticklabels return value as ticklabels argument
|
|
ax[1].set_xticks(ax[0].get_xticks())
|
|
ax[1].set_yticks(ax[0].get_yticks())
|
|
ax[1].set_xticklabels(ax[0].get_xticklabels())
|
|
ax[1].set_yticklabels(ax[0].get_yticklabels())
|
|
|
|
|
|
def test_subsampled_ticklabels():
|
|
# test issue 11937
|
|
fig, ax = plt.subplots()
|
|
ax.plot(np.arange(10))
|
|
ax.xaxis.set_ticks(np.arange(10) + 0.1)
|
|
ax.locator_params(nbins=5)
|
|
ax.xaxis.set_ticklabels([c for c in "bcdefghijk"])
|
|
plt.draw()
|
|
labels = [t.get_text() for t in ax.xaxis.get_ticklabels()]
|
|
assert labels == ['b', 'd', 'f', 'h', 'j']
|
|
|
|
|
|
def test_mismatched_ticklabels():
|
|
fig, ax = plt.subplots()
|
|
ax.plot(np.arange(10))
|
|
ax.xaxis.set_ticks([1.5, 2.5])
|
|
with pytest.raises(ValueError):
|
|
ax.xaxis.set_ticklabels(['a', 'b', 'c'])
|
|
|
|
|
|
def test_empty_ticks_fixed_loc():
|
|
# Smoke test that [] can be used to unset all tick labels
|
|
fig, ax = plt.subplots()
|
|
ax.bar([1, 2], [1, 2])
|
|
ax.set_xticks([1, 2])
|
|
ax.set_xticklabels([])
|
|
|
|
|
|
@image_comparison(['retain_tick_visibility.png'])
|
|
def test_retain_tick_visibility():
|
|
fig, ax = plt.subplots()
|
|
plt.plot([0, 1, 2], [0, -1, 4])
|
|
plt.setp(ax.get_yticklabels(), visible=False)
|
|
ax.tick_params(axis="y", which="both", length=0)
|
|
|
|
|
|
def test_tick_label_update():
|
|
# test issue 9397
|
|
|
|
fig, ax = plt.subplots()
|
|
|
|
# Set up a dummy formatter
|
|
def formatter_func(x, pos):
|
|
return "unit value" if x == 1 else ""
|
|
ax.xaxis.set_major_formatter(plt.FuncFormatter(formatter_func))
|
|
|
|
# Force some of the x-axis ticks to be outside of the drawn range
|
|
ax.set_xticks([-1, 0, 1, 2, 3])
|
|
ax.set_xlim(-0.5, 2.5)
|
|
|
|
ax.figure.canvas.draw()
|
|
tick_texts = [tick.get_text() for tick in ax.xaxis.get_ticklabels()]
|
|
assert tick_texts == ["", "", "unit value", "", ""]
|
|
|
|
|
|
@image_comparison(['o_marker_path_snap.png'], savefig_kwarg={'dpi': 72})
|
|
def test_o_marker_path_snap():
|
|
fig, ax = plt.subplots()
|
|
ax.margins(.1)
|
|
for ms in range(1, 15):
|
|
ax.plot([1, 2, ], np.ones(2) + ms, 'o', ms=ms)
|
|
|
|
for ms in np.linspace(1, 10, 25):
|
|
ax.plot([3, 4, ], np.ones(2) + ms, 'o', ms=ms)
|
|
|
|
|
|
def test_margins():
|
|
# test all ways margins can be called
|
|
data = [1, 10]
|
|
xmin = 0.0
|
|
xmax = len(data) - 1.0
|
|
ymin = min(data)
|
|
ymax = max(data)
|
|
|
|
fig1, ax1 = plt.subplots(1, 1)
|
|
ax1.plot(data)
|
|
ax1.margins(1)
|
|
assert ax1.margins() == (1, 1)
|
|
assert ax1.get_xlim() == (xmin - (xmax - xmin) * 1,
|
|
xmax + (xmax - xmin) * 1)
|
|
assert ax1.get_ylim() == (ymin - (ymax - ymin) * 1,
|
|
ymax + (ymax - ymin) * 1)
|
|
|
|
fig2, ax2 = plt.subplots(1, 1)
|
|
ax2.plot(data)
|
|
ax2.margins(0.5, 2)
|
|
assert ax2.margins() == (0.5, 2)
|
|
assert ax2.get_xlim() == (xmin - (xmax - xmin) * 0.5,
|
|
xmax + (xmax - xmin) * 0.5)
|
|
assert ax2.get_ylim() == (ymin - (ymax - ymin) * 2,
|
|
ymax + (ymax - ymin) * 2)
|
|
|
|
fig3, ax3 = plt.subplots(1, 1)
|
|
ax3.plot(data)
|
|
ax3.margins(x=-0.2, y=0.5)
|
|
assert ax3.margins() == (-0.2, 0.5)
|
|
assert ax3.get_xlim() == (xmin - (xmax - xmin) * -0.2,
|
|
xmax + (xmax - xmin) * -0.2)
|
|
assert ax3.get_ylim() == (ymin - (ymax - ymin) * 0.5,
|
|
ymax + (ymax - ymin) * 0.5)
|
|
|
|
|
|
def test_set_margin_updates_limits():
|
|
mpl.style.use("default")
|
|
fig, ax = plt.subplots()
|
|
ax.plot([1, 2], [1, 2])
|
|
ax.set(xscale="log", xmargin=0)
|
|
assert ax.get_xlim() == (1, 2)
|
|
|
|
|
|
def test_length_one_hist():
|
|
fig, ax = plt.subplots()
|
|
ax.hist(1)
|
|
ax.hist([1])
|
|
|
|
|
|
def test_pathological_hexbin():
|
|
# issue #2863
|
|
mylist = [10] * 100
|
|
fig, ax = plt.subplots(1, 1)
|
|
ax.hexbin(mylist, mylist)
|
|
fig.savefig(io.BytesIO()) # Check that no warning is emitted.
|
|
|
|
|
|
def test_color_None():
|
|
# issue 3855
|
|
fig, ax = plt.subplots()
|
|
ax.plot([1, 2], [1, 2], color=None)
|
|
|
|
|
|
def test_color_alias():
|
|
# issues 4157 and 4162
|
|
fig, ax = plt.subplots()
|
|
line = ax.plot([0, 1], c='lime')[0]
|
|
assert 'lime' == line.get_color()
|
|
|
|
|
|
def test_numerical_hist_label():
|
|
fig, ax = plt.subplots()
|
|
ax.hist([range(15)] * 5, label=range(5))
|
|
ax.legend()
|
|
|
|
|
|
def test_unicode_hist_label():
|
|
fig, ax = plt.subplots()
|
|
a = (b'\xe5\xbe\x88\xe6\xbc\x82\xe4\xba\xae, ' +
|
|
b'r\xc3\xb6m\xc3\xa4n ch\xc3\xa4r\xc3\xa1ct\xc3\xa8rs')
|
|
b = b'\xd7\xa9\xd7\x9c\xd7\x95\xd7\x9d'
|
|
labels = [a.decode('utf-8'),
|
|
'hi aardvark',
|
|
b.decode('utf-8'),
|
|
]
|
|
|
|
ax.hist([range(15)] * 3, label=labels)
|
|
ax.legend()
|
|
|
|
|
|
def test_move_offsetlabel():
|
|
data = np.random.random(10) * 1e-22
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.plot(data)
|
|
fig.canvas.draw()
|
|
before = ax.yaxis.offsetText.get_position()
|
|
assert ax.yaxis.offsetText.get_horizontalalignment() == 'left'
|
|
ax.yaxis.tick_right()
|
|
fig.canvas.draw()
|
|
after = ax.yaxis.offsetText.get_position()
|
|
assert after[0] > before[0] and after[1] == before[1]
|
|
assert ax.yaxis.offsetText.get_horizontalalignment() == 'right'
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.plot(data)
|
|
fig.canvas.draw()
|
|
before = ax.xaxis.offsetText.get_position()
|
|
assert ax.xaxis.offsetText.get_verticalalignment() == 'top'
|
|
ax.xaxis.tick_top()
|
|
fig.canvas.draw()
|
|
after = ax.xaxis.offsetText.get_position()
|
|
assert after[0] == before[0] and after[1] > before[1]
|
|
assert ax.xaxis.offsetText.get_verticalalignment() == 'bottom'
|
|
|
|
|
|
@image_comparison(['rc_spines.png'], savefig_kwarg={'dpi': 40})
|
|
def test_rc_spines():
|
|
rc_dict = {
|
|
'axes.spines.left': False,
|
|
'axes.spines.right': False,
|
|
'axes.spines.top': False,
|
|
'axes.spines.bottom': False}
|
|
with matplotlib.rc_context(rc_dict):
|
|
fig, ax = plt.subplots()
|
|
|
|
|
|
@image_comparison(['rc_grid.png'], savefig_kwarg={'dpi': 40})
|
|
def test_rc_grid():
|
|
fig = plt.figure()
|
|
rc_dict0 = {
|
|
'axes.grid': True,
|
|
'axes.grid.axis': 'both'
|
|
}
|
|
rc_dict1 = {
|
|
'axes.grid': True,
|
|
'axes.grid.axis': 'x'
|
|
}
|
|
rc_dict2 = {
|
|
'axes.grid': True,
|
|
'axes.grid.axis': 'y'
|
|
}
|
|
dict_list = [rc_dict0, rc_dict1, rc_dict2]
|
|
|
|
for i, rc_dict in enumerate(dict_list, 1):
|
|
with matplotlib.rc_context(rc_dict):
|
|
fig.add_subplot(3, 1, i)
|
|
|
|
|
|
def test_rc_tick():
|
|
d = {'xtick.bottom': False, 'xtick.top': True,
|
|
'ytick.left': True, 'ytick.right': False}
|
|
with plt.rc_context(rc=d):
|
|
fig = plt.figure()
|
|
ax1 = fig.add_subplot(1, 1, 1)
|
|
xax = ax1.xaxis
|
|
yax = ax1.yaxis
|
|
# tick1On bottom/left
|
|
assert not xax._major_tick_kw['tick1On']
|
|
assert xax._major_tick_kw['tick2On']
|
|
assert not xax._minor_tick_kw['tick1On']
|
|
assert xax._minor_tick_kw['tick2On']
|
|
|
|
assert yax._major_tick_kw['tick1On']
|
|
assert not yax._major_tick_kw['tick2On']
|
|
assert yax._minor_tick_kw['tick1On']
|
|
assert not yax._minor_tick_kw['tick2On']
|
|
|
|
|
|
def test_rc_major_minor_tick():
|
|
d = {'xtick.top': True, 'ytick.right': True, # Enable all ticks
|
|
'xtick.bottom': True, 'ytick.left': True,
|
|
# Selectively disable
|
|
'xtick.minor.bottom': False, 'xtick.major.bottom': False,
|
|
'ytick.major.left': False, 'ytick.minor.left': False}
|
|
with plt.rc_context(rc=d):
|
|
fig = plt.figure()
|
|
ax1 = fig.add_subplot(1, 1, 1)
|
|
xax = ax1.xaxis
|
|
yax = ax1.yaxis
|
|
# tick1On bottom/left
|
|
assert not xax._major_tick_kw['tick1On']
|
|
assert xax._major_tick_kw['tick2On']
|
|
assert not xax._minor_tick_kw['tick1On']
|
|
assert xax._minor_tick_kw['tick2On']
|
|
|
|
assert not yax._major_tick_kw['tick1On']
|
|
assert yax._major_tick_kw['tick2On']
|
|
assert not yax._minor_tick_kw['tick1On']
|
|
assert yax._minor_tick_kw['tick2On']
|
|
|
|
|
|
def test_square_plot():
|
|
x = np.arange(4)
|
|
y = np.array([1., 3., 5., 7.])
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, y, 'mo')
|
|
ax.axis('square')
|
|
xlim, ylim = ax.get_xlim(), ax.get_ylim()
|
|
assert np.diff(xlim) == np.diff(ylim)
|
|
assert ax.get_aspect() == 1
|
|
assert_array_almost_equal(
|
|
ax.get_position(original=True).extents, (0.125, 0.1, 0.9, 0.9))
|
|
assert_array_almost_equal(
|
|
ax.get_position(original=False).extents, (0.2125, 0.1, 0.8125, 0.9))
|
|
|
|
|
|
def test_bad_plot_args():
|
|
with pytest.raises(ValueError):
|
|
plt.plot(None)
|
|
with pytest.raises(ValueError):
|
|
plt.plot(None, None)
|
|
with pytest.raises(ValueError):
|
|
plt.plot(np.zeros((2, 2)), np.zeros((2, 3)))
|
|
with pytest.raises(ValueError):
|
|
plt.plot((np.arange(5).reshape((1, -1)), np.arange(5).reshape(-1, 1)))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"xy, cls", [
|
|
((), mpl.image.AxesImage), # (0, N)
|
|
(((3, 7), (2, 6)), mpl.image.AxesImage), # (xmin, xmax)
|
|
((range(5), range(4)), mpl.image.AxesImage), # regular grid
|
|
(([1, 2, 4, 8, 16], [0, 1, 2, 3]), # irregular grid
|
|
mpl.image.PcolorImage),
|
|
((np.random.random((4, 5)), np.random.random((4, 5))), # 2D coords
|
|
mpl.collections.QuadMesh),
|
|
]
|
|
)
|
|
@pytest.mark.parametrize(
|
|
"data", [np.arange(12).reshape((3, 4)), np.random.rand(3, 4, 3)]
|
|
)
|
|
def test_pcolorfast(xy, data, cls):
|
|
fig, ax = plt.subplots()
|
|
assert type(ax.pcolorfast(*xy, data)) == cls
|
|
|
|
|
|
def test_shared_scale():
|
|
fig, axs = plt.subplots(2, 2, sharex=True, sharey=True)
|
|
|
|
axs[0, 0].set_xscale("log")
|
|
axs[0, 0].set_yscale("log")
|
|
|
|
for ax in axs.flat:
|
|
assert ax.get_yscale() == 'log'
|
|
assert ax.get_xscale() == 'log'
|
|
|
|
axs[1, 1].set_xscale("linear")
|
|
axs[1, 1].set_yscale("linear")
|
|
|
|
for ax in axs.flat:
|
|
assert ax.get_yscale() == 'linear'
|
|
assert ax.get_xscale() == 'linear'
|
|
|
|
|
|
def test_shared_bool():
|
|
with pytest.raises(TypeError):
|
|
plt.subplot(sharex=True)
|
|
with pytest.raises(TypeError):
|
|
plt.subplot(sharey=True)
|
|
|
|
|
|
def test_violin_point_mass():
|
|
"""Violin plot should handle point mass pdf gracefully."""
|
|
plt.violinplot(np.array([0, 0]))
|
|
|
|
|
|
def generate_errorbar_inputs():
|
|
base_xy = cycler('x', [np.arange(5)]) + cycler('y', [np.ones(5)])
|
|
err_cycler = cycler('err', [1,
|
|
[1, 1, 1, 1, 1],
|
|
[[1, 1, 1, 1, 1],
|
|
[1, 1, 1, 1, 1]],
|
|
np.ones(5),
|
|
np.ones((2, 5)),
|
|
None
|
|
])
|
|
xerr_cy = cycler('xerr', err_cycler)
|
|
yerr_cy = cycler('yerr', err_cycler)
|
|
|
|
empty = ((cycler('x', [[]]) + cycler('y', [[]])) *
|
|
cycler('xerr', [[], None]) * cycler('yerr', [[], None]))
|
|
xerr_only = base_xy * xerr_cy
|
|
yerr_only = base_xy * yerr_cy
|
|
both_err = base_xy * yerr_cy * xerr_cy
|
|
|
|
return [*xerr_only, *yerr_only, *both_err, *empty]
|
|
|
|
|
|
@pytest.mark.parametrize('kwargs', generate_errorbar_inputs())
|
|
def test_errorbar_inputs_shotgun(kwargs):
|
|
ax = plt.gca()
|
|
eb = ax.errorbar(**kwargs)
|
|
eb.remove()
|
|
|
|
|
|
@image_comparison(["dash_offset"], remove_text=True)
|
|
def test_dash_offset():
|
|
fig, ax = plt.subplots()
|
|
x = np.linspace(0, 10)
|
|
y = np.ones_like(x)
|
|
for j in range(0, 100, 2):
|
|
ax.plot(x, j*y, ls=(j, (10, 10)), lw=5, color='k')
|
|
|
|
|
|
def test_title_pad():
|
|
# check that title padding puts the title in the right
|
|
# place...
|
|
fig, ax = plt.subplots()
|
|
ax.set_title('aardvark', pad=30.)
|
|
m = ax.titleOffsetTrans.get_matrix()
|
|
assert m[1, -1] == (30. / 72. * fig.dpi)
|
|
ax.set_title('aardvark', pad=0.)
|
|
m = ax.titleOffsetTrans.get_matrix()
|
|
assert m[1, -1] == 0.
|
|
# check that it is reverted...
|
|
ax.set_title('aardvark', pad=None)
|
|
m = ax.titleOffsetTrans.get_matrix()
|
|
assert m[1, -1] == (matplotlib.rcParams['axes.titlepad'] / 72. * fig.dpi)
|
|
|
|
|
|
def test_title_location_roundtrip():
|
|
fig, ax = plt.subplots()
|
|
# set default title location
|
|
plt.rcParams['axes.titlelocation'] = 'center'
|
|
ax.set_title('aardvark')
|
|
ax.set_title('left', loc='left')
|
|
ax.set_title('right', loc='right')
|
|
|
|
assert 'left' == ax.get_title(loc='left')
|
|
assert 'right' == ax.get_title(loc='right')
|
|
assert 'aardvark' == ax.get_title(loc='center')
|
|
|
|
with pytest.raises(ValueError):
|
|
ax.get_title(loc='foo')
|
|
with pytest.raises(ValueError):
|
|
ax.set_title('fail', loc='foo')
|
|
|
|
|
|
@image_comparison(["loglog.png"], remove_text=True, tol=0.02)
|
|
def test_loglog():
|
|
fig, ax = plt.subplots()
|
|
x = np.arange(1, 11)
|
|
ax.loglog(x, x**3, lw=5)
|
|
ax.tick_params(length=25, width=2)
|
|
ax.tick_params(length=15, width=2, which='minor')
|
|
|
|
|
|
@pytest.mark.parametrize("new_api", [False, True])
|
|
@image_comparison(["test_loglog_nonpos.png"], remove_text=True, style='mpl20')
|
|
def test_loglog_nonpos(new_api):
|
|
fig, axs = plt.subplots(3, 3)
|
|
x = np.arange(1, 11)
|
|
y = x**3
|
|
y[7] = -3.
|
|
x[4] = -10
|
|
for (i, j), ax in np.ndenumerate(axs):
|
|
mcx = ['mask', 'clip', ''][j]
|
|
mcy = ['mask', 'clip', ''][i]
|
|
if new_api:
|
|
if mcx == mcy:
|
|
if mcx:
|
|
ax.loglog(x, y**3, lw=2, nonpositive=mcx)
|
|
else:
|
|
ax.loglog(x, y**3, lw=2)
|
|
else:
|
|
ax.loglog(x, y**3, lw=2)
|
|
if mcx:
|
|
ax.set_xscale("log", nonpositive=mcx)
|
|
if mcy:
|
|
ax.set_yscale("log", nonpositive=mcy)
|
|
else:
|
|
kws = {}
|
|
if mcx:
|
|
kws['nonposx'] = mcx
|
|
if mcy:
|
|
kws['nonposy'] = mcy
|
|
with (pytest.warns(MatplotlibDeprecationWarning) if kws
|
|
else nullcontext()):
|
|
ax.loglog(x, y**3, lw=2, **kws)
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_axes_margins():
|
|
fig, ax = plt.subplots()
|
|
ax.plot([0, 1, 2, 3])
|
|
assert ax.get_ybound()[0] != 0
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.bar([0, 1, 2, 3], [1, 1, 1, 1])
|
|
assert ax.get_ybound()[0] == 0
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.barh([0, 1, 2, 3], [1, 1, 1, 1])
|
|
assert ax.get_xbound()[0] == 0
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.pcolor(np.zeros((10, 10)))
|
|
assert ax.get_xbound() == (0, 10)
|
|
assert ax.get_ybound() == (0, 10)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.pcolorfast(np.zeros((10, 10)))
|
|
assert ax.get_xbound() == (0, 10)
|
|
assert ax.get_ybound() == (0, 10)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.hist(np.arange(10))
|
|
assert ax.get_ybound()[0] == 0
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.imshow(np.zeros((10, 10)))
|
|
assert ax.get_xbound() == (-0.5, 9.5)
|
|
assert ax.get_ybound() == (-0.5, 9.5)
|
|
|
|
|
|
@pytest.fixture(params=['x', 'y'])
|
|
def shared_axis_remover(request):
|
|
def _helper_x(ax):
|
|
ax2 = ax.twinx()
|
|
ax2.remove()
|
|
ax.set_xlim(0, 15)
|
|
r = ax.xaxis.get_major_locator()()
|
|
assert r[-1] > 14
|
|
|
|
def _helper_y(ax):
|
|
ax2 = ax.twiny()
|
|
ax2.remove()
|
|
ax.set_ylim(0, 15)
|
|
r = ax.yaxis.get_major_locator()()
|
|
assert r[-1] > 14
|
|
|
|
return {"x": _helper_x, "y": _helper_y}[request.param]
|
|
|
|
|
|
@pytest.fixture(params=['gca', 'subplots', 'subplots_shared', 'add_axes'])
|
|
def shared_axes_generator(request):
|
|
# test all of the ways to get fig/ax sets
|
|
if request.param == 'gca':
|
|
fig = plt.figure()
|
|
ax = fig.gca()
|
|
elif request.param == 'subplots':
|
|
fig, ax = plt.subplots()
|
|
elif request.param == 'subplots_shared':
|
|
fig, ax_lst = plt.subplots(2, 2, sharex='all', sharey='all')
|
|
ax = ax_lst[0][0]
|
|
elif request.param == 'add_axes':
|
|
fig = plt.figure()
|
|
ax = fig.add_axes([.1, .1, .8, .8])
|
|
return fig, ax
|
|
|
|
|
|
def test_remove_shared_axes(shared_axes_generator, shared_axis_remover):
|
|
# test all of the ways to get fig/ax sets
|
|
fig, ax = shared_axes_generator
|
|
shared_axis_remover(ax)
|
|
|
|
|
|
def test_remove_shared_axes_relim():
|
|
fig, ax_lst = plt.subplots(2, 2, sharex='all', sharey='all')
|
|
ax = ax_lst[0][0]
|
|
orig_xlim = ax_lst[0][1].get_xlim()
|
|
ax.remove()
|
|
ax.set_xlim(0, 5)
|
|
assert_array_equal(ax_lst[0][1].get_xlim(), orig_xlim)
|
|
|
|
|
|
def test_shared_axes_autoscale():
|
|
l = np.arange(-80, 90, 40)
|
|
t = np.random.random_sample((l.size, l.size))
|
|
|
|
ax1 = plt.subplot(211)
|
|
ax1.set_xlim(-1000, 1000)
|
|
ax1.set_ylim(-1000, 1000)
|
|
ax1.contour(l, l, t)
|
|
|
|
ax2 = plt.subplot(212, sharex=ax1, sharey=ax1)
|
|
ax2.contour(l, l, t)
|
|
assert not ax1.get_autoscalex_on() and not ax2.get_autoscalex_on()
|
|
assert not ax1.get_autoscaley_on() and not ax2.get_autoscaley_on()
|
|
assert ax1.get_xlim() == ax2.get_xlim() == (-1000, 1000)
|
|
assert ax1.get_ylim() == ax2.get_ylim() == (-1000, 1000)
|
|
|
|
|
|
def test_adjust_numtick_aspect():
|
|
fig, ax = plt.subplots()
|
|
ax.yaxis.get_major_locator().set_params(nbins='auto')
|
|
ax.set_xlim(0, 1000)
|
|
ax.set_aspect('equal')
|
|
fig.canvas.draw()
|
|
assert len(ax.yaxis.get_major_locator()()) == 2
|
|
ax.set_ylim(0, 1000)
|
|
fig.canvas.draw()
|
|
assert len(ax.yaxis.get_major_locator()()) > 2
|
|
|
|
|
|
@image_comparison(["auto_numticks.png"], style='default')
|
|
def test_auto_numticks():
|
|
# Make tiny, empty subplots, verify that there are only 3 ticks.
|
|
fig, axs = plt.subplots(4, 4)
|
|
|
|
|
|
@image_comparison(["auto_numticks_log.png"], style='default')
|
|
def test_auto_numticks_log():
|
|
# Verify that there are not too many ticks with a large log range.
|
|
fig, ax = plt.subplots()
|
|
matplotlib.rcParams['axes.autolimit_mode'] = 'round_numbers'
|
|
ax.loglog([1e-20, 1e5], [1e-16, 10])
|
|
|
|
|
|
def test_broken_barh_empty():
|
|
fig, ax = plt.subplots()
|
|
ax.broken_barh([], (.1, .5))
|
|
|
|
|
|
def test_broken_barh_timedelta():
|
|
"""Check that timedelta works as x, dx pair for this method."""
|
|
fig, ax = plt.subplots()
|
|
d0 = datetime.datetime(2018, 11, 9, 0, 0, 0)
|
|
pp = ax.broken_barh([(d0, datetime.timedelta(hours=1))], [1, 2])
|
|
assert pp.get_paths()[0].vertices[0, 0] == mdates.date2num(d0)
|
|
assert pp.get_paths()[0].vertices[2, 0] == mdates.date2num(d0) + 1 / 24
|
|
|
|
|
|
def test_pandas_pcolormesh(pd):
|
|
time = pd.date_range('2000-01-01', periods=10)
|
|
depth = np.arange(20)
|
|
data = np.random.rand(19, 9)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.pcolormesh(time, depth, data)
|
|
|
|
|
|
def test_pandas_indexing_dates(pd):
|
|
dates = np.arange('2005-02', '2005-03', dtype='datetime64[D]')
|
|
values = np.sin(np.array(range(len(dates))))
|
|
df = pd.DataFrame({'dates': dates, 'values': values})
|
|
|
|
ax = plt.gca()
|
|
|
|
without_zero_index = df[np.array(df.index) % 2 == 1].copy()
|
|
ax.plot('dates', 'values', data=without_zero_index)
|
|
|
|
|
|
def test_pandas_errorbar_indexing(pd):
|
|
df = pd.DataFrame(np.random.uniform(size=(5, 4)),
|
|
columns=['x', 'y', 'xe', 'ye'],
|
|
index=[1, 2, 3, 4, 5])
|
|
fig, ax = plt.subplots()
|
|
ax.errorbar('x', 'y', xerr='xe', yerr='ye', data=df)
|
|
|
|
|
|
def test_pandas_index_shape(pd):
|
|
df = pd.DataFrame({"XX": [4, 5, 6], "YY": [7, 1, 2]})
|
|
fig, ax = plt.subplots()
|
|
ax.plot(df.index, df['YY'])
|
|
|
|
|
|
def test_pandas_indexing_hist(pd):
|
|
ser_1 = pd.Series(data=[1, 2, 2, 3, 3, 4, 4, 4, 4, 5])
|
|
ser_2 = ser_1.iloc[1:]
|
|
fig, ax = plt.subplots()
|
|
ax.hist(ser_2)
|
|
|
|
|
|
def test_pandas_bar_align_center(pd):
|
|
# Tests fix for issue 8767
|
|
df = pd.DataFrame({'a': range(2), 'b': range(2)})
|
|
|
|
fig, ax = plt.subplots(1)
|
|
|
|
ax.bar(df.loc[df['a'] == 1, 'b'],
|
|
df.loc[df['a'] == 1, 'b'],
|
|
align='center')
|
|
|
|
fig.canvas.draw()
|
|
|
|
|
|
def test_axis_set_tick_params_labelsize_labelcolor():
|
|
# Tests fix for issue 4346
|
|
axis_1 = plt.subplot()
|
|
axis_1.yaxis.set_tick_params(labelsize=30, labelcolor='red',
|
|
direction='out')
|
|
|
|
# Expected values after setting the ticks
|
|
assert axis_1.yaxis.majorTicks[0]._size == 4.0
|
|
assert axis_1.yaxis.majorTicks[0].tick1line.get_color() == 'k'
|
|
assert axis_1.yaxis.majorTicks[0].label1.get_size() == 30.0
|
|
assert axis_1.yaxis.majorTicks[0].label1.get_color() == 'red'
|
|
|
|
|
|
def test_axes_tick_params_gridlines():
|
|
# Now treating grid params like other Tick params
|
|
ax = plt.subplot()
|
|
ax.tick_params(grid_color='b', grid_linewidth=5, grid_alpha=0.5,
|
|
grid_linestyle='dashdot')
|
|
for axis in ax.xaxis, ax.yaxis:
|
|
assert axis.majorTicks[0].gridline.get_color() == 'b'
|
|
assert axis.majorTicks[0].gridline.get_linewidth() == 5
|
|
assert axis.majorTicks[0].gridline.get_alpha() == 0.5
|
|
assert axis.majorTicks[0].gridline.get_linestyle() == '-.'
|
|
|
|
|
|
def test_axes_tick_params_ylabelside():
|
|
# Tests fix for issue 10267
|
|
ax = plt.subplot()
|
|
ax.tick_params(labelleft=False, labelright=True,
|
|
which='major')
|
|
ax.tick_params(labelleft=False, labelright=True,
|
|
which='minor')
|
|
# expects left false, right true
|
|
assert ax.yaxis.majorTicks[0].label1.get_visible() is False
|
|
assert ax.yaxis.majorTicks[0].label2.get_visible() is True
|
|
assert ax.yaxis.minorTicks[0].label1.get_visible() is False
|
|
assert ax.yaxis.minorTicks[0].label2.get_visible() is True
|
|
|
|
|
|
def test_axes_tick_params_xlabelside():
|
|
# Tests fix for issue 10267
|
|
ax = plt.subplot()
|
|
ax.tick_params(labeltop=True, labelbottom=False,
|
|
which='major')
|
|
ax.tick_params(labeltop=True, labelbottom=False,
|
|
which='minor')
|
|
# expects top True, bottom False
|
|
# label1.get_visible() mapped to labelbottom
|
|
# label2.get_visible() mapped to labeltop
|
|
assert ax.xaxis.majorTicks[0].label1.get_visible() is False
|
|
assert ax.xaxis.majorTicks[0].label2.get_visible() is True
|
|
assert ax.xaxis.minorTicks[0].label1.get_visible() is False
|
|
assert ax.xaxis.minorTicks[0].label2.get_visible() is True
|
|
|
|
|
|
def test_none_kwargs():
|
|
ax = plt.figure().subplots()
|
|
ln, = ax.plot(range(32), linestyle=None)
|
|
assert ln.get_linestyle() == '-'
|
|
|
|
|
|
def test_ls_ds_conflict():
|
|
# Passing the drawstyle with the linestyle is deprecated since 3.1.
|
|
# We still need to test this until it's removed from the code.
|
|
# But we don't want to see the deprecation warning in the test.
|
|
with matplotlib.cbook._suppress_matplotlib_deprecation_warning(), \
|
|
pytest.raises(ValueError):
|
|
plt.plot(range(32), linestyle='steps-pre:', drawstyle='steps-post')
|
|
|
|
|
|
def test_bar_uint8():
|
|
xs = [0, 1, 2, 3]
|
|
b = plt.bar(np.array(xs, dtype=np.uint8), [2, 3, 4, 5], align="edge")
|
|
for (patch, x) in zip(b.patches, xs):
|
|
assert patch.xy[0] == x
|
|
|
|
|
|
@image_comparison(['date_timezone_x.png'], tol=1.0)
|
|
def test_date_timezone_x():
|
|
# Tests issue 5575
|
|
time_index = [datetime.datetime(2016, 2, 22, hour=x,
|
|
tzinfo=dateutil.tz.gettz('Canada/Eastern'))
|
|
for x in range(3)]
|
|
|
|
# Same Timezone
|
|
plt.figure(figsize=(20, 12))
|
|
plt.subplot(2, 1, 1)
|
|
plt.plot_date(time_index, [3] * 3, tz='Canada/Eastern')
|
|
|
|
# Different Timezone
|
|
plt.subplot(2, 1, 2)
|
|
plt.plot_date(time_index, [3] * 3, tz='UTC')
|
|
|
|
|
|
@image_comparison(['date_timezone_y.png'])
|
|
def test_date_timezone_y():
|
|
# Tests issue 5575
|
|
time_index = [datetime.datetime(2016, 2, 22, hour=x,
|
|
tzinfo=dateutil.tz.gettz('Canada/Eastern'))
|
|
for x in range(3)]
|
|
|
|
# Same Timezone
|
|
plt.figure(figsize=(20, 12))
|
|
plt.subplot(2, 1, 1)
|
|
plt.plot_date([3] * 3,
|
|
time_index, tz='Canada/Eastern', xdate=False, ydate=True)
|
|
|
|
# Different Timezone
|
|
plt.subplot(2, 1, 2)
|
|
plt.plot_date([3] * 3, time_index, tz='UTC', xdate=False, ydate=True)
|
|
|
|
|
|
@image_comparison(['date_timezone_x_and_y.png'], tol=1.0)
|
|
def test_date_timezone_x_and_y():
|
|
# Tests issue 5575
|
|
UTC = datetime.timezone.utc
|
|
time_index = [datetime.datetime(2016, 2, 22, hour=x, tzinfo=UTC)
|
|
for x in range(3)]
|
|
|
|
# Same Timezone
|
|
plt.figure(figsize=(20, 12))
|
|
plt.subplot(2, 1, 1)
|
|
plt.plot_date(time_index, time_index, tz='UTC', ydate=True)
|
|
|
|
# Different Timezone
|
|
plt.subplot(2, 1, 2)
|
|
plt.plot_date(time_index, time_index, tz='US/Eastern', ydate=True)
|
|
|
|
|
|
@image_comparison(['axisbelow.png'], remove_text=True)
|
|
def test_axisbelow():
|
|
# Test 'line' setting added in 6287.
|
|
# Show only grids, not frame or ticks, to make this test
|
|
# independent of future change to drawing order of those elements.
|
|
axs = plt.figure().subplots(ncols=3, sharex=True, sharey=True)
|
|
settings = (False, 'line', True)
|
|
|
|
for ax, setting in zip(axs, settings):
|
|
ax.plot((0, 10), (0, 10), lw=10, color='m')
|
|
circ = mpatches.Circle((3, 3), color='r')
|
|
ax.add_patch(circ)
|
|
ax.grid(color='c', linestyle='-', linewidth=3)
|
|
ax.tick_params(top=False, bottom=False,
|
|
left=False, right=False)
|
|
for spine in ax.spines.values():
|
|
spine.set_visible(False)
|
|
ax.set_axisbelow(setting)
|
|
|
|
|
|
def test_titletwiny():
|
|
plt.style.use('mpl20')
|
|
fig, ax = plt.subplots(dpi=72)
|
|
ax2 = ax.twiny()
|
|
xlabel2 = ax2.set_xlabel('Xlabel2')
|
|
title = ax.set_title('Title')
|
|
fig.canvas.draw()
|
|
renderer = fig.canvas.get_renderer()
|
|
# ------- Test that title is put above Xlabel2 (Xlabel2 at top) ----------
|
|
bbox_y0_title = title.get_window_extent(renderer).y0 # bottom of title
|
|
bbox_y1_xlabel2 = xlabel2.get_window_extent(renderer).y1 # top of xlabel2
|
|
y_diff = bbox_y0_title - bbox_y1_xlabel2
|
|
assert np.isclose(y_diff, 3)
|
|
|
|
|
|
def test_titlesetpos():
|
|
# Test that title stays put if we set it manually
|
|
fig, ax = plt.subplots()
|
|
fig.subplots_adjust(top=0.8)
|
|
ax2 = ax.twiny()
|
|
ax.set_xlabel('Xlabel')
|
|
ax2.set_xlabel('Xlabel2')
|
|
ax.set_title('Title')
|
|
pos = (0.5, 1.11)
|
|
ax.title.set_position(pos)
|
|
renderer = fig.canvas.get_renderer()
|
|
ax._update_title_position(renderer)
|
|
assert ax.title.get_position() == pos
|
|
|
|
|
|
def test_title_xticks_top():
|
|
# Test that title moves if xticks on top of axes.
|
|
mpl.rcParams['axes.titley'] = None
|
|
fig, ax = plt.subplots()
|
|
ax.xaxis.set_ticks_position('top')
|
|
ax.set_title('xlabel top')
|
|
fig.canvas.draw()
|
|
assert ax.title.get_position()[1] > 1.04
|
|
|
|
|
|
def test_title_xticks_top_both():
|
|
# Test that title moves if xticks on top of axes.
|
|
mpl.rcParams['axes.titley'] = None
|
|
fig, ax = plt.subplots()
|
|
ax.tick_params(axis="x",
|
|
bottom=True, top=True, labelbottom=True, labeltop=True)
|
|
ax.set_title('xlabel top')
|
|
fig.canvas.draw()
|
|
assert ax.title.get_position()[1] > 1.04
|
|
|
|
|
|
def test_title_no_move_off_page():
|
|
# If an axes is off the figure (ie. if it is cropped during a save)
|
|
# make sure that the automatic title repositioning does not get done.
|
|
mpl.rcParams['axes.titley'] = None
|
|
fig = plt.figure()
|
|
ax = fig.add_axes([0.1, -0.5, 0.8, 0.2])
|
|
ax.tick_params(axis="x",
|
|
bottom=True, top=True, labelbottom=True, labeltop=True)
|
|
tt = ax.set_title('Boo')
|
|
fig.canvas.draw()
|
|
assert tt.get_position()[1] == 1.0
|
|
|
|
|
|
def test_offset_label_color():
|
|
# Tests issue 6440
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.plot([1.01e9, 1.02e9, 1.03e9])
|
|
ax.yaxis.set_tick_params(labelcolor='red')
|
|
assert ax.yaxis.get_offset_text().get_color() == 'red'
|
|
|
|
|
|
def test_offset_text_visible():
|
|
fig = plt.figure()
|
|
ax = fig.add_subplot(1, 1, 1)
|
|
ax.plot([1.01e9, 1.02e9, 1.03e9])
|
|
ax.yaxis.set_tick_params(label1On=False, label2On=True)
|
|
assert ax.yaxis.get_offset_text().get_visible()
|
|
ax.yaxis.set_tick_params(label2On=False)
|
|
assert not ax.yaxis.get_offset_text().get_visible()
|
|
|
|
|
|
def test_large_offset():
|
|
fig, ax = plt.subplots()
|
|
ax.plot((1 + np.array([0, 1.e-12])) * 1.e27)
|
|
fig.canvas.draw()
|
|
|
|
|
|
def test_barb_units():
|
|
fig, ax = plt.subplots()
|
|
dates = [datetime.datetime(2017, 7, 15, 18, i) for i in range(0, 60, 10)]
|
|
y = np.linspace(0, 5, len(dates))
|
|
u = v = np.linspace(0, 50, len(dates))
|
|
ax.barbs(dates, y, u, v)
|
|
|
|
|
|
def test_quiver_units():
|
|
fig, ax = plt.subplots()
|
|
dates = [datetime.datetime(2017, 7, 15, 18, i) for i in range(0, 60, 10)]
|
|
y = np.linspace(0, 5, len(dates))
|
|
u = v = np.linspace(0, 50, len(dates))
|
|
ax.quiver(dates, y, u, v)
|
|
|
|
|
|
def test_bar_color_cycle():
|
|
to_rgb = mcolors.to_rgb
|
|
fig, ax = plt.subplots()
|
|
for j in range(5):
|
|
ln, = ax.plot(range(3))
|
|
brs = ax.bar(range(3), range(3))
|
|
for br in brs:
|
|
assert to_rgb(ln.get_color()) == to_rgb(br.get_facecolor())
|
|
|
|
|
|
def test_tick_param_label_rotation():
|
|
fix, (ax, ax2) = plt.subplots(1, 2)
|
|
ax.plot([0, 1], [0, 1])
|
|
ax2.plot([0, 1], [0, 1])
|
|
ax.xaxis.set_tick_params(which='both', rotation=75)
|
|
ax.yaxis.set_tick_params(which='both', rotation=90)
|
|
for text in ax.get_xticklabels(which='both'):
|
|
assert text.get_rotation() == 75
|
|
for text in ax.get_yticklabels(which='both'):
|
|
assert text.get_rotation() == 90
|
|
|
|
ax2.tick_params(axis='x', labelrotation=53)
|
|
ax2.tick_params(axis='y', rotation=35)
|
|
for text in ax2.get_xticklabels(which='major'):
|
|
assert text.get_rotation() == 53
|
|
for text in ax2.get_yticklabels(which='major'):
|
|
assert text.get_rotation() == 35
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_fillbetween_cycle():
|
|
fig, ax = plt.subplots()
|
|
|
|
for j in range(3):
|
|
cc = ax.fill_between(range(3), range(3))
|
|
target = mcolors.to_rgba('C{}'.format(j))
|
|
assert tuple(cc.get_facecolors().squeeze()) == tuple(target)
|
|
|
|
for j in range(3, 6):
|
|
cc = ax.fill_betweenx(range(3), range(3))
|
|
target = mcolors.to_rgba('C{}'.format(j))
|
|
assert tuple(cc.get_facecolors().squeeze()) == tuple(target)
|
|
|
|
target = mcolors.to_rgba('k')
|
|
|
|
for al in ['facecolor', 'facecolors', 'color']:
|
|
cc = ax.fill_between(range(3), range(3), **{al: 'k'})
|
|
assert tuple(cc.get_facecolors().squeeze()) == tuple(target)
|
|
|
|
edge_target = mcolors.to_rgba('k')
|
|
for j, el in enumerate(['edgecolor', 'edgecolors'], start=6):
|
|
cc = ax.fill_between(range(3), range(3), **{el: 'k'})
|
|
face_target = mcolors.to_rgba('C{}'.format(j))
|
|
assert tuple(cc.get_facecolors().squeeze()) == tuple(face_target)
|
|
assert tuple(cc.get_edgecolors().squeeze()) == tuple(edge_target)
|
|
|
|
|
|
def test_log_margins():
|
|
plt.rcParams['axes.autolimit_mode'] = 'data'
|
|
fig, ax = plt.subplots()
|
|
margin = 0.05
|
|
ax.set_xmargin(margin)
|
|
ax.semilogx([10, 100], [10, 100])
|
|
xlim0, xlim1 = ax.get_xlim()
|
|
transform = ax.xaxis.get_transform()
|
|
xlim0t, xlim1t = transform.transform([xlim0, xlim1])
|
|
x0t, x1t = transform.transform([10, 100])
|
|
delta = (x1t - x0t) * margin
|
|
assert_allclose([xlim0t + delta, xlim1t - delta], [x0t, x1t])
|
|
|
|
|
|
def test_color_length_mismatch():
|
|
N = 5
|
|
x, y = np.arange(N), np.arange(N)
|
|
colors = np.arange(N+1)
|
|
fig, ax = plt.subplots()
|
|
with pytest.raises(ValueError):
|
|
ax.scatter(x, y, c=colors)
|
|
c_rgb = (0.5, 0.5, 0.5)
|
|
ax.scatter(x, y, c=c_rgb)
|
|
ax.scatter(x, y, c=[c_rgb] * N)
|
|
|
|
|
|
def test_eventplot_legend():
|
|
plt.eventplot([1.0], label='Label')
|
|
plt.legend()
|
|
|
|
|
|
def test_bar_broadcast_args():
|
|
fig, ax = plt.subplots()
|
|
# Check that a bar chart with a single height for all bars works.
|
|
ax.bar(range(4), 1)
|
|
# Check that a horizontal chart with one width works.
|
|
ax.barh(0, 1, left=range(4), height=1)
|
|
# Check that edgecolor gets broadcast.
|
|
rect1, rect2 = ax.bar([0, 1], [0, 1], edgecolor=(.1, .2, .3, .4))
|
|
assert rect1.get_edgecolor() == rect2.get_edgecolor() == (.1, .2, .3, .4)
|
|
|
|
|
|
def test_invalid_axis_limits():
|
|
plt.plot([0, 1], [0, 1])
|
|
with pytest.raises(ValueError):
|
|
plt.xlim(np.nan)
|
|
with pytest.raises(ValueError):
|
|
plt.xlim(np.inf)
|
|
with pytest.raises(ValueError):
|
|
plt.ylim(np.nan)
|
|
with pytest.raises(ValueError):
|
|
plt.ylim(np.inf)
|
|
|
|
|
|
# Test all 4 combinations of logs/symlogs for minorticks_on()
|
|
@pytest.mark.parametrize('xscale', ['symlog', 'log'])
|
|
@pytest.mark.parametrize('yscale', ['symlog', 'log'])
|
|
def test_minorticks_on(xscale, yscale):
|
|
ax = plt.subplot(111)
|
|
ax.plot([1, 2, 3, 4])
|
|
ax.set_xscale(xscale)
|
|
ax.set_yscale(yscale)
|
|
ax.minorticks_on()
|
|
|
|
|
|
def test_twinx_knows_limits():
|
|
fig, ax = plt.subplots()
|
|
|
|
ax.axvspan(1, 2)
|
|
xtwin = ax.twinx()
|
|
xtwin.plot([0, 0.5], [1, 2])
|
|
# control axis
|
|
fig2, ax2 = plt.subplots()
|
|
|
|
ax2.axvspan(1, 2)
|
|
ax2.plot([0, 0.5], [1, 2])
|
|
|
|
assert_array_equal(xtwin.viewLim.intervalx, ax2.viewLim.intervalx)
|
|
|
|
|
|
def test_zero_linewidth():
|
|
# Check that setting a zero linewidth doesn't error
|
|
plt.plot([0, 1], [0, 1], ls='--', lw=0)
|
|
|
|
|
|
def test_empty_errorbar_legend():
|
|
fig, ax = plt.subplots()
|
|
ax.errorbar([], [], xerr=[], label='empty y')
|
|
ax.errorbar([], [], yerr=[], label='empty x')
|
|
ax.legend()
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_plot_decimal(fig_test, fig_ref):
|
|
x0 = np.arange(-10, 10, 0.3)
|
|
y0 = [5.2 * x ** 3 - 2.1 * x ** 2 + 7.34 * x + 4.5 for x in x0]
|
|
x = [Decimal(i) for i in x0]
|
|
y = [Decimal(i) for i in y0]
|
|
# Test image - line plot with Decimal input
|
|
fig_test.subplots().plot(x, y)
|
|
# Reference image
|
|
fig_ref.subplots().plot(x0, y0)
|
|
|
|
|
|
# pdf and svg tests fail using travis' old versions of gs and inkscape.
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_markerfacecolor_none_alpha(fig_test, fig_ref):
|
|
fig_test.subplots().plot(0, "o", mfc="none", alpha=.5)
|
|
fig_ref.subplots().plot(0, "o", mfc="w", alpha=.5)
|
|
|
|
|
|
def test_tick_padding_tightbbox():
|
|
"""Test that tick padding gets turned off if axis is off"""
|
|
plt.rcParams["xtick.direction"] = "out"
|
|
plt.rcParams["ytick.direction"] = "out"
|
|
fig, ax = plt.subplots()
|
|
bb = ax.get_tightbbox(fig.canvas.get_renderer())
|
|
ax.axis('off')
|
|
bb2 = ax.get_tightbbox(fig.canvas.get_renderer())
|
|
assert bb.x0 < bb2.x0
|
|
assert bb.y0 < bb2.y0
|
|
|
|
|
|
def test_inset():
|
|
"""
|
|
Ensure that inset_ax argument is indeed optional
|
|
"""
|
|
dx, dy = 0.05, 0.05
|
|
# generate 2 2d grids for the x & y bounds
|
|
y, x = np.mgrid[slice(1, 5 + dy, dy),
|
|
slice(1, 5 + dx, dx)]
|
|
z = np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.pcolormesh(x, y, z[:-1, :-1])
|
|
ax.set_aspect(1.)
|
|
ax.apply_aspect()
|
|
# we need to apply_aspect to make the drawing below work.
|
|
|
|
xlim = [1.5, 2.15]
|
|
ylim = [2, 2.5]
|
|
|
|
rect = [xlim[0], ylim[0], xlim[1] - xlim[0], ylim[1] - ylim[0]]
|
|
|
|
rec, connectors = ax.indicate_inset(bounds=rect)
|
|
assert connectors is None
|
|
fig.canvas.draw()
|
|
xx = np.array([[1.5, 2.],
|
|
[2.15, 2.5]])
|
|
assert np.all(rec.get_bbox().get_points() == xx)
|
|
|
|
|
|
def test_zoom_inset():
|
|
dx, dy = 0.05, 0.05
|
|
# generate 2 2d grids for the x & y bounds
|
|
y, x = np.mgrid[slice(1, 5 + dy, dy),
|
|
slice(1, 5 + dx, dx)]
|
|
z = np.sin(x)**10 + np.cos(10 + y*x) * np.cos(x)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.pcolormesh(x, y, z[:-1, :-1])
|
|
ax.set_aspect(1.)
|
|
ax.apply_aspect()
|
|
# we need to apply_aspect to make the drawing below work.
|
|
|
|
# Make the inset_axes... Position axes coordinates...
|
|
axin1 = ax.inset_axes([0.7, 0.7, 0.35, 0.35])
|
|
# redraw the data in the inset axes...
|
|
axin1.pcolormesh(x, y, z[:-1, :-1])
|
|
axin1.set_xlim([1.5, 2.15])
|
|
axin1.set_ylim([2, 2.5])
|
|
axin1.set_aspect(ax.get_aspect())
|
|
|
|
rec, connectors = ax.indicate_inset_zoom(axin1)
|
|
assert len(connectors) == 4
|
|
fig.canvas.draw()
|
|
xx = np.array([[1.5, 2.],
|
|
[2.15, 2.5]])
|
|
assert(np.all(rec.get_bbox().get_points() == xx))
|
|
xx = np.array([[0.6325, 0.692308],
|
|
[0.8425, 0.907692]])
|
|
np.testing.assert_allclose(
|
|
axin1.get_position().get_points(), xx, rtol=1e-4)
|
|
|
|
|
|
@pytest.mark.parametrize('x_inverted', [False, True])
|
|
@pytest.mark.parametrize('y_inverted', [False, True])
|
|
def test_indicate_inset_inverted(x_inverted, y_inverted):
|
|
"""
|
|
Test that the inset lines are correctly located with inverted data axes.
|
|
"""
|
|
fig, (ax1, ax2) = plt.subplots(1, 2)
|
|
|
|
x = np.arange(10)
|
|
ax1.plot(x, x, 'o')
|
|
if x_inverted:
|
|
ax1.invert_xaxis()
|
|
if y_inverted:
|
|
ax1.invert_yaxis()
|
|
|
|
rect, bounds = ax1.indicate_inset([2, 2, 5, 4], ax2)
|
|
lower_left, upper_left, lower_right, upper_right = bounds
|
|
|
|
sign_x = -1 if x_inverted else 1
|
|
sign_y = -1 if y_inverted else 1
|
|
assert sign_x * (lower_right.xy2[0] - lower_left.xy2[0]) > 0
|
|
assert sign_x * (upper_right.xy2[0] - upper_left.xy2[0]) > 0
|
|
assert sign_y * (upper_left.xy2[1] - lower_left.xy2[1]) > 0
|
|
assert sign_y * (upper_right.xy2[1] - lower_right.xy2[1]) > 0
|
|
|
|
|
|
def test_set_position():
|
|
fig, ax = plt.subplots()
|
|
ax.set_aspect(3.)
|
|
ax.set_position([0.1, 0.1, 0.4, 0.4], which='both')
|
|
assert np.allclose(ax.get_position().width, 0.1)
|
|
ax.set_aspect(2.)
|
|
ax.set_position([0.1, 0.1, 0.4, 0.4], which='original')
|
|
assert np.allclose(ax.get_position().width, 0.15)
|
|
ax.set_aspect(3.)
|
|
ax.set_position([0.1, 0.1, 0.4, 0.4], which='active')
|
|
assert np.allclose(ax.get_position().width, 0.1)
|
|
|
|
|
|
def test_spines_properbbox_after_zoom():
|
|
fig, ax = plt.subplots()
|
|
bb = ax.spines['bottom'].get_window_extent(fig.canvas.get_renderer())
|
|
# this is what zoom calls:
|
|
ax._set_view_from_bbox((320, 320, 500, 500), 'in',
|
|
None, False, False)
|
|
bb2 = ax.spines['bottom'].get_window_extent(fig.canvas.get_renderer())
|
|
np.testing.assert_allclose(bb.get_points(), bb2.get_points(), rtol=1e-6)
|
|
|
|
|
|
def test_cartopy_backcompat():
|
|
|
|
class Dummy(matplotlib.axes.Axes):
|
|
...
|
|
|
|
class DummySubplot(matplotlib.axes.SubplotBase, Dummy):
|
|
_axes_class = Dummy
|
|
|
|
matplotlib.axes._subplots._subplot_classes[Dummy] = DummySubplot
|
|
|
|
FactoryDummySubplot = matplotlib.axes.subplot_class_factory(Dummy)
|
|
|
|
assert DummySubplot is FactoryDummySubplot
|
|
|
|
|
|
def test_gettightbbox_ignoreNaN():
|
|
fig, ax = plt.subplots()
|
|
remove_ticks_and_titles(fig)
|
|
ax.text(np.NaN, 1, 'Boo')
|
|
renderer = fig.canvas.get_renderer()
|
|
np.testing.assert_allclose(ax.get_tightbbox(renderer).width, 496)
|
|
|
|
|
|
def test_scatter_series_non_zero_index(pd):
|
|
# create non-zero index
|
|
ids = range(10, 18)
|
|
x = pd.Series(np.random.uniform(size=8), index=ids)
|
|
y = pd.Series(np.random.uniform(size=8), index=ids)
|
|
c = pd.Series([1, 1, 1, 1, 1, 0, 0, 0], index=ids)
|
|
plt.scatter(x, y, c)
|
|
|
|
|
|
def test_scatter_empty_data():
|
|
# making sure this does not raise an exception
|
|
plt.scatter([], [])
|
|
plt.scatter([], [], s=[], c=[])
|
|
|
|
|
|
@image_comparison(['annotate_across_transforms.png'],
|
|
style='mpl20', remove_text=True)
|
|
def test_annotate_across_transforms():
|
|
x = np.linspace(0, 10, 200)
|
|
y = np.exp(-x) * np.sin(x)
|
|
|
|
fig, ax = plt.subplots(figsize=(3.39, 3))
|
|
ax.plot(x, y)
|
|
axins = ax.inset_axes([0.4, 0.5, 0.3, 0.3])
|
|
axins.set_aspect(0.2)
|
|
axins.xaxis.set_visible(False)
|
|
axins.yaxis.set_visible(False)
|
|
ax.annotate("", xy=(x[150], y[150]), xycoords=ax.transData,
|
|
xytext=(1, 0), textcoords=axins.transAxes,
|
|
arrowprops=dict(arrowstyle="->"))
|
|
|
|
|
|
@image_comparison(['secondary_xy.png'], style='mpl20')
|
|
def test_secondary_xy():
|
|
fig, axs = plt.subplots(1, 2, figsize=(10, 5), constrained_layout=True)
|
|
|
|
def invert(x):
|
|
with np.errstate(divide='ignore'):
|
|
return 1 / x
|
|
|
|
for nn, ax in enumerate(axs):
|
|
ax.plot(np.arange(2, 11), np.arange(2, 11))
|
|
if nn == 0:
|
|
secax = ax.secondary_xaxis
|
|
else:
|
|
secax = ax.secondary_yaxis
|
|
|
|
secax(0.2, functions=(invert, invert))
|
|
secax(0.4, functions=(lambda x: 2 * x, lambda x: x / 2))
|
|
secax(0.6, functions=(lambda x: x**2, lambda x: x**(1/2)))
|
|
secax(0.8)
|
|
|
|
|
|
def test_secondary_fail():
|
|
fig, ax = plt.subplots()
|
|
ax.plot(np.arange(2, 11), np.arange(2, 11))
|
|
with pytest.raises(ValueError):
|
|
ax.secondary_xaxis(0.2, functions=(lambda x: 1 / x))
|
|
with pytest.raises(ValueError):
|
|
ax.secondary_xaxis('right')
|
|
with pytest.raises(ValueError):
|
|
ax.secondary_yaxis('bottom')
|
|
|
|
|
|
def test_secondary_resize():
|
|
fig, ax = plt.subplots(figsize=(10, 5))
|
|
ax.plot(np.arange(2, 11), np.arange(2, 11))
|
|
def invert(x):
|
|
with np.errstate(divide='ignore'):
|
|
return 1 / x
|
|
|
|
ax.secondary_xaxis('top', functions=(invert, invert))
|
|
fig.canvas.draw()
|
|
fig.set_size_inches((7, 4))
|
|
assert_allclose(ax.get_position().extents, [0.125, 0.1, 0.9, 0.9])
|
|
|
|
|
|
def test_secondary_minorloc():
|
|
fig, ax = plt.subplots(figsize=(10, 5))
|
|
ax.plot(np.arange(2, 11), np.arange(2, 11))
|
|
def invert(x):
|
|
with np.errstate(divide='ignore'):
|
|
return 1 / x
|
|
|
|
secax = ax.secondary_xaxis('top', functions=(invert, invert))
|
|
assert isinstance(secax._axis.get_minor_locator(),
|
|
mticker.NullLocator)
|
|
secax.minorticks_on()
|
|
assert isinstance(secax._axis.get_minor_locator(),
|
|
mticker.AutoMinorLocator)
|
|
ax.set_xscale('log')
|
|
plt.draw()
|
|
assert isinstance(secax._axis.get_minor_locator(),
|
|
mticker.LogLocator)
|
|
ax.set_xscale('linear')
|
|
plt.draw()
|
|
assert isinstance(secax._axis.get_minor_locator(),
|
|
mticker.NullLocator)
|
|
|
|
|
|
def test_secondary_formatter():
|
|
fig, ax = plt.subplots()
|
|
ax.set_xscale("log")
|
|
secax = ax.secondary_xaxis("top")
|
|
secax.xaxis.set_major_formatter(mticker.ScalarFormatter())
|
|
fig.canvas.draw()
|
|
assert isinstance(
|
|
secax.xaxis.get_major_formatter(), mticker.ScalarFormatter)
|
|
|
|
|
|
def color_boxes(fig, axs):
|
|
"""
|
|
Helper for the tests below that test the extents of various axes elements
|
|
"""
|
|
fig.canvas.draw()
|
|
|
|
renderer = fig.canvas.get_renderer()
|
|
bbaxis = []
|
|
for nn, axx in enumerate([axs.xaxis, axs.yaxis]):
|
|
bb = axx.get_tightbbox(renderer)
|
|
if bb:
|
|
axisr = plt.Rectangle(
|
|
(bb.x0, bb.y0), width=bb.width, height=bb.height,
|
|
linewidth=0.7, edgecolor='y', facecolor="none", transform=None,
|
|
zorder=3)
|
|
fig.add_artist(axisr)
|
|
bbaxis += [bb]
|
|
|
|
bbspines = []
|
|
for nn, a in enumerate(['bottom', 'top', 'left', 'right']):
|
|
bb = axs.spines[a].get_window_extent(renderer)
|
|
spiner = plt.Rectangle(
|
|
(bb.x0, bb.y0), width=bb.width, height=bb.height,
|
|
linewidth=0.7, edgecolor="green", facecolor="none", transform=None,
|
|
zorder=3)
|
|
fig.add_artist(spiner)
|
|
bbspines += [bb]
|
|
|
|
bb = axs.get_window_extent()
|
|
rect2 = plt.Rectangle(
|
|
(bb.x0, bb.y0), width=bb.width, height=bb.height,
|
|
linewidth=1.5, edgecolor="magenta", facecolor="none", transform=None,
|
|
zorder=2)
|
|
fig.add_artist(rect2)
|
|
bbax = bb
|
|
|
|
bb2 = axs.get_tightbbox(renderer)
|
|
rect2 = plt.Rectangle(
|
|
(bb2.x0, bb2.y0), width=bb2.width, height=bb2.height,
|
|
linewidth=3, edgecolor="red", facecolor="none", transform=None,
|
|
zorder=1)
|
|
fig.add_artist(rect2)
|
|
bbtb = bb2
|
|
return bbaxis, bbspines, bbax, bbtb
|
|
|
|
|
|
def test_normal_axes():
|
|
with rc_context({'_internal.classic_mode': False}):
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
fig.canvas.draw()
|
|
plt.close(fig)
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
|
|
# test the axis bboxes
|
|
target = [
|
|
[123.375, 75.88888888888886, 983.25, 33.0],
|
|
[85.51388888888889, 99.99999999999997, 53.375, 993.0]
|
|
]
|
|
for nn, b in enumerate(bbaxis):
|
|
targetbb = mtransforms.Bbox.from_bounds(*target[nn])
|
|
assert_array_almost_equal(b.bounds, targetbb.bounds, decimal=2)
|
|
|
|
target = [
|
|
[150.0, 119.999, 930.0, 11.111],
|
|
[150.0, 1080.0, 930.0, 0.0],
|
|
[150.0, 119.9999, 11.111, 960.0],
|
|
[1068.8888, 119.9999, 11.111, 960.0]
|
|
]
|
|
for nn, b in enumerate(bbspines):
|
|
targetbb = mtransforms.Bbox.from_bounds(*target[nn])
|
|
assert_array_almost_equal(b.bounds, targetbb.bounds, decimal=2)
|
|
|
|
target = [150.0, 119.99999999999997, 930.0, 960.0]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_array_almost_equal(bbax.bounds, targetbb.bounds, decimal=2)
|
|
|
|
target = [85.5138, 75.88888, 1021.11, 1017.11]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_array_almost_equal(bbtb.bounds, targetbb.bounds, decimal=2)
|
|
|
|
# test that get_position roundtrips to get_window_extent
|
|
axbb = ax.get_position().transformed(fig.transFigure).bounds
|
|
assert_array_almost_equal(axbb, ax.get_window_extent().bounds, decimal=2)
|
|
|
|
|
|
def test_nodecorator():
|
|
with rc_context({'_internal.classic_mode': False}):
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
fig.canvas.draw()
|
|
ax.set(xticklabels=[], yticklabels=[])
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
|
|
# test the axis bboxes
|
|
target = [
|
|
None,
|
|
None
|
|
]
|
|
for nn, b in enumerate(bbaxis):
|
|
assert b is None
|
|
|
|
target = [
|
|
[150.0, 119.999, 930.0, 11.111],
|
|
[150.0, 1080.0, 930.0, 0.0],
|
|
[150.0, 119.9999, 11.111, 960.0],
|
|
[1068.8888, 119.9999, 11.111, 960.0]
|
|
]
|
|
for nn, b in enumerate(bbspines):
|
|
targetbb = mtransforms.Bbox.from_bounds(*target[nn])
|
|
assert_allclose(b.bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
target = [150.0, 119.99999999999997, 930.0, 960.0]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_allclose(bbax.bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
target = [150., 120., 930., 960.]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_allclose(bbtb.bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
|
|
def test_displaced_spine():
|
|
with rc_context({'_internal.classic_mode': False}):
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
ax.set(xticklabels=[], yticklabels=[])
|
|
ax.spines['bottom'].set_position(('axes', -0.1))
|
|
fig.canvas.draw()
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
|
|
target = [
|
|
[150., 24., 930., 11.111111],
|
|
[150.0, 1080.0, 930.0, 0.0],
|
|
[150.0, 119.9999, 11.111, 960.0],
|
|
[1068.8888, 119.9999, 11.111, 960.0]
|
|
]
|
|
for nn, b in enumerate(bbspines):
|
|
targetbb = mtransforms.Bbox.from_bounds(*target[nn])
|
|
|
|
target = [150.0, 119.99999999999997, 930.0, 960.0]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_allclose(bbax.bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
target = [150., 24., 930., 1056.]
|
|
targetbb = mtransforms.Bbox.from_bounds(*target)
|
|
assert_allclose(bbtb.bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
|
|
def test_tickdirs():
|
|
"""
|
|
Switch the tickdirs and make sure the bboxes switch with them
|
|
"""
|
|
targets = [[[150.0, 120.0, 930.0, 11.1111],
|
|
[150.0, 120.0, 11.111, 960.0]],
|
|
[[150.0, 108.8889, 930.0, 11.111111111111114],
|
|
[138.889, 120, 11.111, 960.0]],
|
|
[[150.0, 114.44444444444441, 930.0, 11.111111111111114],
|
|
[144.44444444444446, 119.999, 11.111, 960.0]]]
|
|
for dnum, dirs in enumerate(['in', 'out', 'inout']):
|
|
with rc_context({'_internal.classic_mode': False}):
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
ax.tick_params(direction=dirs)
|
|
fig.canvas.draw()
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
for nn, num in enumerate([0, 2]):
|
|
targetbb = mtransforms.Bbox.from_bounds(*targets[dnum][nn])
|
|
assert_allclose(
|
|
bbspines[num].bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
|
|
def test_minor_accountedfor():
|
|
with rc_context({'_internal.classic_mode': False}):
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
fig.canvas.draw()
|
|
ax.tick_params(which='both', direction='out')
|
|
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
targets = [[150.0, 108.88888888888886, 930.0, 11.111111111111114],
|
|
[138.8889, 119.9999, 11.1111, 960.0]]
|
|
for n in range(2):
|
|
targetbb = mtransforms.Bbox.from_bounds(*targets[n])
|
|
assert_allclose(
|
|
bbspines[n * 2].bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
fig, ax = plt.subplots(dpi=200, figsize=(6, 6))
|
|
fig.canvas.draw()
|
|
ax.tick_params(which='both', direction='out')
|
|
ax.minorticks_on()
|
|
ax.tick_params(axis='both', which='minor', length=30)
|
|
fig.canvas.draw()
|
|
bbaxis, bbspines, bbax, bbtb = color_boxes(fig, ax)
|
|
targets = [[150.0, 36.66666666666663, 930.0, 83.33333333333334],
|
|
[66.6667, 120.0, 83.3333, 960.0]]
|
|
|
|
for n in range(2):
|
|
targetbb = mtransforms.Bbox.from_bounds(*targets[n])
|
|
assert_allclose(
|
|
bbspines[n * 2].bounds, targetbb.bounds, atol=1e-2)
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_axis_bool_arguments(fig_test, fig_ref):
|
|
# Test if False and "off" give the same
|
|
fig_test.add_subplot(211).axis(False)
|
|
fig_ref.add_subplot(211).axis("off")
|
|
# Test if True after False gives the same as "on"
|
|
ax = fig_test.add_subplot(212)
|
|
ax.axis(False)
|
|
ax.axis(True)
|
|
fig_ref.add_subplot(212).axis("on")
|
|
|
|
|
|
def test_axis_extent_arg():
|
|
fig, ax = plt.subplots()
|
|
xmin = 5
|
|
xmax = 10
|
|
ymin = 15
|
|
ymax = 20
|
|
extent = ax.axis([xmin, xmax, ymin, ymax])
|
|
|
|
# test that the docstring is correct
|
|
assert tuple(extent) == (xmin, xmax, ymin, ymax)
|
|
|
|
# test that limits were set per the docstring
|
|
assert (xmin, xmax) == ax.get_xlim()
|
|
assert (ymin, ymax) == ax.get_ylim()
|
|
|
|
|
|
def test_datetime_masked():
|
|
# make sure that all-masked data falls back to the viewlim
|
|
# set in convert.axisinfo....
|
|
x = np.array([datetime.datetime(2017, 1, n) for n in range(1, 6)])
|
|
y = np.array([1, 2, 3, 4, 5])
|
|
m = np.ma.masked_greater(y, 0)
|
|
|
|
fig, ax = plt.subplots()
|
|
ax.plot(x, m)
|
|
dt = mdates.date2num(np.datetime64('0000-12-31'))
|
|
assert ax.get_xlim() == (730120.0 + dt, 733773.0 + dt)
|
|
|
|
|
|
def test_hist_auto_bins():
|
|
_, bins, _ = plt.hist([[1, 2, 3], [3, 4, 5, 6]], bins='auto')
|
|
assert bins[0] <= 1
|
|
assert bins[-1] >= 6
|
|
|
|
|
|
def test_hist_nan_data():
|
|
fig, (ax1, ax2) = plt.subplots(2)
|
|
|
|
data = [1, 2, 3]
|
|
nan_data = data + [np.nan]
|
|
|
|
bins, edges, _ = ax1.hist(data)
|
|
with np.errstate(invalid='ignore'):
|
|
nanbins, nanedges, _ = ax2.hist(nan_data)
|
|
|
|
np.testing.assert_allclose(bins, nanbins)
|
|
np.testing.assert_allclose(edges, nanedges)
|
|
|
|
|
|
def test_hist_range_and_density():
|
|
_, bins, _ = plt.hist(np.random.rand(10), "auto",
|
|
range=(0, 1), density=True)
|
|
assert bins[0] == 0
|
|
assert bins[-1] == 1
|
|
|
|
|
|
def test_bar_errbar_zorder():
|
|
# Check that the zorder of errorbars is always greater than the bar they
|
|
# are plotted on
|
|
fig, ax = plt.subplots()
|
|
x = [1, 2, 3]
|
|
barcont = ax.bar(x=x, height=x, yerr=x, capsize=5, zorder=3)
|
|
|
|
data_line, caplines, barlinecols = barcont.errorbar.lines
|
|
for bar in barcont.patches:
|
|
for capline in caplines:
|
|
assert capline.zorder > bar.zorder
|
|
for barlinecol in barlinecols:
|
|
assert barlinecol.zorder > bar.zorder
|
|
|
|
|
|
def test_set_ticks_inverted():
|
|
fig, ax = plt.subplots()
|
|
ax.invert_xaxis()
|
|
ax.set_xticks([.3, .7])
|
|
assert ax.get_xlim() == (1, 0)
|
|
|
|
|
|
def test_aspect_nonlinear_adjustable_box():
|
|
fig = plt.figure(figsize=(10, 10)) # Square.
|
|
|
|
ax = fig.add_subplot()
|
|
ax.plot([.4, .6], [.4, .6]) # Set minpos to keep logit happy.
|
|
ax.set(xscale="log", xlim=(1, 10),
|
|
yscale="logit", ylim=(1/11, 1/1001),
|
|
aspect=1, adjustable="box")
|
|
ax.margins(0)
|
|
pos = fig.transFigure.transform_bbox(ax.get_position())
|
|
assert pos.height / pos.width == pytest.approx(2)
|
|
|
|
|
|
def test_aspect_nonlinear_adjustable_datalim():
|
|
fig = plt.figure(figsize=(10, 10)) # Square.
|
|
|
|
ax = fig.add_axes([.1, .1, .8, .8]) # Square.
|
|
ax.plot([.4, .6], [.4, .6]) # Set minpos to keep logit happy.
|
|
ax.set(xscale="log", xlim=(1, 100),
|
|
yscale="logit", ylim=(1 / 101, 1 / 11),
|
|
aspect=1, adjustable="datalim")
|
|
ax.margins(0)
|
|
ax.apply_aspect()
|
|
|
|
assert ax.get_xlim() == pytest.approx([1*10**(1/2), 100/10**(1/2)])
|
|
assert ax.get_ylim() == (1 / 101, 1 / 11)
|
|
|
|
|
|
def test_box_aspect():
|
|
# Test if axes with box_aspect=1 has same dimensions
|
|
# as axes with aspect equal and adjustable="box"
|
|
|
|
fig1, ax1 = plt.subplots()
|
|
axtwin = ax1.twinx()
|
|
axtwin.plot([12, 344])
|
|
|
|
ax1.set_box_aspect(1)
|
|
|
|
fig2, ax2 = plt.subplots()
|
|
ax2.margins(0)
|
|
ax2.plot([0, 2], [6, 8])
|
|
ax2.set_aspect("equal", adjustable="box")
|
|
|
|
fig1.canvas.draw()
|
|
fig2.canvas.draw()
|
|
|
|
bb1 = ax1.get_position()
|
|
bbt = axtwin.get_position()
|
|
bb2 = ax2.get_position()
|
|
|
|
assert_array_equal(bb1.extents, bb2.extents)
|
|
assert_array_equal(bbt.extents, bb2.extents)
|
|
|
|
|
|
def test_box_aspect_custom_position():
|
|
# Test if axes with custom position and box_aspect
|
|
# behaves the same independent of the order of setting those.
|
|
|
|
fig1, ax1 = plt.subplots()
|
|
ax1.set_position([0.1, 0.1, 0.9, 0.2])
|
|
fig1.canvas.draw()
|
|
ax1.set_box_aspect(1.)
|
|
|
|
fig2, ax2 = plt.subplots()
|
|
ax2.set_box_aspect(1.)
|
|
fig2.canvas.draw()
|
|
ax2.set_position([0.1, 0.1, 0.9, 0.2])
|
|
|
|
fig1.canvas.draw()
|
|
fig2.canvas.draw()
|
|
|
|
bb1 = ax1.get_position()
|
|
bb2 = ax2.get_position()
|
|
|
|
assert_array_equal(bb1.extents, bb2.extents)
|
|
|
|
|
|
def test_bbox_aspect_axes_init():
|
|
# Test that box_aspect can be given to axes init and produces
|
|
# all equal square axes.
|
|
fig, axs = plt.subplots(2, 3, subplot_kw=dict(box_aspect=1),
|
|
constrained_layout=True)
|
|
fig.canvas.draw()
|
|
renderer = fig.canvas.get_renderer()
|
|
sizes = []
|
|
for ax in axs.flat:
|
|
bb = ax.get_window_extent(renderer)
|
|
sizes.extend([bb.width, bb.height])
|
|
|
|
assert_allclose(sizes, sizes[0])
|
|
|
|
|
|
def test_redraw_in_frame():
|
|
fig, ax = plt.subplots(1, 1)
|
|
ax.plot([1, 2, 3])
|
|
fig.canvas.draw()
|
|
ax.redraw_in_frame()
|
|
|
|
|
|
def test_invisible_axes():
|
|
# invisible axes should not respond to events...
|
|
fig, ax = plt.subplots()
|
|
assert fig.canvas.inaxes((200, 200)) is not None
|
|
ax.set_visible(False)
|
|
assert fig.canvas.inaxes((200, 200)) is None
|
|
|
|
|
|
def test_xtickcolor_is_not_markercolor():
|
|
plt.rcParams['lines.markeredgecolor'] = 'white'
|
|
ax = plt.axes()
|
|
ticks = ax.xaxis.get_major_ticks()
|
|
for tick in ticks:
|
|
assert tick.tick1line.get_markeredgecolor() != 'white'
|
|
|
|
|
|
def test_ytickcolor_is_not_markercolor():
|
|
plt.rcParams['lines.markeredgecolor'] = 'white'
|
|
ax = plt.axes()
|
|
ticks = ax.yaxis.get_major_ticks()
|
|
for tick in ticks:
|
|
assert tick.tick1line.get_markeredgecolor() != 'white'
|
|
|
|
|
|
@pytest.mark.parametrize('auto', (True, False, None))
|
|
def test_unautoscaley(auto):
|
|
fig, ax = plt.subplots()
|
|
x = np.arange(100)
|
|
y = np.linspace(-.1, .1, 100)
|
|
ax.scatter(x, y)
|
|
|
|
post_auto = ax.get_autoscaley_on() if auto is None else auto
|
|
|
|
ax.set_ylim((-.5, .5), auto=auto)
|
|
assert post_auto == ax.get_autoscaley_on()
|
|
fig.canvas.draw()
|
|
assert_array_equal(ax.get_ylim(), (-.5, .5))
|
|
|
|
|
|
@pytest.mark.parametrize('auto', (True, False, None))
|
|
def test_unautoscalex(auto):
|
|
fig, ax = plt.subplots()
|
|
x = np.arange(100)
|
|
y = np.linspace(-.1, .1, 100)
|
|
ax.scatter(y, x)
|
|
|
|
post_auto = ax.get_autoscalex_on() if auto is None else auto
|
|
|
|
ax.set_xlim((-.5, .5), auto=auto)
|
|
assert post_auto == ax.get_autoscalex_on()
|
|
fig.canvas.draw()
|
|
assert_array_equal(ax.get_xlim(), (-.5, .5))
|
|
|
|
|
|
@check_figures_equal(extensions=["png"])
|
|
def test_polar_interpolation_steps_variable_r(fig_test, fig_ref):
|
|
l, = fig_test.add_subplot(projection="polar").plot([0, np.pi/2], [1, 2])
|
|
l.get_path()._interpolation_steps = 100
|
|
fig_ref.add_subplot(projection="polar").plot(
|
|
np.linspace(0, np.pi/2, 101), np.linspace(1, 2, 101))
|
|
|
|
|
|
@pytest.mark.style('default')
|
|
def test_autoscale_tiny_sticky():
|
|
fig, ax = plt.subplots()
|
|
ax.bar(0, 1e-9)
|
|
fig.canvas.draw()
|
|
assert ax.get_ylim() == (0, 1.05e-9)
|
|
|
|
|
|
@pytest.mark.parametrize('size', [size for size in mfont_manager.font_scalings
|
|
if size is not None] + [8, 10, 12])
|
|
@pytest.mark.style('default')
|
|
def test_relative_ticklabel_sizes(size):
|
|
mpl.rcParams['xtick.labelsize'] = size
|
|
mpl.rcParams['ytick.labelsize'] = size
|
|
fig, ax = plt.subplots()
|
|
fig.canvas.draw()
|
|
|
|
for name, axis in zip(['x', 'y'], [ax.xaxis, ax.yaxis]):
|
|
for tick in axis.get_major_ticks():
|
|
assert tick.label1.get_size() == axis._get_tick_label_size(name)
|