"""

The image module supports basic image loading, rescaling and display

operations.

"""

import os

import logging

from pathlib import Path

import warnings

import numpy as np

import PIL.Image

import PIL.PngImagePlugin

import matplotlib as mpl

from matplotlib import _api, cbook

# For clarity, names from _image are given explicitly in this module

from matplotlib import _image

# For user convenience, the names from _image are also imported into

# the image namespace

from matplotlib._image import * # noqa: F401, F403

import matplotlib.artist as martist

import matplotlib.colorizer as mcolorizer

from matplotlib.backend_bases import FigureCanvasBase

import matplotlib.colors as mcolors

from matplotlib.transforms import (

Affine2D, BboxBase, Bbox, BboxTransform, BboxTransformTo,

IdentityTransform, TransformedBbox)

_log = logging.getLogger(__name__)

# map interpolation strings to module constants

_interpd_ = {

'auto': _image.NEAREST, # this will use nearest or Hanning...

'none': _image.NEAREST, # fall back to nearest when not supported

'nearest': _image.NEAREST,

'bilinear': _image.BILINEAR,

'bicubic': _image.BICUBIC,

'spline16': _image.SPLINE16,

'spline36': _image.SPLINE36,

'hanning': _image.HANNING,

'hamming': _image.HAMMING,

'hermite': _image.HERMITE,

'kaiser': _image.KAISER,

'quadric': _image.QUADRIC,

'catrom': _image.CATROM,

'gaussian': _image.GAUSSIAN,

'bessel': _image.BESSEL,

'mitchell': _image.MITCHELL,

'sinc': _image.SINC,

'lanczos': _image.LANCZOS,

'blackman': _image.BLACKMAN,

'antialiased': _image.NEAREST, # this will use nearest or Hanning...

}

interpolations_names = set(_interpd_)

def composite_images(images, renderer, magnification=1.0):

"""

Composite a number of RGBA images into one. The images are

composited in the order in which they appear in the *images* list.

Parameters

----------

images : list of Images

Each must have a `!make_image` method. For each image,

`!can_composite` should return `True`, though this is not

enforced by this function. Each image must have a purely

affine transformation with no shear.

renderer : `.RendererBase`

magnification : float, default: 1

The additional magnification to apply for the renderer in use.

Returns

-------

image : (M, N, 4) `numpy.uint8` array

The composited RGBA image.

offset_x, offset_y : float

The (left, bottom) offset where the composited image should be placed

in the output figure.

"""

if len(images) == 0:

return np.empty((0, 0, 4), dtype=np.uint8), 0, 0

parts = []

bboxes = []

for image in images:

data, x, y, trans = image.make_image(renderer, magnification)

if data is not None:

x *= magnification

y *= magnification

parts.append((data, x, y))

bboxes.append(

Bbox([[x, y], [x + data.shape[1], y + data.shape[0]]]))

if len(parts) == 0:

return np.empty((0, 0, 4), dtype=np.uint8), 0, 0

bbox = Bbox.union(bboxes)

output = np.zeros(

(int(bbox.height), int(bbox.width), 4), dtype=np.uint8)

for data, x, y in parts:

trans = Affine2D().translate(x - bbox.x0, y - bbox.y0)

# Agg resampler assumes data is not premultiplied when dtype is uint8

_image.resample(data, output, trans, _image.NEAREST, resample=False)

return output, bbox.x0 / magnification, bbox.y0 / magnification

def _draw_list_compositing_images(

renderer, parent, artists, suppress_composite=None):

"""

Draw a sorted list of artists, compositing images into a single

image where possible.

For internal Matplotlib use only: It is here to reduce duplication

between `Figure.draw` and `Axes.draw`, but otherwise should not be

generally useful.

"""

has_images = any(isinstance(x, _ImageBase) for x in artists)

# override the renderer default if suppressComposite is not None

not_composite = (suppress_composite if suppress_composite is not None

else renderer.option_image_nocomposite())

if not_composite or not has_images:

for a in artists:

a.draw(renderer)

else:

# Composite any adjacent images together

image_group = []

mag = renderer.get_image_magnification()

def flush_images():

if len(image_group) == 1:

image_group[0].draw(renderer)

elif len(image_group) > 1:

data, l, b = composite_images(image_group, renderer, mag)

if data.size != 0:

gc = renderer.new_gc()

gc.set_clip_rectangle(parent.bbox)

gc.set_clip_path(parent.get_clip_path())

renderer.draw_image(gc, round(l), round(b), data)

gc.restore()

del image_group[:]

for a in artists:

if (isinstance(a, _ImageBase) and a.can_composite() and

a.get_clip_on() and not a.get_clip_path() and

a.get_blend_mode() == "normal"):

image_group.append(a)

else:

flush_images()

a.draw(renderer)

flush_images()

def _resample(

image_obj, data, out_shape, transform, *, resample=None, alpha=1):

"""

Convenience wrapper around `._image.resample` to resample *data* to

*out_shape* (with a third dimension if *data* is RGBA) that takes care of

allocating the output array and fetching the relevant properties from the

Image object *image_obj*.

"""

# AGG can only handle coordinates smaller than 24-bit signed integers,

# so raise errors if the input data is larger than _image.resample can

# handle.

msg = ('Data with more than {n} cannot be accurately displayed. '

'Downsampling to less than {n} before displaying. '

'To remove this warning, manually downsample your data.')

if data.shape[1] > 2**23:

warnings.warn(msg.format(n='2**23 columns'))

step = int(np.ceil(data.shape[1] / 2**23))

data = data[:, ::step]

transform = Affine2D().scale(step, 1) + transform

if data.shape[0] > 2**24:

warnings.warn(msg.format(n='2**24 rows'))

step = int(np.ceil(data.shape[0] / 2**24))

data = data[::step, :]

transform = Affine2D().scale(1, step) + transform

# decide if we need to apply anti-aliasing if the data is upsampled:

# compare the number of displayed pixels to the number of

# the data pixels.

interpolation = image_obj.get_interpolation()

if interpolation in ['antialiased', 'auto']:

# don't antialias if upsampling by an integer number or

# if zooming in more than a factor of 3

pos = np.array([[0, 0], [data.shape[1], data.shape[0]]])

disp = transform.transform(pos)

dispx = np.abs(np.diff(disp[:, 0]))

dispy = np.abs(np.diff(disp[:, 1]))

if ((dispx > 3 * data.shape[1] or

dispx == data.shape[1] or

dispx == 2 * data.shape[1]) and

(dispy > 3 * data.shape[0] or

dispy == data.shape[0] or

dispy == 2 * data.shape[0])):

interpolation = 'nearest'

else:

interpolation = 'hanning'

out = np.zeros(out_shape + data.shape[2:], data.dtype) # 2D->2D, 3D->3D.

if resample is None:

resample = image_obj.get_resample()

# When an output pixel falls exactly on the edge between two input pixels, the Agg

# resampler will use the right input pixel as the nearest neighbor. We want the

# left input pixel to be chosen instead, so we flip the input data and the supplied

# transform. If origin != 'upper', the transform will already include a flip in the

# vertical direction.

if interpolation == 'nearest':

transform = Affine2D().translate(-data.shape[1], 0).scale(-1, 1) + transform

data = np.flip(data, axis=1)

if image_obj.origin == 'upper':

transform = Affine2D().translate(0, -data.shape[0]).scale(1, -1) + transform

data = np.flip(data, axis=0)

_image.resample(data, out, transform,

_interpd_[interpolation],

resample,

alpha,

image_obj.get_filternorm(),

image_obj.get_filterrad())

return out

def _rgb_to_rgba(A):

"""

Convert an RGB image to RGBA, as required by the image resample C++

extension.

"""

rgba = np.zeros((A.shape[0], A.shape[1], 4), dtype=A.dtype)

rgba[:, :, :3] = A

if rgba.dtype == np.uint8:

rgba[:, :, 3] = 255

else:

rgba[:, :, 3] = 1.0

return rgba

class _ImageBase(mcolorizer.ColorizingArtist):

"""

Base class for images.

*interpolation* and *cmap* default to their rc settings.

*cmap* is a `.colors.Colormap` instance.

*norm* is a `.colors.Normalize` instance to map luminance to 0-1.

*extent* is a ``(left, right, bottom, top)`` tuple in data coordinates, for

making image plots registered with data plots; the default is to label the

pixel centers with the zero-based row and column indices.

Additional kwargs are `.Artist` properties.

"""

zorder = 0

def __init__(self, ax,

cmap=None,

norm=None,

colorizer=None,

interpolation=None,

origin=None,

filternorm=True,

filterrad=4.0,

resample=False,

*,

interpolation_stage=None,

**kwargs

):

super().__init__(self._get_colorizer(cmap, norm, colorizer))

origin = mpl._val_or_rc(origin, 'image.origin')

_api.check_in_list(["upper", "lower"], origin=origin)

self.origin = origin

self.set_filternorm(filternorm)

self.set_filterrad(filterrad)

self.set_interpolation(interpolation)

if isinstance(self.norm, mcolors.MultiNorm):

if interpolation_stage not in [None, 'data', 'auto']:

raise ValueError("when using multivariate color mapping 'data' "

"is the only valid interpolation_stage, but got "

f"{interpolation_stage}")

self.set_interpolation_stage('data')

else:

self.set_interpolation_stage(interpolation_stage)

self.set_resample(resample)

self.axes = ax

self._imcache = None

self._internal_update(kwargs)

def __str__(self):

try:

shape = self.get_shape()

return f"{type(self).__name__}(shape={shape!r})"

except RuntimeError:

return type(self).__name__

def __getstate__(self):

# Save some space on the pickle by not saving the cache.

return {**super().__getstate__(), "_imcache": None}

def get_size(self):

"""Return the size of the image as tuple (numrows, numcols)."""

return self.get_shape()[:2]

def get_shape(self):

"""

Return the shape of the image as tuple (numrows, numcols, channels).

"""

if self._A is None:

raise RuntimeError('You must first set the image array')

return self._A.shape

def set_alpha(self, alpha):

"""

Set the alpha value used for blending - not supported on all backends.

Parameters

----------

alpha : float or 2D array-like or None

"""

martist.Artist._set_alpha_for_array(self, alpha)

if np.ndim(alpha) not in (0, 2):

raise TypeError('alpha must be a float, two-dimensional '

'array, or None')

self._imcache = None

def _get_scalar_alpha(self):

"""

Get a scalar alpha value to be applied to the artist as a whole.

If the alpha value is a matrix, the method returns 1.0 because pixels

have individual alpha values (see `~._ImageBase._make_image` for

details). If the alpha value is a scalar, the method returns said value

to be applied to the artist as a whole because pixels do not have

individual alpha values.

"""

return 1.0 if self._alpha is None or np.ndim(self._alpha) > 0 \

else self._alpha

def changed(self):

"""

Call this whenever the mappable is changed so observers can update.

"""

self._imcache = None

super().changed()

def _make_image(self, A, in_bbox, out_bbox, clip_bbox, magnification=1.0,

unsampled=False, round_to_pixel_border=True):

"""

Normalize, rescale, and colormap the image *A* from the given *in_bbox*

(in data space), to the given *out_bbox* (in pixel space) clipped to

the given *clip_bbox* (also in pixel space), and magnified by the

*magnification* factor.

Parameters

----------

A : ndarray

- a (M, N) array interpreted as scalar (greyscale) image,

with one of the dtypes `~numpy.float32`, `~numpy.float64`,

`~numpy.float128`, `~numpy.uint16` or `~numpy.uint8`.

- a (M, N) structured array with K fields for multivariate colormapping.

This must be used with a `.BivarColormap` (K=2) or generally with a

K-component `.MultivarColormap`.

- (M, N, 4) RGBA image with a dtype of `~numpy.float32`,

`~numpy.float64`, `~numpy.float128`, or `~numpy.uint8`.

in_bbox : `~matplotlib.transforms.Bbox`

out_bbox : `~matplotlib.transforms.Bbox`

clip_bbox : `~matplotlib.transforms.Bbox`

magnification : float, default: 1

unsampled : bool, default: False

If True, the image will not be scaled, but an appropriate

affine transformation will be returned instead.

round_to_pixel_border : bool, default: True

If True, the output image size will be rounded to the nearest pixel

boundary. This makes the images align correctly with the Axes.

It should not be used if exact scaling is needed, such as for

`.FigureImage`.

Returns

-------

image : (M, N, 4) `numpy.uint8` array

The RGBA image, resampled unless *unsampled* is True.

x, y : float

The upper left corner where the image should be drawn, in pixel

space.

trans : `~matplotlib.transforms.Affine2D`

The affine transformation from image to pixel space.

"""

if A is None:

raise RuntimeError('You must first set the image '

'array or the image attribute')

if A.size == 0:

raise RuntimeError("_make_image must get a non-empty image. "

"Your Artist's draw method must filter before "

"this method is called.")

clipped_bbox = Bbox.intersection(out_bbox, clip_bbox)

if clipped_bbox is None:

return None, 0, 0, None

# Define the magnified bbox after clipping

magnified_extents = clipped_bbox.extents * magnification

if ((not unsampled) and round_to_pixel_border):

# Round to the nearest output pixel

# Add a tiny fudge amount to account for numerical precision loss

# on the two sides away from the Agg anchor point (x0, y1)

x0 = np.floor(magnified_extents[0] + 0.5) # round half up

y0 = np.ceil(magnified_extents[1] - 0.5 - 1e-8) # round half down

x1 = np.floor(magnified_extents[2] + 0.5 + 1e-8) # round half up

y1 = np.ceil(magnified_extents[3] - 0.5) # round half down

magnified_bbox = Bbox.from_extents([x0, y0, x1, y1])

else:

magnified_bbox = Bbox.from_extents(magnified_extents)

if magnified_bbox.width == 0 or magnified_bbox.height == 0:

return None, 0, 0, None

if self.origin == 'upper':

# Flip the input image using a transform. This avoids the

# problem with flipping the array, which results in a copy

# when it is converted to contiguous in the C wrapper

t0 = Affine2D().translate(0, -A.shape[0]).scale(1, -1)

else:

t0 = IdentityTransform()

t0 += (

Affine2D()

.scale(

in_bbox.width / A.shape[1],

in_bbox.height / A.shape[0])

.translate(in_bbox.x0, in_bbox.y0)

+ self.get_transform())

t = (t0

+ (Affine2D()

.scale(magnification)

.translate(-magnified_bbox.x0, -magnified_bbox.y0)))

out_shape = (int(magnified_bbox.height), int(magnified_bbox.width))

if not unsampled:

if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in (3, 4)):

raise ValueError(f"Invalid shape {A.shape} for image data")

# if antialiased, this needs to change as window sizes

# change:

interpolation_stage = self._interpolation_stage

if interpolation_stage in ['antialiased', 'auto']:

pos = np.array([[0, 0], [A.shape[1], A.shape[0]]])

disp = t.transform(pos)

dispx = np.abs(np.diff(disp[:, 0])) / A.shape[1]

dispy = np.abs(np.diff(disp[:, 1])) / A.shape[0]

if (dispx < 3) or (dispy < 3):

interpolation_stage = 'rgba'

else:

interpolation_stage = 'data'

if A.ndim == 2 and interpolation_stage == 'data':

# if we are a 2D array, then we are running through the

# norm + colormap transformation. However, in general the

# input data is not going to match the size on the screen so we

# have to resample to the correct number of pixels

if A.dtype.fields is None: # scalar data and colormap

arrs, norms, dtypes = [A], [self.norm], [A.dtype]

else: # using a multivariate colormap

arrs = [A[f] for f in A.dtype.fields]

norms = self.norm.norms

dtypes = [A.dtype.fields[f][0] for f in A.dtype.fields]

def get_scaled_dtype(A):

# gets the scaled dtype

if A.dtype.kind == 'f': # Float dtype: scale to same dtype.

scaled_dtype = np.dtype('f8' if A.dtype.itemsize > 4 else 'f4')

if scaled_dtype.itemsize < A.dtype.itemsize:

_api.warn_external(f"Casting input data from {A.dtype}"

f" to {scaled_dtype} for imshow.")

else: # Int dtype, likely.

# TODO slice input array first

# Scale to appropriately sized float: use float32 if the

# dynamic range is small, to limit the memory footprint.

da = A.max().astype("f8") - A.min().astype("f8")

scaled_dtype = "f8" if da > 1e8 else "f4"

return scaled_dtype

A_resampled = [_resample(self,

a.astype(get_scaled_dtype(a)),

out_shape, t)

for a in arrs]

# if using NoNorm, cast back to the original datatype

for i, n in enumerate(norms):

if isinstance(n, mcolors.NoNorm):

A_resampled[i] = A_resampled[i].astype(dtypes[i])

# Compute out_mask (what screen pixels include "bad" data

# pixels) and out_alpha (to what extent screen pixels are

# covered by data pixels: 0 outside the data extent, 1 inside

# (even for bad data), and intermediate values at the edges).

mask = (np.where(self._getmaskarray(A),

np.float32(np.nan), np.float32(1))

if A.mask.shape == A.shape # nontrivial mask

else np.ones_like(A, np.float32))

# we always have to interpolate the mask to account for

# non-affine transformations

out_alpha = _resample(self, mask, out_shape, t, resample=True)

del mask # Make sure we don't use mask anymore!

out_mask = np.isnan(out_alpha)

out_alpha[out_mask] = 1

# Apply the pixel-by-pixel alpha values if present

alpha = self.get_alpha()

if alpha is not None and np.ndim(alpha) > 0:

out_alpha *= _resample(self, alpha, out_shape, t, resample=True)

# mask

resampled_masked = [np.ma.masked_array(r, out_mask)

for r in A_resampled]

if A.dtype.fields is None:

resampled_masked = resampled_masked[0]

res = self.norm(resampled_masked)

else:

if A.ndim == 2: # interpolation_stage = 'rgba'

self.norm.autoscale_None(A)

A = self.to_rgba(A)

if A.dtype == np.uint8:

# uint8 is too imprecise for premultiplied alpha roundtrips.

A = np.divide(A, 0xff, dtype=np.float32)

alpha = self.get_alpha()

post_apply_alpha = False

if alpha is None: # alpha parameter not specified

if A.shape[2] == 3: # image has no alpha channel

A = np.dstack([A, np.ones(A.shape[:2])])

elif np.ndim(alpha) > 0: # Array alpha

if A.shape[2] == 3: # RGB: use array alpha directly

A = np.dstack([A, alpha])

else: # RGBA: multiply existing alpha by array alpha

A = np.dstack([A[..., :3], A[..., 3] * alpha])

else: # Scalar alpha

if A.shape[2] == 3: # broadcast scalar alpha

A = np.dstack([A, np.full(A.shape[:2], alpha, np.float32)])

else: # or apply scalar alpha to existing alpha channel

post_apply_alpha = True

# Resample in premultiplied alpha space. (TODO: Consider

# implementing premultiplied-space resampling in

# span_image_resample_rgba_affine::generate?)

# Multiplying the whole array and then restoring the alpha channel

# is faster than an in-place multiply of the strided A[..., :3]

# view. If alpha is uniformly 1, premultiplication can be skipped.

alpha_in = A[..., 3]

if (alpha_in != 1).any():

A = A * alpha_in[..., None]

A[..., 3] = alpha_in

res = _resample(self, A, out_shape, t)

# Demultiply. Zeroes in the divisor are replaced by ones,

# which leaves the corresponding (premultiplied) RGB values

# untouched. Dividing the whole contiguous array is several

# times faster than np.divide(..., where=...) into the strided

# res[..., :3] view.

alpha_out = res[..., 3].copy()

res /= np.where(alpha_out != 0, alpha_out, 1)[..., None]

res[..., 3] = alpha_out

if post_apply_alpha:

res[..., 3] *= alpha

# res is now either a 2D array of normed (int or float) data

# or an RGBA array of re-sampled input

output = self.to_rgba(res, bytes=True, norm=False)

# output is now a correctly sized RGBA array of uint8

# Apply alpha *after* if the input was greyscale without a mask

if A.ndim == 2:

alpha = self._get_scalar_alpha()

alpha_channel = output[:, :, 3]

alpha_channel[:] = ( # Assignment will cast to uint8.

alpha_channel.astype(np.float32) * out_alpha * alpha)

else:

if self._imcache is None:

self._imcache = self.to_rgba(A, bytes=True, norm=(A.ndim == 2))

output = self._imcache

# Subset the input image to only the part that will be displayed.

subset = TransformedBbox(clip_bbox, t0.inverted()).frozen()

output = output[

int(max(subset.ymin, 0)):

int(min(subset.ymax + 1, output.shape[0])),

int(max(subset.xmin, 0)):

int(min(subset.xmax + 1, output.shape[1]))]

t = Affine2D().translate(

int(max(subset.xmin, 0)), int(max(subset.ymin, 0))) + t

return (output,

magnified_bbox.x0 / magnification,

magnified_bbox.y0 / magnification,

t)

def make_image(self, renderer, magnification=1.0, unsampled=False):

"""

Normalize, rescale, and colormap this image's data for rendering using

*renderer*, with the given *magnification*.

If *unsampled* is True, the image will not be scaled, but an

appropriate affine transformation will be returned instead.

Returns

-------

image : (M, N, 4) `numpy.uint8` array

The RGBA image, resampled unless *unsampled* is True.

x, y : float

The upper left corner where the image should be drawn, in pixel

space.

trans : `~matplotlib.transforms.Affine2D`

The affine transformation from image to pixel space.

"""

raise NotImplementedError('The make_image method must be overridden')

def _check_unsampled_image(self):

"""

Return whether the image is better to be drawn unsampled.

The derived class needs to override it.

"""

return False

@martist.allow_rasterization

def draw(self, renderer):

# if not visible, declare victory and return

if not self.get_visible():

self.stale = False

return

# for empty images, there is nothing to draw!

if self.get_array().size == 0:

self.stale = False

return

# actually render the image.

gc = renderer.new_gc()

self._set_gc_clip(gc)

gc.set_blend_mode(self.get_blend_mode())

gc.set_url(self.get_url())

gc.set_gid(self.get_gid())

if (renderer.option_scale_image() # Renderer supports transform kwarg.

and self._check_unsampled_image()

and self.get_transform().is_affine):

im, l, b, trans = self.make_image(renderer, unsampled=True)

if im is not None:

gc.set_alpha(self._get_scalar_alpha())

trans = Affine2D().scale(im.shape[1], im.shape[0]) + trans

renderer.draw_image(gc, l, b, im, trans)

else:

im, l, b, trans = self.make_image(

renderer, renderer.get_image_magnification())

if im is not None:

renderer.draw_image(gc, l, b, im)

gc.restore()

self.stale = False

def contains(self, mouseevent):

"""Test whether the mouse event occurred within the image."""

if (self._different_canvas(mouseevent)

# This doesn't work for figimage.

or not self.axes.contains(mouseevent)[0]):

return False, {}

# TODO: make sure this is consistent with patch and patch

# collection on nonlinear transformed coordinates.

# TODO: consider returning image coordinates (shouldn't

# be too difficult given that the image is rectilinear

trans = self.get_transform().inverted()

x, y = trans.transform([mouseevent.x, mouseevent.y])

xmin, xmax, ymin, ymax = self.get_extent()

# This checks xmin <= x <= xmax *or* xmax <= x <= xmin.

inside = (x is not None and (x - xmin) * (x - xmax) <= 0

and y is not None and (y - ymin) * (y - ymax) <= 0)

return inside, {}

def write_png(self, fname):

"""Write the image to png file *fname*."""

im = self.to_rgba(self._A[::-1] if self.origin == 'lower' else self._A,

bytes=True, norm=True)

PIL.Image.fromarray(im).save(fname, format="png")

@staticmethod

def _normalize_image_array(A):

"""

Check validity of image-like input *A* and normalize it to a format suitable for

Image subclasses.

"""

A = cbook.safe_masked_invalid(A, copy=True)

if A.dtype != np.uint8 and not np.can_cast(A.dtype, float, "same_kind"):

if A.dtype.fields is None:

raise TypeError(f"Image data of dtype {A.dtype} cannot be "

f"converted to float")

else:

for key in A.dtype.fields:

if not np.can_cast(A[key].dtype, float, "same_kind"):

raise TypeError(f"Image data of dtype {A.dtype} cannot be "

f"converted to a sequence of floats")

if A.ndim == 3 and A.shape[-1] == 1:

A = A.squeeze(-1) # If just (M, N, 1), assume scalar and apply colormap.

if not (A.ndim == 2 or A.ndim == 3 and A.shape[-1] in [3, 4]):

raise TypeError(f"Invalid shape {A.shape} for image data")

if A.ndim == 3:

# If the input data has values outside the valid range (after

# normalisation), we issue a warning and then clip X to the bounds

# - otherwise casting wraps extreme values, hiding outliers and

# making reliable interpretation impossible.

high = 255 if np.issubdtype(A.dtype, np.integer) else 1

if A.min() < 0 or high < A.max():

_log.warning(

'Clipping input data to the valid range for imshow with '

'RGB data ([0..1] for floats or [0..255] for integers). '

'Got range [%s..%s].',

A.min(), A.max()

)

A = np.clip(A, 0, high)

# Cast unsupported integer types to uint8

if A.dtype != np.uint8 and np.issubdtype(A.dtype, np.integer):

A = A.astype(np.uint8)

return A

def set_data(self, A):

"""

Set the image array.

Note that this function does *not* update the normalization used.

Parameters

----------

A : array-like or `PIL.Image.Image`

"""

if isinstance(A, PIL.Image.Image):

A = pil_to_array(A) # Needed e.g. to apply png palette.

self._A = self._normalize_image_array(A)

self._imcache = None

self.stale = True

def set_array(self, A):

"""

Retained for backwards compatibility - use set_data instead.

Parameters

----------

A : array-like

"""

# This also needs to be here to override the inherited

# cm.ScalarMappable.set_array method so it is not invoked by mistake.

self.set_data(A)

def get_interpolation(self):

"""

Return the interpolation method the image uses when resizing.

One of 'auto', 'antialiased', 'nearest', 'bilinear', 'bicubic',

'spline16', 'spline36', 'hanning', 'hamming', 'hermite', 'kaiser',

'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos',

or 'none'.

"""

return self._interpolation

def set_interpolation(self, s):

"""

Set the interpolation method the image uses when resizing.

If None, use :rc:`image.interpolation`. If 'none', the image is

shown as is without interpolating. 'none' is only supported in

agg, ps and pdf backends and will fall back to 'nearest' mode

for other backends.

Parameters

----------

s : {'auto', 'nearest', 'bilinear', 'bicubic', 'spline16', \

'spline36', 'hanning', 'hamming', 'hermite', 'kaiser', 'quadric', 'catrom', \

'gaussian', 'bessel', 'mitchell', 'sinc', 'lanczos', 'none'} or None

"""

s = mpl._val_or_rc(s, 'image.interpolation').lower()

_api.check_in_list(interpolations_names, interpolation=s)

self._interpolation = s

self.stale = True

def get_interpolation_stage(self):

"""

Return when interpolation happens during the transform to RGBA.

One of 'data', 'rgba', 'auto'.

"""

return self._interpolation_stage

def set_interpolation_stage(self, s):

"""

Set when interpolation happens during the transform to RGBA.

Parameters

----------

s : {'data', 'rgba', 'auto'}, default: :rc:`image.interpolation_stage`

Whether to apply resampling interpolation in data or RGBA space.

If 'auto', 'rgba' is used if the upsampling rate is less than 3,

otherwise 'data' is used.

"""

s = mpl._val_or_rc(s, 'image.interpolation_stage')

_api.check_in_list(['data', 'rgba', 'auto'], s=s)

self._interpolation_stage = s

self.stale = True

def can_composite(self):

"""Return whether the image can be composited with its neighbors."""

trans = self.get_transform()

return (

self._interpolation != 'none' and

trans.is_affine and

trans.is_separable)

def set_resample(self, v):

"""

Set whether image resampling is used.

Parameters

----------

v : bool, default: :rc:`image.resample`

"""

v = mpl._val_or_rc(v, 'image.resample')

self._resample = v

self.stale = True

def get_resample(self):

"""Return whether image resampling is used."""

return self._resample

def set_filternorm(self, filternorm):

"""

Set whether the resize filter normalizes the weights.

See help for `~.Axes.imshow`.

Parameters

----------

filternorm : bool

"""

self._filternorm = bool(filternorm)

self.stale = True

def get_filternorm(self):

"""Return whether the resize filter normalizes the weights."""

return self._filternorm

def set_filterrad(self, filterrad):

"""

Set the resize filter radius (only applicable to some

interpolation schemes).

See help for `~.Axes.imshow`.

Parameters

----------

filterrad : positive float

"""

r = float(filterrad)

if r <= 0:

raise ValueError("The filter radius must be a positive number")

self._filterrad = r

self.stale = True

def get_filterrad(self):

"""Return the filterrad setting."""

return self._filterrad

class AxesImage(_ImageBase):

"""

An image with pixels on a regular grid, attached to an Axes.

Parameters

----------

ax : `~matplotlib.axes.Axes`

The Axes the image will belong to.

cmap : str or `~matplotlib.colors.Colormap`, default: :rc:`image.cmap`

The Colormap instance or registered colormap name used to map scalar

data to colors.

norm : str or `~matplotlib.colors.Normalize`

Maps luminance to 0-1.

interpolation : str, default: :rc:`image.interpolation`

Supported values are 'none', 'auto', 'nearest', 'bilinear',

'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 'hermite',

'kaiser', 'quadric', 'catrom', 'gaussian', 'bessel', 'mitchell',

'sinc', 'lanczos', 'blackman'.

interpolation_stage : {'data', 'rgba'}, default: 'data'

If 'data', interpolation

is carried out on the data provided by the user. If 'rgba', the

interpolation is carried out after the colormapping has been

applied (visual interpolation).

origin : {'upper', 'lower'}, default: :rc:`image.origin`

Place the [0, 0] index of the array in the upper left or lower left

corner of the Axes. The convention 'upper' is typically used for

matrices and images.

extent : tuple, optional

The data axes (left, right, bottom, top) for making image plots

registered with data plots. Default is to label the pixel

centers with the zero-based row and column indices.

filternorm : bool, default: True

A parameter for the antigrain image resize filter

(see the antigrain documentation).

If filternorm is set, the filter normalizes integer values and corrects

the rounding errors. It doesn't do anything with the source floating

point values, it corrects only integers according to the rule of 1.0

which means that any sum of pixel weights must be equal to 1.0. So,

the filter function must produce a graph of the proper shape.

filterrad : float > 0, default: 4

The filter radius for filters that have a radius parameter, i.e. when

interpolation is one of: 'sinc', 'lanczos' or 'blackman'.

resample : bool, default: False

When True, use a full resampling method. When False, only resample when

the output image is larger than the input image.

**kwargs : `~matplotlib.artist.Artist` properties

"""

def __init__(self, ax,

*,

cmap=None,

norm=None,

colorizer=None,

interpolation=None,

origin=None,

extent=None,

filternorm=True,

filterrad=4.0,

resample=False,

interpolation_stage=None,

**kwargs

):

self._extent = extent

super().__init__(

ax,

cmap=cmap,

norm=norm,

colorizer=colorizer,

interpolation=interpolation,

origin=origin,

filternorm=filternorm,

filterrad=filterrad,

resample=resample,

interpolation_stage=interpolation_stage,

**kwargs

)

def get_window_extent(self, renderer=None):

x0, x1, y0, y1 = self._extent

bbox = Bbox.from_extents([x0, y0, x1, y1])

return bbox.transformed(self.get_transform())

def make_image(self, renderer, magnification=1.0, unsampled=False):

# docstring inherited

trans = self.get_transform()

# image is created in the canvas coordinate.

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

bbox = Bbox(np.array([[x1, y1], [x2, y2]]))

transformed_bbox = TransformedBbox(bbox, trans)

clip = ((self.get_clip_box() or self.axes.bbox) if self.get_clip_on()

else self.get_figure(root=True).bbox)

return self._make_image(self._A, bbox, transformed_bbox, clip,

magnification, unsampled=unsampled)

def _check_unsampled_image(self):

"""Return whether the image would be better drawn unsampled."""

return self.get_interpolation() == "none"

def set_extent(self, extent, **kwargs):

"""

Set the image extent.

Parameters

----------

extent : 4-tuple of float

The position and size of the image as tuple

``(left, right, bottom, top)`` in data coordinates.

**kwargs

Other parameters from which unit info (i.e., the *xunits*,

*yunits*, *zunits* (for 3D Axes), *runits* and *thetaunits* (for