fonttools 4.59.1__cp310-cp310-win_amd64.whl → 4.60.0__cp310-cp310-win_amd64.whl

fontTools/varLib/__init__.py

@@ -30,7 +30,11 @@ from fontTools.misc.fixedTools import floatToFixed as fl2fi
 from fontTools.misc.textTools import Tag, tostr
 from fontTools.ttLib import TTFont, newTable
 from fontTools.ttLib.tables._f_v_a_r import Axis, NamedInstance
-from fontTools.ttLib.tables._g_l_y_f import GlyphCoordinates, dropImpliedOnCurvePoints
+from fontTools.ttLib.tables._g_l_y_f import (
+    GlyphCoordinates,
+    dropImpliedOnCurvePoints,
+    USE_MY_METRICS,
+)
 from fontTools.ttLib.tables.ttProgram import Program
 from fontTools.ttLib.tables.TupleVariation import TupleVariation
 from fontTools.ttLib.tables import otTables as ot
@@ -489,6 +493,77 @@ def _merge_TTHinting(font, masterModel, master_ttfs):
         cvar.variations = variations
 
 
+def _has_inconsistent_use_my_metrics_flag(
+    master_glyf, glyph_name, flagged_components, expected_num_components
+) -> bool:
+    master_glyph = master_glyf.get(glyph_name)
+    # 'sparse' glyph master doesn't contribute. Besides when components don't match
+    # the VF build is going to fail anyway, so be lenient here.
+    if (
+        master_glyph is not None
+        and master_glyph.isComposite()
+        and len(master_glyph.components) == expected_num_components
+    ):
+        for i, base_glyph in flagged_components:
+            comp = master_glyph.components[i]
+            if comp.glyphName != base_glyph:
+                break
+            if not (comp.flags & USE_MY_METRICS):
+                return True
+    return False
+
+
+def _unset_inconsistent_use_my_metrics_flags(vf, master_fonts):
+    """Clear USE_MY_METRICS on composite components if inconsistent across masters.
+
+    If a composite glyph's component has USE_MY_METRICS set differently among
+    the masters, the flag is removed from the variable font's glyf table so that
+    advance widths are not determined by that single component's phantom points.
+    """
+    glyf = vf["glyf"]
+    master_glyfs = [m["glyf"] for m in master_fonts if "glyf" in m]
+    if not master_glyfs:
+        # Should not happen: at least the base master (as copied into vf) has glyf
+        return
+
+    for glyph_name in glyf.keys():
+        glyph = glyf[glyph_name]
+        if not glyph.isComposite():
+            continue
+
+        # collect indices of component(s) that carry the USE_MY_METRICS flag.
+        # This is supposed to be 1 component per composite, but you never know.
+        flagged_components = [
+            (i, comp.glyphName)
+            for i, comp in enumerate(glyph.components)
+            if (comp.flags & USE_MY_METRICS)
+        ]
+        if not flagged_components:
+            # Nothing to fix
+            continue
+
+        # Verify that for all master glyf tables that contribute this glyph, the
+        # corresponding component (same glyphName and index) also carries USE_MY_METRICS
+        # and unset the flag if not.
+        expected_num_components = len(glyph.components)
+        if any(
+            _has_inconsistent_use_my_metrics_flag(
+                master_glyf, glyph_name, flagged_components, expected_num_components
+            )
+            for master_glyf in master_glyfs
+        ):
+            comp_names = [name for _, name in flagged_components]
+            log.info(
+                "Composite glyph '%s' has inconsistent USE_MY_METRICS flags across "
+                "masters; clearing the flag on component%s %s",
+                glyph_name,
+                "s" if len(comp_names) > 1 else "",
+                comp_names if len(comp_names) > 1 else comp_names[0],
+            )
+            for i, _ in flagged_components:
+                glyph.components[i].flags &= ~USE_MY_METRICS
+
+
 _MetricsFields = namedtuple(
     "_MetricsFields",
     [
@@ -1205,6 +1280,10 @@ def build(
     if "DSIG" in vf:
         del vf["DSIG"]
 
+    # Clear USE_MY_METRICS composite flags if set inconsistently across masters.
+    if "glyf" in vf:
+        _unset_inconsistent_use_my_metrics_flags(vf, master_fonts)
+
     # TODO append masters as named-instances as well; needs .designspace change.
     fvar = _add_fvar(vf, ds.axes, ds.instances)
     if "STAT" not in exclude:

fontTools/varLib/avar/__main__.py

@@ -0,0 +1,72 @@
+import logging
+
+log = logging.getLogger("fontTools.varLib.avar")
+
+
+def main(args=None):
+    from fontTools.ttLib import TTFont
+    from fontTools.misc.cliTools import makeOutputFileName
+    from fontTools import configLogger
+    import argparse
+    import sys
+
+    print(
+        "WARNING: This script is deprecated. Use `fonttools varLib.avar.build` "
+        "or `fonttools varLib.avar.unbuild` instead.\n",
+        file=sys.stderr,
+    )
+
+    if args is None:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.avar",
+        description="Add `avar` table from designspace file to variable font.",
+    )
+    parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
+    parser.add_argument(
+        "designspace",
+        metavar="family.designspace",
+        help="Designspace file.",
+        nargs="?",
+        default=None,
+    )
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        type=str,
+        help="Output font file name.",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+
+    options = parser.parse_args(args)
+
+    configLogger(level=("INFO" if options.verbose else "WARNING"))
+
+    font = TTFont(options.font)
+
+    if options.designspace is None:
+        from .unbuild import unbuild
+
+        unbuild(font)
+        return 0
+
+    from .build import build
+
+    build(font, options.designspace)
+
+    if options.output_file is None:
+        outfile = makeOutputFileName(options.font, overWrite=True, suffix=".avar")
+    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/avar/build.py

@@ -0,0 +1,79 @@
+from fontTools.varLib import _add_fvar, _add_avar, load_designspace
+from fontTools.ttLib import newTable
+import logging
+
+log = logging.getLogger("fontTools.varLib.avar")
+
+
+def build(font, designspace_file):
+    ds = load_designspace(designspace_file, require_sources=False)
+
+    if not "fvar" in font:
+        # if "name" not in font:
+        font["name"] = newTable("name")
+        _add_fvar(font, ds.axes, ds.instances)
+
+    axisTags = [a.axisTag for a in font["fvar"].axes]
+
+    if "avar" in font:
+        log.warning("avar table already present, overwriting.")
+        del font["avar"]
+
+    _add_avar(font, ds.axes, ds.axisMappings, axisTags)
+
+
+def main(args=None):
+    """Add `avar` table from designspace file to variable font."""
+
+    from fontTools.ttLib import TTFont
+    from fontTools.misc.cliTools import makeOutputFileName
+    from fontTools import configLogger
+    import argparse
+
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.avar.build",
+        description="Add `avar` table from designspace file to variable font.",
+    )
+    parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
+    parser.add_argument(
+        "designspace",
+        metavar="family.designspace",
+        help="Designspace file.",
+        default=None,
+    )
+    parser.add_argument(
+        "-o",
+        "--output-file",
+        type=str,
+        help="Output font file name.",
+    )
+    parser.add_argument(
+        "-v", "--verbose", action="store_true", help="Run more verbosely."
+    )
+
+    options = parser.parse_args(args)
+
+    configLogger(level=("INFO" if options.verbose else "WARNING"))
+
+    font = TTFont(options.font)
+
+    build(font, options.designspace)
+
+    if options.output_file is None:
+        outfile = makeOutputFileName(options.font, overWrite=True, suffix=".avar")
+    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/avar/map.py

@@ -0,0 +1,108 @@
+from fontTools.varLib.models import normalizeValue
+
+
+def _denormalize(v, triplet):
+    if v >= 0:
+        return triplet[1] + v * (triplet[2] - triplet[1])
+    else:
+        return triplet[1] + v * (triplet[1] - triplet[0])
+
+
+def map(
+    font, location, *, inputNormalized=False, outputNormalized=False, dropZeroes=False
+):
+    if "fvar" not in font:
+        return None
+
+    fvar = font["fvar"]
+    axes = {a.axisTag: (a.minValue, a.defaultValue, a.maxValue) for a in fvar.axes}
+
+    if not inputNormalized:
+        location = {
+            tag: normalizeValue(value, axes[tag]) for tag, value in location.items()
+        }
+
+    if "avar" in font:
+        location = font["avar"].renormalizeLocation(location, font, dropZeroes)
+
+    if not outputNormalized:
+        location = {
+            tag: _denormalize(value, axes[tag]) for tag, value in location.items()
+        }
+
+    return location
+
+
+def main(args=None):
+    """Map variation coordinates through the `avar` table."""
+
+    from fontTools.ttLib import TTFont
+    import argparse
+
+    if args is None:
+        import sys
+
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        "fonttools varLib.avar.map",
+        description="Map variation coordinates through the `avar` table.",
+    )
+    parser.add_argument("font", metavar="varfont.ttf", help="Variable-font file.")
+    parser.add_argument(
+        "coords",
+        metavar="[AXIS=value...]",
+        help="Coordinates to map, e.g. 'wght=700 wdth=75'.",
+        nargs="*",
+        default=None,
+    )
+    parser.add_argument(
+        "-f", action="store_true", help="Do not omit axes at default location."
+    )
+    parser.add_argument(
+        "-i", action="store_true", help="Input coordinates are normalized (-1..1)."
+    )
+    parser.add_argument(
+        "-o", action="store_true", help="Output coordinates as normalized (-1..1)."
+    )
+
+    options = parser.parse_args(args)
+
+    if not options.coords:
+        parser.error(
+            "No coordinates provided. Please specify at least one axis coordinate (e.g., wght=500)"
+        )
+
+    if options.font.endswith(".designspace"):
+        from .build import build
+
+        font = TTFont()
+        build(font, options.font)
+    else:
+        font = TTFont(options.font)
+        if "fvar" not in font:
+            parser.error(f"Font '{options.font}' does not contain an 'fvar' table.")
+
+    location = {
+        tag: float(value) for tag, value in (item.split("=") for item in options.coords)
+    }
+
+    mapped = map(
+        font,
+        location,
+        inputNormalized=options.i,
+        outputNormalized=options.o,
+        dropZeroes=not options.f,
+    )
+    assert mapped is not None
+
+    for tag in mapped:
+        v = mapped[tag]
+        v = int(v) if v == int(v) else v
+        print(f"{tag}={v:g}")
+
+
+if __name__ == "__main__":
+    import sys
+
+    sys.exit(main())