fonttools 4.55.6__cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

fontTools/ttLib/ttGlyphSet.py

@@ -0,0 +1,500 @@
+"""GlyphSets returned by a TTFont."""
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from contextlib import contextmanager
+from copy import copy, deepcopy
+from types import SimpleNamespace
+from fontTools.misc.vector import Vector
+from fontTools.misc.fixedTools import otRound, fixedToFloat as fi2fl
+from fontTools.misc.loggingTools import deprecateFunction
+from fontTools.misc.transform import Transform, DecomposedTransform
+from fontTools.pens.transformPen import TransformPen, TransformPointPen
+from fontTools.pens.recordingPen import (
+    DecomposingRecordingPen,
+    lerpRecordings,
+    replayRecording,
+)
+
+
+class _TTGlyphSet(Mapping):
+    """Generic dict-like GlyphSet class that pulls metrics from hmtx and
+    glyph shape from TrueType or CFF.
+    """
+
+    def __init__(self, font, location, glyphsMapping, *, recalcBounds=True):
+        self.recalcBounds = recalcBounds
+        self.font = font
+        self.defaultLocationNormalized = (
+            {axis.axisTag: 0 for axis in self.font["fvar"].axes}
+            if "fvar" in self.font
+            else {}
+        )
+        self.location = location if location is not None else {}
+        self.rawLocation = {}  # VarComponent-only location
+        self.originalLocation = location if location is not None else {}
+        self.depth = 0
+        self.locationStack = []
+        self.rawLocationStack = []
+        self.glyphsMapping = glyphsMapping
+        self.hMetrics = font["hmtx"].metrics
+        self.vMetrics = getattr(font.get("vmtx"), "metrics", None)
+        self.hvarTable = None
+        if location:
+            from fontTools.varLib.varStore import VarStoreInstancer
+
+            self.hvarTable = getattr(font.get("HVAR"), "table", None)
+            if self.hvarTable is not None:
+                self.hvarInstancer = VarStoreInstancer(
+                    self.hvarTable.VarStore, font["fvar"].axes, location
+                )
+            # TODO VVAR, VORG
+
+    @contextmanager
+    def pushLocation(self, location, reset: bool):
+        self.locationStack.append(self.location)
+        self.rawLocationStack.append(self.rawLocation)
+        if reset:
+            self.location = self.originalLocation.copy()
+            self.rawLocation = self.defaultLocationNormalized.copy()
+        else:
+            self.location = self.location.copy()
+            self.rawLocation = {}
+        self.location.update(location)
+        self.rawLocation.update(location)
+
+        try:
+            yield None
+        finally:
+            self.location = self.locationStack.pop()
+            self.rawLocation = self.rawLocationStack.pop()
+
+    @contextmanager
+    def pushDepth(self):
+        try:
+            depth = self.depth
+            self.depth += 1
+            yield depth
+        finally:
+            self.depth -= 1
+
+    def __contains__(self, glyphName):
+        return glyphName in self.glyphsMapping
+
+    def __iter__(self):
+        return iter(self.glyphsMapping.keys())
+
+    def __len__(self):
+        return len(self.glyphsMapping)
+
+    @deprecateFunction(
+        "use 'glyphName in glyphSet' instead", category=DeprecationWarning
+    )
+    def has_key(self, glyphName):
+        return glyphName in self.glyphsMapping
+
+
+class _TTGlyphSetGlyf(_TTGlyphSet):
+    def __init__(self, font, location, recalcBounds=True):
+        self.glyfTable = font["glyf"]
+        super().__init__(font, location, self.glyfTable, recalcBounds=recalcBounds)
+        self.gvarTable = font.get("gvar")
+
+    def __getitem__(self, glyphName):
+        return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
+
+
+class _TTGlyphSetGlyf(_TTGlyphSet):
+    def __init__(self, font, location, recalcBounds=True):
+        self.glyfTable = font["glyf"]
+        super().__init__(font, location, self.glyfTable, recalcBounds=recalcBounds)
+        self.gvarTable = font.get("gvar")
+
+    def __getitem__(self, glyphName):
+        return _TTGlyphGlyf(self, glyphName, recalcBounds=self.recalcBounds)
+
+
+class _TTGlyphSetCFF(_TTGlyphSet):
+    def __init__(self, font, location):
+        tableTag = "CFF2" if "CFF2" in font else "CFF "
+        self.charStrings = list(font[tableTag].cff.values())[0].CharStrings
+        super().__init__(font, location, self.charStrings)
+        self.setLocation(location)
+
+    def __getitem__(self, glyphName):
+        return _TTGlyphCFF(self, glyphName)
+
+    def setLocation(self, location):
+        self.blender = None
+        if location:
+            # TODO Optimize by using instancer.setLocation()
+
+            from fontTools.varLib.varStore import VarStoreInstancer
+
+            varStore = getattr(self.charStrings, "varStore", None)
+            if varStore is not None:
+                instancer = VarStoreInstancer(
+                    varStore.otVarStore, self.font["fvar"].axes, location
+                )
+                self.blender = instancer.interpolateFromDeltas
+        else:
+            self.blender = None
+
+    @contextmanager
+    def pushLocation(self, location, reset: bool):
+        self.setLocation(location)
+        with _TTGlyphSet.pushLocation(self, location, reset) as value:
+            try:
+                yield value
+            finally:
+                self.setLocation(self.location)
+
+
+class _TTGlyphSetVARC(_TTGlyphSet):
+    def __init__(self, font, location, glyphSet):
+        self.glyphSet = glyphSet
+        super().__init__(font, location, glyphSet)
+        self.varcTable = font["VARC"].table
+
+    def __getitem__(self, glyphName):
+        varc = self.varcTable
+        if glyphName not in varc.Coverage.glyphs:
+            return self.glyphSet[glyphName]
+        return _TTGlyphVARC(self, glyphName)
+
+
+class _TTGlyph(ABC):
+    """Glyph object 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, glyphName, *, recalcBounds=True):
+        self.glyphSet = glyphSet
+        self.name = glyphName
+        self.recalcBounds = recalcBounds
+        self.width, self.lsb = glyphSet.hMetrics[glyphName]
+        if glyphSet.vMetrics is not None:
+            self.height, self.tsb = glyphSet.vMetrics[glyphName]
+        else:
+            self.height, self.tsb = None, None
+        if glyphSet.location and glyphSet.hvarTable is not None:
+            varidx = (
+                glyphSet.font.getGlyphID(glyphName)
+                if glyphSet.hvarTable.AdvWidthMap is None
+                else glyphSet.hvarTable.AdvWidthMap.mapping[glyphName]
+            )
+            self.width += glyphSet.hvarInstancer[varidx]
+        # TODO: VVAR/VORG
+
+    @abstractmethod
+    def draw(self, pen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details
+        how that works.
+        """
+        raise NotImplementedError
+
+    def drawPoints(self, pen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.pointPen for details
+        how that works.
+        """
+        from fontTools.pens.pointPen import SegmentToPointPen
+
+        self.draw(SegmentToPointPen(pen))
+
+
+class _TTGlyphGlyf(_TTGlyph):
+    def draw(self, pen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details
+        how that works.
+        """
+        glyph, offset = self._getGlyphAndOffset()
+
+        with self.glyphSet.pushDepth() as depth:
+            if depth:
+                offset = 0  # Offset should only apply at top-level
+
+            glyph.draw(pen, self.glyphSet.glyfTable, offset)
+
+    def drawPoints(self, pen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.pointPen for details
+        how that works.
+        """
+        glyph, offset = self._getGlyphAndOffset()
+
+        with self.glyphSet.pushDepth() as depth:
+            if depth:
+                offset = 0  # Offset should only apply at top-level
+
+            glyph.drawPoints(pen, self.glyphSet.glyfTable, offset)
+
+    def _getGlyphAndOffset(self):
+        if self.glyphSet.location and self.glyphSet.gvarTable is not None:
+            glyph = self._getGlyphInstance()
+        else:
+            glyph = self.glyphSet.glyfTable[self.name]
+
+        offset = self.lsb - glyph.xMin if hasattr(glyph, "xMin") else 0
+        return glyph, offset
+
+    def _getGlyphInstance(self):
+        from fontTools.varLib.iup import iup_delta
+        from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates
+        from fontTools.varLib.models import supportScalar
+
+        glyphSet = self.glyphSet
+        glyfTable = glyphSet.glyfTable
+        variations = glyphSet.gvarTable.variations[self.name]
+        hMetrics = glyphSet.hMetrics
+        vMetrics = glyphSet.vMetrics
+        coordinates, _ = glyfTable._getCoordinatesAndControls(
+            self.name, hMetrics, vMetrics
+        )
+        origCoords, endPts = None, None
+        for var in variations:
+            scalar = supportScalar(glyphSet.location, var.axes)
+            if not scalar:
+                continue
+            delta = var.coordinates
+            if None in delta:
+                if origCoords is None:
+                    origCoords, control = glyfTable._getCoordinatesAndControls(
+                        self.name, 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(glyfTable[self.name])  # Shallow copy
+        width, lsb, height, tsb = _setCoordinates(
+            glyph, coordinates, glyfTable, recalcBounds=self.recalcBounds
+        )
+        self.lsb = lsb
+        self.tsb = tsb
+        if glyphSet.hvarTable is None:
+            # no HVAR: let's set metrics from the phantom points
+            self.width = width
+            self.height = height
+        return glyph
+
+
+class _TTGlyphCFF(_TTGlyph):
+    def draw(self, pen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details
+        how that works.
+        """
+        self.glyphSet.charStrings[self.name].draw(pen, self.glyphSet.blender)
+
+
+def _evaluateCondition(condition, fvarAxes, location, instancer):
+    if condition.Format == 1:
+        # ConditionAxisRange
+        axisIndex = condition.AxisIndex
+        axisTag = fvarAxes[axisIndex].axisTag
+        axisValue = location.get(axisTag, 0)
+        minValue = condition.FilterRangeMinValue
+        maxValue = condition.FilterRangeMaxValue
+        return minValue <= axisValue <= maxValue
+    elif condition.Format == 2:
+        # ConditionValue
+        value = condition.DefaultValue
+        value += instancer[condition.VarIdx][0]
+        return value > 0
+    elif condition.Format == 3:
+        # ConditionAnd
+        for subcondition in condition.ConditionTable:
+            if not _evaluateCondition(subcondition, fvarAxes, location, instancer):
+                return False
+        return True
+    elif condition.Format == 4:
+        # ConditionOr
+        for subcondition in condition.ConditionTable:
+            if _evaluateCondition(subcondition, fvarAxes, location, instancer):
+                return True
+        return False
+    elif condition.Format == 5:
+        # ConditionNegate
+        return not _evaluateCondition(
+            condition.conditionTable, fvarAxes, location, instancer
+        )
+    else:
+        return False  # Unkonwn condition format
+
+
+class _TTGlyphVARC(_TTGlyph):
+    def _draw(self, pen, isPointPen):
+        """Draw the glyph onto ``pen``. See fontTools.pens.basePen for details
+        how that works.
+        """
+        from fontTools.ttLib.tables.otTables import (
+            VarComponentFlags,
+            NO_VARIATION_INDEX,
+        )
+
+        glyphSet = self.glyphSet
+        varc = glyphSet.varcTable
+        idx = varc.Coverage.glyphs.index(self.name)
+        glyph = varc.VarCompositeGlyphs.VarCompositeGlyph[idx]
+
+        from fontTools.varLib.multiVarStore import MultiVarStoreInstancer
+        from fontTools.varLib.varStore import VarStoreInstancer
+
+        fvarAxes = glyphSet.font["fvar"].axes
+        instancer = MultiVarStoreInstancer(
+            varc.MultiVarStore, fvarAxes, self.glyphSet.location
+        )
+
+        for comp in glyph.components:
+            if comp.flags & VarComponentFlags.HAVE_CONDITION:
+                condition = varc.ConditionList.ConditionTable[comp.conditionIndex]
+                if not _evaluateCondition(
+                    condition, fvarAxes, self.glyphSet.location, instancer
+                ):
+                    continue
+
+            location = {}
+            if comp.axisIndicesIndex is not None:
+                axisIndices = varc.AxisIndicesList.Item[comp.axisIndicesIndex]
+                axisValues = Vector(comp.axisValues)
+                if comp.axisValuesVarIndex != NO_VARIATION_INDEX:
+                    axisValues += fi2fl(instancer[comp.axisValuesVarIndex], 14)
+                assert len(axisIndices) == len(axisValues), (
+                    len(axisIndices),
+                    len(axisValues),
+                )
+                location = {
+                    fvarAxes[i].axisTag: v for i, v in zip(axisIndices, axisValues)
+                }
+
+            if comp.transformVarIndex != NO_VARIATION_INDEX:
+                deltas = instancer[comp.transformVarIndex]
+                comp = deepcopy(comp)
+                comp.applyTransformDeltas(deltas)
+            transform = comp.transform
+
+            reset = comp.flags & VarComponentFlags.RESET_UNSPECIFIED_AXES
+            with self.glyphSet.glyphSet.pushLocation(location, reset):
+                with self.glyphSet.pushLocation(location, reset):
+                    shouldDecompose = self.name == comp.glyphName
+
+                    if not shouldDecompose:
+                        try:
+                            pen.addVarComponent(
+                                comp.glyphName, transform, self.glyphSet.rawLocation
+                            )
+                        except AttributeError:
+                            shouldDecompose = True
+
+                    if shouldDecompose:
+                        t = transform.toTransform()
+                        compGlyphSet = (
+                            self.glyphSet
+                            if comp.glyphName != self.name
+                            else glyphSet.glyphSet
+                        )
+                        g = compGlyphSet[comp.glyphName]
+                        if isPointPen:
+                            tPen = TransformPointPen(pen, t)
+                            g.drawPoints(tPen)
+                        else:
+                            tPen = TransformPen(pen, t)
+                            g.draw(tPen)
+
+    def draw(self, pen):
+        self._draw(pen, False)
+
+    def drawPoints(self, pen):
+        self._draw(pen, True)
+
+
+def _setCoordinates(glyph, coord, glyfTable, *, recalcBounds=True):
+    # 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]
+
+    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]  # Shallow copy
+        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
+
+    if recalcBounds:
+        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 LerpGlyphSet(Mapping):
+    """A glyphset that interpolates between two other glyphsets.
+
+    Factor is typically between 0 and 1. 0 means the first glyphset,
+    1 means the second glyphset, and 0.5 means the average of the
+    two glyphsets. Other values are possible, and can be useful to
+    extrapolate. Defaults to 0.5.
+    """
+
+    def __init__(self, glyphset1, glyphset2, factor=0.5):
+        self.glyphset1 = glyphset1
+        self.glyphset2 = glyphset2
+        self.factor = factor
+
+    def __getitem__(self, glyphname):
+        if glyphname in self.glyphset1 and glyphname in self.glyphset2:
+            return LerpGlyph(glyphname, self)
+        raise KeyError(glyphname)
+
+    def __contains__(self, glyphname):
+        return glyphname in self.glyphset1 and glyphname in self.glyphset2
+
+    def __iter__(self):
+        set1 = set(self.glyphset1)
+        set2 = set(self.glyphset2)
+        return iter(set1.intersection(set2))
+
+    def __len__(self):
+        set1 = set(self.glyphset1)
+        set2 = set(self.glyphset2)
+        return len(set1.intersection(set2))
+
+
+class LerpGlyph:
+    def __init__(self, glyphname, glyphset):
+        self.glyphset = glyphset
+        self.glyphname = glyphname
+
+    def draw(self, pen):
+        recording1 = DecomposingRecordingPen(self.glyphset.glyphset1)
+        self.glyphset.glyphset1[self.glyphname].draw(recording1)
+        recording2 = DecomposingRecordingPen(self.glyphset.glyphset2)
+        self.glyphset.glyphset2[self.glyphname].draw(recording2)
+
+        factor = self.glyphset.factor
+
+        replayRecording(lerpRecordings(recording1.value, recording2.value, factor), pen)

fontTools/ttLib/ttVisitor.py

@@ -0,0 +1,32 @@
+"""Specialization of fontTools.misc.visitor to work with TTFont."""
+
+from fontTools.misc.visitor import Visitor
+from fontTools.ttLib import TTFont
+
+
+class TTVisitor(Visitor):
+    def visitAttr(self, obj, attr, value, *args, **kwargs):
+        if isinstance(value, TTFont):
+            return False
+        super().visitAttr(obj, attr, value, *args, **kwargs)
+
+    def visit(self, obj, *args, **kwargs):
+        if hasattr(obj, "ensureDecompiled"):
+            obj.ensureDecompiled(recurse=False)
+        super().visit(obj, *args, **kwargs)
+
+
+@TTVisitor.register(TTFont)
+def visit(visitor, font, *args, **kwargs):
+    # Some objects have links back to TTFont; even though we
+    # have a check in visitAttr to stop them from recursing
+    # onto TTFont, sometimes they still do, for example when
+    # someone overrides visitAttr.
+    if hasattr(visitor, "font"):
+        return False
+
+    visitor.font = font
+    for tag in font.keys():
+        visitor.visit(font[tag], *args, **kwargs)
+    del visitor.font
+    return False