| |
| """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), |
| "raqm_reshaped": (RAQM, True), |
| "basic_plain": (BASIC, False), |
| "basic_reshaped": (BASIC, True), |
| } |
|
|
| 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: |
| |
| |
| 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), |
| |
| |
| |
| |
| |
| |
| "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") |
|
|
