from contextlib import ExitStack

import functools

import io

import os

from pathlib import Path

import platform

import sys

import urllib.request

import numpy as np

from numpy.testing import assert_allclose, assert_array_equal

from PIL import Image

import matplotlib as mpl

from matplotlib import (

colors, image as mimage, patches, pyplot as plt, style, rcParams)

from matplotlib.image import (AxesImage, BboxImage, FigureImage,

NonUniformImage, PcolorImage)

from matplotlib.patches import Rectangle

from matplotlib.testing.decorators import check_figures_equal, image_comparison

from matplotlib.transforms import Bbox, Affine2D, Transform, TransformedBbox

import matplotlib.ticker as mticker

import pytest

@pytest.fixture

def nonaffine_identity():

"""Non-affine identity transform for compositing with any affine transform"""

class NonAffineIdentityTransform(Transform):

input_dims = 2

output_dims = 2

def inverted(self):

return self

return NonAffineIdentityTransform()

@image_comparison(['interp_alpha.png'], remove_text=True)

def test_alpha_interp():

"""Test the interpolation of the alpha channel on RGBA images"""

fig, (axl, axr) = plt.subplots(1, 2)

# full green image

img = np.zeros((5, 5, 4))

img[..., 1] = np.ones((5, 5))

# transparent under main diagonal

img[..., 3] = np.tril(np.ones((5, 5), dtype=np.uint8))

axl.imshow(img, interpolation="none")

axr.imshow(img, interpolation="bilinear")

@image_comparison(['interp_nearest_vs_none'], tol=3.7, # For Ghostscript 10.06+.

extensions=['pdf', 'svg'], remove_text=True)

def test_interp_nearest_vs_none():

"""Test the effect of "nearest" and "none" interpolation"""

# Setting dpi to something really small makes the difference very

# visible. This works fine with pdf, since the dpi setting doesn't

# affect anything but images, but the agg output becomes unusably

# small.

rcParams['savefig.dpi'] = 3

X = np.array([[[218, 165, 32], [122, 103, 238]],

[[127, 255, 0], [255, 99, 71]]], dtype=np.uint8)

fig, (ax1, ax2) = plt.subplots(1, 2)

ax1.imshow(X, interpolation='none')

ax1.set_title('interpolation none')

ax2.imshow(X, interpolation='nearest')

ax2.set_title('interpolation nearest')

@pytest.mark.parametrize('suppressComposite', [False, True])

@image_comparison(['figimage'], extensions=['png', 'pdf'])

def test_figimage(suppressComposite):

fig = plt.figure(figsize=(2, 2), dpi=100)

fig.suppressComposite = suppressComposite

x, y = np.ix_(np.arange(100) / 100.0, np.arange(100) / 100)

z = np.sin(x**2 + y**2 - x*y)

c = np.sin(20*x**2 + 50*y**2)

img = z + c/5

fig.figimage(img, xo=0, yo=0, origin='lower')

fig.figimage(img[::-1, :], xo=0, yo=100, origin='lower')

fig.figimage(img[:, ::-1], xo=100, yo=0, origin='lower')

fig.figimage(img[::-1, ::-1], xo=100, yo=100, origin='lower')

def test_image_python_io():

fig, ax = plt.subplots()

ax.plot([1, 2, 3])

buffer = io.BytesIO()

fig.savefig(buffer)

buffer.seek(0)

plt.imread(buffer)

@pytest.mark.parametrize(

"img_size, fig_size, interpolation",

[(5, 2, "hanning"), # data larger than figure.

(5, 5, "nearest"), # exact resample.

(5, 10, "nearest"), # double sample.

(3, 2.9, "hanning"), # <3 upsample.

(3, 9.1, "nearest"), # >3 upsample.

])

@check_figures_equal()

def test_imshow_antialiased(fig_test, fig_ref,

img_size, fig_size, interpolation):

np.random.seed(19680801)

dpi = plt.rcParams["savefig.dpi"]

A = np.random.rand(int(dpi * img_size), int(dpi * img_size))

for fig in [fig_test, fig_ref]:

fig.set_size_inches(fig_size, fig_size)

ax = fig_test.subplots()

ax.set_position([0, 0, 1, 1])

ax.imshow(A, interpolation='auto')

ax = fig_ref.subplots()

ax.set_position([0, 0, 1, 1])

ax.imshow(A, interpolation=interpolation)

@check_figures_equal()

def test_imshow_zoom(fig_test, fig_ref):

# should be less than 3 upsample, so should be nearest...

np.random.seed(19680801)

dpi = plt.rcParams["savefig.dpi"]

A = np.random.rand(int(dpi * 3), int(dpi * 3))

for fig in [fig_test, fig_ref]:

fig.set_size_inches(2.9, 2.9)

ax = fig_test.subplots()

ax.imshow(A, interpolation='auto')

ax.set_xlim(10, 20)

ax.set_ylim(10, 20)

ax = fig_ref.subplots()

ax.imshow(A, interpolation='nearest')

ax.set_xlim(10, 20)

ax.set_ylim(10, 20)

@check_figures_equal()

def test_imshow_pil(fig_test, fig_ref):

style.use("default")

png_path = Path(__file__).parent / "baseline_images/pngsuite/basn3p04.png"

tiff_path = Path(__file__).parent / "baseline_images/test_image/uint16.tif"

axs = fig_test.subplots(2)

axs[0].imshow(Image.open(png_path))

axs[1].imshow(Image.open(tiff_path))

axs = fig_ref.subplots(2)

axs[0].imshow(plt.imread(png_path))

axs[1].imshow(plt.imread(tiff_path))

def test_imread_pil_uint16():

img = plt.imread(os.path.join(os.path.dirname(__file__),

'baseline_images', 'test_image', 'uint16.tif'))

assert img.dtype == np.uint16

assert np.sum(img) == 134184960

def test_imread_fspath():

img = plt.imread(

Path(__file__).parent / 'baseline_images/test_image/uint16.tif')

assert img.dtype == np.uint16

assert np.sum(img) == 134184960

@pytest.mark.parametrize("fmt", ["png", "jpg", "jpeg", "tiff"])

def test_imsave(fmt):

has_alpha = fmt not in ["jpg", "jpeg"]

# The goal here is that the user can specify an output logical DPI

# for the image, but this will not actually add any extra pixels

# to the image, it will merely be used for metadata purposes.

# So we do the traditional case (dpi == 1), and the new case (dpi

# == 100) and read the resulting PNG files back in and make sure

# the data is 100% identical.

np.random.seed(1)

# The height of 1856 pixels was selected because going through creating an

# actual dpi=100 figure to save the image to a Pillow-provided format would

# cause a rounding error resulting in a final image of shape 1855.

data = np.random.rand(1856, 2)

buff_dpi1 = io.BytesIO()

plt.imsave(buff_dpi1, data, format=fmt, dpi=1)

buff_dpi100 = io.BytesIO()

plt.imsave(buff_dpi100, data, format=fmt, dpi=100)

buff_dpi1.seek(0)

arr_dpi1 = plt.imread(buff_dpi1, format=fmt)

buff_dpi100.seek(0)

arr_dpi100 = plt.imread(buff_dpi100, format=fmt)

assert arr_dpi1.shape == (1856, 2, 3 + has_alpha)

assert arr_dpi100.shape == (1856, 2, 3 + has_alpha)

assert_array_equal(arr_dpi1, arr_dpi100)

def test_imsave_python_sequences():

# Tests saving an image with data passed using Python sequence types

# such as lists or tuples.

# RGB image: 3 rows × 2 columns, with float values in [0.0, 1.0]

img_data = [

[(1.0, 0.0, 0.0), (0.0, 1.0, 0.0)],

[(0.0, 0.0, 1.0), (1.0, 1.0, 0.0)],

[(0.0, 1.0, 1.0), (1.0, 0.0, 1.0)],

]

buff = io.BytesIO()

plt.imsave(buff, img_data, format="png")

buff.seek(0)

read_img = plt.imread(buff)

assert_array_equal(

np.array(img_data),

read_img[:, :, :3] # Drop alpha if present

)

@pytest.mark.parametrize("origin", ["upper", "lower"])

def test_imsave_rgba_origin(origin):

# test that imsave always passes c-contiguous arrays down to pillow

buf = io.BytesIO()

result = np.zeros((10, 10, 4), dtype='uint8')

mimage.imsave(buf, arr=result, format="png", origin=origin)

@pytest.mark.parametrize("fmt", ["png", "pdf", "ps", "eps", "svg"])

def test_imsave_fspath(fmt, tmp_path):

plt.imsave(tmp_path / f'unused.{fmt}', np.array([[0, 1]]), format=fmt)

def test_imsave_color_alpha():

# Test that imsave accept arrays with ndim=3 where the third dimension is

# color and alpha without raising any exceptions, and that the data is

# acceptably preserved through a save/read roundtrip.

np.random.seed(1)

for origin in ['lower', 'upper']:

data = np.random.rand(16, 16, 4)

buff = io.BytesIO()

plt.imsave(buff, data, origin=origin, format="png")

buff.seek(0)

arr_buf = plt.imread(buff)

# Recreate the float -> uint8 conversion of the data

# We can only expect to be the same with 8 bits of precision,

# since that's what the PNG file used.

data = (255*data).astype('uint8')

if origin == 'lower':

data = data[::-1]

arr_buf = (255*arr_buf).astype('uint8')

assert_array_equal(data, arr_buf)

def test_imsave_pil_kwargs_png():

from PIL.PngImagePlugin import PngInfo

buf = io.BytesIO()

pnginfo = PngInfo()

pnginfo.add_text("Software", "test")

plt.imsave(buf, [[0, 1], [2, 3]],

format="png", pil_kwargs={"pnginfo": pnginfo})

im = Image.open(buf)

assert im.info["Software"] == "test"

def test_imsave_pil_kwargs_tiff():

from PIL.TiffTags import TAGS_V2 as TAGS

buf = io.BytesIO()

pil_kwargs = {"description": "test image"}

plt.imsave(buf, [[0, 1], [2, 3]], format="tiff", pil_kwargs=pil_kwargs)

assert len(pil_kwargs) == 1

im = Image.open(buf)

tags = {TAGS[k].name: v for k, v in im.tag_v2.items()}

assert tags["ImageDescription"] == "test image"

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

def test_image_alpha():

np.random.seed(0)

Z = np.random.rand(6, 6)

fig, (ax1, ax2, ax3) = plt.subplots(1, 3)

ax1.imshow(Z, alpha=1.0, interpolation='none')

ax2.imshow(Z, alpha=0.5, interpolation='none')

ax3.imshow(Z, alpha=0.5, interpolation='nearest')

@mpl.style.context('mpl20')

@check_figures_equal()

def test_imshow_alpha(fig_test, fig_ref):

np.random.seed(19680801)

rgbf = np.random.rand(6, 6, 3).astype(np.float32)

rgbu = np.uint8(rgbf * 255)

((ax0, ax1), (ax2, ax3)) = fig_test.subplots(2, 2)

ax0.imshow(rgbf, alpha=0.5)

ax1.imshow(rgbf, alpha=0.75)

ax2.imshow(rgbu, alpha=127/255)

ax3.imshow(rgbu, alpha=191/255)

rgbaf = np.concatenate((rgbf, np.ones((6, 6, 1))), axis=2).astype(np.float32)

rgbau = np.concatenate((rgbu, np.full((6, 6, 1), 255, np.uint8)), axis=2)

((ax0, ax1), (ax2, ax3)) = fig_ref.subplots(2, 2)

rgbaf[:, :, 3] = 0.5

ax0.imshow(rgbaf)

rgbaf[:, :, 3] = 0.75

ax1.imshow(rgbaf)

rgbau[:, :, 3] = 127

ax2.imshow(rgbau)

rgbau[:, :, 3] = 191

ax3.imshow(rgbau)

@pytest.mark.parametrize('n_channels, is_int, alpha_arr, opaque',

[(3, False, False, False), # RGB float

(4, False, False, False), # RGBA float

(4, False, True, False), # RGBA float with alpha array

(4, False, False, True), # RGBA float with solid color

(4, True, False, False)]) # RGBA unint8

def test_imshow_multi_draw(n_channels, is_int, alpha_arr, opaque):

if is_int:

array = np.random.randint(0, 256, (2, 2, n_channels))

else:

array = np.random.random((2, 2, n_channels))

if opaque:

array[:, :, 3] = 1

if alpha_arr:

alpha = np.array([[0.3, 0.5], [1, 0.8]])

else:

alpha = None

fig, ax = plt.subplots()

im = ax.imshow(array, alpha=alpha)

fig.draw_without_rendering()

# Draw should not modify original array

np.testing.assert_array_equal(array, im._A)

def test_cursor_data():

from matplotlib.backend_bases import MouseEvent

fig, ax = plt.subplots()

im = ax.imshow(np.arange(100).reshape(10, 10), origin='upper')

x, y = 4, 4

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) == 44

# Now try for a point outside the image

# Tests issue #4957

x, y = 10.1, 4

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) is None

# Hmm, something is wrong here... I get 0, not None...

# But, this works further down in the tests with extents flipped

# x, y = 0.1, -0.1

# xdisp, ydisp = ax.transData.transform([x, y])

# event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

# z = im.get_cursor_data(event)

# assert z is None, "Did not get None, got %d" % z

ax.clear()

# Now try with the extents flipped.

im = ax.imshow(np.arange(100).reshape(10, 10), origin='lower')

x, y = 4, 4

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) == 44

fig, ax = plt.subplots()

im = ax.imshow(np.arange(100).reshape(10, 10), extent=[0, 0.5, 0, 0.5])

x, y = 0.25, 0.25

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) == 55

# Now try for a point outside the image

# Tests issue #4957

x, y = 0.75, 0.25

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) is None

x, y = 0.01, -0.01

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) is None

# Now try with additional transform applied to the image artist

trans = Affine2D().scale(2).rotate(0.5)

im = ax.imshow(np.arange(100).reshape(10, 10),

transform=trans + ax.transData)

x, y = 3, 10

xdisp, ydisp = ax.transData.transform([x, y])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) == 44

@pytest.mark.parametrize("xy, data", [

# x/y coords chosen to be 0.5 above boundaries so they lie within image pixels

[[0.5, 0.5], 0 + 0],

[[0.5, 1.5], 0 + 1],

[[4.5, 0.5], 16 + 0],

[[8.5, 0.5], 16 + 0],

[[9.5, 2.5], 81 + 4],

[[-1, 0.5], None],

[[0.5, -1], None],

]

)

def test_cursor_data_nonuniform(xy, data):

from matplotlib.backend_bases import MouseEvent

# Non-linear set of x-values

x = np.array([0, 1, 4, 9, 16])

y = np.array([0, 1, 2, 3, 4])

z = x[np.newaxis, :]**2 + y[:, np.newaxis]**2

fig, ax = plt.subplots()

im = NonUniformImage(ax, extent=(x.min(), x.max(), y.min(), y.max()))

im.set_data(x, y, z)

ax.add_image(im)

# Set lower min lim so we can test cursor outside image

ax.set_xlim(x.min() - 2, x.max())

ax.set_ylim(y.min() - 2, y.max())

xdisp, ydisp = ax.transData.transform(xy)

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.get_cursor_data(event) == data, (im.get_cursor_data(event), data)

@pytest.mark.parametrize(

"data, text", [

([[10001, 10000]], "[10001.000]"),

([[.123, .987]], "[0.123]"),

([[np.nan, 1, 2]], "[]"),

([[1, 1+1e-15]], "[1.0000000000000000]"),

([[-1, -1]], "[-1.0]"),

([[0, 0]], "[0.00]"),

])

def test_format_cursor_data(data, text):

from matplotlib.backend_bases import MouseEvent

fig, ax = plt.subplots()

im = ax.imshow(data)

xdisp, ydisp = ax.transData.transform([0, 0])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.format_cursor_data(im.get_cursor_data(event)) == text

@pytest.mark.parametrize(

"data, text", [

([[[10001, 10000]], [[0, 0]]], "[10001.000, 0.000]"),

([[[.123, .987]], [[0.1, 0]]], "[0.123, 0.100]"),

([[[np.nan, 1, 2]], [[0, 0, 0]]], "[]"),

])

def test_format_cursor_data_multinorm(data, text):

from matplotlib.backend_bases import MouseEvent

fig, ax = plt.subplots()

cmap_bivar = mpl.bivar_colormaps['BiOrangeBlue']

cmap_multivar = mpl.multivar_colormaps['2VarAddA']

# This is a test for ColorizingArtist._format_cursor_data_override()

# with data with multiple channels.

# It includes a workaround so that we can test this functionality

# before the MultiVar/BiVariate colormaps and MultiNorm are exposed

# via the top-level methods (ax.imshow())

# i.e. we here set the hidden variables _cmap and _norm

# and use set_array() on the ColorizingArtist rather than the _ImageBase

# but this workaround should be replaced by:

# `ax.imshow(data, cmap=cmap_bivar, vmin=(0,0), vmax=(1,1))`

# once the functionality is available.

# see https://github.com/matplotlib/matplotlib/issues/14168

im = ax.imshow([[0, 1]])

im.colorizer._cmap = cmap_bivar

im.colorizer._norm = colors.MultiNorm([im.norm, im.norm])

mpl.colorizer.ColorizingArtist.set_array(im, data)

xdisp, ydisp = ax.transData.transform([0, 0])

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.format_cursor_data(im.get_cursor_data(event)) == text

im.colorizer._cmap = cmap_multivar

event = MouseEvent('motion_notify_event', fig.canvas, xdisp, ydisp)

assert im.format_cursor_data(im.get_cursor_data(event)) == text

@image_comparison(['image_clip'], style='mpl20')

def test_image_clip():

d = [[1, 2], [3, 4]]

fig, ax = plt.subplots()

im = ax.imshow(d)

patch = patches.Circle((0, 0), radius=1, transform=ax.transData)

im.set_clip_path(patch)

@image_comparison(['image_cliprect'], style='mpl20')

def test_image_cliprect():

fig, ax = plt.subplots()

d = [[1, 2], [3, 4]]

im = ax.imshow(d, extent=(0, 5, 0, 5))

rect = patches.Rectangle(

xy=(1, 1), width=2, height=2, transform=im.axes.transData)

im.set_clip_path(rect)

@check_figures_equal()

def test_imshow_10_10_1(fig_test, fig_ref):

# 10x10x1 should be the same as 10x10

arr = np.arange(100).reshape((10, 10, 1))

ax = fig_ref.subplots()

ax.imshow(arr[:, :, 0], interpolation="bilinear", extent=(1, 2, 1, 2))

ax.set_xlim(0, 3)

ax.set_ylim(0, 3)

ax = fig_test.subplots()

ax.imshow(arr, interpolation="bilinear", extent=(1, 2, 1, 2))

ax.set_xlim(0, 3)

ax.set_ylim(0, 3)

def test_imshow_10_10_2():

fig, ax = plt.subplots()

arr = np.arange(200).reshape((10, 10, 2))

with pytest.raises(TypeError):

ax.imshow(arr)

def test_imshow_10_10_5():

fig, ax = plt.subplots()

arr = np.arange(500).reshape((10, 10, 5))

with pytest.raises(TypeError):

ax.imshow(arr)

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

def test_no_interpolation_origin():

fig, axs = plt.subplots(2)

axs[0].imshow(np.arange(100).reshape((2, 50)), origin="lower",

interpolation='none')

axs[1].imshow(np.arange(100).reshape((2, 50)), interpolation='none')

@image_comparison(['image_shift'], remove_text=True, extensions=['pdf', 'svg'])

def test_image_shift():

imgData = [[1 / x + 1 / y for x in range(1, 100)] for y in range(1, 100)]

tMin = 734717.945208

tMax = 734717.946366

fig, ax = plt.subplots()

ax.imshow(imgData, norm=colors.LogNorm(), interpolation='none',

extent=(tMin, tMax, 1, 100))

ax.set_aspect('auto')

def test_image_edges():

fig = plt.figure(figsize=[1, 1])

ax = fig.add_axes((0, 0, 1, 1), frameon=False)

data = np.tile(np.arange(12), 15).reshape(20, 9)

im = ax.imshow(data, origin='upper', extent=[-10, 10, -10, 10],

interpolation='none', cmap='gray')

x = y = 2

ax.set_xlim(-x, x)

ax.set_ylim(-y, y)

ax.set_xticks([])

ax.set_yticks([])

buf = io.BytesIO()

fig.savefig(buf, facecolor=(0, 1, 0))

buf.seek(0)

im = plt.imread(buf)

r, g, b, a = sum(im[:, 0])

r, g, b, a = sum(im[:, -1])

assert g != 100, 'Expected a non-green edge - but sadly, it was.'

@image_comparison(['image_composite_background'],

remove_text=True, style='mpl20')

def test_image_composite_background():

fig, ax = plt.subplots()

arr = np.arange(12).reshape(4, 3)

ax.imshow(arr, extent=[0, 2, 15, 0])

ax.imshow(arr, extent=[4, 6, 15, 0])

ax.set_facecolor((1, 0, 0, 0.5))

ax.set_xlim(0, 12)

@image_comparison(['image_composite_alpha'], remove_text=True, tol=0.07)

def test_image_composite_alpha():

"""

Tests that the alpha value is recognized and correctly applied in the

process of compositing images together.

"""

fig, ax = plt.subplots()

arr = np.zeros((11, 21, 4))

arr[:, :, 0] = 1

arr[:, :, 3] = np.concatenate(

(np.arange(0, 1.1, 0.1), np.arange(0, 1, 0.1)[::-1]))

arr2 = np.zeros((21, 11, 4))

arr2[:, :, 0] = 1

arr2[:, :, 1] = 1

arr2[:, :, 3] = np.concatenate(

(np.arange(0, 1.1, 0.1), np.arange(0, 1, 0.1)[::-1]))[:, np.newaxis]

ax.imshow(arr, extent=[1, 2, 5, 0], alpha=0.3)

ax.imshow(arr, extent=[2, 3, 5, 0], alpha=0.6)

ax.imshow(arr, extent=[3, 4, 5, 0])

ax.imshow(arr2, extent=[0, 5, 1, 2])

ax.imshow(arr2, extent=[0, 5, 2, 3], alpha=0.6)

ax.imshow(arr2, extent=[0, 5, 3, 4], alpha=0.3)

ax.set_facecolor((0, 0.5, 0, 1))

ax.set_xlim(0, 5)

ax.set_ylim(5, 0)

@check_figures_equal(extensions=["pdf"])

def test_clip_path_disables_compositing(fig_test, fig_ref):

t = np.arange(9).reshape((3, 3))

for fig in [fig_test, fig_ref]:

ax = fig.add_subplot()

ax.imshow(t, clip_path=(mpl.path.Path([(0, 0), (0, 1), (1, 0)]),

ax.transData))

ax.imshow(t, clip_path=(mpl.path.Path([(1, 1), (1, 2), (2, 1)]),

ax.transData))

fig_ref.suppressComposite = True

@image_comparison(['rasterize_10dpi'],

extensions=['pdf', 'svg'], remove_text=True, style='mpl20')

def test_rasterize_dpi():

# This test should check rasterized rendering with high output resolution.

# It plots a rasterized line and a normal image with imshow. So it will

# catch when images end up in the wrong place in case of non-standard dpi

# setting. Instead of high-res rasterization I use low-res. Therefore

# the fact that the resolution is non-standard is easily checked by

# image_comparison.

img = np.asarray([[1, 2], [3, 4]])

fig, axs = plt.subplots(1, 3, figsize=(3, 1))

axs[0].imshow(img)

axs[1].plot([0, 1], [0, 1], linewidth=20., rasterized=True)

axs[1].set(xlim=(0, 1), ylim=(-1, 2))

axs[2].plot([0, 1], [0, 1], linewidth=20.)

axs[2].set(xlim=(0, 1), ylim=(-1, 2))

# Low-dpi PDF rasterization errors prevent proper image comparison tests.

# Hide detailed structures like the axes spines.

for ax in axs:

ax.set_xticks([])

ax.set_yticks([])

ax.spines[:].set_visible(False)

rcParams['savefig.dpi'] = 10

@image_comparison(['bbox_image_inverted'], remove_text=True, style='mpl20')

def test_bbox_image_inverted():

# This is just used to produce an image to feed to BboxImage

image = np.arange(100).reshape((10, 10))

fig, ax = plt.subplots()

bbox_im = BboxImage(

TransformedBbox(Bbox([[100, 100], [0, 0]]), ax.transData),

interpolation='nearest')

bbox_im.set_data(image)

bbox_im.set_clip_on(False)

ax.set_xlim(0, 100)

ax.set_ylim(0, 100)

ax.add_artist(bbox_im)

image = np.identity(10)

bbox_im = BboxImage(TransformedBbox(Bbox([[0.1, 0.2], [0.3, 0.25]]),

ax.get_figure().transFigure),

interpolation='nearest')

bbox_im.set_data(image)

bbox_im.set_clip_on(False)

ax.add_artist(bbox_im)

def test_get_window_extent_for_AxisImage():

# Create a figure of known size (1000x1000 pixels), place an image

# object at a given location and check that get_window_extent()

# returns the correct bounding box values (in pixels).

im = np.array([[0.25, 0.75, 1.0, 0.75], [0.1, 0.65, 0.5, 0.4],

[0.6, 0.3, 0.0, 0.2], [0.7, 0.9, 0.4, 0.6]])

fig, ax = plt.subplots(figsize=(10, 10), dpi=100)

ax.set_position([0, 0, 1, 1])

ax.set_xlim(0, 1)

ax.set_ylim(0, 1)

im_obj = ax.imshow(

im, extent=[0.4, 0.7, 0.2, 0.9], interpolation='nearest')

fig.canvas.draw()

renderer = fig.canvas.renderer

im_bbox = im_obj.get_window_extent(renderer)

assert_array_equal(im_bbox.get_points(), [[400, 200], [700, 900]])

fig, ax = plt.subplots(figsize=(10, 10), dpi=100)

ax.set_position([0, 0, 1, 1])

ax.set_xlim(1, 2)

ax.set_ylim(0, 1)

im_obj = ax.imshow(

im, extent=[0.4, 0.7, 0.2, 0.9], interpolation='nearest',

transform=ax.transAxes)

fig.canvas.draw()

renderer = fig.canvas.renderer

im_bbox = im_obj.get_window_extent(renderer)

assert_array_equal(im_bbox.get_points(), [[400, 200], [700, 900]])

@image_comparison(['zoom_and_clip_upper_origin.png'],

remove_text=True, style='mpl20')

def test_zoom_and_clip_upper_origin():

image = np.arange(100)

image = image.reshape((10, 10))

fig, ax = plt.subplots()

ax.imshow(image)

ax.set_ylim(2.0, -0.5)

ax.set_xlim(-0.5, 2.0)

def test_nonuniformimage_setcmap():

ax = plt.gca()

im = NonUniformImage(ax)

im.set_cmap('Blues')

def test_nonuniformimage_setnorm():

ax = plt.gca()

im = NonUniformImage(ax)

im.set_norm(plt.Normalize())

def test_jpeg_2d():

# smoke test that mode-L pillow images work.

imd = np.ones((10, 10), dtype='uint8')

for i in range(10):

imd[i, :] = np.linspace(0.0, 1.0, 10) * 255

im = Image.new('L', (10, 10))

im.putdata(imd.flatten())

fig, ax = plt.subplots()

ax.imshow(im)

def test_jpeg_alpha():

plt.figure(figsize=(1, 1), dpi=300)

# Create an image that is all black, with a gradient from 0-1 in

# the alpha channel from left to right.

im = np.zeros((300, 300, 4), dtype=float)

im[..., 3] = np.linspace(0.0, 1.0, 300)

plt.figimage(im)

buff = io.BytesIO()

plt.savefig(buff, facecolor="red", format='jpg', dpi=300)

buff.seek(0)

image = Image.open(buff)

# If this fails, there will be only one color (all black). If this

# is working, we should have all 256 shades of grey represented.

num_colors = len(image.getcolors(256))

assert 175 <= num_colors <= 230

# The fully transparent part should be red.

corner_pixel = image.getpixel((0, 0))

assert corner_pixel == (254, 0, 0)

def test_axesimage_setdata():

ax = plt.gca()

im = AxesImage(ax)

z = np.arange(12, dtype=float).reshape((4, 3))

im.set_data(z)

z[0, 0] = 9.9

assert im._A[0, 0] == 0, 'value changed'

def test_figureimage_setdata():

fig = plt.gcf()

im = FigureImage(fig)

z = np.arange(12, dtype=float).reshape((4, 3))

im.set_data(z)

z[0, 0] = 9.9

assert im._A[0, 0] == 0, 'value changed'

@pytest.mark.parametrize(

"image_cls,x,y,a", [

(NonUniformImage,

np.arange(3.), np.arange(4.), np.arange(12.).reshape((4, 3))),

(PcolorImage,

np.arange(3.), np.arange(4.), np.arange(6.).reshape((3, 2))),

])

def test_setdata_xya(image_cls, x, y, a):

ax = plt.gca()

im = image_cls(ax)

im.set_data(x, y, a)

x[0] = y[0] = a[0, 0] = 9.9

assert im._A[0, 0] == im._Ax[0] == im._Ay[0] == 0, 'value changed'

im.set_data(x, y, a.reshape((*a.shape, -1))) # Just a smoketest.

def test_minimized_rasterized():

# This ensures that the rasterized content in the colorbars is

# only as thick as the colorbar, and doesn't extend to other parts

# of the image. See #5814. While the original bug exists only

# in Postscript, the best way to detect it is to generate SVG

# and then parse the output to make sure the two colorbar images

# are the same size.

from xml.etree import ElementTree

np.random.seed(0)

data = np.random.rand(10, 10)

fig, ax = plt.subplots(1, 2)

p1 = ax[0].pcolormesh(data)

p2 = ax[1].pcolormesh(data)

plt.colorbar(p1, ax=ax[0])

plt.colorbar(p2, ax=ax[1])

buff = io.BytesIO()

plt.savefig(buff, format='svg')

buff = io.BytesIO(buff.getvalue())

tree = ElementTree.parse(buff)

width = None

for image in tree.iter('image'):

if width is None:

width = image['width']

else:

if image['width'] != width:

assert False

def test_load_from_url():

path = Path(__file__).parent / "baseline_images/pngsuite/basn3p04.png"

url = ('file:'

+ ('///' if sys.platform == 'win32' else '')

+ path.resolve().as_posix())

with pytest.raises(ValueError, match="Please open the URL"):

plt.imread(url)

with urllib.request.urlopen(url) as file:

plt.imread(file)

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

def test_log_scale_image():

Z = np.zeros((10, 10))

Z[::2] = 1

fig, ax = plt.subplots()

ax.imshow(Z, extent=[1, 100, 1, 100], cmap='viridis', vmax=1, vmin=-1,

aspect='auto')

ax.set(yscale='log')

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

def test_rotate_image():

delta = 0.25

x = y = np.arange(-3.0, 3.0, delta)

X, Y = np.meshgrid(x, y)

Z1 = np.exp(-(X**2 + Y**2) / 2) / (2 * np.pi)

Z2 = (np.exp(-(((X - 1) / 1.5)**2 + ((Y - 1) / 0.5)**2) / 2) /

(2 * np.pi * 0.5 * 1.5))

Z = Z2 - Z1 # difference of Gaussians

fig, ax1 = plt.subplots(1, 1)

im1 = ax1.imshow(Z, interpolation='none', cmap='viridis',

origin='lower',

extent=[-2, 4, -3, 2], clip_on=True)

trans_data2 = Affine2D().rotate_deg(30) + ax1.transData

im1.set_transform(trans_data2)

# display intended extent of the image

x1, x2, y1, y2 = im1.get_extent()

ax1.plot([x1, x2, x2, x1, x1], [y1, y1, y2, y2, y1], "r--", lw=3,

transform=trans_data2)

ax1.set_xlim(2, 5)

ax1.set_ylim(0, 4)

def test_image_preserve_size():

buff = io.BytesIO()

im = np.zeros((481, 321))

plt.imsave(buff, im, format="png")

buff.seek(0)

img = plt.imread(buff)

assert img.shape[:2] == im.shape

def test_image_preserve_size2():

n = 7

data = np.identity(n, float)

fig = plt.figure(figsize=(n, n), frameon=False)

ax = fig.add_axes((0.0, 0.0, 1.0, 1.0))

ax.set_axis_off()

ax.imshow(data, interpolation='nearest', origin='lower', aspect='auto')

buff = io.BytesIO()

fig.savefig(buff, dpi=1)

buff.seek(0)

img = plt.imread(buff)

assert img.shape == (7, 7, 4)

assert_array_equal(np.asarray(img[:, :, 0], bool),

np.identity(n, bool)[::-1])

@image_comparison(['mask_image_over_under.png'], remove_text=True, tol=1.0)

def test_mask_image_over_under():

delta = 0.025

x = y = np.arange(-3.0, 3.0, delta)

X, Y = np.meshgrid(x, y)

Z1 = np.exp(-(X**2 + Y**2) / 2) / (2 * np.pi)

Z2 = (np.exp(-(((X - 1) / 1.5)**2 + ((Y - 1) / 0.5)**2) / 2) /

(2 * np.pi * 0.5 * 1.5))

Z = 10*(Z2 - Z1) # difference of Gaussians

palette = plt.colormaps["gray"].with_extremes(over='r', under='g', bad='b')

Zm = np.ma.masked_where(Z > 1.2, Z)

fig, (ax1, ax2) = plt.subplots(1, 2)

im = ax1.imshow(Zm, interpolation='bilinear',

cmap=palette,

norm=colors.Normalize(vmin=-1.0, vmax=1.0, clip=False),

origin='lower', extent=[-3, 3, -3, 3])

ax1.set_title('Green=low, Red=high, Blue=bad')

fig.colorbar(im, extend='both', orientation='horizontal',

ax=ax1, aspect=10)

im = ax2.imshow(Zm, interpolation='nearest',

cmap=palette,

norm=colors.BoundaryNorm([-1, -0.5, -0.2, 0, 0.2, 0.5, 1],

ncolors=256, clip=False),

origin='lower', extent=[-3, 3, -3, 3])

ax2.set_title('With BoundaryNorm')

fig.colorbar(im, extend='both', spacing='proportional',

orientation='horizontal', ax=ax2, aspect=10)

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

def test_mask_image():

# Test mask image two ways: Using nans and using a masked array.

fig, (ax1, ax2) = plt.subplots(1, 2)

A = np.ones((5, 5))

A[1:2, 1:2] = np.nan

ax1.imshow(A, interpolation='nearest')

A = np.zeros((5, 5), dtype=bool)

A[1:2, 1:2] = True

A = np.ma.masked_array(np.ones((5, 5), dtype=np.uint16), A)

ax2.imshow(A, interpolation='nearest')