/usr/share/pyshared/matplotlib/type1font.py is in python-matplotlib 1.1.1~rc1+git20120423-0ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 | """
This module contains a class representing a Type 1 font.
This version reads pfa and pfb files and splits them for embedding in
pdf files. It also supports SlantFont and ExtendFont transformations,
similarly to pdfTeX and friends. There is no support yet for
subsetting.
Usage::
>>> font = Type1Font(filename)
>>> clear_part, encrypted_part, finale = font.parts
>>> slanted_font = font.transform({'slant': 0.167})
>>> extended_font = font.transform({'extend': 1.2})
Sources:
* Adobe Technical Note #5040, Supporting Downloadable PostScript
Language Fonts.
* Adobe Type 1 Font Format, Adobe Systems Incorporated, third printing,
v1.1, 1993. ISBN 0-201-57044-0.
"""
import matplotlib.cbook as cbook
import cStringIO
import itertools
import numpy as np
import re
import struct
class Type1Font(object):
"""
A class representing a Type-1 font, for use by backends.
.. attribute:: parts
A 3-tuple of the cleartext part, the encrypted part, and the
finale of zeros.
.. attribute:: prop
A dictionary of font properties.
"""
__slots__ = ('parts', 'prop')
def __init__(self, input):
"""
Initialize a Type-1 font. *input* can be either the file name of
a pfb file or a 3-tuple of already-decoded Type-1 font parts.
"""
if isinstance(input, tuple) and len(input) == 3:
self.parts = input
else:
file = open(input, 'rb')
try:
data = self._read(file)
finally:
file.close()
self.parts = self._split(data)
self._parse()
def _read(self, file):
"""
Read the font from a file, decoding into usable parts.
"""
rawdata = file.read()
if not rawdata.startswith(chr(128)):
return rawdata
data = ''
while len(rawdata) > 0:
if not rawdata.startswith(chr(128)):
raise RuntimeError, \
'Broken pfb file (expected byte 128, got %d)' % \
ord(rawdata[0])
type = ord(rawdata[1])
if type in (1,2):
length, = struct.unpack('<i', rawdata[2:6])
segment = rawdata[6:6+length]
rawdata = rawdata[6+length:]
if type == 1: # ASCII text: include verbatim
data += segment
elif type == 2: # binary data: encode in hexadecimal
data += ''.join(['%02x' % ord(char)
for char in segment])
elif type == 3: # end of file
break
else:
raise RuntimeError, \
'Unknown segment type %d in pfb file' % type
return data
def _split(self, data):
"""
Split the Type 1 font into its three main parts.
The three parts are: (1) the cleartext part, which ends in a
eexec operator; (2) the encrypted part; (3) the fixed part,
which contains 512 ASCII zeros possibly divided on various
lines, a cleartomark operator, and possibly something else.
"""
# Cleartext part: just find the eexec and skip whitespace
idx = data.index('eexec')
idx += len('eexec')
while data[idx] in ' \t\r\n':
idx += 1
len1 = idx
# Encrypted part: find the cleartomark operator and count
# zeros backward
idx = data.rindex('cleartomark') - 1
zeros = 512
while zeros and data[idx] in ('0', '\n', '\r'):
if data[idx] == '0':
zeros -= 1
idx -= 1
if zeros:
raise RuntimeError, 'Insufficiently many zeros in Type 1 font'
# Convert encrypted part to binary (if we read a pfb file, we
# may end up converting binary to hexadecimal to binary again;
# but if we read a pfa file, this part is already in hex, and
# I am not quite sure if even the pfb format guarantees that
# it will be in binary).
binary = ''.join([chr(int(data[i:i+2], 16))
for i in range(len1, idx, 2)])
return data[:len1], binary, data[idx:]
_whitespace = re.compile(r'[\0\t\r\014\n ]+')
_token = re.compile(r'/{0,2}[^]\0\t\r\v\n ()<>{}/%[]+')
_comment = re.compile(r'%[^\r\n\v]*')
_instring = re.compile(r'[()\\]')
@classmethod
def _tokens(cls, text):
"""
A PostScript tokenizer. Yield (token, value) pairs such as
('whitespace', ' ') or ('name', '/Foobar').
"""
pos = 0
while pos < len(text):
match = cls._comment.match(text[pos:]) or cls._whitespace.match(text[pos:])
if match:
yield ('whitespace', match.group())
pos += match.end()
elif text[pos] == '(':
start = pos
pos += 1
depth = 1
while depth:
match = cls._instring.search(text[pos:])
if match is None: return
pos += match.end()
if match.group() == '(':
depth += 1
elif match.group() == ')':
depth -= 1
else: # a backslash - skip the next character
pos += 1
yield ('string', text[start:pos])
elif text[pos:pos+2] in ('<<', '>>'):
yield ('delimiter', text[pos:pos+2])
pos += 2
elif text[pos] == '<':
start = pos
pos += text[pos:].index('>')
yield ('string', text[start:pos])
else:
match = cls._token.match(text[pos:])
if match:
try:
float(match.group())
yield ('number', match.group())
except ValueError:
yield ('name', match.group())
pos += match.end()
else:
yield ('delimiter', text[pos])
pos += 1
def _parse(self):
"""
Find the values of various font properties. This limited kind
of parsing is described in Chapter 10 "Adobe Type Manager
Compatibility" of the Type-1 spec.
"""
# Start with reasonable defaults
prop = { 'weight': 'Regular', 'ItalicAngle': 0.0, 'isFixedPitch': False,
'UnderlinePosition': -100, 'UnderlineThickness': 50 }
tokenizer = self._tokens(self.parts[0])
filtered = itertools.ifilter(lambda x: x[0] != 'whitespace', tokenizer)
for token, value in filtered:
if token == 'name' and value.startswith('/'):
key = value[1:]
token, value = filtered.next()
if token == 'name':
if value in ('true', 'false'):
value = value == 'true'
else:
value = value.lstrip('/')
elif token == 'string':
value = value.lstrip('(').rstrip(')')
elif token == 'number':
if '.' in value: value = float(value)
else: value = int(value)
else: # more complicated value such as an array
value = None
if key != 'FontInfo' and value is not None:
prop[key] = value
# Fill in the various *Name properties
if not prop.has_key('FontName'):
prop['FontName'] = prop.get('FullName') or prop.get('FamilyName') or 'Unknown'
if not prop.has_key('FullName'):
prop['FullName'] = prop['FontName']
if not prop.has_key('FamilyName'):
extras = r'(?i)([ -](regular|plain|italic|oblique|(semi)?bold|(ultra)?light|extra|condensed))+$'
prop['FamilyName'] = re.sub(extras, '', prop['FullName'])
self.prop = prop
@classmethod
def _transformer(cls, tokens, slant, extend):
def fontname(name):
result = name
if slant: result += '_Slant_' + str(int(1000*slant))
if extend != 1.0: result += '_Extend_' + str(int(1000*extend))
return result
def italicangle(angle):
return str(float(angle) - np.arctan(slant)/np.pi*180)
def fontmatrix(array):
array = array.lstrip('[').rstrip(']').strip().split()
array = [ float(x) for x in array ]
oldmatrix = np.eye(3,3)
oldmatrix[0:3,0] = array[::2]
oldmatrix[0:3,1] = array[1::2]
modifier = np.array([[extend, 0, 0],
[slant, 1, 0],
[0, 0, 1]])
newmatrix = np.dot(modifier, oldmatrix)
array[::2] = newmatrix[0:3,0]
array[1::2] = newmatrix[0:3,1]
return '[' + ' '.join(str(x) for x in array) + ']'
def replace(fun):
def replacer(tokens):
token, value = tokens.next() # name, e.g. /FontMatrix
yield value
token, value = tokens.next() # possible whitespace
while token == 'whitespace':
yield value
token, value = tokens.next()
if value != '[': # name/number/etc.
yield fun(value)
else: # array, e.g. [1 2 3]
array = []
while value != ']':
array += value
token, value = tokens.next()
array += value
yield fun(''.join(array))
return replacer
def suppress(tokens):
for x in itertools.takewhile(lambda x: x[1] != 'def', tokens):
pass
yield ''
table = { '/FontName': replace(fontname),
'/ItalicAngle': replace(italicangle),
'/FontMatrix': replace(fontmatrix),
'/UniqueID': suppress }
while True:
token, value = tokens.next()
if token == 'name' and value in table:
for value in table[value](itertools.chain([(token, value)], tokens)):
yield value
else:
yield value
def transform(self, effects):
"""
Transform the font by slanting or extending. *effects* should
be a dict where ``effects['slant']`` is the tangent of the
angle that the font is to be slanted to the right (so negative
values slant to the left) and ``effects['extend']`` is the
multiplier by which the font is to be extended (so values less
than 1.0 condense). Returns a new :class:`Type1Font` object.
"""
buffer = cStringIO.StringIO()
tokenizer = self._tokens(self.parts[0])
for value in self._transformer(tokenizer,
slant=effects.get('slant', 0.0),
extend=effects.get('extend', 1.0)):
buffer.write(value)
result = buffer.getvalue()
buffer.close()
return Type1Font((result, self.parts[1], self.parts[2]))
|