r"""

# for a non-math symbol, simply return its unicode index

if not math:

return ord(symbol)

# From UTF #25: U+2212 minus sign is the preferred

# representation of the unary and binary minus sign rather than

# the ASCII-derived U+002D hyphen-minus, because minus sign is

# unambiguous and because it is rendered with a more desirable

# length, usually longer than a hyphen.

if symbol == '-':

return 0x2212

try: # This will succeed if symbol is a single unicode char

return ord(symbol)

except TypeError:

pass

try: # Is symbol a TeX symbol (i.e. \alpha)

return tex2uni[symbol.strip("\\")]

except KeyError:

raise ValueError(

"'{}' is not a valid Unicode character or TeX/Type1 symbol"

"""

def __init__(self):

self.width = 0

self.height = 0

self.depth = 0

def set_canvas_size(self, w, h, d):

'Dimension the drawing canvas'

self.width = w

self.height = h

self.depth = d

def render_glyph(self, ox, oy, info):

"""

raise NotImplementedError()

def render_rect_filled(self, x1, y1, x2, y2):

"""

raise NotImplementedError()

def get_results(self, box):

"""

raise NotImplementedError()

def get_hinting_type(self):

"""

"""

def __init__(self):

self.ox = 0

self.oy = 0

self.image = None

self.mode = 'bbox'

self.bbox = [0, 0, 0, 0]

MathtextBackend.__init__(self)

def _update_bbox(self, x1, y1, x2, y2):

self.bbox = [min(self.bbox[0], x1),

min(self.bbox[1], y1),

max(self.bbox[2], x2),

max(self.bbox[3], y2)]

def set_canvas_size(self, w, h, d):

MathtextBackend.set_canvas_size(self, w, h, d)

if self.mode != 'bbox':

self.image = FT2Image(np.ceil(w), np.ceil(h + max(d, 0)))

def render_glyph(self, ox, oy, info):

if self.mode == 'bbox':

self._update_bbox(ox + info.metrics.xmin,

oy - info.metrics.ymax,

ox + info.metrics.xmax,

oy - info.metrics.ymin)

else:

info.font.draw_glyph_to_bitmap(

self.image, ox, oy - info.metrics.iceberg, info.glyph,

antialiased=rcParams['text.antialiased'])

def render_rect_filled(self, x1, y1, x2, y2):

if self.mode == 'bbox':

self._update_bbox(x1, y1, x2, y2)

else:

height = max(int(y2 - y1) - 1, 0)

if height == 0:

center = (y2 + y1) / 2.0

y = int(center - (height + 1) / 2.0)

else:

y = int(y1)

self.image.draw_rect_filled(int(x1), y, np.ceil(x2), y + height)

def get_results(self, box, used_characters):

self.mode = 'bbox'

orig_height = box.height

orig_depth = box.depth

ship(0, 0, box)

bbox = self.bbox

bbox = [bbox[0] - 1, bbox[1] - 1, bbox[2] + 1, bbox[3] + 1]

self.mode = 'render'

self.set_canvas_size(

bbox[2] - bbox[0],

(bbox[3] - bbox[1]) - orig_depth,

(bbox[3] - bbox[1]) - orig_height)

ship(-bbox[0], -bbox[1], box)

result = (self.ox,

self.oy,

self.width,

self.height + self.depth,

self.depth,

self.image,

used_characters)

self.image = None

return result

def get_hinting_type(self):

from matplotlib.backends import backend_agg

def get_results(self, box, used_characters):

ox, oy, width, height, depth, image, characters = \

MathtextBackendAgg.get_results(self, box, used_characters)

"""

_PSResult = namedtuple(

"_PSResult", "width height depth pswriter used_characters")

def __init__(self):

self.pswriter = StringIO()

self.lastfont = None

def render_glyph(self, ox, oy, info):

oy = self.height - oy + info.offset

postscript_name = info.postscript_name

fontsize = info.fontsize

symbol_name = info.symbol_name

if (postscript_name, fontsize) != self.lastfont:

self.lastfont = postscript_name, fontsize

self.pswriter.write(

f"/{postscript_name} findfont\n"

f"{fontsize} scalefont\n"

f"setfont\n")

self.pswriter.write(

f"{ox:f} {oy:f} moveto\n"

f"/{symbol_name} glyphshow\n")

def render_rect_filled(self, x1, y1, x2, y2):

ps = "%f %f %f %f rectfill\n" % (

x1, self.height - y2, x2 - x1, y2 - y1)

self.pswriter.write(ps)

def get_results(self, box, used_characters):

ship(0, 0, box)

return self._PSResult(self.width,

self.height + self.depth,

self.depth,

self.pswriter,

"""Store information to write a mathtext rendering to the PDF backend."""

_PDFResult = namedtuple(

"_PDFResult", "width height depth glyphs rects used_characters")

def __init__(self):

self.glyphs = []

self.rects = []

def render_glyph(self, ox, oy, info):

filename = info.font.fname

oy = self.height - oy + info.offset

self.glyphs.append(

(ox, oy, filename, info.fontsize,

info.num, info.symbol_name))

def render_rect_filled(self, x1, y1, x2, y2):

self.rects.append((x1, self.height - y2, x2 - x1, y2 - y1))

def get_results(self, box, used_characters):

ship(0, 0, box)

return self._PDFResult(self.width,

self.height + self.depth,

self.depth,

self.glyphs,

self.rects,

"""

def __init__(self):

self.svg_glyphs = []

self.svg_rects = []

def render_glyph(self, ox, oy, info):

oy = self.height - oy + info.offset

self.svg_glyphs.append(

(info.font, info.fontsize, info.num, ox, oy, info.metrics))

def render_rect_filled(self, x1, y1, x2, y2):

self.svg_rects.append(

(x1, self.height - y1 + 1, x2 - x1, y2 - y1))

def get_results(self, box, used_characters):

ship(0, 0, box)

svg_elements = types.SimpleNamespace(svg_glyphs=self.svg_glyphs,

svg_rects=self.svg_rects)

return (self.width,

self.height + self.depth,

self.depth,

svg_elements,

"""

def __init__(self):

self.glyphs = []

self.rects = []

def render_glyph(self, ox, oy, info):

oy = self.height - oy + info.offset

thetext = info.num

self.glyphs.append(

(info.font, info.fontsize, thetext, ox, oy))

def render_rect_filled(self, x1, y1, x2, y2):

self.rects.append((x1, self.height - y2, x2 - x1, y2 - y1))

def get_results(self, box, used_characters):

ship(0, 0, box)

return (self.width,

self.height + self.depth,

self.depth,

self.glyphs,

"""

def __init__(self):

self.glyphs = []

self.rects = []

def render_glyph(self, ox, oy, info):

oy = oy - info.offset - self.height

thetext = chr(info.num)

self.glyphs.append(

(info.font, info.fontsize, thetext, ox, oy))

def render_rect_filled(self, x1, y1, x2, y2):

self.rects.append(

(x1, y1 - self.height, x2 - x1, y2 - y1))

def get_results(self, box, used_characters):

ship(0, 0, box)

return (self.width,

self.height + self.depth,

self.depth,

self.glyphs,

"""

def __init__(self, default_font_prop, mathtext_backend):

"""

self.default_font_prop = default_font_prop

self.mathtext_backend = mathtext_backend

self.used_characters = {}

def destroy(self):

"""

self.used_characters = None

def get_kern(self, font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi):

r"""

return 0.

def get_metrics(self, font, font_class, sym, fontsize, dpi, math=True):

r"""

info = self._get_info(font, font_class, sym, fontsize, dpi, math)

return info.metrics

def set_canvas_size(self, w, h, d):

"""

self.width, self.height, self.depth = np.ceil([w, h, d])

self.mathtext_backend.set_canvas_size(

self.width, self.height, self.depth)

def render_glyph(self, ox, oy, facename, font_class, sym, fontsize, dpi):

"""

info = self._get_info(facename, font_class, sym, fontsize, dpi)

realpath, stat_key = get_realpath_and_stat(info.font.fname)

used_characters = self.used_characters.setdefault(

stat_key, (realpath, set()))

used_characters[1].add(info.num)

self.mathtext_backend.render_glyph(ox, oy, info)

def render_rect_filled(self, x1, y1, x2, y2):

"""

self.mathtext_backend.render_rect_filled(x1, y1, x2, y2)

def get_xheight(self, font, fontsize, dpi):

"""

raise NotImplementedError()

def get_underline_thickness(self, font, fontsize, dpi):

"""

raise NotImplementedError()

def get_used_characters(self):

"""

return self.used_characters

def get_results(self, box):

"""

result = self.mathtext_backend.get_results(

box, self.get_used_characters())

self.destroy()

return result

def get_sized_alternatives_for_symbol(self, fontname, sym):

"""

"""

def __init__(self, default_font_prop, mathtext_backend):

Fonts.__init__(self, default_font_prop, mathtext_backend)

self.glyphd = {}

self._fonts = {}

filename = findfont(default_font_prop)

default_font = get_font(filename)

self._fonts['default'] = default_font

self._fonts['regular'] = default_font

def destroy(self):

self.glyphd = None

Fonts.destroy(self)

def _get_font(self, font):

if font in self.fontmap:

basename = self.fontmap[font]

else:

basename = font

cached_font = self._fonts.get(basename)

if cached_font is None and os.path.exists(basename):

cached_font = get_font(basename)

self._fonts[basename] = cached_font

self._fonts[cached_font.postscript_name] = cached_font

self._fonts[cached_font.postscript_name.lower()] = cached_font

return cached_font

def _get_offset(self, font, glyph, fontsize, dpi):

if font.postscript_name == 'Cmex10':

return ((glyph.height/64.0/2.0) + (fontsize/3.0 * dpi/72.0))

return 0.

def _get_info(self, fontname, font_class, sym, fontsize, dpi, math=True):

key = fontname, font_class, sym, fontsize, dpi

bunch = self.glyphd.get(key)

if bunch is not None:

return bunch

font, num, symbol_name, fontsize, slanted = \

self._get_glyph(fontname, font_class, sym, fontsize, math)

font.set_size(fontsize, dpi)

glyph = font.load_char(

num,

flags=self.mathtext_backend.get_hinting_type())

xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox]

offset = self._get_offset(font, glyph, fontsize, dpi)

metrics = types.SimpleNamespace(

advance = glyph.linearHoriAdvance/65536.0,

height = glyph.height/64.0,

width = glyph.width/64.0,

xmin = xmin,

xmax = xmax,

ymin = ymin+offset,

ymax = ymax+offset,

# iceberg is the equivalent of TeX's "height"

iceberg = glyph.horiBearingY/64.0 + offset,

slanted = slanted

)

result = self.glyphd[key] = types.SimpleNamespace(

font = font,

fontsize = fontsize,

postscript_name = font.postscript_name,

metrics = metrics,

symbol_name = symbol_name,

num = num,

glyph = glyph,

offset = offset

)

return result

def get_xheight(self, fontname, fontsize, dpi):

font = self._get_font(fontname)

font.set_size(fontsize, dpi)

pclt = font.get_sfnt_table('pclt')

if pclt is None:

# Some fonts don't store the xHeight, so we do a poor man's xHeight

metrics = self.get_metrics(

fontname, rcParams['mathtext.default'], 'x', fontsize, dpi)

return metrics.iceberg

xHeight = (pclt['xHeight'] / 64.0) * (fontsize / 12.0) * (dpi / 100.0)

return xHeight

def get_underline_thickness(self, font, fontsize, dpi):

# This function used to grab underline thickness from the font

# metrics, but that information is just too un-reliable, so it

# is now hardcoded.

return ((0.75 / 12.0) * fontsize * dpi) / 72.0

def get_kern(self, font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi):

if font1 == font2 and fontsize1 == fontsize2:

info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)

info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)

font = info1.font

return font.get_kerning(info1.num, info2.num, KERNING_DEFAULT) / 64

return Fonts.get_kern(self, font1, fontclass1, sym1, fontsize1,

"""

_fontmap = {

'cal': 'cmsy10',

'rm': 'cmr10',

'tt': 'cmtt10',

'it': 'cmmi10',

'bf': 'cmb10',

'sf': 'cmss10',

'ex': 'cmex10',

}

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

self._stix_fallback = StixFonts(*args, **kwargs)

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

for key, val in self._fontmap.items():

fullpath = findfont(val)

self.fontmap[key] = fullpath

self.fontmap[val] = fullpath

_slanted_symbols = set(r"\int \oint".split())

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

symbol_name = None

font = None

if fontname in self.fontmap and sym in latex_to_bakoma:

basename, num = latex_to_bakoma[sym]

slanted = (basename == "cmmi10") or sym in self._slanted_symbols

font = self._get_font(basename)

elif len(sym) == 1:

slanted = (fontname == "it")

font = self._get_font(fontname)

if font is not None:

num = ord(sym)

if font is not None:

gid = font.get_char_index(num)

if gid != 0:

symbol_name = font.get_glyph_name(gid)

if symbol_name is None:

return self._stix_fallback._get_glyph(

fontname, font_class, sym, fontsize, math)

return font, num, symbol_name, fontsize, slanted

# The Bakoma fonts contain many pre-sized alternatives for the

# delimiters. The AutoSizedChar class will use these alternatives

# and select the best (closest sized) glyph.

_size_alternatives = {

'(': [('rm', '('), ('ex', '\xa1'), ('ex', '\xb3'),

('ex', '\xb5'), ('ex', '\xc3')],

')': [('rm', ')'), ('ex', '\xa2'), ('ex', '\xb4'),

('ex', '\xb6'), ('ex', '\x21')],

'{': [('cal', '{'), ('ex', '\xa9'), ('ex', '\x6e'),

('ex', '\xbd'), ('ex', '\x28')],

'}': [('cal', '}'), ('ex', '\xaa'), ('ex', '\x6f'),

('ex', '\xbe'), ('ex', '\x29')],

# The fourth size of '[' is mysteriously missing from the BaKoMa

# font, so I've omitted it for both '[' and ']'

'[': [('rm', '['), ('ex', '\xa3'), ('ex', '\x68'),

('ex', '\x22')],

']': [('rm', ']'), ('ex', '\xa4'), ('ex', '\x69'),

('ex', '\x23')],

r'\lfloor': [('ex', '\xa5'), ('ex', '\x6a'),

('ex', '\xb9'), ('ex', '\x24')],

r'\rfloor': [('ex', '\xa6'), ('ex', '\x6b'),

('ex', '\xba'), ('ex', '\x25')],

r'\lceil': [('ex', '\xa7'), ('ex', '\x6c'),

('ex', '\xbb'), ('ex', '\x26')],

r'\rceil': [('ex', '\xa8'), ('ex', '\x6d'),

('ex', '\xbc'), ('ex', '\x27')],

r'\langle': [('ex', '\xad'), ('ex', '\x44'),

('ex', '\xbf'), ('ex', '\x2a')],

r'\rangle': [('ex', '\xae'), ('ex', '\x45'),

('ex', '\xc0'), ('ex', '\x2b')],

r'\__sqrt__': [('ex', '\x70'), ('ex', '\x71'),

('ex', '\x72'), ('ex', '\x73')],

r'\backslash': [('ex', '\xb2'), ('ex', '\x2f'),

('ex', '\xc2'), ('ex', '\x2d')],

r'/': [('rm', '/'), ('ex', '\xb1'), ('ex', '\x2e'),

('ex', '\xcb'), ('ex', '\x2c')],

r'\widehat': [('rm', '\x5e'), ('ex', '\x62'), ('ex', '\x63'),

('ex', '\x64')],

r'\widetilde': [('rm', '\x7e'), ('ex', '\x65'), ('ex', '\x66'),

('ex', '\x67')],

r'<': [('cal', 'h'), ('ex', 'D')],

r'>': [('cal', 'i'), ('ex', 'E')]

}

for alias, target in [(r'\leftparen', '('),

(r'\rightparent', ')'),

(r'\leftbrace', '{'),

(r'\rightbrace', '}'),

(r'\leftbracket', '['),

(r'\rightbracket', ']'),

(r'\{', '{'),

(r'\}', '}'),

(r'\[', '['),

(r'\]', ']')]:

_size_alternatives[alias] = _size_alternatives[target]

def get_sized_alternatives_for_symbol(self, fontname, sym):

"""

use_cmex = True

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

# This must come first so the backend's owner is set correctly

if rcParams['mathtext.fallback_to_cm']:

self.cm_fallback = BakomaFonts(*args, **kwargs)

else:

self.cm_fallback = None

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

for texfont in "cal rm tt it bf sf".split():

prop = rcParams['mathtext.' + texfont]

font = findfont(prop)

self.fontmap[texfont] = font

prop = FontProperties('cmex10')

font = findfont(prop)

self.fontmap['ex'] = font

_slanted_symbols = set(r"\int \oint".split())

def _map_virtual_font(self, fontname, font_class, uniindex):

return fontname, uniindex

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

found_symbol = False

if self.use_cmex:

uniindex = latex_to_cmex.get(sym)

if uniindex is not None:

fontname = 'ex'

found_symbol = True

if not found_symbol:

try:

uniindex = get_unicode_index(sym, math)

found_symbol = True

except ValueError:

uniindex = ord('?')

_log.warning(

"No TeX to unicode mapping for {!a}.".format(sym))

fontname, uniindex = self._map_virtual_font(

fontname, font_class, uniindex)

new_fontname = fontname

# Only characters in the "Letter" class should be italicized in 'it'

# mode. Greek capital letters should be Roman.

if found_symbol:

if fontname == 'it' and uniindex < 0x10000:

char = chr(uniindex)

if (unicodedata.category(char)[0] != "L"

or unicodedata.name(char).startswith("GREEK CAPITAL")):

new_fontname = 'rm'

slanted = (new_fontname == 'it') or sym in self._slanted_symbols

found_symbol = False

font = self._get_font(new_fontname)

if font is not None:

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

found_symbol = True

if not found_symbol:

if self.cm_fallback:

if isinstance(self.cm_fallback, BakomaFonts):

_log.warning(

"Substituting with a symbol from Computer Modern.")

if (fontname in ('it', 'regular') and

isinstance(self.cm_fallback, StixFonts)):

return self.cm_fallback._get_glyph(

'rm', font_class, sym, fontsize)

else:

return self.cm_fallback._get_glyph(

fontname, font_class, sym, fontsize)

else:

if (fontname in ('it', 'regular')

and isinstance(self, StixFonts)):

return self._get_glyph('rm', font_class, sym, fontsize)

_log.warning("Font {!r} does not have a glyph for {!a} "

"[U+{:x}], substituting with a dummy "

"symbol.".format(new_fontname, sym, uniindex))

fontname = 'rm'

font = self._get_font(fontname)

uniindex = 0xA4 # currency char, for lack of anything better

glyphindex = font.get_char_index(uniindex)

slanted = False

symbol_name = font.get_glyph_name(glyphindex)

return font, uniindex, symbol_name, fontsize, slanted

def get_sized_alternatives_for_symbol(self, fontname, sym):

if self.cm_fallback:

return self.cm_fallback.get_sized_alternatives_for_symbol(

fontname, sym)

use_cmex = False

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

# This must come first so the backend's owner is set correctly

if isinstance(self, DejaVuSerifFonts):

self.cm_fallback = StixFonts(*args, **kwargs)

else:

self.cm_fallback = StixSansFonts(*args, **kwargs)

self.bakoma = BakomaFonts(*args, **kwargs)

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

# Include Stix sized alternatives for glyphs

self._fontmap.update({

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

})

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

# Override prime symbol to use Bakoma.

if sym == r'\prime':

return self.bakoma._get_glyph(

fontname, font_class, sym, fontsize, math)

else:

# check whether the glyph is available in the display font

uniindex = get_unicode_index(sym)

font = self._get_font('ex')

if font is not None:

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

return super()._get_glyph(

'ex', font_class, sym, fontsize, math)

# otherwise return regular glyph

return super()._get_glyph(

"""

_fontmap = {

'rm': 'DejaVu Serif',

'it': 'DejaVu Serif:italic',

'bf': 'DejaVu Serif:weight=bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Serif Display',

0: 'DejaVu Serif',

"""

_fontmap = {

'rm': 'DejaVu Sans',

'it': 'DejaVu Sans:italic',

'bf': 'DejaVu Sans:weight=bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Sans Display',

0: 'DejaVu Sans',

"""

_fontmap = {

'rm': 'STIXGeneral',

'it': 'STIXGeneral:italic',

'bf': 'STIXGeneral:weight=bold',

'nonunirm': 'STIXNonUnicode',

'nonuniit': 'STIXNonUnicode:italic',

'nonunibf': 'STIXNonUnicode:weight=bold',

0: 'STIXGeneral',

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

}

use_cmex = False

cm_fallback = False

_sans = False

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

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _map_virtual_font(self, fontname, font_class, uniindex):

# Handle these "fonts" that are actually embedded in

# other fonts.

mapping = stix_virtual_fonts.get(fontname)

if (self._sans and mapping is None

and fontname not in ('regular', 'default')):

mapping = stix_virtual_fonts['sf']

doing_sans_conversion = True

else:

doing_sans_conversion = False

if mapping is not None:

if isinstance(mapping, dict):

try:

mapping = mapping[font_class]

except KeyError: