[instancer] Start avar2 instancing

Lib/fontTools/ttLib/tables/_a_v_a_r.py

@@ -10,8 +10,10 @@
 from fontTools.varLib.models import piecewiseLinearMap
 from fontTools.varLib.varStore import VarStoreInstancer, NO_VARIATION_INDEX
 from fontTools.ttLib import TTLibError
+from fontTools.varLib import instancer
 from . import DefaultTable
 from . import otTables
+from copy import deepcopy
 import struct
 import logging
 
@@ -142,7 +144,6 @@
             super().fromXML(name, attrs, content, ttFont)
 
     def renormalizeLocation(self, location, font):
-
         if self.majorVersion not in (1, 2):
             raise NotImplementedError("Unknown avar table version")
 
@@ -163,18 +164,17 @@
         varStore = self.table.VarStore
         axes = font["fvar"].axes
         if varStore is not None:
-            instancer = VarStoreInstancer(varStore, axes, mappedLocation)
+            varStoreInstancer = VarStoreInstancer(varStore, axes, mappedLocation)
 
         coords = list(fl2fi(mappedLocation.get(axis.axisTag, 0), 14) for axis in axes)
 
         out = []
         for varIdx, v in enumerate(coords):
-
             if varIdxMap is not None:
                 varIdx = varIdxMap[varIdx]
 
             if varStore is not None:
-                delta = instancer[varIdx]
+                delta = varStoreInstancer[varIdx]
                 v += otRound(delta)
                 v = min(max(v, -(1 << 14)), +(1 << 14))
 
@@ -185,3 +185,78 @@
         }
 
         return mappedLocation
+
+    def renormalizeAxisLimits(self, axisLimits, font, *, versionOneOnly=False):
+        version = getattr(self, "majorVersion", 1)
+        if version not in (1, 2):
+            raise NotImplementedError("Unknown avar table version")
+
+        avarSegments = self.segments
+        mappedAxisLimits = {}
+        for axisTag, triple in axisLimits.items():
+            avarMapping = avarSegments.get(axisTag, None)
+            if avarMapping is not None:
+                triple = tuple(
+                    piecewiseLinearMap(value, avarMapping) for value in triple
+                )
+            mappedAxisLimits[axisTag] = triple
+
+        if version == 1 or versionOneOnly:
+            return instancer.NormalizedAxisLimits(mappedAxisLimits)
+
+        # Version 2
+
+        limits = deepcopy(axisLimits)
+        fvar = font["fvar"]
+        avar = self
+
+        varIdxMap = getattr(avar.table, "VarIdxMap", None)
+        varStore = getattr(avar.table, "VarStore", None)
+        if varStore is not None:
+            varStore = deepcopy(varStore)
+        axes = font["fvar"].axes
+
+        pinnedAxes = axisLimits.pinnedLocation()
+
+        defaultDeltas = instancer.instantiateItemVariationStore(
+            varStore, fvar.axes, limits
+        )
+
+        for axis in fvar.axes:
+            if axis.axisTag in limits:
+                continue
+            private = axis.flags & 0x1
+            if not private:
+                continue
+            # if private, pin at default
+            limits[axis.axisTag] = instancer.NormalizedAxisTripleAndDistances(0, 0, 0)
+
+        newLimits = {}
+        for axisIdx, axis in enumerate(fvar.axes):
+            if axis.axisTag in pinnedAxes:
+                v = axisLimits[axis.axisTag][0]
+                newLimits[axis.axisTag] = instancer.NormalizedAxisTripleAndDistances(
+                    v, v, v
+                )
+                continue
+            varIdx = axisIdx
+            if varIdxMap is not None:
+                varIdx = varIdxMap[varIdx]
+            # Only for public axes
+            private = axis.flags & 0x1
+            identityAxisIndex = None if private else axisIdx
+            minV, maxV = varStore.getExtremes(
+                varIdx, fvar.axes, limits, identityAxisIndex
+            )
+            # TODO: To 2.14 and back...
+            default = defaultDeltas[varIdx]
+            newLimits[axis.axisTag] = instancer.NormalizedAxisTripleAndDistances(
+                max(-1, min((default + minV) / 16384, +1)),
+                default / 16384,
+                max(-1, min((default + maxV) / 16384, +1)),
+                axis.defaultValue - axis.minValue,
+                axis.maxValue - axis.defaultValue,
+            )
+        limits = newLimits
+
+        return instancer.NormalizedAxisLimits(limits)

Lib/fontTools/varLib/instancer/__init__.py

@@ -108,6 +108,7 @@
 from fontTools.varLib.mvar import MVAR_ENTRIES
 from fontTools.varLib.merger import MutatorMerger
 from fontTools.varLib.instancer import names
+from fontTools.varLib.varStore import OnlineVarStoreBuilder
 from .featureVars import instantiateFeatureVariations
 from fontTools.misc.cliTools import makeOutputFileName
 from fontTools.varLib.instancer import solver
@@ -342,6 +343,9 @@
     def __getitem__(self, key: str) -> AxisTriple:
         return self._data[key]
 
+    def __setitem__(self, key, value):
+        self._data[key] = value
+
     def __iter__(self) -> Iterable[str]:
         return iter(self._data)
 
@@ -414,34 +418,46 @@
             if a.axisTag in self
         }
 
-        avarSegments = {}
-        if usingAvar and "avar" in varfont:
-            avarSegments = varfont["avar"].segments
-
         normalizedLimits = {}
 
         for axis_tag, triple in axes.items():
-            distanceNegative = triple[1] - triple[0]
-            distancePositive = triple[2] - triple[1]
-
-            if self[axis_tag] is None:
-                normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
-                    0, 0, 0, distanceNegative, distancePositive
-                )
+            if self[axis_tag] is None:  # Drop
+                normalizedLimits[axis_tag] = (0, 0, 0)
                 continue
 
             minV, defaultV, maxV = self[axis_tag]
 
             if defaultV is None:
                 defaultV = triple[1]
 
-            avarMapping = avarSegments.get(axis_tag, None)
-            normalizedLimits[axis_tag] = NormalizedAxisTripleAndDistances(
-                *(normalize(v, triple, avarMapping) for v in (minV, defaultV, maxV)),
-                distanceNegative,
-                distancePositive,
+            normalizedLimits[axis_tag] = tuple(
+                normalize(v, triple) for v in (minV, defaultV, maxV)
+            )
+
+        fvarAxes = fvar.getAxes()
+        for tag, triple in normalizedLimits.items():
+            minV, defaultV, maxV = fvarAxes[tag]
+            if defaultV is None:
+                defaultV = triple[1]
+            distanceNegative = defaultV - minV
+            distancePositive = maxV - defaultV
+
+            if triple is None:  # Drop
+                normalizedLimits[tag] = NormalizedAxisTripleAndDistances(
+                    0, 0, 0, distanceNegative, distancePositive
+                )
+                continue
+
+            normalizedLimits[tag] = NormalizedAxisTripleAndDistances(
+                *triple, distanceNegative, distancePositive
             )
 
+        normalizedLimits = NormalizedAxisLimits(normalizedLimits)
+
+        if usingAvar and "avar" in varfont:
+            avar = varfont["avar"]
+            normalizedLimits = avar.renormalizeAxisLimits(normalizedLimits, varfont)
+
         return NormalizedAxisLimits(normalizedLimits)
 
 
@@ -1313,12 +1329,10 @@
     return True
 
 
-def instantiateAvar(varfont, axisLimits):
+def instantiateAvar(varfont, axisLimits, normalizedLimits):
     # 'axisLimits' dict must contain user-space (non-normalized) coordinates.
 
     avar = varfont["avar"]
-    if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
-        raise NotImplementedError("avar table with VarStore is not supported")
 
     segments = avar.segments
 
@@ -1383,6 +1397,64 @@
             newSegments[axisTag] = mapping
     avar.segments = newSegments
 
+    version = getattr(avar, "majorVersion", 1)
+    if version == 1:
+        return
+
+    assert version == 2
+    fvarAxes = varfont["fvar"].axes
+    varStore = getattr(avar.table, "VarStore", None)
+
+    if varStore is not None:
+        # Compute scalar for each region, based on the new axis limits
+        regionList = varStore.VarRegionList.Region
+        scalars = []
+        for region in regionList:
+            regionAxes = region.get_support(fvarAxes)
+            scalar = 1.0
+            for axisTag, axis in regionAxes.items():
+                if axis[1] == 0:
+                    continue
+                if axisTag in axisLimits:
+                    axisRange = axisLimits[axisTag]
+                    scalar *= (axisRange.maximum - axisRange.minimum) / 2.0
+            scalars.append(scalar)
+
+        varIdxMap = getattr(avar.table, "VarIdxMap", None)
+        varStoreBuilder = OnlineVarStoreBuilder([axis.axisTag for axis in fvarAxes])
+        newVarIdxMapping = []
+        for i in range(len(fvarAxes)):
+            if i in pinnedAxes:
+                continue
+            varIdx = i
+            if varIdxMap:
+                varIdx = varIdxMap[varIdx]
+            if varIdx != varStore.NO_VARIATION_INDEX:
+                VarData = varStore.VarData[varIdx >> 16]
+                supports = [
+                    regionList[regionIndex].get_support(fvarAxes)
+                    for regionIndex in VarData.VarRegionIndex
+                ]
+                varStoreBuilder.setSupports(supports)
+                row = VarData.Item[varIdx & 0xFFFF]
+                row = [
+                    delta / scalars[idx]
+                    for delta, idx in zip(row, VarData.VarRegionIndex)
+                ]
+                varIdx = varStoreBuilder.storeDeltas(row)
+
+            newVarIdxMapping.append(varIdx)
+
+        varStore = avar.table.VarStore = varStoreBuilder.finish()
+        if varIdxMap is not None:
+            varIdxMap.mapping = newVarIdxMapping
+
+        # TODO: Optimize VarStore
+
+        defaultDeltas = instantiateItemVariationStore(
+            varStore, fvarAxes, normalizedLimits
+        )
+
 
 def isInstanceWithinAxisRanges(location, axisRanges):
     for axisTag, coord in location.items():
@@ -1505,7 +1577,7 @@
             glyph.flags[0] |= flagOverlapSimple
 
 
-def normalize(value, triple, avarMapping):
+def normalize(value, triple, avarMapping=None):
     value = normalizeValue(value, triple)
     if avarMapping:
         value = piecewiseLinearMap(value, avarMapping)
@@ -1621,7 +1693,7 @@
     instantiateFeatureVariations(varfont, normalizedLimits)
 
     if "avar" in varfont:
-        instantiateAvar(varfont, axisLimits)
+        instantiateAvar(varfont, axisLimits, normalizedLimits)
 
     with names.pruningUnusedNames(varfont):
         if "STAT" in varfont:

Lib/fontTools/varLib/instancer/avar2.py

@@ -0,0 +1,42 @@
+from fontTools.varLib.varStore import VarStoreInstancer, NO_VARIATION_INDEX
+from fontTools.ttLib.tables.otTables import VarStore
+from fontTools.ttLib.tables._f_v_a_r import Axis
+from fontTools.varLib import instancer
+
+
+if __name__ == "__main__":
+    import sys
+    from fontTools.ttLib import TTFont
+
+    font = TTFont(sys.argv[1])
+
+    limits = sys.argv[2:]
+    limits = instancer.parseLimits(limits)
+    limits = instancer.AxisLimits(limits).limitAxesAndPopulateDefaults(font)
+    limits = limits.normalize(font, usingAvar=False)
+    print(limits)
+
+    fvar = font["fvar"]
+    avar = font.get("avar", None)
+
+    varIdxMap = None
+    varStore = None
+    if avar and hasattr(avar, "table"):
+        varIdxMap = getattr(avar.table, "VarIdxMap", None)
+        varStore = getattr(avar.table, "VarStore", None)
+
+    pinnedAxes = limits.pinnedLocation()
+    unpinnedAxes = [axis for axis in fvar.axes if axis.axisTag not in pinnedAxes]
+
+    if avar:
+        limits = avar.renormalizeAxisLimits(limits, font)
+
+    for axisIdx, axis in enumerate(fvar.axes):
+        varIdx = axisIdx
+        if varIdxMap is not None:
+            varIdx = varIdxMap[varIdx]
+        private = axis.flags & 0x1
+        print(
+            "%s%s" % (axis.axisTag, "*" if private else ""),
+            limits.get(axis.axisTag, (0, 0, 0) if private else (-1, 0, +1)),
+        )