'antialiased': _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,

"""

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 == 'antialiased':

# 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,

interpolation=None,

origin=None,

filternorm=True,

filterrad=4.0,

resample=False,

*,

interpolation_stage=None,

**kwargs

):

martist.Artist.__init__(self)

cm.ScalarMappable.__init__(self, norm, cmap)

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:

size = self.get_size()

return f"{type(self).__name__}(size={size!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)."""

if self._A is None:

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

return self._A.shape[:2]

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

cm.ScalarMappable.changed(self)

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 (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 A.ndim == 2 and self._interpolation_stage != 'rgba':

# 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

# TODO slice input array first

a_min = A.min()

a_max = A.max()

if a_min is np.ma.masked: # All masked; values don't matter.

a_min, a_max = np.int32(0), np.int32(1)

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

scaled_dtype = np.dtype(

np.float64 if A.dtype.itemsize > 4 else np.float32)

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.

# Scale to appropriately sized float: use float32 if the

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

da = a_max.astype(np.float64) - a_min.astype(np.float64)

scaled_dtype = np.float64 if da > 1e8 else np.float32

# Scale the input data to [.1, .9]. The Agg interpolators clip

# to [0, 1] internally, and we use a smaller input scale to

# identify the interpolated points that need to be flagged as

# over/under. This may introduce numeric instabilities in very

# broadly scaled data.

# Always copy, and don't allow array subtypes.

A_scaled = np.array(A, dtype=scaled_dtype)

# Clip scaled data around norm if necessary. This is necessary

# for big numbers at the edge of float64's ability to represent

# changes. Applying a norm first would be good, but ruins the

# interpolation of over numbers.

self.norm.autoscale_None(A)

dv = np.float64(self.norm.vmax) - np.float64(self.norm.vmin)

vmid = np.float64(self.norm.vmin) + dv / 2

fact = 1e7 if scaled_dtype == np.float64 else 1e4

newmin = vmid - dv * fact

if newmin < a_min:

newmin = None

else:

a_min = np.float64(newmin)

newmax = vmid + dv * fact

if newmax > a_max:

newmax = None

else:

a_max = np.float64(newmax)

if newmax is not None or newmin is not None:

np.clip(A_scaled, newmin, newmax, out=A_scaled)

# Rescale the raw data to [offset, 1-offset] so that the

# resampling code will run cleanly. Using dyadic numbers here

# could reduce the error, but would not fully eliminate it and

# breaks a number of tests (due to the slightly different

# error bouncing some pixels across a boundary in the (very

# quantized) colormapping step).

offset = .1

frac = .8

# Run vmin/vmax through the same rescaling as the raw data;

# otherwise, data values close or equal to the boundaries can

# end up on the wrong side due to floating point error.

vmin, vmax = self.norm.vmin, self.norm.vmax

if vmin is np.ma.masked:

vmin, vmax = a_min, a_max

vrange = np.array([vmin, vmax], dtype=scaled_dtype)

A_scaled -= a_min

vrange -= a_min

# .item() handles a_min/a_max being ndarray subclasses.

a_min = a_min.astype(scaled_dtype).item()

a_max = a_max.astype(scaled_dtype).item()

if a_min != a_max:

A_scaled /= ((a_max - a_min) / frac)

vrange /= ((a_max - a_min) / frac)

A_scaled += offset

vrange += offset

# resample the input data to the correct resolution and shape

A_resampled = _resample(self, A_scaled, out_shape, t)

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

# Un-scale the resampled data to approximately the original

# range. Things that interpolated to outside the original range

# will still be outside, but possibly clipped in the case of

# higher order interpolation + drastically changing data.

A_resampled -= offset

vrange -= offset

if a_min != a_max:

A_resampled *= ((a_max - a_min) / frac)

vrange *= ((a_max - a_min) / frac)

A_resampled += a_min

vrange += a_min

# if using NoNorm, cast back to the original datatype

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

A_resampled = A_resampled.astype(A.dtype)

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!

# Agg updates out_alpha in place. If the pixel has no image

# data it will not be updated (and still be 0 as we initialized

# it), if input data that would go into that output pixel than

# it will be `nan`, if all the input data for a pixel is good

# it will be 1, and if there is _some_ good data in that output

# pixel it will be between [0, 1] (such as a rotated image).

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)

# we have re-set the vmin/vmax to account for small errors

# that may have moved input values in/out of range

s_vmin, s_vmax = vrange

if isinstance(self.norm, mcolors.LogNorm) and s_vmin <= 0:

# Don't give 0 or negative values to LogNorm

s_vmin = np.finfo(scaled_dtype).eps

# Block the norm from sending an update signal during the

# temporary vmin/vmax change

with self.norm.callbacks.blocked(), \

cbook._setattr_cm(self.norm, vmin=s_vmin, vmax=s_vmax):

output = self.norm(resampled_masked)

else:

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

self.norm.autoscale_None(A)

A = self.to_rgba(A)

if A.shape[2] == 3:

A = _rgb_to_rgba(A)

alpha = self._get_scalar_alpha()

output_alpha = _resample( # resample alpha channel

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

output = _resample( # resample rgb channels

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

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, *args, **kwargs):

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

inside, info = self._default_contains(mouseevent)

if inside is not None:

return inside, info

# 1) This doesn't work for figimage; but figimage also needs a fix

# below (as the check cannot use x/ydata and extents).

# 2) As long as the check below uses x/ydata, we need to test axes

# identity instead of `self.axes.contains(event)` because even if

# axes overlap, x/ydata is only valid for event.inaxes anyways.

if self.axes is not mouseevent.inaxes:

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

if xmin > xmax:

xmin, xmax = xmax, xmin

if ymin > ymax:

ymin, ymax = ymax, ymin

if x is not None and y is not None:

inside = (xmin <= x <= xmax) and (ymin <= y <= ymax)

else:

inside = False

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

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 = cbook.safe_masked_invalid(A, copy=True)

if (self._A.dtype != np.uint8 and

not np.can_cast(self._A.dtype, float, "same_kind")):

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

"converted to float")

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

# If just one dimension assume scalar and apply colormap

self._A = self._A[:, :, 0]

if not (self._A.ndim == 2

or self._A.ndim == 3 and self._A.shape[-1] in [3, 4]):

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

if self._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(self._A.dtype, np.integer) else 1

if self._A.min() < 0 or high < self._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).'

)

self._A = np.clip(self._A, 0, high)

# Cast unsupported integer types to uint8

if self._A.dtype != np.uint8 and np.issubdtype(self._A.dtype,

np.integer):

self._A = self._A.astype(np.uint8)

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

"""

if s is None:

s = mpl.rcParams['image.interpolation']

s = s.lower()

_api.check_in_list(_interpd_, interpolation=s)

self._interpolation = s

self.stale = True

def set_interpolation_stage(self, s):

"""

if s is None:

s = "data" # placeholder for maybe having rcParam

_api.check_in_list(['data', 'rgba'], 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):

"""

if v is None:

v = mpl.rcParams['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,

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,

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