#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ render_single_chars.py — render a list of Chinese characters into a "one image per character" evaluation image set. Core features 1. Multi-font-plane routing: look up the cmap of each font in order and use the first font that covers the character; 2. Adaptive scaling: shrink the font size when the glyph overflows the canvas, keeping it centered (anchor=mm); 3. Blank-glyph guard: count ink pixels after rendering; blank/tofu images automatically retry with the next font; 4. Annotation output: each batch writes annotations.csv (filename, character, codepoint, font used). Typical usage # render each input txt into a same-named subdirectory under --out python render_single_chars.py token2.txt token3.txt token4.txt \ --out ./images --font fontA.ttf fontB.ttf # render everything into one directory (distinguished by --prefix) python render_single_chars.py chars.txt --out ./images --flat \ --font fontA.ttf --prefix 2token Dependencies: pip install Pillow fonttools """ from __future__ import annotations import argparse import csv import sys import time from collections import Counter from pathlib import Path if hasattr(sys.stdout, "reconfigure"): # Windows consoles default to GBK sys.stdout.reconfigure(encoding="utf-8", errors="replace") sys.stderr.reconfigure(encoding="utf-8", errors="replace") from fontTools.ttLib import TTFont, TTLibFileIsCollectionError from PIL import Image, ImageDraw, ImageFont # --------------------------------------------------------------------------- # # Font management # --------------------------------------------------------------------------- # class FontRouter: """Route a single character across multiple font files (multi-plane fonts). .ttc collections are supported: every face in a collection is routed separately, in file order.""" def __init__(self, font_paths: list[str]): if not font_paths: raise ValueError("at least one font file is required (--font)") self.paths: list[Path] = [] # per-face path (may repeat for .ttc) self.faces: list[int] = [] # face number within the file self.labels: list[str] = [] # human-readable name for annotations.csv for p in map(Path, font_paths): if not p.is_file(): raise FileNotFoundError(f"font not found: {p}") first = None try: first = TTFont(str(p), lazy=True) faces = [first] except TTLibFileIsCollectionError: first = TTFont(str(p), lazy=True, fontNumber=0) faces = [TTFont(str(p), lazy=True, fontNumber=i) for i in range(first.reader.numFonts)] for i, f in enumerate(faces): self.paths.append(p) self.faces.append(i) self.labels.append(p.name if len(faces) == 1 else f"{p.name}#{i}") if first is not None: first.close() self.cmaps = [] for p, face in zip(self.paths, self.faces): try: f = TTFont(str(p), lazy=True, fontNumber=face) self.cmaps.append(f.getBestCmap() or {}) f.close() except Exception as e: print(f"[warn] cannot read cmap of {p.name}#{face}: {e}", file=sys.stderr) self.cmaps.append({}) self._cache: dict[tuple[int, int], ImageFont.FreeTypeFont] = {} def font_index(self, ch: str) -> int | None: """Return the index of the first font covering the character.""" cp = ord(ch) for i, cm in enumerate(self.cmaps): if cp in cm: return i return None def _font(self, idx: int, px: int) -> ImageFont.FreeTypeFont: key = (idx, px) if key not in self._cache: self._cache[key] = ImageFont.truetype(str(self.paths[idx]), px, index=self.faces[idx]) return self._cache[key] def render(self, ch: str, canvas: int, font_px: int, bg: int = 255, fg: int = 0, min_ink: int = 40): """Render one character; return (PIL.Image, font index) or (None, None).""" order = [i for i in range(len(self.paths)) if ord(ch) in self.cmaps[i]] for idx in order: try: px = font_px probe = ImageDraw.Draw(Image.new("L", (8, 8))) # Adaptive scaling: shrink the font size when it overflows while px > 20: font = self._font(idx, px) b = probe.textbbox((canvas // 2, canvas // 2), ch, font=font, anchor="mm") if b[0] >= 0 and b[1] >= 0 and b[2] <= canvas and b[3] <= canvas: break px -= 6 img = Image.new("L", (canvas, canvas), bg) ImageDraw.Draw(img).text((canvas // 2, canvas // 2), ch, font=self._font(idx, px), fill=fg, anchor="mm") ink = sum(img.histogram()[:200]) # pixels < 200 (blank/tofu guard) if ink >= min_ink: return img, idx except Exception as e: # one failed char must not abort the batch print(f"[warn] render {ch!r} with {self.paths[idx].name}: {e}", file=sys.stderr) return None, None # --------------------------------------------------------------------------- # # Main flow # --------------------------------------------------------------------------- # def read_chars(path: Path) -> list[str]: """Read a txt input: every non-whitespace character on every line is a character to render. utf-8-sig tolerates a BOM (the BOM is not treated as a character).""" chars: list[str] = [] for line in path.read_text(encoding="utf-8-sig").splitlines(): chars.extend(c for c in line if not c.isspace()) chars = [c for c in chars if c != "\ufeff"] # dedup, preserving order seen: set[str] = set() return [c for c in chars if not (c in seen or seen.add(c))] def render_batch(chars: list[str], out_dir: Path, router: FontRouter, prefix: str, canvas: int, font_px: int, min_ink: int) -> tuple[list[dict], list[str]]: out_dir.mkdir(parents=True, exist_ok=True) rows, failed = [], [] for i, ch in enumerate(chars, 1): img, idx = router.render(ch, canvas, font_px, min_ink=min_ink) if img is None: failed.append(ch) continue fname = f"{prefix}_{i:04d}_{ch}.png" img.save(out_dir / fname) rows.append({ "filename": fname, "char": ch, "codepoint": f"U+{ord(ch):04X}", "font": router.labels[idx] if idx is not None else "", }) return rows, failed def main() -> int: ap = argparse.ArgumentParser( description="Render a list of Chinese characters into a " "one-image-per-character evaluation set", formatter_class=argparse.ArgumentDefaultsHelpFormatter) ap.add_argument("inputs", nargs="+", type=Path, help="input txt files (chars per line, whitespace ignored, " "auto-dedup preserving order)") ap.add_argument("--out", type=Path, default=Path("images"), help="output root") ap.add_argument("--font", nargs="+", required=True, help="font file(s), priority = order given (e.g., plane-split stacks)") ap.add_argument("--size", type=int, default=128, help="canvas size (px)") ap.add_argument("--font-px", type=int, default=100, help="initial font size (auto-shrinks)") ap.add_argument("--min-ink", type=int, default=40, help="blank-detection threshold (dark pixels)") ap.add_argument("--flat", action="store_true", help="render into --out without per-input subdirectories") ap.add_argument("--prefix", default="char", help="filename prefix in --flat mode") args = ap.parse_args() router = FontRouter(args.font) all_rows: list[dict] = [] t0 = time.time() for src in args.inputs: if not src.is_file(): print(f"[error] input not found: {src}", file=sys.stderr) return 1 chars = read_chars(src) prefix = args.prefix if args.flat else src.stem out_dir = args.out if args.flat else args.out / src.stem rows, failed = render_batch(chars, out_dir, router, prefix, args.size, args.font_px, args.min_ink) all_rows.extend({**r, "group": prefix} for r in rows) cov = Counter(r["font"] for r in rows) print(f"[{src.name}] chars={len(chars)} rendered={len(rows)} " f"failed={len(failed)}{''.join(failed[:10])} fonts={dict(cov)}") ann = args.out / "annotations.csv" ann.parent.mkdir(parents=True, exist_ok=True) with open(ann, "w", encoding="utf-8-sig", newline="") as f: w = csv.DictWriter(f, fieldnames=["group", "filename", "char", "codepoint", "font"]) w.writeheader() w.writerows(all_rows) print(f"total={len(all_rows)} annotations={ann} time={time.time()-t0:.1f}s") return 0 if __name__ == "__main__": sys.exit(main())