'eps': 'Encapsulated Postscript',

'gif': 'Graphics Interchange Format',

'jpg': 'Joint Photographic Experts Group',

'jpeg': 'Joint Photographic Experts Group',

'pdf': 'Portable Document Format',

'pgf': 'PGF code for LaTeX',

'png': 'Portable Network Graphics',

'ps': 'Postscript',

'raw': 'Raw RGBA bitmap',

'rgba': 'Raw RGBA bitmap',

'svg': 'Scalable Vector Graphics',

'svgz': 'Scalable Vector Graphics',

'tif': 'Tagged Image File Format',

'tiff': 'Tagged Image File Format',

'webp': 'WebP Image Format',

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

'gif': 'matplotlib.backends.backend_agg',

'jpg': 'matplotlib.backends.backend_agg',

'jpeg': 'matplotlib.backends.backend_agg',

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

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

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

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

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

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

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

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

'tif': 'matplotlib.backends.backend_agg',

'tiff': 'matplotlib.backends.backend_agg',

'webp': 'matplotlib.backends.backend_agg',

"""

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

"""

def __init__(self):

super().__init__()

self._texmanager = None

self._text2path = text.TextToPath()

self._raster_depth = 0

self._rasterizing = False

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

"""

def close_group(self, s):

"""

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

"""Draw a `~.path.Path` instance using the given affine transform."""

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, offset_trans, facecolors, edgecolors,

linewidths, linestyles, antialiaseds, urls,

offset_position, *, hatchcolors=None):

"""

path_ids = self._iter_collection_raw_paths(master_transform,

paths, all_transforms)

if hatchcolors is None:

hatchcolors = []

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

gc, list(path_ids), offsets, offset_trans,

facecolors, edgecolors, linewidths, linestyles,

antialiaseds, urls, offset_position, hatchcolors=hatchcolors):

path, transform = path_id

# Only apply another translation if we have an offset, else we

# reuse the initial transform.

if xo != 0 or yo != 0:

# The transformation can be used by multiple paths. Since

# translate is a inplace operation, we need to copy the

# transformation by .frozen() before applying the translation.

transform = transform.frozen()

transform.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(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_triangles(self, gc, triangles_array, colors_array,

transform):

"""

raise NotImplementedError

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, path_ids, offsets, offset_trans, facecolors,

edgecolors, linewidths, linestyles,

antialiaseds, urls, offset_position, *, hatchcolors):

"""

Npaths = len(path_ids)

Noffsets = len(offsets)

N = max(Npaths, Noffsets)

Nfacecolors = len(facecolors)

Nedgecolors = len(edgecolors)

Nhatchcolors = len(hatchcolors)

Nlinewidths = len(linewidths)

Nlinestyles = len(linestyles)

Nurls = len(urls)

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

return

gc0 = self.new_gc()

gc0.copy_properties(gc)

def cycle_or_default(seq, default=None):

# Cycle over *seq* if it is not empty; else always yield *default*.

return (itertools.cycle(seq) if len(seq)

else itertools.repeat(default))

pathids = cycle_or_default(path_ids)

toffsets = cycle_or_default(offset_trans.transform(offsets), (0, 0))

fcs = cycle_or_default(facecolors)

ecs = cycle_or_default(edgecolors)

hcs = cycle_or_default(hatchcolors)

lws = cycle_or_default(linewidths)

lss = cycle_or_default(linestyles)

aas = cycle_or_default(antialiaseds)

urls = cycle_or_default(urls)

if Nedgecolors == 0:

gc0.set_linewidth(0.0)

for pathid, (xo, yo), fc, ec, hc, lw, ls, aa, url in itertools.islice(

zip(pathids, toffsets, fcs, ecs, hcs, lws, lss, aas, urls), N):

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

continue

if Nedgecolors:

if Nlinewidths:

gc0.set_linewidth(lw)

if Nlinestyles:

gc0.set_dashes(*ls)

if len(ec) == 4 and ec[3] == 0.0:

gc0.set_linewidth(0)

else:

gc0.set_foreground(ec)

if Nhatchcolors:

gc0.set_hatch_color(hc)

if fc is not None and len(fc) == 4 and fc[3] == 0:

fc = None

gc0.set_antialiased(aa)

if Nurls:

gc0.set_url(url)

yield xo, yo, pathid, gc0, fc

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, *, 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 _draw_text_as_path(self, gc, 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)

if self.flipy():

width, height = self.get_canvas_width_height()

transform = (Affine2D()

.scale(fontsize / text2path.FONT_SCALE)

.rotate_deg(angle)

.translate(x, height - y))

else:

transform = (Affine2D()

.scale(fontsize / text2path.FONT_SCALE)

.rotate_deg(angle)

.translate(x, y))

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

"""

fontsize = prop.get_size_in_points()

if ismath == 'TeX':

# todo: handle properties

return self.get_texmanager().get_text_width_height_descent(

s, fontsize, renderer=self)

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)

font.set_size(fontsize, 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:

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

def start_rasterizing(self):

"""

def stop_rasterizing(self):

"""

def start_filter(self):

"""

def stop_filter(self, filter_func):

"""

def _draw_disabled(self):

"""

no_ops = {

meth_name: functools.update_wrapper(lambda *args, **kwargs: None,

getattr(RendererBase, meth_name))

for meth_name in dir(RendererBase)

if (meth_name.startswith("draw_")

or meth_name in ["open_group", "close_group"])

}

"""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 = CapStyle('butt')

self._cliprect = None

self._clippath = None

self._dashes = 0, None

self._joinstyle = JoinStyle('round')

self._linestyle = 'solid'

self._linewidth = 1

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

self._hatch = None

self._hatch_color = None

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 the `.CapStyle`."""

return self._capstyle.name

def get_clip_rectangle(self):

"""

return self._cliprect

def get_clip_path(self):

"""

if self._clippath is not None:

tpath, tr = self._clippath.get_transformed_path_and_affine()

if np.all(np.isfinite(tpath.vertices)):

return tpath, tr

else:

_log.warning("Ill-defined clip_path detected. Returning None.")

return None, None

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 `.JoinStyle`."""

return self._joinstyle.name

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

@_docstring.interpd

def set_capstyle(self, cs):

"""

self._capstyle = CapStyle(cs)

def set_clip_rectangle(self, rectangle):

"""Set the clip rectangle to a `.Bbox` or None."""

self._cliprect = rectangle

def set_clip_path(self, path):

"""Set the clip path to a `.TransformedPath` or None."""

_api.check_isinstance((transforms.TransformedPath, None), path=path)

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

if dl.size and not np.any(dl > 0.0):

raise ValueError(

'At least one value 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)

@_docstring.interpd

def set_joinstyle(self, js):

"""

self._joinstyle = 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 set_hatch_linewidth(self, hatch_linewidth):

"""Set the hatch linewidth."""

self._hatch_linewidth = hatch_linewidth

def get_sketch_params(self):

"""

return self._sketch