bddedc1bc1
we don't need to round all simple glyphs' coordinates (which may be costly), only when these are used as components with an interesting transform
2312 lines
84 KiB
Python
2312 lines
84 KiB
Python
"""_g_l_y_f.py -- Converter classes for the 'glyf' table."""
|
||
|
||
from collections import namedtuple
|
||
from fontTools.misc import sstruct
|
||
from fontTools import ttLib
|
||
from fontTools import version
|
||
from fontTools.misc.transform import DecomposedTransform
|
||
from fontTools.misc.textTools import tostr, safeEval, pad
|
||
from fontTools.misc.arrayTools import updateBounds, pointInRect
|
||
from fontTools.misc.bezierTools import calcQuadraticBounds
|
||
from fontTools.misc.fixedTools import (
|
||
fixedToFloat as fi2fl,
|
||
floatToFixed as fl2fi,
|
||
floatToFixedToStr as fl2str,
|
||
strToFixedToFloat as str2fl,
|
||
)
|
||
from fontTools.misc.roundTools import noRound, otRound
|
||
from fontTools.misc.vector import Vector
|
||
from numbers import Number
|
||
from . import DefaultTable
|
||
from . import ttProgram
|
||
import sys
|
||
import struct
|
||
import array
|
||
import logging
|
||
import math
|
||
import os
|
||
from fontTools.misc import xmlWriter
|
||
from fontTools.misc.filenames import userNameToFileName
|
||
from fontTools.misc.loggingTools import deprecateFunction
|
||
from enum import IntFlag
|
||
from functools import partial
|
||
from types import SimpleNamespace
|
||
from typing import Set
|
||
|
||
log = logging.getLogger(__name__)
|
||
|
||
# We compute the version the same as is computed in ttlib/__init__
|
||
# so that we can write 'ttLibVersion' attribute of the glyf TTX files
|
||
# when glyf is written to separate files.
|
||
version = ".".join(version.split(".")[:2])
|
||
|
||
#
|
||
# The Apple and MS rasterizers behave differently for
|
||
# scaled composite components: one does scale first and then translate
|
||
# and the other does it vice versa. MS defined some flags to indicate
|
||
# the difference, but it seems nobody actually _sets_ those flags.
|
||
#
|
||
# Funny thing: Apple seems to _only_ do their thing in the
|
||
# WE_HAVE_A_SCALE (eg. Chicago) case, and not when it's WE_HAVE_AN_X_AND_Y_SCALE
|
||
# (eg. Charcoal)...
|
||
#
|
||
SCALE_COMPONENT_OFFSET_DEFAULT = 0 # 0 == MS, 1 == Apple
|
||
|
||
|
||
class table__g_l_y_f(DefaultTable.DefaultTable):
|
||
"""Glyph Data table
|
||
|
||
This class represents the `glyf <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf>`_
|
||
table, which contains outlines for glyphs in TrueType format. In many cases,
|
||
it is easier to access and manipulate glyph outlines through the ``GlyphSet``
|
||
object returned from :py:meth:`fontTools.ttLib.ttFont.getGlyphSet`::
|
||
|
||
>> from fontTools.pens.boundsPen import BoundsPen
|
||
>> glyphset = font.getGlyphSet()
|
||
>> bp = BoundsPen(glyphset)
|
||
>> glyphset["A"].draw(bp)
|
||
>> bp.bounds
|
||
(19, 0, 633, 716)
|
||
|
||
However, this class can be used for low-level access to the ``glyf`` table data.
|
||
Objects of this class support dictionary-like access, mapping glyph names to
|
||
:py:class:`Glyph` objects::
|
||
|
||
>> glyf = font["glyf"]
|
||
>> len(glyf["Aacute"].components)
|
||
2
|
||
|
||
Note that when adding glyphs to the font via low-level access to the ``glyf``
|
||
table, the new glyphs must also be added to the ``hmtx``/``vmtx`` table::
|
||
|
||
>> font["glyf"]["divisionslash"] = Glyph()
|
||
>> font["hmtx"]["divisionslash"] = (640, 0)
|
||
|
||
"""
|
||
|
||
dependencies = ["fvar"]
|
||
|
||
# this attribute controls the amount of padding applied to glyph data upon compile.
|
||
# Glyph lenghts are aligned to multiples of the specified value.
|
||
# Allowed values are (0, 1, 2, 4). '0' means no padding; '1' (default) also means
|
||
# no padding, except for when padding would allow to use short loca offsets.
|
||
padding = 1
|
||
|
||
def decompile(self, data, ttFont):
|
||
self.axisTags = (
|
||
[axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
|
||
)
|
||
loca = ttFont["loca"]
|
||
pos = int(loca[0])
|
||
nextPos = 0
|
||
noname = 0
|
||
self.glyphs = {}
|
||
self.glyphOrder = glyphOrder = ttFont.getGlyphOrder()
|
||
self._reverseGlyphOrder = {}
|
||
for i in range(0, len(loca) - 1):
|
||
try:
|
||
glyphName = glyphOrder[i]
|
||
except IndexError:
|
||
noname = noname + 1
|
||
glyphName = "ttxautoglyph%s" % i
|
||
nextPos = int(loca[i + 1])
|
||
glyphdata = data[pos:nextPos]
|
||
if len(glyphdata) != (nextPos - pos):
|
||
raise ttLib.TTLibError("not enough 'glyf' table data")
|
||
glyph = Glyph(glyphdata)
|
||
self.glyphs[glyphName] = glyph
|
||
pos = nextPos
|
||
if len(data) - nextPos >= 4:
|
||
log.warning(
|
||
"too much 'glyf' table data: expected %d, received %d bytes",
|
||
nextPos,
|
||
len(data),
|
||
)
|
||
if noname:
|
||
log.warning("%s glyphs have no name", noname)
|
||
if ttFont.lazy is False: # Be lazy for None and True
|
||
self.ensureDecompiled()
|
||
|
||
def ensureDecompiled(self, recurse=False):
|
||
# The recurse argument is unused, but part of the signature of
|
||
# ensureDecompiled across the library.
|
||
for glyph in self.glyphs.values():
|
||
glyph.expand(self)
|
||
|
||
def compile(self, ttFont):
|
||
self.axisTags = (
|
||
[axis.axisTag for axis in ttFont["fvar"].axes] if "fvar" in ttFont else []
|
||
)
|
||
if not hasattr(self, "glyphOrder"):
|
||
self.glyphOrder = ttFont.getGlyphOrder()
|
||
padding = self.padding
|
||
assert padding in (0, 1, 2, 4)
|
||
locations = []
|
||
currentLocation = 0
|
||
dataList = []
|
||
recalcBBoxes = ttFont.recalcBBoxes
|
||
boundsDone = set()
|
||
for glyphName in self.glyphOrder:
|
||
glyph = self.glyphs[glyphName]
|
||
glyphData = glyph.compile(self, recalcBBoxes, boundsDone=boundsDone)
|
||
if padding > 1:
|
||
glyphData = pad(glyphData, size=padding)
|
||
locations.append(currentLocation)
|
||
currentLocation = currentLocation + len(glyphData)
|
||
dataList.append(glyphData)
|
||
locations.append(currentLocation)
|
||
|
||
if padding == 1 and currentLocation < 0x20000:
|
||
# See if we can pad any odd-lengthed glyphs to allow loca
|
||
# table to use the short offsets.
|
||
indices = [
|
||
i for i, glyphData in enumerate(dataList) if len(glyphData) % 2 == 1
|
||
]
|
||
if indices and currentLocation + len(indices) < 0x20000:
|
||
# It fits. Do it.
|
||
for i in indices:
|
||
dataList[i] += b"\0"
|
||
currentLocation = 0
|
||
for i, glyphData in enumerate(dataList):
|
||
locations[i] = currentLocation
|
||
currentLocation += len(glyphData)
|
||
locations[len(dataList)] = currentLocation
|
||
|
||
data = b"".join(dataList)
|
||
if "loca" in ttFont:
|
||
ttFont["loca"].set(locations)
|
||
if "maxp" in ttFont:
|
||
ttFont["maxp"].numGlyphs = len(self.glyphs)
|
||
if not data:
|
||
# As a special case when all glyph in the font are empty, add a zero byte
|
||
# to the table, so that OTS doesn’t reject it, and to make the table work
|
||
# on Windows as well.
|
||
# See https://github.com/khaledhosny/ots/issues/52
|
||
data = b"\0"
|
||
return data
|
||
|
||
def toXML(self, writer, ttFont, splitGlyphs=False):
|
||
notice = (
|
||
"The xMin, yMin, xMax and yMax values\n"
|
||
"will be recalculated by the compiler."
|
||
)
|
||
glyphNames = ttFont.getGlyphNames()
|
||
if not splitGlyphs:
|
||
writer.newline()
|
||
writer.comment(notice)
|
||
writer.newline()
|
||
writer.newline()
|
||
numGlyphs = len(glyphNames)
|
||
if splitGlyphs:
|
||
path, ext = os.path.splitext(writer.file.name)
|
||
existingGlyphFiles = set()
|
||
for glyphName in glyphNames:
|
||
glyph = self.get(glyphName)
|
||
if glyph is None:
|
||
log.warning("glyph '%s' does not exist in glyf table", glyphName)
|
||
continue
|
||
if glyph.numberOfContours:
|
||
if splitGlyphs:
|
||
glyphPath = userNameToFileName(
|
||
tostr(glyphName, "utf-8"),
|
||
existingGlyphFiles,
|
||
prefix=path + ".",
|
||
suffix=ext,
|
||
)
|
||
existingGlyphFiles.add(glyphPath.lower())
|
||
glyphWriter = xmlWriter.XMLWriter(
|
||
glyphPath,
|
||
idlefunc=writer.idlefunc,
|
||
newlinestr=writer.newlinestr,
|
||
)
|
||
glyphWriter.begintag("ttFont", ttLibVersion=version)
|
||
glyphWriter.newline()
|
||
glyphWriter.begintag("glyf")
|
||
glyphWriter.newline()
|
||
glyphWriter.comment(notice)
|
||
glyphWriter.newline()
|
||
writer.simpletag("TTGlyph", src=os.path.basename(glyphPath))
|
||
else:
|
||
glyphWriter = writer
|
||
glyphWriter.begintag(
|
||
"TTGlyph",
|
||
[
|
||
("name", glyphName),
|
||
("xMin", glyph.xMin),
|
||
("yMin", glyph.yMin),
|
||
("xMax", glyph.xMax),
|
||
("yMax", glyph.yMax),
|
||
],
|
||
)
|
||
glyphWriter.newline()
|
||
glyph.toXML(glyphWriter, ttFont)
|
||
glyphWriter.endtag("TTGlyph")
|
||
glyphWriter.newline()
|
||
if splitGlyphs:
|
||
glyphWriter.endtag("glyf")
|
||
glyphWriter.newline()
|
||
glyphWriter.endtag("ttFont")
|
||
glyphWriter.newline()
|
||
glyphWriter.close()
|
||
else:
|
||
writer.simpletag("TTGlyph", name=glyphName)
|
||
writer.comment("contains no outline data")
|
||
if not splitGlyphs:
|
||
writer.newline()
|
||
writer.newline()
|
||
|
||
def fromXML(self, name, attrs, content, ttFont):
|
||
if name != "TTGlyph":
|
||
return
|
||
if not hasattr(self, "glyphs"):
|
||
self.glyphs = {}
|
||
if not hasattr(self, "glyphOrder"):
|
||
self.glyphOrder = ttFont.getGlyphOrder()
|
||
glyphName = attrs["name"]
|
||
log.debug("unpacking glyph '%s'", glyphName)
|
||
glyph = Glyph()
|
||
for attr in ["xMin", "yMin", "xMax", "yMax"]:
|
||
setattr(glyph, attr, safeEval(attrs.get(attr, "0")))
|
||
self.glyphs[glyphName] = glyph
|
||
for element in content:
|
||
if not isinstance(element, tuple):
|
||
continue
|
||
name, attrs, content = element
|
||
glyph.fromXML(name, attrs, content, ttFont)
|
||
if not ttFont.recalcBBoxes:
|
||
glyph.compact(self, 0)
|
||
|
||
def setGlyphOrder(self, glyphOrder):
|
||
"""Sets the glyph order
|
||
|
||
Args:
|
||
glyphOrder ([str]): List of glyph names in order.
|
||
"""
|
||
self.glyphOrder = glyphOrder
|
||
self._reverseGlyphOrder = {}
|
||
|
||
def getGlyphName(self, glyphID):
|
||
"""Returns the name for the glyph with the given ID.
|
||
|
||
Raises a ``KeyError`` if the glyph name is not found in the font.
|
||
"""
|
||
return self.glyphOrder[glyphID]
|
||
|
||
def _buildReverseGlyphOrderDict(self):
|
||
self._reverseGlyphOrder = d = {}
|
||
for glyphID, glyphName in enumerate(self.glyphOrder):
|
||
d[glyphName] = glyphID
|
||
|
||
def getGlyphID(self, glyphName):
|
||
"""Returns the ID of the glyph with the given name.
|
||
|
||
Raises a ``ValueError`` if the glyph is not found in the font.
|
||
"""
|
||
glyphOrder = self.glyphOrder
|
||
id = getattr(self, "_reverseGlyphOrder", {}).get(glyphName)
|
||
if id is None or id >= len(glyphOrder) or glyphOrder[id] != glyphName:
|
||
self._buildReverseGlyphOrderDict()
|
||
id = self._reverseGlyphOrder.get(glyphName)
|
||
if id is None:
|
||
raise ValueError(glyphName)
|
||
return id
|
||
|
||
def removeHinting(self):
|
||
"""Removes TrueType hints from all glyphs in the glyphset.
|
||
|
||
See :py:meth:`Glyph.removeHinting`.
|
||
"""
|
||
for glyph in self.glyphs.values():
|
||
glyph.removeHinting()
|
||
|
||
def keys(self):
|
||
return self.glyphs.keys()
|
||
|
||
def has_key(self, glyphName):
|
||
return glyphName in self.glyphs
|
||
|
||
__contains__ = has_key
|
||
|
||
def get(self, glyphName, default=None):
|
||
glyph = self.glyphs.get(glyphName, default)
|
||
if glyph is not None:
|
||
glyph.expand(self)
|
||
return glyph
|
||
|
||
def __getitem__(self, glyphName):
|
||
glyph = self.glyphs[glyphName]
|
||
glyph.expand(self)
|
||
return glyph
|
||
|
||
def __setitem__(self, glyphName, glyph):
|
||
self.glyphs[glyphName] = glyph
|
||
if glyphName not in self.glyphOrder:
|
||
self.glyphOrder.append(glyphName)
|
||
|
||
def __delitem__(self, glyphName):
|
||
del self.glyphs[glyphName]
|
||
self.glyphOrder.remove(glyphName)
|
||
|
||
def __len__(self):
|
||
assert len(self.glyphOrder) == len(self.glyphs)
|
||
return len(self.glyphs)
|
||
|
||
def _getPhantomPoints(self, glyphName, hMetrics, vMetrics=None):
|
||
"""Compute the four "phantom points" for the given glyph from its bounding box
|
||
and the horizontal and vertical advance widths and sidebearings stored in the
|
||
ttFont's "hmtx" and "vmtx" tables.
|
||
|
||
'hMetrics' should be ttFont['hmtx'].metrics.
|
||
|
||
'vMetrics' should be ttFont['vmtx'].metrics if there is "vmtx" or None otherwise.
|
||
If there is no vMetrics passed in, vertical phantom points are set to the zero coordinate.
|
||
|
||
https://docs.microsoft.com/en-us/typography/opentype/spec/tt_instructing_glyphs#phantoms
|
||
"""
|
||
glyph = self[glyphName]
|
||
if not hasattr(glyph, "xMin"):
|
||
glyph.recalcBounds(self)
|
||
|
||
horizontalAdvanceWidth, leftSideBearing = hMetrics[glyphName]
|
||
leftSideX = glyph.xMin - leftSideBearing
|
||
rightSideX = leftSideX + horizontalAdvanceWidth
|
||
|
||
if vMetrics:
|
||
verticalAdvanceWidth, topSideBearing = vMetrics[glyphName]
|
||
topSideY = topSideBearing + glyph.yMax
|
||
bottomSideY = topSideY - verticalAdvanceWidth
|
||
else:
|
||
bottomSideY = topSideY = 0
|
||
|
||
return [
|
||
(leftSideX, 0),
|
||
(rightSideX, 0),
|
||
(0, topSideY),
|
||
(0, bottomSideY),
|
||
]
|
||
|
||
def _getCoordinatesAndControls(
|
||
self, glyphName, hMetrics, vMetrics=None, *, round=otRound
|
||
):
|
||
"""Return glyph coordinates and controls as expected by "gvar" table.
|
||
|
||
The coordinates includes four "phantom points" for the glyph metrics,
|
||
as mandated by the "gvar" spec.
|
||
|
||
The glyph controls is a namedtuple with the following attributes:
|
||
- numberOfContours: -1 for composite glyphs.
|
||
- endPts: list of indices of end points for each contour in simple
|
||
glyphs, or component indices in composite glyphs (used for IUP
|
||
optimization).
|
||
- flags: array of contour point flags for simple glyphs (None for
|
||
composite glyphs).
|
||
- components: list of base glyph names (str) for each component in
|
||
composite glyphs (None for simple glyphs).
|
||
|
||
The "hMetrics" and vMetrics are used to compute the "phantom points" (see
|
||
the "_getPhantomPoints" method).
|
||
|
||
Return None if the requested glyphName is not present.
|
||
"""
|
||
glyph = self.get(glyphName)
|
||
if glyph is None:
|
||
return None
|
||
if glyph.isComposite():
|
||
coords = GlyphCoordinates(
|
||
[(getattr(c, "x", 0), getattr(c, "y", 0)) for c in glyph.components]
|
||
)
|
||
controls = _GlyphControls(
|
||
numberOfContours=glyph.numberOfContours,
|
||
endPts=list(range(len(glyph.components))),
|
||
flags=None,
|
||
components=[
|
||
(c.glyphName, getattr(c, "transform", None))
|
||
for c in glyph.components
|
||
],
|
||
)
|
||
else:
|
||
coords, endPts, flags = glyph.getCoordinates(self)
|
||
coords = coords.copy()
|
||
controls = _GlyphControls(
|
||
numberOfContours=glyph.numberOfContours,
|
||
endPts=endPts,
|
||
flags=flags,
|
||
components=None,
|
||
)
|
||
# Add phantom points for (left, right, top, bottom) positions.
|
||
phantomPoints = self._getPhantomPoints(glyphName, hMetrics, vMetrics)
|
||
coords.extend(phantomPoints)
|
||
coords.toInt(round=round)
|
||
return coords, controls
|
||
|
||
def _setCoordinates(self, glyphName, coord, hMetrics, vMetrics=None):
|
||
"""Set coordinates and metrics for the given glyph.
|
||
|
||
"coord" is an array of GlyphCoordinates which must include the "phantom
|
||
points" as the last four coordinates.
|
||
|
||
Both the horizontal/vertical advances and left/top sidebearings in "hmtx"
|
||
and "vmtx" tables (if any) are updated from four phantom points and
|
||
the glyph's bounding boxes.
|
||
|
||
The "hMetrics" and vMetrics are used to propagate "phantom points"
|
||
into "hmtx" and "vmtx" tables if desired. (see the "_getPhantomPoints"
|
||
method).
|
||
"""
|
||
glyph = self[glyphName]
|
||
|
||
# Handle phantom points for (left, right, top, bottom) positions.
|
||
assert len(coord) >= 4
|
||
leftSideX = coord[-4][0]
|
||
rightSideX = coord[-3][0]
|
||
topSideY = coord[-2][1]
|
||
bottomSideY = coord[-1][1]
|
||
|
||
coord = coord[:-4]
|
||
|
||
if glyph.isComposite():
|
||
assert len(coord) == len(glyph.components)
|
||
for p, comp in zip(coord, glyph.components):
|
||
if hasattr(comp, "x"):
|
||
comp.x, comp.y = p
|
||
elif glyph.numberOfContours == 0:
|
||
assert len(coord) == 0
|
||
else:
|
||
assert len(coord) == len(glyph.coordinates)
|
||
glyph.coordinates = GlyphCoordinates(coord)
|
||
|
||
glyph.recalcBounds(self, boundsDone=set())
|
||
|
||
horizontalAdvanceWidth = otRound(rightSideX - leftSideX)
|
||
if horizontalAdvanceWidth < 0:
|
||
# unlikely, but it can happen, see:
|
||
# https://github.com/fonttools/fonttools/pull/1198
|
||
horizontalAdvanceWidth = 0
|
||
leftSideBearing = otRound(glyph.xMin - leftSideX)
|
||
hMetrics[glyphName] = horizontalAdvanceWidth, leftSideBearing
|
||
|
||
if vMetrics is not None:
|
||
verticalAdvanceWidth = otRound(topSideY - bottomSideY)
|
||
if verticalAdvanceWidth < 0: # unlikely but do the same as horizontal
|
||
verticalAdvanceWidth = 0
|
||
topSideBearing = otRound(topSideY - glyph.yMax)
|
||
vMetrics[glyphName] = verticalAdvanceWidth, topSideBearing
|
||
|
||
# Deprecated
|
||
|
||
def _synthesizeVMetrics(self, glyphName, ttFont, defaultVerticalOrigin):
|
||
"""This method is wrong and deprecated.
|
||
For rationale see:
|
||
https://github.com/fonttools/fonttools/pull/2266/files#r613569473
|
||
"""
|
||
vMetrics = getattr(ttFont.get("vmtx"), "metrics", None)
|
||
if vMetrics is None:
|
||
verticalAdvanceWidth = ttFont["head"].unitsPerEm
|
||
topSideY = getattr(ttFont.get("hhea"), "ascent", None)
|
||
if topSideY is None:
|
||
if defaultVerticalOrigin is not None:
|
||
topSideY = defaultVerticalOrigin
|
||
else:
|
||
topSideY = verticalAdvanceWidth
|
||
glyph = self[glyphName]
|
||
glyph.recalcBounds(self)
|
||
topSideBearing = otRound(topSideY - glyph.yMax)
|
||
vMetrics = {glyphName: (verticalAdvanceWidth, topSideBearing)}
|
||
return vMetrics
|
||
|
||
@deprecateFunction("use '_getPhantomPoints' instead", category=DeprecationWarning)
|
||
def getPhantomPoints(self, glyphName, ttFont, defaultVerticalOrigin=None):
|
||
"""Old public name for self._getPhantomPoints().
|
||
See: https://github.com/fonttools/fonttools/pull/2266"""
|
||
hMetrics = ttFont["hmtx"].metrics
|
||
vMetrics = self._synthesizeVMetrics(glyphName, ttFont, defaultVerticalOrigin)
|
||
return self._getPhantomPoints(glyphName, hMetrics, vMetrics)
|
||
|
||
@deprecateFunction(
|
||
"use '_getCoordinatesAndControls' instead", category=DeprecationWarning
|
||
)
|
||
def getCoordinatesAndControls(self, glyphName, ttFont, defaultVerticalOrigin=None):
|
||
"""Old public name for self._getCoordinatesAndControls().
|
||
See: https://github.com/fonttools/fonttools/pull/2266"""
|
||
hMetrics = ttFont["hmtx"].metrics
|
||
vMetrics = self._synthesizeVMetrics(glyphName, ttFont, defaultVerticalOrigin)
|
||
return self._getCoordinatesAndControls(glyphName, hMetrics, vMetrics)
|
||
|
||
@deprecateFunction("use '_setCoordinates' instead", category=DeprecationWarning)
|
||
def setCoordinates(self, glyphName, ttFont):
|
||
"""Old public name for self._setCoordinates().
|
||
See: https://github.com/fonttools/fonttools/pull/2266"""
|
||
hMetrics = ttFont["hmtx"].metrics
|
||
vMetrics = getattr(ttFont.get("vmtx"), "metrics", None)
|
||
self._setCoordinates(glyphName, hMetrics, vMetrics)
|
||
|
||
|
||
_GlyphControls = namedtuple(
|
||
"_GlyphControls", "numberOfContours endPts flags components"
|
||
)
|
||
|
||
|
||
glyphHeaderFormat = """
|
||
> # big endian
|
||
numberOfContours: h
|
||
xMin: h
|
||
yMin: h
|
||
xMax: h
|
||
yMax: h
|
||
"""
|
||
|
||
# flags
|
||
flagOnCurve = 0x01
|
||
flagXShort = 0x02
|
||
flagYShort = 0x04
|
||
flagRepeat = 0x08
|
||
flagXsame = 0x10
|
||
flagYsame = 0x20
|
||
flagOverlapSimple = 0x40
|
||
flagCubic = 0x80
|
||
|
||
# These flags are kept for XML output after decompiling the coordinates
|
||
keepFlags = flagOnCurve + flagOverlapSimple + flagCubic
|
||
|
||
_flagSignBytes = {
|
||
0: 2,
|
||
flagXsame: 0,
|
||
flagXShort | flagXsame: +1,
|
||
flagXShort: -1,
|
||
flagYsame: 0,
|
||
flagYShort | flagYsame: +1,
|
||
flagYShort: -1,
|
||
}
|
||
|
||
|
||
def flagBest(x, y, onCurve):
|
||
"""For a given x,y delta pair, returns the flag that packs this pair
|
||
most efficiently, as well as the number of byte cost of such flag."""
|
||
|
||
flag = flagOnCurve if onCurve else 0
|
||
cost = 0
|
||
# do x
|
||
if x == 0:
|
||
flag = flag | flagXsame
|
||
elif -255 <= x <= 255:
|
||
flag = flag | flagXShort
|
||
if x > 0:
|
||
flag = flag | flagXsame
|
||
cost += 1
|
||
else:
|
||
cost += 2
|
||
# do y
|
||
if y == 0:
|
||
flag = flag | flagYsame
|
||
elif -255 <= y <= 255:
|
||
flag = flag | flagYShort
|
||
if y > 0:
|
||
flag = flag | flagYsame
|
||
cost += 1
|
||
else:
|
||
cost += 2
|
||
return flag, cost
|
||
|
||
|
||
def flagFits(newFlag, oldFlag, mask):
|
||
newBytes = _flagSignBytes[newFlag & mask]
|
||
oldBytes = _flagSignBytes[oldFlag & mask]
|
||
return newBytes == oldBytes or abs(newBytes) > abs(oldBytes)
|
||
|
||
|
||
def flagSupports(newFlag, oldFlag):
|
||
return (
|
||
(oldFlag & flagOnCurve) == (newFlag & flagOnCurve)
|
||
and flagFits(newFlag, oldFlag, flagXsame | flagXShort)
|
||
and flagFits(newFlag, oldFlag, flagYsame | flagYShort)
|
||
)
|
||
|
||
|
||
def flagEncodeCoord(flag, mask, coord, coordBytes):
|
||
byteCount = _flagSignBytes[flag & mask]
|
||
if byteCount == 1:
|
||
coordBytes.append(coord)
|
||
elif byteCount == -1:
|
||
coordBytes.append(-coord)
|
||
elif byteCount == 2:
|
||
coordBytes.extend(struct.pack(">h", coord))
|
||
|
||
|
||
def flagEncodeCoords(flag, x, y, xBytes, yBytes):
|
||
flagEncodeCoord(flag, flagXsame | flagXShort, x, xBytes)
|
||
flagEncodeCoord(flag, flagYsame | flagYShort, y, yBytes)
|
||
|
||
|
||
ARG_1_AND_2_ARE_WORDS = 0x0001 # if set args are words otherwise they are bytes
|
||
ARGS_ARE_XY_VALUES = 0x0002 # if set args are xy values, otherwise they are points
|
||
ROUND_XY_TO_GRID = 0x0004 # for the xy values if above is true
|
||
WE_HAVE_A_SCALE = 0x0008 # Sx = Sy, otherwise scale == 1.0
|
||
NON_OVERLAPPING = 0x0010 # set to same value for all components (obsolete!)
|
||
MORE_COMPONENTS = 0x0020 # indicates at least one more glyph after this one
|
||
WE_HAVE_AN_X_AND_Y_SCALE = 0x0040 # Sx, Sy
|
||
WE_HAVE_A_TWO_BY_TWO = 0x0080 # t00, t01, t10, t11
|
||
WE_HAVE_INSTRUCTIONS = 0x0100 # instructions follow
|
||
USE_MY_METRICS = 0x0200 # apply these metrics to parent glyph
|
||
OVERLAP_COMPOUND = 0x0400 # used by Apple in GX fonts
|
||
SCALED_COMPONENT_OFFSET = 0x0800 # composite designed to have the component offset scaled (designed for Apple)
|
||
UNSCALED_COMPONENT_OFFSET = 0x1000 # composite designed not to have the component offset scaled (designed for MS)
|
||
|
||
|
||
CompositeMaxpValues = namedtuple(
|
||
"CompositeMaxpValues", ["nPoints", "nContours", "maxComponentDepth"]
|
||
)
|
||
|
||
|
||
class Glyph(object):
|
||
"""This class represents an individual TrueType glyph.
|
||
|
||
TrueType glyph objects come in two flavours: simple and composite. Simple
|
||
glyph objects contain contours, represented via the ``.coordinates``,
|
||
``.flags``, ``.numberOfContours``, and ``.endPtsOfContours`` attributes;
|
||
composite glyphs contain components, available through the ``.components``
|
||
attributes.
|
||
|
||
Because the ``.coordinates`` attribute (and other simple glyph attributes mentioned
|
||
above) is only set on simple glyphs and the ``.components`` attribute is only
|
||
set on composite glyphs, it is necessary to use the :py:meth:`isComposite`
|
||
method to test whether a glyph is simple or composite before attempting to
|
||
access its data.
|
||
|
||
For a composite glyph, the components can also be accessed via array-like access::
|
||
|
||
>> assert(font["glyf"]["Aacute"].isComposite())
|
||
>> font["glyf"]["Aacute"][0]
|
||
<fontTools.ttLib.tables._g_l_y_f.GlyphComponent at 0x1027b2ee0>
|
||
|
||
"""
|
||
|
||
def __init__(self, data=b""):
|
||
if not data:
|
||
# empty char
|
||
self.numberOfContours = 0
|
||
return
|
||
self.data = data
|
||
|
||
def compact(self, glyfTable, recalcBBoxes=True):
|
||
data = self.compile(glyfTable, recalcBBoxes)
|
||
self.__dict__.clear()
|
||
self.data = data
|
||
|
||
def expand(self, glyfTable):
|
||
if not hasattr(self, "data"):
|
||
# already unpacked
|
||
return
|
||
if not self.data:
|
||
# empty char
|
||
del self.data
|
||
self.numberOfContours = 0
|
||
return
|
||
dummy, data = sstruct.unpack2(glyphHeaderFormat, self.data, self)
|
||
del self.data
|
||
# Some fonts (eg. Neirizi.ttf) have a 0 for numberOfContours in
|
||
# some glyphs; decompileCoordinates assumes that there's at least
|
||
# one, so short-circuit here.
|
||
if self.numberOfContours == 0:
|
||
return
|
||
if self.isComposite():
|
||
self.decompileComponents(data, glyfTable)
|
||
else:
|
||
self.decompileCoordinates(data)
|
||
|
||
def compile(
|
||
self, glyfTable, recalcBBoxes=True, *, boundsDone=None, optimizeSize=None
|
||
):
|
||
if hasattr(self, "data"):
|
||
if recalcBBoxes:
|
||
# must unpack glyph in order to recalculate bounding box
|
||
self.expand(glyfTable)
|
||
else:
|
||
return self.data
|
||
if self.numberOfContours == 0:
|
||
return b""
|
||
|
||
if recalcBBoxes:
|
||
self.recalcBounds(glyfTable, boundsDone=boundsDone)
|
||
|
||
data = sstruct.pack(glyphHeaderFormat, self)
|
||
if self.isComposite():
|
||
data = data + self.compileComponents(glyfTable)
|
||
else:
|
||
if optimizeSize is None:
|
||
optimizeSize = getattr(glyfTable, "optimizeSize", True)
|
||
data = data + self.compileCoordinates(optimizeSize=optimizeSize)
|
||
return data
|
||
|
||
def toXML(self, writer, ttFont):
|
||
if self.isComposite():
|
||
for compo in self.components:
|
||
compo.toXML(writer, ttFont)
|
||
haveInstructions = hasattr(self, "program")
|
||
else:
|
||
last = 0
|
||
for i in range(self.numberOfContours):
|
||
writer.begintag("contour")
|
||
writer.newline()
|
||
for j in range(last, self.endPtsOfContours[i] + 1):
|
||
attrs = [
|
||
("x", self.coordinates[j][0]),
|
||
("y", self.coordinates[j][1]),
|
||
("on", self.flags[j] & flagOnCurve),
|
||
]
|
||
if self.flags[j] & flagOverlapSimple:
|
||
# Apple's rasterizer uses flagOverlapSimple in the first contour/first pt to flag glyphs that contain overlapping contours
|
||
attrs.append(("overlap", 1))
|
||
if self.flags[j] & flagCubic:
|
||
attrs.append(("cubic", 1))
|
||
writer.simpletag("pt", attrs)
|
||
writer.newline()
|
||
last = self.endPtsOfContours[i] + 1
|
||
writer.endtag("contour")
|
||
writer.newline()
|
||
haveInstructions = self.numberOfContours > 0
|
||
if haveInstructions:
|
||
if self.program:
|
||
writer.begintag("instructions")
|
||
writer.newline()
|
||
self.program.toXML(writer, ttFont)
|
||
writer.endtag("instructions")
|
||
else:
|
||
writer.simpletag("instructions")
|
||
writer.newline()
|
||
|
||
def fromXML(self, name, attrs, content, ttFont):
|
||
if name == "contour":
|
||
if self.numberOfContours < 0:
|
||
raise ttLib.TTLibError("can't mix composites and contours in glyph")
|
||
self.numberOfContours = self.numberOfContours + 1
|
||
coordinates = GlyphCoordinates()
|
||
flags = bytearray()
|
||
for element in content:
|
||
if not isinstance(element, tuple):
|
||
continue
|
||
name, attrs, content = element
|
||
if name != "pt":
|
||
continue # ignore anything but "pt"
|
||
coordinates.append((safeEval(attrs["x"]), safeEval(attrs["y"])))
|
||
flag = bool(safeEval(attrs["on"]))
|
||
if "overlap" in attrs and bool(safeEval(attrs["overlap"])):
|
||
flag |= flagOverlapSimple
|
||
if "cubic" in attrs and bool(safeEval(attrs["cubic"])):
|
||
flag |= flagCubic
|
||
flags.append(flag)
|
||
if not hasattr(self, "coordinates"):
|
||
self.coordinates = coordinates
|
||
self.flags = flags
|
||
self.endPtsOfContours = [len(coordinates) - 1]
|
||
else:
|
||
self.coordinates.extend(coordinates)
|
||
self.flags.extend(flags)
|
||
self.endPtsOfContours.append(len(self.coordinates) - 1)
|
||
elif name == "component":
|
||
if self.numberOfContours > 0:
|
||
raise ttLib.TTLibError("can't mix composites and contours in glyph")
|
||
self.numberOfContours = -1
|
||
if not hasattr(self, "components"):
|
||
self.components = []
|
||
component = GlyphComponent()
|
||
self.components.append(component)
|
||
component.fromXML(name, attrs, content, ttFont)
|
||
elif name == "instructions":
|
||
self.program = ttProgram.Program()
|
||
for element in content:
|
||
if not isinstance(element, tuple):
|
||
continue
|
||
name, attrs, content = element
|
||
self.program.fromXML(name, attrs, content, ttFont)
|
||
|
||
def getCompositeMaxpValues(self, glyfTable, maxComponentDepth=1):
|
||
assert self.isComposite()
|
||
nContours = 0
|
||
nPoints = 0
|
||
initialMaxComponentDepth = maxComponentDepth
|
||
for compo in self.components:
|
||
baseGlyph = glyfTable[compo.glyphName]
|
||
if baseGlyph.numberOfContours == 0:
|
||
continue
|
||
elif baseGlyph.numberOfContours > 0:
|
||
nP, nC = baseGlyph.getMaxpValues()
|
||
else:
|
||
nP, nC, componentDepth = baseGlyph.getCompositeMaxpValues(
|
||
glyfTable, initialMaxComponentDepth + 1
|
||
)
|
||
maxComponentDepth = max(maxComponentDepth, componentDepth)
|
||
nPoints = nPoints + nP
|
||
nContours = nContours + nC
|
||
return CompositeMaxpValues(nPoints, nContours, maxComponentDepth)
|
||
|
||
def getMaxpValues(self):
|
||
assert self.numberOfContours > 0
|
||
return len(self.coordinates), len(self.endPtsOfContours)
|
||
|
||
def decompileComponents(self, data, glyfTable):
|
||
self.components = []
|
||
more = 1
|
||
haveInstructions = 0
|
||
while more:
|
||
component = GlyphComponent()
|
||
more, haveInstr, data = component.decompile(data, glyfTable)
|
||
haveInstructions = haveInstructions | haveInstr
|
||
self.components.append(component)
|
||
if haveInstructions:
|
||
(numInstructions,) = struct.unpack(">h", data[:2])
|
||
data = data[2:]
|
||
self.program = ttProgram.Program()
|
||
self.program.fromBytecode(data[:numInstructions])
|
||
data = data[numInstructions:]
|
||
if len(data) >= 4:
|
||
log.warning(
|
||
"too much glyph data at the end of composite glyph: %d excess bytes",
|
||
len(data),
|
||
)
|
||
|
||
def decompileCoordinates(self, data):
|
||
endPtsOfContours = array.array("H")
|
||
endPtsOfContours.frombytes(data[: 2 * self.numberOfContours])
|
||
if sys.byteorder != "big":
|
||
endPtsOfContours.byteswap()
|
||
self.endPtsOfContours = endPtsOfContours.tolist()
|
||
|
||
pos = 2 * self.numberOfContours
|
||
(instructionLength,) = struct.unpack(">h", data[pos : pos + 2])
|
||
self.program = ttProgram.Program()
|
||
self.program.fromBytecode(data[pos + 2 : pos + 2 + instructionLength])
|
||
pos += 2 + instructionLength
|
||
nCoordinates = self.endPtsOfContours[-1] + 1
|
||
flags, xCoordinates, yCoordinates = self.decompileCoordinatesRaw(
|
||
nCoordinates, data, pos
|
||
)
|
||
|
||
# fill in repetitions and apply signs
|
||
self.coordinates = coordinates = GlyphCoordinates.zeros(nCoordinates)
|
||
xIndex = 0
|
||
yIndex = 0
|
||
for i in range(nCoordinates):
|
||
flag = flags[i]
|
||
# x coordinate
|
||
if flag & flagXShort:
|
||
if flag & flagXsame:
|
||
x = xCoordinates[xIndex]
|
||
else:
|
||
x = -xCoordinates[xIndex]
|
||
xIndex = xIndex + 1
|
||
elif flag & flagXsame:
|
||
x = 0
|
||
else:
|
||
x = xCoordinates[xIndex]
|
||
xIndex = xIndex + 1
|
||
# y coordinate
|
||
if flag & flagYShort:
|
||
if flag & flagYsame:
|
||
y = yCoordinates[yIndex]
|
||
else:
|
||
y = -yCoordinates[yIndex]
|
||
yIndex = yIndex + 1
|
||
elif flag & flagYsame:
|
||
y = 0
|
||
else:
|
||
y = yCoordinates[yIndex]
|
||
yIndex = yIndex + 1
|
||
coordinates[i] = (x, y)
|
||
assert xIndex == len(xCoordinates)
|
||
assert yIndex == len(yCoordinates)
|
||
coordinates.relativeToAbsolute()
|
||
# discard all flags except "keepFlags"
|
||
for i in range(len(flags)):
|
||
flags[i] &= keepFlags
|
||
self.flags = flags
|
||
|
||
def decompileCoordinatesRaw(self, nCoordinates, data, pos=0):
|
||
# unpack flags and prepare unpacking of coordinates
|
||
flags = bytearray(nCoordinates)
|
||
# Warning: deep Python trickery going on. We use the struct module to unpack
|
||
# the coordinates. We build a format string based on the flags, so we can
|
||
# unpack the coordinates in one struct.unpack() call.
|
||
xFormat = ">" # big endian
|
||
yFormat = ">" # big endian
|
||
j = 0
|
||
while True:
|
||
flag = data[pos]
|
||
pos += 1
|
||
repeat = 1
|
||
if flag & flagRepeat:
|
||
repeat = data[pos] + 1
|
||
pos += 1
|
||
for k in range(repeat):
|
||
if flag & flagXShort:
|
||
xFormat = xFormat + "B"
|
||
elif not (flag & flagXsame):
|
||
xFormat = xFormat + "h"
|
||
if flag & flagYShort:
|
||
yFormat = yFormat + "B"
|
||
elif not (flag & flagYsame):
|
||
yFormat = yFormat + "h"
|
||
flags[j] = flag
|
||
j = j + 1
|
||
if j >= nCoordinates:
|
||
break
|
||
assert j == nCoordinates, "bad glyph flags"
|
||
# unpack raw coordinates, krrrrrr-tching!
|
||
xDataLen = struct.calcsize(xFormat)
|
||
yDataLen = struct.calcsize(yFormat)
|
||
if len(data) - pos - (xDataLen + yDataLen) >= 4:
|
||
log.warning(
|
||
"too much glyph data: %d excess bytes",
|
||
len(data) - pos - (xDataLen + yDataLen),
|
||
)
|
||
xCoordinates = struct.unpack(xFormat, data[pos : pos + xDataLen])
|
||
yCoordinates = struct.unpack(
|
||
yFormat, data[pos + xDataLen : pos + xDataLen + yDataLen]
|
||
)
|
||
return flags, xCoordinates, yCoordinates
|
||
|
||
def compileComponents(self, glyfTable):
|
||
data = b""
|
||
lastcomponent = len(self.components) - 1
|
||
more = 1
|
||
haveInstructions = 0
|
||
for i in range(len(self.components)):
|
||
if i == lastcomponent:
|
||
haveInstructions = hasattr(self, "program")
|
||
more = 0
|
||
compo = self.components[i]
|
||
data = data + compo.compile(more, haveInstructions, glyfTable)
|
||
if haveInstructions:
|
||
instructions = self.program.getBytecode()
|
||
data = data + struct.pack(">h", len(instructions)) + instructions
|
||
return data
|
||
|
||
def compileCoordinates(self, *, optimizeSize=True):
|
||
assert len(self.coordinates) == len(self.flags)
|
||
data = []
|
||
endPtsOfContours = array.array("H", self.endPtsOfContours)
|
||
if sys.byteorder != "big":
|
||
endPtsOfContours.byteswap()
|
||
data.append(endPtsOfContours.tobytes())
|
||
instructions = self.program.getBytecode()
|
||
data.append(struct.pack(">h", len(instructions)))
|
||
data.append(instructions)
|
||
|
||
deltas = self.coordinates.copy()
|
||
deltas.toInt()
|
||
deltas.absoluteToRelative()
|
||
|
||
if optimizeSize:
|
||
# TODO(behdad): Add a configuration option for this?
|
||
deltas = self.compileDeltasGreedy(self.flags, deltas)
|
||
# deltas = self.compileDeltasOptimal(self.flags, deltas)
|
||
else:
|
||
deltas = self.compileDeltasForSpeed(self.flags, deltas)
|
||
|
||
data.extend(deltas)
|
||
return b"".join(data)
|
||
|
||
def compileDeltasGreedy(self, flags, deltas):
|
||
# Implements greedy algorithm for packing coordinate deltas:
|
||
# uses shortest representation one coordinate at a time.
|
||
compressedFlags = bytearray()
|
||
compressedXs = bytearray()
|
||
compressedYs = bytearray()
|
||
lastflag = None
|
||
repeat = 0
|
||
for flag, (x, y) in zip(flags, deltas):
|
||
# Oh, the horrors of TrueType
|
||
# do x
|
||
if x == 0:
|
||
flag = flag | flagXsame
|
||
elif -255 <= x <= 255:
|
||
flag = flag | flagXShort
|
||
if x > 0:
|
||
flag = flag | flagXsame
|
||
else:
|
||
x = -x
|
||
compressedXs.append(x)
|
||
else:
|
||
compressedXs.extend(struct.pack(">h", x))
|
||
# do y
|
||
if y == 0:
|
||
flag = flag | flagYsame
|
||
elif -255 <= y <= 255:
|
||
flag = flag | flagYShort
|
||
if y > 0:
|
||
flag = flag | flagYsame
|
||
else:
|
||
y = -y
|
||
compressedYs.append(y)
|
||
else:
|
||
compressedYs.extend(struct.pack(">h", y))
|
||
# handle repeating flags
|
||
if flag == lastflag and repeat != 255:
|
||
repeat = repeat + 1
|
||
if repeat == 1:
|
||
compressedFlags.append(flag)
|
||
else:
|
||
compressedFlags[-2] = flag | flagRepeat
|
||
compressedFlags[-1] = repeat
|
||
else:
|
||
repeat = 0
|
||
compressedFlags.append(flag)
|
||
lastflag = flag
|
||
return (compressedFlags, compressedXs, compressedYs)
|
||
|
||
def compileDeltasOptimal(self, flags, deltas):
|
||
# Implements optimal, dynaic-programming, algorithm for packing coordinate
|
||
# deltas. The savings are negligible :(.
|
||
candidates = []
|
||
bestTuple = None
|
||
bestCost = 0
|
||
repeat = 0
|
||
for flag, (x, y) in zip(flags, deltas):
|
||
# Oh, the horrors of TrueType
|
||
flag, coordBytes = flagBest(x, y, flag)
|
||
bestCost += 1 + coordBytes
|
||
newCandidates = [
|
||
(bestCost, bestTuple, flag, coordBytes),
|
||
(bestCost + 1, bestTuple, (flag | flagRepeat), coordBytes),
|
||
]
|
||
for lastCost, lastTuple, lastFlag, coordBytes in candidates:
|
||
if (
|
||
lastCost + coordBytes <= bestCost + 1
|
||
and (lastFlag & flagRepeat)
|
||
and (lastFlag < 0xFF00)
|
||
and flagSupports(lastFlag, flag)
|
||
):
|
||
if (lastFlag & 0xFF) == (
|
||
flag | flagRepeat
|
||
) and lastCost == bestCost + 1:
|
||
continue
|
||
newCandidates.append(
|
||
(lastCost + coordBytes, lastTuple, lastFlag + 256, coordBytes)
|
||
)
|
||
candidates = newCandidates
|
||
bestTuple = min(candidates, key=lambda t: t[0])
|
||
bestCost = bestTuple[0]
|
||
|
||
flags = []
|
||
while bestTuple:
|
||
cost, bestTuple, flag, coordBytes = bestTuple
|
||
flags.append(flag)
|
||
flags.reverse()
|
||
|
||
compressedFlags = bytearray()
|
||
compressedXs = bytearray()
|
||
compressedYs = bytearray()
|
||
coords = iter(deltas)
|
||
ff = []
|
||
for flag in flags:
|
||
repeatCount, flag = flag >> 8, flag & 0xFF
|
||
compressedFlags.append(flag)
|
||
if flag & flagRepeat:
|
||
assert repeatCount > 0
|
||
compressedFlags.append(repeatCount)
|
||
else:
|
||
assert repeatCount == 0
|
||
for i in range(1 + repeatCount):
|
||
x, y = next(coords)
|
||
flagEncodeCoords(flag, x, y, compressedXs, compressedYs)
|
||
ff.append(flag)
|
||
try:
|
||
next(coords)
|
||
raise Exception("internal error")
|
||
except StopIteration:
|
||
pass
|
||
|
||
return (compressedFlags, compressedXs, compressedYs)
|
||
|
||
def compileDeltasForSpeed(self, flags, deltas):
|
||
# uses widest representation needed, for all deltas.
|
||
compressedFlags = bytearray()
|
||
compressedXs = bytearray()
|
||
compressedYs = bytearray()
|
||
|
||
# Compute the necessary width for each axis
|
||
xs = [d[0] for d in deltas]
|
||
ys = [d[1] for d in deltas]
|
||
minX, minY, maxX, maxY = min(xs), min(ys), max(xs), max(ys)
|
||
xZero = minX == 0 and maxX == 0
|
||
yZero = minY == 0 and maxY == 0
|
||
xShort = -255 <= minX <= maxX <= 255
|
||
yShort = -255 <= minY <= maxY <= 255
|
||
|
||
lastflag = None
|
||
repeat = 0
|
||
for flag, (x, y) in zip(flags, deltas):
|
||
# Oh, the horrors of TrueType
|
||
# do x
|
||
if xZero:
|
||
flag = flag | flagXsame
|
||
elif xShort:
|
||
flag = flag | flagXShort
|
||
if x > 0:
|
||
flag = flag | flagXsame
|
||
else:
|
||
x = -x
|
||
compressedXs.append(x)
|
||
else:
|
||
compressedXs.extend(struct.pack(">h", x))
|
||
# do y
|
||
if yZero:
|
||
flag = flag | flagYsame
|
||
elif yShort:
|
||
flag = flag | flagYShort
|
||
if y > 0:
|
||
flag = flag | flagYsame
|
||
else:
|
||
y = -y
|
||
compressedYs.append(y)
|
||
else:
|
||
compressedYs.extend(struct.pack(">h", y))
|
||
# handle repeating flags
|
||
if flag == lastflag and repeat != 255:
|
||
repeat = repeat + 1
|
||
if repeat == 1:
|
||
compressedFlags.append(flag)
|
||
else:
|
||
compressedFlags[-2] = flag | flagRepeat
|
||
compressedFlags[-1] = repeat
|
||
else:
|
||
repeat = 0
|
||
compressedFlags.append(flag)
|
||
lastflag = flag
|
||
return (compressedFlags, compressedXs, compressedYs)
|
||
|
||
def recalcBounds(self, glyfTable, *, boundsDone=None):
|
||
"""Recalculates the bounds of the glyph.
|
||
|
||
Each glyph object stores its bounding box in the
|
||
``xMin``/``yMin``/``xMax``/``yMax`` attributes. These bounds must be
|
||
recomputed when the ``coordinates`` change. The ``table__g_l_y_f`` bounds
|
||
must be provided to resolve component bounds.
|
||
"""
|
||
if self.isComposite() and self.tryRecalcBoundsComposite(
|
||
glyfTable, boundsDone=boundsDone
|
||
):
|
||
return
|
||
try:
|
||
coords, endPts, flags = self.getCoordinates(glyfTable, round=otRound)
|
||
self.xMin, self.yMin, self.xMax, self.yMax = coords.calcIntBounds()
|
||
except NotImplementedError:
|
||
pass
|
||
|
||
def tryRecalcBoundsComposite(self, glyfTable, *, boundsDone=None):
|
||
"""Try recalculating the bounds of a composite glyph that has
|
||
certain constrained properties. Namely, none of the components
|
||
have a transform other than an integer translate, and none
|
||
uses the anchor points.
|
||
|
||
Each glyph object stores its bounding box in the
|
||
``xMin``/``yMin``/``xMax``/``yMax`` attributes. These bounds must be
|
||
recomputed when the ``coordinates`` change. The ``table__g_l_y_f`` bounds
|
||
must be provided to resolve component bounds.
|
||
|
||
Return True if bounds were calculated, False otherwise.
|
||
"""
|
||
for compo in self.components:
|
||
if not compo._hasOnlyIntegerTranslate():
|
||
return False
|
||
|
||
# All components are untransformed and have an integer x/y translate
|
||
bounds = None
|
||
for compo in self.components:
|
||
glyphName = compo.glyphName
|
||
g = glyfTable[glyphName]
|
||
|
||
if boundsDone is None or glyphName not in boundsDone:
|
||
g.recalcBounds(glyfTable, boundsDone=boundsDone)
|
||
if boundsDone is not None:
|
||
boundsDone.add(glyphName)
|
||
# empty components shouldn't update the bounds of the parent glyph
|
||
if g.numberOfContours == 0:
|
||
continue
|
||
|
||
x, y = compo.x, compo.y
|
||
bounds = updateBounds(bounds, (g.xMin + x, g.yMin + y))
|
||
bounds = updateBounds(bounds, (g.xMax + x, g.yMax + y))
|
||
|
||
if bounds is None:
|
||
bounds = (0, 0, 0, 0)
|
||
self.xMin, self.yMin, self.xMax, self.yMax = bounds
|
||
return True
|
||
|
||
def isComposite(self):
|
||
"""Test whether a glyph has components"""
|
||
if hasattr(self, "data"):
|
||
return struct.unpack(">h", self.data[:2])[0] == -1 if self.data else False
|
||
else:
|
||
return self.numberOfContours == -1
|
||
|
||
def getCoordinates(self, glyfTable, *, round=noRound):
|
||
"""Return the coordinates, end points and flags
|
||
|
||
This method returns three values: A :py:class:`GlyphCoordinates` object,
|
||
a list of the indexes of the final points of each contour (allowing you
|
||
to split up the coordinates list into contours) and a list of flags.
|
||
|
||
On simple glyphs, this method returns information from the glyph's own
|
||
contours; on composite glyphs, it "flattens" all components recursively
|
||
to return a list of coordinates representing all the components involved
|
||
in the glyph.
|
||
|
||
To interpret the flags for each point, see the "Simple Glyph Flags"
|
||
section of the `glyf table specification <https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#simple-glyph-description>`.
|
||
"""
|
||
|
||
if self.numberOfContours > 0:
|
||
return self.coordinates, self.endPtsOfContours, self.flags
|
||
elif self.isComposite():
|
||
# it's a composite
|
||
allCoords = GlyphCoordinates()
|
||
allFlags = bytearray()
|
||
allEndPts = []
|
||
for compo in self.components:
|
||
g = glyfTable[compo.glyphName]
|
||
try:
|
||
coordinates, endPts, flags = g.getCoordinates(
|
||
glyfTable, round=round
|
||
)
|
||
except RecursionError:
|
||
raise ttLib.TTLibError(
|
||
"glyph '%s' contains a recursive component reference"
|
||
% compo.glyphName
|
||
)
|
||
coordinates = GlyphCoordinates(coordinates)
|
||
# if asked to round e.g. while computing bboxes, it's important we
|
||
# do it immediately before a component transform is applied to a
|
||
# simple glyph's coordinates in case these might still contain floats;
|
||
# however, if the referenced component glyph is another composite, we
|
||
# must not round here but only at the end, after all the nested
|
||
# transforms have been applied, or else rounding errors will compound.
|
||
if (
|
||
round is not noRound
|
||
and g.numberOfContours > 0
|
||
and not compo._hasOnlyIntegerTranslate()
|
||
):
|
||
coordinates.toInt(round=round)
|
||
if hasattr(compo, "firstPt"):
|
||
# component uses two reference points: we apply the transform _before_
|
||
# computing the offset between the points
|
||
if hasattr(compo, "transform"):
|
||
coordinates.transform(compo.transform)
|
||
x1, y1 = allCoords[compo.firstPt]
|
||
x2, y2 = coordinates[compo.secondPt]
|
||
move = x1 - x2, y1 - y2
|
||
coordinates.translate(move)
|
||
else:
|
||
# component uses XY offsets
|
||
move = compo.x, compo.y
|
||
if not hasattr(compo, "transform"):
|
||
coordinates.translate(move)
|
||
else:
|
||
apple_way = compo.flags & SCALED_COMPONENT_OFFSET
|
||
ms_way = compo.flags & UNSCALED_COMPONENT_OFFSET
|
||
assert not (apple_way and ms_way)
|
||
if not (apple_way or ms_way):
|
||
scale_component_offset = (
|
||
SCALE_COMPONENT_OFFSET_DEFAULT # see top of this file
|
||
)
|
||
else:
|
||
scale_component_offset = apple_way
|
||
if scale_component_offset:
|
||
# the Apple way: first move, then scale (ie. scale the component offset)
|
||
coordinates.translate(move)
|
||
coordinates.transform(compo.transform)
|
||
else:
|
||
# the MS way: first scale, then move
|
||
coordinates.transform(compo.transform)
|
||
coordinates.translate(move)
|
||
offset = len(allCoords)
|
||
allEndPts.extend(e + offset for e in endPts)
|
||
allCoords.extend(coordinates)
|
||
allFlags.extend(flags)
|
||
return allCoords, allEndPts, allFlags
|
||
else:
|
||
return GlyphCoordinates(), [], bytearray()
|
||
|
||
def getComponentNames(self, glyfTable):
|
||
"""Returns a list of names of component glyphs used in this glyph
|
||
|
||
This method can be used on simple glyphs (in which case it returns an
|
||
empty list) or composite glyphs.
|
||
"""
|
||
if not hasattr(self, "data"):
|
||
if self.isComposite():
|
||
return [c.glyphName for c in self.components]
|
||
else:
|
||
return []
|
||
|
||
# Extract components without expanding glyph
|
||
|
||
if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0:
|
||
return [] # Not composite
|
||
|
||
data = self.data
|
||
i = 10
|
||
components = []
|
||
more = 1
|
||
while more:
|
||
flags, glyphID = struct.unpack(">HH", data[i : i + 4])
|
||
i += 4
|
||
flags = int(flags)
|
||
components.append(glyfTable.getGlyphName(int(glyphID)))
|
||
|
||
if flags & ARG_1_AND_2_ARE_WORDS:
|
||
i += 4
|
||
else:
|
||
i += 2
|
||
if flags & WE_HAVE_A_SCALE:
|
||
i += 2
|
||
elif flags & WE_HAVE_AN_X_AND_Y_SCALE:
|
||
i += 4
|
||
elif flags & WE_HAVE_A_TWO_BY_TWO:
|
||
i += 8
|
||
more = flags & MORE_COMPONENTS
|
||
|
||
return components
|
||
|
||
def trim(self, remove_hinting=False):
|
||
"""Remove padding and, if requested, hinting, from a glyph.
|
||
This works on both expanded and compacted glyphs, without
|
||
expanding it."""
|
||
if not hasattr(self, "data"):
|
||
if remove_hinting:
|
||
if self.isComposite():
|
||
if hasattr(self, "program"):
|
||
del self.program
|
||
else:
|
||
self.program = ttProgram.Program()
|
||
self.program.fromBytecode([])
|
||
# No padding to trim.
|
||
return
|
||
if not self.data:
|
||
return
|
||
numContours = struct.unpack(">h", self.data[:2])[0]
|
||
data = bytearray(self.data)
|
||
i = 10
|
||
if numContours >= 0:
|
||
i += 2 * numContours # endPtsOfContours
|
||
nCoordinates = ((data[i - 2] << 8) | data[i - 1]) + 1
|
||
instructionLen = (data[i] << 8) | data[i + 1]
|
||
if remove_hinting:
|
||
# Zero instruction length
|
||
data[i] = data[i + 1] = 0
|
||
i += 2
|
||
if instructionLen:
|
||
# Splice it out
|
||
data = data[:i] + data[i + instructionLen :]
|
||
instructionLen = 0
|
||
else:
|
||
i += 2 + instructionLen
|
||
|
||
coordBytes = 0
|
||
j = 0
|
||
while True:
|
||
flag = data[i]
|
||
i = i + 1
|
||
repeat = 1
|
||
if flag & flagRepeat:
|
||
repeat = data[i] + 1
|
||
i = i + 1
|
||
xBytes = yBytes = 0
|
||
if flag & flagXShort:
|
||
xBytes = 1
|
||
elif not (flag & flagXsame):
|
||
xBytes = 2
|
||
if flag & flagYShort:
|
||
yBytes = 1
|
||
elif not (flag & flagYsame):
|
||
yBytes = 2
|
||
coordBytes += (xBytes + yBytes) * repeat
|
||
j += repeat
|
||
if j >= nCoordinates:
|
||
break
|
||
assert j == nCoordinates, "bad glyph flags"
|
||
i += coordBytes
|
||
# Remove padding
|
||
data = data[:i]
|
||
elif self.isComposite():
|
||
more = 1
|
||
we_have_instructions = False
|
||
while more:
|
||
flags = (data[i] << 8) | data[i + 1]
|
||
if remove_hinting:
|
||
flags &= ~WE_HAVE_INSTRUCTIONS
|
||
if flags & WE_HAVE_INSTRUCTIONS:
|
||
we_have_instructions = True
|
||
data[i + 0] = flags >> 8
|
||
data[i + 1] = flags & 0xFF
|
||
i += 4
|
||
flags = int(flags)
|
||
|
||
if flags & ARG_1_AND_2_ARE_WORDS:
|
||
i += 4
|
||
else:
|
||
i += 2
|
||
if flags & WE_HAVE_A_SCALE:
|
||
i += 2
|
||
elif flags & WE_HAVE_AN_X_AND_Y_SCALE:
|
||
i += 4
|
||
elif flags & WE_HAVE_A_TWO_BY_TWO:
|
||
i += 8
|
||
more = flags & MORE_COMPONENTS
|
||
if we_have_instructions:
|
||
instructionLen = (data[i] << 8) | data[i + 1]
|
||
i += 2 + instructionLen
|
||
# Remove padding
|
||
data = data[:i]
|
||
|
||
self.data = data
|
||
|
||
def removeHinting(self):
|
||
"""Removes TrueType hinting instructions from the glyph."""
|
||
self.trim(remove_hinting=True)
|
||
|
||
def draw(self, pen, glyfTable, offset=0):
|
||
"""Draws the glyph using the supplied pen object.
|
||
|
||
Arguments:
|
||
pen: An object conforming to the pen protocol.
|
||
glyfTable: A :py:class:`table__g_l_y_f` object, to resolve components.
|
||
offset (int): A horizontal offset. If provided, all coordinates are
|
||
translated by this offset.
|
||
"""
|
||
|
||
if self.isComposite():
|
||
for component in self.components:
|
||
glyphName, transform = component.getComponentInfo()
|
||
pen.addComponent(glyphName, transform)
|
||
return
|
||
|
||
self.expand(glyfTable)
|
||
coordinates, endPts, flags = self.getCoordinates(glyfTable)
|
||
if offset:
|
||
coordinates = coordinates.copy()
|
||
coordinates.translate((offset, 0))
|
||
start = 0
|
||
maybeInt = lambda v: int(v) if v == int(v) else v
|
||
for end in endPts:
|
||
end = end + 1
|
||
contour = coordinates[start:end]
|
||
cFlags = [flagOnCurve & f for f in flags[start:end]]
|
||
cuFlags = [flagCubic & f for f in flags[start:end]]
|
||
start = end
|
||
if 1 not in cFlags:
|
||
assert all(cuFlags) or not any(cuFlags)
|
||
cubic = all(cuFlags)
|
||
if cubic:
|
||
count = len(contour)
|
||
assert count % 2 == 0, "Odd number of cubic off-curves undefined"
|
||
l = contour[-1]
|
||
f = contour[0]
|
||
p0 = (maybeInt((l[0] + f[0]) * 0.5), maybeInt((l[1] + f[1]) * 0.5))
|
||
pen.moveTo(p0)
|
||
for i in range(0, count, 2):
|
||
p1 = contour[i]
|
||
p2 = contour[i + 1]
|
||
p4 = contour[i + 2 if i + 2 < count else 0]
|
||
p3 = (
|
||
maybeInt((p2[0] + p4[0]) * 0.5),
|
||
maybeInt((p2[1] + p4[1]) * 0.5),
|
||
)
|
||
pen.curveTo(p1, p2, p3)
|
||
else:
|
||
# There is not a single on-curve point on the curve,
|
||
# use pen.qCurveTo's special case by specifying None
|
||
# as the on-curve point.
|
||
contour.append(None)
|
||
pen.qCurveTo(*contour)
|
||
else:
|
||
# Shuffle the points so that the contour is guaranteed
|
||
# to *end* in an on-curve point, which we'll use for
|
||
# the moveTo.
|
||
firstOnCurve = cFlags.index(1) + 1
|
||
contour = contour[firstOnCurve:] + contour[:firstOnCurve]
|
||
cFlags = cFlags[firstOnCurve:] + cFlags[:firstOnCurve]
|
||
cuFlags = cuFlags[firstOnCurve:] + cuFlags[:firstOnCurve]
|
||
pen.moveTo(contour[-1])
|
||
while contour:
|
||
nextOnCurve = cFlags.index(1) + 1
|
||
if nextOnCurve == 1:
|
||
# Skip a final lineTo(), as it is implied by
|
||
# pen.closePath()
|
||
if len(contour) > 1:
|
||
pen.lineTo(contour[0])
|
||
else:
|
||
cubicFlags = [f for f in cuFlags[: nextOnCurve - 1]]
|
||
assert all(cubicFlags) or not any(cubicFlags)
|
||
cubic = any(cubicFlags)
|
||
if cubic:
|
||
assert all(
|
||
cubicFlags
|
||
), "Mixed cubic and quadratic segment undefined"
|
||
|
||
count = nextOnCurve
|
||
assert (
|
||
count >= 3
|
||
), "At least two cubic off-curve points required"
|
||
assert (
|
||
count - 1
|
||
) % 2 == 0, "Odd number of cubic off-curves undefined"
|
||
for i in range(0, count - 3, 2):
|
||
p1 = contour[i]
|
||
p2 = contour[i + 1]
|
||
p4 = contour[i + 2]
|
||
p3 = (
|
||
maybeInt((p2[0] + p4[0]) * 0.5),
|
||
maybeInt((p2[1] + p4[1]) * 0.5),
|
||
)
|
||
lastOnCurve = p3
|
||
pen.curveTo(p1, p2, p3)
|
||
pen.curveTo(*contour[count - 3 : count])
|
||
else:
|
||
pen.qCurveTo(*contour[:nextOnCurve])
|
||
contour = contour[nextOnCurve:]
|
||
cFlags = cFlags[nextOnCurve:]
|
||
cuFlags = cuFlags[nextOnCurve:]
|
||
pen.closePath()
|
||
|
||
def drawPoints(self, pen, glyfTable, offset=0):
|
||
"""Draw the glyph using the supplied pointPen. As opposed to Glyph.draw(),
|
||
this will not change the point indices.
|
||
"""
|
||
|
||
if self.isComposite():
|
||
for component in self.components:
|
||
glyphName, transform = component.getComponentInfo()
|
||
pen.addComponent(glyphName, transform)
|
||
return
|
||
|
||
coordinates, endPts, flags = self.getCoordinates(glyfTable)
|
||
if offset:
|
||
coordinates = coordinates.copy()
|
||
coordinates.translate((offset, 0))
|
||
start = 0
|
||
for end in endPts:
|
||
end = end + 1
|
||
contour = coordinates[start:end]
|
||
cFlags = flags[start:end]
|
||
start = end
|
||
pen.beginPath()
|
||
# Start with the appropriate segment type based on the final segment
|
||
|
||
if cFlags[-1] & flagOnCurve:
|
||
segmentType = "line"
|
||
elif cFlags[-1] & flagCubic:
|
||
segmentType = "curve"
|
||
else:
|
||
segmentType = "qcurve"
|
||
for i, pt in enumerate(contour):
|
||
if cFlags[i] & flagOnCurve:
|
||
pen.addPoint(pt, segmentType=segmentType)
|
||
segmentType = "line"
|
||
else:
|
||
pen.addPoint(pt)
|
||
segmentType = "curve" if cFlags[i] & flagCubic else "qcurve"
|
||
pen.endPath()
|
||
|
||
def __eq__(self, other):
|
||
if type(self) != type(other):
|
||
return NotImplemented
|
||
return self.__dict__ == other.__dict__
|
||
|
||
def __ne__(self, other):
|
||
result = self.__eq__(other)
|
||
return result if result is NotImplemented else not result
|
||
|
||
|
||
# Vector.__round__ uses the built-in (Banker's) `round` but we want
|
||
# to use otRound below
|
||
_roundv = partial(Vector.__round__, round=otRound)
|
||
|
||
|
||
def _is_mid_point(p0: tuple, p1: tuple, p2: tuple) -> bool:
|
||
# True if p1 is in the middle of p0 and p2, either before or after rounding
|
||
p0 = Vector(p0)
|
||
p1 = Vector(p1)
|
||
p2 = Vector(p2)
|
||
return ((p0 + p2) * 0.5).isclose(p1) or _roundv(p0) + _roundv(p2) == _roundv(p1) * 2
|
||
|
||
|
||
def dropImpliedOnCurvePoints(*interpolatable_glyphs: Glyph) -> Set[int]:
|
||
"""Drop impliable on-curve points from the (simple) glyph or glyphs.
|
||
|
||
In TrueType glyf outlines, on-curve points can be implied when they are located at
|
||
the midpoint of the line connecting two consecutive off-curve points.
|
||
|
||
If more than one glyphs are passed, these are assumed to be interpolatable masters
|
||
of the same glyph impliable, and thus only the on-curve points that are impliable
|
||
for all of them will actually be implied.
|
||
Composite glyphs or empty glyphs are skipped, only simple glyphs with 1 or more
|
||
contours are considered.
|
||
The input glyph(s) is/are modified in-place.
|
||
|
||
Args:
|
||
interpolatable_glyphs: The glyph or glyphs to modify in-place.
|
||
|
||
Returns:
|
||
The set of point indices that were dropped if any.
|
||
|
||
Raises:
|
||
ValueError if simple glyphs are not in fact interpolatable because they have
|
||
different point flags or number of contours.
|
||
|
||
Reference:
|
||
https://developer.apple.com/fonts/TrueType-Reference-Manual/RM01/Chap1.html
|
||
"""
|
||
staticAttributes = SimpleNamespace(
|
||
numberOfContours=None, flags=None, endPtsOfContours=None
|
||
)
|
||
drop = None
|
||
simple_glyphs = []
|
||
for i, glyph in enumerate(interpolatable_glyphs):
|
||
if glyph.numberOfContours < 1:
|
||
# ignore composite or empty glyphs
|
||
continue
|
||
|
||
for attr in staticAttributes.__dict__:
|
||
expected = getattr(staticAttributes, attr)
|
||
found = getattr(glyph, attr)
|
||
if expected is None:
|
||
setattr(staticAttributes, attr, found)
|
||
elif expected != found:
|
||
raise ValueError(
|
||
f"Incompatible {attr} for glyph at master index {i}: "
|
||
f"expected {expected}, found {found}"
|
||
)
|
||
|
||
may_drop = set()
|
||
start = 0
|
||
coords = glyph.coordinates
|
||
flags = staticAttributes.flags
|
||
endPtsOfContours = staticAttributes.endPtsOfContours
|
||
for last in endPtsOfContours:
|
||
for i in range(start, last + 1):
|
||
if not (flags[i] & flagOnCurve):
|
||
continue
|
||
prv = i - 1 if i > start else last
|
||
nxt = i + 1 if i < last else start
|
||
if (flags[prv] & flagOnCurve) or flags[prv] != flags[nxt]:
|
||
continue
|
||
# we may drop the ith on-curve if halfway between previous/next off-curves
|
||
if not _is_mid_point(coords[prv], coords[i], coords[nxt]):
|
||
continue
|
||
|
||
may_drop.add(i)
|
||
start = last + 1
|
||
# we only want to drop if ALL interpolatable glyphs have the same implied oncurves
|
||
if drop is None:
|
||
drop = may_drop
|
||
else:
|
||
drop.intersection_update(may_drop)
|
||
|
||
simple_glyphs.append(glyph)
|
||
|
||
if drop:
|
||
# Do the actual dropping
|
||
flags = staticAttributes.flags
|
||
assert flags is not None
|
||
newFlags = array.array(
|
||
"B", (flags[i] for i in range(len(flags)) if i not in drop)
|
||
)
|
||
|
||
endPts = staticAttributes.endPtsOfContours
|
||
assert endPts is not None
|
||
newEndPts = []
|
||
i = 0
|
||
delta = 0
|
||
for d in sorted(drop):
|
||
while d > endPts[i]:
|
||
newEndPts.append(endPts[i] - delta)
|
||
i += 1
|
||
delta += 1
|
||
while i < len(endPts):
|
||
newEndPts.append(endPts[i] - delta)
|
||
i += 1
|
||
|
||
for glyph in simple_glyphs:
|
||
coords = glyph.coordinates
|
||
glyph.coordinates = GlyphCoordinates(
|
||
coords[i] for i in range(len(coords)) if i not in drop
|
||
)
|
||
glyph.flags = newFlags
|
||
glyph.endPtsOfContours = newEndPts
|
||
|
||
return drop if drop is not None else set()
|
||
|
||
|
||
class GlyphComponent(object):
|
||
"""Represents a component within a composite glyph.
|
||
|
||
The component is represented internally with four attributes: ``glyphName``,
|
||
``x``, ``y`` and ``transform``. If there is no "two-by-two" matrix (i.e
|
||
no scaling, reflection, or rotation; only translation), the ``transform``
|
||
attribute is not present.
|
||
"""
|
||
|
||
# The above documentation is not *completely* true, but is *true enough* because
|
||
# the rare firstPt/lastPt attributes are not totally supported and nobody seems to
|
||
# mind - see below.
|
||
|
||
def __init__(self):
|
||
pass
|
||
|
||
def getComponentInfo(self):
|
||
"""Return information about the component
|
||
|
||
This method returns a tuple of two values: the glyph name of the component's
|
||
base glyph, and a transformation matrix. As opposed to accessing the attributes
|
||
directly, ``getComponentInfo`` always returns a six-element tuple of the
|
||
component's transformation matrix, even when the two-by-two ``.transform``
|
||
matrix is not present.
|
||
"""
|
||
# XXX Ignoring self.firstPt & self.lastpt for now: I need to implement
|
||
# something equivalent in fontTools.objects.glyph (I'd rather not
|
||
# convert it to an absolute offset, since it is valuable information).
|
||
# This method will now raise "AttributeError: x" on glyphs that use
|
||
# this TT feature.
|
||
if hasattr(self, "transform"):
|
||
[[xx, xy], [yx, yy]] = self.transform
|
||
trans = (xx, xy, yx, yy, self.x, self.y)
|
||
else:
|
||
trans = (1, 0, 0, 1, self.x, self.y)
|
||
return self.glyphName, trans
|
||
|
||
def decompile(self, data, glyfTable):
|
||
flags, glyphID = struct.unpack(">HH", data[:4])
|
||
self.flags = int(flags)
|
||
glyphID = int(glyphID)
|
||
self.glyphName = glyfTable.getGlyphName(int(glyphID))
|
||
data = data[4:]
|
||
|
||
if self.flags & ARG_1_AND_2_ARE_WORDS:
|
||
if self.flags & ARGS_ARE_XY_VALUES:
|
||
self.x, self.y = struct.unpack(">hh", data[:4])
|
||
else:
|
||
x, y = struct.unpack(">HH", data[:4])
|
||
self.firstPt, self.secondPt = int(x), int(y)
|
||
data = data[4:]
|
||
else:
|
||
if self.flags & ARGS_ARE_XY_VALUES:
|
||
self.x, self.y = struct.unpack(">bb", data[:2])
|
||
else:
|
||
x, y = struct.unpack(">BB", data[:2])
|
||
self.firstPt, self.secondPt = int(x), int(y)
|
||
data = data[2:]
|
||
|
||
if self.flags & WE_HAVE_A_SCALE:
|
||
(scale,) = struct.unpack(">h", data[:2])
|
||
self.transform = [
|
||
[fi2fl(scale, 14), 0],
|
||
[0, fi2fl(scale, 14)],
|
||
] # fixed 2.14
|
||
data = data[2:]
|
||
elif self.flags & WE_HAVE_AN_X_AND_Y_SCALE:
|
||
xscale, yscale = struct.unpack(">hh", data[:4])
|
||
self.transform = [
|
||
[fi2fl(xscale, 14), 0],
|
||
[0, fi2fl(yscale, 14)],
|
||
] # fixed 2.14
|
||
data = data[4:]
|
||
elif self.flags & WE_HAVE_A_TWO_BY_TWO:
|
||
(xscale, scale01, scale10, yscale) = struct.unpack(">hhhh", data[:8])
|
||
self.transform = [
|
||
[fi2fl(xscale, 14), fi2fl(scale01, 14)],
|
||
[fi2fl(scale10, 14), fi2fl(yscale, 14)],
|
||
] # fixed 2.14
|
||
data = data[8:]
|
||
more = self.flags & MORE_COMPONENTS
|
||
haveInstructions = self.flags & WE_HAVE_INSTRUCTIONS
|
||
self.flags = self.flags & (
|
||
ROUND_XY_TO_GRID
|
||
| USE_MY_METRICS
|
||
| SCALED_COMPONENT_OFFSET
|
||
| UNSCALED_COMPONENT_OFFSET
|
||
| NON_OVERLAPPING
|
||
| OVERLAP_COMPOUND
|
||
)
|
||
return more, haveInstructions, data
|
||
|
||
def compile(self, more, haveInstructions, glyfTable):
|
||
data = b""
|
||
|
||
# reset all flags we will calculate ourselves
|
||
flags = self.flags & (
|
||
ROUND_XY_TO_GRID
|
||
| USE_MY_METRICS
|
||
| SCALED_COMPONENT_OFFSET
|
||
| UNSCALED_COMPONENT_OFFSET
|
||
| NON_OVERLAPPING
|
||
| OVERLAP_COMPOUND
|
||
)
|
||
if more:
|
||
flags = flags | MORE_COMPONENTS
|
||
if haveInstructions:
|
||
flags = flags | WE_HAVE_INSTRUCTIONS
|
||
|
||
if hasattr(self, "firstPt"):
|
||
if (0 <= self.firstPt <= 255) and (0 <= self.secondPt <= 255):
|
||
data = data + struct.pack(">BB", self.firstPt, self.secondPt)
|
||
else:
|
||
data = data + struct.pack(">HH", self.firstPt, self.secondPt)
|
||
flags = flags | ARG_1_AND_2_ARE_WORDS
|
||
else:
|
||
x = otRound(self.x)
|
||
y = otRound(self.y)
|
||
flags = flags | ARGS_ARE_XY_VALUES
|
||
if (-128 <= x <= 127) and (-128 <= y <= 127):
|
||
data = data + struct.pack(">bb", x, y)
|
||
else:
|
||
data = data + struct.pack(">hh", x, y)
|
||
flags = flags | ARG_1_AND_2_ARE_WORDS
|
||
|
||
if hasattr(self, "transform"):
|
||
transform = [[fl2fi(x, 14) for x in row] for row in self.transform]
|
||
if transform[0][1] or transform[1][0]:
|
||
flags = flags | WE_HAVE_A_TWO_BY_TWO
|
||
data = data + struct.pack(
|
||
">hhhh",
|
||
transform[0][0],
|
||
transform[0][1],
|
||
transform[1][0],
|
||
transform[1][1],
|
||
)
|
||
elif transform[0][0] != transform[1][1]:
|
||
flags = flags | WE_HAVE_AN_X_AND_Y_SCALE
|
||
data = data + struct.pack(">hh", transform[0][0], transform[1][1])
|
||
else:
|
||
flags = flags | WE_HAVE_A_SCALE
|
||
data = data + struct.pack(">h", transform[0][0])
|
||
|
||
glyphID = glyfTable.getGlyphID(self.glyphName)
|
||
return struct.pack(">HH", flags, glyphID) + data
|
||
|
||
def toXML(self, writer, ttFont):
|
||
attrs = [("glyphName", self.glyphName)]
|
||
if not hasattr(self, "firstPt"):
|
||
attrs = attrs + [("x", self.x), ("y", self.y)]
|
||
else:
|
||
attrs = attrs + [("firstPt", self.firstPt), ("secondPt", self.secondPt)]
|
||
|
||
if hasattr(self, "transform"):
|
||
transform = self.transform
|
||
if transform[0][1] or transform[1][0]:
|
||
attrs = attrs + [
|
||
("scalex", fl2str(transform[0][0], 14)),
|
||
("scale01", fl2str(transform[0][1], 14)),
|
||
("scale10", fl2str(transform[1][0], 14)),
|
||
("scaley", fl2str(transform[1][1], 14)),
|
||
]
|
||
elif transform[0][0] != transform[1][1]:
|
||
attrs = attrs + [
|
||
("scalex", fl2str(transform[0][0], 14)),
|
||
("scaley", fl2str(transform[1][1], 14)),
|
||
]
|
||
else:
|
||
attrs = attrs + [("scale", fl2str(transform[0][0], 14))]
|
||
attrs = attrs + [("flags", hex(self.flags))]
|
||
writer.simpletag("component", attrs)
|
||
writer.newline()
|
||
|
||
def fromXML(self, name, attrs, content, ttFont):
|
||
self.glyphName = attrs["glyphName"]
|
||
if "firstPt" in attrs:
|
||
self.firstPt = safeEval(attrs["firstPt"])
|
||
self.secondPt = safeEval(attrs["secondPt"])
|
||
else:
|
||
self.x = safeEval(attrs["x"])
|
||
self.y = safeEval(attrs["y"])
|
||
if "scale01" in attrs:
|
||
scalex = str2fl(attrs["scalex"], 14)
|
||
scale01 = str2fl(attrs["scale01"], 14)
|
||
scale10 = str2fl(attrs["scale10"], 14)
|
||
scaley = str2fl(attrs["scaley"], 14)
|
||
self.transform = [[scalex, scale01], [scale10, scaley]]
|
||
elif "scalex" in attrs:
|
||
scalex = str2fl(attrs["scalex"], 14)
|
||
scaley = str2fl(attrs["scaley"], 14)
|
||
self.transform = [[scalex, 0], [0, scaley]]
|
||
elif "scale" in attrs:
|
||
scale = str2fl(attrs["scale"], 14)
|
||
self.transform = [[scale, 0], [0, scale]]
|
||
self.flags = safeEval(attrs["flags"])
|
||
|
||
def __eq__(self, other):
|
||
if type(self) != type(other):
|
||
return NotImplemented
|
||
return self.__dict__ == other.__dict__
|
||
|
||
def __ne__(self, other):
|
||
result = self.__eq__(other)
|
||
return result if result is NotImplemented else not result
|
||
|
||
def _hasOnlyIntegerTranslate(self):
|
||
"""Return True if it's a 'simple' component.
|
||
|
||
That is, it has no anchor points and no transform other than integer translate.
|
||
"""
|
||
return (
|
||
not hasattr(self, "firstPt")
|
||
and not hasattr(self, "transform")
|
||
and float(self.x).is_integer()
|
||
and float(self.y).is_integer()
|
||
)
|
||
|
||
|
||
class GlyphCoordinates(object):
|
||
"""A list of glyph coordinates.
|
||
|
||
Unlike an ordinary list, this is a numpy-like matrix object which supports
|
||
matrix addition, scalar multiplication and other operations described below.
|
||
"""
|
||
|
||
def __init__(self, iterable=[]):
|
||
self._a = array.array("d")
|
||
self.extend(iterable)
|
||
|
||
@property
|
||
def array(self):
|
||
"""Returns the underlying array of coordinates"""
|
||
return self._a
|
||
|
||
@staticmethod
|
||
def zeros(count):
|
||
"""Creates a new ``GlyphCoordinates`` object with all coordinates set to (0,0)"""
|
||
g = GlyphCoordinates()
|
||
g._a.frombytes(bytes(count * 2 * g._a.itemsize))
|
||
return g
|
||
|
||
def copy(self):
|
||
"""Creates a new ``GlyphCoordinates`` object which is a copy of the current one."""
|
||
c = GlyphCoordinates()
|
||
c._a.extend(self._a)
|
||
return c
|
||
|
||
def __len__(self):
|
||
"""Returns the number of coordinates in the array."""
|
||
return len(self._a) // 2
|
||
|
||
def __getitem__(self, k):
|
||
"""Returns a two element tuple (x,y)"""
|
||
a = self._a
|
||
if isinstance(k, slice):
|
||
indices = range(*k.indices(len(self)))
|
||
# Instead of calling ourselves recursively, duplicate code; faster
|
||
ret = []
|
||
for k in indices:
|
||
x = a[2 * k]
|
||
y = a[2 * k + 1]
|
||
ret.append(
|
||
(int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)
|
||
)
|
||
return ret
|
||
x = a[2 * k]
|
||
y = a[2 * k + 1]
|
||
return (int(x) if x.is_integer() else x, int(y) if y.is_integer() else y)
|
||
|
||
def __setitem__(self, k, v):
|
||
"""Sets a point's coordinates to a two element tuple (x,y)"""
|
||
if isinstance(k, slice):
|
||
indices = range(*k.indices(len(self)))
|
||
# XXX This only works if len(v) == len(indices)
|
||
for j, i in enumerate(indices):
|
||
self[i] = v[j]
|
||
return
|
||
self._a[2 * k], self._a[2 * k + 1] = v
|
||
|
||
def __delitem__(self, i):
|
||
"""Removes a point from the list"""
|
||
i = (2 * i) % len(self._a)
|
||
del self._a[i]
|
||
del self._a[i]
|
||
|
||
def __repr__(self):
|
||
return "GlyphCoordinates([" + ",".join(str(c) for c in self) + "])"
|
||
|
||
def append(self, p):
|
||
self._a.extend(tuple(p))
|
||
|
||
def extend(self, iterable):
|
||
for p in iterable:
|
||
self._a.extend(p)
|
||
|
||
def toInt(self, *, round=otRound):
|
||
if round is noRound:
|
||
return
|
||
a = self._a
|
||
for i in range(len(a)):
|
||
a[i] = round(a[i])
|
||
|
||
def calcBounds(self):
|
||
a = self._a
|
||
if not a:
|
||
return 0, 0, 0, 0
|
||
xs = a[0::2]
|
||
ys = a[1::2]
|
||
return min(xs), min(ys), max(xs), max(ys)
|
||
|
||
def calcIntBounds(self, round=otRound):
|
||
return tuple(round(v) for v in self.calcBounds())
|
||
|
||
def relativeToAbsolute(self):
|
||
a = self._a
|
||
x, y = 0, 0
|
||
for i in range(0, len(a), 2):
|
||
a[i] = x = a[i] + x
|
||
a[i + 1] = y = a[i + 1] + y
|
||
|
||
def absoluteToRelative(self):
|
||
a = self._a
|
||
x, y = 0, 0
|
||
for i in range(0, len(a), 2):
|
||
nx = a[i]
|
||
ny = a[i + 1]
|
||
a[i] = nx - x
|
||
a[i + 1] = ny - y
|
||
x = nx
|
||
y = ny
|
||
|
||
def translate(self, p):
|
||
"""
|
||
>>> GlyphCoordinates([(1,2)]).translate((.5,0))
|
||
"""
|
||
x, y = p
|
||
if x == 0 and y == 0:
|
||
return
|
||
a = self._a
|
||
for i in range(0, len(a), 2):
|
||
a[i] += x
|
||
a[i + 1] += y
|
||
|
||
def scale(self, p):
|
||
"""
|
||
>>> GlyphCoordinates([(1,2)]).scale((.5,0))
|
||
"""
|
||
x, y = p
|
||
if x == 1 and y == 1:
|
||
return
|
||
a = self._a
|
||
for i in range(0, len(a), 2):
|
||
a[i] *= x
|
||
a[i + 1] *= y
|
||
|
||
def transform(self, t):
|
||
"""
|
||
>>> GlyphCoordinates([(1,2)]).transform(((.5,0),(.2,.5)))
|
||
"""
|
||
a = self._a
|
||
for i in range(0, len(a), 2):
|
||
x = a[i]
|
||
y = a[i + 1]
|
||
px = x * t[0][0] + y * t[1][0]
|
||
py = x * t[0][1] + y * t[1][1]
|
||
a[i] = px
|
||
a[i + 1] = py
|
||
|
||
def __eq__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g2 = GlyphCoordinates([(1.0,2)])
|
||
>>> g3 = GlyphCoordinates([(1.5,2)])
|
||
>>> g == g2
|
||
True
|
||
>>> g == g3
|
||
False
|
||
>>> g2 == g3
|
||
False
|
||
"""
|
||
if type(self) != type(other):
|
||
return NotImplemented
|
||
return self._a == other._a
|
||
|
||
def __ne__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g2 = GlyphCoordinates([(1.0,2)])
|
||
>>> g3 = GlyphCoordinates([(1.5,2)])
|
||
>>> g != g2
|
||
False
|
||
>>> g != g3
|
||
True
|
||
>>> g2 != g3
|
||
True
|
||
"""
|
||
result = self.__eq__(other)
|
||
return result if result is NotImplemented else not result
|
||
|
||
# Math operations
|
||
|
||
def __pos__(self):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g
|
||
GlyphCoordinates([(1, 2)])
|
||
>>> g2 = +g
|
||
>>> g2
|
||
GlyphCoordinates([(1, 2)])
|
||
>>> g2.translate((1,0))
|
||
>>> g2
|
||
GlyphCoordinates([(2, 2)])
|
||
>>> g
|
||
GlyphCoordinates([(1, 2)])
|
||
"""
|
||
return self.copy()
|
||
|
||
def __neg__(self):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g
|
||
GlyphCoordinates([(1, 2)])
|
||
>>> g2 = -g
|
||
>>> g2
|
||
GlyphCoordinates([(-1, -2)])
|
||
>>> g
|
||
GlyphCoordinates([(1, 2)])
|
||
"""
|
||
r = self.copy()
|
||
a = r._a
|
||
for i in range(len(a)):
|
||
a[i] = -a[i]
|
||
return r
|
||
|
||
def __round__(self, *, round=otRound):
|
||
r = self.copy()
|
||
r.toInt(round=round)
|
||
return r
|
||
|
||
def __add__(self, other):
|
||
return self.copy().__iadd__(other)
|
||
|
||
def __sub__(self, other):
|
||
return self.copy().__isub__(other)
|
||
|
||
def __mul__(self, other):
|
||
return self.copy().__imul__(other)
|
||
|
||
def __truediv__(self, other):
|
||
return self.copy().__itruediv__(other)
|
||
|
||
__radd__ = __add__
|
||
__rmul__ = __mul__
|
||
|
||
def __rsub__(self, other):
|
||
return other + (-self)
|
||
|
||
def __iadd__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g += (.5,0)
|
||
>>> g
|
||
GlyphCoordinates([(1.5, 2)])
|
||
>>> g2 = GlyphCoordinates([(3,4)])
|
||
>>> g += g2
|
||
>>> g
|
||
GlyphCoordinates([(4.5, 6)])
|
||
"""
|
||
if isinstance(other, tuple):
|
||
assert len(other) == 2
|
||
self.translate(other)
|
||
return self
|
||
if isinstance(other, GlyphCoordinates):
|
||
other = other._a
|
||
a = self._a
|
||
assert len(a) == len(other)
|
||
for i in range(len(a)):
|
||
a[i] += other[i]
|
||
return self
|
||
return NotImplemented
|
||
|
||
def __isub__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g -= (.5,0)
|
||
>>> g
|
||
GlyphCoordinates([(0.5, 2)])
|
||
>>> g2 = GlyphCoordinates([(3,4)])
|
||
>>> g -= g2
|
||
>>> g
|
||
GlyphCoordinates([(-2.5, -2)])
|
||
"""
|
||
if isinstance(other, tuple):
|
||
assert len(other) == 2
|
||
self.translate((-other[0], -other[1]))
|
||
return self
|
||
if isinstance(other, GlyphCoordinates):
|
||
other = other._a
|
||
a = self._a
|
||
assert len(a) == len(other)
|
||
for i in range(len(a)):
|
||
a[i] -= other[i]
|
||
return self
|
||
return NotImplemented
|
||
|
||
def __imul__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g *= (2,.5)
|
||
>>> g *= 2
|
||
>>> g
|
||
GlyphCoordinates([(4, 2)])
|
||
>>> g = GlyphCoordinates([(1,2)])
|
||
>>> g *= 2
|
||
>>> g
|
||
GlyphCoordinates([(2, 4)])
|
||
"""
|
||
if isinstance(other, tuple):
|
||
assert len(other) == 2
|
||
self.scale(other)
|
||
return self
|
||
if isinstance(other, Number):
|
||
if other == 1:
|
||
return self
|
||
a = self._a
|
||
for i in range(len(a)):
|
||
a[i] *= other
|
||
return self
|
||
return NotImplemented
|
||
|
||
def __itruediv__(self, other):
|
||
"""
|
||
>>> g = GlyphCoordinates([(1,3)])
|
||
>>> g /= (.5,1.5)
|
||
>>> g /= 2
|
||
>>> g
|
||
GlyphCoordinates([(1, 1)])
|
||
"""
|
||
if isinstance(other, Number):
|
||
other = (other, other)
|
||
if isinstance(other, tuple):
|
||
if other == (1, 1):
|
||
return self
|
||
assert len(other) == 2
|
||
self.scale((1.0 / other[0], 1.0 / other[1]))
|
||
return self
|
||
return NotImplemented
|
||
|
||
def __bool__(self):
|
||
"""
|
||
>>> g = GlyphCoordinates([])
|
||
>>> bool(g)
|
||
False
|
||
>>> g = GlyphCoordinates([(0,0), (0.,0)])
|
||
>>> bool(g)
|
||
True
|
||
>>> g = GlyphCoordinates([(0,0), (1,0)])
|
||
>>> bool(g)
|
||
True
|
||
>>> g = GlyphCoordinates([(0,.5), (0,0)])
|
||
>>> bool(g)
|
||
True
|
||
"""
|
||
return bool(self._a)
|
||
|
||
__nonzero__ = __bool__
|
||
|
||
|
||
if __name__ == "__main__":
|
||
import doctest, sys
|
||
|
||
sys.exit(doctest.testmod().failed)
|