"""GlyphSets returned by a TTFont.""" from fontTools.misc.fixedTools import otRound from copy import copy class _TTGlyphSet(object): """Generic dict-like GlyphSet class that pulls metrics from hmtx and glyph shape from TrueType or CFF. """ def __init__(self, ttFont, glyphs, glyphType): """Construct a new glyphset. Args: font (TTFont): The font object (used to get metrics). glyphs (dict): A dictionary mapping glyph names to ``_TTGlyph`` objects. glyphType (class): Either ``_TTGlyphCFF`` or ``_TTGlyphGlyf``. """ self._glyphs = glyphs self._hmtx = ttFont['hmtx'] self._vmtx = ttFont['vmtx'] if 'vmtx' in ttFont else None self._glyphType = glyphType def keys(self): return list(self._glyphs.keys()) def has_key(self, glyphName): return glyphName in self._glyphs __contains__ = has_key def __getitem__(self, glyphName): horizontalMetrics = self._hmtx[glyphName] verticalMetrics = self._vmtx[glyphName] if self._vmtx else None return self._glyphType( self, self._glyphs[glyphName], horizontalMetrics, verticalMetrics) def __len__(self): return len(self._glyphs) def get(self, glyphName, default=None): try: return self[glyphName] except KeyError: return default class _TTGlyph(object): """Wrapper for a TrueType glyph that supports the Pen protocol, meaning that it has .draw() and .drawPoints() methods that take a pen object as their only argument. Additionally there are 'width' and 'lsb' attributes, read from the 'hmtx' table. If the font contains a 'vmtx' table, there will also be 'height' and 'tsb' attributes. """ def __init__(self, glyphset, glyph, horizontalMetrics, verticalMetrics=None): """Construct a new _TTGlyph. Args: glyphset (_TTGlyphSet): A glyphset object used to resolve components. glyph (ttLib.tables._g_l_y_f.Glyph): The glyph object. horizontalMetrics (int, int): The glyph's width and left sidebearing. """ self._glyphset = glyphset self._glyph = glyph self.width, self.lsb = horizontalMetrics if verticalMetrics: self.height, self.tsb = verticalMetrics else: self.height, self.tsb = None, None def draw(self, pen): """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details how that works. """ self._glyph.draw(pen) def drawPoints(self, pen): from fontTools.pens.pointPen import SegmentToPointPen self.draw(SegmentToPointPen(pen)) class _TTGlyphCFF(_TTGlyph): pass class _TTGlyphGlyf(_TTGlyph): def draw(self, pen): """Draw the glyph onto Pen. See fontTools.pens.basePen for details how that works. """ glyfTable = self._glyphset._glyphs glyph = self._glyph offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 glyph.draw(pen, glyfTable, offset) def drawPoints(self, pen): """Draw the glyph onto PointPen. See fontTools.pens.pointPen for details how that works. """ glyfTable = self._glyphset._glyphs glyph = self._glyph offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 glyph.drawPoints(pen, glyfTable, offset) class _TTVarGlyphSet(_TTGlyphSet): def __init__(self, font, location, normalized=False): self._ttFont = font self._glyphs = font['glyf'] if not normalized: from fontTools.varLib.models import normalizeLocation, piecewiseLinearMap axes = {a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in font['fvar'].axes} location = normalizeLocation(location, axes) if 'avar' in font: avar = font['avar'] avarSegments = avar.segments new_location = {} for axis_tag, value in location.items(): avarMapping = avarSegments.get(axis_tag, None) if avarMapping is not None: value = piecewiseLinearMap(value, avarMapping) new_location[axis_tag] = value location = new_location del new_location self.location = location def __getitem__(self, glyphName): if glyphName not in self._glyphs: raise KeyError(glyphName) return _TTVarGlyphGlyf(self._ttFont, glyphName, self.location) def _setCoordinates(glyph, coord, glyfTable): # Handle phantom points for (left, right, top, bottom) positions. assert len(coord) >= 4 if not hasattr(glyph, 'xMin'): glyph.recalcBounds(glyfTable) leftSideX = coord[-4][0] rightSideX = coord[-3][0] topSideY = coord[-2][1] bottomSideY = coord[-1][1] for _ in range(4): del coord[-1] 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 = coord glyph.recalcBounds(glyfTable) horizontalAdvanceWidth = otRound(rightSideX - leftSideX) verticalAdvanceWidth = otRound(topSideY - bottomSideY) leftSideBearing = otRound(glyph.xMin - leftSideX) topSideBearing = otRound(topSideY - glyph.yMax) return ( horizontalAdvanceWidth, leftSideBearing, verticalAdvanceWidth, topSideBearing, ) class _TTVarGlyph(_TTGlyph): def __init__(self, ttFont, glyphName, location): self._ttFont = ttFont self._glyphName = glyphName self._location = location # draw() fills these in self.width = self.height = self.lsb = self.tsb = None class _TTVarGlyphGlyf(_TTVarGlyph): def draw(self, pen): from fontTools.varLib.iup import iup_delta from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates from fontTools.varLib.models import supportScalar glyf = self._ttFont['glyf'] hMetrics = self._ttFont['hmtx'].metrics vMetrics = getattr(self._ttFont.get('vmtx'), 'metrics', None) variations = self._ttFont['gvar'].variations[self._glyphName] coordinates, _ = glyf._getCoordinatesAndControls(self._glyphName, hMetrics, vMetrics) origCoords, endPts = None, None for var in variations: scalar = supportScalar(self._location, var.axes) if not scalar: continue delta = var.coordinates if None in delta: if origCoords is None: origCoords,control = glyf._getCoordinatesAndControls(self._glyphName, hMetrics, vMetrics) endPts = control[1] if control[0] >= 1 else list(range(len(control[1]))) delta = iup_delta(delta, origCoords, endPts) coordinates += GlyphCoordinates(delta) * scalar glyph = copy(glyf[self._glyphName]) # Shallow copy width, lsb, height, tsb = _setCoordinates(glyph, coordinates, glyf) self.width = width self.lsb = lsb self.height = height self.tsb = tsb offset = lsb - glyph.xMin if hasattr(glyph, "xMin") else 0 glyph.draw(pen, glyf, offset)