from contextlib import ExitStack

from copy import copy

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_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.testing.decorators import check_figures_equal, image_comparison

from matplotlib.transforms import Bbox, Affine2D, TransformedBbox

import matplotlib.ticker as mticker

import pytest

@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(extensions=['png'])

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(extensions=['png'])

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(extensions=['png'])

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):

plt.imsave(Path(os.devnull), 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(extensions=['png'])

def test_imshow_alpha(fig_test, fig_ref):

np.random.seed(19680801)

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

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=0.5)

ax3.imshow(rgbu, alpha=0.75)

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

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)

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

@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(extensions=['png'])

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)

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.cm.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')

def test_mask_image_all():

# Test behavior with an image that is entirely masked does not warn

data = np.full((2, 2), np.nan)

fig, ax = plt.subplots()

ax.imshow(data)

fig.canvas.draw_idle() # would emit a warning

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

def test_imshow_endianess():

x = np.arange(10)

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

Z = np.hypot(X - 5, Y - 5)

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

kwargs = dict(origin="lower", interpolation='nearest', cmap='viridis')

ax1.imshow(Z.astype('<f8'), **kwargs)

ax2.imshow(Z.astype('>f8'), **kwargs)

@image_comparison(['imshow_masked_interpolation'],

tol=0 if platform.machine() == 'x86_64' else 0.01,

remove_text=True, style='mpl20')

def test_imshow_masked_interpolation():

cmap = mpl.colormaps['viridis'].with_extremes(over='r', under='b', bad='k')

N = 20

n = colors.Normalize(vmin=0, vmax=N*N-1)

data = np.arange(N*N, dtype=float).reshape(N, N)

data[5, 5] = -1

# This will cause crazy ringing for the higher-order

# interpolations

data[15, 5] = 1e5

# data[3, 3] = np.nan

data[15, 15] = np.inf

mask = np.zeros_like(data).astype('bool')

mask[5, 15] = True

data = np.ma.masked_array(data, mask)

fig, ax_grid = plt.subplots(3, 6)

interps = sorted(mimage._interpd_)

interps.remove('auto')

interps.remove('antialiased')

for interp, ax in zip(interps, ax_grid.ravel()):

ax.set_title(interp)

ax.imshow(data, norm=n, cmap=cmap, interpolation=interp)

ax.axis('off')

def test_imshow_no_warn_invalid():

plt.imshow([[1, 2], [3, np.nan]]) # Check that no warning is emitted.

@pytest.mark.parametrize(

'dtype', [np.dtype(s) for s in 'u2 u4 i2 i4 i8 f4 f8'.split()])

def test_imshow_clips_rgb_to_valid_range(dtype):

arr = np.arange(300, dtype=dtype).reshape((10, 10, 3))

if dtype.kind != 'u':

arr -= 10

too_low = arr < 0

too_high = arr > 255

if dtype.kind == 'f':

arr = arr / 255

_, ax = plt.subplots()