# -*- coding: utf-8 -*-

"""

A PDF matplotlib backend

Author: Jouni K Seppänen <jks@iki.fi>

"""

from __future__ import (absolute_import, division, print_function,

unicode_literals)

import six

import codecs

import os

import re

import struct

import sys

import time

import warnings

import zlib

from io import BytesIO

from functools import total_ordering

import numpy as np

from six import unichr

from datetime import datetime

from math import ceil, cos, floor, pi, sin

import matplotlib

from matplotlib import __version__, rcParams

from matplotlib._pylab_helpers import Gcf

from matplotlib.backend_bases import (RendererBase, GraphicsContextBase,

FigureManagerBase, FigureCanvasBase)

from matplotlib.backends.backend_mixed import MixedModeRenderer

from matplotlib.cbook import (Bunch, is_string_like, get_realpath_and_stat,

is_writable_file_like, maxdict)

from matplotlib.figure import Figure

from matplotlib.font_manager import findfont, is_opentype_cff_font, get_font

from matplotlib.afm import AFM

import matplotlib.type1font as type1font

import matplotlib.dviread as dviread

from matplotlib.ft2font import (FIXED_WIDTH, ITALIC, LOAD_NO_SCALE,

LOAD_NO_HINTING, KERNING_UNFITTED)

from matplotlib.mathtext import MathTextParser

from matplotlib.transforms import Affine2D, BboxBase

from matplotlib.path import Path

from matplotlib import _path

from matplotlib import _png

from matplotlib import ttconv

# Overview

#

# The low-level knowledge about pdf syntax lies mainly in the pdfRepr

# function and the classes Reference, Name, Operator, and Stream. The

# PdfFile class knows about the overall structure of pdf documents.

# It provides a "write" method for writing arbitrary strings in the

# file, and an "output" method that passes objects through the pdfRepr

# function before writing them in the file. The output method is

# called by the RendererPdf class, which contains the various draw_foo

# methods. RendererPdf contains a GraphicsContextPdf instance, and

# each draw_foo calls self.check_gc before outputting commands. This

# method checks whether the pdf graphics state needs to be modified

# and outputs the necessary commands. GraphicsContextPdf represents

# the graphics state, and its "delta" method returns the commands that

# modify the state.

# Add "pdf.use14corefonts: True" in your configuration file to use only

# the 14 PDF core fonts. These fonts do not need to be embedded; every

# PDF viewing application is required to have them. This results in very

# light PDF files you can use directly in LaTeX or ConTeXt documents

# generated with pdfTeX, without any conversion.

# These fonts are: Helvetica, Helvetica-Bold, Helvetica-Oblique,

# Helvetica-BoldOblique, Courier, Courier-Bold, Courier-Oblique,

# Courier-BoldOblique, Times-Roman, Times-Bold, Times-Italic,

# Times-BoldItalic, Symbol, ZapfDingbats.

#

# Some tricky points:

#

# 1. The clip path can only be widened by popping from the state

# stack. Thus the state must be pushed onto the stack before narrowing

# the clip path. This is taken care of by GraphicsContextPdf.

#

# 2. Sometimes it is necessary to refer to something (e.g., font,

# image, or extended graphics state, which contains the alpha value)

# in the page stream by a name that needs to be defined outside the

# stream. PdfFile provides the methods fontName, imageObject, and

# alphaState for this purpose. The implementations of these methods

# should perhaps be generalized.

# TODOs:

#

# * encoding of fonts, including mathtext fonts and unicode support

# * TTF support has lots of small TODOs, e.g., how do you know if a font

# is serif/sans-serif, or symbolic/non-symbolic?

# * draw_markers, draw_line_collection, etc.

def fill(strings, linelen=75):

"""Make one string from sequence of strings, with whitespace

in between. The whitespace is chosen to form lines of at most

linelen characters, if possible."""

currpos = 0

lasti = 0

result = []

for i, s in enumerate(strings):

length = len(s)

if currpos + length < linelen:

currpos += length + 1

else:

result.append(b' '.join(strings[lasti:i]))

lasti = i

currpos = length

result.append(b' '.join(strings[lasti:]))

return b'\n'.join(result)

# PDF strings are supposed to be able to include any eight-bit data,

# except that unbalanced parens and backslashes must be escaped by a

# backslash. However, sf bug #2708559 shows that the carriage return

# character may get read as a newline; these characters correspond to

# \gamma and \Omega in TeX's math font encoding. Escaping them fixes

# the bug.

_string_escape_regex = re.compile(br'([\\()\r\n])')

def _string_escape(match):

m = match.group(0)

if m in br'\()':

return b'\\' + m

elif m == b'\n':

return br'\n'

elif m == b'\r':

return br'\r'

assert False

def pdfRepr(obj):

"""Map Python objects to PDF syntax."""

# Some objects defined later have their own pdfRepr method.

if hasattr(obj, 'pdfRepr'):

return obj.pdfRepr()

# Floats. PDF does not have exponential notation (1.0e-10) so we

# need to use %f with some precision. Perhaps the precision

# should adapt to the magnitude of the number?

elif isinstance(obj, (float, np.floating)):

if not np.isfinite(obj):

raise ValueError("Can only output finite numbers in PDF")

r = ("%.10f" % obj).encode('ascii')

return r.rstrip(b'0').rstrip(b'.')

# Booleans. Needs to be tested before integers since

# isinstance(True, int) is true.

elif isinstance(obj, bool):

return [b'false', b'true'][obj]

# Integers are written as such.

elif isinstance(obj, (six.integer_types, np.integer)):

return ("%d" % obj).encode('ascii')

# Unicode strings are encoded in UTF-16BE with byte-order mark.

elif isinstance(obj, six.text_type):

try:

# But maybe it's really ASCII?

s = obj.encode('ASCII')

return pdfRepr(s)

except UnicodeEncodeError:

s = codecs.BOM_UTF16_BE + obj.encode('UTF-16BE')

return pdfRepr(s)

# Strings are written in parentheses, with backslashes and parens

# escaped. Actually balanced parens are allowed, but it is

# simpler to escape them all. TODO: cut long strings into lines;

# I believe there is some maximum line length in PDF.

elif isinstance(obj, bytes):

return b'(' + _string_escape_regex.sub(_string_escape, obj) + b')'

# Dictionaries. The keys must be PDF names, so if we find strings

# there, we make Name objects from them. The values may be

# anything, so the caller must ensure that PDF names are

# represented as Name objects.

elif isinstance(obj, dict):

r = [b"<<"]

r.extend([Name(key).pdfRepr() + b" " + pdfRepr(obj[key])

for key in sorted(obj)])

r.append(b">>")

return fill(r)

# Lists.

elif isinstance(obj, (list, tuple)):

r = [b"["]

r.extend([pdfRepr(val) for val in obj])

r.append(b"]")

return fill(r)

# The null keyword.

elif obj is None:

return b'null'

# A date.

elif isinstance(obj, datetime):

r = obj.strftime('D:%Y%m%d%H%M%S')

if time.daylight:

z = time.altzone

else:

z = time.timezone

if z == 0:

r += 'Z'

elif z < 0:

r += "+%02d'%02d'" % ((-z) // 3600, (-z) % 3600)

else:

r += "-%02d'%02d'" % (z // 3600, z % 3600)

return pdfRepr(r)

# A bounding box

elif isinstance(obj, BboxBase):

return fill([pdfRepr(val) for val in obj.bounds])

else:

msg = "Don't know a PDF representation for %s objects." % type(obj)

raise TypeError(msg)

class Reference(object):

"""PDF reference object.

Use PdfFile.reserveObject() to create References.

"""

def __init__(self, id):

self.id = id

def __repr__(self):

return "<Reference %d>" % self.id

def pdfRepr(self):

return ("%d 0 R" % self.id).encode('ascii')

def write(self, contents, file):

write = file.write

write(("%d 0 obj\n" % self.id).encode('ascii'))

write(pdfRepr(contents))

write(b"\nendobj\n")

@total_ordering

class Name(object):

"""PDF name object."""

__slots__ = ('name',)

_regex = re.compile(r'[^!-~]')

def __init__(self, name):

if isinstance(name, Name):

self.name = name.name

else:

if isinstance(name, bytes):

name = name.decode('ascii')

self.name = self._regex.sub(Name.hexify, name).encode('ascii')

def __repr__(self):

return "<Name %s>" % self.name

def __str__(self):

return '/' + six.text_type(self.name)

def __eq__(self, other):

return isinstance(other, Name) and self.name == other.name

def __lt__(self, other):

return isinstance(other, Name) and self.name < other.name

def __hash__(self):

return hash(self.name)

@staticmethod

def hexify(match):

return '#%02x' % ord(match.group())

def pdfRepr(self):

return b'/' + self.name

class Operator(object):

"""PDF operator object."""

__slots__ = ('op',)

def __init__(self, op):

self.op = op

def __repr__(self):

return '<Operator %s>' % self.op

def pdfRepr(self):

return self.op

class Verbatim(object):

"""Store verbatim PDF command content for later inclusion in the

stream."""

def __init__(self, x):

self._x = x

def pdfRepr(self):

return self._x

# PDF operators (not an exhaustive list)

_pdfops = dict(

close_fill_stroke=b'b', fill_stroke=b'B', fill=b'f', closepath=b'h',

close_stroke=b's', stroke=b'S', endpath=b'n', begin_text=b'BT',

end_text=b'ET', curveto=b'c', rectangle=b're', lineto=b'l', moveto=b'm',

concat_matrix=b'cm', use_xobject=b'Do', setgray_stroke=b'G',

setgray_nonstroke=b'g', setrgb_stroke=b'RG', setrgb_nonstroke=b'rg',

setcolorspace_stroke=b'CS', setcolorspace_nonstroke=b'cs',

setcolor_stroke=b'SCN', setcolor_nonstroke=b'scn', setdash=b'd',

setlinejoin=b'j', setlinecap=b'J', setgstate=b'gs', gsave=b'q',

grestore=b'Q', textpos=b'Td', selectfont=b'Tf', textmatrix=b'Tm',

show=b'Tj', showkern=b'TJ', setlinewidth=b'w', clip=b'W', shading=b'sh')

Op = Bunch(**dict([(name, Operator(value))

for name, value in six.iteritems(_pdfops)]))

def _paint_path(fill, stroke):

"""Return the PDF operator to paint a path in the following way:

fill: fill the path with the fill color

stroke: stroke the outline of the path with the line color"""

if stroke:

if fill:

return Op.fill_stroke

else:

return Op.stroke

else:

if fill:

return Op.fill

else:

return Op.endpath

Op.paint_path = _paint_path

class Stream(object):

"""PDF stream object.

This has no pdfRepr method. Instead, call begin(), then output the

contents of the stream by calling write(), and finally call end().

"""

__slots__ = ('id', 'len', 'pdfFile', 'file', 'compressobj', 'extra', 'pos')

def __init__(self, id, len, file, extra=None, png=None):

"""id: object id of stream; len: an unused Reference object for the

length of the stream, or None (to use a memory buffer); file:

a PdfFile; extra: a dictionary of extra key-value pairs to

include in the stream header; png: if the data is already

png compressed, the decode parameters"""

self.id = id # object id

self.len = len # id of length object

self.pdfFile = file

self.file = file.fh # file to which the stream is written

self.compressobj = None # compression object

if extra is None:

self.extra = dict()

else:

self.extra = extra.copy()

if png is not None:

self.extra.update({'Filter': Name('FlateDecode'),

'DecodeParms': png})

self.pdfFile.recordXref(self.id)

if rcParams['pdf.compression'] and not png:

self.compressobj = zlib.compressobj(rcParams['pdf.compression'])

if self.len is None:

self.file = BytesIO()

else:

self._writeHeader()

self.pos = self.file.tell()

def _writeHeader(self):

write = self.file.write

write(("%d 0 obj\n" % self.id).encode('ascii'))

dict = self.extra

dict['Length'] = self.len

if rcParams['pdf.compression']:

dict['Filter'] = Name('FlateDecode')

write(pdfRepr(dict))

write(b"\nstream\n")

def end(self):

"""Finalize stream."""

self._flush()

if self.len is None:

contents = self.file.getvalue()

self.len = len(contents)

self.file = self.pdfFile.fh

self._writeHeader()

self.file.write(contents)

self.file.write(b"\nendstream\nendobj\n")

else:

length = self.file.tell() - self.pos

self.file.write(b"\nendstream\nendobj\n")

self.pdfFile.writeObject(self.len, length)

def write(self, data):

"""Write some data on the stream."""

if self.compressobj is None:

self.file.write(data)

else:

compressed = self.compressobj.compress(data)

self.file.write(compressed)

def _flush(self):

"""Flush the compression object."""

if self.compressobj is not None:

compressed = self.compressobj.flush()

self.file.write(compressed)

self.compressobj = None

class PdfFile(object):

"""PDF file object."""

def __init__(self, filename):

self.nextObject = 1 # next free object id

self.xrefTable = [[0, 65535, 'the zero object']]

self.passed_in_file_object = False

self.original_file_like = None

self.tell_base = 0

if is_string_like(filename):

fh = open(filename, 'wb')

elif is_writable_file_like(filename):

try:

self.tell_base = filename.tell()

except IOError:

fh = BytesIO()

self.original_file_like = filename

else:

fh = filename

self.passed_in_file_object = True

else:

raise ValueError("filename must be a path or a file-like object")

self._core14fontdir = os.path.join(

rcParams['datapath'], 'fonts', 'pdfcorefonts')

self.fh = fh

self.currentstream = None # stream object to write to, if any

fh.write(b"%PDF-1.4\n") # 1.4 is the first version to have alpha

# Output some eight-bit chars as a comment so various utilities

# recognize the file as binary by looking at the first few

# lines (see note in section 3.4.1 of the PDF reference).

fh.write(b"%\254\334 \253\272\n")

self.rootObject = self.reserveObject('root')

self.pagesObject = self.reserveObject('pages')

self.pageList = []

self.fontObject = self.reserveObject('fonts')

self.alphaStateObject = self.reserveObject('extended graphics states')

self.hatchObject = self.reserveObject('tiling patterns')

self.gouraudObject = self.reserveObject('Gouraud triangles')

self.XObjectObject = self.reserveObject('external objects')

self.resourceObject = self.reserveObject('resources')

root = {'Type': Name('Catalog'),

'Pages': self.pagesObject}

self.writeObject(self.rootObject, root)

revision = ''

self.infoDict = {

'Creator': 'matplotlib %s, http://matplotlib.org' % __version__,

'Producer': 'matplotlib pdf backend%s' % revision,

'CreationDate': datetime.today()

}

self.fontNames = {} # maps filenames to internal font names

self.nextFont = 1 # next free internal font name

self.dviFontInfo = {} # information on dvi fonts

# differently encoded Type-1 fonts may share the same descriptor

self.type1Descriptors = {}

self.used_characters = {}

self.alphaStates = {} # maps alpha values to graphics state objects

self.nextAlphaState = 1

self.hatchPatterns = {}

self.nextHatch = 1

self.gouraudTriangles = []

self._images = {}

self.nextImage = 1

self.markers = {}

self.multi_byte_charprocs = {}

self.paths = []

self.pageAnnotations = [] # A list of annotations for the

# current page

# The PDF spec recommends to include every procset

procsets = [Name(x)

for x in "PDF Text ImageB ImageC ImageI".split()]

# Write resource dictionary.

# Possibly TODO: more general ExtGState (graphics state dictionaries)

# ColorSpace Pattern Shading Properties

resources = {'Font': self.fontObject,

'XObject': self.XObjectObject,

'ExtGState': self.alphaStateObject,

'Pattern': self.hatchObject,

'Shading': self.gouraudObject,

'ProcSet': procsets}

self.writeObject(self.resourceObject, resources)

def newPage(self, width, height):

self.endStream()

self.width, self.height = width, height

contentObject = self.reserveObject('page contents')

thePage = {'Type': Name('Page'),

'Parent': self.pagesObject,

'Resources': self.resourceObject,

'MediaBox': [0, 0, 72 * width, 72 * height],

'Contents': contentObject,

'Group': {'Type': Name('Group'),

'S': Name('Transparency'),

'CS': Name('DeviceRGB')},

'Annots': self.pageAnnotations,

}

pageObject = self.reserveObject('page')

self.writeObject(pageObject, thePage)

self.pageList.append(pageObject)

self.beginStream(contentObject.id,

self.reserveObject('length of content stream'))

# Initialize the pdf graphics state to match the default mpl

# graphics context: currently only the join style needs to be set

self.output(GraphicsContextPdf.joinstyles['round'], Op.setlinejoin)

# Clear the list of annotations for the next page

self.pageAnnotations = []

def newTextnote(self, text, positionRect=[-100, -100, 0, 0]):

# Create a new annotation of type text

theNote = {'Type': Name('Annot'),

'Subtype': Name('Text'),

'Contents': text,

'Rect': positionRect,

}

annotObject = self.reserveObject('annotation')

self.writeObject(annotObject, theNote)

self.pageAnnotations.append(annotObject)

def close(self):

self.endStream()

# Write out the various deferred objects

self.writeFonts()

self.writeObject(self.alphaStateObject,

dict([(val[0], val[1])

for val in six.itervalues(self.alphaStates)]))

self.writeHatches()

self.writeGouraudTriangles()

xobjects = dict(x[1:] for x in six.itervalues(self._images))

for tup in six.itervalues(self.markers):

xobjects[tup[0]] = tup[1]

for name, value in six.iteritems(self.multi_byte_charprocs):

xobjects[name] = value

for name, path, trans, ob, join, cap, padding, filled, stroked \

in self.paths:

xobjects[name] = ob

self.writeObject(self.XObjectObject, xobjects)

self.writeImages()

self.writeMarkers()

self.writePathCollectionTemplates()

self.writeObject(self.pagesObject,

{'Type': Name('Pages'),

'Kids': self.pageList,

'Count': len(self.pageList)})

self.writeInfoDict()

# Finalize the file

self.writeXref()

self.writeTrailer()

if self.passed_in_file_object:

self.fh.flush()

elif self.original_file_like is not None:

self.original_file_like.write(self.fh.getvalue())

self.fh.close()

else:

self.fh.close()

def write(self, data):

if self.currentstream is None:

self.fh.write(data)

else:

self.currentstream.write(data)

def output(self, *data):

self.write(fill([pdfRepr(x) for x in data]))

self.write(b'\n')

def beginStream(self, id, len, extra=None, png=None):

assert self.currentstream is None

self.currentstream = Stream(id, len, self, extra, png)

def endStream(self):

if self.currentstream is not None:

self.currentstream.end()

self.currentstream = None

def fontName(self, fontprop):

"""

Select a font based on fontprop and return a name suitable for

Op.selectfont. If fontprop is a string, it will be interpreted

as the filename (or dvi name) of the font.

"""

if is_string_like(fontprop):

filename = fontprop

elif rcParams['pdf.use14corefonts']:

filename = findfont(

fontprop, fontext='afm', directory=self._core14fontdir)

if filename is None:

filename = findfont(

"Helvetica", fontext='afm', directory=self._core14fontdir)

else:

filename = findfont(fontprop)

Fx = self.fontNames.get(filename)

if Fx is None:

Fx = Name('F%d' % self.nextFont)

self.fontNames[filename] = Fx

self.nextFont += 1

matplotlib.verbose.report(

'Assigning font %s = %r' % (Fx, filename),

'debug')

return Fx

def writeFonts(self):

fonts = {}

for filename, Fx in six.iteritems(self.fontNames):

matplotlib.verbose.report('Embedding font %s' % filename, 'debug')

if filename.endswith('.afm'):

# from pdf.use14corefonts

matplotlib.verbose.report('Writing AFM font', 'debug')

fonts[Fx] = self._write_afm_font(filename)

elif filename in self.dviFontInfo:

# a Type 1 font from a dvi file;

# the filename is really the TeX name

matplotlib.verbose.report('Writing Type-1 font', 'debug')

fonts[Fx] = self.embedTeXFont(filename,

self.dviFontInfo[filename])

else:

# a normal TrueType font

matplotlib.verbose.report('Writing TrueType font', 'debug')

realpath, stat_key = get_realpath_and_stat(filename)

chars = self.used_characters.get(stat_key)

if chars is not None and len(chars[1]):

fonts[Fx] = self.embedTTF(realpath, chars[1])

self.writeObject(self.fontObject, fonts)

def _write_afm_font(self, filename):

with open(filename, 'rb') as fh:

font = AFM(fh)

fontname = font.get_fontname()

fontdict = {'Type': Name('Font'),

'Subtype': Name('Type1'),

'BaseFont': Name(fontname),

'Encoding': Name('WinAnsiEncoding')}

fontdictObject = self.reserveObject('font dictionary')

self.writeObject(fontdictObject, fontdict)

return fontdictObject

def embedTeXFont(self, texname, fontinfo):

msg = ('Embedding TeX font ' + texname + ' - fontinfo=' +

repr(fontinfo.__dict__))

matplotlib.verbose.report(msg, 'debug')

# Widths

widthsObject = self.reserveObject('font widths')

self.writeObject(widthsObject, fontinfo.dvifont.widths)

# Font dictionary

fontdictObject = self.reserveObject('font dictionary')

fontdict = {

'Type': Name('Font'),

'Subtype': Name('Type1'),

'FirstChar': 0,

'LastChar': len(fontinfo.dvifont.widths) - 1,

'Widths': widthsObject,

}

# Encoding (if needed)

if fontinfo.encodingfile is not None:

enc = dviread.Encoding(fontinfo.encodingfile)

differencesArray = [Name(ch) for ch in enc]

differencesArray = [0] + differencesArray

fontdict['Encoding'] = \

{'Type': Name('Encoding'),

'Differences': differencesArray}

# If no file is specified, stop short

if fontinfo.fontfile is None:

msg = ('Because of TeX configuration (pdftex.map, see updmap '

'option pdftexDownloadBase14) the font {0} is not '

'embedded. This is deprecated as of PDF 1.5 and it may '

'cause the consumer application to show something that '

'was not intended.').format(fontinfo.basefont)

warnings.warn(msg)

fontdict['BaseFont'] = Name(fontinfo.basefont)

self.writeObject(fontdictObject, fontdict)

return fontdictObject

# We have a font file to embed - read it in and apply any effects

t1font = type1font.Type1Font(fontinfo.fontfile)

if fontinfo.effects:

t1font = t1font.transform(fontinfo.effects)

fontdict['BaseFont'] = Name(t1font.prop['FontName'])

# Font descriptors may be shared between differently encoded

# Type-1 fonts, so only create a new descriptor if there is no

# existing descriptor for this font.

effects = (fontinfo.effects.get('slant', 0.0),

fontinfo.effects.get('extend', 1.0))

fontdesc = self.type1Descriptors.get((fontinfo.fontfile, effects))

if fontdesc is None:

fontdesc = self.createType1Descriptor(t1font, fontinfo.fontfile)

self.type1Descriptors[(fontinfo.fontfile, effects)] = fontdesc

fontdict['FontDescriptor'] = fontdesc

self.writeObject(fontdictObject, fontdict)

return fontdictObject

def createType1Descriptor(self, t1font, fontfile):

# Create and write the font descriptor and the font file

# of a Type-1 font

fontdescObject = self.reserveObject('font descriptor')

fontfileObject = self.reserveObject('font file')

italic_angle = t1font.prop['ItalicAngle']

fixed_pitch = t1font.prop['isFixedPitch']

flags = 0

# fixed width

if fixed_pitch:

flags |= 1 << 0

# TODO: serif

if 0:

flags |= 1 << 1

# TODO: symbolic (most TeX fonts are)

if 1:

flags |= 1 << 2

# non-symbolic

else:

flags |= 1 << 5

# italic

if italic_angle:

flags |= 1 << 6

# TODO: all caps

if 0:

flags |= 1 << 16

# TODO: small caps

if 0:

flags |= 1 << 17

# TODO: force bold

if 0:

flags |= 1 << 18

ft2font = get_font(fontfile)

descriptor = {

'Type': Name('FontDescriptor'),

'FontName': Name(t1font.prop['FontName']),

'Flags': flags,

'FontBBox': ft2font.bbox,

'ItalicAngle': italic_angle,

'Ascent': ft2font.ascender,

'Descent': ft2font.descender,

'CapHeight': 1000, # TODO: find this out

'XHeight': 500, # TODO: this one too

'FontFile': fontfileObject,

'FontFamily': t1font.prop['FamilyName'],

'StemV': 50, # TODO

# (see also revision 3874; but not all TeX distros have AFM files!)

# 'FontWeight': a number where 400 = Regular, 700 = Bold

}

self.writeObject(fontdescObject, descriptor)

self.beginStream(fontfileObject.id, None,

{'Length1': len(t1font.parts[0]),

'Length2': len(t1font.parts[1]),

'Length3': 0})

self.currentstream.write(t1font.parts[0])

self.currentstream.write(t1font.parts[1])

self.endStream()

return fontdescObject

def _get_xobject_symbol_name(self, filename, symbol_name):

return "%s-%s" % (

os.path.splitext(os.path.basename(filename))[0],

symbol_name)

_identityToUnicodeCMap = """/CIDInit /ProcSet findresource begin

12 dict begin

begincmap

/CIDSystemInfo

<< /Registry (Adobe)

/Ordering (UCS)

/Supplement 0

>> def

/CMapName /Adobe-Identity-UCS def

/CMapType 2 def

1 begincodespacerange

<0000> <ffff>

endcodespacerange

%d beginbfrange

%s

endbfrange

endcmap

CMapName currentdict /CMap defineresource pop

end

end"""

def embedTTF(self, filename, characters):

"""Embed the TTF font from the named file into the document."""

font = get_font(filename)

fonttype = rcParams['pdf.fonttype']

def cvt(length, upe=font.units_per_EM, nearest=True):

"Convert font coordinates to PDF glyph coordinates"

value = length / upe * 1000

if nearest:

return np.round(value)

# Perhaps best to round away from zero for bounding

# boxes and the like

if value < 0:

return floor(value)

else:

return ceil(value)

def embedTTFType3(font, characters, descriptor):

"""The Type 3-specific part of embedding a Truetype font"""

widthsObject = self.reserveObject('font widths')

fontdescObject = self.reserveObject('font descriptor')

fontdictObject = self.reserveObject('font dictionary')

charprocsObject = self.reserveObject('character procs')

differencesArray = []

firstchar, lastchar = 0, 255

bbox = [cvt(x, nearest=False) for x in font.bbox]

fontdict = {

'Type': Name('Font'),

'BaseFont': ps_name,

'FirstChar': firstchar,

'LastChar': lastchar,

'FontDescriptor': fontdescObject,

'Subtype': Name('Type3'),

'Name': descriptor['FontName'],

'FontBBox': bbox,

'FontMatrix': [.001, 0, 0, .001, 0, 0],

'CharProcs': charprocsObject,

'Encoding': {

'Type': Name('Encoding'),

'Differences': differencesArray},

'Widths': widthsObject

}

# Make the "Widths" array

from encodings import cp1252

# The "decoding_map" was changed

# to a "decoding_table" as of Python 2.5.

if hasattr(cp1252, 'decoding_map'):

def decode_char(charcode):

return cp1252.decoding_map[charcode] or 0

else:

def decode_char(charcode):

return ord(cp1252.decoding_table[charcode])

def get_char_width(charcode):

s = decode_char(charcode)

width = font.load_char(

s, flags=LOAD_NO_SCALE | LOAD_NO_HINTING).horiAdvance

return cvt(width)

widths = [get_char_width(charcode)

for charcode in range(firstchar, lastchar+1)]

descriptor['MaxWidth'] = max(widths)

# Make the "Differences" array, sort the ccodes < 255 from

# the multi-byte ccodes, and build the whole set of glyph ids

# that we need from this font.

glyph_ids = []

differences = []

multi_byte_chars = set()

for c in characters:

ccode = c

gind = font.get_char_index(ccode)

glyph_ids.append(gind)

glyph_name = font.get_glyph_name(gind)

if ccode <= 255:

differences.append((ccode, glyph_name))

else:

multi_byte_chars.add(glyph_name)

differences.sort()

last_c = -2

for c, name in differences:

if c != last_c + 1:

differencesArray.append(c)

differencesArray.append(Name(name))

last_c = c

# Make the charprocs array (using ttconv to generate the

# actual outlines)

rawcharprocs = ttconv.get_pdf_charprocs(

filename.encode(sys.getfilesystemencoding()), glyph_ids)

charprocs = {}

for charname, stream in six.iteritems(rawcharprocs):

charprocDict = {'Length': len(stream)}

# The 2-byte characters are used as XObjects, so they

# need extra info in their dictionary

if charname in multi_byte_chars:

charprocDict['Type'] = Name('XObject')

charprocDict['Subtype'] = Name('Form')

charprocDict['BBox'] = bbox

# Each glyph includes bounding box information,

# but xpdf and ghostscript can't handle it in a

# Form XObject (they segfault!!!), so we remove it

# from the stream here. It's not needed anyway,

# since the Form XObject includes it in its BBox

# value.

stream = stream[stream.find(b"d1") + 2:]

charprocObject = self.reserveObject('charProc')

self.beginStream(charprocObject.id, None, charprocDict)

self.currentstream.write(stream)

self.endStream()

# Send the glyphs with ccode > 255 to the XObject dictionary,

# and the others to the font itself

if charname in multi_byte_chars:

name = self._get_xobject_symbol_name(filename, charname)

self.multi_byte_charprocs[name] = charprocObject

else:

charprocs[charname] = charprocObject

# Write everything out

self.writeObject(fontdictObject, fontdict)

self.writeObject(fontdescObject, descriptor)

self.writeObject(widthsObject, widths)

self.writeObject(charprocsObject, charprocs)

return fontdictObject

def embedTTFType42(font, characters, descriptor):

"""The Type 42-specific part of embedding a Truetype font"""

fontdescObject = self.reserveObject('font descriptor')

cidFontDictObject = self.reserveObject('CID font dictionary')

type0FontDictObject = self.reserveObject('Type 0 font dictionary')

cidToGidMapObject = self.reserveObject('CIDToGIDMap stream')

fontfileObject = self.reserveObject('font file stream')

wObject = self.reserveObject('Type 0 widths')

toUnicodeMapObject = self.reserveObject('ToUnicode map')

cidFontDict = {

'Type': Name('Font'),

'Subtype': Name('CIDFontType2'),

'BaseFont': ps_name,

'CIDSystemInfo': {

'Registry': 'Adobe',

'Ordering': 'Identity',

'Supplement': 0},

'FontDescriptor': fontdescObject,

'W': wObject,

'CIDToGIDMap': cidToGidMapObject

}

type0FontDict = {

'Type': Name('Font'),

'Subtype': Name('Type0'),

'BaseFont': ps_name,

'Encoding': Name('Identity-H'),

'DescendantFonts': [cidFontDictObject],

'ToUnicode': toUnicodeMapObject

}

# Make fontfile stream

descriptor['FontFile2'] = fontfileObject

length1Object = self.reserveObject('decoded length of a font')

self.beginStream(

fontfileObject.id,

self.reserveObject('length of font stream'),

{'Length1': length1Object})

with open(filename, 'rb') as fontfile:

length1 = 0

while True: