'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_alpha() or 1.0))

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 = renderer.option_image_nocomposite()

if suppress_composite is not None:

not_composite = suppress_composite

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, np.round(l), np.round(b), data)

gc.restore()

del image_group[:]

for a in artists:

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

image_group.append(a)

else:

flush_images()

a.draw(renderer)

"""

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

# the 3 following keys seem to be unused now, keep it for

# backward compatibility just in case.

_interpd = _interpd_

# reverse interp dict

_interpdr = {v: k for k, v in six.iteritems(_interpd_)}

iterpnames = interpolations_names

# <end unused keys>

def set_cmap(self, cmap):

super(_ImageBase, self).set_cmap(cmap)

self.stale = True

def set_norm(self, norm):

super(_ImageBase, self).set_norm(norm)

self.stale = True

def __str__(self):

return "AxesImage(%g,%g;%gx%g)" % tuple(self.axes.bbox.bounds)

def __init__(self, ax,

cmap=None,

norm=None,

interpolation=None,

origin=None,

filternorm=1,

filterrad=4.0,

resample=False,

**kwargs

):

"""

martist.Artist.__init__(self)

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

self._mouseover = True

if origin is None:

origin = rcParams['image.origin']

self.origin = origin

self.set_filternorm(filternorm)

self.set_filterrad(filterrad)

self.set_interpolation(interpolation)

self.set_resample(resample)

self.axes = ax

self._imcache = None

self.update(kwargs)

def __getstate__(self):

state = super(_ImageBase, self).__getstate__()

# We can't pickle the C Image cached object.

state['_imcache'] = None

return state

def get_size(self):

"""Get the numrows, numcols of the input image"""

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(self, alpha)

self._imcache = None

def changed(self):

"""

self._imcache = None

self._rgbacache = 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, 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 just 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 = int(ceil(out_width_base))

out_height = int(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)

if not unsampled:

created_rgba_mask = False

if A.ndim not in (2, 3):

raise ValueError("Invalid dimensions, got {}".format(A.shape))

if A.ndim == 2:

A = self.norm(A)

if A.dtype.kind == 'f':

# If the image is greyscale, convert to RGBA and

# use the extra channels for resizing the over,

# under, and bad pixels. This is needed because

# Agg's resampler is very aggressive about

# clipping to [0, 1] and we use out-of-bounds

# values to carry the over/under/bad information

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

rgba[..., 0] = A # normalized data

# this is to work around spurious warnings coming

# out of masked arrays.

with np.errstate(invalid='ignore'):

rgba[..., 1] = np.where(A < 0, np.nan, 1) # under data

rgba[..., 2] = np.where(A > 1, np.nan, 1) # over data

# Have to invert mask, Agg knows what alpha means

# so if you put this in as 0 for 'good' points, they

# all get zeroed out

rgba[..., 3] = 1

if A.mask.shape == A.shape:

# this is the case of a nontrivial mask

mask = np.where(A.mask, np.nan, 1)

else:

# this is the case that the mask is a

# numpy.bool_ of False

mask = A.mask

# ~A.mask # masked data

A = rgba

output = np.zeros((out_height, out_width, 4),

dtype=A.dtype)

alpha = 1.0

created_rgba_mask = True

else:

# colormap norms that output integers (ex NoNorm

# and BoundaryNorm) to RGBA space before

# interpolating. This is needed due to the

# Agg resampler only working on floats in the

# range [0, 1] and because interpolating indexes

# into an arbitrary LUT may be problematic.

#

# This falls back to interpolating in RGBA space which

# can produce it's own artifacts of colors not in the map

# showing up in the final image.

A = self.cmap(A, alpha=self.get_alpha(), bytes=True)

if not created_rgba_mask:

# Always convert to RGBA, even if only RGB input

if A.shape[2] == 3:

A = _rgb_to_rgba(A)

elif A.shape[2] != 4:

raise ValueError("Invalid dimensions, got %s" % (A.shape,))

output = np.zeros((out_height, out_width, 4), dtype=A.dtype)

alpha = self.get_alpha()

if alpha is None:

alpha = 1.0

_image.resample(

A, output, t, _interpd_[self.get_interpolation()],

self.get_resample(), alpha,

self.get_filternorm() or 0.0, self.get_filterrad() or 0.0)

if created_rgba_mask:

# Convert back to a masked greyscale array so

# colormapping works correctly

hid_output = output

# any pixel where the a masked pixel is included

# in the kernel (pulling this down from 1) needs to

# be masked in the output

if len(mask.shape) == 2:

out_mask = np.empty((out_height, out_width),

dtype=mask.dtype)

_image.resample(mask, out_mask, t,

_interpd_[self.get_interpolation()],

True, 1,

self.get_filternorm() or 0.0,

self.get_filterrad() or 0.0)

out_mask = np.isnan(out_mask)

else:

out_mask = mask

# we need to mask both pixels which came in as masked

# and the pixels that Agg is telling us to ignore (relavent

# to non-affine transforms)

# Use half alpha as the threshold for pixels to mask.

out_mask = out_mask | (hid_output[..., 3] < .5)

output = np.ma.masked_array(

hid_output[..., 0],

out_mask)

# 'unshare' the mask array to

# needed to suppress numpy warning

del out_mask

invalid_mask = ~output.mask * ~np.isnan(output.data)

# relabel under data. If any of the input data for

# the pixel has input out of the norm bounds,

output[np.isnan(hid_output[..., 1]) * invalid_mask] = -1

# relabel over data

output[np.isnan(hid_output[..., 2]) * invalid_mask] = 2

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

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

if A.ndim == 2 or created_rgba_mask:

alpha = self.get_alpha()

if alpha is not None and alpha != 1.0:

alpha_channel = output[:, :, 3]

alpha_channel[:] = np.asarray(

np.asarray(alpha_channel, np.float32) * alpha,

np.uint8)

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.frozen().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 RuntimeError('The make_image method must be overridden.')

def _draw_unsampled_image(self, renderer, gc):

"""

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

if im is None:

return

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

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

def _check_unsampled_image(self, renderer):

"""

return False

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

gc.set_url(self.get_url())

gc.set_gid(self.get_gid())

if (self._check_unsampled_image(renderer) and

self.get_transform().is_affine):

self._draw_unsampled_image(renderer, gc)

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

"""

if callable(self._contains):

return self._contains(self, mouseevent)

# 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

x, y = mouseevent.xdata, mouseevent.ydata

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 with fname"""

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

bytes=True, norm=True)

_png.write_png(im, fname)

def set_data(self, A):

"""

# check if data is PIL Image without importing Image

if hasattr(A, 'getpixel'):

self._A = pil_to_array(A)

else:

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("Image data cannot be converted to float")

if not (self._A.ndim == 2

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

raise TypeError("Invalid dimensions for image data")

self._imcache = None

self._rgbacache = 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 = rcParams['image.interpolation']

s = s.lower()

if s not in _interpd_:

raise ValueError('Illegal interpolation string')

self._interpolation = s

self.stale = True

def can_composite(self):

"""

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 = rcParams['image.resample']

self._resample = v

self.stale = True

def get_resample(self):

"""Return the image resample boolean"""

return self._resample

def set_filternorm(self, filternorm):

"""

if filternorm:

self._filternorm = 1

else:

self._filternorm = 0

self.stale = True

def get_filternorm(self):

"""Return the filternorm setting"""

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

return "AxesImage(%g,%g;%gx%g)" % tuple(self.axes.bbox.bounds)

def __init__(self, ax,

cmap=None,

norm=None,

interpolation=None,

origin=None,

extent=None,

filternorm=1,

filterrad=4.0,

resample=False,

**kwargs

):

"""

self._extent = extent

super(AxesImage, self).__init__(

ax,

cmap=cmap,

norm=norm,

interpolation=interpolation,

origin=origin,

filternorm=filternorm,

filterrad=filterrad,

resample=resample,

**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.axes.transData)

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

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)

return self._make_image(

self._A, bbox, transformed_bbox, self.axes.bbox, magnification,

unsampled=unsampled)

def _check_unsampled_image(self, renderer):

"""

if (self.get_interpolation() == "none" and

renderer.option_scale_image()):

return True

return False

def set_extent(self, extent):

"""

self._extent = extent

xmin, xmax, ymin, ymax = 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._autoscaleXon:

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

if self.axes._autoscaleYon:

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

self.stale = True

def get_extent(self):

"""Get the image extent: 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):

"""Get the cursor data for a given event"""

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

if self.origin == 'upper':

ymin, ymax = ymax, ymin

arr = self.get_array()

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

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

trans = BboxTransform(boxin=data_extent,

boxout=array_extent)

y, x = event.ydata, event.xdata

i, j = trans.transform_point([y, x]).astype(int)

# Clip the coordinates at array bounds

if not (0 <= i < arr.shape[0]) or not (0 <= j < arr.shape[1]):

return None

else:

def __init__(self, ax, **kwargs):

"""

interp = kwargs.pop('interpolation', 'nearest')

super(NonUniformImage, self).__init__(ax, **kwargs)

self.set_interpolation(interp)

def _check_unsampled_image(self, renderer):

"""

return False

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

if self._A is None:

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

if unsampled:

raise ValueError('unsampled not supported on NonUniformImage')

A = self._A

if A.ndim == 2:

if A.dtype != np.uint8:

A = self.to_rgba(A, bytes=True)

self.is_grayscale = self.cmap.is_gray()

else:

A = np.repeat(A[:, :, np.newaxis], 4, 2)

A[:, :, 3] = 255

self.is_grayscale = True

else:

if A.dtype != np.uint8:

A = (255*A).astype(np.uint8)

if A.shape[2] == 3:

B = np.zeros(tuple(list(A.shape[0:2]) + [4]), np.uint8)

B[:, :, 0:3] = A

B[:, :, 3] = 255

A = B

self.is_grayscale = False

x0, y0, v_width, v_height = self.axes.viewLim.bounds

l, b, r, t = self.axes.bbox.extents

width = (np.round(r) + 0.5) - (np.round(l) - 0.5)

height = (np.round(t) + 0.5) - (np.round(b) - 0.5)

width *= magnification

height *= magnification

im = _image.pcolor(self._Ax, self._Ay, A,

int(height), int(width),

(x0, x0+v_width, y0, y0+v_height),

_interpd_[self._interpolation])

return im, l, b, IdentityTransform()

def set_data(self, x, y, A):

"""

x = np.array(x, np.float32)

y = np.array(y, np.float32)

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

if not (x.ndim == y.ndim == 1 and A.shape[0:2] == y.shape + x.shape):

raise TypeError("Axes don't match array shape")

if A.ndim not in [2, 3]:

raise TypeError("Can only plot 2D or 3D data")

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

raise TypeError("3D arrays must have three (RGB) "

"or four (RGBA) color components")

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

A.shape = A.shape[0:2]

self._A = A

self._Ax = x

self._Ay = y

self._imcache = None

self.stale = True

def set_array(self, *args):

raise NotImplementedError('Method not supported')

def set_interpolation(self, s):

if s is not None and s not in ('nearest', 'bilinear'):

raise NotImplementedError('Only nearest neighbor and '

'bilinear interpolations are supported')

AxesImage.set_interpolation(self, s)

def get_extent(self):

if self._A is None:

raise RuntimeError('Must set data first')

return self._Ax[0], self._Ax[-1], self._Ay[0], self._Ay[-1]

def set_filternorm(self, s):

pass

def set_filterrad(self, s):

pass

def set_norm(self, norm):

if self._A is not None:

raise RuntimeError('Cannot change colors after loading data')

super(NonUniformImage, self).set_norm(norm)

def set_cmap(self, cmap):

if self._A is not None:

raise RuntimeError('Cannot change colors after loading data')

"""

def __init__(self, ax,

x=None,

y=None,

A=None,

cmap=None,

norm=None,

**kwargs

):

"""

super(PcolorImage, self).__init__(ax, norm=norm, cmap=cmap)

self.update(kwargs)

if A is not None:

self.set_data(x, y, A)

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

if self._A is None:

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

if unsampled:

raise ValueError('unsampled not supported on PColorImage')

fc = self.axes.patch.get_facecolor()

bg = mcolors.to_rgba(fc, 0)

bg = (np.array(bg)*255).astype(np.uint8)

l, b, r, t = self.axes.bbox.extents

width = (np.round(r) + 0.5) - (np.round(l) - 0.5)

height = (np.round(t) + 0.5) - (np.round(b) - 0.5)

# The extra cast-to-int is only needed for python2

width = int(np.round(width * magnification))

height = int(np.round(height * magnification))

if self._rgbacache is None:

A = self.to_rgba(self._A, bytes=True)

self._rgbacache = A

if self._A.ndim == 2:

self.is_grayscale = self.cmap.is_gray()

else: