@howaboua/pi-pet 0.1.1

package/authoring/hatch/scripts/make_contact_sheet.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""Create a labeled contact sheet from a Codex pet atlas."""
+
+# Modified from the Apache-2.0 Hatch Pet workflow for the Pi Pet authoring package.
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+COLUMNS = 8
+ROWS = 9
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+LABEL_HEIGHT = 22
+ROW_NAMES = [
+    "idle",
+    "running-right",
+    "running-left",
+    "waving",
+    "jumping",
+    "failed",
+    "waiting",
+    "running",
+    "review",
+    "look 000-157.5",
+    "look 180-337.5",
+]
+USED_COUNTS = [6, 8, 8, 4, 5, 8, 6, 6, 6, 8, 8]
+EXTENDED_NEUTRAL_LOOK_FRAME = (0, 6)
+
+
+def is_used_cell(rows: int, row: int, column: int) -> bool:
+    return column < USED_COUNTS[row] or (
+        rows == 11 and (row, column) == EXTENDED_NEUTRAL_LOOK_FRAME
+    )
+
+
+def frame_count_label(rows: int, row: int) -> str:
+    if rows == 11 and row == EXTENDED_NEUTRAL_LOOK_FRAME[0]:
+        return "6 + neutral"
+    return f"{USED_COUNTS[row]} frames"
+
+
+def checker(size: tuple[int, int], square: int = 16) -> Image.Image:
+    image = Image.new("RGB", size, "#ffffff")
+    draw = ImageDraw.Draw(image)
+    for y in range(0, size[1], square):
+        for x in range(0, size[0], square):
+            if (x // square + y // square) % 2:
+                draw.rectangle((x, y, x + square - 1, y + square - 1), fill="#e8e8e8")
+    return image
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--scale", type=float, default=0.5)
+    args = parser.parse_args()
+
+    with Image.open(Path(args.atlas).expanduser().resolve()) as opened:
+        atlas = opened.convert("RGBA")
+    rows = atlas.height // CELL_HEIGHT
+    if atlas.width != COLUMNS * CELL_WIDTH or rows not in {9, 11}:
+        raise SystemExit(f"atlas must be 1536x1872 or 1536x2288; got {atlas.width}x{atlas.height}")
+
+    cell_w = max(1, round(CELL_WIDTH * args.scale))
+    cell_h = max(1, round(CELL_HEIGHT * args.scale))
+    width = COLUMNS * cell_w
+    height = rows * (cell_h + LABEL_HEIGHT)
+    sheet = Image.new("RGB", (width, height), "#f7f7f7")
+    draw = ImageDraw.Draw(sheet)
+    font = ImageFont.load_default()
+
+    for row in range(rows):
+        y = row * (cell_h + LABEL_HEIGHT)
+        draw.rectangle((0, y, width, y + LABEL_HEIGHT - 1), fill="#111111")
+        draw.text((6, y + 5), f"row {row}: {ROW_NAMES[row]}", fill="#ffffff", font=font)
+        draw.text(
+            (width - 92, y + 5),
+            frame_count_label(rows, row),
+            fill="#ffffff",
+            font=font,
+        )
+        for column in range(COLUMNS):
+            crop = atlas.crop(
+                (
+                    column * CELL_WIDTH,
+                    row * CELL_HEIGHT,
+                    (column + 1) * CELL_WIDTH,
+                    (row + 1) * CELL_HEIGHT,
+                )
+            )
+            crop = crop.resize((cell_w, cell_h), Image.Resampling.LANCZOS)
+            bg = checker((cell_w, cell_h))
+            bg.paste(crop, (0, 0), crop)
+            x = column * cell_w
+            sheet.paste(bg, (x, y + LABEL_HEIGHT))
+            outline = "#18a058" if is_used_cell(rows, row, column) else "#cc3344"
+            draw.rectangle(
+                (x, y + LABEL_HEIGHT, x + cell_w - 1, y + LABEL_HEIGHT + cell_h - 1),
+                outline=outline,
+            )
+            draw.text((x + 4, y + LABEL_HEIGHT + 4), str(column), fill="#111111", font=font)
+
+    output = Path(args.output).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    sheet.save(output)
+    print(f"wrote {output}")
+
+
+if __name__ == "__main__":
+    main()

package/authoring/hatch/scripts/make_direction_blind_qa_sheet.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Create an unlabeled A/B direction-pair sheet and a hidden answer key."""
+
+# Modified from the Apache-2.0 Hatch Pet workflow for the Pi Pet authoring package.
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import random
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+COLUMNS = 8
+ROWS = 11
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+LOOK_ROW_INDEX = 9
+LABEL_HEIGHT = 28
+PAIR_COLUMNS = 2
+
+LOOK_DIRECTION_LABELS = [
+    "000",
+    "022.5",
+    "045",
+    "067.5",
+    "090",
+    "112.5",
+    "135",
+    "157.5",
+    "180",
+    "202.5",
+    "225",
+    "247.5",
+    "270",
+    "292.5",
+    "315",
+    "337.5",
+]
+
+AXIS_PAIRS = [
+    ("horizontal", "022.5", "screen-right", "337.5", "screen-left"),
+    ("horizontal", "045", "screen-right", "315", "screen-left"),
+    ("horizontal", "067.5", "screen-right", "292.5", "screen-left"),
+    ("horizontal", "090", "screen-right", "270", "screen-left"),
+    ("horizontal", "112.5", "screen-right", "247.5", "screen-left"),
+    ("horizontal", "135", "screen-right", "225", "screen-left"),
+    ("horizontal", "157.5", "screen-right", "202.5", "screen-left"),
+    ("vertical", "000", "up", "180", "down"),
+    ("vertical", "022.5", "up", "157.5", "down"),
+    ("vertical", "045", "up", "135", "down"),
+    ("vertical", "067.5", "up", "112.5", "down"),
+    ("vertical", "337.5", "up", "202.5", "down"),
+    ("vertical", "315", "up", "225", "down"),
+    ("vertical", "292.5", "up", "247.5", "down"),
+]
+
+
+def atlas_cell(atlas: Image.Image, label: str) -> Image.Image:
+    index = LOOK_DIRECTION_LABELS.index(label)
+    row = LOOK_ROW_INDEX + index // COLUMNS
+    column = index % COLUMNS
+    return atlas.crop(
+        (
+            column * CELL_WIDTH,
+            row * CELL_HEIGHT,
+            (column + 1) * CELL_WIDTH,
+            (row + 1) * CELL_HEIGHT,
+        )
+    )
+
+
+def paste_cell(
+    sheet: Image.Image,
+    cell: Image.Image,
+    *,
+    label: str,
+    column: int,
+    row: int,
+) -> None:
+    x = column * CELL_WIDTH
+    y = row * (CELL_HEIGHT + LABEL_HEIGHT)
+    sheet.alpha_composite(
+        Image.new("RGBA", (CELL_WIDTH, CELL_HEIGHT), (242, 242, 242, 255)),
+        (x, y + LABEL_HEIGHT),
+    )
+    sheet.alpha_composite(cell, (x, y + LABEL_HEIGHT))
+    ImageDraw.Draw(sheet).text((x + 6, y + 8), label, fill=(0, 0, 0, 255))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--answer-key", required=True)
+    args = parser.parse_args()
+
+    atlas_path = Path(args.atlas).expanduser().resolve()
+    with Image.open(atlas_path) as opened:
+        atlas = opened.convert("RGBA")
+    if atlas.size != (COLUMNS * CELL_WIDTH, ROWS * CELL_HEIGHT):
+        raise SystemExit(f"extended atlas must be 1536x2288; got {atlas.width}x{atlas.height}")
+
+    seed = int.from_bytes(hashlib.sha256(atlas.tobytes()).digest()[:8], "big")
+    rng = random.Random(seed)
+    sheet = Image.new(
+        "RGBA",
+        (
+            PAIR_COLUMNS * CELL_WIDTH,
+            len(AXIS_PAIRS) * (CELL_HEIGHT + LABEL_HEIGHT),
+        ),
+        (255, 255, 255, 255),
+    )
+    answers: list[dict[str, object]] = []
+
+    axis_indexes = {"horizontal": 0, "vertical": 0}
+    for row, (axis, first_label, first_direction, second_label, second_direction) in enumerate(
+        AXIS_PAIRS
+    ):
+        axis_indexes[axis] += 1
+        pair_id = f"{axis}-{axis_indexes[axis]}"
+        pair = [
+            (first_label, first_direction),
+            (second_label, second_direction),
+        ]
+        rng.shuffle(pair)
+        cells: list[tuple[str, str, Image.Image]] = []
+        for source_label, expected_direction in pair:
+            cells.append((source_label, expected_direction, atlas_cell(atlas, source_label)))
+
+        label = f"{axis.title()} pair {axis_indexes[axis]}"
+        paste_cell(sheet, cells[0][2], label=f"{label} A", column=0, row=row)
+        paste_cell(sheet, cells[1][2], label=f"{label} B", column=1, row=row)
+        answers.append(
+            {
+                "pair": pair_id,
+                "axis": axis,
+                "gate": (
+                    "hard"
+                    if {first_label, second_label} in ({"000", "180"}, {"090", "270"})
+                    else "review"
+                ),
+                "A": {
+                    "expected_direction": cells[0][1],
+                    "source_direction": cells[0][0],
+                },
+                "B": {
+                    "expected_direction": cells[1][1],
+                    "source_direction": cells[1][0],
+                },
+            }
+        )
+
+    output = Path(args.output).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    sheet.convert("RGB").save(output)
+    answer_key = Path(args.answer_key).expanduser().resolve()
+    answer_key.parent.mkdir(parents=True, exist_ok=True)
+    answer_key.write_text(
+        json.dumps(
+            {
+                "schema_version": 3,
+                "atlas_sha256": hashlib.sha256(atlas_path.read_bytes()).hexdigest(),
+                "instructions": "Do not provide this answer key to the blind visual QA reviewer.",
+                "pairs": answers,
+            },
+            indent=2,
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    print(f"wrote {output}")
+    print(f"wrote {answer_key}")
+
+
+if __name__ == "__main__":
+    main()

package/authoring/hatch/scripts/make_direction_qa_sheet.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""Create a focused QA sheet for extended pet look directions."""
+
+# Modified from the Apache-2.0 Hatch Pet workflow for the Pi Pet authoring package.
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from PIL import Image, ImageDraw
+
+COLUMNS = 8
+ROWS = 11
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+LOOK_ROW_INDEX = 9
+NEUTRAL_ROW_INDEX = 0
+NEUTRAL_COLUMN_INDEX = 6
+LABEL_HEIGHT = 26
+FOCUS_PADDING = 18
+LOOK_DIRECTION_LABELS = [
+    ("000", "up"),
+    ("022.5", "up-right"),
+    ("045", "up-right"),
+    ("067.5", "up-right"),
+    ("090", "right"),
+    ("112.5", "down-right"),
+    ("135", "down-right"),
+    ("157.5", "down-right"),
+    ("180", "down"),
+    ("202.5", "down-left"),
+    ("225", "down-left"),
+    ("247.5", "down-left"),
+    ("270", "left"),
+    ("292.5", "up-left"),
+    ("315", "up-left"),
+    ("337.5", "up-left"),
+]
+
+
+def paste_labeled_cell(
+    sheet: Image.Image,
+    atlas: Image.Image,
+    *,
+    label: str,
+    row_index: int,
+    column_index: int,
+    output_column: int,
+    output_row: int,
+) -> None:
+    draw = ImageDraw.Draw(sheet)
+    x = output_column * CELL_WIDTH
+    y = output_row * (CELL_HEIGHT + LABEL_HEIGHT)
+    cell = atlas.crop(
+        (
+            column_index * CELL_WIDTH,
+            row_index * CELL_HEIGHT,
+            (column_index + 1) * CELL_WIDTH,
+            (row_index + 1) * CELL_HEIGHT,
+        )
+    )
+    background = Image.new("RGBA", (CELL_WIDTH, CELL_HEIGHT), (242, 242, 242, 255))
+    sheet.alpha_composite(background, (x, y + LABEL_HEIGHT))
+    sheet.alpha_composite(cell, (x, y + LABEL_HEIGHT))
+    draw.text((x + 6, y + 7), label, fill=(0, 0, 0, 255))
+
+
+def focused_head_cell(cell: Image.Image) -> Image.Image:
+    bbox = cell.getbbox()
+    if bbox is None:
+        return cell
+
+    left, top, right, bottom = bbox
+    sprite_height = bottom - top
+    focus_bottom = top + max(1, int(sprite_height * 0.52))
+    crop_box = (
+        max(0, left - FOCUS_PADDING),
+        max(0, top - FOCUS_PADDING),
+        min(CELL_WIDTH, right + FOCUS_PADDING),
+        min(CELL_HEIGHT, focus_bottom + FOCUS_PADDING),
+    )
+    crop = cell.crop(crop_box)
+    focused = Image.new("RGBA", (CELL_WIDTH, CELL_HEIGHT), (0, 0, 0, 0))
+    crop.thumbnail((CELL_WIDTH, CELL_HEIGHT), Image.Resampling.LANCZOS)
+    focused.alpha_composite(
+        crop,
+        ((CELL_WIDTH - crop.width) // 2, (CELL_HEIGHT - crop.height) // 2),
+    )
+    return focused
+
+
+def paste_labeled_focus_cell(
+    sheet: Image.Image,
+    atlas: Image.Image,
+    *,
+    label: str,
+    row_index: int,
+    column_index: int,
+    output_column: int,
+    output_row: int,
+) -> None:
+    cell = atlas.crop(
+        (
+            column_index * CELL_WIDTH,
+            row_index * CELL_HEIGHT,
+            (column_index + 1) * CELL_WIDTH,
+            (row_index + 1) * CELL_HEIGHT,
+        )
+    )
+    focused = focused_head_cell(cell)
+    background = Image.new("RGBA", (CELL_WIDTH, CELL_HEIGHT), (242, 242, 242, 255))
+    x = output_column * CELL_WIDTH
+    y = output_row * (CELL_HEIGHT + LABEL_HEIGHT)
+    sheet.alpha_composite(background, (x, y + LABEL_HEIGHT))
+    sheet.alpha_composite(focused, (x, y + LABEL_HEIGHT))
+    ImageDraw.Draw(sheet).text((x + 6, y + 7), label, fill=(0, 0, 0, 255))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--output", required=True)
+    args = parser.parse_args()
+
+    with Image.open(Path(args.atlas).expanduser().resolve()) as opened:
+        atlas = opened.convert("RGBA")
+    if atlas.size != (COLUMNS * CELL_WIDTH, ROWS * CELL_HEIGHT):
+        raise SystemExit(f"extended atlas must be 1536x2288; got {atlas.width}x{atlas.height}")
+
+    sheet = Image.new(
+        "RGBA",
+        (COLUMNS * CELL_WIDTH, 5 * (CELL_HEIGHT + LABEL_HEIGHT)),
+        (255, 255, 255, 255),
+    )
+    paste_labeled_cell(
+        sheet,
+        atlas,
+        label="neutral",
+        row_index=NEUTRAL_ROW_INDEX,
+        column_index=NEUTRAL_COLUMN_INDEX,
+        output_column=0,
+        output_row=0,
+    )
+    for index, (label, expected_direction) in enumerate(LOOK_DIRECTION_LABELS):
+        paste_labeled_cell(
+            sheet,
+            atlas,
+            label=f"{label} {expected_direction}",
+            row_index=LOOK_ROW_INDEX + index // COLUMNS,
+            column_index=index % COLUMNS,
+            output_column=index % COLUMNS,
+            output_row=1 + index // COLUMNS,
+        )
+        paste_labeled_focus_cell(
+            sheet,
+            atlas,
+            label=f"zoom {label} {expected_direction}",
+            row_index=LOOK_ROW_INDEX + index // COLUMNS,
+            column_index=index % COLUMNS,
+            output_column=index % COLUMNS,
+            output_row=3 + index // COLUMNS,
+        )
+
+    output = Path(args.output).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    sheet.convert("RGB").save(output)
+    print(f"wrote {output}")
+
+
+if __name__ == "__main__":
+    main()

package/authoring/hatch/scripts/measure_direction_continuity.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Measure adjacent-pair continuity for extended pet look directions."""
+
+# Modified from the Apache-2.0 Hatch Pet workflow for current Pillow pixel access.
+
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+from pathlib import Path
+
+from PIL import Image, ImageChops
+
+COLUMNS = 8
+ROWS = 11
+CELL_WIDTH = 192
+CELL_HEIGHT = 208
+LOOK_ROW_INDEX = 9
+LOOK_DIRECTION_LABELS = [
+    "000",
+    "022.5",
+    "045",
+    "067.5",
+    "090",
+    "112.5",
+    "135",
+    "157.5",
+    "180",
+    "202.5",
+    "225",
+    "247.5",
+    "270",
+    "292.5",
+    "315",
+    "337.5",
+]
+
+
+def nontransparent_pixels(image: Image.Image) -> int:
+    return sum(1 for alpha in image.getchannel("A").get_flattened_data() if alpha > 16)
+
+
+def center_for_bbox(bbox: tuple[int, int, int, int] | None) -> tuple[float, float] | None:
+    if bbox is None:
+        return None
+    left, top, right, bottom = bbox
+    return ((left + right) / 2, (top + bottom) / 2)
+
+
+def cell_from_atlas(atlas: Image.Image, index: int) -> Image.Image:
+    row = LOOK_ROW_INDEX + index // COLUMNS
+    column = index % COLUMNS
+    return atlas.crop(
+        (
+            column * CELL_WIDTH,
+            row * CELL_HEIGHT,
+            (column + 1) * CELL_WIDTH,
+            (row + 1) * CELL_HEIGHT,
+        )
+    )
+
+
+def transparent_hole_rows(image: Image.Image) -> list[dict[str, int]]:
+    alpha = list(image.getchannel("A").get_flattened_data())
+    rows = [alpha[index * CELL_WIDTH : (index + 1) * CELL_WIDTH] for index in range(CELL_HEIGHT)]
+    holes = []
+    for y in range(1, CELL_HEIGHT - 1):
+        prev_xs = [x for x, value in enumerate(rows[y - 1]) if value > 16]
+        next_xs = [x for x, value in enumerate(rows[y + 1]) if value > 16]
+        if not prev_xs or not next_xs:
+            continue
+        left = max(min(prev_xs), min(next_xs))
+        right = min(max(prev_xs), max(next_xs))
+        if right <= left:
+            continue
+        span = rows[y][left : right + 1]
+        transparent_pixels = sum(1 for value in span if value <= 16)
+        if len(span) >= 64 and transparent_pixels > max(32, int(len(span) * 0.25)):
+            holes.append(
+                {
+                    "row": y,
+                    "transparentPixels": transparent_pixels,
+                    "spanPixels": len(span),
+                }
+            )
+    return holes
+
+
+def pair_metric(first: Image.Image, second: Image.Image) -> dict[str, float | int | None]:
+    first_bbox = first.getbbox()
+    second_bbox = second.getbbox()
+    first_center = center_for_bbox(first_bbox)
+    second_center = center_for_bbox(second_bbox)
+    first_pixels = nontransparent_pixels(first)
+    second_pixels = nontransparent_pixels(second)
+    diff = ImageChops.difference(first, second)
+    diff_pixels = nontransparent_pixels(diff)
+
+    if first_center is None or second_center is None:
+        center_delta = None
+    else:
+        center_delta = (
+            (first_center[0] - second_center[0]) ** 2 + (first_center[1] - second_center[1]) ** 2
+        ) ** 0.5
+
+    if first_pixels == 0 or second_pixels == 0:
+        area_ratio = None
+    else:
+        area_ratio = max(first_pixels, second_pixels) / min(first_pixels, second_pixels)
+
+    return {
+        "firstPixels": first_pixels,
+        "secondPixels": second_pixels,
+        "diffPixels": diff_pixels,
+        "centerDelta": center_delta,
+        "areaRatio": area_ratio,
+    }
+
+
+def median(values: list[float]) -> float:
+    if not values:
+        return 0
+    return statistics.median(values)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("atlas")
+    parser.add_argument("--json-out", required=True)
+    parser.add_argument("--diff-outlier-ratio", type=float, default=1.45)
+    parser.add_argument("--center-delta-warning", type=float, default=8)
+    parser.add_argument("--area-ratio-warning", type=float, default=1.15)
+    args = parser.parse_args()
+
+    with Image.open(Path(args.atlas).expanduser().resolve()) as opened:
+        atlas = opened.convert("RGBA")
+    if atlas.size != (COLUMNS * CELL_WIDTH, ROWS * CELL_HEIGHT):
+        raise SystemExit(f"extended atlas must be 1536x2288; got {atlas.width}x{atlas.height}")
+
+    cells = [cell_from_atlas(atlas, index) for index in range(len(LOOK_DIRECTION_LABELS))]
+    pairs = []
+    for index, label in enumerate(LOOK_DIRECTION_LABELS):
+        next_index = (index + 1) % len(LOOK_DIRECTION_LABELS)
+        next_label = LOOK_DIRECTION_LABELS[next_index]
+        pairs.append(
+            {
+                "from": label,
+                "to": next_label,
+                **pair_metric(cells[index], cells[next_index]),
+            }
+        )
+
+    diff_values = [float(pair["diffPixels"]) for pair in pairs]
+    median_diff = median(diff_values)
+    warnings = []
+    alpha_holes = []
+    for label, cell in zip(LOOK_DIRECTION_LABELS, cells, strict=True):
+        holes = transparent_hole_rows(cell)
+        if holes:
+            alpha_holes.append({"direction": label, "holes": holes})
+            preview = ", ".join(f"y={hole['row']}" for hole in holes[:4])
+            suffix = "" if len(holes) <= 4 else f", +{len(holes) - 4} more"
+            warnings.append(f"{label} has transparent interior hole rows ({preview}{suffix})")
+
+    for index, pair in enumerate(pairs):
+        diff_pixels = float(pair["diffPixels"])
+        center_delta = pair["centerDelta"]
+        area_ratio = pair["areaRatio"]
+        pair_label = f"{pair['from']}->{pair['to']}"
+        neighbor_diff = statistics.mean(
+            [
+                diff_values[(index - 1) % len(diff_values)],
+                diff_values[(index + 1) % len(diff_values)],
+            ]
+        )
+        if neighbor_diff and diff_pixels > neighbor_diff * args.diff_outlier_ratio:
+            warnings.append(
+                f"{pair_label} diff is a local outlier ({diff_pixels:.0f} pixels vs neighbor average {neighbor_diff:.0f})"
+            )
+        if isinstance(center_delta, float) and center_delta > args.center_delta_warning:
+            warnings.append(f"{pair_label} center shift is high ({center_delta:.1f}px)")
+        if isinstance(area_ratio, float) and area_ratio > args.area_ratio_warning:
+            warnings.append(f"{pair_label} sprite area ratio is high ({area_ratio:.2f})")
+
+    result = {
+        "ok": True,
+        "reviewRequired": bool(warnings),
+        "medianDiffPixels": median_diff,
+        "warnings": warnings,
+        "alphaHoles": alpha_holes,
+        "pairs": pairs,
+    }
+    output = Path(args.json_out).expanduser().resolve()
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()