fonttools/Lib/fontTools/ttLib/ttGlyphSet.py

"""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=None, 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
		if horizontalMetrics:
			self.width, self.lsb = horizontalMetrics
		else:
			self.width, self.lsb = None, None
		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, glyphs, glyphType, location, normalized):
		self._ttFont = font
		self._glyphs = glyphs
		self._glyphType = glyphType

		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 self._glyphType(self, 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)
		glyph.components = [copy(comp) for comp in 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, glyphSet, glyphName, location):

		super().__init__(glyphSet._glyphs, glyphSet._glyphs[glyphName])

		self._glyphSet = glyphSet
		self._ttFont = glyphSet._ttFont
		self._glyphs = glyphSet._glyphs
		self._glyphName = glyphName
		self._location = location


class _TTVarGlyphCFF(_TTVarGlyph):
	def draw(self, pen):
		varStore = self._glyphs.varStore
		if varStore is None:
			blender = None
		else:
			from fontTools.varLib.varStore import VarStoreInstancer

			vsInstancer = getattr(self._glyphSet, "vsInstancer", None)
			if vsInstancer is None:
				self._glyphSet.vsInstancer = vsInstancer = VarStoreInstancer(
					varStore.otVarStore, self._ttFont["fvar"].axes, self._location
				)
			blender = vsInstancer.interpolateFromDeltas
		self._glyph.draw(pen, blender)

		self.width = self._ttFont["hmtx"][self._glyphName][0]
		if "HVAR" in self._ttFont:
			hvar = self._ttFont["HVAR"].table
			varidx = self._ttFont.getGlyphID(self._glyphName)
			if hvar.AdvWidthMap is not None:
				varidx = hvar.AdvWidthMap.mapping[self._glyphName]
			vsInstancer = VarStoreInstancer(
				hvar.VarStore, self._ttFont["fvar"].axes, self._location
			)
			delta = vsInstancer[varidx]
			self.width += delta


class _TTVarGlyphGlyf(_TTVarGlyph):
	def draw(self, pen):
		self._drawWithPen(pen, isPointPen=False)

	def drawPoints(self, pen):
		self._drawWithPen(pen, isPointPen=True)

	def _drawWithPen(self, pen, isPointPen):
		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
		if isPointPen:
			glyph.drawPoints(pen, glyf, offset)
		else:
			glyph.draw(pen, glyf, offset)