import base64

import io

import platform

import numpy as np

from numpy.testing import assert_array_almost_equal, assert_array_equal

import pytest

from matplotlib.testing.decorators import (

check_figures_equal, image_comparison, remove_ticks_and_titles)

import matplotlib.pyplot as plt

from matplotlib import patches, transforms

from matplotlib.path import Path

# NOTE: All of these tests assume that path.simplify is set to True

# (the default)

@image_comparison(['clipping'], remove_text=True)

def test_clipping():

t = np.arange(0.0, 2.0, 0.01)

s = np.sin(2*np.pi*t)

fig, ax = plt.subplots()

ax.plot(t, s, linewidth=1.0)

ax.set_ylim((-0.20, -0.28))

@image_comparison(['overflow'], remove_text=True,

tol=0.007 if platform.machine() == 'arm64' else 0)

def test_overflow():

x = np.array([1.0, 2.0, 3.0, 2.0e5])

y = np.arange(len(x))

fig, ax = plt.subplots()

ax.plot(x, y)

ax.set_xlim(2, 6)

@image_comparison(['clipping_diamond'], remove_text=True)

def test_diamond():

x = np.array([0.0, 1.0, 0.0, -1.0, 0.0])

y = np.array([1.0, 0.0, -1.0, 0.0, 1.0])

fig, ax = plt.subplots()

ax.plot(x, y)

ax.set_xlim(-0.6, 0.6)

ax.set_ylim(-0.6, 0.6)

def test_clipping_out_of_bounds():

# Should work on a Path *without* codes.

path = Path([(0, 0), (1, 2), (2, 1)])

simplified = path.cleaned(clip=(10, 10, 20, 20))

assert_array_equal(simplified.vertices, [(0, 0)])

assert simplified.codes == [Path.STOP]

# Should work on a Path *with* codes, and no curves.

path = Path([(0, 0), (1, 2), (2, 1)],

[Path.MOVETO, Path.LINETO, Path.LINETO])

simplified = path.cleaned(clip=(10, 10, 20, 20))

assert_array_equal(simplified.vertices, [(0, 0)])

assert simplified.codes == [Path.STOP]

# A Path with curves does not do any clipping yet.

path = Path([(0, 0), (1, 2), (2, 3)],

[Path.MOVETO, Path.CURVE3, Path.CURVE3])

simplified = path.cleaned()

simplified_clipped = path.cleaned(clip=(10, 10, 20, 20))

assert_array_equal(simplified.vertices, simplified_clipped.vertices)

assert_array_equal(simplified.codes, simplified_clipped.codes)

def test_noise():

np.random.seed(0)

x = np.random.uniform(size=50000) * 50

fig, ax = plt.subplots()

p1 = ax.plot(x, solid_joinstyle='round', linewidth=2.0)

# Ensure that the path's transform takes the new axes limits into account.

fig.canvas.draw()

path = p1[0].get_path()

transform = p1[0].get_transform()

path = transform.transform_path(path)

simplified = path.cleaned(simplify=True)

assert simplified.vertices.size == 25512

def test_antiparallel_simplification():

def _get_simplified(x, y):

fig, ax = plt.subplots()

p1 = ax.plot(x, y)

path = p1[0].get_path()

transform = p1[0].get_transform()

path = transform.transform_path(path)

simplified = path.cleaned(simplify=True)

simplified = transform.inverted().transform_path(simplified)

return simplified

# test ending on a maximum

x = [0, 0, 0, 0, 0, 1]

y = [.5, 1, -1, 1, 2, .5]

simplified = _get_simplified(x, y)

assert_array_almost_equal([[0., 0.5],

[0., -1.],

[0., 2.],

[1., 0.5]],

simplified.vertices[:-2, :])

# test ending on a minimum

x = [0, 0, 0, 0, 0, 1]

y = [.5, 1, -1, 1, -2, .5]

simplified = _get_simplified(x, y)

assert_array_almost_equal([[0., 0.5],

[0., 1.],

[0., -2.],

[1., 0.5]],

simplified.vertices[:-2, :])

# test ending in between

x = [0, 0, 0, 0, 0, 1]

y = [.5, 1, -1, 1, 0, .5]

simplified = _get_simplified(x, y)

assert_array_almost_equal([[0., 0.5],

[0., 1.],

[0., -1.],

[0., 0.],

[1., 0.5]],

simplified.vertices[:-2, :])

# test no anti-parallel ending at max

x = [0, 0, 0, 0, 0, 1]

y = [.5, 1, 2, 1, 3, .5]

simplified = _get_simplified(x, y)

assert_array_almost_equal([[0., 0.5],

[0., 3.],

[1., 0.5]],

simplified.vertices[:-2, :])

# test no anti-parallel ending in middle

x = [0, 0, 0, 0, 0, 1]

y = [.5, 1, 2, 1, 1, .5]

simplified = _get_simplified(x, y)

assert_array_almost_equal([[0., 0.5],

[0., 2.],

[0., 1.],

[1., 0.5]],

simplified.vertices[:-2, :])

# Only consider angles in 0 <= angle <= pi/2, otherwise

# using min/max will get the expected results out of order:

# min/max for simplification code depends on original vector,

# and if angle is outside above range then simplification

# min/max will be opposite from actual min/max.

@pytest.mark.parametrize('angle', [0, np.pi/4, np.pi/3, np.pi/2])

@pytest.mark.parametrize('offset', [0, .5])

def test_angled_antiparallel(angle, offset):

scale = 5

np.random.seed(19680801)

# get 15 random offsets

# TODO: guarantee offset > 0 results in some offsets < 0

vert_offsets = (np.random.rand(15) - offset) * scale

# always start at 0 so rotation makes sense

vert_offsets[0] = 0

# always take the first step the same direction

vert_offsets[1] = 1

# compute points along a diagonal line

x = np.sin(angle) * vert_offsets

y = np.cos(angle) * vert_offsets

# will check these later

x_max = x[1:].max()

x_min = x[1:].min()

y_max = y[1:].max()

y_min = y[1:].min()

if offset > 0:

p_expected = Path([[0, 0],

[x_max, y_max],

[x_min, y_min],

[x[-1], y[-1]],

[0, 0]],

codes=[1, 2, 2, 2, 0])

else:

p_expected = Path([[0, 0],

[x_max, y_max],

[x[-1], y[-1]],

[0, 0]],

codes=[1, 2, 2, 0])

p = Path(np.vstack([x, y]).T)

p2 = p.cleaned(simplify=True)

assert_array_almost_equal(p_expected.vertices,

p2.vertices)

assert_array_equal(p_expected.codes, p2.codes)

def test_sine_plus_noise():

np.random.seed(0)

x = (np.sin(np.linspace(0, np.pi * 2.0, 50000)) +

np.random.uniform(size=50000) * 0.01)

fig, ax = plt.subplots()

p1 = ax.plot(x, solid_joinstyle='round', linewidth=2.0)

# Ensure that the path's transform takes the new axes limits into account.

fig.canvas.draw()

path = p1[0].get_path()

transform = p1[0].get_transform()

path = transform.transform_path(path)

simplified = path.cleaned(simplify=True)

assert simplified.vertices.size == 25240

@image_comparison(['simplify_curve'], remove_text=True, tol=0.017)

def test_simplify_curve():

pp1 = patches.PathPatch(

Path([(0, 0), (1, 0), (1, 1), (np.nan, 1), (0, 0), (2, 0), (2, 2),

(0, 0)],

[Path.MOVETO, Path.CURVE3, Path.CURVE3, Path.CURVE3, Path.CURVE3,

Path.CURVE3, Path.CURVE3, Path.CLOSEPOLY]),

fc="none")

fig, ax = plt.subplots()

ax.add_patch(pp1)

ax.set_xlim((0, 2))

ax.set_ylim((0, 2))

@check_figures_equal()

def test_closed_path_nan_removal(fig_test, fig_ref):

ax_test = fig_test.subplots(2, 2).flatten()

ax_ref = fig_ref.subplots(2, 2).flatten()

# NaN on the first point also removes the last point, because it's closed.

path = Path(

[[-3, np.nan], [3, -3], [3, 3], [-3, 3], [-3, -3]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])

ax_test[0].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-3, np.nan], [3, -3], [3, 3], [-3, 3], [-3, np.nan]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO])

ax_ref[0].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN on second-last point should not re-close.

path = Path(

[[-2, -2], [2, -2], [2, 2], [-2, np.nan], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])

ax_test[0].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-2, -2], [2, -2], [2, 2], [-2, np.nan], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO])

ax_ref[0].add_patch(patches.PathPatch(path, facecolor='none'))

# Test multiple loops in a single path (with same paths as above).

path = Path(

[[-3, np.nan], [3, -3], [3, 3], [-3, 3], [-3, -3],

[-2, -2], [2, -2], [2, 2], [-2, np.nan], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY,

Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.CLOSEPOLY])

ax_test[1].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-3, np.nan], [3, -3], [3, 3], [-3, 3], [-3, np.nan],

[-2, -2], [2, -2], [2, 2], [-2, np.nan], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO,

Path.MOVETO, Path.LINETO, Path.LINETO, Path.LINETO, Path.LINETO])

ax_ref[1].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN in first point of CURVE3 should not re-close, and hide entire curve.

path = Path(

[[-1, -1], [1, -1], [1, np.nan], [0, 1], [-1, 1], [-1, -1]],

[Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO,

Path.CLOSEPOLY])

ax_test[2].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-1, -1], [1, -1], [1, np.nan], [0, 1], [-1, 1], [-1, -1]],

[Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO,

Path.CLOSEPOLY])

ax_ref[2].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN in second point of CURVE3 should not re-close, and hide entire curve

# plus next line segment.

path = Path(

[[-3, -3], [3, -3], [3, 0], [0, np.nan], [-3, 3], [-3, -3]],

[Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO,

Path.LINETO])

ax_test[2].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-3, -3], [3, -3], [3, 0], [0, np.nan], [-3, 3], [-3, -3]],

[Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE3, Path.LINETO,

Path.LINETO])

ax_ref[2].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN in first point of CURVE4 should not re-close, and hide entire curve.

path = Path(

[[-1, -1], [1, -1], [1, np.nan], [0, 0], [0, 1], [-1, 1], [-1, -1]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.CLOSEPOLY])

ax_test[3].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-1, -1], [1, -1], [1, np.nan], [0, 0], [0, 1], [-1, 1], [-1, -1]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.CLOSEPOLY])

ax_ref[3].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN in second point of CURVE4 should not re-close, and hide entire curve.

path = Path(

[[-2, -2], [2, -2], [2, 0], [0, np.nan], [0, 2], [-2, 2], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.LINETO])

ax_test[3].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-2, -2], [2, -2], [2, 0], [0, np.nan], [0, 2], [-2, 2], [-2, -2]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.LINETO])

ax_ref[3].add_patch(patches.PathPatch(path, facecolor='none'))

# NaN in third point of CURVE4 should not re-close, and hide entire curve

# plus next line segment.

path = Path(

[[-3, -3], [3, -3], [3, 0], [0, 0], [0, np.nan], [-3, 3], [-3, -3]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.LINETO])

ax_test[3].add_patch(patches.PathPatch(path, facecolor='none'))

path = Path(

[[-3, -3], [3, -3], [3, 0], [0, 0], [0, np.nan], [-3, 3], [-3, -3]],

[Path.MOVETO, Path.LINETO, Path.CURVE4, Path.CURVE4, Path.CURVE4,

Path.LINETO, Path.LINETO])

ax_ref[3].add_patch(patches.PathPatch(path, facecolor='none'))

# Keep everything clean.

for ax in [*ax_test.flat, *ax_ref.flat]:

ax.set(xlim=(-3.5, 3.5), ylim=(-3.5, 3.5))

remove_ticks_and_titles(fig_test)

remove_ticks_and_titles(fig_ref)

@check_figures_equal()

def test_closed_path_clipping(fig_test, fig_ref):

vertices = []

for roll in range(8):

offset = 0.1 * roll + 0.1

# A U-like pattern.

pattern = [

[-0.5, 1.5], [-0.5, -0.5], [1.5, -0.5], [1.5, 1.5], # Outer square

# With a notch in the top.

[1 - offset / 2, 1.5], [1 - offset / 2, offset],

[offset / 2, offset], [offset / 2, 1.5],

]

# Place the initial/final point anywhere in/out of the clipping area.

pattern = np.roll(pattern, roll, axis=0)

pattern = np.concatenate((pattern, pattern[:1, :]))

vertices.append(pattern)

# Multiple subpaths are used here to ensure they aren't broken by closed

# loop clipping.

codes = np.full(len(vertices[0]), Path.LINETO)

codes[0] = Path.MOVETO

codes[-1] = Path.CLOSEPOLY

codes = np.tile(codes, len(vertices))

vertices = np.concatenate(vertices)

fig_test.set_size_inches((5, 5))

path = Path(vertices, codes)

fig_test.add_artist(patches.PathPatch(path, facecolor='none'))

# For reference, we draw the same thing, but unclosed by using a line to

# the last point only.

fig_ref.set_size_inches((5, 5))

codes = codes.copy()

codes[codes == Path.CLOSEPOLY] = Path.LINETO

path = Path(vertices, codes)

fig_ref.add_artist(patches.PathPatch(path, facecolor='none'))

@image_comparison(['hatch_simplify'], remove_text=True)

def test_hatch():

fig, ax = plt.subplots()

ax.add_patch(plt.Rectangle((0, 0), 1, 1, fill=False, hatch="/"))

ax.set_xlim((0.45, 0.55))

ax.set_ylim((0.45, 0.55))

@image_comparison(['fft_peaks'], remove_text=True)

def test_fft_peaks():

fig, ax = plt.subplots()

t = np.arange(65536)

p1 = ax.plot(abs(np.fft.fft(np.sin(2*np.pi*.01*t)*np.blackman(len(t)))))

# Ensure that the path's transform takes the new axes limits into account.

fig.canvas.draw()

path = p1[0].get_path()

transform = p1[0].get_transform()

path = transform.transform_path(path)

simplified = path.cleaned(simplify=True)

assert simplified.vertices.size == 36

def test_start_with_moveto():

# Should be entirely clipped away to a single MOVETO

data = b"""

ZwAAAAku+v9UAQAA+Tj6/z8CAADpQ/r/KAMAANlO+v8QBAAAyVn6//UEAAC6ZPr/2gUAAKpv+v+8

BgAAm3r6/50HAACLhfr/ewgAAHyQ+v9ZCQAAbZv6/zQKAABepvr/DgsAAE+x+v/lCwAAQLz6/7wM

AAAxx/r/kA0AACPS+v9jDgAAFN36/zQPAAAF6Pr/AxAAAPfy+v/QEAAA6f36/5wRAADbCPv/ZhIA

AMwT+/8uEwAAvh77//UTAACwKfv/uRQAAKM0+/98FQAAlT/7/z0WAACHSvv//RYAAHlV+/+7FwAA

bGD7/3cYAABea/v/MRkAAFF2+//pGQAARIH7/6AaAAA3jPv/VRsAACmX+/8JHAAAHKL7/7ocAAAP

rfv/ah0AAAO4+/8YHgAA9sL7/8QeAADpzfv/bx8AANzY+/8YIAAA0OP7/78gAADD7vv/ZCEAALf5

+/8IIgAAqwT8/6kiAACeD/z/SiMAAJIa/P/oIwAAhiX8/4QkAAB6MPz/HyUAAG47/P+4JQAAYkb8

/1AmAABWUfz/5SYAAEpc/P95JwAAPmf8/wsoAAAzcvz/nCgAACd9/P8qKQAAHIj8/7cpAAAQk/z/

QyoAAAWe/P/MKgAA+aj8/1QrAADus/z/2isAAOO+/P9eLAAA2Mn8/+AsAADM1Pz/YS0AAMHf/P/g

LQAAtur8/10uAACr9fz/2C4AAKEA/f9SLwAAlgv9/8ovAACLFv3/QDAAAIAh/f+1MAAAdSz9/ycx

AABrN/3/mDEAAGBC/f8IMgAAVk39/3UyAABLWP3/4TIAAEFj/f9LMwAANm79/7MzAAAsef3/GjQA

ACKE/f9+NAAAF4/9/+E0AAANmv3/QzUAAAOl/f+iNQAA+a/9/wA2AADvuv3/XDYAAOXF/f+2NgAA

29D9/w83AADR2/3/ZjcAAMfm/f+7NwAAvfH9/w44AACz/P3/XzgAAKkH/v+vOAAAnxL+//04AACW

Hf7/SjkAAIwo/v+UOQAAgjP+/905AAB5Pv7/JDoAAG9J/v9pOgAAZVT+/606AABcX/7/7zoAAFJq

/v8vOwAASXX+/207AAA/gP7/qjsAADaL/v/lOwAALZb+/x48AAAjof7/VTwAABqs/v+LPAAAELf+

/788AAAHwv7/8TwAAP7M/v8hPQAA9df+/1A9AADr4v7/fT0AAOLt/v+oPQAA2fj+/9E9AADQA///

+T0AAMYO//8fPgAAvRn//0M+AAC0JP//ZT4AAKsv//+GPgAAojr//6U+AACZRf//wj4AAJBQ///d

PgAAh1v///c+AAB+Zv//Dz8AAHRx//8lPwAAa3z//zk/AABih///TD8AAFmS//9dPwAAUJ3//2w/

AABHqP//ej8AAD6z//+FPwAANb7//48/AAAsyf//lz8AACPU//+ePwAAGt///6M/AAAR6v//pj8A

AAj1//+nPwAA/////w=="""

verts = np.frombuffer(base64.decodebytes(data), dtype='<i4')

verts = verts.reshape((len(verts) // 2, 2))

path = Path(verts)

segs = path.iter_segments(transforms.IdentityTransform(),

clip=(0.0, 0.0, 100.0, 100.0))

segs = list(segs)

assert len(segs) == 1

assert segs[0][1] == Path.MOVETO

def test_throw_rendering_complexity_exceeded():

plt.rcParams['path.simplify'] = False

xx = np.arange(2_000_000)

yy = np.random.rand(2_000_000)

yy[1000] = np.nan

fig, ax = plt.subplots()

ax.plot(xx, yy)

with pytest.raises(OverflowError):

fig.savefig(io.BytesIO())

@image_comparison(['clipper_edge'], remove_text=True)

def test_clipper():

dat = (0, 1, 0, 2, 0, 3, 0, 4, 0, 5)

fig = plt.figure(figsize=(2, 1))

fig.subplots_adjust(left=0, bottom=0, wspace=0, hspace=0)

ax = fig.add_axes((0, 0, 1.0, 1.0), ylim=(0, 5), autoscale_on=False)

ax.plot(dat)

ax.xaxis.set_major_locator(plt.MultipleLocator(1))

ax.yaxis.set_major_locator(plt.MultipleLocator(1))

ax.xaxis.set_ticks_position('bottom')

ax.yaxis.set_ticks_position('left')

ax.set_xlim(5, 9)

@image_comparison(['para_equal_perp'], remove_text=True)

def test_para_equal_perp():

x = np.array([0, 1, 2, 1, 0, -1, 0, 1] + [1] * 128)

y = np.array([1, 1, 2, 1, 0, -1, 0, 0] + [0] * 128)

fig, ax = plt.subplots()

ax.plot(x + 1, y + 1)

ax.plot(x + 1, y + 1, 'ro')

@image_comparison(['clipping_with_nans'])

def test_clipping_with_nans():

x = np.linspace(0, 3.14 * 2, 3000)

y = np.sin(x)

x[::100] = np.nan

fig, ax = plt.subplots()

ax.plot(x, y)

ax.set_ylim(-0.25, 0.25)

def test_clipping_full():

p = Path([[1e30, 1e30]] * 5)

simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))

assert simplified == []

p = Path([[50, 40], [75, 65]], [1, 2])

simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))

assert ([(list(x), y) for x, y in simplified] ==

[([50, 40], 1), ([75, 65], 2)])

p = Path([[50, 40]], [1])

simplified = list(p.iter_segments(clip=[0, 0, 100, 100]))

assert ([(list(x), y) for x, y in simplified] ==

[([50, 40], 1)])