FELDoc-Atomic / src /render_single_chars.py
AnonymousGAOSA's picture
Upload 3 files
4f8eb4f verified
Raw History Blame Contribute Delete
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())