Download src/render_single_chars.py from AnonymousGAOSA/FELDoc-Atomic: direct link, hf CLI and curl.
- Browser
- Download file 9.49 kB
-
https://huggingface.co/datasets/AnonymousGAOSA/FELDoc-Atomic/resolve/main/src/render_single_chars.py
- Command line
-
hf download hf://datasets/AnonymousGAOSA/FELDoc-Atomic/src/render_single_chars.py
-
curl -L -o render_single_chars.py https://huggingface.co/datasets/AnonymousGAOSA/FELDoc-Atomic/resolve/main/src/render_single_chars.py
9.49 kB
| #!/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()) | |