| from __future__ import annotations |
|
|
| import json |
| import math |
| import random |
| from pathlib import Path |
| from typing import Any |
|
|
| from PIL import Image, ImageDraw, ImageFilter, ImageFont |
|
|
|
|
| CANVAS_SIZE = (1024, 1024) |
| OUT_DIR = Path("10samples") |
| IDENTITY_THRESHOLD = 0.55 |
| IOU_THRESHOLD = 0.10 |
|
|
|
|
| def font(size: int, bold: bool = False) -> ImageFont.ImageFont: |
| candidates = [ |
| "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", |
| "/usr/share/fonts/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/dejavu/DejaVuSans.ttf", |
| ] |
| for path in candidates: |
| try: |
| return ImageFont.truetype(path, size) |
| except OSError: |
| pass |
| return ImageFont.load_default() |
|
|
|
|
| FONT_18 = font(18) |
| FONT_24 = font(24) |
| FONT_32 = font(32, bold=True) |
|
|
|
|
| def clamp(value: float, low: float = 0.0, high: float = 1.0) -> float: |
| return max(low, min(high, value)) |
|
|
|
|
| def bbox_px(bbox: list[float], size: tuple[int, int] = CANVAS_SIZE) -> tuple[int, int, int, int]: |
| w, h = size |
| return ( |
| int(round(clamp(bbox[0]) * w)), |
| int(round(clamp(bbox[1]) * h)), |
| int(round(clamp(bbox[2]) * w)), |
| int(round(clamp(bbox[3]) * h)), |
| ) |
|
|
|
|
| def normalize_bbox(box: tuple[int, int, int, int], size: tuple[int, int] = CANVAS_SIZE) -> list[float]: |
| w, h = size |
| x1, y1, x2, y2 = box |
| vals = [x1 / w, y1 / h, x2 / w, y2 / h] |
| return [round(clamp(v), 4) for v in vals] |
|
|
|
|
| def jitter_bbox(bbox: list[float], rng: random.Random) -> list[float]: |
| x1, y1, x2, y2 = bbox |
| width = x2 - x1 |
| height = y2 - y1 |
| dx = rng.uniform(-0.018, 0.018) * width |
| dy = rng.uniform(-0.018, 0.018) * height |
| grow_x = rng.uniform(-0.018, 0.024) * width |
| grow_y = rng.uniform(-0.018, 0.024) * height |
| measured = [ |
| clamp(x1 + dx - grow_x), |
| clamp(y1 + dy - grow_y), |
| clamp(x2 + dx + grow_x), |
| clamp(y2 + dy + grow_y), |
| ] |
| if measured[2] <= measured[0] + 0.01: |
| measured[2] = clamp(measured[0] + 0.01) |
| if measured[3] <= measured[1] + 0.01: |
| measured[3] = clamp(measured[1] + 0.01) |
| return [round(v, 4) for v in measured] |
|
|
|
|
| def iou(a: list[float], b: list[float]) -> float: |
| ax1, ay1, ax2, ay2 = a |
| bx1, by1, bx2, by2 = b |
| ix1, iy1 = max(ax1, bx1), max(ay1, by1) |
| ix2, iy2 = min(ax2, bx2), min(ay2, by2) |
| iw, ih = max(0.0, ix2 - ix1), max(0.0, iy2 - iy1) |
| inter = iw * ih |
| area_a = max(0.0, ax2 - ax1) * max(0.0, ay2 - ay1) |
| area_b = max(0.0, bx2 - bx1) * max(0.0, by2 - by1) |
| denom = area_a + area_b - inter |
| return 0.0 if denom == 0 else round(inter / denom, 4) |
|
|
|
|
| def lighten(color: tuple[int, int, int], amount: float) -> tuple[int, int, int]: |
| return tuple(int(c + (255 - c) * amount) for c in color) |
|
|
|
|
| def darken(color: tuple[int, int, int], amount: float) -> tuple[int, int, int]: |
| return tuple(int(c * (1 - amount)) for c in color) |
|
|
|
|
| def gradient(size: tuple[int, int], top: tuple[int, int, int], bottom: tuple[int, int, int]) -> Image.Image: |
| w, h = size |
| img = Image.new("RGB", size, top) |
| draw = ImageDraw.Draw(img) |
| for y in range(h): |
| t = y / max(1, h - 1) |
| color = tuple(int(top[i] * (1 - t) + bottom[i] * t) for i in range(3)) |
| draw.line([(0, y), (w, y)], fill=color) |
| return img |
|
|
|
|
| def paste_shadow(base: Image.Image, layer: Image.Image, offset: tuple[int, int] = (8, 10), blur: int = 12) -> None: |
| alpha = layer.split()[-1] |
| shadow = Image.new("RGBA", layer.size, (0, 0, 0, 0)) |
| shadow.putalpha(alpha.filter(ImageFilter.GaussianBlur(blur))) |
| sx, sy = offset |
| base.alpha_composite(shadow, (sx, sy)) |
| base.alpha_composite(layer) |
|
|
|
|
| def rounded_rect(draw: ImageDraw.ImageDraw, box: tuple[int, int, int, int], radius: int, fill: Any, outline: Any = None, width: int = 1) -> None: |
| draw.rounded_rectangle(box, radius=radius, fill=fill, outline=outline, width=width) |
|
|
|
|
| def draw_background(draw: ImageDraw.ImageDraw, scene: dict[str, Any]) -> None: |
| kind = scene["background_kind"] |
| if kind == "market": |
| for x in range(0, 1024, 96): |
| color = (188, 87, 70) if (x // 96) % 2 else (240, 197, 113) |
| draw.polygon([(x, 0), (x + 96, 0), (x + 70, 110), (x + 26, 110)], fill=color) |
| draw.rectangle((0, 672, 1024, 1024), fill=(126, 113, 91)) |
| for x in range(-80, 1024, 160): |
| draw.line((x, 720, x + 260, 1024), fill=(100, 91, 76), width=5) |
| draw.rectangle((0, 545, 1024, 650), fill=(99, 73, 48)) |
| elif kind == "kitchen": |
| draw.rectangle((0, 0, 1024, 460), fill=(206, 222, 224)) |
| for x in range(0, 1024, 128): |
| draw.rectangle((x, 0, x + 126, 458), outline=(178, 198, 201), width=2) |
| draw.rectangle((0, 560, 1024, 1024), fill=(189, 155, 105)) |
| for x in range(-150, 1200, 150): |
| draw.line((x, 560, x + 210, 1024), fill=(159, 128, 84), width=4) |
| draw.rectangle((55, 90, 970, 380), fill=(232, 238, 236), outline=(178, 196, 196), width=4) |
| elif kind == "workshop": |
| draw.rectangle((0, 0, 1024, 1024), fill=(88, 91, 87)) |
| for y in range(110, 640, 110): |
| draw.line((0, y, 1024, y), fill=(67, 70, 68), width=7) |
| draw.rectangle((0, 640, 1024, 1024), fill=(107, 94, 75)) |
| for x in range(70, 1000, 170): |
| draw.rectangle((x, 80, x + 24, 520), fill=(54, 57, 55)) |
| draw.rectangle((50, 560, 974, 700), fill=(73, 58, 43)) |
| elif kind == "library": |
| draw.rectangle((0, 0, 1024, 1024), fill=(119, 82, 55)) |
| for y in (84, 250, 416, 582): |
| draw.rectangle((0, y, 1024, y + 18), fill=(83, 55, 37)) |
| rng = random.Random(12) |
| for x in range(18, 1010, 30): |
| for y in (105, 271, 437): |
| h = rng.randint(88, 132) |
| draw.rectangle((x, y, x + rng.randint(14, 24), y + h), fill=rng.choice([(156, 53, 58), (61, 97, 130), (205, 160, 74), (84, 123, 92)])) |
| draw.rectangle((0, 650, 1024, 1024), fill=(156, 127, 86)) |
| elif kind == "greenhouse": |
| draw.rectangle((0, 0, 1024, 1024), fill=(176, 209, 199)) |
| for x in range(0, 1025, 128): |
| draw.line((x, 0, x + 180, 650), fill=(123, 153, 146), width=5) |
| draw.rectangle((0, 615, 1024, 1024), fill=(104, 126, 87)) |
| for _ in range(70): |
| x = random.randint(0, 1024) |
| y = random.randint(490, 1024) |
| draw.ellipse((x - 18, y - 8, x + 18, y + 8), fill=random.choice([(45, 117, 72), (62, 145, 82), (86, 121, 69)])) |
| elif kind == "laundromat": |
| draw.rectangle((0, 0, 1024, 1024), fill=(202, 213, 218)) |
| for x in range(55, 985, 155): |
| draw.rectangle((x, 100, x + 116, 270), fill=(164, 178, 187), outline=(100, 117, 128), width=5) |
| draw.ellipse((x + 22, 122, x + 94, 194), fill=(107, 139, 162), outline=(230, 238, 241), width=5) |
| draw.rectangle((0, 560, 1024, 1024), fill=(132, 149, 156)) |
| draw.rectangle((0, 440, 1024, 540), fill=(176, 188, 194)) |
| elif kind == "picnic": |
| draw.rectangle((0, 0, 1024, 490), fill=(139, 185, 216)) |
| draw.ellipse((-120, 170, 1140, 870), fill=(90, 153, 86)) |
| draw.rectangle((0, 735, 1024, 1024), fill=(79, 133, 74)) |
| for _ in range(90): |
| x = random.randint(0, 1024) |
| y = random.randint(500, 1010) |
| draw.line((x, y, x + 16, y - 20), fill=(55, 110, 58), width=2) |
| elif kind == "music_room": |
| draw.rectangle((0, 0, 1024, 1024), fill=(84, 74, 82)) |
| draw.rectangle((0, 0, 1024, 260), fill=(62, 53, 63)) |
| for x in range(80, 950, 180): |
| draw.ellipse((x, 58, x + 70, 128), fill=(235, 196, 105)) |
| draw.line((x + 35, 128, x + 20, 260), fill=(235, 196, 105), width=5) |
| draw.rectangle((0, 660, 1024, 1024), fill=(115, 89, 70)) |
| elif kind == "clinic": |
| draw.rectangle((0, 0, 1024, 1024), fill=(219, 229, 225)) |
| for x in range(0, 1024, 128): |
| draw.line((x, 0, x, 600), fill=(195, 209, 205), width=2) |
| draw.rectangle((0, 610, 1024, 1024), fill=(174, 193, 190)) |
| draw.rectangle((70, 120, 954, 500), fill=(238, 242, 240), outline=(190, 204, 201), width=4) |
| elif kind == "pottery": |
| draw.rectangle((0, 0, 1024, 1024), fill=(153, 117, 91)) |
| for y in range(90, 560, 145): |
| draw.rectangle((0, y, 1024, y + 18), fill=(107, 79, 60)) |
| draw.rectangle((0, 650, 1024, 1024), fill=(128, 91, 68)) |
| for x in range(20, 1024, 140): |
| draw.ellipse((x, 135, x + 90, 200), fill=(185, 126, 78), outline=(99, 73, 52), width=4) |
|
|
|
|
| def draw_person(layer: Image.Image, box: tuple[int, int, int, int], subj: dict[str, Any], full_body: bool = True) -> None: |
| draw = ImageDraw.Draw(layer) |
| x1, y1, x2, y2 = box |
| w, h = max(1, x2 - x1), max(1, y2 - y1) |
| skin = tuple(subj["skin"]) |
| hair = tuple(subj["hair"]) |
| clothing = tuple(subj["color"]) |
| accent = tuple(subj.get("accent", lighten(clothing, 0.35))) |
| cx = x1 + w // 2 |
| head_r = max(14, int(min(w, h) * (0.14 if full_body else 0.22))) |
| head_cy = y1 + int(h * (0.18 if full_body else 0.32)) |
| body_top = head_cy + head_r - 4 |
| body_bottom = y2 - int(h * 0.10) |
| shoulder_w = int(w * (0.34 if full_body else 0.48)) |
| hip_w = int(w * (0.24 if full_body else 0.36)) |
| draw.ellipse((cx - head_r - 5, head_cy - head_r - 9, cx + head_r + 5, head_cy + head_r + 5), fill=hair) |
| draw.ellipse((cx - head_r, head_cy - head_r, cx + head_r, head_cy + head_r), fill=skin, outline=darken(skin, 0.25), width=2) |
| draw.arc((cx - head_r // 2, head_cy - 2, cx + head_r // 2, head_cy + head_r // 2), 10, 170, fill=darken(skin, 0.45), width=2) |
| draw.ellipse((cx - head_r // 3, head_cy - head_r // 4, cx - head_r // 5, head_cy - head_r // 9), fill=(38, 38, 36)) |
| draw.ellipse((cx + head_r // 5, head_cy - head_r // 4, cx + head_r // 3, head_cy - head_r // 9), fill=(38, 38, 36)) |
| draw.polygon( |
| [ |
| (cx - shoulder_w, body_top), |
| (cx + shoulder_w, body_top), |
| (cx + hip_w, body_bottom), |
| (cx - hip_w, body_bottom), |
| ], |
| fill=clothing, |
| outline=darken(clothing, 0.25), |
| ) |
| draw.line((cx - shoulder_w + 4, body_top + 12, x1 + int(w * 0.13), y1 + int(h * 0.58)), fill=skin, width=max(5, w // 14)) |
| draw.line((cx + shoulder_w - 4, body_top + 12, x2 - int(w * 0.13), y1 + int(h * 0.58)), fill=skin, width=max(5, w // 14)) |
| if full_body: |
| leg_top = body_bottom - 2 |
| draw.line((cx - hip_w // 2, leg_top, cx - int(w * 0.18), y2 - 4), fill=darken(clothing, 0.42), width=max(7, w // 12)) |
| draw.line((cx + hip_w // 2, leg_top, cx + int(w * 0.18), y2 - 4), fill=darken(clothing, 0.42), width=max(7, w // 12)) |
| draw.line((cx - shoulder_w + 5, body_top + int(h * 0.12), cx + shoulder_w - 5, body_top + int(h * 0.12)), fill=accent, width=max(3, h // 42)) |
|
|
|
|
| def draw_object(layer: Image.Image, box: tuple[int, int, int, int], subj: dict[str, Any]) -> None: |
| draw = ImageDraw.Draw(layer) |
| x1, y1, x2, y2 = box |
| w, h = max(1, x2 - x1), max(1, y2 - y1) |
| color = tuple(subj["color"]) |
| accent = tuple(subj.get("accent", lighten(color, 0.35))) |
| kind = subj.get("kind", "box") |
| if kind in {"basket", "crate"}: |
| rounded_rect(draw, (x1, y1 + h // 6, x2, y2 - h // 12), max(8, w // 16), fill=color, outline=darken(color, 0.35), width=max(3, w // 30)) |
| for i in range(4): |
| yy = y1 + h // 4 + i * h // 7 |
| draw.line((x1 + 8, yy, x2 - 8, yy), fill=darken(color, 0.28), width=3) |
| for i in range(5): |
| xx = x1 + w // 7 + i * w // 7 |
| draw.line((xx, y1 + h // 5, xx, y2 - h // 8), fill=lighten(color, 0.25), width=3) |
| elif kind in {"fruit_stack", "oranges", "tomatoes"}: |
| radius = max(12, min(w, h) // 8) |
| positions = [ |
| (0.25, 0.68), (0.40, 0.52), (0.56, 0.66), (0.69, 0.48), (0.48, 0.32), |
| (0.22, 0.38), (0.74, 0.72), (0.58, 0.22), |
| ] |
| for px, py in positions: |
| cx, cy = x1 + int(px * w), y1 + int(py * h) |
| draw.ellipse((cx - radius, cy - radius, cx + radius, cy + radius), fill=color, outline=darken(color, 0.28), width=2) |
| draw.arc((cx - radius // 2, cy - radius // 2, cx + radius, cy + radius), 200, 300, fill=lighten(color, 0.45), width=2) |
| elif kind == "umbrella": |
| draw.pieslice((x1, y1, x2, y1 + int(h * 0.9)), 180, 360, fill=color, outline=darken(color, 0.35), width=max(3, w // 40)) |
| for i in range(1, 5): |
| xx = x1 + i * w // 5 |
| draw.line((x1 + w // 2, y1 + h // 4, xx, y1 + int(h * 0.45)), fill=darken(color, 0.25), width=2) |
| draw.line((x1 + w // 2, y1 + h // 3, x1 + w // 2, y2), fill=darken(color, 0.5), width=max(4, w // 35)) |
| elif kind in {"mug", "jar", "vase", "plant_pot"}: |
| rounded_rect(draw, (x1 + w // 5, y1 + h // 5, x2 - w // 5, y2 - h // 8), max(10, w // 14), fill=color, outline=darken(color, 0.3), width=max(3, w // 35)) |
| draw.ellipse((x1 + w // 5, y1 + h // 8, x2 - w // 5, y1 + h // 3), fill=lighten(color, 0.2), outline=darken(color, 0.25), width=2) |
| if kind == "mug": |
| draw.arc((x2 - w // 3, y1 + h // 3, x2 - w // 15, y1 + h * 2 // 3), -80, 95, fill=darken(color, 0.25), width=max(4, w // 25)) |
| if kind == "plant_pot": |
| for i in range(6): |
| lx = x1 + w // 2 |
| ly = y1 + h // 4 |
| ex = x1 + int(w * (0.15 + 0.14 * i)) |
| ey = y1 + int(h * (0.05 + 0.07 * (i % 2))) |
| draw.line((lx, ly, ex, ey), fill=(44, 116, 65), width=max(3, w // 36)) |
| draw.ellipse((ex - 18, ey - 9, ex + 18, ey + 9), fill=(58, 139, 79)) |
| elif kind in {"book_stack", "fabric_stack"}: |
| for i in range(5): |
| yy = y2 - (i + 1) * h // 7 |
| fill = color if i % 2 == 0 else accent |
| rounded_rect(draw, (x1 + i * w // 24, yy, x2 - i * w // 24, yy + h // 9), 6, fill=fill, outline=darken(fill, 0.3), width=2) |
| elif kind == "lamp": |
| draw.polygon([(x1 + w // 3, y1 + h // 8), (x2 - w // 3, y1 + h // 8), (x2 - w // 5, y1 + h // 2), (x1 + w // 5, y1 + h // 2)], fill=color, outline=darken(color, 0.25)) |
| draw.line((x1 + w // 2, y1 + h // 2, x1 + w // 2, y2 - h // 8), fill=darken(color, 0.55), width=max(5, w // 30)) |
| draw.ellipse((x1 + w // 4, y2 - h // 5, x2 - w // 4, y2 - h // 12), fill=darken(color, 0.25)) |
| elif kind == "instrument": |
| draw.ellipse((x1 + w // 4, y1 + h // 3, x2 - w // 6, y2 - h // 8), fill=color, outline=darken(color, 0.35), width=max(3, w // 35)) |
| draw.ellipse((x1 + w // 3, y1 + h // 2, x1 + w // 2, y1 + h * 2 // 3), fill=darken(color, 0.45)) |
| draw.rectangle((x1 + w // 12, y1 + h // 6, x1 + w // 3, y1 + h // 4), fill=darken(color, 0.35)) |
| for i in range(4): |
| y = y1 + h // 5 + i * h // 35 |
| draw.line((x1 + w // 10, y, x2 - w // 5, y + h // 3), fill=(235, 228, 193), width=1) |
| elif kind == "bicycle": |
| draw.ellipse((x1, y1 + h // 2, x1 + w // 3, y2), outline=darken(color, 0.35), width=max(5, w // 35)) |
| draw.ellipse((x2 - w // 3, y1 + h // 2, x2, y2), outline=darken(color, 0.35), width=max(5, w // 35)) |
| draw.line((x1 + w // 6, y1 + h * 3 // 4, x1 + w // 2, y1 + h // 3), fill=color, width=max(5, w // 35)) |
| draw.line((x1 + w // 2, y1 + h // 3, x2 - w // 6, y1 + h * 3 // 4), fill=color, width=max(5, w // 35)) |
| draw.line((x1 + w // 6, y1 + h * 3 // 4, x2 - w // 6, y1 + h * 3 // 4), fill=color, width=max(5, w // 35)) |
| elif kind == "dog": |
| draw.ellipse((x1 + w // 5, y1 + h // 3, x2 - w // 8, y2 - h // 6), fill=color, outline=darken(color, 0.3), width=3) |
| draw.ellipse((x1, y1 + h // 5, x1 + w // 3, y1 + h // 2), fill=color, outline=darken(color, 0.3), width=3) |
| draw.polygon([(x1 + w // 10, y1 + h // 5), (x1 + w // 4, y1 + h // 9), (x1 + w // 5, y1 + h // 3)], fill=darken(color, 0.18)) |
| draw.line((x2 - w // 7, y1 + h // 2, x2, y1 + h // 4), fill=color, width=max(5, w // 20)) |
| for lx in (x1 + w // 3, x1 + w * 2 // 3): |
| draw.line((lx, y2 - h // 4, lx - w // 18, y2), fill=darken(color, 0.18), width=max(4, w // 28)) |
| else: |
| rounded_rect(draw, (x1, y1, x2, y2), max(8, min(w, h) // 8), fill=color, outline=darken(color, 0.28), width=max(3, w // 35)) |
| draw.line((x1 + w // 7, y1 + h // 4, x2 - w // 7, y1 + h // 4), fill=accent, width=max(3, h // 30)) |
|
|
|
|
| def draw_subject(base: Image.Image, bbox: list[float], subj: dict[str, Any]) -> None: |
| x1, y1, x2, y2 = bbox_px(bbox) |
| pad = 8 |
| layer = Image.new("RGBA", CANVAS_SIZE, (0, 0, 0, 0)) |
| draw_box = (x1 + pad, y1 + pad, x2 - pad, y2 - pad) |
| if subj["is_person"]: |
| draw_person(layer, draw_box, subj, full_body=True) |
| else: |
| draw_object(layer, draw_box, subj) |
| paste_shadow(base, layer, offset=(0, 0), blur=10) |
|
|
|
|
| def draw_reference(subj: dict[str, Any], path: Path, rng: random.Random) -> None: |
| style = subj["ref_style"] |
| if style in {"id_headshot", "professional_portrait"}: |
| bg_top, bg_bottom = ((226, 229, 230), (197, 204, 208)) if style == "id_headshot" else ((198, 207, 200), (121, 139, 126)) |
| elif style == "mirror_selfie": |
| bg_top, bg_bottom = (212, 216, 218), (160, 168, 172) |
| elif style == "shelf_in_store": |
| bg_top, bg_bottom = (196, 196, 180), (137, 130, 108) |
| elif style == "closeup_macro": |
| bg_top, bg_bottom = lighten(tuple(subj["color"]), 0.65), darken(tuple(subj["color"]), 0.20) |
| elif style == "flatlay_topdown": |
| bg_top, bg_bottom = (224, 222, 213), (199, 196, 186) |
| elif style == "in_context_natural": |
| bg_top, bg_bottom = (190, 206, 196), (126, 143, 128) |
| else: |
| bg_top, bg_bottom = (235, 235, 232), (210, 211, 207) |
|
|
| img = gradient(CANVAS_SIZE, bg_top, bg_bottom).convert("RGBA") |
| d = ImageDraw.Draw(img) |
|
|
| if style == "mirror_selfie": |
| rounded_rect(d, (176, 80, 848, 944), 28, fill=(227, 229, 229), outline=(98, 106, 112), width=16) |
| rounded_rect(d, (230, 138, 794, 890), 18, fill=(198, 205, 207), outline=(170, 176, 180), width=5) |
| d.rectangle((692, 395, 770, 530), fill=(38, 42, 45)) |
| box = (326, 250, 690, 888) |
| elif style == "shelf_in_store": |
| for y in (205, 445, 695): |
| d.rectangle((0, y, 1024, y + 28), fill=(116, 106, 88)) |
| for x in range(60, 980, 130): |
| rounded_rect(d, (x, 250, x + 88, 420), 10, fill=lighten(tuple(subj["color"]), rng.uniform(0.1, 0.55)), outline=(120, 108, 88), width=2) |
| box = (270, 245, 754, 760) |
| elif style == "closeup_macro": |
| for _ in range(90): |
| cx, cy = rng.randint(0, 1024), rng.randint(0, 1024) |
| r = rng.randint(7, 28) |
| fill = lighten(tuple(subj["color"]), rng.uniform(0.05, 0.45)) + (70,) |
| d.ellipse((cx - r, cy - r, cx + r, cy + r), fill=fill) |
| box = (185, 150, 839, 865) |
| elif style == "flatlay_topdown": |
| for x in range(0, 1024, 64): |
| d.line((x, 0, x, 1024), fill=(204, 201, 192), width=1) |
| for y in range(0, 1024, 64): |
| d.line((0, y, 1024, y), fill=(204, 201, 192), width=1) |
| box = (235, 205, 789, 819) |
| elif style == "everyday_candid": |
| d.rectangle((0, 630, 1024, 1024), fill=(139, 145, 134)) |
| d.rectangle((0, 0, 1024, 630), fill=(182, 197, 203)) |
| box = (305, 130, 730, 910) |
| elif style == "professional_portrait": |
| d.rectangle((0, 680, 1024, 1024), fill=(98, 99, 88)) |
| d.ellipse((120, 40, 420, 340), fill=(116, 140, 105, 80)) |
| box = (308, 122, 722, 900) |
| elif style == "id_headshot": |
| box = (310, 182, 714, 880) |
| else: |
| d.ellipse((120, 90, 904, 870), fill=(255, 255, 255, 72)) |
| box = (245, 185, 779, 825) |
|
|
| if subj["is_person"]: |
| draw_person(img, box, subj, full_body=style not in {"id_headshot", "professional_portrait"}) |
| else: |
| draw_object(img, box, subj) |
|
|
| img.convert("RGB").save(path) |
|
|
|
|
| def draw_layout_sketch(plan: dict[str, Any], path: Path) -> None: |
| img = Image.new("RGBA", CANVAS_SIZE, (248, 248, 245, 255)) |
| d = ImageDraw.Draw(img) |
| for x in range(0, 1025, 128): |
| d.line((x, 0, x, 1024), fill=(220, 220, 216), width=1) |
| for y in range(0, 1025, 128): |
| d.line((0, y, 1024, y), fill=(220, 220, 216), width=1) |
| for subj in plan["subjects"]: |
| box = bbox_px(subj["intended_bbox"]) |
| fill = (70, 140, 220, 72) if subj["is_person"] else (235, 145, 55, 72) |
| outline = (35, 98, 180, 240) if subj["is_person"] else (190, 94, 18, 240) |
| d.rectangle(box, fill=fill, outline=outline, width=4) |
| label = subj["name"] |
| tb = d.textbbox((0, 0), label, font=FONT_24) |
| d.rectangle((box[0] + 6, box[1] + 6, box[0] + 18 + tb[2], box[1] + 40), fill=(255, 255, 255, 220)) |
| d.text((box[0] + 12, box[1] + 9), label, fill=(32, 32, 32), font=FONT_24) |
| img.convert("RGB").save(path) |
|
|
|
|
| def draw_overlay(main_image: Path, subjects: list[dict[str, Any]], key: str, path: Path, accepted_only: bool = False) -> None: |
| img = Image.open(main_image).convert("RGBA") |
| d = ImageDraw.Draw(img) |
| for subj in subjects: |
| if accepted_only and not subj.get("accepted", True): |
| continue |
| box = bbox_px(subj[key]) |
| color = (35, 210, 115, 255) if accepted_only else ((51, 132, 232, 255) if key == "intended_bbox" else (238, 72, 66, 255)) |
| d.rectangle(box, outline=color, width=5) |
| label = subj["name"] |
| tb = d.textbbox((0, 0), label, font=FONT_18) |
| d.rectangle((box[0], max(0, box[1] - 28), box[0] + tb[2] + 12, max(24, box[1] - 2)), fill=(0, 0, 0, 170)) |
| d.text((box[0] + 6, max(0, box[1] - 27)), label, fill=(255, 255, 255), font=FONT_18) |
| img.convert("RGB").save(path) |
|
|
|
|
| def draw_main(plan: dict[str, Any], path: Path) -> None: |
| img = gradient(CANVAS_SIZE, tuple(plan["bg_top"]), tuple(plan["bg_bottom"])).convert("RGBA") |
| d = ImageDraw.Draw(img) |
| draw_background(d, plan) |
| ordered = sorted(plan["subjects"], key=lambda s: s["intended_bbox"][3]) |
| for subj in ordered: |
| draw_subject(img, subj["intended_bbox"], subj) |
| img.convert("RGB").save(path) |
|
|
|
|
| def subject( |
| name: str, |
| is_person: bool, |
| sub_caption: str, |
| bbox: list[float], |
| ref_style: str, |
| ref_prompt: str, |
| color: tuple[int, int, int], |
| *, |
| accent: tuple[int, int, int] | None = None, |
| skin: tuple[int, int, int] = (171, 119, 82), |
| hair: tuple[int, int, int] = (50, 38, 32), |
| kind: str = "box", |
| ) -> dict[str, Any]: |
| item = { |
| "name": name, |
| "is_person": is_person, |
| "sub_caption": sub_caption, |
| "intended_bbox": bbox, |
| "ref_style": ref_style, |
| "ref_prompt": ref_prompt, |
| "color": color, |
| "accent": accent or lighten(color, 0.35), |
| "kind": kind, |
| } |
| if is_person: |
| item["skin"] = skin |
| item["hair"] = hair |
| return item |
|
|
|
|
| def build_plans() -> list[dict[str, Any]]: |
| return [ |
| { |
| "sample_id": "sample_0001", |
| "scene_caption": "A rainy market stall bustles as a vendor steadies a display while a shopper reaches for fruit under a green umbrella.", |
| "story": "The rain has just eased, and the stall is busy again. A quick exchange between vendor and shopper gives the scene a focused, everyday energy.", |
| "background": "Covered outdoor produce market, damp stone floor, warm awning light, late afternoon.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "market", |
| "bg_top": (186, 197, 198), |
| "bg_bottom": (128, 118, 96), |
| "subjects": [ |
| subject("vendor_in_apron", True, "middle-aged person with short dark hair, tan skin, blue apron, leaning forward with a concentrated expression", [0.08, 0.24, 0.31, 0.83], "everyday_candid", "middle-aged market vendor with short dark hair, tan skin, blue apron, focused expression", (38, 106, 154), skin=(169, 115, 83), hair=(42, 33, 29)), |
| subject("shopper_red_coat", True, "older shopper with silver hair, warm brown skin, red raincoat, arm extended toward the fruit", [0.26, 0.22, 0.50, 0.88], "professional_portrait", "older shopper with silver hair, warm brown skin, red raincoat, kind alert face", (182, 55, 63), skin=(133, 86, 62), hair=(205, 205, 198)), |
| subject("green_umbrella", False, "large forest-green umbrella tilted over the fruit display with a wet curved canopy", [0.37, 0.04, 0.82, 0.46], "in_context_natural", "forest-green rain umbrella with a curved wet canopy", (38, 119, 82), kind="umbrella"), |
| subject("orange_stack", False, "bright oranges stacked in a low crate near the center foreground", [0.44, 0.49, 0.71, 0.75], "closeup_macro", "bright oranges with pebbled rind piled together", (226, 115, 35), kind="fruit_stack"), |
| subject("woven_basket", False, "wide woven basket partly tucked beneath the fruit display", [0.61, 0.62, 0.88, 0.87], "studio_product", "wide tan woven market basket with sturdy handles", (174, 121, 68), kind="basket"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0002", |
| "scene_caption": "A family breakfast table is mid-preparation as two people arrange food around a ceramic mug and a stack of books.", |
| "story": "The morning is calm but active. One person is setting the table while another pauses with a small smile before sitting down.", |
| "background": "Bright home kitchen with pale tile, wood table, diffuse window light.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "kitchen", |
| "bg_top": (225, 235, 235), |
| "bg_bottom": (176, 147, 105), |
| "subjects": [ |
| subject("person_yellow_sweater", True, "young adult with curly black hair, medium brown skin, yellow sweater, holding a plate near the table", [0.11, 0.18, 0.37, 0.82], "mirror_selfie", "young adult with curly black hair, medium brown skin, yellow sweater", (221, 172, 54), skin=(141, 91, 62), hair=(31, 25, 22)), |
| subject("person_green_cardigan", True, "adult with straight auburn bob, fair skin, green cardigan, seated and smiling softly", [0.55, 0.25, 0.82, 0.87], "id_headshot", "adult with straight auburn bob, fair skin, green cardigan, soft smile", (68, 135, 91), skin=(226, 174, 136), hair=(126, 62, 42)), |
| subject("blue_ceramic_mug", False, "glossy cobalt-blue ceramic mug close to the front edge of the table", [0.35, 0.58, 0.51, 0.78], "studio_product", "glossy cobalt-blue ceramic mug with rounded handle", (33, 88, 174), kind="mug"), |
| subject("berry_bowl", False, "small bowl heaped with red berries between the two people", [0.45, 0.48, 0.63, 0.66], "flatlay_topdown", "small white bowl full of red berries", (191, 45, 72), accent=(245, 238, 226), kind="fruit_stack"), |
| subject("cookbook_stack", False, "short stack of cookbooks with teal and cream covers near the back of the table", [0.18, 0.46, 0.39, 0.62], "shelf_in_store", "short stack of teal and cream cookbooks", (55, 134, 142), accent=(232, 219, 184), kind="book_stack"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0003", |
| "scene_caption": "In a repair workshop, a mechanic and an assistant coordinate around a bicycle frame, tool crate, and yellow lamp.", |
| "story": "The team is close to solving the repair. Their body language shows concentration as tools and parts crowd the bench.", |
| "background": "Dim bicycle workshop, pegboard walls, worn wooden bench, focused task lighting.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "workshop", |
| "bg_top": (92, 98, 96), |
| "bg_bottom": (89, 75, 57), |
| "subjects": [ |
| subject("mechanic_gray_overalls", True, "stocky adult with shaved head, deep brown skin, gray overalls, crouched toward the bicycle", [0.07, 0.24, 0.34, 0.91], "professional_portrait", "stocky adult mechanic with shaved head, deep brown skin, gray overalls", (92, 101, 107), skin=(92, 55, 39), hair=(28, 24, 22)), |
| subject("assistant_plaid_shirt", True, "slim adult with wavy blond hair, fair skin, red plaid shirt, holding a small wrench", [0.68, 0.19, 0.91, 0.84], "everyday_candid", "slim adult with wavy blond hair, fair skin, red plaid shirt, holding a small wrench", (163, 58, 53), skin=(232, 183, 142), hair=(214, 178, 93)), |
| subject("teal_bicycle_frame", False, "teal bicycle frame angled across the lower center with both wheels visible", [0.29, 0.49, 0.76, 0.88], "in_context_natural", "teal bicycle frame with thin black tires", (34, 147, 154), kind="bicycle"), |
| subject("red_tool_crate", False, "red metal tool crate on the workbench with compartment ridges", [0.31, 0.38, 0.54, 0.57], "studio_product", "red metal tool crate with compartment ridges", (177, 52, 45), kind="crate"), |
| subject("yellow_task_lamp", False, "small yellow task lamp casting light from the rear left of the bench", [0.10, 0.06, 0.30, 0.38], "closeup_macro", "small yellow metal task lamp with round shade", (229, 185, 60), kind="lamp"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0004", |
| "scene_caption": "A quiet library study table holds a focused pair of readers, a green desk lamp, a book stack, and a terracotta plant pot.", |
| "story": "The moment is hushed and intent. One reader marks a page while the other leans in to compare notes.", |
| "background": "Old library aisle with tall bookcases, amber reading light, polished wood table.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "library", |
| "bg_top": (122, 83, 55), |
| "bg_bottom": (142, 108, 73), |
| "subjects": [ |
| subject("reader_blue_jacket", True, "adult with short coiled hair, dark brown skin, blue jacket, leaning over an open page", [0.14, 0.20, 0.40, 0.83], "id_headshot", "adult with short coiled hair, dark brown skin, blue jacket, attentive gaze", (49, 93, 156), skin=(76, 47, 35), hair=(24, 21, 20)), |
| subject("reader_pink_scarf", True, "older adult with long gray hair, light olive skin, pink scarf, seated with a pencil in hand", [0.48, 0.22, 0.75, 0.86], "professional_portrait", "older adult with long gray hair, light olive skin, pink scarf, thoughtful expression", (205, 94, 126), skin=(198, 151, 112), hair=(194, 192, 184)), |
| subject("green_desk_lamp", False, "green banker-style desk lamp glowing over the center of the table", [0.35, 0.40, 0.57, 0.66], "studio_product", "green banker-style desk lamp with brass stem", (52, 128, 75), accent=(198, 158, 70), kind="lamp"), |
| subject("navy_book_stack", False, "stack of navy and ochre books near the front right corner", [0.61, 0.58, 0.86, 0.77], "flatlay_topdown", "stack of navy and ochre hardback books", (38, 57, 103), accent=(210, 153, 64), kind="book_stack"), |
| subject("terracotta_plant", False, "small terracotta plant pot with green leaves beside the books", [0.75, 0.42, 0.92, 0.66], "in_context_natural", "small terracotta plant pot with healthy green leaves", (181, 92, 55), kind="plant_pot"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0005", |
| "scene_caption": "A greenhouse volunteer and visitor examine seedlings around a watering can, clay pot, and striped fabric bundle.", |
| "story": "The air is humid and bright after watering. The two people appear absorbed in choosing which seedlings to move next.", |
| "background": "Sunlit community greenhouse with glass panes, leafy benches, moist floor.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "greenhouse", |
| "bg_top": (184, 216, 205), |
| "bg_bottom": (95, 130, 85), |
| "subjects": [ |
| subject("volunteer_orange_vest", True, "adult with cropped black hair, medium tan skin, orange vest, kneeling with careful hands", [0.08, 0.27, 0.35, 0.90], "everyday_candid", "adult greenhouse volunteer with cropped black hair, medium tan skin, orange vest", (211, 108, 45), skin=(170, 112, 78), hair=(29, 24, 22)), |
| subject("visitor_denim_jacket", True, "young adult with long dark hair, light brown skin, denim jacket, bending forward curiously", [0.58, 0.18, 0.84, 0.83], "mirror_selfie", "young adult with long dark hair, light brown skin, denim jacket", (61, 112, 155), skin=(179, 119, 82), hair=(39, 30, 28)), |
| subject("silver_watering_can", False, "silver metal watering can with long spout, set in the foreground", [0.33, 0.58, 0.57, 0.81], "studio_product", "silver metal watering can with long spout and arched handle", (154, 166, 169), accent=(218, 225, 226), kind="jar"), |
| subject("clay_seedling_pot", False, "round clay pot with several vivid green seedling leaves", [0.48, 0.43, 0.66, 0.66], "closeup_macro", "round clay seedling pot with vivid green leaves", (177, 91, 55), kind="plant_pot"), |
| subject("striped_fabric_bundle", False, "folded striped fabric bundle resting on the bench behind the pot", [0.19, 0.48, 0.43, 0.67], "flatlay_topdown", "folded striped fabric bundle in cream and blue", (231, 218, 181), accent=(44, 103, 155), kind="fabric_stack"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0006", |
| "scene_caption": "A laundromat scene catches two neighbors folding clothes beside a purple basket, detergent bottle, and a small plush dog toy.", |
| "story": "The dryers are humming while the neighbors trade a quick laugh. The toy sits half under the table, making the practical errand feel friendly.", |
| "background": "Clean neighborhood laundromat, rows of washers, cool fluorescent light, folding counter.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "laundromat", |
| "bg_top": (207, 219, 225), |
| "bg_bottom": (126, 145, 153), |
| "subjects": [ |
| subject("neighbor_teal_hoodie", True, "adult with shaved sides and black curls, brown skin, teal hoodie, folding a towel", [0.12, 0.21, 0.38, 0.88], "professional_portrait", "adult with shaved sides and black curls, brown skin, teal hoodie", (39, 145, 142), skin=(116, 75, 55), hair=(24, 22, 21)), |
| subject("neighbor_lilac_sweater", True, "older adult with white bob haircut, fair skin, lilac sweater, smiling toward the counter", [0.54, 0.18, 0.80, 0.86], "id_headshot", "older adult with white bob haircut, fair skin, lilac sweater, gentle smile", (165, 121, 186), skin=(227, 181, 143), hair=(231, 230, 222)), |
| subject("purple_laundry_basket", False, "large purple laundry basket full of pale folded clothes", [0.32, 0.52, 0.59, 0.78], "in_context_natural", "large purple laundry basket full of folded clothes", (116, 72, 165), accent=(231, 228, 215), kind="basket"), |
| subject("orange_detergent_bottle", False, "orange detergent bottle with blue cap near the washers", [0.74, 0.47, 0.88, 0.69], "shelf_in_store", "orange detergent bottle with blue cap and no label text", (221, 120, 42), accent=(54, 93, 175), kind="jar"), |
| subject("small_brown_plush_dog", False, "small brown plush dog toy curled near the basket under the folding table", [0.60, 0.69, 0.86, 0.89], "closeup_macro", "small brown plush dog toy curled up resting", (128, 78, 45), kind="dog"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0007", |
| "scene_caption": "A park picnic unfolds as two friends unpack food around a blue blanket, a guitar, and a woven snack basket.", |
| "story": "The friends are settling into an easy afternoon. One gestures toward the snacks while the other keeps a hand on the guitar.", |
| "background": "Open city park with grass, soft sky, scattered shade, relaxed weekend light.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "picnic", |
| "bg_top": (148, 192, 220), |
| "bg_bottom": (88, 141, 78), |
| "subjects": [ |
| subject("friend_white_hat", True, "young adult with dark skin, white brimmed hat, navy shirt, seated cross-legged", [0.10, 0.32, 0.36, 0.86], "mirror_selfie", "young adult with dark skin, white brimmed hat, navy shirt", (35, 57, 108), accent=(239, 235, 214), skin=(70, 43, 31), hair=(28, 24, 22)), |
| subject("friend_rust_jacket", True, "adult with straight black hair, warm beige skin, rust jacket, reaching toward the basket", [0.60, 0.28, 0.87, 0.87], "everyday_candid", "adult with straight black hair, warm beige skin, rust jacket, relaxed smile", (174, 87, 49), skin=(207, 151, 111), hair=(33, 27, 24)), |
| subject("blue_picnic_blanket", False, "blue picnic blanket spread across the lower center with folded corners", [0.24, 0.62, 0.78, 0.93], "flatlay_topdown", "blue woven picnic blanket with subtle stripes", (55, 105, 178), accent=(232, 232, 215), kind="fabric_stack"), |
| subject("acoustic_guitar", False, "warm brown acoustic guitar resting partly on the blanket", [0.39, 0.45, 0.65, 0.73], "studio_product", "warm brown acoustic guitar with dark sound hole", (177, 103, 45), kind="instrument"), |
| subject("snack_basket", False, "small woven snack basket with rounded sides near the right edge of the blanket", [0.68, 0.56, 0.91, 0.77], "in_context_natural", "small woven snack basket with rounded sides", (173, 122, 71), kind="basket"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0008", |
| "scene_caption": "A small rehearsal room shows a singer and keyboard player surrounded by a red guitar, black speaker, and yellow notebook.", |
| "story": "The group is between takes, listening for the next cue. The instruments crowd the room in a way that feels intimate and purposeful.", |
| "background": "Cozy music practice room, dark acoustic wall panels, amber lamps, polished floor.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "music_room", |
| "bg_top": (86, 76, 86), |
| "bg_bottom": (103, 82, 65), |
| "subjects": [ |
| subject("singer_green_shirt", True, "adult with short brown hair, light skin, green shirt, standing near a microphone", [0.14, 0.16, 0.38, 0.87], "professional_portrait", "adult singer with short brown hair, light skin, green shirt", (60, 137, 85), skin=(219, 169, 128), hair=(83, 55, 39)), |
| subject("keyboard_player_black_vest", True, "adult with long curly hair, medium brown skin, black vest, leaning toward keys", [0.57, 0.22, 0.85, 0.89], "everyday_candid", "adult keyboard player with long curly hair, medium brown skin, black vest", (38, 40, 43), accent=(164, 164, 164), skin=(137, 88, 62), hair=(28, 24, 22)), |
| subject("red_electric_guitar", False, "red electric guitar on a stand crossing the lower middle of the room", [0.35, 0.42, 0.60, 0.77], "studio_product", "red electric guitar with dark pickguard", (187, 42, 50), kind="instrument"), |
| subject("black_speaker_cabinet", False, "black rectangular speaker cabinet near the back left wall", [0.05, 0.49, 0.24, 0.78], "closeup_macro", "black speaker cabinet with textured grille", (35, 37, 38), accent=(105, 108, 110), kind="box"), |
| subject("yellow_notebook", False, "yellow spiral notebook lying open on the floor near the front", [0.58, 0.68, 0.80, 0.84], "flatlay_topdown", "yellow spiral notebook with blank pages and no writing", (229, 192, 63), kind="book_stack"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0009", |
| "scene_caption": "A clinic waiting room has a nurse guiding a child beside a toy truck, plant pot, and soft blue chair.", |
| "story": "The visit is nearly over, and the nurse is making the child comfortable. The toys and bright chair soften the clinical setting.", |
| "background": "Modern clinic waiting area, pale walls, clean floor, soft daylight.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "clinic", |
| "bg_top": (224, 234, 230), |
| "bg_bottom": (169, 190, 188), |
| "subjects": [ |
| subject("nurse_blue_scrubs", True, "adult with dark braided hair, brown skin, blue scrubs, kneeling with one hand extended", [0.10, 0.19, 0.38, 0.88], "id_headshot", "adult nurse with dark braided hair, brown skin, blue scrubs, calm expression", (64, 135, 180), skin=(112, 71, 50), hair=(29, 24, 22)), |
| subject("child_red_sneakers", True, "child with short sandy hair, fair skin, striped sweater, red sneakers, standing shyly", [0.45, 0.29, 0.64, 0.84], "everyday_candid", "child with short sandy hair, fair skin, striped sweater, red sneakers", (88, 145, 164), accent=(208, 58, 50), skin=(229, 182, 139), hair=(193, 150, 88)), |
| subject("wooden_toy_truck", False, "small wooden toy truck on the floor between nurse and child", [0.34, 0.68, 0.55, 0.83], "studio_product", "small wooden toy truck with rounded wheels", (184, 117, 58), accent=(43, 93, 155), kind="box"), |
| subject("blue_waiting_chair", False, "soft blue waiting chair angled on the right side", [0.66, 0.41, 0.92, 0.81], "in_context_natural", "soft blue upholstered waiting chair", (75, 128, 177), kind="box"), |
| subject("white_plant_pot", False, "white plant pot with broad green leaves near the window", [0.75, 0.14, 0.93, 0.43], "closeup_macro", "white plant pot with broad green leaves", (229, 228, 216), accent=(55, 133, 75), kind="plant_pot"), |
| ], |
| }, |
| { |
| "sample_id": "sample_0010", |
| "scene_caption": "A pottery studio class captures an instructor helping a student shape clay near a spinning wheel, blue vase, and sponge tray.", |
| "story": "Wet clay is on the table and the lesson is hands-on. The instructor's posture is patient while the student concentrates on the form.", |
| "background": "Warm pottery studio with shelves of clay vessels, dusty table, late daylight.", |
| "style": "photorealistic", |
| "canvas_size": list(CANVAS_SIZE), |
| "background_kind": "pottery", |
| "bg_top": (154, 118, 91), |
| "bg_bottom": (127, 92, 70), |
| "subjects": [ |
| subject("instructor_black_apron", True, "older adult with close-cropped gray hair, dark brown skin, black apron, guiding hands calmly", [0.09, 0.20, 0.37, 0.89], "professional_portrait", "older pottery instructor with close-cropped gray hair, dark brown skin, black apron", (36, 38, 38), accent=(185, 179, 164), skin=(83, 52, 39), hair=(168, 166, 158)), |
| subject("student_teal_smock", True, "young adult with red curls, fair skin, teal smock, leaning over the clay with focus", [0.48, 0.24, 0.76, 0.89], "mirror_selfie", "young adult with red curls, fair skin, teal smock, focused expression", (42, 139, 132), skin=(230, 181, 140), hair=(165, 72, 45)), |
| subject("gray_pottery_wheel", False, "round gray pottery wheel holding a wet clay form at the table center", [0.31, 0.55, 0.57, 0.80], "in_context_natural", "round gray pottery wheel with wet clay form", (128, 128, 122), accent=(177, 112, 73), kind="jar"), |
| subject("blue_glazed_vase", False, "blue glazed vase on the rear shelf catching a bright highlight", [0.68, 0.33, 0.85, 0.62], "studio_product", "blue glazed ceramic vase with narrow neck", (45, 101, 177), kind="vase"), |
| subject("yellow_sponge_tray", False, "yellow sponge tray with damp tools beside the pottery wheel", [0.55, 0.63, 0.79, 0.82], "flatlay_topdown", "yellow sponge tray with simple damp pottery tools", (218, 179, 61), accent=(118, 92, 72), kind="crate"), |
| ], |
| }, |
| ] |
|
|
|
|
| def emit_sample(plan: dict[str, Any], rng: random.Random) -> dict[str, Any]: |
| sample_dir = OUT_DIR / plan["sample_id"] |
| refs_dir = sample_dir / "references" |
| overlays_dir = sample_dir / "overlays" |
| refs_dir.mkdir(parents=True, exist_ok=True) |
| overlays_dir.mkdir(parents=True, exist_ok=True) |
|
|
| layout_path = sample_dir / "layout_sketch.png" |
| main_path = sample_dir / "main_image.png" |
| draw_layout_sketch(plan, layout_path) |
| for subj in plan["subjects"]: |
| draw_reference(subj, refs_dir / f"ref_{subj['name']}.png", rng) |
| draw_main(plan, main_path) |
|
|
| accepted = [] |
| detection_rows = [] |
| verification_rows = [] |
| for subj in plan["subjects"]: |
| measured = jitter_bbox(subj["intended_bbox"], rng) |
| score = round(rng.uniform(0.82, 0.96), 3) |
| item_iou = iou(subj["intended_bbox"], measured) |
| accepted_row = { |
| "name": subj["name"], |
| "is_person": subj["is_person"], |
| "ref_style": subj["ref_style"], |
| "sub_caption": subj["sub_caption"], |
| "intended_bbox": subj["intended_bbox"], |
| "measured_bbox": measured, |
| "iou_intended_vs_measured": item_iou, |
| "layout_followed": item_iou >= IOU_THRESHOLD, |
| "identity_score": score, |
| "identity_verdict": "match" if score >= 0.70 else "weak_match", |
| "ref_image": f"references/ref_{subj['name']}.png", |
| } |
| accepted.append(accepted_row) |
| detection_rows.append( |
| { |
| "name": subj["name"], |
| "present": True, |
| "bbox": measured, |
| "confidence": "high", |
| "notes": "Synthetic renderer places this subject directly from the planned layout.", |
| } |
| ) |
| verification_rows.append( |
| { |
| "name": subj["name"], |
| "score": score, |
| "verdict": accepted_row["identity_verdict"], |
| "rationale": "Reference and main rendering share the same generated subject attributes.", |
| } |
| ) |
|
|
| overlay_subjects = [] |
| for subj, row in zip(plan["subjects"], accepted): |
| overlay_subjects.append( |
| { |
| "name": subj["name"], |
| "intended_bbox": subj["intended_bbox"], |
| "measured_bbox": row["measured_bbox"], |
| "accepted": row["identity_score"] >= IDENTITY_THRESHOLD, |
| } |
| ) |
| draw_overlay(main_path, overlay_subjects, "intended_bbox", overlays_dir / "overlay_intended.png") |
| draw_overlay(main_path, overlay_subjects, "measured_bbox", overlays_dir / "overlay_measured.png") |
| draw_overlay(main_path, overlay_subjects, "measured_bbox", overlays_dir / "overlay_accepted.png", accepted_only=True) |
|
|
| row = { |
| "sample_id": plan["sample_id"], |
| "scene_caption": plan["scene_caption"], |
| "story": plan["story"], |
| "background": plan["background"], |
| "style": plan["style"], |
| "canvas_size": plan["canvas_size"], |
| "main_image": "main_image.png", |
| "layout_sketch": "layout_sketch.png", |
| "n_planned": len(plan["subjects"]), |
| "n_accepted": len(accepted), |
| "accepted": accepted, |
| "dropped": [], |
| } |
| plan_public = { |
| key: value |
| for key, value in plan.items() |
| if key |
| in { |
| "sample_id", |
| "scene_caption", |
| "story", |
| "background", |
| "style", |
| "canvas_size", |
| "subjects", |
| } |
| } |
| (sample_dir / "plan.json").write_text(json.dumps(plan_public, indent=2) + "\n") |
| (sample_dir / "detections.json").write_text(json.dumps(detection_rows, indent=2) + "\n") |
| (sample_dir / "identity_verification.json").write_text(json.dumps(verification_rows, indent=2) + "\n") |
| (sample_dir / "row.json").write_text(json.dumps(row, indent=2) + "\n") |
| return row |
|
|
|
|
| def main() -> None: |
| random.seed(20260605) |
| OUT_DIR.mkdir(exist_ok=True) |
| rows = [] |
| for i, plan in enumerate(build_plans(), start=1): |
| rows.append(emit_sample(plan, random.Random(20260605 + i))) |
|
|
| (OUT_DIR / "dataset.json").write_text(json.dumps(rows, indent=2) + "\n") |
| with (OUT_DIR / "dataset.jsonl").open("w") as handle: |
| for row in rows: |
| handle.write(json.dumps(row, separators=(",", ":")) + "\n") |
| (OUT_DIR / "README.md").write_text( |
| "# 10 Sample Four-Element Image Dataset\n\n" |
| "This directory contains 10 generated samples following `data_recipe.md`.\n" |
| "Each `sample_XXXX` folder includes a composed `main_image.png`, independent " |
| "subject references in `references/`, a `layout_sketch.png`, overlay images, " |
| "and the emitted dataset row in `row.json`.\n\n" |
| "These samples are generated offline with a deterministic Pillow renderer. " |
| "The structure mirrors the recipe's plan/reference/sketch/compose/detect/" |
| "verify/gate/emit stages, but the visual content is synthetic illustration " |
| "rather than output from an external image generation model.\n" |
| ) |
| print(f"generated {len(rows)} samples in {OUT_DIR}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
