@playcraft/cli 0.0.44 → 0.0.46

package/project-templates/threejs/skills/playable-art/scripts/import-gpt-tile-sheet.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Import a GPT-generated Mahjong tile sheet into fixed project sprite sizes."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+from PIL import Image
+
+from import_gpt_art_pipeline import project_root
+
+ROOT = project_root()
+DEFAULT_SOURCE = ROOT / "assets" / "reference" / "gpt-image-2-mahjong-tiles-sheet.png"
+OUT_DIR = ROOT / "assets" / "images" / "tiles"
+
+SPRITES = [
+    "wan_1",
+    "wan_2",
+    "wan_3",
+    "tong_1",
+    "tong_2",
+    "tong_3",
+    "tiao_1",
+    "tiao_2",
+    "tiao_3",
+    "gold",
+    "back",
+]
+
+TILE_SIZE = (176, 216)
+GRID_COLS = 4
+GRID_ROWS = 3
+MAGENTA = (255, 0, 255)
+
+
+def remove_chroma(image: Image.Image, tolerance: int) -> Image.Image:
+    rgba = image.convert("RGBA")
+    pixels = rgba.load()
+    for y in range(rgba.height):
+        for x in range(rgba.width):
+            r, g, b, a = pixels[x, y]
+            is_exact_key = (
+                abs(r - MAGENTA[0]) <= tolerance
+                and abs(g - MAGENTA[1]) <= tolerance
+                and abs(b - MAGENTA[2]) <= tolerance
+            )
+            is_key_fringe = r >= 160 and b >= 145 and g <= 95
+            if is_exact_key or is_key_fringe:
+                pixels[x, y] = (255, 0, 255, 0)
+    return rgba
+
+
+def crop_to_alpha(image: Image.Image) -> Image.Image:
+    bbox = image.getchannel("A").getbbox()
+    if not bbox:
+        return image
+    left, top, right, bottom = bbox
+    pad = 2
+    return image.crop((
+        max(0, left + pad),
+        max(0, top + pad),
+        min(image.width, right - pad),
+        min(image.height, bottom - pad),
+    ))
+
+
+def fit_tile(image: Image.Image, padding: int) -> Image.Image:
+    target_w, target_h = TILE_SIZE
+    max_w = target_w - padding * 2
+    max_h = target_h - padding * 2
+    scale = min(max_w / image.width, max_h / image.height)
+    new_size = (max(1, round(image.width * scale)), max(1, round(image.height * scale)))
+    resized = image.resize(new_size, Image.Resampling.LANCZOS)
+    out = Image.new("RGBA", TILE_SIZE, (0, 0, 0, 0))
+    out.alpha_composite(resized, ((target_w - new_size[0]) // 2, (target_h - new_size[1]) // 2))
+    return out
+
+
+def import_sheet(source: Path, tolerance: int, padding: int) -> None:
+    sheet = Image.open(source).convert("RGBA")
+    cell_w = sheet.width // GRID_COLS
+    cell_h = sheet.height // GRID_ROWS
+    inset = max(4, min(cell_w, cell_h) // 60)
+    OUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    for index, name in enumerate(SPRITES):
+        col = index % GRID_COLS
+        row = index // GRID_COLS
+        cell = sheet.crop((
+            col * cell_w + inset,
+            row * cell_h + inset,
+            (col + 1) * cell_w - inset,
+            (row + 1) * cell_h - inset,
+        ))
+        transparent = remove_chroma(cell, tolerance)
+        content = crop_to_alpha(transparent)
+        tile = fit_tile(content, padding)
+        tile.save(OUT_DIR / f"{name}.png")
+
+    print(f"Imported {len(SPRITES)} GPT tiles from {source}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--source", type=Path, default=DEFAULT_SOURCE)
+    parser.add_argument("--tolerance", type=int, default=34)
+    parser.add_argument("--padding", type=int, default=4)
+    args = parser.parse_args()
+    import_sheet(args.source, args.tolerance, args.padding)
+
+
+if __name__ == "__main__":
+    main()

package/project-templates/threejs/skills/playable-art/scripts/import_gpt_art_pipeline.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Shared GPT sheet → sprite pipeline: bg remove, element segment, contain-fit."""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from pathlib import Path
+
+from PIL import Image
+
+MAGENTA = (255, 0, 255)
+WAVESPEED_ENDPOINT = "https://api.wavespeed.ai/api/v3/wavespeed-ai/image-background-remover"
+
+
+def project_root() -> Path:
+    cwd = Path.cwd().resolve()
+    if (cwd / "assets").exists() and (cwd / "package.json").exists():
+        return cwd
+    script_path = Path(__file__).resolve()
+    for parent in script_path.parents:
+        if (parent / "assets").exists() and (parent / "package.json").exists():
+            return parent
+    return script_path.parents[3]
+
+
+ROOT = project_root()
+
+
+def load_dotenv(path: Path | None = None) -> None:
+    env_path = path or (ROOT / ".env")
+    if not env_path.exists():
+        return
+    for raw in env_path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key and key not in os.environ:
+            os.environ[key] = value
+
+
+load_dotenv()
+
+
+@dataclass(frozen=True)
+class Blob:
+    left: int
+    top: int
+    right: int
+    bottom: int
+    area: int
+
+    @property
+    def cx(self) -> float:
+        return (self.left + self.right) / 2
+
+    @property
+    def cy(self) -> float:
+        return (self.top + self.bottom) / 2
+
+    @property
+    def width(self) -> int:
+        return self.right - self.left
+
+    @property
+    def height(self) -> int:
+        return self.bottom - self.top
+
+
+def remove_chroma(image: Image.Image) -> Image.Image:
+    rgba = image.convert("RGBA")
+    pixels = rgba.load()
+    for y in range(rgba.height):
+        for x in range(rgba.width):
+            r, g, b, a = pixels[x, y]
+            is_key = abs(r - MAGENTA[0]) <= 46 and g <= 96 and abs(b - MAGENTA[2]) <= 46
+            is_fringe = r >= 150 and b >= 135 and g <= 105
+            if is_key or is_fringe:
+                pixels[x, y] = (255, 0, 255, 0)
+    return rgba
+
+
+def _download_bytes(url: str) -> bytes:
+    with urllib.request.urlopen(url, timeout=120) as resp:
+        return resp.read()
+
+
+def remove_background_wavespeed(source: Path, cache_path: Path | None = None) -> Image.Image | None:
+    api_key = os.getenv("WAVESPEED_API_KEY", "").strip()
+    if not api_key:
+        return None
+
+    if cache_path and cache_path.exists():
+        return Image.open(cache_path).convert("RGBA")
+
+    payload = {
+        "image": f"data:image/png;base64,{base64.b64encode(source.read_bytes()).decode()}",
+        "enable_sync_mode": True,
+        "enable_base64_output": True,
+    }
+    req = urllib.request.Request(
+        WAVESPEED_ENDPOINT,
+        data=json.dumps(payload).encode(),
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=180) as resp:
+            result = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode(errors="replace")
+        raise RuntimeError(f"WaveSpeed HTTP {exc.code}: {body[:400]}") from exc
+
+    outputs = _extract_outputs(result)
+    if not outputs:
+        request_id = result.get("data", {}).get("id") or result.get("id")
+        if request_id:
+            outputs = _poll_wavespeed_outputs(api_key, request_id)
+    if not outputs:
+        raise RuntimeError(f"WaveSpeed returned no outputs: {json.dumps(result)[:400]}")
+
+    output = outputs[0]
+    if isinstance(output, str) and output.startswith("data:image"):
+        b64 = output.split(",", 1)[1]
+        raw = base64.b64decode(b64)
+    elif isinstance(output, str) and output.startswith("http"):
+        raw = _download_bytes(output)
+    elif isinstance(output, str) and len(output) > 128:
+        # sync mode may return raw base64 without data-uri prefix
+        raw = base64.b64decode(output)
+    else:
+        raise RuntimeError(f"Unexpected WaveSpeed output format: {str(output)[:120]}")
+
+    image = Image.open(__import__("io").BytesIO(raw)).convert("RGBA")
+    if cache_path:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        image.save(cache_path)
+    return image
+
+
+def _extract_outputs(result: dict) -> list:
+    data = result.get("data", result)
+    outputs = data.get("outputs")
+    if outputs:
+        return outputs
+    output = data.get("output")
+    return [output] if output else []
+
+
+def _poll_wavespeed_outputs(api_key: str, request_id: str, attempts: int = 40) -> list:
+    url = f"https://api.wavespeed.ai/api/v3/predictions/{request_id}/result"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    for _ in range(attempts):
+        req = urllib.request.Request(url, headers=headers, method="GET")
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            result = json.loads(resp.read().decode())
+        data = result.get("data", result)
+        status = data.get("status")
+        outputs = _extract_outputs(result)
+        if status == "completed" and outputs:
+            return outputs
+        if status == "failed":
+            raise RuntimeError(f"WaveSpeed failed: {json.dumps(result)[:400]}")
+        time.sleep(1.5)
+    raise RuntimeError(f"WaveSpeed timed out for prediction {request_id}")
+
+
+def prepare_sheet_rgba(source: Path, cache_path: Path | None = None) -> Image.Image:
+    wavespeed = remove_background_wavespeed(source, cache_path)
+    if wavespeed is not None:
+        return wavespeed
+    return remove_chroma(Image.open(source).convert("RGBA"))
+
+
+def find_blobs(alpha: Image.Image, min_area_ratio: float = 0.0012) -> list[Blob]:
+    width, height = alpha.size
+    pixels = alpha.load()
+    visited = bytearray(width * height)
+    min_area = max(64, int(width * height * min_area_ratio))
+    blobs: list[Blob] = []
+
+    def idx(x: int, y: int) -> int:
+        return y * width + x
+
+    for y in range(height):
+        for x in range(width):
+            start = idx(x, y)
+            if visited[start] or pixels[x, y] <= 12:
+                continue
+            stack = [(x, y)]
+            visited[start] = 1
+            min_x = max_x = x
+            min_y = max_y = y
+            area = 0
+            while stack:
+                cx, cy = stack.pop()
+                area += 1
+                min_x = min(min_x, cx)
+                max_x = max(max_x, cx)
+                min_y = min(min_y, cy)
+                max_y = max(max_y, cy)
+                for nx, ny in ((cx + 1, cy), (cx - 1, cy), (cx, cy + 1), (cx, cy - 1)):
+                    if nx < 0 or ny < 0 or nx >= width or ny >= height:
+                        continue
+                    nidx = idx(nx, ny)
+                    if visited[nidx] or pixels[nx, ny] <= 12:
+                        continue
+                    visited[nidx] = 1
+                    stack.append((nx, ny))
+            if area >= min_area:
+                blobs.append(Blob(min_x, min_y, max_x + 1, max_y + 1, area))
+
+    return blobs
+
+
+def sort_blobs_reading_order(blobs: list[Blob], rows: int) -> list[Blob]:
+    if not blobs:
+        return []
+    band = max(1, int(max(b.height for b in blobs) * 0.55))
+    return sorted(blobs, key=lambda b: (int(b.cy // band), b.cx))
+
+
+def crop_blob(image: Image.Image, blob: Blob, pad: int = 10) -> Image.Image:
+    return image.crop((
+        max(0, blob.left - pad),
+        max(0, blob.top - pad),
+        min(image.width, blob.right + pad),
+        min(image.height, blob.bottom + pad),
+    ))
+
+
+def filter_icon_noise(image: Image.Image) -> Image.Image:
+    alpha = image.getchannel("A")
+    width, height = image.size
+    pixels = alpha.load()
+    visited = bytearray(width * height)
+    min_area = max(8, int(width * height * 0.0015))
+    keep = Image.new("L", image.size, 0)
+    keep_pixels = keep.load()
+
+    def idx(x: int, y: int) -> int:
+        return y * width + x
+
+    components: list[list[tuple[int, int]]] = []
+    for y in range(height):
+        for x in range(width):
+            start = idx(x, y)
+            if visited[start] or pixels[x, y] <= 8:
+                continue
+            stack = [(x, y)]
+            visited[start] = 1
+            comp: list[tuple[int, int]] = []
+            while stack:
+                cx, cy = stack.pop()
+                comp.append((cx, cy))
+                for nx, ny in ((cx + 1, cy), (cx - 1, cy), (cx, cy + 1), (cx - 1, cy)):
+                    if nx < 0 or ny < 0 or nx >= width or ny >= height:
+                        continue
+                    nidx = idx(nx, ny)
+                    if visited[nidx] or pixels[nx, ny] <= 8:
+                        continue
+                    visited[nidx] = 1
+                    stack.append((nx, ny))
+            components.append(comp)
+
+    if not components:
+        return image
+
+    largest = max(components, key=len)
+    threshold = max(8, len(largest) // 40)
+    for comp in components:
+        if comp is not largest and len(comp) < threshold:
+            continue
+        if comp is not largest:
+            continue
+        for x, y in comp:
+            keep_pixels[x, y] = pixels[x, y]
+
+    out = image.copy()
+    out.putalpha(keep)
+    return out
+
+
+def crop_digit_core(image: Image.Image) -> Image.Image:
+    alpha = image.getchannel("A")
+    strong = alpha.point(lambda p: 255 if p >= 132 else 0)
+    bbox = strong.getbbox() or alpha.getbbox()
+    if not bbox:
+        return image
+    left, top, right, bottom = bbox
+    margin_x = max(3, int((right - left) * 0.18))
+    margin_y = max(3, int((bottom - top) * 0.12))
+    return image.crop((
+        max(0, left - margin_x),
+        max(0, top - margin_y),
+        min(image.width, right + margin_x),
+        min(image.height, bottom + margin_y),
+    ))
+
+
+def contain_center(image: Image.Image, size: tuple[int, int], padding: int = 4) -> Image.Image:
+    max_w = max(1, size[0] - padding * 2)
+    max_h = max(1, size[1] - padding * 2)
+    scale = min(max_w / image.width, max_h / image.height)
+    new_size = (max(1, round(image.width * scale)), max(1, round(image.height * scale)))
+    resized = image.resize(new_size, Image.Resampling.LANCZOS)
+    out = Image.new("RGBA", size, (0, 0, 0, 0))
+    out.alpha_composite(resized, ((size[0] - new_size[0]) // 2, (size[1] - new_size[1]) // 2))
+    return out

package/project-templates/threejs/skills/playable-art/scripts/import_gpt_art_sheets_v2_test.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""Unit tests for mark-first GPT art sheet importing."""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+try:
+    from PIL import Image, ImageDraw
+except ModuleNotFoundError:
+    print("skipped: Pillow unavailable")
+    raise SystemExit(0)
+
+
+SCRIPT = Path(__file__).resolve().with_name("import-gpt-art-sheets-v2.py")
+sys.path.insert(0, str(SCRIPT.parent))
+spec = importlib.util.spec_from_file_location("import_gpt_art_sheets_v2", SCRIPT)
+assert spec and spec.loader
+module = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = module
+spec.loader.exec_module(module)
+
+
+class ImportGptArtSheetsV2Test(unittest.TestCase):
+    def make_root(self) -> Path:
+        root = Path(tempfile.mkdtemp(prefix="playcraft-slice-mark-"))
+        (root / "assets" / "reference").mkdir(parents=True)
+        (root / "package.json").write_text('{"scripts":{}}\n', encoding="utf-8")
+        sheet = Image.new("RGBA", (240, 120), (255, 0, 255, 255))
+        draw = ImageDraw.Draw(sheet)
+        draw.rounded_rectangle((20, 30, 82, 92), radius=8, fill=(255, 80, 40, 255))
+        draw.rounded_rectangle((150, 24, 222, 98), radius=8, fill=(40, 120, 255, 255))
+        sheet.save(root / "assets" / "reference" / "two-sprites.png")
+        return root
+
+    def test_mark_only_writes_plan_evidence_without_sprites(self) -> None:
+        root = self.make_root()
+        sheet_spec = module.SheetSpec(
+            "two-sprites.png",
+            1,
+            (
+                module.Entry("sprite_a", "ui/sprite_a.png", (64, 64)),
+                module.Entry("sprite_b", "ui/sprite_b.png", (80, 72)),
+            ),
+            blob_pad=12,
+        )
+
+        plan = module.import_spec(sheet_spec, root, mark_only=True)
+        module._write_plan(root, [plan], root / "assets" / "reference" / "slice-plan.json")
+
+        self.assertEqual(plan["marked"], 2)
+        self.assertTrue((root / "assets" / "reference" / "slice-plan.json").exists())
+        self.assertTrue((root / "assets" / "reference" / "marked" / "two-sprites-slice-marks.png").exists())
+        self.assertFalse((root / "assets" / "images" / "ui" / "sprite_a.png").exists())
+        self.assertIn("safeSliceBox", plan["marks"][0])
+        self.assertIn("contentBox", plan["marks"][0])
+
+    def test_import_uses_safe_slice_boxes_and_target_sizes(self) -> None:
+        root = self.make_root()
+        sheet_spec = module.SheetSpec(
+            "two-sprites.png",
+            1,
+            (
+                module.Entry("sprite_a", "ui/sprite_a.png", (64, 64)),
+                module.Entry("sprite_b", "ui/sprite_b.png", (80, 72)),
+            ),
+            blob_pad=12,
+        )
+
+        plan = module.import_spec(sheet_spec, root)
+
+        self.assertEqual(plan["marked"], 2)
+        with Image.open(root / "assets" / "images" / "ui" / "sprite_a.png") as img:
+            self.assertEqual(img.size, (64, 64))
+        with Image.open(root / "assets" / "images" / "ui" / "sprite_b.png") as img:
+            self.assertEqual(img.size, (80, 72))
+
+    def test_blocking_slice_issue_does_not_write_sprites_by_default(self) -> None:
+        root = Path(tempfile.mkdtemp(prefix="playcraft-slice-block-"))
+        (root / "assets" / "reference").mkdir(parents=True)
+        (root / "package.json").write_text('{"scripts":{}}\n', encoding="utf-8")
+        sheet = Image.new("RGBA", (96, 96), (255, 0, 255, 255))
+        draw = ImageDraw.Draw(sheet)
+        draw.rectangle((0, 20, 52, 76), fill=(255, 80, 40, 255))
+        sheet.save(root / "assets" / "reference" / "edge-sprite.png")
+        sheet_spec = module.SheetSpec(
+            "edge-sprite.png",
+            1,
+            (module.Entry("sprite_edge", "ui/sprite_edge.png", (64, 64)),),
+            blob_pad=12,
+        )
+
+        plan = module.import_spec(sheet_spec, root)
+
+        self.assertTrue(plan["blocking"])
+        self.assertEqual(plan["status"], "fail")
+        self.assertFalse((root / "assets" / "images" / "ui" / "sprite_edge.png").exists())
+        self.assertTrue((root / "assets" / "reference" / "marked" / "edge-sprite-slice-marks.png").exists())
+
+    def test_allow_slice_issues_writes_sprites_for_debugging(self) -> None:
+        root = Path(tempfile.mkdtemp(prefix="playcraft-slice-allow-"))
+        (root / "assets" / "reference").mkdir(parents=True)
+        (root / "package.json").write_text('{"scripts":{}}\n', encoding="utf-8")
+        sheet = Image.new("RGBA", (96, 96), (255, 0, 255, 255))
+        draw = ImageDraw.Draw(sheet)
+        draw.rectangle((0, 20, 52, 76), fill=(255, 80, 40, 255))
+        sheet.save(root / "assets" / "reference" / "edge-sprite.png")
+        sheet_spec = module.SheetSpec(
+            "edge-sprite.png",
+            1,
+            (module.Entry("sprite_edge", "ui/sprite_edge.png", (64, 64)),),
+            blob_pad=12,
+        )
+
+        plan = module.import_spec(sheet_spec, root, allow_slice_issues=True)
+
+        self.assertTrue(plan["blocking"])
+        self.assertTrue((root / "assets" / "images" / "ui" / "sprite_edge.png").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/project-templates/threejs/skills/playable-art/scripts/placeholder_common.py

@@ -0,0 +1,98 @@
+"""Shared helpers for local placeholder PNG generation."""
+
+from __future__ import annotations
+
+from PIL import Image, ImageDraw, ImageFont
+
+
+def hex_rgb(value: str) -> tuple[int, int, int]:
+    value = value.lstrip("#")
+    return tuple(int(value[i : i + 2], 16) for i in (0, 2, 4))
+
+
+def hex_rgba(value: str, alpha: int = 255) -> tuple[int, int, int, int]:
+    r, g, b = hex_rgb(value)
+    return r, g, b, alpha
+
+
+def load_font(size: int) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    candidates = [
+        "/System/Library/Fonts/PingFang.ttc",
+        "/System/Library/Fonts/STHeiti Light.ttc",
+        "/System/Library/Fonts/Supplemental/Arial Bold.ttf",
+        "/System/Library/Fonts/Helvetica.ttc",
+        "/Library/Fonts/Arial.ttf",
+    ]
+    for path in candidates:
+        try:
+            return ImageFont.truetype(path, size)
+        except OSError:
+            continue
+    return ImageFont.load_default()
+
+
+def fit_font(
+    draw: ImageDraw.ImageDraw,
+    text: str,
+    max_w: int,
+    max_h: int,
+    start_size: int = 48,
+    min_size: int = 14,
+) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+    for size in range(start_size, min_size - 1, -2):
+        font = load_font(size)
+        bbox = draw.textbbox((0, 0), text, font=font)
+        tw = bbox[2] - bbox[0]
+        th = bbox[3] - bbox[1]
+        if tw <= max_w and th <= max_h:
+            return font
+    return load_font(min_size)
+
+
+def draw_centered_text(
+    draw: ImageDraw.ImageDraw,
+    box: tuple[int, int, int, int],
+    text: str,
+    fill: tuple[int, int, int] | tuple[int, int, int, int],
+    font: ImageFont.FreeTypeFont | ImageFont.ImageFont | None = None,
+) -> None:
+    x0, y0, x1, y1 = box
+    inner_w = x1 - x0
+    inner_h = y1 - y0
+    font = font or fit_font(draw, text, inner_w, inner_h)
+    bbox = draw.textbbox((0, 0), text, font=font)
+    tw = bbox[2] - bbox[0]
+    th = bbox[3] - bbox[1]
+    x = x0 + (inner_w - tw) / 2 - bbox[0]
+    y = y0 + (inner_h - th) / 2 - bbox[1]
+    draw.text((x, y), text, fill=fill, font=font)
+
+
+def draw_panel(
+    size: tuple[int, int],
+    *,
+    fill: str = "#1A0A00",
+    stroke: str = "#D4A838",
+    stroke_width: int = 3,
+    radius: int = 16,
+    label: str | None = None,
+    subtitle: str | None = None,
+    label_color: str = "#D4A838",
+    subtitle_color: str = "#FFD700",
+) -> Image.Image:
+    w, h = size
+    image = Image.new("RGBA", (w, h), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    pad = max(4, stroke_width + 1)
+    box = (pad, pad, w - pad - 1, h - pad - 1)
+
+    draw.rounded_rectangle(box, radius=radius, fill=hex_rgba(fill), outline=hex_rgba(stroke), width=stroke_width)
+
+    if subtitle and label:
+        mid = (box[1] + box[3]) // 2
+        draw_centered_text(draw, (box[0], box[1], box[2], mid), label, hex_rgb(label_color))
+        draw_centered_text(draw, (box[0], mid, box[2], box[3]), subtitle, hex_rgb(subtitle_color))
+    elif label:
+        draw_centered_text(draw, box, label, hex_rgb(label_color))
+
+    return image