'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, str):

backend_class = importlib.import_module(backend_class).FigureCanvas

_default_backends[format] = backend_class

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

def __init__(self):

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 = [

(path, transforms.Affine2D(transform))

for path, transform in self._iter_collection_raw_paths(

master_transform, paths, all_transforms)]

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

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

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

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

"""Return the `.TexManager` instance."""

if self._texmanager is None:

from matplotlib.texmanager import TexManager

self._texmanager = TexManager()

return self._texmanager

def new_gc(self):

"""Return an instance of a `GraphicsContextBase`."""

return GraphicsContextBase()

def points_to_pixels(self, points):

"""

return points

@cbook.deprecated("3.1", alternative="cbook.strip_math")

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

"""

"""An abstract base class that provides color, line styles, etc."""

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 whether 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 the line join style as one of ('miter', 'round', 'bevel')."""

return self._joinstyle

def get_linewidth(self):

"""Return the line width in points."""

return self._linewidth

def get_rgb(self):

"""Return a tuple of three or four floats from 0-1."""

return self._rgb

def get_url(self):

"""Return a url if one is set, None otherwise."""

return self._url

def get_gid(self):

"""Return the object identifier if one is set, None otherwise."""

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

"""Set whether object should be drawn with antialiased rendering."""

# Use ints to make life easier on extension code trying to read the gc.

self._antialiased = int(bool(b))

def set_capstyle(self, cs):

"""Set the capstyle to be one of ('butt', 'round', 'projecting')."""

cbook._check_in_list(['butt', 'round', 'projecting'], cs=cs)

self._capstyle = cs

def set_clip_rectangle(self, rectangle):

"""

self._cliprect = rectangle

def set_clip_path(self, path):

"""

if (path is not None

and not isinstance(path, transforms.TransformedPath)):

raise ValueError("Path should be a "

"matplotlib.transforms.TransformedPath instance")

self._clippath = path

def set_dashes(self, dash_offset, dash_list):

"""

if dash_list is not None:

dl = np.asarray(dash_list)

if np.any(dl < 0.0):

raise ValueError(

"All values in the dash list must be positive")

self._dashes = dash_offset, dash_list

def set_foreground(self, fg, isRGBA=False):

"""

if self._forced_alpha and isRGBA:

self._rgb = fg[:3] + (self._alpha,)

elif self._forced_alpha:

self._rgb = colors.to_rgba(fg, self._alpha)

elif isRGBA:

self._rgb = fg

else:

self._rgb = colors.to_rgba(fg)

def set_joinstyle(self, js):

"""Set the join style to be one of ('miter', 'round', 'bevel')."""

cbook._check_in_list(['miter', 'round', 'bevel'], js=js)

self._joinstyle = js

def set_linewidth(self, w):

"""Set the linewidth in points."""

self._linewidth = float(w)

def set_url(self, url):

"""Set the url for links in compatible backends."""

self._url = url

def set_gid(self, id):

"""Set the id."""

self._gid = id

def set_snap(self, snap):

"""

self._snap = snap

def set_hatch(self, hatch):

"""Set the hatch style (for fills)."""

self._hatch = hatch

def get_hatch(self):

"""Get the current hatch style."""

return self._hatch

def get_hatch_path(self, density=6.0):

"""Return a `Path` for the current hatch."""

hatch = self.get_hatch()

if hatch is None:

return None

return Path.hatch(hatch, density)

def get_hatch_color(self):

"""Get the hatch color."""

return self._hatch_color

def set_hatch_color(self, hatch_color):

"""Set the hatch color."""

self._hatch_color = hatch_color

def get_hatch_linewidth(self):

"""Get the hatch linewidth."""

return self._hatch_linewidth

def get_sketch_params(self):

"""