'ps': 'Postscript',

'eps': 'Encapsulated Postscript',

'pdf': 'Portable Document Format',

'pgf': 'PGF code for LaTeX',

'png': 'Portable Network Graphics',

'raw': 'Raw RGBA bitmap',

'rgba': 'Raw RGBA bitmap',

'svg': 'Scalable Vector Graphics',

'svgz': 'Scalable Vector Graphics'

'ps': 'matplotlib.backends.backend_ps',

'eps': 'matplotlib.backends.backend_ps',

'pdf': 'matplotlib.backends.backend_pdf',

'pgf': 'matplotlib.backends.backend_pgf',

'png': 'matplotlib.backends.backend_agg',

'raw': 'matplotlib.backends.backend_agg',

'rgba': 'matplotlib.backends.backend_agg',

'svg': 'matplotlib.backends.backend_svg',

'svgz': 'matplotlib.backends.backend_svg',

"""

if description is None:

description = ''

_default_backends[format] = backend

"""

if format not in _default_backends:

return None

backend_class = _default_backends[format]

if isinstance(backend_class, six.string_types):

backend_class = importlib.import_module(backend_class).FigureCanvas

_default_backends[format] = backend_class

"""

def __call__(self, block=None):

"""

managers = Gcf.get_all_fig_managers()

if not managers:

return

for manager in managers:

manager.show()

if block is not None:

if block:

self.mainloop()

return

else:

return

# Hack: determine at runtime whether we are

# inside ipython in pylab mode.

from matplotlib import pyplot

try:

ipython_pylab = not pyplot.show._needmain

# IPython versions >= 0.10 tack the _needmain

# attribute onto pyplot.show, and always set

# it to False, when in %pylab mode.

ipython_pylab = ipython_pylab and get_backend() != 'WebAgg'

# TODO: The above is a hack to get the WebAgg backend

# working with ipython's `%pylab` mode until proper

# integration is implemented.

except AttributeError:

ipython_pylab = False

# Leave the following as a separate step in case we

# want to control this behavior with an rcParam.

if ipython_pylab:

return

if not is_interactive() or get_backend() == 'WebAgg':

self.mainloop()

def mainloop(self):

"""An abstract base class to handle drawing/rendering operations.

def __init__(self):

# A lightweight id for unique-ification purposes. Along with id(self),

# the combination should be unique enough to use as part of a cache key.

self._uid = next(_unique_renderer_id)

self._texmanager = None

self._text2path = textpath.TextToPath()

def open_group(self, s, gid=None):

"""

def close_group(self, s):

"""

def draw_path(self, gc, path, transform, rgbFace=None):

"""

raise NotImplementedError

def draw_markers(self, gc, marker_path, marker_trans, path,

trans, rgbFace=None):

"""

for vertices, codes in path.iter_segments(trans, simplify=False):

if len(vertices):

x, y = vertices[-2:]

self.draw_path(gc, marker_path,

marker_trans +

transforms.Affine2D().translate(x, y),

rgbFace)

def draw_path_collection(self, gc, master_transform, paths, all_transforms,

offsets, offsetTrans, facecolors, edgecolors,

linewidths, linestyles, antialiaseds, urls,

offset_position):

"""

path_ids = []

for path, transform in self._iter_collection_raw_paths(

master_transform, paths, all_transforms):

path_ids.append((path, transforms.Affine2D(transform)))

for xo, yo, path_id, gc0, rgbFace in self._iter_collection(

gc, master_transform, all_transforms, path_ids, offsets,

offsetTrans, facecolors, edgecolors, linewidths, linestyles,

antialiaseds, urls, offset_position):

path, transform = path_id

transform = transforms.Affine2D(

transform.get_matrix()).translate(xo, yo)

self.draw_path(gc0, path, transform, rgbFace)

def draw_quad_mesh(self, gc, master_transform, meshWidth, meshHeight,

coordinates, offsets, offsetTrans, facecolors,

antialiased, edgecolors):

"""

from matplotlib.collections import QuadMesh

paths = QuadMesh.convert_mesh_to_paths(

meshWidth, meshHeight, coordinates)

if edgecolors is None:

edgecolors = facecolors

linewidths = np.array([gc.get_linewidth()], float)

return self.draw_path_collection(

gc, master_transform, paths, [], offsets, offsetTrans, facecolors,

edgecolors, linewidths, [], [antialiased], [None], 'screen')

def draw_gouraud_triangle(self, gc, points, colors, transform):

"""

raise NotImplementedError

def draw_gouraud_triangles(self, gc, triangles_array, colors_array,

transform):

"""

transform = transform.frozen()

for tri, col in zip(triangles_array, colors_array):

self.draw_gouraud_triangle(gc, tri, col, transform)

def _iter_collection_raw_paths(self, master_transform, paths,

all_transforms):

"""

Npaths = len(paths)

Ntransforms = len(all_transforms)

N = max(Npaths, Ntransforms)

if Npaths == 0:

return

transform = transforms.IdentityTransform()

for i in xrange(N):

path = paths[i % Npaths]

if Ntransforms:

transform = Affine2D(all_transforms[i % Ntransforms])

yield path, transform + master_transform

def _iter_collection_uses_per_path(self, paths, all_transforms,

offsets, facecolors, edgecolors):

"""

Npaths = len(paths)

if Npaths == 0 or (len(facecolors) == 0 and len(edgecolors) == 0):

return 0

Npath_ids = max(Npaths, len(all_transforms))

N = max(Npath_ids, len(offsets))

return (N + Npath_ids - 1) // Npath_ids

def _iter_collection(self, gc, master_transform, all_transforms,

path_ids, offsets, offsetTrans, facecolors,

edgecolors, linewidths, linestyles,

antialiaseds, urls, offset_position):

"""

Ntransforms = len(all_transforms)

Npaths = len(path_ids)

Noffsets = len(offsets)

N = max(Npaths, Noffsets)

Nfacecolors = len(facecolors)

Nedgecolors = len(edgecolors)

Nlinewidths = len(linewidths)

Nlinestyles = len(linestyles)

Naa = len(antialiaseds)

Nurls = len(urls)

if (Nfacecolors == 0 and Nedgecolors == 0) or Npaths == 0:

return

if Noffsets:

toffsets = offsetTrans.transform(offsets)

gc0 = self.new_gc()

gc0.copy_properties(gc)

if Nfacecolors == 0:

rgbFace = None

if Nedgecolors == 0:

gc0.set_linewidth(0.0)

xo, yo = 0, 0

for i in xrange(N):

path_id = path_ids[i % Npaths]

if Noffsets:

xo, yo = toffsets[i % Noffsets]

if offset_position == 'data':

if Ntransforms:

transform = (

Affine2D(all_transforms[i % Ntransforms]) +

master_transform)

else:

transform = master_transform

xo, yo = transform.transform_point((xo, yo))

xp, yp = transform.transform_point((0, 0))

xo = -(xp - xo)

yo = -(yp - yo)

if not (np.isfinite(xo) and np.isfinite(yo)):

continue

if Nfacecolors:

rgbFace = facecolors[i % Nfacecolors]

if Nedgecolors:

if Nlinewidths:

gc0.set_linewidth(linewidths[i % Nlinewidths])

if Nlinestyles:

gc0.set_dashes(*linestyles[i % Nlinestyles])

fg = edgecolors[i % Nedgecolors]

if len(fg) == 4:

if fg[3] == 0.0:

gc0.set_linewidth(0)

else:

gc0.set_foreground(fg)

else:

gc0.set_foreground(fg)

if rgbFace is not None and len(rgbFace) == 4:

if rgbFace[3] == 0:

rgbFace = None

gc0.set_antialiased(antialiaseds[i % Naa])

if Nurls:

gc0.set_url(urls[i % Nurls])

yield xo, yo, path_id, gc0, rgbFace

gc0.restore()

def get_image_magnification(self):

"""

return 1.0

def draw_image(self, gc, x, y, im, transform=None):

"""

raise NotImplementedError

def option_image_nocomposite(self):

"""

return False

def option_scale_image(self):

"""

return False

def draw_tex(self, gc, x, y, s, prop, angle, ismath='TeX!', mtext=None):

"""

self._draw_text_as_path(gc, x, y, s, prop, angle, ismath="TeX")

def draw_text(self, gc, x, y, s, prop, angle, ismath=False, mtext=None):

"""

self._draw_text_as_path(gc, x, y, s, prop, angle, ismath)

def _get_text_path_transform(self, x, y, s, prop, angle, ismath):

"""

text2path = self._text2path

fontsize = self.points_to_pixels(prop.get_size_in_points())

if ismath == "TeX":

verts, codes = text2path.get_text_path(prop, s, ismath=False,

usetex=True)

else:

verts, codes = text2path.get_text_path(prop, s, ismath=ismath,

usetex=False)

path = Path(verts, codes)

angle = np.deg2rad(angle)

if self.flipy():

transform = Affine2D().scale(fontsize / text2path.FONT_SCALE,

fontsize / text2path.FONT_SCALE)

transform = transform.rotate(angle).translate(x, self.height - y)

else:

transform = Affine2D().scale(fontsize / text2path.FONT_SCALE,

fontsize / text2path.FONT_SCALE)

transform = transform.rotate(angle).translate(x, y)

return path, transform

def _draw_text_as_path(self, gc, x, y, s, prop, angle, ismath):

"""

path, transform = self._get_text_path_transform(

x, y, s, prop, angle, ismath)

color = gc.get_rgb()

gc.set_linewidth(0.0)

self.draw_path(gc, path, transform, rgbFace=color)

def get_text_width_height_descent(self, s, prop, ismath):

"""

if ismath == 'TeX':

# todo: handle props

size = prop.get_size_in_points()

texmanager = self._text2path.get_texmanager()

fontsize = prop.get_size_in_points()

w, h, d = texmanager.get_text_width_height_descent(

s, fontsize, renderer=self)

return w, h, d

dpi = self.points_to_pixels(72)

if ismath:

dims = self._text2path.mathtext_parser.parse(s, dpi, prop)

return dims[0:3] # return width, height, descent

flags = self._text2path._get_hinting_flag()

font = self._text2path._get_font(prop)

size = prop.get_size_in_points()

font.set_size(size, dpi)

# the width and height of unrotated string

font.set_text(s, 0.0, flags=flags)

w, h = font.get_width_height()

d = font.get_descent()

w /= 64.0 # convert from subpixels

h /= 64.0

d /= 64.0

return w, h, d

def flipy(self):

"""

return True

def get_canvas_width_height(self):

'return the canvas width and height in display coords'

return 1, 1

def get_texmanager(self):

"""

if self._texmanager is None:

from matplotlib.texmanager import TexManager

self._texmanager = TexManager()

return self._texmanager

def new_gc(self):

"""

return GraphicsContextBase()

def points_to_pixels(self, points):

"""

return points

def strip_math(self, s):

return cbook.strip_math(s)

def start_rasterizing(self):

"""

def stop_rasterizing(self):

"""

def start_filter(self):

"""

def stop_filter(self, filter_func):

"""

"""

def __init__(self):

self._alpha = 1.0

self._forced_alpha = False # if True, _alpha overrides A from RGBA

self._antialiased = 1 # use 0,1 not True, False for extension code

self._capstyle = 'butt'

self._cliprect = None

self._clippath = None

self._dashes = None, None

self._joinstyle = 'round'

self._linestyle = 'solid'

self._linewidth = 1

self._rgb = (0.0, 0.0, 0.0, 1.0)

self._hatch = None

self._hatch_color = colors.to_rgba(rcParams['hatch.color'])

self._hatch_linewidth = rcParams['hatch.linewidth']

self._url = None

self._gid = None

self._snap = None

self._sketch = None

def copy_properties(self, gc):

'Copy properties from gc to self'

self._alpha = gc._alpha

self._forced_alpha = gc._forced_alpha

self._antialiased = gc._antialiased

self._capstyle = gc._capstyle

self._cliprect = gc._cliprect

self._clippath = gc._clippath

self._dashes = gc._dashes

self._joinstyle = gc._joinstyle

self._linestyle = gc._linestyle

self._linewidth = gc._linewidth

self._rgb = gc._rgb

self._hatch = gc._hatch

self._hatch_color = gc._hatch_color

self._hatch_linewidth = gc._hatch_linewidth

self._url = gc._url

self._gid = gc._gid

self._snap = gc._snap

self._sketch = gc._sketch

def restore(self):

"""

def get_alpha(self):

"""

return self._alpha

def get_antialiased(self):

"Return true if the object should try to do antialiased rendering"

return self._antialiased

def get_capstyle(self):

"""

return self._capstyle

def get_clip_rectangle(self):

"""

return self._cliprect

def get_clip_path(self):

"""

if self._clippath is not None:

return self._clippath.get_transformed_path_and_affine()

return None, None

def get_dashes(self):

"""

return self._dashes

def get_forced_alpha(self):

"""

return self._forced_alpha

def get_joinstyle(self):

"""

return self._joinstyle

@cbook.deprecated("2.1")

def get_linestyle(self):

"""

return self._linestyle

def get_linewidth(self):

"""

return self._linewidth

def get_rgb(self):

"""

return self._rgb

def get_url(self):

"""

return self._url

def get_gid(self):

"""

return self._gid

def get_snap(self):

"""

return self._snap

def set_alpha(self, alpha):

"""

if alpha is not None:

self._alpha = alpha

self._forced_alpha = True

else:

self._alpha = 1.0

self._forced_alpha = False

self.set_foreground(self._rgb, isRGBA=True)

def set_antialiased(self, b):

"""

# use 0, 1 to make life easier on extension code trying to read the gc

if b:

self._antialiased = 1

else:

self._antialiased = 0

def set_capstyle(self, cs):

"""

if cs in ('butt', 'round', 'projecting'):

self._capstyle = cs

else:

raise ValueError('Unrecognized cap style. Found %s' % cs)