"""Post-normalization original glyphs and their public/optical routes. All source acquisition belongs to catalog/outlines/metrics, not this module. """ from collections import defaultdict from copy import deepcopy from fontTools.pens.boundsPen import BoundsPen from fontTools.pens.t2CharStringPen import T2CharStringPen from fontTools.ttLib.tables.otBase import ValueRecord import declarations import mapping as U import metrics import substitution from config import identity as font_identity from font_geometry import ( _copy_shift, _set_charstring, aggregate_values, math_add, update_average_width, ) from mapping import bold_identities from math_tables import copy_math_attributes from positioning import append_pairs from substitution import insert_routes, ssty_index, ssty_mapping, validate_gsub AMS_SYMBOLS = ((10003, 88, "checkmark"), (10016, 122, "maltese")) AMS_STYLES = (("T", "mt2syat"), ("S", "mt2syas"), ("SS", "mt2syaf")) def add_ams_glyphs(f, sources): original = list(f.getGlyphOrder()) if "CFF " not in f: raise ValueError("append requires CFF OTF") names = [ label + ("" if i == 0 else ".ssty" + str(i)) for _, _, label in AMS_SYMBOLS for i in range(3) ] if set(names) & set(original): raise ValueError("appended glyph name collision") if any( (cp in st.cmap for st in f["cmap"].tables for cp, _, _ in AMS_SYMBOLS) ): raise ValueError("Unicode collision or repeated append") unicodes = [st for st in f["cmap"].tables if st.isUnicode()] if not unicodes or any((st.format not in (4, 12) for st in unicodes)): raise ValueError("unsupported Unicode cmap structure") ssty = ssty_mapping(f) gi = f["MATH"].table.MathGlyphInfo for name in names: if name in ssty: raise ValueError("ssty collision") if ( gi.MathItalicsCorrectionInfo is None or gi.MathTopAccentAttachment is None ): raise ValueError("MATH value tables missing") top = f["CFF "].cff.topDictIndex[0] for cp, slot, label in AMS_SYMBOLS: optical = [] for i, (style, stem) in enumerate(AMS_STYLES): t1, tfm = sources[stem] if slot not in tfm.chars: raise ValueError("source slot missing") source_name = t1["Encoding"][slot] if source_name == ".notdef" or source_name not in t1.getGlyphSet(): raise ValueError("AMS_SYMBOLS source Encoding slot missing") glyph = t1.getGlyphSet()[source_name] m = tfm.chars[slot] width = round(1000 * m["width"]) ic = round(1000 * m.get("italic", 0)) accent = round((width + ic) / 2) name = label + ("" if i == 0 else ".ssty" + str(i)) optical.append(name) pen = T2CharStringPen( width - top.Private.nominalWidthX, t1.getGlyphSet() ) glyph.draw(pen) char = pen.getCharString( private=top.Private, globalSubrs=f["CFF "].cff.GlobalSubrs ) top.CharStrings.charStrings[name] = len( top.CharStrings.charStringsIndex ) top.CharStrings.charStringsIndex.items.append(char) top.charset.append(name) bounds = BoundsPen(t1.getGlyphSet()) glyph.draw(bounds) f["hmtx"].metrics[name] = ( width, round(bounds.bounds[0] if bounds.bounds else 0), ) f.setGlyphOrder(list(top.charset)) math_add(f, name, ic, accent) ssty[optical[0]] = optical[1:] for st in unicodes: st.cmap[cp] = optical[0] f["maxp"].numGlyphs = len(f.getGlyphOrder()) update_average_width(f) ALTERNATE_STYLES = ("text", "script", "scriptscript") def add_optical_alternates(f, cache, mf, ledger): if "CFF " not in f: raise ValueError("alternate append requires completed CFF OTF") top = f["CFF "].cff.topDictIndex[0] # Decompile MATH before modifying the glyph set. f["MATH"].table.MathGlyphInfo for route in ledger: if ( tuple((s["style"] for s in route["source_styles"])) != ALTERNATE_STYLES ): raise ValueError("alternate style order differs") for i, style in enumerate(route["source_styles"]): alt = style["alternate"] stem = alt["font"] tag = alt["tag"] slot = int(alt["slot"]) if declarations.SOURCE_FONTS.get(tag) != stem: raise ValueError("alternate source family mismatch") pf, tf = cache[stem] sn = pf["Encoding"][slot] if ( sn == ".notdef" or sn not in pf.getGlyphSet() or slot not in tf.chars ): raise ValueError("alternate Type1 slot mismatch") m = tf.chars[slot] skewchar = mf["skewchar_by_tag"][tag] skew = ( tf.kerning.get(slot, {}).get(skewchar, 0) if skewchar is not None else 0 ) if alt["accent_calibration"]["skewchar"] != skewchar: raise ValueError("alternate skew policy mismatch") width = round(1000 * m["width"]) ic = round(1000 * m.get("italic", 0)) accent = round( 1000 * ((m["width"] + m.get("italic", 0)) / 2 + skew) ) name = ( "diagnostic." + route["semantic_id"].replace(".", "_") + "." + style["style"] ) if name in top.CharStrings.charStrings: raise ValueError("alternate identity collision") glyph = pf.getGlyphSet()[sn] pen = T2CharStringPen( width - top.Private.nominalWidthX, pf.getGlyphSet() ) glyph.draw(pen) char = pen.getCharString( private=top.Private, globalSubrs=f["CFF "].cff.GlobalSubrs ) top.CharStrings.charStrings[name] = len( top.CharStrings.charStringsIndex.items ) top.CharStrings.charStringsIndex.items.append(char) top.charset.append(name) f.setGlyphOrder(list(top.charset)) bp = BoundsPen(pf.getGlyphSet()) glyph.draw(bp) f["hmtx"][name] = (width, round(bp.bounds[0])) math_add(f, name, ic, accent) f["maxp"].numGlyphs = len(f.getGlyphOrder()) update_average_width(f) AMS_ALTERNATE_STYLES = ( ("T", "ams", "mt2syat"), ("S", "ams_s", "mt2syas"), ("SS", "ams_ss", "mt2syaf"), ) AMS_ALTERNATE_SYMBOLS = ( (165, 85, "yen", "cv18"), (174, 114, "registered", "cv19"), ) def ams_alternates_identities(): return [ dict( Unicode_input=cp, tag=tag, slot=slot, style=style, source=stem, source_role=role, output_glyph="original.ams." + label + "." + style, ) for cp, slot, label, tag in AMS_ALTERNATE_SYMBOLS for style, role, stem in AMS_ALTERNATE_STYLES ] def ams_alternates_precheck(font): if ( "CFF " not in font or font["head"].unitsPerEm != 1000 or font["name"].getDebugName(6) != font_identity("full")[1] ): raise ValueError("AMS alternates require Full 1000-UPM CFF OTF") if any( ( n.startswith(("original.ams.yen.", "original.ams.registered.")) for n in font.getGlyphOrder() ) ): raise ValueError("AMS alternate namespace collision/repeated append") gs = font["GSUB"].table if any( ( r.FeatureTag in {s[3] for s in AMS_ALTERNATE_SYMBOLS} for r in gs.FeatureList.FeatureRecord ) ): raise ValueError("AMS alternate feature collision/repeated append") validate_gsub(gs) index = ssty_index(gs) cmap = font.getBestCmap() if ( any((cp not in cmap for cp, _, _, _ in AMS_ALTERNATE_SYMBOLS)) or cmap[165] == cmap[174] ): raise ValueError( "two distinct existing yen/registered cmap owners required" ) info = font["MATH"].table.MathGlyphInfo if ( info.MathItalicsCorrectionInfo is None or info.MathTopAccentAttachment is None ): raise ValueError("AMS alternate MATH IC/TopAccent tables required") return index def add_ams_alternates(f, cache): index = ams_alternates_precheck(f) top = f["CFF "].cff.topDictIndex[0] rows = [] for identity in ams_alternates_identities(): pf, tf = cache[identity["source"]] slot = identity["slot"] sn = pf["Encoding"][slot] if ( slot not in tf.chars or sn == ".notdef" or sn not in pf.getGlyphSet() ): raise ValueError("AMS alternate original slot missing") m = tf.chars[slot] width = round(1000 * m["width"]) corr = round(1000 * m.get("italic", 0)) accent = round((width + corr) / 2) bp = BoundsPen(pf.getGlyphSet()) pf.getGlyphSet()[sn].draw(bp) if bp.bounds is None: raise ValueError("empty AMS alternate original outline") name = identity["output_glyph"] pen = T2CharStringPen( width - top.Private.nominalWidthX, pf.getGlyphSet() ) pf.getGlyphSet()[sn].draw(pen) char = pen.getCharString( private=top.Private, globalSubrs=f["CFF "].cff.GlobalSubrs ) top.CharStrings.charStrings[name] = len( top.CharStrings.charStringsIndex.items ) top.CharStrings.charStringsIndex.items.append(char) top.charset.append(name) f.setGlyphOrder(list(top.charset)) f["hmtx"][name] = (width, round(bp.bounds[0])) math_add(f, name, corr, accent) rows.append(identity) for offset, (_, _, _, tag) in enumerate(AMS_ALTERNATE_SYMBOLS): selected = [row for row in rows if row["tag"] == tag] insert_routes(f, selected, index + offset, tag=tag) f["maxp"].numGlyphs = len(f.getGlyphOrder()) agg = aggregate_values(f) top.FontBBox = agg["FontBBox"] for k, v in zip(("xMin", "yMin", "xMax", "yMax"), agg["head_bbox"]): setattr(f["head"], k, v) for k, v in agg["hhea"].items(): setattr(f["hhea"], k, v) update_average_width(f) BOLD_MATH_FIELDS = ( ( "MathItalicsCorrectionInfo", "Coverage", "ItalicsCorrection", "ItalicsCorrectionCount", ), ( "MathTopAccentAttachment", "TopAccentCoverage", "TopAccentAttachment", "TopAccentAttachmentCount", ), ) def mbf_precheck(font): if "CFF " not in font or font["head"].unitsPerEm != 1000: raise ValueError("mbf186 requires CFF1 OTF at 1000 UPM") top = font["CFF "].cff.topDictIndex[0] if tuple(top.FontMatrix) != (0.001, 0, 0, 0.001, 0, 0): raise ValueError("unsupported output CFF FontMatrix") if not top.CharStrings.charStringsAreIndexed or hasattr(top, "FDArray"): raise ValueError("unsupported CFF charstring/CID structure") names = [r["output_glyph"] for r in bold_identities()] existing = set(font.getGlyphOrder()) overlap = sorted(existing & set(names)) if overlap: raise ValueError( "mbf glyph collision/repeated append: " + ", ".join(overlap[:3]) ) if any((n.startswith("original.mbf.") for n in existing)): raise ValueError("partial mbf glyph namespace collision") gs = font["GSUB"].table validate_gsub(gs) index = ssty_index(gs) cmap = font.getBestCmap() cps = {r["Unicode_input"] for r in bold_identities()} if not cps <= set(cmap) or len({cmap[c] for c in cps}) != 62: raise ValueError( "62 distinct existing mathematical bold cmap owners required" ) gi = font["MATH"].table.MathGlyphInfo if any( (getattr(gi, field) is None for field, _, _, _ in BOLD_MATH_FIELDS) ): raise ValueError("MATH IC/TopAccent tables required") return index def add_original_bold(font, cache, mf, edition): mbf_precheck(font) expected_name = font_identity(edition)[1] if font["name"].getDebugName(6) != expected_name: raise ValueError("font edition mismatch") top = font["CFF "].cff.topDictIndex[0] rows = [] for identity in bold_identities(): stem = identity["source_face"] slot = identity["source_slot"] role = identity["source_role"] pf, tfm = cache[stem] if slot not in tfm.chars: raise ValueError("mbf TFM slot missing: " + identity["source_id"]) source_name = pf["Encoding"][slot] if source_name == ".notdef" or source_name not in pf.getGlyphSet(): raise ValueError( "mbf PFB Encoding slot missing: " + identity["source_id"] ) metrics = tfm.chars[slot] width = metrics["width"] italic = metrics.get("italic", 0) skew = tfm.kerning.get(slot, {}).get(mf["skewchar_by_tag"][role], 0) if any( ( float(v) * (1 << 20) != int(float(v) * (1 << 20)) for v in (width, italic, skew) ) ): raise ValueError( "binary TFM metric is not an exact fix_word fraction" ) advance = round(1000 * width) ic = round(1000 * italic) accent = round(1000 * ((width + italic) / 2 + skew)) glyphs = pf.getGlyphSet() glyph = glyphs[source_name] source_bounds = BoundsPen(glyphs) glyph.draw(source_bounds) if source_bounds.bounds is None: raise ValueError( "empty mbf source outline: " + identity["source_id"] ) # T2 width operand is relative to the existing Private # nominalWidthX. pen = T2CharStringPen(advance - top.Private.nominalWidthX, glyphs) glyph.draw(pen) char = pen.getCharString( private=top.Private, globalSubrs=font["CFF "].cff.GlobalSubrs ) name = identity["output_glyph"] top.CharStrings.charStrings[name] = len( top.CharStrings.charStringsIndex.items ) top.CharStrings.charStringsIndex.items.append(char) top.charset.append(name) font.setGlyphOrder(list(top.charset)) bp = BoundsPen(font.getGlyphSet()) char.draw(bp) if bp.bounds is None or char.width != advance: raise ValueError("new CFF outline/decoded width mismatch") font["hmtx"][name] = (advance, round(bp.bounds[0])) math_add(font, name, ic, accent) rows.append(identity) grouped = {} for row in rows: grouped.setdefault(row["Unicode_input"], {})[row["style"]] = row[ "output_glyph" ] optical = ssty_mapping(font) optical.update({v["T"]: [v["S"], v["SS"]] for v in grouped.values()}) font["maxp"].numGlyphs = len(font.getGlyphOrder()) agg = aggregate_values(font) top.FontBBox = agg["FontBBox"] for k, v in zip(("xMin", "yMin", "xMax", "yMax"), agg["head_bbox"]): setattr(font["head"], k, v) for k, v in agg["hhea"].items(): setattr(font["hhea"], k, v) update_average_width(font) def source_info(face, slot, skew): p, tf = face.font, face.raw_metrics() name = p["Encoding"][slot] m = tf.chars.get(slot) present = name != ".notdef" and name in p["CharStrings"] and m is not None fix = metrics.read_kerns_fix20(face.tfm_path) return dict( role=face.role, slot=slot, pfb=face.pfb_path.name, tfm=face.tfm_path.name, encoding_name=name, present=present, width=round(1000 * m["width"]) if m else None, IC=round(1000 * m.get("italic", 0)) if m else None, skewchar=skew, skew_fix20=fix.get((slot, skew), 0), TopAccent=round( 1000 * ( (m["width"] + m.get("italic", 0)) / 2 + fix.get((slot, skew), 0) / (1 << 20) ) ) if m else None, ) def split_bars(font, ss): cmap = font.getBestCmap() aliases, clones, records = {}, {}, [] for oldcp, newcp in [(0x007C, 0x2223), (0x2016, 0x2225)]: source = cmap[oldcp] if cmap[newcp] != source: raise ValueError("relation bars already split; do not apply twice") forms = [source, *ss[source]] new = [f"uni{newcp:04X}" + s for s in ("", ".ssty1", ".ssty2")] aliases[source] = [ f"U+{cp:04X}" for cp, n in cmap.items() if n == source ] for a, b in zip(forms, new): _copy_shift(font, a, b) font["hmtx"][b] = font["hmtx"][a] copy_math_attributes(font, a, b) clones[a] = b ss[new[0]] = new[1:] mv = font["MATH"].table.MathVariants for direction in ("Vert", "Horiz"): cov = getattr(mv, direction + "GlyphCoverage") cs = getattr(mv, direction + "GlyphConstruction") for a, b in zip(forms, new): if a in cov.glyphs: cs.append(deepcopy(cs[cov.glyphs.index(a)])) cov.glyphs.append(b) setattr(mv, direction + "GlyphCount", len(cov.glyphs)) for table in font["cmap"].tables: if table.isUnicode() and newcp in table.cmap: table.cmap[newcp] = new[0] records.append( dict( Unicode=f"U+{newcp:04X}", old=forms, new=new, original_aliases=aliases[source], growth="copied constructions; existing internal glyphs shared", ) ) pairs = {} for lookup in font["GPOS"].table.LookupList.Lookup: for sub in lookup.SubTable: st = getattr(sub, "ExtSubTable", sub) if not hasattr(st, "PairSet"): raise ValueError("unsupported GPOS during bar split") for a, ps in zip(st.Coverage.glyphs, st.PairSet): for pv in ps.PairValueRecord: b = pv.SecondGlyph for na in [a] + ([clones[a]] if a in clones else []): for nb in [b] + ([clones[b]] if b in clones else []): if (na, nb) != (a, b): pairs[na, nb] = ( deepcopy(pv.Value1), deepcopy(pv.Value2), ) append_pairs(font, pairs) return records, len(pairs) def build_relations(font, catalog, snapshot, ab_report): edition = catalog.edition source_map = { (r["role"], r["slot"]): r["glyph"] for r in ab_report["source_glyphs"] if r["glyph"] in font.getGlyphOrder() } ss = substitution.ssty_mapping(font) bars, cloned_pairs = split_bars(font, ss) cmap = font.getBestCmap() maps = defaultdict(dict) routes, sources, imported = [], [], [] new_names = set() def source(role, slot, glyph): face = catalog.faces[role] info = source_info(face, slot, snapshot["skewchar_by_tag"].get(role)) if not info["present"]: raise ValueError( "adopted source slot missing: " + role + ":" + str(slot) ) sources.append(dict(info, glyph=glyph)) return info def import_source(role, slot): if (role, slot) in source_map: return source_map[role, slot] # Glyph identifiers are independent of public feature tags. n = f"cv22.{U.SOURCE_FONTS[role]}.s{slot:03d}" info = source(role, slot, n) face = catalog.faces[role] glyphs = face.font.getGlyphSet() _set_charstring( font, n, glyphs[info["encoding_name"]].draw, info["width"] ) math_add(font, n, info["IC"], info["TopAccent"]) source_map[role, slot] = n new_names.add(n) imported.append(dict(info, glyph=n)) return n for tag, cp, target, role, slot, boldcp in U.RELATION_ROWS: if role == "ams" and edition == "lite": continue if cp not in cmap or target not in font.getGlyphOrder(): raise ValueError("adopted base input/target absent") inputs = [cmap[cp], *ss[cmap[cp]]] targets = [target, *ss[target]] for level, (a, b) in enumerate(zip(inputs, targets)): maps[tag][a] = b info = source(role + U.RELATION_SUFFIX[level], slot, b) source_map[role + U.RELATION_SUFFIX[level], slot] = b routes.append( dict( tag=tag, Unicode=f"U+{cp:04X}", level=level, input=a, output=b, bold=False, role=info["role"], slot=slot, ) ) if boldcp is not None and edition == "full": targets = [ import_source("bmit" + s, slot) for s in U.RELATION_SUFFIX ] ss[targets[0]] = targets[1:] inputs = [cmap[boldcp], *ss[cmap[boldcp]]] for level, (a, b) in enumerate(zip(inputs, targets)): maps[tag][a] = b routes.append( dict( tag=tag, Unicode=f"U+{boldcp:04X}", level=level, input=a, output=b, bold=True, role="bmit" + U.RELATION_SUFFIX[level], slot=slot, ) ) pair_values, new_kerns = {}, [] for role in ( ["bmit" + s for s in U.RELATION_SUFFIX] if edition == "full" else [] ): skew = snapshot["skewchar_by_tag"][role] face = catalog.faces[role] for (left, right), fix in metrics.read_kerns_fix20( face.tfm_path ).items(): if ( right == skew or (role, left) not in source_map or (role, right) not in source_map ): continue a, b = source_map[role, left], source_map[role, right] value = round(1000 * fix / (1 << 20)) if not value or not ({a, b} & new_names): continue val = ValueRecord() val.XAdvance = value pair_values[a, b] = (val, None) new_kerns.append( dict( role=role, left_slot=left, right_slot=right, left_glyph=a, right_glyph=b, xadvance=value, source_fix20=fix, ) ) append_pairs(font, pair_values) new_tags = tuple(dict.fromkeys( tag for tag, *_ in U.RELATION_ROWS if tag != "cv10" )) substitution.install_maps(font, maps, new_tags=new_tags) font["maxp"].numGlyphs = len(font.getGlyphOrder()) return dict( edition=edition, feature_tags=sorted(maps), split_bars=bars, cloned_bar_pairs=cloned_pairs, routes=routes, sources=sources, imported=imported, new_source_kerns=new_kerns, physical_deletion=False, bold_cards=( "bsyt slots129/131 exist; no distinct standard " "bold Unicode input; not imported" ), AMS_bold=( "mt2bsya/mt2hsya exist; no distinct standard " "bold/heavy Unicode inputs for these " "relations; not imported" ), ) def bind_unicode(font, catalog): edition = catalog.edition if edition not in ("full", "lite"): raise ValueError("unknown edition") ss = substitution.ssty_mapping(font) report = [] for cp, command, glyph, role, slot in U.STANDARD_UNICODE_ROUTES: if edition == "lite" and role == "ams": continue forms = [glyph, *ss.get(glyph, ())] if len(forms) != 3 or any( n not in font.getGlyphOrder() for n in forms ): raise ValueError("existing T/S/SS family missing: " + glyph) tables = [t for t in font["cmap"].tables if t.isUnicode()] if not tables or any(t.format not in (4, 12) for t in tables): raise ValueError("unsupported Unicode cmap structure") if any(cp in t.cmap for t in tables): raise ValueError( "standard entrance already present; refuse overwrite" ) for table in tables: table.cmap[cp] = glyph report.append( dict( Unicode=f"U+{cp:04X}", command="\\" + command, glyph=glyph, forms=forms, role=role, slot=slot, Unicode_subtables=len(tables), new_glyphs=0, ) ) # LuaTeX aligns nucleus and overlay TopAccentAttachment values. The # original zero-width slash has positive x coordinates: retain its # outline and advance, and attach at the geometric ink center. root = font.getBestCmap()[0x0338] forms = [root, *ss[root]] if len(forms) != 3: raise ValueError("overlay T/S/SS source family missing") table = font["MATH"].table.MathGlyphInfo.MathTopAccentAttachment attachments = dict( zip(table.TopAccentCoverage.glyphs, table.TopAccentAttachment) ) glyphs = font.getGlyphSet() classes = font["GDEF"].table.GlyphClassDef.classDefs overlay = [] for name in forms: pen = BoundsPen(glyphs) glyphs[name].draw(pen) x0, y0, x1, y1 = pen.bounds if font["hmtx"][name][0] != 0: raise ValueError("original overlay advance must remain zero") value = round((x0 + x1) / 2) before = attachments[name].Value attachments[name].Value = value classes[name] = 3 overlay.append( dict( glyph=name, bbox=pen.bounds, attachment_before=before, attachment=value, ) ) tie = font.getBestCmap()[0x0361] tie_forms = [tie, *ss[tie]] if len(tie_forms) != 3: raise ValueError("tie T/S/SS source family missing") tie_metrics = [] for name, role in zip(tie_forms, ("syt", "syt_s", "syt_ss")): face = catalog.faces[role] raw = face.raw_metrics().chars[65] skew = catalog.declarations.skewchar_by_tag.get(role) kern = metrics.read_kerns_fix20(face.tfm_path).get((65, skew), 0) # Use raw source arithmetic for this protected combining mark. value = round( 1000 * (raw.get("width", 0) + raw.get("italic", 0)) / 2 + 1000 * kern / (1 << 20) ) attachments[name].Value = value classes[name] = 3 tie_metrics.append( dict( glyph=name, source=role, slot=65, advance=font["hmtx"][name][0], attachment=value, ) ) return dict( edition=edition, additions=report, overlay=overlay, tie_source_metrics_preserved=tie_metrics, physical_deletion=False, outlines_unchanged=True, advances_unchanged=True, GPOS_unchanged=True, )