fonttools 4.55.4__cp313-cp313-musllinux_1_2_aarch64.whl → 4.61.1__cp313-cp313-musllinux_1_2_aarch64.whl

fontTools/varLib/featureVars.py

@@ -95,6 +95,14 @@ def addFeatureVariations(font, conditionalSubstitutions, featureTag="rvrn"):
 
     addFeatureVariationsRaw(font, font["GSUB"].table, conditionsAndLookups, featureTags)
 
+    # Update OS/2.usMaxContext in case the font didn't have features before, but
+    # does now, if the OS/2 table exists. The table may be required, but
+    # fontTools needs to be able to deal with non-standard fonts. Since feature
+    # variations are always 1:1 mappings, we can set the value to at least 1
+    # instead of recomputing it with `otlLib.maxContextCalc.maxCtxFont()`.
+    if (os2 := font.get("OS/2")) is not None:
+        os2.usMaxContext = max(1, os2.usMaxContext)
+
 
 def _existingVariableFeatures(table):
     existingFeatureVarsTags = set()
@@ -392,10 +400,13 @@ def addFeatureVariationsRaw(font, table, conditionalSubstitutions, featureTag="r
 
             for scriptRecord in table.ScriptList.ScriptRecord:
                 if scriptRecord.Script.DefaultLangSys is None:
-                    raise VarLibError(
-                        "Feature variations require that the script "
-                        f"'{scriptRecord.ScriptTag}' defines a default language system."
-                    )
+                    # We need to have a default LangSys to attach variations to.
+                    langSys = ot.LangSys()
+                    langSys.LookupOrder = None
+                    langSys.ReqFeatureIndex = 0xFFFF
+                    langSys.FeatureIndex = []
+                    langSys.FeatureCount = 0
+                    scriptRecord.Script.DefaultLangSys = langSys
                 langSystems = [lsr.LangSys for lsr in scriptRecord.Script.LangSysRecord]
                 for langSys in [scriptRecord.Script.DefaultLangSys] + langSystems:
                     langSys.FeatureIndex.append(varFeatureIndex)
@@ -597,9 +608,12 @@ def buildFeatureRecord(featureTag, lookupListIndices):
 def buildFeatureVariationRecord(conditionTable, substitutionRecords):
     """Build a FeatureVariationRecord."""
     fvr = ot.FeatureVariationRecord()
-    fvr.ConditionSet = ot.ConditionSet()
-    fvr.ConditionSet.ConditionTable = conditionTable
-    fvr.ConditionSet.ConditionCount = len(conditionTable)
+    if len(conditionTable) != 0:
+        fvr.ConditionSet = ot.ConditionSet()
+        fvr.ConditionSet.ConditionTable = conditionTable
+        fvr.ConditionSet.ConditionCount = len(conditionTable)
+    else:
+        fvr.ConditionSet = None
     fvr.FeatureTableSubstitution = ot.FeatureTableSubstitution()
     fvr.FeatureTableSubstitution.Version = 0x00010000
     fvr.FeatureTableSubstitution.SubstitutionRecord = substitutionRecords

fontTools/varLib/hvar.py

@@ -0,0 +1,113 @@
+from fontTools.misc.roundTools import noRound
+from fontTools.ttLib import TTFont, newTable
+from fontTools.ttLib.tables import otTables as ot
+from fontTools.ttLib.tables.otBase import OTTableWriter
+from fontTools.varLib import HVAR_FIELDS, VVAR_FIELDS, _add_VHVAR
+from fontTools.varLib import builder, models, varStore
+from fontTools.misc.fixedTools import fixedToFloat as fi2fl
+from fontTools.misc.cliTools import makeOutputFileName
+from functools import partial
+import logging
+
+log = logging.getLogger("fontTools.varLib.avar")
+
+
+def _get_advance_metrics(font, axisTags, tableFields):
+    # There's two ways we can go from here:
+    # 1. For each glyph, at each master peak, compute the value of the
+    #    advance width at that peak.  Then pass these all to a VariationModel
+    #    builder to compute back the deltas.
+    # 2. For each master peak, pull out the deltas of the advance width directly,
+    #    and feed these to the VarStoreBuilder, forgoing the remodeling step.
+    # We'll go with the second option, as it's simpler, faster, and more direct.
+    gvar = font["gvar"]
+    vhAdvanceDeltasAndSupports = {}
+    glyphOrder = font.getGlyphOrder()
+    phantomIndex = tableFields.phantomIndex
+    for glyphName in glyphOrder:
+        supports = []
+        deltas = []
+        variations = gvar.variations.get(glyphName, [])
+
+        for tv in variations:
+            supports.append(tv.axes)
+            phantoms = tv.coordinates[-4:]
+            phantoms = phantoms[phantomIndex * 2 : phantomIndex * 2 + 2]
+            assert len(phantoms) == 2
+            phantoms[0] = phantoms[0][phantomIndex] if phantoms[0] is not None else 0
+            phantoms[1] = phantoms[1][phantomIndex] if phantoms[1] is not None else 0
+            deltas.append(phantoms[1] - phantoms[0])
+
+        vhAdvanceDeltasAndSupports[glyphName] = (deltas, supports)
+
+    vOrigDeltasAndSupports = None  # TODO
+
+    return vhAdvanceDeltasAndSupports, vOrigDeltasAndSupports
+
+
+def add_HVAR(font):
+    if "HVAR" in font:
+        del font["HVAR"]
+    axisTags = [axis.axisTag for axis in font["fvar"].axes]
+    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, HVAR_FIELDS)
+    _add_VHVAR(font, axisTags, HVAR_FIELDS, getAdvanceMetrics)
+
+
+def add_VVAR(font):
+    if "VVAR" in font:
+        del font["VVAR"]
+    getAdvanceMetrics = partial(_get_advance_metrics, font, axisTags, VVAR_FIELDS)
+    axisTags = [axis.axisTag for axis in font["fvar"].axes]
+    _add_VHVAR(font, axisTags, VVAR_FIELDS, getAdvanceMetrics)
+
+
+def main(args=None):
+    """Add `HVAR` table to variable font."""
+
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    from fontTools import configLogger
+    from fontTools.designspaceLib import DesignSpaceDocument
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.hvar",
+        description="Add `HVAR` table from to variable font.",
+    )
+    parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        type=str,
+        help="Output font file name.",
+    )
+
+    options = parser.parse_args(args)
+
+    configLogger(level="WARNING")
+
+    font = TTFont(options.font)
+    if not "fvar" in font:
+        log.error("Not a variable font.")
+        return 1
+
+    add_HVAR(font)
+    if "vmtx" in font:
+        add_VVAR(font)
+
+    if options.output_file is None:
+        outfile = makeOutputFileName(options.font, overWrite=True, suffix=".hvar")
+    else:
+        outfile = options.output_file
+    if outfile:
+        log.info("Saving %s", outfile)
+        font.save(outfile)
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())

fontTools/varLib/instancer/__init__.py

@@ -1,4 +1,4 @@
-""" Partially instantiate a variable font.
+"""Partially instantiate a variable font.
 
 The module exports an `instantiateVariableFont` function and CLI that allow to
 create full instances (i.e. static fonts) from variable fonts, as well as "partial"
@@ -36,7 +36,7 @@ If the input location specifies all the axes, the resulting instance is no longe
 'variable' (same as using fontools varLib.mutator):
 .. code-block:: pycon
 
-    >>>    
+    >>>
     >> instance = instancer.instantiateVariableFont(
     ...     varfont, {"wght": 700, "wdth": 67.5}
     ... )
@@ -56,8 +56,10 @@ From the console script, this is equivalent to passing `wght=drop` as input.
 
 This module is similar to fontTools.varLib.mutator, which it's intended to supersede.
 Note that, unlike varLib.mutator, when an axis is not mentioned in the input
-location, the varLib.instancer will keep the axis and the corresponding deltas,
-whereas mutator implicitly drops the axis at its default coordinate.
+location, by default the varLib.instancer will keep the axis and the corresponding
+deltas, whereas mutator implicitly drops the axis at its default coordinate.
+To obtain the same behavior as mutator, pass the `static=True` parameter or
+the `--static` CLI option.
 
 The module supports all the following "levels" of instancing, which can of
 course be combined:
@@ -72,7 +74,7 @@ L1
 L2
     dropping one or more axes while pinning them at non-default locations;
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": 700})
 
@@ -81,22 +83,18 @@ L3
     a new minimum or maximum, potentially -- though not necessarily -- dropping
     entire regions of variations that fall completely outside this new range.
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300)})
 
 L4
     moving the default location of an axis, by specifying (min,defalt,max) values:
     .. code-block:: pycon
-    
+
         >>>
         >> font = instancer.instantiateVariableFont(varfont, {"wght": (100, 300, 700)})
 
-Currently only TrueType-flavored variable fonts (i.e. containing 'glyf' table)
-are supported, but support for CFF2 variable fonts will be added soon.
-
-The discussion and implementation of these features are tracked at
-https://github.com/fonttools/fonttools/issues/1537
+Both TrueType-flavored (glyf+gvar) variable and CFF2 variable fonts are supported.
 """
 
 from fontTools.misc.fixedTools import (
@@ -120,6 +118,7 @@ from fontTools.cffLib.specializer import (
     specializeCommands,
     generalizeCommands,
 )
+from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
 from fontTools.varLib import builder
 from fontTools.varLib.mvar import MVAR_ENTRIES
 from fontTools.varLib.merger import MutatorMerger
@@ -136,6 +135,7 @@ from enum import IntEnum
 import logging
 import os
 import re
+import io
 from typing import Dict, Iterable, Mapping, Optional, Sequence, Tuple, Union
 import warnings
 
@@ -433,7 +433,27 @@ class AxisLimits(_BaseAxisLimits):
 
         avarSegments = {}
         if usingAvar and "avar" in varfont:
-            avarSegments = varfont["avar"].segments
+            avar = varfont["avar"]
+            avarSegments = avar.segments
+
+            if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
+                pinnedAxes = set(self.pinnedLocation())
+                if not pinnedAxes.issuperset(avarSegments):
+                    raise NotImplementedError(
+                        "Partial-instancing avar2 table is not supported"
+                    )
+
+                # TODO: Merge this with the main codepath.
+
+                # Full instancing of avar2 font. Use avar table to normalize location and return.
+                location = self.pinnedLocation()
+                location = {
+                    tag: normalize(value, axes[tag], None)
+                    for tag, value in location.items()
+                }
+                return NormalizedAxisLimits(
+                    **avar.renormalizeLocation(location, varfont, dropZeroes=False)
+                )
 
         normalizedLimits = {}
 
@@ -643,7 +663,11 @@ def instantiateCFF2(
     # the Private dicts.
     #
     # Then prune unused things and possibly drop the VarStore if it's empty.
-    # In which case, downgrade to CFF table if requested.
+    #
+    # If the downgrade parameter is True, no actual downgrading is done, but
+    # the function returns True if the VarStore was empty after instantiation,
+    # and hence a downgrade to CFF is possible. In all other cases it returns
+    # False.
 
     log.info("Instantiating CFF2 table")
 
@@ -675,6 +699,7 @@ def instantiateCFF2(
             privateDicts.append(fd.Private)
 
     allCommands = []
+    allCommandPrivates = []
     for cs in charStrings:
         assert cs.private.vstore.otVarStore is varStore  # Or in many places!!
         commands = programToCommands(cs.program, getNumRegions=getNumRegions)
@@ -683,6 +708,7 @@ def instantiateCFF2(
         if specialize:
             commands = specializeCommands(commands, generalizeFirst=not generalize)
         allCommands.append(commands)
+        allCommandPrivates.append(cs.private)
 
     def storeBlendsToVarStore(arg):
         if not isinstance(arg, list):
@@ -721,9 +747,7 @@ def instantiateCFF2(
             minor = varDataCursor[major]
             varDataCursor[major] += 1
 
-            varIdx = (major << 16) + minor
-
-            defaultValue += round(defaultDeltas[varIdx])
+            defaultValue += round(defaultDeltas[major][minor])
             newDefaults.append(defaultValue)
 
             varData = varStore.VarData[major]
@@ -742,8 +766,8 @@ def instantiateCFF2(
         assert varData.ItemCount == 0
 
     # Add charstring blend lists to VarStore so we can instantiate them
-    for commands in allCommands:
-        vsindex = 0
+    for commands, private in zip(allCommands, allCommandPrivates):
+        vsindex = getattr(private, "vsindex", 0)
         for command in commands:
             if command[0] == "vsindex":
                 vsindex = command[1][0]
@@ -752,7 +776,6 @@ def instantiateCFF2(
                 storeBlendsToVarStore(arg)
 
     # Add private blend lists to VarStore so we can instantiate values
-    vsindex = 0
     for opcode, name, arg_type, default, converter in privateDictOperators2:
         if arg_type not in ("number", "delta", "array"):
             continue
@@ -763,6 +786,7 @@ def instantiateCFF2(
                 continue
             values = getattr(private, name)
 
+            # This is safe here since "vsindex" is the first in the privateDictOperators2
             if name == "vsindex":
                 vsindex = values[0]
                 continue
@@ -779,12 +803,14 @@ def instantiateCFF2(
                 storeBlendsToVarStore(value + [count])
 
     # Instantiate VarStore
-    defaultDeltas = instantiateItemVariationStore(varStore, fvarAxes, axisLimits)
+    defaultDeltas = instantiateItemVariationStore(
+        varStore, fvarAxes, axisLimits, hierarchical=True
+    )
 
     # Read back new charstring blends from the instantiated VarStore
     varDataCursor = [0] * len(varStore.VarData)
-    for commands in allCommands:
-        vsindex = 0
+    for commands, private in zip(allCommands, allCommandPrivates):
+        vsindex = getattr(private, "vsindex", 0)
         for command in commands:
             if command[0] == "vsindex":
                 vsindex = command[1][0]
@@ -799,9 +825,16 @@ def instantiateCFF2(
         if arg_type not in ("number", "delta", "array"):
             continue
 
+        vsindex = 0
         for private in privateDicts:
             if not hasattr(private, name):
                 continue
+
+            # This is safe here since "vsindex" is the first in the privateDictOperators2
+            if name == "vsindex":
+                vsindex = values[0]
+                continue
+
             values = getattr(private, name)
             if arg_type == "number":
                 values = [values]
@@ -830,18 +863,13 @@ def instantiateCFF2(
         varData.Item = []
         varData.ItemCount = 0
 
-    # Remove vsindex commands that are no longer needed, collect those that are.
-    usedVsindex = set()
-    for commands in allCommands:
-        if any(isinstance(arg, list) for command in commands for arg in command[1]):
-            vsindex = 0
-            for command in commands:
-                if command[0] == "vsindex":
-                    vsindex = command[1][0]
-                    continue
-                if any(isinstance(arg, list) for arg in command[1]):
-                    usedVsindex.add(vsindex)
-        else:
+    # Collect surviving vsindexes
+    usedVsindex = set(
+        i for i in range(len(varStore.VarData)) if varStore.VarData[i].VarRegionCount
+    )
+    # Remove vsindex commands that are no longer needed
+    for commands, private in zip(allCommands, allCommandPrivates):
+        if not any(isinstance(arg, list) for command in commands for arg in command[1]):
             commands[:] = [command for command in commands if command[0] != "vsindex"]
 
     # Remove unused VarData and update vsindex values
@@ -854,10 +882,14 @@ def instantiateCFF2(
         for command in commands:
             if command[0] == "vsindex":
                 command[1][0] = vsindexMapping[command[1][0]]
+    for private in privateDicts:
+        if hasattr(private, "vsindex"):
+            private.vsindex = vsindexMapping[private.vsindex]
 
     # Remove initial vsindex commands that are implied
-    for commands in allCommands:
-        if commands and commands[0] == ("vsindex", [0]):
+    for commands, private in zip(allCommands, allCommandPrivates):
+        vsindex = getattr(private, "vsindex", 0)
+        if commands and commands[0] == ("vsindex", [vsindex]):
             commands.pop(0)
 
     # Ship the charstrings!
@@ -874,9 +906,9 @@ def instantiateCFF2(
             del private.vstore
 
         if downgrade:
-            from fontTools.cffLib.CFF2ToCFF import convertCFF2ToCFF
+            return True
 
-            convertCFF2ToCFF(varfont)
+    return False
 
 
 def _instantiateGvarGlyph(
@@ -1108,7 +1140,8 @@ def _instantiateVHVAR(varfont, axisLimits, tableFields, *, round=round):
                     varIdx = advMapping.mapping[glyphName]
                 else:
                     varIdx = varfont.getGlyphID(glyphName)
-                metrics[glyphName] = (advanceWidth + round(defaultDeltas[varIdx]), sb)
+                delta = round(defaultDeltas[varIdx])
+                metrics[glyphName] = (max(0, advanceWidth + delta), sb)
 
             if (
                 tableTag == "VVAR"
@@ -1238,7 +1271,9 @@ class _TupleVarStoreAdapter(object):
         return itemVarStore
 
 
-def instantiateItemVariationStore(itemVarStore, fvarAxes, axisLimits):
+def instantiateItemVariationStore(
+    itemVarStore, fvarAxes, axisLimits, hierarchical=False
+):
     """Compute deltas at partial location, and update varStore in-place.
 
     Remove regions in which all axes were instanced, or fall outside the new axis
@@ -1270,12 +1305,19 @@ def instantiateItemVariationStore(itemVarStore, fvarAxes, axisLimits):
     assert itemVarStore.VarDataCount == newItemVarStore.VarDataCount
     itemVarStore.VarData = newItemVarStore.VarData
 
-    defaultDeltas = {
-        ((major << 16) + minor): delta
-        for major, deltas in enumerate(defaultDeltaArray)
-        for minor, delta in enumerate(deltas)
-    }
-    defaultDeltas[itemVarStore.NO_VARIATION_INDEX] = 0
+    if not hierarchical:
+        defaultDeltas = {
+            ((major << 16) + minor): delta
+            for major, deltas in enumerate(defaultDeltaArray)
+            for minor, delta in enumerate(deltas)
+        }
+        defaultDeltas[itemVarStore.NO_VARIATION_INDEX] = 0
+    else:
+        defaultDeltas = {0xFFFF: {0xFFFF: 0}}  # NO_VARIATION_INDEX
+        for major, deltas in enumerate(defaultDeltaArray):
+            defaultDeltasForMajor = defaultDeltas.setdefault(major, {})
+            for minor, delta in enumerate(deltas):
+                defaultDeltasForMajor[minor] = delta
     return defaultDeltas
 
 
@@ -1360,12 +1402,55 @@ def _isValidAvarSegmentMap(axisTag, segmentMap):
     return True
 
 
+def downgradeCFF2ToCFF(varfont):
+    # Save these properties
+    recalcTimestamp = varfont.recalcTimestamp
+    recalcBBoxes = varfont.recalcBBoxes
+
+    # Disable them
+    varfont.recalcTimestamp = False
+    varfont.recalcBBoxes = False
+
+    # Save to memory, reload, downgrade and save again, reload.
+    # We do this dance because the convertCFF2ToCFF changes glyph
+    # names, so following save would fail if any other table was
+    # loaded and referencing glyph names.
+    #
+    # The second save+load is unfortunate but also necessary.
+
+    stream = io.BytesIO()
+    log.info("Saving CFF2 font to memory for downgrade")
+    varfont.save(stream)
+    stream.seek(0)
+    varfont = TTFont(stream, recalcTimestamp=False, recalcBBoxes=False)
+
+    convertCFF2ToCFF(varfont)
+
+    stream = io.BytesIO()
+    log.info("Saving downgraded CFF font to memory")
+    varfont.save(stream)
+    stream.seek(0)
+    varfont = TTFont(stream, recalcTimestamp=False, recalcBBoxes=False)
+
+    # Uncomment, to see test all tables can be loaded. This fails without
+    # the extra save+load above.
+    """
+    for tag in varfont.keys():
+        print("Loading", tag)
+        varfont[tag]
+    """
+
+    # Restore them
+    varfont.recalcTimestamp = recalcTimestamp
+    varfont.recalcBBoxes = recalcBBoxes
+
+    return varfont
+
+
 def instantiateAvar(varfont, axisLimits):
     # '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
 
@@ -1376,6 +1461,9 @@ def instantiateAvar(varfont, axisLimits):
         del varfont["avar"]
         return
 
+    if getattr(avar, "majorVersion", 1) >= 2 and avar.table.VarStore:
+        raise NotImplementedError("avar table with VarStore is not supported")
+
     log.info("Instantiating avar table")
     for axis in pinnedAxes:
         if axis in segments:
@@ -1577,6 +1665,7 @@ def instantiateVariableFont(
     updateFontNames=False,
     *,
     downgradeCFF2=False,
+    static=False,
 ):
     """Instantiate variable font, either fully or partially.
 
@@ -1620,12 +1709,23 @@ def instantiateVariableFont(
             software that does not support CFF2. Defaults to False. Note that this
             operation also removes overlaps within glyph shapes, as CFF does not support
             overlaps but CFF2 does.
+        static (bool): if True, generate a full instance (static font) instead of a partial
+            instance (variable font).
     """
     # 'overlap' used to be bool and is now enum; for backward compat keep accepting bool
     overlap = OverlapMode(int(overlap))
 
     sanityCheckVariableTables(varfont)
 
+    if static:
+        unspecified = []
+        for axis in varfont["fvar"].axes:
+            if axis.axisTag not in axisLimits:
+                axisLimits[axis.axisTag] = None
+                unspecified.append(axis.axisTag)
+        if unspecified:
+            log.info("Pinning unspecified axes to default: %s", unspecified)
+
     axisLimits = AxisLimits(axisLimits).limitAxesAndPopulateDefaults(varfont)
 
     log.info("Restricted limits: %s", axisLimits)
@@ -1648,7 +1748,9 @@ def instantiateVariableFont(
         instantiateVARC(varfont, normalizedLimits)
 
     if "CFF2" in varfont:
-        instantiateCFF2(varfont, normalizedLimits, downgrade=downgradeCFF2)
+        downgradeCFF2 = instantiateCFF2(
+            varfont, normalizedLimits, downgrade=downgradeCFF2
+        )
 
     if "gvar" in varfont:
         instantiateGvar(varfont, normalizedLimits, optimize=optimize)
@@ -1678,19 +1780,6 @@ def instantiateVariableFont(
 
         instantiateFvar(varfont, axisLimits)
 
-    if "fvar" not in varfont:
-        if "glyf" in varfont:
-            if overlap == OverlapMode.KEEP_AND_SET_FLAGS:
-                setMacOverlapFlags(varfont["glyf"])
-            elif overlap in (OverlapMode.REMOVE, OverlapMode.REMOVE_AND_IGNORE_ERRORS):
-                from fontTools.ttLib.removeOverlaps import removeOverlaps
-
-                log.info("Removing overlaps from glyf table")
-                removeOverlaps(
-                    varfont,
-                    ignoreErrors=(overlap == OverlapMode.REMOVE_AND_IGNORE_ERRORS),
-                )
-
     if "OS/2" in varfont:
         varfont["OS/2"].recalcAvgCharWidth(varfont)
 
@@ -1703,6 +1792,25 @@ def instantiateVariableFont(
         # name table has been updated.
         setRibbiBits(varfont)
 
+    if downgradeCFF2:
+        origVarfont = varfont
+        varfont = downgradeCFF2ToCFF(varfont)
+        if inplace:
+            origVarfont.__dict__ = varfont.__dict__.copy()
+
+    if "fvar" not in varfont:
+        if overlap == OverlapMode.KEEP_AND_SET_FLAGS:
+            if "glyf" in varfont:
+                setMacOverlapFlags(varfont["glyf"])
+        elif overlap in (OverlapMode.REMOVE, OverlapMode.REMOVE_AND_IGNORE_ERRORS):
+            from fontTools.ttLib.removeOverlaps import removeOverlaps
+
+            log.info("Removing glyph outlines overlaps")
+            removeOverlaps(
+                varfont,
+                ignoreErrors=(overlap == OverlapMode.REMOVE_AND_IGNORE_ERRORS),
+            )
+
     return varfont
 
 
@@ -1809,6 +1917,12 @@ def parseArgs(args):
         default=None,
         help="Output instance TTF file (default: INPUT-instance.ttf).",
     )
+    parser.add_argument(
+        "--static",
+        dest="static",
+        action="store_true",
+        help="Make a static font: pin unspecified axes to their default location.",
+    )
     parser.add_argument(
         "--no-optimize",
         dest="optimize",
@@ -1906,13 +2020,13 @@ def main(args=None):
         recalcBBoxes=options.recalc_bounds,
     )
 
-    isFullInstance = {
+    isFullInstance = options.static or {
         axisTag
         for axisTag, limit in axisLimits.items()
         if limit is None or limit[0] == limit[2]
     }.issuperset(axis.axisTag for axis in varfont["fvar"].axes)
 
-    instantiateVariableFont(
+    varfont = instantiateVariableFont(
         varfont,
         axisLimits,
         inplace=True,
@@ -1920,6 +2034,7 @@ def main(args=None):
         overlap=options.overlap,
         updateFontNames=options.update_name_table,
         downgradeCFF2=options.downgrade_cff2,
+        static=options.static,
     )
 
     suffix = "-instance" if isFullInstance else "-partial"

fontTools/varLib/interpolatableHelpers.py

@@ -174,6 +174,9 @@ def min_cost_perfect_bipartite_matching_bruteforce(G):
     return best, best_cost
 
 
+# Prefer `scipy.optimize.linear_sum_assignment` for performance.
+# `Munkres` is also supported as a fallback for minimalistic systems
+# where installing SciPy is not feasible.
 try:
     from scipy.optimize import linear_sum_assignment