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

"""

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, image._get_scalar_alpha()))

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, alpha in parts:

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

_image.resample(data, output, trans, _image.NEAREST,

resample=False, alpha=alpha)

renderer, parent, artists, suppress_composite=None):

"""

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

image_group.append(a)

else:

flush_images()

a.draw(renderer)

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

"""

# 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()

_image.resample(data, out, transform,

_interpd_[interpolation],

resample,

alpha,

image_obj.get_filternorm(),

image_obj.get_filterrad())

"""

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

"""

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

if origin is None:

origin = mpl.rcParams['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)

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

"""

if self._A is None:

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

return self._A.shape

def set_alpha(self, alpha):

"""

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

"""

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

else self._alpha

def changed(self):

"""

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

"""

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

out_width_base = clipped_bbox.width * magnification

out_height_base = clipped_bbox.height * magnification

if out_width_base == 0 or out_height_base == 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()

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

.scale(magnification)))

# So that the image is aligned with the edge of the Axes, we want to

# round up the output width to the next integer. This also means

# scaling the transform slightly to account for the extra subpixel.

if ((not unsampled) and t.is_affine and round_to_pixel_border and

(out_width_base % 1.0 != 0.0 or out_height_base % 1.0 != 0.0)):

out_width = math.ceil(out_width_base)

out_height = math.ceil(out_height_base)

extra_width = (out_width - out_width_base) / out_width_base

extra_height = (out_height - out_height_base) / out_height_base

t += Affine2D().scale(1.0 + extra_width, 1.0 + extra_height)

else:

out_width = int(out_width_base)

out_height = int(out_height_base)

out_shape = (out_height, out_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.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"

# resample the input data to the correct resolution and shape

A_resampled = _resample(self, A.astype(scaled_dtype), out_shape, t)

# if using NoNorm, cast back to the original datatype

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

A_resampled = A_resampled.astype(A.dtype)

# 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(A.mask, 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 and run through the norm

resampled_masked = np.ma.masked_array(A_resampled, out_mask)

output = self.norm(resampled_masked)

else:

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

self.norm.autoscale_None(A)

A = self.to_rgba(A)

alpha = self.get_alpha()

if alpha is None: # alpha parameter not specified

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

output_alpha = 255 if A.dtype == np.uint8 else 1.0

else:

output_alpha = _resample( # resample alpha channel

self, A[..., 3], out_shape, t)

output = _resample( # resample rgb channels

self, _rgb_to_rgba(A[..., :3]), out_shape, t)

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

# user-specified array alpha overrides the existing alpha channel

output_alpha = _resample(self, alpha, out_shape, t)

output = _resample(

self, _rgb_to_rgba(A[..., :3]), out_shape, t)

else: # Scalar alpha

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

output_alpha = (255 * alpha) if A.dtype == np.uint8 else alpha

else: # or apply scalar alpha to existing alpha channel

output_alpha = _resample(self, A[..., 3], out_shape, t) * alpha

output = _resample(

self, _rgb_to_rgba(A[..., :3]), out_shape, t)

output[..., 3] = output_alpha # recombine rgb and alpha

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

# or an RGBA array of re-sampled input

output = self.to_rgba(output, 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, clipped_bbox.x0, clipped_bbox.y0, t

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

"""

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

def _check_unsampled_image(self):

"""

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_alpha(self._get_scalar_alpha())

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:

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

"""

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

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

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

f"converted to float")

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

"""

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

"""

# 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 self._interpolation

def set_interpolation(self, s):

"""

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 self._interpolation_stage

def set_interpolation_stage(self, s):

"""

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

"""

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

"""

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

"""

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."""

"""

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

"""

(xmin, xmax), (ymin, ymax) = self.axes._process_unit_info(

[("x", [extent[0], extent[1]]),

("y", [extent[2], extent[3]])],

kwargs)

if kwargs:

raise _api.kwarg_error("set_extent", kwargs)

xmin = self.axes._validate_converted_limits(

xmin, self.convert_xunits)

xmax = self.axes._validate_converted_limits(

xmax, self.convert_xunits)

ymin = self.axes._validate_converted_limits(

ymin, self.convert_yunits)

ymax = self.axes._validate_converted_limits(

ymax, self.convert_yunits)

extent = [xmin, xmax, ymin, ymax]

self._extent = extent

corners = (xmin, ymin), (xmax, ymax)

self.axes.update_datalim(corners)

self.sticky_edges.x[:] = [xmin, xmax]

self.sticky_edges.y[:] = [ymin, ymax]

if self.axes.get_autoscalex_on():

self.axes.set_xlim((xmin, xmax), auto=None)

if self.axes.get_autoscaley_on():

self.axes.set_ylim((ymin, ymax), auto=None)

self.stale = True

def get_extent(self):

"""Return the image extent as tuple (left, right, bottom, top)."""

if self._extent is not None:

return self._extent

else:

sz = self.get_size()

numrows, numcols = sz

if self.origin == 'upper':

return (-0.5, numcols-0.5, numrows-0.5, -0.5)

else:

return (-0.5, numcols-0.5, -0.5, numrows-0.5)

def get_cursor_data(self, event):

"""

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

if self.origin == 'upper':

ymin, ymax = ymax, ymin

arr = self.get_array()

data_extent = Bbox([[xmin, ymin], [xmax, ymax]])

array_extent = Bbox([[0, 0], [arr.shape[1], arr.shape[0]]])

trans = self.get_transform().inverted()

trans += BboxTransform(boxin=data_extent, boxout=array_extent)

point = trans.transform([event.x, event.y])

if any(np.isnan(point)):

return None

j, i = point.astype(int)

# Clip the coordinates at array bounds