Add files using upload-large-folder tool

derived/Source/README.md

@@ -11,8 +11,8 @@ Important version note:
 - Verification for the industrial-instrumentation rows therefore uses the external version-matched `liii_2v16.pdf` from ibiblio rather than the bundled `2.33` PDF.
 
 Outputs:
-- [visuals/four_column_table.html](/workspace/SchemID/derived/Source/visuals/four_column_table.html) is the spreadsheet-style visual table with all four columns and inline PNGs.
-- [visuals/four_column_table.csv](/workspace/SchemID/derived/Source/visuals/four_column_table.csv) is the CSV companion with image paths and source metadata.
+- [sheets](/workspace/SchemID/derived/Source/sheets) contains high-resolution PNG visualization sheets with multiple rendered circuits per page.
+- [sheets/sheet_manifest.csv](/workspace/SchemID/derived/Source/sheets/sheet_manifest.csv) lists the generated sheet pages and the figures included in each one.
 - [circuit_generation_code](/workspace/SchemID/derived/Source/circuit_generation_code) contains the extracted EPS code used to generate circuit diagrams.
 - [rendered](/workspace/SchemID/derived/Source/rendered) contains regenerated PNGs and no-text PNGs.
 - [metadata](/workspace/SchemID/derived/Source/metadata) contains structure and verification manifests.
@@ -24,6 +24,11 @@ Build command:
 python3 /workspace/SchemID/derived/Source/scripts/build_circuit_dataset.py --repo-root /workspace/SchemID
 ```
 
+Sheet build command:
+```bash
+python3 /workspace/SchemID/derived/Source/scripts/generate_visual_sheets.py
+```
+
 Upload command:
 ```bash
 python3 /workspace/SchemID/derived/Source/scripts/build_circuit_dataset.py --repo-root /workspace/SchemID --upload

derived/Source/scripts/generate_visual_sheets.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+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"
+SHEETS_ORIGINAL_ROOT = SHEETS_ROOT / "original"
+MANIFEST_PATH = SHEETS_ROOT / "sheet_manifest.csv"
+
+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:
+    SHEETS_ORIGINAL_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["Circuit generated image"]),
+                    "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_ORIGINAL_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),
+                }
+            )
+
+    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()