Upload render_bench.py with huggingface_hub

render_bench.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""ArShape — when does the standard Arabic rendering recipe break Arabic?
+
+Author: Syamjith NK
+
+REBUILT after the first version measured the wrong thing. Recording why, because the
+mistake is the finding.
+
+I assumed Arabic needs `arabic_reshaper` + `python-bidi` applied before drawing, and
+that plain rendering would come out disconnected. That is the advice you find
+everywhere. Rendering it proved the opposite: on a modern text stack, plain output was
+correct (مرحبا بكم) and the reshaped output was mangled (مكب ابحرم).
+
+The reason is that Pillow 12 links **Raqm/HarfBuzz**, which already performs shaping
+and the bidi algorithm. Pre-reshaping hands it text that has been shaped once and
+reordered once, and it does both again. Two rights make a wrong.
+
+So the real question is not "does Arabic need reshaping" but:
+
+    Does this rendering path ALREADY do complex-text layout?
+      yes -> reshaping breaks it
+      no  -> reshaping is required
+
+This benchmark measures that 2x2 directly, plus the font-coverage trap that bit the
+first run: SFArabic.ttf has no Latin digit glyphs, so "في عام 2026" renders the digits
+as .notdef boxes while looking perfectly fine to anyone not reading the numbers.
+"""
+import json
+from pathlib import Path
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+HERE = Path(__file__).parent
+OUT = HERE / "out"; OUT.mkdir(parents=True, exist_ok=True)
+SIZE = (900, 170)
+PT = 60
+
+FONTS = {
+    "SFArabic": "/System/Library/Fonts/SFArabic.ttf",
+    "GeezaPro": "/System/Library/Fonts/GeezaPro.ttc",
+    "IBMPlexSansArabic": str(Path.home() / "Library/Fonts/IBMPlexSansArabic-Regular.ttf"),
+}
+
+CASES = [
+    ("greeting",    "مرحبا بكم"),
+    ("sentence",    "التزامنا بالنزاهة"),
+    ("with_digits", "في عام 2026"),
+    ("mixed_latin", "شركة Pixelogik للإنتاج"),
+    ("diacritics",  "مَرْحَبًا بِكُمْ"),
+]
+
+
+def reshape(text: str) -> str:
+    import arabic_reshaper
+    from bidi.algorithm import get_display
+    return get_display(arabic_reshaper.reshape(text))
+
+
+def draw(text: str, font_path: str, engine, pre_reshape: bool) -> Image.Image:
+    if pre_reshape:
+        text = reshape(text)
+    im = Image.new("L", SIZE, 255)
+    f = ImageFont.truetype(font_path, PT, layout_engine=engine)
+    ImageDraw.Draw(im).text((SIZE[0] - 30, 45), text, font=f, fill=0, anchor="ra")
+    return im
+
+
+def ink_iou(a: Image.Image, b: Image.Image) -> float:
+    """Shape similarity, INVARIANT to where the text sits.
+
+    A raw pixel IoU compares position as well as shape, and the two layout engines
+    place glyphs a few pixels apart. That made a visually IDENTICAL rendering score
+    zero - the metric could not tell "same words, different kerning" from "different
+    words". Crop each to its ink bounding box and normalise before comparing, so this
+    measures the letterforms and not the layout offset.
+    """
+    def norm(im):
+        arr = (np.asarray(im) < 128)
+        if not arr.any():
+            return np.zeros((64, 256), dtype=bool)
+        ys, xs = np.where(arr)
+        crop = Image.fromarray((~arr[ys.min():ys.max() + 1, xs.min():xs.max() + 1]).astype(np.uint8) * 255)
+        return np.asarray(crop.resize((256, 64), Image.LANCZOS)) < 128
+    x, y = norm(a), norm(b)
+    u = (x | y).sum()
+    return float((x & y).sum() / u) if u else 1.0
+
+
+def missing_glyphs(text: str, font_path: str) -> list[str]:
+    """Characters the font has no glyph for. These render as .notdef boxes and are
+    invisible to anyone skim-reading the language they DO know."""
+    try:
+        from fontTools.ttLib import TTFont, TTCollection
+        f = (TTCollection(font_path).fonts[0] if font_path.endswith(".ttc")
+             else TTFont(font_path, fontNumber=0))
+        cmap = set()
+        for t in f["cmap"].tables:
+            cmap |= set(t.cmap.keys())
+        return [c for c in dict.fromkeys(text) if c.strip() and ord(c) not in cmap]
+    except Exception:
+        return []
+
+
+RAQM = ImageFont.Layout.RAQM
+BASIC = ImageFont.Layout.BASIC
+
+PATHS = {
+    "raqm_plain":       (RAQM,  False),   # modern stack, text passed through as-is
+    "raqm_reshaped":    (RAQM,  True),    # modern stack + the legacy recipe
+    "basic_plain":      (BASIC, False),   # no complex-text layout, no recipe
+    "basic_reshaped":   (BASIC, True),    # no complex-text layout + the recipe
+}
+
+if __name__ == "__main__":
+    rows = []
+    for fname, fpath in FONTS.items():
+        if not Path(fpath).exists():
+            print(f"  (skipping {fname}: not installed)"); continue
+        for cid, text in CASES:
+            # Ground truth: raqm_plain, verified BY EYE in the first run. Everything
+            # is measured against it, and the contact sheet lets a human re-check.
+            ref = draw(text, fpath, RAQM, False)
+            miss = missing_glyphs(text, fpath)
+            for pname, (engine, pre) in PATHS.items():
+                im = draw(text, fpath, engine, pre)
+                im.save(OUT / f"{fname}__{cid}__{pname}.png")
+                iou = ink_iou(im, ref)
+                rows.append({"font": fname, "case": cid, "text": text, "path": pname,
+                             "iou_vs_reference": round(iou, 3),
+                             # Three bands, not a pass/fail. Antialiasing across two
+                             # layout engines means even a visually identical render
+                             # will not reach 0.97, and a single threshold hid the
+                             # most interesting result: the legacy recipe RECOVERS
+                             # plain Arabic but still fails on digits, Latin runs and
+                             # diacritics, because those need real shaping regardless.
+                             "verdict": ("identical" if iou > 0.95 else
+                                         "recognisable" if iou > 0.60 else "broken"),
+                             "missing_glyphs": miss})
+    (HERE / "results.jsonl").write_text(
+        "\n".join(json.dumps(r, ensure_ascii=False) for r in rows) + "\n")
+
+    print(f"\n{'path':17}{'identical':>11}{'recognisable':>14}{'broken':>9}   per-case IoU")
+    for pname in PATHS:
+        sub = [r for r in rows if r["path"] == pname]
+        c = {v: sum(1 for r in sub if r["verdict"] == v)
+             for v in ("identical", "recognisable", "broken")}
+        ious = [f"{r['iou_vs_reference']:.2f}" for r in sub if r["font"] == "IBMPlexSansArabic"]
+        print(f"{pname:17}{c['identical']:>11}{c['recognisable']:>14}{c['broken']:>9}   {' '.join(ious)}")
+    print("\n  (per-case order: greeting · sentence · with_digits · mixed_latin · diacritics)")
+
+    print("\nfont coverage traps:")
+    seen = set()
+    for r in rows:
+        if r["missing_glyphs"] and (r["font"], r["case"]) not in seen:
+            seen.add((r["font"], r["case"]))
+            print(f"  {r['font']:20}{r['case']:13} cannot render: {' '.join(r['missing_glyphs'])}")
+    if not seen:
+        print("  none")