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

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 = dict([(v, k) for k, v in six.iteritems(_interpd_)])

iterpnames = interpolations_names

# <end unused keys>

def set_cmap(self, cmap):

super(_AxesImageBase, self).set_cmap(cmap)

self.stale = True

def set_norm(self, norm):

super(_AxesImageBase, 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._filterrad = filterrad

self.set_interpolation(interpolation)

self.set_resample(resample)

self.axes = ax

self._imcache = None

# this is an experimental attribute, if True, unsampled image

# will be drawn using the affine transform that are

# appropriately skewed so that the given position

# corresponds to the actual position in the coordinate. -JJL

self._image_skew_coordinate = None

self.update(kwargs)

def __getstate__(self):

state = super(_AxesImageBase, 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, magnification=1.0):

raise RuntimeError('The make_image method must be overridden.')

def _get_unsampled_image(self, A, image_extents, viewlim):

"""

xmin, xmax, ymin, ymax = image_extents

dxintv = xmax-xmin

dyintv = ymax-ymin

# the viewport scale factor

if viewlim.width == 0.0 and dxintv == 0.0:

sx = 1.0

else:

sx = dxintv/viewlim.width

if viewlim.height == 0.0 and dyintv == 0.0:

sy = 1.0

else:

sy = dyintv/viewlim.height

numrows, numcols = A.shape[:2]

if sx > 2:

x0 = (viewlim.x0-xmin)/dxintv * numcols

ix0 = max(0, int(x0 - self._filterrad))

x1 = (viewlim.x1-xmin)/dxintv * numcols

ix1 = min(numcols, int(x1 + self._filterrad))

xslice = slice(ix0, ix1)

xmin_old = xmin

xmin = xmin_old + ix0*dxintv/numcols

xmax = xmin_old + ix1*dxintv/numcols

dxintv = xmax - xmin

sx = dxintv/viewlim.width

else:

xslice = slice(0, numcols)

if sy > 2:

y0 = (viewlim.y0-ymin)/dyintv * numrows

iy0 = max(0, int(y0 - self._filterrad))

y1 = (viewlim.y1-ymin)/dyintv * numrows

iy1 = min(numrows, int(y1 + self._filterrad))

yslice = slice(iy0, iy1)

ymin_old = ymin

ymin = ymin_old + iy0*dyintv/numrows

ymax = ymin_old + iy1*dyintv/numrows

dyintv = ymax - ymin

sy = dyintv/viewlim.height

else:

yslice = slice(0, numrows)

if xslice != self._oldxslice or yslice != self._oldyslice:

self._imcache = None

self._oldxslice = xslice

self._oldyslice = yslice

if self._imcache is None:

A = self._A

if self.origin == 'upper':

A = A[::-1]

if A.dtype == np.uint8 and A.ndim == 3:

im = _image.frombyte(A[yslice, xslice, :], 0)

im.is_grayscale = False

else:

if self._rgbacache is None:

x = self.to_rgba(A, bytes=False)

# Avoid side effects: to_rgba can return its argument

# unchanged.

if np.may_share_memory(x, A):

x = x.copy()

# premultiply the colors

x[..., 0:3] *= x[..., 3:4]

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

self._rgbacache = x

else:

x = self._rgbacache

im = _image.frombyte(x[yslice, xslice, :], 0)

if self._A.ndim == 2:

im.is_grayscale = self.cmap.is_gray()

else:

im.is_grayscale = False

self._imcache = im

else:

im = self._imcache

return im, xmin, ymin, dxintv, dyintv, sx, sy

@staticmethod

def _get_rotate_and_skew_transform(x1, y1, x2, y2, x3, y3):

"""

tr1 = mtransforms.Affine2D()

tr1.translate(-x1, -y1)

x2a, y2a = tr1.transform_point((x2, y2))

x3a, y3a = tr1.transform_point((x3, y3))

inv_mat = 1. / (x2a*y3a-y2a*x3a) * np.mat([[y3a, -y2a], [-x3a, x2a]])

a, b = (inv_mat * np.mat([[x2a], [x2a]])).flat

c, d = (inv_mat * np.mat([[y2a], [0]])).flat

tr2 = mtransforms.Affine2D.from_values(a, c, b, d, 0, 0)

tr = (tr1 + tr2 +

mtransforms.Affine2D().translate(x1, y1)).inverted().get_affine()

return tr

def _draw_unsampled_image(self, renderer, gc):

"""

trans = self.get_transform() # axes.transData

# convert the coordinates to the intermediate coordinate (ic).

# The transformation from the ic to the canvas is a pure

# affine transform.

# A straight-forward way is to use the non-affine part of the

# original transform for conversion to the ic.

# firs, convert the image extent to the ic

x_llc, x_trc, y_llc, y_trc = self.get_extent()

xy = trans.transform(np.array([(x_llc, y_llc),

(x_trc, y_trc)]))

_xx1, _yy1 = xy[0]

_xx2, _yy2 = xy[1]

extent_in_ic = _xx1, _xx2, _yy1, _yy2

# define trans_ic_to_canvas : unless _image_skew_coordinate is

# set, it is simply a affine part of the original transform.

if self._image_skew_coordinate:

# skew the image when required.

x_lrc, y_lrc = self._image_skew_coordinate

xy2 = trans.transform(np.array([(x_lrc, y_lrc)]))

_xx3, _yy3 = xy2[0]

tr_rotate_skew = self._get_rotate_and_skew_transform(_xx1, _yy1,

_xx2, _yy2,

_xx3, _yy3)

trans_ic_to_canvas = tr_rotate_skew

else:

trans_ic_to_canvas = IdentityTransform()

# Now, viewLim in the ic. It can be rotated and can be

# skewed. Make it big enough.

x1, y1, x2, y2 = self.axes.bbox.extents

trans_canvas_to_ic = trans_ic_to_canvas.inverted()

xy_ = trans_canvas_to_ic.transform(np.array([(x1, y1),

(x2, y1),

(x2, y2),

(x1, y2)]))

x1_, x2_ = min(xy_[:, 0]), max(xy_[:, 0])

y1_, y2_ = min(xy_[:, 1]), max(xy_[:, 1])

viewLim_in_ic = Bbox.from_extents(x1_, y1_, x2_, y2_)

# get the image, sliced if necessary. This is done in the ic.

im, xmin, ymin, dxintv, dyintv, sx, sy = \

self._get_unsampled_image(self._A, extent_in_ic, viewLim_in_ic)

if im is None:

return # I'm not if this check is required. -JJL

fc = self.axes.patch.get_facecolor()

bg = mcolors.colorConverter.to_rgba(fc, 0)

im.set_bg(*bg)

# image input dimensions

im.reset_matrix()

numrows, numcols = im.get_size()

if numrows <= 0 or numcols <= 0:

return

im.resize(numcols, numrows) # just to create im.bufOut that

# is required by backends. There

# may be better solution -JJL

im._url = self.get_url()

im._gid = self.get_gid()

renderer.draw_image(gc, xmin, ymin, im, dxintv, dyintv,

trans_ic_to_canvas)

def _check_unsampled_image(self, renderer):

"""

return False

@allow_rasterization

def draw(self, renderer, *args, **kwargs):

if not self.get_visible():

return

if (self.axes.get_xscale() != 'linear' or

self.axes.get_yscale() != 'linear'):

warnings.warn("Images are not supported on non-linear axes.")

l, b, widthDisplay, heightDisplay = self.axes.bbox.bounds

gc = renderer.new_gc()

self._set_gc_clip(gc)

gc.set_alpha(self.get_alpha())

if self._check_unsampled_image(renderer):

self._draw_unsampled_image(renderer, gc)

else:

if self._image_skew_coordinate is not None:

warnings.warn("Image will not be shown"

" correctly with this backend.")

im = self.make_image(renderer.get_image_magnification())

if im is None:

return

im._url = self.get_url()

im._gid = self.get_gid()

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

gc.restore()

self.stale = False

def contains(self, mouseevent):

"""

if six.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 = ((x >= xmin) and (x <= xmax) and

(y >= ymin) and (y <= ymax))

else:

inside = False

return inside, {}

def write_png(self, fname, noscale=False):

"""Write the image to png file with fname"""

im = self.make_image()

if im is None:

return

if noscale:

numrows, numcols = im.get_size()

im.reset_matrix()

im.set_interpolation(0)

im.resize(numcols, numrows)

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

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

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

raise TypeError("Image data can not convert to float")

if (self._A.ndim not in (2, 3) or

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

raise TypeError("Invalid dimensions for image data")

self._imcache = None

self._rgbacache = None

self._oldxslice = None

self._oldyslice = 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 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

_AxesImageBase.__init__(self, 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, magnification=1.0):

if self._A is None:

raise RuntimeError('You must first set the image'

' array or the image attribute')

# image is created in the canvas coordinate.

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

trans = self.get_transform()

xy = trans.transform(np.array([(x1, y1),

(x2, y2),

]))

_x1, _y1 = xy[0]

_x2, _y2 = xy[1]

transformed_viewLim = mtransforms.TransformedBbox(self.axes.viewLim,

trans)

im, xmin, ymin, dxintv, dyintv, sx, sy = \

self._get_unsampled_image(self._A, [_x1, _x2, _y1, _y2],

transformed_viewLim)

fc = self.axes.patch.get_facecolor()

bg = mcolors.colorConverter.to_rgba(fc, 0)

im.set_bg(*bg)

# image input dimensions

im.reset_matrix()

numrows, numcols = im.get_size()

if numrows < 1 or numcols < 1: # out of range

return None

im.set_interpolation(_interpd_[self._interpolation])

im.set_resample(self._resample)

# the viewport translation

if dxintv == 0.0:

tx = 0.0

else:

tx = (xmin-transformed_viewLim.x0)/dxintv * numcols

if dyintv == 0.0:

ty = 0.0

else:

ty = (ymin-transformed_viewLim.y0)/dyintv * numrows

im.apply_translation(tx, ty)

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

widthDisplay = ((round(r*magnification) + 0.5) -

(round(l*magnification) - 0.5))

heightDisplay = ((round(t*magnification) + 0.5) -

(round(b*magnification) - 0.5))

# resize viewport to display

rx = widthDisplay / numcols

ry = heightDisplay / numrows

im.apply_scaling(rx*sx, ry*sy)

im.resize(int(widthDisplay+0.5), int(heightDisplay+0.5),

norm=self._filternorm, radius=self._filterrad)

return im

def _check_unsampled_image(self, renderer):

"""

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

if renderer.option_scale_image():

return True

else:

warnings.warn("The backend (%s) does not support "

"interpolation='none'. The image will be "

"interpolated with 'nearest` "

"mode." % renderer.__class__)

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)

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 = mtransforms.Bbox([[ymin, xmin], [ymax, xmax]])

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

trans = mtransforms.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')

AxesImage.__init__(self, ax,

**kwargs)

self.set_interpolation(interp)

def _check_unsampled_image(self, renderer):

"""

return False

def make_image(self, magnification=1.0):

if self._A is None:

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

A = self._A

if len(A.shape) == 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 = (round(r) + 0.5) - (round(l) - 0.5)

height = (round(t) + 0.5) - (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])

fc = self.axes.patch.get_facecolor()

bg = mcolors.colorConverter.to_rgba(fc, 0)

im.set_bg(*bg)

im.is_grayscale = self.is_grayscale

return im

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

"""

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

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

A = cbook.safe_masked_invalid(A)

if len(x.shape) != 1 or len(y.shape) != 1\

or A.shape[0:2] != (y.shape[0], x.shape[0]):

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

if len(A.shape) not in [2, 3]:

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

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

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

"or four (RGBA) color components")

if len(A.shape) == 3 and A.shape[2] == 1:

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

self._A = A

self._Ax = x

self._Ay = y

self._imcache = None

# I am adding this in accor with _AxesImageBase.set_data --

# examples/pylab_examples/image_nonuniform.py was breaking on

# the call to _get_unsampled_image when the oldxslice attr was

# accessed - JDH 3/3/2010

self._oldxslice = None

self._oldyslice = 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

):

"""

martist.Artist.__init__(self)

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

self.axes = ax

self._rgbacache = None

# There is little point in caching the image itself because

# it needs to be remade if the bbox or viewlim change,

# so caching does help with zoom/pan/resize.

self.update(kwargs)

self.set_data(x, y, A)

def make_image(self, magnification=1.0):

if self._A is None:

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

fc = self.axes.patch.get_facecolor()

bg = mcolors.colorConverter.to_rgba(fc, 0)

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

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

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

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

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

width = int(round(width * magnification))

height = int(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:

A = self._rgbacache

vl = self.axes.viewLim

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

height,

width,

(vl.x0, vl.x1, vl.y0, vl.y1),

bg)

im.is_grayscale = self.is_grayscale

return im

def changed(self):

self._rgbacache = None

cm.ScalarMappable.changed(self)

@allow_rasterization

def draw(self, renderer, *args, **kwargs):

if not self.get_visible():

return

im = self.make_image(renderer.get_image_magnification())

gc = renderer.new_gc()

gc.set_clip_rectangle(self.axes.bbox.frozen())

gc.set_clip_path(self.get_clip_path())

gc.set_alpha(self.get_alpha())

renderer.draw_image(gc,

round(self.axes.bbox.xmin),

round(self.axes.bbox.ymin),

im)

gc.restore()

self.stale = False

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

A = cbook.safe_masked_invalid(A)

if x is None:

x = np.arange(0, A.shape[1]+1, dtype=np.float64)

else:

x = np.asarray(x, np.float64).ravel()

if y is None:

y = np.arange(0, A.shape[0]+1, dtype=np.float64)

else:

y = np.asarray(y, np.float64).ravel()

if A.shape[:2] != (y.size-1, x.size-1):

print(A.shape)

print(y.size)

print(x.size)

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

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

raise ValueError("A must be 2D or 3D")

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

A.shape = A.shape[:2]

self.is_grayscale = False

if A.ndim == 3:

if A.shape[2] in [3, 4]:

if ((A[:, :, 0] == A[:, :, 1]).all() and

(A[:, :, 0] == A[:, :, 2]).all()):

self.is_grayscale = True

else:

raise ValueError("3D arrays must have RGB or RGBA as last dim")

self._A = A

self._Ax = x

self._Ay = y

self._rgbacache = None

self.stale = True

def set_array(self, *args):

raise NotImplementedError('Method not supported')

def set_alpha(self, alpha):

"""

martist.Artist.set_alpha(self, alpha)

zorder = 0

def __init__(self, fig,

cmap=None,

norm=None,

offsetx=0,

offsety=0,

origin=None,

**kwargs

):

"""