238 lines
8.8 KiB
Python
238 lines
8.8 KiB
Python
import re
|
|
|
|
from matplotlib.testing import _check_for_pgf
|
|
from matplotlib.backend_bases import (
|
|
FigureCanvasBase, LocationEvent, MouseButton, MouseEvent,
|
|
NavigationToolbar2, RendererBase)
|
|
from matplotlib.backend_tools import (ToolZoom, ToolPan, RubberbandBase,
|
|
ToolViewsPositions, _views_positions)
|
|
from matplotlib.figure import Figure
|
|
import matplotlib.pyplot as plt
|
|
import matplotlib.transforms as transforms
|
|
import matplotlib.path as path
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
needs_xelatex = pytest.mark.skipif(not _check_for_pgf('xelatex'),
|
|
reason='xelatex + pgf is required')
|
|
|
|
|
|
def test_uses_per_path():
|
|
id = transforms.Affine2D()
|
|
paths = [path.Path.unit_regular_polygon(i) for i in range(3, 7)]
|
|
tforms_matrices = [id.rotate(i).get_matrix().copy() for i in range(1, 5)]
|
|
offsets = np.arange(20).reshape((10, 2))
|
|
facecolors = ['red', 'green']
|
|
edgecolors = ['red', 'green']
|
|
|
|
def check(master_transform, paths, all_transforms,
|
|
offsets, facecolors, edgecolors):
|
|
rb = RendererBase()
|
|
raw_paths = list(rb._iter_collection_raw_paths(
|
|
master_transform, paths, all_transforms))
|
|
gc = rb.new_gc()
|
|
ids = [path_id for xo, yo, path_id, gc0, rgbFace in
|
|
rb._iter_collection(
|
|
gc, master_transform, all_transforms,
|
|
range(len(raw_paths)), offsets,
|
|
transforms.AffineDeltaTransform(master_transform),
|
|
facecolors, edgecolors, [], [], [False],
|
|
[], 'screen')]
|
|
uses = rb._iter_collection_uses_per_path(
|
|
paths, all_transforms, offsets, facecolors, edgecolors)
|
|
if raw_paths:
|
|
seen = np.bincount(ids, minlength=len(raw_paths))
|
|
assert set(seen).issubset([uses - 1, uses])
|
|
|
|
check(id, paths, tforms_matrices, offsets, facecolors, edgecolors)
|
|
check(id, paths[0:1], tforms_matrices, offsets, facecolors, edgecolors)
|
|
check(id, [], tforms_matrices, offsets, facecolors, edgecolors)
|
|
check(id, paths, tforms_matrices[0:1], offsets, facecolors, edgecolors)
|
|
check(id, paths, [], offsets, facecolors, edgecolors)
|
|
for n in range(0, offsets.shape[0]):
|
|
check(id, paths, tforms_matrices, offsets[0:n, :],
|
|
facecolors, edgecolors)
|
|
check(id, paths, tforms_matrices, offsets, [], edgecolors)
|
|
check(id, paths, tforms_matrices, offsets, facecolors, [])
|
|
check(id, paths, tforms_matrices, offsets, [], [])
|
|
check(id, paths, tforms_matrices, offsets, facecolors[0:1], edgecolors)
|
|
|
|
|
|
def test_canvas_ctor():
|
|
assert isinstance(FigureCanvasBase().figure, Figure)
|
|
|
|
|
|
def test_get_default_filename():
|
|
assert plt.figure().canvas.get_default_filename() == 'image.png'
|
|
|
|
|
|
def test_canvas_change():
|
|
fig = plt.figure()
|
|
# Replaces fig.canvas
|
|
canvas = FigureCanvasBase(fig)
|
|
# Should still work.
|
|
plt.close(fig)
|
|
assert not plt.fignum_exists(fig.number)
|
|
|
|
|
|
@pytest.mark.backend('pdf')
|
|
def test_non_gui_warning(monkeypatch):
|
|
plt.subplots()
|
|
|
|
monkeypatch.setenv("DISPLAY", ":999")
|
|
|
|
with pytest.warns(UserWarning) as rec:
|
|
plt.show()
|
|
assert len(rec) == 1
|
|
assert ('Matplotlib is currently using pdf, which is a non-GUI backend'
|
|
in str(rec[0].message))
|
|
|
|
with pytest.warns(UserWarning) as rec:
|
|
plt.gcf().show()
|
|
assert len(rec) == 1
|
|
assert ('Matplotlib is currently using pdf, which is a non-GUI backend'
|
|
in str(rec[0].message))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"x, y", [(42, 24), (None, 42), (None, None), (200, 100.01), (205.75, 2.0)])
|
|
def test_location_event_position(x, y):
|
|
# LocationEvent should cast its x and y arguments to int unless it is None.
|
|
fig, ax = plt.subplots()
|
|
canvas = FigureCanvasBase(fig)
|
|
event = LocationEvent("test_event", canvas, x, y)
|
|
if x is None:
|
|
assert event.x is None
|
|
else:
|
|
assert event.x == int(x)
|
|
assert isinstance(event.x, int)
|
|
if y is None:
|
|
assert event.y is None
|
|
else:
|
|
assert event.y == int(y)
|
|
assert isinstance(event.y, int)
|
|
if x is not None and y is not None:
|
|
assert re.match(
|
|
"x={} +y={}".format(ax.format_xdata(x), ax.format_ydata(y)),
|
|
ax.format_coord(x, y))
|
|
ax.fmt_xdata = ax.fmt_ydata = lambda x: "foo"
|
|
assert re.match("x=foo +y=foo", ax.format_coord(x, y))
|
|
|
|
|
|
def test_pick():
|
|
fig = plt.figure()
|
|
fig.text(.5, .5, "hello", ha="center", va="center", picker=True)
|
|
fig.canvas.draw()
|
|
picks = []
|
|
fig.canvas.mpl_connect("pick_event", lambda event: picks.append(event))
|
|
start_event = MouseEvent(
|
|
"button_press_event", fig.canvas, *fig.transFigure.transform((.5, .5)),
|
|
MouseButton.LEFT)
|
|
fig.canvas.callbacks.process(start_event.name, start_event)
|
|
assert len(picks) == 1
|
|
|
|
|
|
def test_interactive_zoom():
|
|
fig, ax = plt.subplots()
|
|
ax.set(xscale="logit")
|
|
assert ax.get_navigate_mode() is None
|
|
|
|
tb = NavigationToolbar2(fig.canvas)
|
|
tb.zoom()
|
|
assert ax.get_navigate_mode() == 'ZOOM'
|
|
|
|
xlim0 = ax.get_xlim()
|
|
ylim0 = ax.get_ylim()
|
|
|
|
# Zoom from x=1e-6, y=0.1 to x=1-1e-5, 0.8 (data coordinates, "d").
|
|
d0 = (1e-6, 0.1)
|
|
d1 = (1-1e-5, 0.8)
|
|
# Convert to screen coordinates ("s"). Events are defined only with pixel
|
|
# precision, so round the pixel values, and below, check against the
|
|
# corresponding xdata/ydata, which are close but not equal to d0/d1.
|
|
s0 = ax.transData.transform(d0).astype(int)
|
|
s1 = ax.transData.transform(d1).astype(int)
|
|
|
|
# Zoom in.
|
|
start_event = MouseEvent(
|
|
"button_press_event", fig.canvas, *s0, MouseButton.LEFT)
|
|
fig.canvas.callbacks.process(start_event.name, start_event)
|
|
stop_event = MouseEvent(
|
|
"button_release_event", fig.canvas, *s1, MouseButton.LEFT)
|
|
fig.canvas.callbacks.process(stop_event.name, stop_event)
|
|
assert ax.get_xlim() == (start_event.xdata, stop_event.xdata)
|
|
assert ax.get_ylim() == (start_event.ydata, stop_event.ydata)
|
|
|
|
# Zoom out.
|
|
start_event = MouseEvent(
|
|
"button_press_event", fig.canvas, *s1, MouseButton.RIGHT)
|
|
fig.canvas.callbacks.process(start_event.name, start_event)
|
|
stop_event = MouseEvent(
|
|
"button_release_event", fig.canvas, *s0, MouseButton.RIGHT)
|
|
fig.canvas.callbacks.process(stop_event.name, stop_event)
|
|
# Absolute tolerance much less than original xmin (1e-7).
|
|
assert ax.get_xlim() == pytest.approx(xlim0, rel=0, abs=1e-10)
|
|
assert ax.get_ylim() == pytest.approx(ylim0, rel=0, abs=1e-10)
|
|
|
|
tb.zoom()
|
|
assert ax.get_navigate_mode() is None
|
|
|
|
|
|
def test_toolbar_zoompan():
|
|
expected_warning_regex = (
|
|
r"Treat the new Tool classes introduced in "
|
|
r"v[0-9]*.[0-9]* as experimental for now; "
|
|
"the API and rcParam may change in future versions.")
|
|
with pytest.warns(UserWarning, match=expected_warning_regex):
|
|
plt.rcParams['toolbar'] = 'toolmanager'
|
|
ax = plt.gca()
|
|
assert ax.get_navigate_mode() is None
|
|
ax.figure.canvas.manager.toolmanager.add_tool(name="zoom",
|
|
tool=ToolZoom)
|
|
ax.figure.canvas.manager.toolmanager.add_tool(name="pan",
|
|
tool=ToolPan)
|
|
ax.figure.canvas.manager.toolmanager.add_tool(name=_views_positions,
|
|
tool=ToolViewsPositions)
|
|
ax.figure.canvas.manager.toolmanager.add_tool(name='rubberband',
|
|
tool=RubberbandBase)
|
|
ax.figure.canvas.manager.toolmanager.trigger_tool('zoom')
|
|
assert ax.get_navigate_mode() == "ZOOM"
|
|
ax.figure.canvas.manager.toolmanager.trigger_tool('pan')
|
|
assert ax.get_navigate_mode() == "PAN"
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"backend", ['svg', 'ps', 'pdf', pytest.param('pgf', marks=needs_xelatex)]
|
|
)
|
|
def test_draw(backend):
|
|
from matplotlib.figure import Figure
|
|
from matplotlib.backends.backend_agg import FigureCanvas
|
|
test_backend = pytest.importorskip(
|
|
f'matplotlib.backends.backend_{backend}'
|
|
)
|
|
TestCanvas = test_backend.FigureCanvas
|
|
fig_test = Figure(constrained_layout=True)
|
|
TestCanvas(fig_test)
|
|
axes_test = fig_test.subplots(2, 2)
|
|
|
|
# defaults to FigureCanvasBase
|
|
fig_agg = Figure(constrained_layout=True)
|
|
# put a backends.backend_agg.FigureCanvas on it
|
|
FigureCanvas(fig_agg)
|
|
axes_agg = fig_agg.subplots(2, 2)
|
|
|
|
init_pos = [ax.get_position() for ax in axes_test.ravel()]
|
|
|
|
fig_test.canvas.draw()
|
|
fig_agg.canvas.draw()
|
|
|
|
layed_out_pos_test = [ax.get_position() for ax in axes_test.ravel()]
|
|
layed_out_pos_agg = [ax.get_position() for ax in axes_agg.ravel()]
|
|
|
|
for init, placed in zip(init_pos, layed_out_pos_test):
|
|
assert not np.allclose(init, placed, atol=0.005)
|
|
|
|
for ref, test in zip(layed_out_pos_agg, layed_out_pos_test):
|
|
np.testing.assert_allclose(ref, test, atol=0.005)
|