| |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import html |
| import json |
| import math |
| import re |
| import textwrap |
| from collections import defaultdict |
| from pathlib import Path |
|
|
| from PIL import Image, ImageDraw, ImageFont |
|
|
|
|
| REPO_ROOT = Path("/workspace/SchemID") |
| SOURCE_ROOT = REPO_ROOT / "derived" / "Source" |
| ROWS_PATH = SOURCE_ROOT / "metadata" / "rows.jsonl" |
| SHEETS_ROOT = SOURCE_ROOT / "sheets" |
|
|
| PAGE_W = 4200 |
| PAGE_H = 5940 |
| MARGIN_X = 140 |
| MARGIN_Y = 140 |
| PAGE_HEADER_H = 180 |
| COLS = 2 |
| ROWS = 3 |
| GRID_GAP_X = 90 |
| GRID_GAP_Y = 90 |
| CARD_PADDING = 36 |
| CARD_RADIUS = 28 |
| PER_PAGE = COLS * ROWS |
|
|
| FONT_REGULAR = "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf" |
| FONT_BOLD = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" |
| TAG_RE = re.compile(r"<[^>]+>") |
| SPACE_RE = re.compile(r"\s+") |
|
|
| BOOK_ORDER = ["DC", "AC", "SEMI", "DIGI", "REF", "EXP", "LIII"] |
|
|
|
|
| def load_font(path: str, size: int) -> ImageFont.FreeTypeFont: |
| return ImageFont.truetype(path, size=size) |
|
|
|
|
| TITLE_FONT = load_font(FONT_BOLD, 52) |
| CONTEXT_FONT = load_font(FONT_REGULAR, 34) |
| META_FONT = load_font(FONT_REGULAR, 30) |
| PAGE_TITLE_FONT = load_font(FONT_BOLD, 72) |
| PAGE_META_FONT = load_font(FONT_REGULAR, 36) |
|
|
|
|
| def clean_text(value: str | None) -> str: |
| if not value: |
| return "" |
| value = html.unescape(value) |
| value = TAG_RE.sub("", value) |
| value = SPACE_RE.sub(" ", value).strip() |
| return value |
|
|
|
|
| def first_ref(source_payload: dict) -> dict: |
| refs = source_payload.get("references") or [] |
| return refs[0] if refs else {} |
|
|
|
|
| def sort_key(source_payload: dict) -> tuple: |
| ref = first_ref(source_payload) |
| return ( |
| clean_text(ref.get("reference_source")), |
| ref.get("line") or 0, |
| source_payload.get("figure_id") or "", |
| ) |
|
|
|
|
| def pick_primary_title(source_payload: dict) -> str: |
| ref = first_ref(source_payload) |
| for key in ("caption", "subsection", "section", "chapter"): |
| text = clean_text(ref.get(key)) |
| if text: |
| return text |
| return f"{source_payload['book']} {source_payload['figure_id']}" |
|
|
|
|
| def pick_context(source_payload: dict) -> str: |
| ref = first_ref(source_payload) |
| parts: list[str] = [] |
| for key in ("chapter", "section", "subsection"): |
| text = clean_text(ref.get(key)) |
| if text and text not in parts: |
| parts.append(text) |
| primary = pick_primary_title(source_payload) |
| parts = [part for part in parts if part != primary] |
| return " / ".join(parts) |
|
|
|
|
| def pick_source_line(source_payload: dict) -> str: |
| ref = first_ref(source_payload) |
| source_file = clean_text(ref.get("reference_source")) or "unknown" |
| line = ref.get("line") |
| line_text = f":{line}" if line else "" |
| return ( |
| f"{source_payload['book']} {source_payload['figure_id']} | " |
| f"{source_file}{line_text}" |
| ) |
|
|
|
|
| def draw_rounded_box(draw: ImageDraw.ImageDraw, box: tuple[int, int, int, int]) -> None: |
| draw.rounded_rectangle(box, radius=CARD_RADIUS, fill="white", outline="#cfcfcf", width=4) |
|
|
|
|
| def fit_image(image: Image.Image, max_w: int, max_h: int) -> Image.Image: |
| image = trim_image(image.convert("RGBA")) |
| scale = min(max_w / image.width, max_h / image.height) |
| new_size = (max(1, int(image.width * scale)), max(1, int(image.height * scale))) |
| resized = image.resize(new_size, Image.Resampling.LANCZOS) |
| white_bg = Image.new("RGBA", resized.size, (255, 255, 255, 255)) |
| return Image.alpha_composite(white_bg, resized).convert("RGB") |
|
|
|
|
| def trim_image(image: Image.Image) -> Image.Image: |
| bg = Image.new("RGBA", image.size, (255, 255, 255, 255)) |
| flattened = Image.alpha_composite(bg, image).convert("RGB") |
| pixels = flattened.load() |
| min_x = flattened.width |
| min_y = flattened.height |
| max_x = -1 |
| max_y = -1 |
|
|
| for y in range(flattened.height): |
| for x in range(flattened.width): |
| r, g, b = pixels[x, y] |
| if r < 250 or g < 250 or b < 250: |
| if x < min_x: |
| min_x = x |
| if y < min_y: |
| min_y = y |
| if x > max_x: |
| max_x = x |
| if y > max_y: |
| max_y = y |
|
|
| if max_x < min_x or max_y < min_y: |
| return image |
|
|
| pad = 20 |
| min_x = max(0, min_x - pad) |
| min_y = max(0, min_y - pad) |
| max_x = min(image.width, max_x + pad + 1) |
| max_y = min(image.height, max_y + pad + 1) |
| return image.crop((min_x, min_y, max_x, max_y)) |
|
|
|
|
| def wrap_lines(text: str, width: int) -> list[str]: |
| if not text: |
| return [] |
| wrapped = textwrap.wrap(text, width=width, break_long_words=False, replace_whitespace=False) |
| return wrapped or [text] |
|
|
|
|
| def build_page(rows: list[dict], display_name: str, book: str, page_number: int, page_count: int, output_path: Path) -> None: |
| page = Image.new("RGB", (PAGE_W, PAGE_H), "white") |
| draw = ImageDraw.Draw(page) |
|
|
| draw.text((MARGIN_X, MARGIN_Y - 10), display_name, fill="#111111", font=PAGE_TITLE_FONT) |
| meta_text = f"Sheet {page_number} / {page_count} | {len(rows)} circuits on this page" |
| draw.text((MARGIN_X, MARGIN_Y + 86), meta_text, fill="#444444", font=PAGE_META_FONT) |
|
|
| grid_top = MARGIN_Y + PAGE_HEADER_H |
| usable_w = PAGE_W - (2 * MARGIN_X) - ((COLS - 1) * GRID_GAP_X) |
| usable_h = PAGE_H - grid_top - MARGIN_Y - ((ROWS - 1) * GRID_GAP_Y) |
| card_w = usable_w // COLS |
| card_h = usable_h // ROWS |
|
|
| for idx, row in enumerate(rows): |
| col = idx % COLS |
| r = idx // COLS |
| x0 = MARGIN_X + col * (card_w + GRID_GAP_X) |
| y0 = grid_top + r * (card_h + GRID_GAP_Y) |
| x1 = x0 + card_w |
| y1 = y0 + card_h |
| draw_rounded_box(draw, (x0, y0, x1, y1)) |
|
|
| content_x = x0 + CARD_PADDING |
| content_y = y0 + CARD_PADDING |
| content_w = card_w - (2 * CARD_PADDING) |
| content_h = card_h - (2 * CARD_PADDING) |
|
|
| primary = wrap_lines(row["primary_title"], width=42)[:3] |
| context = wrap_lines(row["context"], width=60)[:3] |
| meta = wrap_lines(row["source_line"], width=68)[:2] |
|
|
| y_cursor = content_y |
| for line in primary: |
| draw.text((content_x, y_cursor), line, fill="#111111", font=TITLE_FONT) |
| y_cursor += 62 |
|
|
| if context: |
| y_cursor += 8 |
| for line in context: |
| draw.text((content_x, y_cursor), line, fill="#444444", font=CONTEXT_FONT) |
| y_cursor += 42 |
|
|
| image_box_top = y_cursor + 18 |
| meta_h = 40 * max(1, len(meta)) |
| image_box_h = content_h - (image_box_top - content_y) - meta_h - 18 |
|
|
| with Image.open(row["image_path"]) as circuit: |
| fitted = fit_image(circuit, content_w, image_box_h) |
| image_x = content_x + (content_w - fitted.width) // 2 |
| image_y = image_box_top + max(0, (image_box_h - fitted.height) // 2) |
| page.paste(fitted.convert("RGB"), (image_x, image_y)) |
|
|
| meta_y = content_y + content_h - meta_h |
| for line in meta: |
| draw.text((content_x, meta_y), line, fill="#666666", font=META_FONT) |
| meta_y += 38 |
|
|
| output_path.parent.mkdir(parents=True, exist_ok=True) |
| page.save(output_path, format="PNG", compress_level=3) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument( |
| "--image-field", |
| default="Circuit generated image", |
| choices=[ |
| "Circuit generated image", |
| "Circuit Generated image with no text", |
| ], |
| help="Dataset row field containing the image path to place on the sheets.", |
| ) |
| parser.add_argument( |
| "--output-subdir", |
| default="original", |
| help="Subdirectory under derived/Source/sheets where the page PNGs will be written.", |
| ) |
| parser.add_argument( |
| "--manifest-name", |
| default="sheet_manifest.csv", |
| help="Manifest filename written under derived/Source/sheets.", |
| ) |
| args = parser.parse_args() |
|
|
| sheets_output_root = SHEETS_ROOT / args.output_subdir |
| manifest_path = SHEETS_ROOT / args.manifest_name |
| sheets_output_root.mkdir(parents=True, exist_ok=True) |
|
|
| grouped: dict[str, list[dict]] = defaultdict(list) |
| display_names: dict[str, str] = {} |
|
|
| with ROWS_PATH.open() as handle: |
| for line in handle: |
| raw = json.loads(line) |
| source_payload = json.loads(raw["Source"]) |
| book = source_payload["book"] |
| display_names[book] = source_payload["display_name"] |
| grouped[book].append( |
| { |
| "book": book, |
| "figure_id": source_payload["figure_id"], |
| "image_path": Path(raw[args.image_field]), |
| "primary_title": pick_primary_title(source_payload), |
| "context": pick_context(source_payload), |
| "source_line": pick_source_line(source_payload), |
| "source_payload": source_payload, |
| } |
| ) |
|
|
| manifest_rows: list[dict[str, str]] = [] |
| for book in BOOK_ORDER: |
| rows = grouped.get(book) |
| if not rows: |
| continue |
| rows.sort(key=lambda row: sort_key(row["source_payload"])) |
| display_name = display_names[book] |
| page_count = math.ceil(len(rows) / PER_PAGE) |
| for page_index in range(page_count): |
| start = page_index * PER_PAGE |
| end = start + PER_PAGE |
| page_rows = rows[start:end] |
| output_path = ( |
| sheets_output_root |
| / book |
| / f"{book}_sheet_{page_index + 1:03d}.png" |
| ) |
| build_page( |
| page_rows, |
| display_name=display_name, |
| book=book, |
| page_number=page_index + 1, |
| page_count=page_count, |
| output_path=output_path, |
| ) |
| manifest_rows.append( |
| { |
| "book": book, |
| "display_name": display_name, |
| "page_number": str(page_index + 1), |
| "page_count": str(page_count), |
| "sheet_png": str(output_path.relative_to(SHEETS_ROOT)), |
| "figure_ids": "|".join(row["figure_id"] for row in page_rows), |
| "titles": " || ".join(row["primary_title"] for row in page_rows), |
| } |
| ) |
|
|
| keep_paths = { |
| (SHEETS_ROOT / row["sheet_png"]).resolve() |
| for row in manifest_rows |
| } |
| for path in sheets_output_root.rglob("*.png"): |
| if path.resolve() not in keep_paths: |
| path.unlink() |
|
|
| with manifest_path.open("w", newline="") as handle: |
| writer = csv.DictWriter( |
| handle, |
| fieldnames=[ |
| "book", |
| "display_name", |
| "page_number", |
| "page_count", |
| "sheet_png", |
| "figure_ids", |
| "titles", |
| ], |
| ) |
| writer.writeheader() |
| writer.writerows(manifest_rows) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
