""" Tests specific to the patches module. """ import platform import numpy as np from numpy.testing import assert_almost_equal, assert_array_equal import pytest import matplotlib as mpl from matplotlib.patches import (Annulus, Ellipse, Patch, Polygon, Rectangle, FancyArrowPatch, FancyArrow, BoxStyle, Arc) from matplotlib.testing.decorators import image_comparison, check_figures_equal from matplotlib.transforms import Bbox import matplotlib.pyplot as plt from matplotlib import ( collections as mcollections, colors as mcolors, patches as mpatches, path as mpath, transforms as mtransforms, rcParams) def test_Polygon_close(): #: GitHub issue #1018 identified a bug in the Polygon handling #: of the closed attribute; the path was not getting closed #: when set_xy was used to set the vertices. # open set of vertices: xy = [[0, 0], [0, 1], [1, 1]] # closed set: xyclosed = xy + [[0, 0]] # start with open path and close it: p = Polygon(xy, closed=True) assert p.get_closed() assert_array_equal(p.get_xy(), xyclosed) p.set_xy(xy) assert_array_equal(p.get_xy(), xyclosed) # start with closed path and open it: p = Polygon(xyclosed, closed=False) assert_array_equal(p.get_xy(), xy) p.set_xy(xyclosed) assert_array_equal(p.get_xy(), xy) # start with open path and leave it open: p = Polygon(xy, closed=False) assert not p.get_closed() assert_array_equal(p.get_xy(), xy) p.set_xy(xy) assert_array_equal(p.get_xy(), xy) # start with closed path and leave it closed: p = Polygon(xyclosed, closed=True) assert_array_equal(p.get_xy(), xyclosed) p.set_xy(xyclosed) assert_array_equal(p.get_xy(), xyclosed) def test_corner_center(): loc = [10, 20] width = 1 height = 2 # Rectangle # No rotation corners = ((10, 20), (11, 20), (11, 22), (10, 22)) rect = Rectangle(loc, width, height) assert_array_equal(rect.get_corners(), corners) assert_array_equal(rect.get_center(), (10.5, 21)) # 90 deg rotation corners_rot = ((10, 20), (10, 21), (8, 21), (8, 20)) rect.set_angle(90) assert_array_equal(rect.get_corners(), corners_rot) assert_array_equal(rect.get_center(), (9, 20.5)) # Rotation not a multiple of 90 deg theta = 33 t = mtransforms.Affine2D().rotate_around(*loc, np.deg2rad(theta)) corners_rot = t.transform(corners) rect.set_angle(theta) assert_almost_equal(rect.get_corners(), corners_rot) # Ellipse loc = [loc[0] + width / 2, loc[1] + height / 2] ellipse = Ellipse(loc, width, height) # No rotation assert_array_equal(ellipse.get_corners(), corners) # 90 deg rotation corners_rot = ((11.5, 20.5), (11.5, 21.5), (9.5, 21.5), (9.5, 20.5)) ellipse.set_angle(90) assert_array_equal(ellipse.get_corners(), corners_rot) # Rotation shouldn't change ellipse center assert_array_equal(ellipse.get_center(), loc) # Rotation not a multiple of 90 deg theta = 33 t = mtransforms.Affine2D().rotate_around(*loc, np.deg2rad(theta)) corners_rot = t.transform(corners) ellipse.set_angle(theta) assert_almost_equal(ellipse.get_corners(), corners_rot) def test_ellipse_vertices(): # expect 0 for 0 ellipse width, height ellipse = Ellipse(xy=(0, 0), width=0, height=0, angle=0) assert_almost_equal( ellipse.get_vertices(), [(0.0, 0.0), (0.0, 0.0)], ) assert_almost_equal( ellipse.get_co_vertices(), [(0.0, 0.0), (0.0, 0.0)], ) ellipse = Ellipse(xy=(0, 0), width=2, height=1, angle=30) assert_almost_equal( ellipse.get_vertices(), [ ( ellipse.center[0] + ellipse.width / 4 * np.sqrt(3), ellipse.center[1] + ellipse.width / 4, ), ( ellipse.center[0] - ellipse.width / 4 * np.sqrt(3), ellipse.center[1] - ellipse.width / 4, ), ], ) assert_almost_equal( ellipse.get_co_vertices(), [ ( ellipse.center[0] - ellipse.height / 4, ellipse.center[1] + ellipse.height / 4 * np.sqrt(3), ), ( ellipse.center[0] + ellipse.height / 4, ellipse.center[1] - ellipse.height / 4 * np.sqrt(3), ), ], ) v1, v2 = np.array(ellipse.get_vertices()) np.testing.assert_almost_equal((v1 + v2) / 2, ellipse.center) v1, v2 = np.array(ellipse.get_co_vertices()) np.testing.assert_almost_equal((v1 + v2) / 2, ellipse.center) ellipse = Ellipse(xy=(2.252, -10.859), width=2.265, height=1.98, angle=68.78) v1, v2 = np.array(ellipse.get_vertices()) np.testing.assert_almost_equal((v1 + v2) / 2, ellipse.center) v1, v2 = np.array(ellipse.get_co_vertices()) np.testing.assert_almost_equal((v1 + v2) / 2, ellipse.center) def test_rotate_rect(): loc = np.asarray([1.0, 2.0]) width = 2 height = 3 angle = 30.0 # A rotated rectangle rect1 = Rectangle(loc, width, height, angle=angle) # A non-rotated rectangle rect2 = Rectangle(loc, width, height) # Set up an explicit rotation matrix (in radians) angle_rad = np.pi * angle / 180.0 rotation_matrix = np.array([[np.cos(angle_rad), -np.sin(angle_rad)], [np.sin(angle_rad), np.cos(angle_rad)]]) # Translate to origin, rotate each vertex, and then translate back new_verts = np.inner(rotation_matrix, rect2.get_verts() - loc).T + loc # They should be the same assert_almost_equal(rect1.get_verts(), new_verts) @check_figures_equal(extensions=['png']) def test_rotate_rect_draw(fig_test, fig_ref): ax_test = fig_test.add_subplot() ax_ref = fig_ref.add_subplot() loc = (0, 0) width, height = (1, 1) angle = 30 rect_ref = Rectangle(loc, width, height, angle=angle) ax_ref.add_patch(rect_ref) assert rect_ref.get_angle() == angle # Check that when the angle is updated after adding to an Axes, that the # patch is marked stale and redrawn in the correct location rect_test = Rectangle(loc, width, height) assert rect_test.get_angle() == 0 ax_test.add_patch(rect_test) rect_test.set_angle(angle) assert rect_test.get_angle() == angle @check_figures_equal(extensions=['png']) def test_dash_offset_patch_draw(fig_test, fig_ref): ax_test = fig_test.add_subplot() ax_ref = fig_ref.add_subplot() loc = (0.1, 0.1) width, height = (0.8, 0.8) rect_ref = Rectangle(loc, width, height, linewidth=3, edgecolor='b', linestyle=(0, [6, 6])) # fill the line gaps using a linestyle (0, [0, 6, 6, 0]), which is # equivalent to (6, [6, 6]) but has 0 dash offset rect_ref2 = Rectangle(loc, width, height, linewidth=3, edgecolor='r', linestyle=(0, [0, 6, 6, 0])) assert rect_ref.get_linestyle() == (0, [6, 6]) assert rect_ref2.get_linestyle() == (0, [0, 6, 6, 0]) ax_ref.add_patch(rect_ref) ax_ref.add_patch(rect_ref2) # Check that the dash offset of the rect is the same if we pass it in the # init method and if we create two rects with appropriate onoff sequence # of linestyle. rect_test = Rectangle(loc, width, height, linewidth=3, edgecolor='b', linestyle=(0, [6, 6])) rect_test2 = Rectangle(loc, width, height, linewidth=3, edgecolor='r', linestyle=(6, [6, 6])) assert rect_test.get_linestyle() == (0, [6, 6]) assert rect_test2.get_linestyle() == (6, [6, 6]) ax_test.add_patch(rect_test) ax_test.add_patch(rect_test2) def test_negative_rect(): # These two rectangles have the same vertices, but starting from a # different point. (We also drop the last vertex, which is a duplicate.) pos_vertices = Rectangle((-3, -2), 3, 2).get_verts()[:-1] neg_vertices = Rectangle((0, 0), -3, -2).get_verts()[:-1] assert_array_equal(np.roll(neg_vertices, 2, 0), pos_vertices) @image_comparison(['clip_to_bbox']) def test_clip_to_bbox(): fig, ax = plt.subplots() ax.set_xlim([-18, 20]) ax.set_ylim([-150, 100]) path = mpath.Path.unit_regular_star(8).deepcopy() path.vertices *= [10, 100] path.vertices -= [5, 25] path2 = mpath.Path.unit_circle().deepcopy() path2.vertices *= [10, 100] path2.vertices += [10, -25] combined = mpath.Path.make_compound_path(path, path2) patch = mpatches.PathPatch( combined, alpha=0.5, facecolor='coral', edgecolor='none') ax.add_patch(patch) bbox = mtransforms.Bbox([[-12, -77.5], [50, -110]]) result_path = combined.clip_to_bbox(bbox) result_patch = mpatches.PathPatch( result_path, alpha=0.5, facecolor='green', lw=4, edgecolor='black') ax.add_patch(result_patch) @image_comparison(['patch_alpha_coloring'], remove_text=True) def test_patch_alpha_coloring(): """ Test checks that the patch and collection are rendered with the specified alpha values in their facecolor and edgecolor. """ star = mpath.Path.unit_regular_star(6) circle = mpath.Path.unit_circle() # concatenate the star with an internal cutout of the circle verts = np.concatenate([circle.vertices, star.vertices[::-1]]) codes = np.concatenate([circle.codes, star.codes]) cut_star1 = mpath.Path(verts, codes) cut_star2 = mpath.Path(verts + 1, codes) ax = plt.axes() col = mcollections.PathCollection([cut_star2], linewidth=5, linestyles='dashdot', facecolor=(1, 0, 0, 0.5), edgecolor=(0, 0, 1, 0.75)) ax.add_collection(col) patch = mpatches.PathPatch(cut_star1, linewidth=5, linestyle='dashdot', facecolor=(1, 0, 0, 0.5), edgecolor=(0, 0, 1, 0.75)) ax.add_patch(patch) ax.set_xlim(-1, 2) ax.set_ylim(-1, 2) @image_comparison(['patch_alpha_override'], remove_text=True) def test_patch_alpha_override(): #: Test checks that specifying an alpha attribute for a patch or #: collection will override any alpha component of the facecolor #: or edgecolor. star = mpath.Path.unit_regular_star(6) circle = mpath.Path.unit_circle() # concatenate the star with an internal cutout of the circle verts = np.concatenate([circle.vertices, star.vertices[::-1]]) codes = np.concatenate([circle.codes, star.codes]) cut_star1 = mpath.Path(verts, codes) cut_star2 = mpath.Path(verts + 1, codes) ax = plt.axes() col = mcollections.PathCollection([cut_star2], linewidth=5, linestyles='dashdot', alpha=0.25, facecolor=(1, 0, 0, 0.5), edgecolor=(0, 0, 1, 0.75)) ax.add_collection(col) patch = mpatches.PathPatch(cut_star1, linewidth=5, linestyle='dashdot', alpha=0.25, facecolor=(1, 0, 0, 0.5), edgecolor=(0, 0, 1, 0.75)) ax.add_patch(patch) ax.set_xlim(-1, 2) ax.set_ylim(-1, 2) @mpl.style.context('default') def test_patch_color_none(): # Make sure the alpha kwarg does not override 'none' facecolor. # Addresses issue #7478. c = plt.Circle((0, 0), 1, facecolor='none', alpha=1) assert c.get_facecolor()[0] == 0 @image_comparison(['patch_custom_linestyle'], remove_text=True) def test_patch_custom_linestyle(): #: A test to check that patches and collections accept custom dash #: patterns as linestyle and that they display correctly. star = mpath.Path.unit_regular_star(6) circle = mpath.Path.unit_circle() # concatenate the star with an internal cutout of the circle verts = np.concatenate([circle.vertices, star.vertices[::-1]]) codes = np.concatenate([circle.codes, star.codes]) cut_star1 = mpath.Path(verts, codes) cut_star2 = mpath.Path(verts + 1, codes) ax = plt.axes() col = mcollections.PathCollection( [cut_star2], linewidth=5, linestyles=[(0, (5, 7, 10, 7))], facecolor=(1, 0, 0), edgecolor=(0, 0, 1)) ax.add_collection(col) patch = mpatches.PathPatch( cut_star1, linewidth=5, linestyle=(0, (5, 7, 10, 7)), facecolor=(1, 0, 0), edgecolor=(0, 0, 1)) ax.add_patch(patch) ax.set_xlim(-1, 2) ax.set_ylim(-1, 2) def test_patch_linestyle_accents(): #: Test if linestyle can also be specified with short mnemonics like "--" #: c.f. GitHub issue #2136 star = mpath.Path.unit_regular_star(6) circle = mpath.Path.unit_circle() # concatenate the star with an internal cutout of the circle verts = np.concatenate([circle.vertices, star.vertices[::-1]]) codes = np.concatenate([circle.codes, star.codes]) linestyles = ["-", "--", "-.", ":", "solid", "dashed", "dashdot", "dotted"] fig, ax = plt.subplots() for i, ls in enumerate(linestyles): star = mpath.Path(verts + i, codes) patch = mpatches.PathPatch(star, linewidth=3, linestyle=ls, facecolor=(1, 0, 0), edgecolor=(0, 0, 1)) ax.add_patch(patch) ax.set_xlim([-1, i + 1]) ax.set_ylim([-1, i + 1]) fig.canvas.draw() @check_figures_equal(extensions=['png']) def test_patch_linestyle_none(fig_test, fig_ref): circle = mpath.Path.unit_circle() ax_test = fig_test.add_subplot() ax_ref = fig_ref.add_subplot() for i, ls in enumerate(['none', 'None', ' ', '']): path = mpath.Path(circle.vertices + i, circle.codes) patch = mpatches.PathPatch(path, linewidth=3, linestyle=ls, facecolor=(1, 0, 0), edgecolor=(0, 0, 1)) ax_test.add_patch(patch) patch = mpatches.PathPatch(path, linewidth=3, linestyle='-', facecolor=(1, 0, 0), edgecolor='none') ax_ref.add_patch(patch) ax_test.set_xlim([-1, i + 1]) ax_test.set_ylim([-1, i + 1]) ax_ref.set_xlim([-1, i + 1]) ax_ref.set_ylim([-1, i + 1]) def test_wedge_movement(): param_dict = {'center': ((0, 0), (1, 1), 'set_center'), 'r': (5, 8, 'set_radius'), 'width': (2, 3, 'set_width'), 'theta1': (0, 30, 'set_theta1'), 'theta2': (45, 50, 'set_theta2')} init_args = {k: v[0] for k, v in param_dict.items()} w = mpatches.Wedge(**init_args) for attr, (old_v, new_v, func) in param_dict.items(): assert getattr(w, attr) == old_v getattr(w, func)(new_v) assert getattr(w, attr) == new_v @image_comparison(['wedge_range'], remove_text=True, tol=0.009 if platform.machine() == 'arm64' else 0) def test_wedge_range(): ax = plt.axes() t1 = 2.313869244286224 args = [[52.31386924, 232.31386924], [52.313869244286224, 232.31386924428622], [t1, t1 + 180.0], [0, 360], [90, 90 + 360], [-180, 180], [0, 380], [45, 46], [46, 45]] for i, (theta1, theta2) in enumerate(args): x = i % 3 y = i // 3 wedge = mpatches.Wedge((x * 3, y * 3), 1, theta1, theta2, facecolor='none', edgecolor='k', lw=3) ax.add_artist(wedge) ax.set_xlim(-2, 8) ax.set_ylim(-2, 9) def test_patch_str(): """ Check that patches have nice and working `str` representation. Note that the logic is that `__str__` is defined such that: str(eval(str(p))) == str(p) """ p = mpatches.Circle(xy=(1, 2), radius=3) assert str(p) == 'Circle(xy=(1, 2), radius=3)' p = mpatches.Ellipse(xy=(1, 2), width=3, height=4, angle=5) assert str(p) == 'Ellipse(xy=(1, 2), width=3, height=4, angle=5)' p = mpatches.Rectangle(xy=(1, 2), width=3, height=4, angle=5) assert str(p) == 'Rectangle(xy=(1, 2), width=3, height=4, angle=5)' p = mpatches.Wedge(center=(1, 2), r=3, theta1=4, theta2=5, width=6) assert str(p) == 'Wedge(center=(1, 2), r=3, theta1=4, theta2=5, width=6)' p = mpatches.Arc(xy=(1, 2), width=3, height=4, angle=5, theta1=6, theta2=7) expected = 'Arc(xy=(1, 2), width=3, height=4, angle=5, theta1=6, theta2=7)' assert str(p) == expected p = mpatches.Annulus(xy=(1, 2), r=(3, 4), width=1, angle=2) expected = "Annulus(xy=(1, 2), r=(3, 4), width=1, angle=2)" assert str(p) == expected p = mpatches.RegularPolygon((1, 2), 20, radius=5) assert str(p) == "RegularPolygon((1, 2), 20, radius=5, orientation=0)" p = mpatches.CirclePolygon(xy=(1, 2), radius=5, resolution=20) assert str(p) == "CirclePolygon((1, 2), radius=5, resolution=20)" p = mpatches.FancyBboxPatch((1, 2), width=3, height=4) assert str(p) == "FancyBboxPatch((1, 2), width=3, height=4)" # Further nice __str__ which cannot be `eval`uated: path = mpath.Path([(1, 2), (2, 2), (1, 2)], closed=True) p = mpatches.PathPatch(path) assert str(p) == "PathPatch3((1, 2) ...)" p = mpatches.Polygon(np.empty((0, 2))) assert str(p) == "Polygon0()" data = [[1, 2], [2, 2], [1, 2]] p = mpatches.Polygon(data) assert str(p) == "Polygon3((1, 2) ...)" p = mpatches.FancyArrowPatch(path=path) assert str(p)[:27] == "FancyArrowPatch(Path(array(" p = mpatches.FancyArrowPatch((1, 2), (3, 4)) assert str(p) == "FancyArrowPatch((1, 2)->(3, 4))" p = mpatches.ConnectionPatch((1, 2), (3, 4), 'data') assert str(p) == "ConnectionPatch((1, 2), (3, 4))" s = mpatches.Shadow(p, 1, 1) assert str(s) == "Shadow(ConnectionPatch((1, 2), (3, 4)))" # Not testing Arrow, FancyArrow here # because they seem to exist only for historical reasons. @image_comparison(['multi_color_hatch'], remove_text=True, style='default') def test_multi_color_hatch(): fig, ax = plt.subplots() rects = ax.bar(range(5), range(1, 6)) for i, rect in enumerate(rects): rect.set_facecolor('none') rect.set_edgecolor(f'C{i}') rect.set_hatch('/') ax.autoscale_view() ax.autoscale(False) for i in range(5): with mpl.style.context({'hatch.color': f'C{i}'}): r = Rectangle((i - .8 / 2, 5), .8, 1, hatch='//', fc='none') ax.add_patch(r) @image_comparison(['units_rectangle.png']) def test_units_rectangle(): import matplotlib.testing.jpl_units as U U.register() p = mpatches.Rectangle((5*U.km, 6*U.km), 1*U.km, 2*U.km) fig, ax = plt.subplots() ax.add_patch(p) ax.set_xlim([4*U.km, 7*U.km]) ax.set_ylim([5*U.km, 9*U.km]) @image_comparison(['connection_patch.png'], style='mpl20', remove_text=True, tol=0.024 if platform.machine() == 'arm64' else 0) def test_connection_patch(): fig, (ax1, ax2) = plt.subplots(1, 2) con = mpatches.ConnectionPatch(xyA=(0.1, 0.1), xyB=(0.9, 0.9), coordsA='data', coordsB='data', axesA=ax2, axesB=ax1, arrowstyle="->") ax2.add_artist(con) xyA = (0.6, 1.0) # in axes coordinates xyB = (0.0, 0.2) # x in axes coordinates, y in data coordinates coordsA = "axes fraction" coordsB = ax2.get_yaxis_transform() con = mpatches.ConnectionPatch(xyA=xyA, xyB=xyB, coordsA=coordsA, coordsB=coordsB, arrowstyle="-") ax2.add_artist(con) @check_figures_equal(extensions=["png"]) def test_connection_patch_fig(fig_test, fig_ref): # Test that connection patch can be added as figure artist, and that figure # pixels count negative values from the top right corner (this API may be # changed in the future). ax1, ax2 = fig_test.subplots(1, 2) con = mpatches.ConnectionPatch( xyA=(.3, .2), coordsA="data", axesA=ax1, xyB=(-30, -20), coordsB="figure pixels", arrowstyle="->", shrinkB=5) fig_test.add_artist(con) ax1, ax2 = fig_ref.subplots(1, 2) bb = fig_ref.bbox # Necessary so that pixel counts match on both sides. plt.rcParams["savefig.dpi"] = plt.rcParams["figure.dpi"] con = mpatches.ConnectionPatch( xyA=(.3, .2), coordsA="data", axesA=ax1, xyB=(bb.width - 30, bb.height - 20), coordsB="figure pixels", arrowstyle="->", shrinkB=5) fig_ref.add_artist(con) def test_datetime_rectangle(): # Check that creating a rectangle with timedeltas doesn't fail from datetime import datetime, timedelta start = datetime(2017, 1, 1, 0, 0, 0) delta = timedelta(seconds=16) patch = mpatches.Rectangle((start, 0), delta, 1) fig, ax = plt.subplots() ax.add_patch(patch) def test_datetime_datetime_fails(): from datetime import datetime start = datetime(2017, 1, 1, 0, 0, 0) dt_delta = datetime(1970, 1, 5) # Will be 5 days if units are done wrong. with pytest.raises(TypeError): mpatches.Rectangle((start, 0), dt_delta, 1) with pytest.raises(TypeError): mpatches.Rectangle((0, start), 1, dt_delta) def test_contains_point(): ell = mpatches.Ellipse((0.5, 0.5), 0.5, 1.0) points = [(0.0, 0.5), (0.2, 0.5), (0.25, 0.5), (0.5, 0.5)] path = ell.get_path() transform = ell.get_transform() radius = ell._process_radius(None) expected = np.array([path.contains_point(point, transform, radius) for point in points]) result = np.array([ell.contains_point(point) for point in points]) assert np.all(result == expected) def test_contains_points(): ell = mpatches.Ellipse((0.5, 0.5), 0.5, 1.0) points = [(0.0, 0.5), (0.2, 0.5), (0.25, 0.5), (0.5, 0.5)] path = ell.get_path() transform = ell.get_transform() radius = ell._process_radius(None) expected = path.contains_points(points, transform, radius) result = ell.contains_points(points) assert np.all(result == expected) # Currently fails with pdf/svg, probably because some parts assume a dpi of 72. @check_figures_equal(extensions=["png"]) def test_shadow(fig_test, fig_ref): xy = np.array([.2, .3]) dxy = np.array([.1, .2]) # We need to work around the nonsensical (dpi-dependent) interpretation of # offsets by the Shadow class... plt.rcParams["savefig.dpi"] = "figure" # Test image. a1 = fig_test.subplots() rect = mpatches.Rectangle(xy=xy, width=.5, height=.5) shadow = mpatches.Shadow(rect, ox=dxy[0], oy=dxy[1]) a1.add_patch(rect) a1.add_patch(shadow) # Reference image. a2 = fig_ref.subplots() rect = mpatches.Rectangle(xy=xy, width=.5, height=.5) shadow = mpatches.Rectangle( xy=xy + fig_ref.dpi / 72 * dxy, width=.5, height=.5, fc=np.asarray(mcolors.to_rgb(rect.get_facecolor())) * .3, ec=np.asarray(mcolors.to_rgb(rect.get_facecolor())) * .3, alpha=.5) a2.add_patch(shadow) a2.add_patch(rect) def test_fancyarrow_units(): from datetime import datetime # Smoke test to check that FancyArrowPatch works with units dtime = datetime(2000, 1, 1) fig, ax = plt.subplots() arrow = FancyArrowPatch((0, dtime), (0.01, dtime)) def test_fancyarrow_setdata(): fig, ax = plt.subplots() arrow = ax.arrow(0, 0, 10, 10, head_length=5, head_width=1, width=.5) expected1 = np.array( [[13.54, 13.54], [10.35, 9.65], [10.18, 9.82], [0.18, -0.18], [-0.18, 0.18], [9.82, 10.18], [9.65, 10.35], [13.54, 13.54]] ) assert np.allclose(expected1, np.round(arrow.verts, 2)) expected2 = np.array( [[16.71, 16.71], [16.71, 15.29], [16.71, 15.29], [1.71, 0.29], [0.29, 1.71], [15.29, 16.71], [15.29, 16.71], [16.71, 16.71]] ) arrow.set_data( x=1, y=1, dx=15, dy=15, width=2, head_width=2, head_length=1 ) assert np.allclose(expected2, np.round(arrow.verts, 2)) @image_comparison(["large_arc.svg"], style="mpl20") def test_large_arc(): fig, (ax1, ax2) = plt.subplots(1, 2) x = 210 y = -2115 diameter = 4261 for ax in [ax1, ax2]: a = Arc((x, y), diameter, diameter, lw=2, color='k') ax.add_patch(a) ax.set_axis_off() ax.set_aspect('equal') # force the high accuracy case ax1.set_xlim(7, 8) ax1.set_ylim(5, 6) # force the low accuracy case ax2.set_xlim(-25000, 18000) ax2.set_ylim(-20000, 6600) @image_comparison(["all_quadrants_arcs.svg"], style="mpl20") def test_rotated_arcs(): fig, ax_arr = plt.subplots(2, 2, squeeze=False, figsize=(10, 10)) scale = 10_000_000 diag_centers = ((-1, -1), (-1, 1), (1, 1), (1, -1)) on_axis_centers = ((0, 1), (1, 0), (0, -1), (-1, 0)) skews = ((2, 2), (2, 1/10), (2, 1/100), (2, 1/1000)) for ax, (sx, sy) in zip(ax_arr.ravel(), skews): k = 0 for prescale, centers in zip((1 - .0001, (1 - .0001) / np.sqrt(2)), (on_axis_centers, diag_centers)): for j, (x_sign, y_sign) in enumerate(centers, start=k): a = Arc( (x_sign * scale * prescale, y_sign * scale * prescale), scale * sx, scale * sy, lw=4, color=f"C{j}", zorder=1 + j, angle=np.rad2deg(np.arctan2(y_sign, x_sign)) % 360, label=f'big {j}', gid=f'big {j}' ) ax.add_patch(a) k = j+1 ax.set_xlim(-scale / 4000, scale / 4000) ax.set_ylim(-scale / 4000, scale / 4000) ax.axhline(0, color="k") ax.axvline(0, color="k") ax.set_axis_off() ax.set_aspect("equal") def test_fancyarrow_shape_error(): with pytest.raises(ValueError, match="Got unknown shape: 'foo'"): FancyArrow(0, 0, 0.2, 0.2, shape='foo') @pytest.mark.parametrize('fmt, match', ( ("foo", "Unknown style: 'foo'"), ("Round,foo", "Incorrect style argument: 'Round,foo'"), )) def test_boxstyle_errors(fmt, match): with pytest.raises(ValueError, match=match): BoxStyle(fmt) @image_comparison(baseline_images=['annulus'], extensions=['png']) def test_annulus(): fig, ax = plt.subplots() cir = Annulus((0.5, 0.5), 0.2, 0.05, fc='g') # circular annulus ell = Annulus((0.5, 0.5), (0.5, 0.3), 0.1, 45, # elliptical fc='m', ec='b', alpha=0.5, hatch='xxx') ax.add_patch(cir) ax.add_patch(ell) ax.set_aspect('equal') @image_comparison(baseline_images=['annulus'], extensions=['png']) def test_annulus_setters(): fig, ax = plt.subplots() cir = Annulus((0., 0.), 0.2, 0.01, fc='g') # circular annulus ell = Annulus((0., 0.), (1, 2), 0.1, 0, # elliptical fc='m', ec='b', alpha=0.5, hatch='xxx') ax.add_patch(cir) ax.add_patch(ell) ax.set_aspect('equal') cir.center = (0.5, 0.5) cir.radii = 0.2 cir.width = 0.05 ell.center = (0.5, 0.5) ell.radii = (0.5, 0.3) ell.width = 0.1 ell.angle = 45 @image_comparison(baseline_images=['annulus'], extensions=['png']) def test_annulus_setters2(): fig, ax = plt.subplots() cir = Annulus((0., 0.), 0.2, 0.01, fc='g') # circular annulus ell = Annulus((0., 0.), (1, 2), 0.1, 0, # elliptical fc='m', ec='b', alpha=0.5, hatch='xxx') ax.add_patch(cir) ax.add_patch(ell) ax.set_aspect('equal') cir.center = (0.5, 0.5) cir.set_semimajor(0.2) cir.set_semiminor(0.2) assert cir.radii == (0.2, 0.2) cir.width = 0.05 ell.center = (0.5, 0.5) ell.set_semimajor(0.5) ell.set_semiminor(0.3) assert ell.radii == (0.5, 0.3) ell.width = 0.1 ell.angle = 45 def test_degenerate_polygon(): point = [0, 0] correct_extents = Bbox([point, point]).extents assert np.all(Polygon([point]).get_extents().extents == correct_extents) @pytest.mark.parametrize('kwarg', ('edgecolor', 'facecolor')) def test_color_override_warning(kwarg): with pytest.warns(UserWarning, match="Setting the 'color' property will override " "the edgecolor or facecolor properties."): Patch(color='black', **{kwarg: 'black'}) def test_empty_verts(): poly = Polygon(np.zeros((0, 2))) assert poly.get_verts() == [] def test_default_antialiased(): patch = Patch() patch.set_antialiased(not rcParams['patch.antialiased']) assert patch.get_antialiased() == (not rcParams['patch.antialiased']) # Check that None resets the state patch.set_antialiased(None) assert patch.get_antialiased() == rcParams['patch.antialiased'] def test_default_linestyle(): patch = Patch() patch.set_linestyle('--') patch.set_linestyle(None) assert patch.get_linestyle() == 'solid' def test_default_capstyle(): patch = Patch() assert patch.get_capstyle() == 'butt' def test_default_joinstyle(): patch = Patch() assert patch.get_joinstyle() == 'miter' @image_comparison(["autoscale_arc"], extensions=['png', 'svg'], style="mpl20", remove_text=True) def test_autoscale_arc(): fig, axs = plt.subplots(1, 3, figsize=(4, 1)) arc_lists = ( [Arc((0, 0), 1, 1, theta1=0, theta2=90)], [Arc((0.5, 0.5), 1.5, 0.5, theta1=10, theta2=20)], [Arc((0.5, 0.5), 1.5, 0.5, theta1=10, theta2=20), Arc((0.5, 0.5), 2.5, 0.5, theta1=110, theta2=120), Arc((0.5, 0.5), 3.5, 0.5, theta1=210, theta2=220), Arc((0.5, 0.5), 4.5, 0.5, theta1=310, theta2=320)]) for ax, arcs in zip(axs, arc_lists): for arc in arcs: ax.add_patch(arc) ax.autoscale() @check_figures_equal(extensions=["png", 'svg', 'pdf', 'eps']) def test_arc_in_collection(fig_test, fig_ref): arc1 = Arc([.5, .5], .5, 1, theta1=0, theta2=60, angle=20) arc2 = Arc([.5, .5], .5, 1, theta1=0, theta2=60, angle=20) col = mcollections.PatchCollection(patches=[arc2], facecolors='none', edgecolors='k') fig_ref.subplots().add_patch(arc1) fig_test.subplots().add_collection(col) @check_figures_equal(extensions=["png", 'svg', 'pdf', 'eps']) def test_modifying_arc(fig_test, fig_ref): arc1 = Arc([.5, .5], .5, 1, theta1=0, theta2=60, angle=20) arc2 = Arc([.5, .5], 1.5, 1, theta1=0, theta2=60, angle=10) fig_ref.subplots().add_patch(arc1) fig_test.subplots().add_patch(arc2) arc2.set_width(.5) arc2.set_angle(20) def test_arrow_set_data(): fig, ax = plt.subplots() arrow = mpl.patches.Arrow(2, 0, 0, 10) expected1 = np.array( [[1.9, 0.], [2.1, -0.], [2.1, 8.], [2.3, 8.], [2., 10.], [1.7, 8.], [1.9, 8.], [1.9, 0.]] ) assert np.allclose(expected1, np.round(arrow.get_verts(), 2)) expected2 = np.array( [[0.39, 0.04], [0.61, -0.04], [3.01, 6.36], [3.24, 6.27], [3.5, 8.], [2.56, 6.53], [2.79, 6.44], [0.39, 0.04]] ) arrow.set_data(x=.5, dx=3, dy=8, width=1.2) assert np.allclose(expected2, np.round(arrow.get_verts(), 2))