#!/usr/bin/env python3
"""Step 01: generate single-stream data and tasks from open-source solid icon database."""
from __future__ import annotations
import io
import argparse
import base64
import json
import hashlib
import math
import pickle
import random
import subprocess
import benchmark_core as core
from collections import deque
from pathlib import Path
from time import perf_counter
from typing import Dict, List, Optional, Set, Tuple
try:
import numpy as np
except Exception: # pragma: no cover
np = None
try:
from tqdm import tqdm
except Exception:
def tqdm(iterable=None, **kwargs): # type: ignore
return iterable
from benchmark_core import (
ACTIONS,
Pose,
apply_action,
create_mask,
create_oblique_view,
ensure_dir,
iou,
load_default_config,
pose_distance_steps,
render_views_fast,
read_json,
read_jsonl,
resolve_paths,
write_json,
write_jsonl,
write_png_gray,
)
from render_protocol import STANDARD_DISPLAY_SIZE, STANDARD_IMAGE_SIZE
INIT_THETA_DEG = 30
ALLOWED_STEP_ANGLES = [30, 10, 5]
MAX_ICON_POINTS = 90000
ICON_CACHE_FORMAT_VERSION = 2
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Step 01 generate data")
parser.add_argument("--root", type=str, default=".", help="Project root path")
parser.add_argument(
"--config",
type=str,
default="results/artifacts/config/run_config.json",
help="Config path relative to root",
)
parser.add_argument("--save-init-images", action="store_true", help="Save init projection PNGs")
parser.add_argument("--save-init-oblique-images", action="store_true", help="Save init oblique PNGs")
parser.add_argument("--sample-count", type=int, default=0, help="Override sample_count in config when > 0")
parser.add_argument("--resume", dest="resume", action="store_true", help="Resume Step1 from checkpoint")
parser.add_argument("--no-resume", dest="resume", action="store_false", help="Start Step1 from scratch")
parser.add_argument(
"--no-save-target-images",
dest="save_target_images",
action="store_false",
help="Do not save target PNGs (may break API-based Step02)",
)
parser.set_defaults(save_target_images=True)
parser.set_defaults(resume=False)
return parser.parse_args()
def random_pose(rng: random.Random) -> Pose:
choices = list(range(-120, 121, 15))
return Pose(roll=rng.choice(choices), pitch=rng.choice(choices), yaw=rng.choice(choices))
def _slug(svg_path: Path) -> str:
return f"{svg_path.parent.name}-{svg_path.stem}".lower().replace(" ", "-")
def uniform_downsample_points(points: List[List[float]], max_points: int) -> List[List[float]]:
"""Keep the full scan range while deterministically limiting point count."""
if max_points <= 0:
raise ValueError("max_points must be positive")
if len(points) <= max_points:
return points
if max_points == 1:
return [points[0]]
last = len(points) - 1
denominator = max_points - 1
return [points[(index * last) // denominator] for index in range(max_points)]
def svg_to_icon_points(svg_path: Path, max_points: int = MAX_ICON_POINTS) -> List[List[float]]:
import cairosvg
from PIL import Image
png = cairosvg.svg2png(url=str(svg_path), output_width=512, output_height=512)
img = Image.open(io.BytesIO(png)).convert("RGBA")
w, h = img.size
px = img.load()
corners = [
px[0, 0][:3],
px[w - 1, 0][:3],
px[0, h - 1][:3],
px[w - 1, h - 1][:3],
]
bg_r = int(sum(c[0] for c in corners) / 4)
bg_g = int(sum(c[1] for c in corners) / 4)
bg_b = int(sum(c[2] for c in corners) / 4)
points: List[List[float]] = []
stride = 1
for y in range(0, h, stride):
for x in range(0, w, stride):
r, g, b, a = px[x, y]
color_delta = abs(int(r) - bg_r) + abs(int(g) - bg_g) + abs(int(b) - bg_b)
if a > 8 and color_delta > 30:
nx = (x - w / 2) / (min(w, h) / 2) * 24.0
ny = (y - h / 2) / (min(w, h) / 2) * 24.0
points.append([round(nx, 4), round(ny, 4)])
# Deterministic full-range downsample to control JSON size and runtime.
points = uniform_downsample_points(points, max_points)
if not points:
raise RuntimeError(f"Empty icon points for {svg_path}")
return points
def _circle_from_two(a: Tuple[float, float], b: Tuple[float, float]) -> Tuple[float, float, float]:
cx = (a[0] + b[0]) / 2.0
cy = (a[1] + b[1]) / 2.0
r = math.hypot(a[0] - b[0], a[1] - b[1]) / 2.0
return cx, cy, r
def _circle_from_three(
a: Tuple[float, float], b: Tuple[float, float], c: Tuple[float, float]
) -> Optional[Tuple[float, float, float]]:
ax, ay = a
bx, by = b
cx, cy = c
d = 2.0 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by))
if abs(d) < 1e-8:
return None
ux = (
(ax * ax + ay * ay) * (by - cy)
+ (bx * bx + by * by) * (cy - ay)
+ (cx * cx + cy * cy) * (ay - by)
) / d
uy = (
(ax * ax + ay * ay) * (cx - bx)
+ (bx * bx + by * by) * (ax - cx)
+ (cx * cx + cy * cy) * (bx - ax)
) / d
r = math.hypot(ux - ax, uy - ay)
return ux, uy, r
def _in_circle(p: Tuple[float, float], c: Tuple[float, float, float]) -> bool:
return math.hypot(p[0] - c[0], p[1] - c[1]) <= c[2] + 1e-7
def minimum_enclosing_circle(points: List[Tuple[float, float]]) -> Tuple[float, float, float]:
if not points:
return 0.0, 0.0, 0.0
pts = points[:]
random.Random(20260302).shuffle(pts)
circle: Optional[Tuple[float, float, float]] = None
for i, p in enumerate(pts):
if circle is not None and _in_circle(p, circle):
continue
circle = (p[0], p[1], 0.0)
for j in range(i):
q = pts[j]
if _in_circle(q, circle):
continue
circle = _circle_from_two(p, q)
for k in range(j):
r = pts[k]
if _in_circle(r, circle):
continue
c3 = _circle_from_three(p, q, r)
if c3 is not None:
circle = c3
if circle is None:
return 0.0, 0.0, 0.0
return circle
def _rasterize_points(points: List[List[float]], size: int = 112, pad: int = 6) -> Tuple[Set[Tuple[int, int]], float]:
if not points:
return set(), 1.0
xs = [float(p[0]) for p in points]
ys = [float(p[1]) for p in points]
min_x, max_x = min(xs), max(xs)
min_y, max_y = min(ys), max(ys)
span_x = max(1e-6, max_x - min_x)
span_y = max(1e-6, max_y - min_y)
scale = min((size - 1 - 2 * pad) / span_x, (size - 1 - 2 * pad) / span_y)
occ: Set[Tuple[int, int]] = set()
for p in points:
x = int(round((float(p[0]) - min_x) * scale + pad))
y = int(round((float(p[1]) - min_y) * scale + pad))
if 0 <= x < size and 0 <= y < size:
occ.add((x, y))
return occ, scale
def _largest_component_ratio(occ: Set[Tuple[int, int]]) -> float:
if not occ:
return 0.0
unvisited = set(occ)
largest = 0
neighbors = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
while unvisited:
start = unvisited.pop()
q = deque([start])
size = 1
while q:
x, y = q.popleft()
for dx, dy in neighbors:
nxt = (x + dx, y + dy)
if nxt in unvisited:
unvisited.remove(nxt)
q.append(nxt)
size += 1
if size > largest:
largest = size
return largest / max(1, len(occ))
def icon_quality_stats(points: List[List[float]]) -> Dict[str, float]:
if not points:
return {"connected_ratio": 0.0, "circle_iou": 0.0, "bbox_fill": 0.0, "aspect_ratio": 99.0}
occ, scale = _rasterize_points(points, size=112, pad=6)
if not occ:
return {"connected_ratio": 0.0, "circle_iou": 0.0, "bbox_fill": 0.0, "aspect_ratio": 99.0}
xs = [p[0] for p in occ]
ys = [p[1] for p in occ]
bw = max(xs) - min(xs) + 1
bh = max(ys) - min(ys) + 1
aspect = max(bw, bh) / max(1, min(bw, bh))
bbox_fill = len(occ) / max(1, bw * bh)
connected_ratio = _largest_component_ratio(occ)
step = max(1, len(points) // 3500)
sampled = [(float(p[0]), float(p[1])) for p in points[::step]]
_, _, r = minimum_enclosing_circle(sampled)
circle_area = math.pi * (max(1e-6, r * scale) ** 2)
circle_iou = min(1.0, len(occ) / max(1e-6, circle_area))
return {
"connected_ratio": float(connected_ratio),
"circle_iou": float(circle_iou),
"bbox_fill": float(bbox_fill),
"aspect_ratio": float(aspect),
}
def build_icon_db(
root: Path,
categories: List[str],
pool_limit: int = 1200,
quality_cfg: Optional[Dict] = None,
) -> Tuple[Dict[str, List[Dict]], Dict]:
base = root / "data_sources" / "game-icons"
if not base.exists():
ensure_dir(base.parent)
subprocess.run(
["git", "clone", "--depth", "1", "https://github.com/game-icons/icons", str(base)],
check=True,
cwd=str(root),
)
cache_dir = root / "data_sources" / "game-icons-cache-v3"
ensure_dir(cache_dir)
all_svgs = list(base.rglob("*.svg"))
def matches(cat: str, name: str) -> bool:
n = name.lower()
if cat == "all":
return True
if cat == "spider":
return "spider" in n and "web" not in n
if cat == "bird":
return "bird" in n and "bird-house" not in n and "bird-house" not in n.replace("_", "-")
if cat == "house":
return ("house" in n or "home" in n) and "bird-house" not in n
return cat in n
db: Dict[str, List[Dict]] = {c: [] for c in categories}
quality_cfg = quality_cfg or {}
min_connected_ratio = float(quality_cfg.get("icon_min_connected_ratio", 0.985))
min_circle_iou = float(quality_cfg.get("icon_min_circle_iou", 0.28))
min_bbox_fill = float(quality_cfg.get("icon_min_bbox_fill", 0.08))
max_aspect_ratio = float(quality_cfg.get("icon_max_aspect_ratio", 2.2))
min_pixel_points = int(quality_cfg.get("icon_min_pixel_points", 1800))
timing = {
"build_icon_db_s": 0.0,
"categories": {},
"totals": {
"candidate_svgs": 0,
"processed_svgs": 0,
"cache_hit": 0,
"cache_miss": 0,
"cache_refresh": 0,
"passed_quality": 0,
"rejected_quality": 0,
"time_svg_to_points_s": 0.0,
"time_quality_eval_s": 0.0,
},
}
t_build_start = perf_counter()
for cat in tqdm(categories, desc="Build icon DB", unit="cat"):
t_cat_start = perf_counter()
candidates = [p for p in all_svgs if matches(cat, p.stem)]
# Keep only stable shape-like icons (drop a few metadata-like outliers).
candidates = [p for p in candidates if "keys" not in p.stem.lower() and "scepter" not in p.stem.lower()]
if not candidates:
raise RuntimeError(f"No icons found for category: {cat}")
timing["totals"]["candidate_svgs"] += len(candidates)
# Truncate BEFORE caching to avoid processing all files.
candidates = sorted(candidates, key=lambda p: _slug(p))
if cat == "all":
limit = int(pool_limit)
if limit >= 0:
candidates = candidates[: max(1, limit)]
else:
candidates = candidates[:24]
for svg in tqdm(candidates, desc=f"Cache {cat}", unit="svg", leave=False):
slug = _slug(svg)
cache_file = cache_dir / f"{slug}.json"
timing["totals"]["processed_svgs"] += 1
cached_payload = json.loads(cache_file.read_text(encoding="utf-8")) if cache_file.exists() else None
cache_is_current = (
isinstance(cached_payload, dict)
and int(cached_payload.get("format_version", 0)) >= ICON_CACHE_FORMAT_VERSION
and isinstance(cached_payload.get("points"), list)
)
legacy_points = cached_payload if isinstance(cached_payload, list) else None
legacy_is_safe = legacy_points is not None and len(legacy_points) < MAX_ICON_POINTS
if cache_is_current:
timing["totals"]["cache_hit"] += 1
icon_points = cached_payload["points"]
elif legacy_is_safe:
timing["totals"]["cache_hit"] += 1
icon_points = legacy_points
else:
timing["totals"]["cache_miss"] += 1
if cache_file.exists():
timing["totals"]["cache_refresh"] += 1
t_svg = perf_counter()
icon_points = svg_to_icon_points(svg)
timing["totals"]["time_svg_to_points_s"] += perf_counter() - t_svg
cache_file.write_text(
json.dumps(
{
"format_version": ICON_CACHE_FORMAT_VERSION,
"sampling": "uniform_full_scan_range",
"max_points": MAX_ICON_POINTS,
"points": icon_points,
},
ensure_ascii=False,
),
encoding="utf-8",
)
t_q = perf_counter()
q = icon_quality_stats(icon_points)
timing["totals"]["time_quality_eval_s"] += perf_counter() - t_q
is_quality_ok = (
len(icon_points) >= min_pixel_points
and q["connected_ratio"] >= min_connected_ratio
and q["circle_iou"] >= min_circle_iou
and q["bbox_fill"] >= min_bbox_fill
and q["aspect_ratio"] <= max_aspect_ratio
)
if not is_quality_ok:
timing["totals"]["rejected_quality"] += 1
continue
timing["totals"]["passed_quality"] += 1
db[cat].append(
{
"icon_slug": slug,
"icon_svg": str(svg.relative_to(root)).replace("\\", "/"),
"icon_cache_file": str(cache_file.relative_to(root)).replace("\\", "/"),
"icon_points": icon_points,
"quality": {
"connected_ratio": round(q["connected_ratio"], 5),
"circle_iou": round(q["circle_iou"], 5),
"bbox_fill": round(q["bbox_fill"], 5),
"aspect_ratio": round(q["aspect_ratio"], 5),
},
}
)
if not db[cat]:
raise RuntimeError(
f"No icons passed quality filters for category={cat}. "
f"Try lowering thresholds: connected>={min_connected_ratio}, circle_iou>={min_circle_iou}, "
f"bbox_fill>={min_bbox_fill}, aspect<={max_aspect_ratio}."
)
db[cat] = sorted(db[cat], key=lambda x: x["icon_slug"])
timing["categories"][cat] = {
"candidates": len(candidates),
"passed": len(db[cat]),
"elapsed_s": round(perf_counter() - t_cat_start, 6),
}
timing["build_icon_db_s"] = round(perf_counter() - t_build_start, 6)
return db, timing
def inverse_action(action: str) -> str:
mapping = {
"PITCH_POS": "PITCH_NEG",
"PITCH_NEG": "PITCH_POS",
"YAW_POS": "YAW_NEG",
"YAW_NEG": "YAW_POS",
"ROLL_POS": "ROLL_NEG",
"ROLL_NEG": "ROLL_POS",
}
return mapping[action]
def _random_unit_vec(rng: random.Random) -> Tuple[float, float, float]:
while True:
x = rng.uniform(-1.0, 1.0)
y = rng.uniform(-1.0, 1.0)
z = rng.uniform(-1.0, 1.0)
n = math.sqrt(x * x + y * y + z * z)
if n > 1e-6:
return x / n, y / n, z / n
def _same_mask(a, b) -> bool:
if np is not None:
return bool(np.array_equal(a, b))
return a == b
def _sample_surface_hole(rng: random.Random) -> Dict:
nx, ny, nz = _random_unit_vec(rng)
shape = rng.choices(
["rect", "parallelogram", "circle"],
weights=[0.4, 0.3, 0.3],
k=1,
)[0]
hole = {
"shape": shape,
"nx": round(nx, 6),
"ny": round(ny, 6),
"nz": round(nz, 6),
"min_n": round(rng.uniform(0.90, 0.97), 6),
"shell_ratio": round(rng.uniform(0.45, 0.72), 6),
}
if shape == "circle":
hole["radius"] = round(rng.uniform(0.09, 0.24), 6)
return hole
long_half = rng.uniform(0.18, 0.34)
short_half = rng.uniform(0.07, 0.15)
if rng.random() < 0.5:
half_w, half_h = long_half, short_half
else:
half_w, half_h = short_half, long_half
hole["half_w"] = round(half_w, 6)
hole["half_h"] = round(half_h, 6)
if shape == "parallelogram":
hole["shear"] = round(rng.uniform(-0.85, 0.85), 6)
return hole
def _print_icon_filter_report(cfg: Dict, icon_db_timing: Dict, icon_db: Dict[str, List[Dict]]) -> None:
print("[step01][icon-filter] quality thresholds:")
print(f" - icon_categories: {cfg.get('icon_categories', ['all'])}")
print(f" - icon_min_connected_ratio: {float(cfg.get('icon_min_connected_ratio', 0.985))}")
print(f" - icon_min_circle_iou: {float(cfg.get('icon_min_circle_iou', 0.28))}")
print(f" - icon_min_bbox_fill: {float(cfg.get('icon_min_bbox_fill', 0.08))}")
print(f" - icon_max_aspect_ratio: {float(cfg.get('icon_max_aspect_ratio', 2.2))}")
print(f" - icon_min_pixel_points: {int(cfg.get('icon_min_pixel_points', 1800))}")
print("[step01][icon-filter] remaining icons after quality filter:")
categories_timing = icon_db_timing.get("categories", {})
total_passed = 0
total_candidates = 0
for cat in cfg.get("icon_categories", ["all"]):
cat_info = categories_timing.get(cat, {})
candidates = int(cat_info.get("candidates", 0))
passed = int(cat_info.get("passed", len(icon_db.get(cat, []))))
total_candidates += candidates
total_passed += passed
print(f" - {cat}: {passed}/{candidates}")
print(f" - total: {total_passed}/{total_candidates}")
def append_jsonl(path: Path, row: Dict) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("a", encoding="utf-8") as f:
f.write(json.dumps(row, ensure_ascii=False) + "\n")
def scan_sample_metadata(path: Path) -> Tuple[List[str], List[str]]:
sample_ids: List[str] = []
icon_slugs: List[str] = []
if not path.exists():
return sample_ids, icon_slugs
with path.open("r", encoding="utf-8") as handle:
for line in handle:
if not line.strip():
continue
row = json.loads(line)
sample_ids.append(str(row.get("sample_id", "")))
icon_slugs.append(str(row.get("icon_slug", "")))
return sample_ids, icon_slugs
def count_jsonl_rows(path: Path) -> int:
if not path.exists():
return 0
with path.open("r", encoding="utf-8") as handle:
return sum(1 for line in handle if line.strip())
def truncate_jsonl_rows(path: Path, row_count: int) -> None:
"""Keep only the first non-empty rows without loading a JSONL file into memory."""
if row_count < 0:
raise ValueError("row_count must be non-negative")
path.parent.mkdir(parents=True, exist_ok=True)
temporary = path.with_suffix(path.suffix + ".truncate.tmp")
kept = 0
with temporary.open("w", encoding="utf-8", newline="\n") as target:
if path.exists():
with path.open("r", encoding="utf-8") as source:
for line in source:
if not line.strip():
continue
if kept >= row_count:
break
target.write(line.rstrip("\r\n") + "\n")
kept += 1
if kept != row_count:
temporary.unlink(missing_ok=True)
raise RuntimeError(f"Cannot keep {row_count} rows from {path}; only found {kept}")
temporary.replace(path)
def config_fingerprint(cfg: Dict) -> str:
keys = [
"random_seed",
"T_max",
"tau_success",
"eval_size",
"display_width",
"display_height",
"icon_categories",
"icon_pool_limit",
"icon_min_connected_ratio",
"icon_min_circle_iou",
"icon_min_bbox_fill",
"icon_max_aspect_ratio",
"icon_min_pixel_points",
"surface_hole_attempts",
]
payload = {k: cfg.get(k) for k in keys}
raw = json.dumps(payload, ensure_ascii=False, sort_keys=True).encode("utf-8")
return hashlib.sha256(raw).hexdigest()
def encode_rng_state(state) -> str:
return base64.b64encode(pickle.dumps(state)).decode("ascii")
def decode_rng_state(text: str):
return pickle.loads(base64.b64decode(text.encode("ascii")))
def load_checkpoint(path: Path) -> Dict:
if not path.exists():
return {}
return read_json(path)
def infer_next_sample_index(existing_samples: List[Dict]) -> int:
max_idx = -1
for row in existing_samples:
sid = str(row.get("sample_id", "")).strip()
if sid.startswith("single_"):
try:
max_idx = max(max_idx, int(sid.split("_")[-1]))
except Exception:
continue
return max_idx + 1 if max_idx >= 0 else len(existing_samples)
def build_unique_icon_pool(
cfg: Dict,
icon_db: Dict[str, List[Dict]],
) -> List[Dict]:
categories = list(cfg.get("icon_categories", ["all"]))
if not categories:
categories = ["all"]
icon_pool: List[Dict] = []
seen = set()
for cat in categories:
for icon in icon_db.get(cat, []):
slug = icon.get("icon_slug", "")
if slug and slug not in seen:
seen.add(slug)
pool_item = {"category": cat, **icon}
pool_item.pop("icon_points", None)
icon_pool.append(pool_item)
return icon_pool
def materialize_icon_points(root: Path, icon: Dict) -> Dict:
"""Load one icon's cached points on demand instead of retaining the whole pool."""
if isinstance(icon.get("icon_points"), list):
return icon
cache_ref = str(icon.get("icon_cache_file", "")).strip()
if not cache_ref:
raise RuntimeError(f"Icon {icon.get('icon_slug', '')} has no cached points reference")
payload = json.loads((root / cache_ref).read_text(encoding="utf-8"))
points = payload.get("points") if isinstance(payload, dict) else payload
if not isinstance(points, list) or not points:
raise RuntimeError(f"Invalid cached points for icon {icon.get('icon_slug', '')}")
materialized = dict(icon)
materialized["icon_points"] = points
return materialized
def carve_hole_variants_without_target_change(
sample: Dict,
cfg: Dict,
target_pose: Pose,
attempt_counts: List[int],
) -> Dict[int, Dict]:
counts = sorted({max(0, int(value)) for value in attempt_counts})
if not counts:
return {}
attempts = counts[-1]
eval_size = int(cfg.get("surface_hole_eval_size", 220))
rng = random.Random(int(sample["shape_seed"]) + 7919)
accepted: List[Dict] = []
snapshots: Dict[int, Dict] = {}
base_sample = dict(sample)
base_sample["surface_holes"] = []
_, baseline_eval, _ = render_views_fast(
base_sample,
target_pose,
display_size=eval_size,
eval_size=eval_size,
need_oblique=False,
)
if 0 in counts:
snapshots[0] = []
for attempt_index in range(1, attempts + 1):
hole = _sample_surface_hole(rng)
cand = dict(sample)
cand["surface_holes"] = accepted + [hole]
_, cand_eval, _ = render_views_fast(
cand,
target_pose,
display_size=eval_size,
eval_size=eval_size,
need_oblique=False,
)
if _same_mask(cand_eval, baseline_eval):
accepted.append(hole)
# If target projection changes, this attempt is reverted by design.
if attempt_index in counts:
snapshots[attempt_index] = [dict(item) for item in accepted]
variants: Dict[int, Dict] = {}
for count in counts:
out = dict(sample)
out["surface_holes"] = snapshots[count]
out["surface_hole_attempts"] = count
out["surface_hole_kept"] = len(snapshots[count])
out["surface_hole_consecutive_failures"] = 0
variants[count] = out
return variants
def carve_holes_without_target_change(sample: Dict, cfg: Dict, target_pose: Pose) -> Dict:
attempts = int(cfg.get("surface_hole_attempts", 30))
variants = carve_hole_variants_without_target_change(
sample,
cfg,
target_pose,
[attempts],
)
return variants[attempts]
def generate_single_sample(
index: int,
cfg: Dict,
icon: Dict,
rng: random.Random,
) -> Dict:
allowed_actions = [a for a in ACTIONS if a != "STOP"]
category = icon["category"]
# Keep target icon recognizable: canonical frontal pose.
target = Pose(roll=0, pitch=0, yaw=0)
scramble_len = rng.randint(6, 16)
scramble_actions: List[str] = []
current = Pose(roll=target.roll, pitch=target.pitch, yaw=target.yaw)
for _ in range(scramble_len):
action = rng.choice(allowed_actions)
if scramble_actions and inverse_action(scramble_actions[-1]) == action:
action = rng.choice([a for a in allowed_actions if a != inverse_action(scramble_actions[-1])])
scramble_actions.append(action)
current = apply_action(current, action, int(INIT_THETA_DEG))
init = current
answer_actions = [inverse_action(a) for a in reversed(scramble_actions)]
sid = f"single_{index:05d}"
sample = {
"sample_id": sid,
"stream_type": "single",
"shape_seed": cfg["random_seed"] + index,
"source_dataset": "game_icons",
"base_shape": "icon",
"category": category,
"icon_slug": icon["icon_slug"],
"icon_svg": icon["icon_svg"],
"icon_points": icon["icon_points"],
"icon_quality": icon.get("quality", {}),
"complexity": 1.0,
"icon_scale": 1.24,
"icon_center_mode": "mec",
"surface_mode": "spherical_icon",
"sphere_radius": 28.0,
"sphere_depth_scale": 1.0,
"sphere_fit_icon": True,
"sphere_xy_ratio": 0.98,
"sphere_double_sided": True,
"sphere_solid": True,
"sphere_fill_layers": 31,
"radial_jitter": 0.0,
"rim_softness": 0.65,
"fine_noise": 0.0,
"target_pose": target.as_dict(),
"init_pose": init.as_dict(),
"scramble_actions": scramble_actions,
"answer_actions": answer_actions,
"theta": int(INIT_THETA_DEG),
"allowed_angles": list(ALLOWED_STEP_ANGLES),
"T_max": cfg["T_max"],
"tau_success": cfg["tau_success"],
"meta": {
"difficulty_bucket": len(scramble_actions),
"generator_mode": "single_stream_spherical_icon_inverse_path",
},
}
return carve_holes_without_target_change(sample, cfg, target_pose=target)
def build_task_row(
*,
sample: Dict,
root: Path,
paths: Dict[str, Path],
args: argparse.Namespace,
display_size: Tuple[int, int],
eval_size: int,
) -> Tuple[Dict, Dict[str, object]]:
sample_id = sample["sample_id"]
stream = "single"
target_pose = Pose.from_dict(sample["target_pose"])
init_pose = Pose.from_dict(sample["init_pose"])
t_rt = perf_counter()
target_mask, target_mask_eval, _ = render_views_fast(
sample,
target_pose,
display_size=display_size,
eval_size=eval_size,
need_oblique=False,
)
dt_rt = perf_counter() - t_rt
t_ri = perf_counter()
init_mask, init_mask_eval, init_oblique = render_views_fast(
sample,
init_pose,
display_size=display_size,
eval_size=eval_size,
need_oblique=True,
)
dt_ri = perf_counter() - t_ri
target_path = paths["data"] / stream / "target" / f"{sample_id}.png"
init_path = paths["data"] / stream / "init" / f"{sample_id}.png"
init_oblique_path = paths["data"] / stream / "init_oblique" / f"{sample_id}.png"
t_wp = perf_counter()
if args.save_target_images:
write_png_gray(target_path, target_mask)
if args.save_init_images:
write_png_gray(init_path, init_mask)
if args.save_init_oblique_images:
write_png_gray(init_oblique_path, init_oblique)
dt_wp = perf_counter() - t_wp
t_pack = perf_counter()
optimal_steps = pose_distance_steps(target_pose, init_pose, sample["theta"])
init_iou = iou(target_mask_eval, init_mask_eval)
task = {
"sample_id": sample_id,
"stream_type": stream,
"theta": sample["theta"],
"T_max": sample["T_max"],
"tau_success": sample["tau_success"],
"target_pose": sample["target_pose"],
"init_pose": sample["init_pose"],
"shape_seed": sample["shape_seed"],
"base_shape": sample["base_shape"],
"source_dataset": sample["source_dataset"],
"category": sample["category"],
"icon_slug": sample["icon_slug"],
"icon_svg": sample["icon_svg"],
"icon_points": sample["icon_points"],
"icon_quality": sample.get("icon_quality", {}),
"complexity": sample["complexity"],
"surface_mode": sample["surface_mode"],
"icon_scale": sample["icon_scale"],
"icon_center_mode": sample.get("icon_center_mode", "bbox"),
"sphere_radius": sample["sphere_radius"],
"sphere_depth_scale": sample.get("sphere_depth_scale", 0.26),
"sphere_fit_icon": bool(sample.get("sphere_fit_icon", True)),
"sphere_xy_ratio": float(sample.get("sphere_xy_ratio", 0.72)),
"sphere_double_sided": bool(sample.get("sphere_double_sided", True)),
"sphere_solid": bool(sample.get("sphere_solid", True)),
"sphere_fill_layers": int(sample.get("sphere_fill_layers", 11)),
"radial_jitter": sample["radial_jitter"],
"rim_softness": sample["rim_softness"],
"fine_noise": sample["fine_noise"],
"surface_holes": sample.get("surface_holes", []),
"surface_hole_attempts": int(sample.get("surface_hole_attempts", 0)),
"surface_hole_kept": int(sample.get("surface_hole_kept", 0)),
"surface_hole_consecutive_failures": int(sample.get("surface_hole_consecutive_failures", 0)),
"target_image": str(target_path.relative_to(root)).replace("\\", "/") if args.save_target_images else "",
"init_image": str(init_path.relative_to(root)).replace("\\", "/") if args.save_init_images else "",
"init_oblique_image": str(init_oblique_path.relative_to(root)).replace("\\", "/")
if args.save_init_oblique_images
else "",
"display_size": {"width": display_size[0], "height": display_size[1]},
"eval_size": eval_size,
"optimal_steps": optimal_steps,
"answer_actions": sample["answer_actions"],
"scramble_actions": sample["scramble_actions"],
"init_iou": round(init_iou, 6),
"meta": sample["meta"],
}
dt_pack = perf_counter() - t_pack
return task, {
"render_target_s": dt_rt,
"render_init_s": dt_ri,
"write_png_s": dt_wp,
"task_pack_s": dt_pack,
}
def main() -> None:
args = parse_args()
root = Path(args.root).resolve()
paths = resolve_paths(root)
cfg_path = root / args.config
if cfg_path.exists():
cfg = read_json(cfg_path)
else:
cfg = load_default_config()
if int(args.sample_count) > 0:
cfg["sample_count"] = int(args.sample_count)
write_json(cfg_path, cfg)
if "icon_categories" not in cfg:
cfg["icon_categories"] = ["all"]
write_json(cfg_path, cfg)
debug_timing = bool(cfg.get("debug_timing", False))
timing_report: Dict[str, object] = {}
runtime_caps = {
"numpy": bool(getattr(core, "np", None) is not None),
"numba": bool(getattr(core, "njit", None) is not None),
"opencv": bool(getattr(core, "cv2", None) is not None),
}
fast_render_enabled = runtime_caps["numpy"] and runtime_caps["numba"] and runtime_caps["opencv"]
print(
"[runtime][step01] "
f"numpy={runtime_caps['numpy']} "
f"numba={runtime_caps['numba']} "
f"opencv={runtime_caps['opencv']} "
f"fast_render={fast_render_enabled}"
)
if not fast_render_enabled:
print(
"[runtime][step01][warn] "
"Fast render path disabled. This can make Generate single-stream very slow."
)
timing_report["runtime_caps"] = runtime_caps
timing_report["fast_render_enabled"] = bool(fast_render_enabled)
pool_limit = int(cfg.get("icon_pool_limit", 1200))
t_icon_db = perf_counter()
icon_db, icon_db_timing = build_icon_db(
root,
cfg.get("icon_categories", ["all"]),
pool_limit=pool_limit,
quality_cfg=cfg,
)
_print_icon_filter_report(cfg, icon_db_timing, icon_db)
timing_report["build_icon_db_total_s"] = round(perf_counter() - t_icon_db, 6)
timing_report["build_icon_db"] = icon_db_timing
single_path = paths["data"] / "single" / "samples.jsonl"
if args.save_target_images:
ensure_dir(paths["data"] / "single" / "target")
if args.save_init_images:
ensure_dir(paths["data"] / "single" / "init")
if args.save_init_oblique_images:
ensure_dir(paths["data"] / "single" / "init_oblique")
eval_size = STANDARD_IMAGE_SIZE
display_size = STANDARD_DISPLAY_SIZE
checkpoint_path = paths["reports"] / "step_01_checkpoint.json"
sample_count = int(cfg.get("sample_count", 0))
if sample_count <= 0:
sample_count = 1000
icon_pool = build_unique_icon_pool(cfg, icon_db=icon_db)
icon_passed_by_category = {
cat: int(icon_db_timing.get("categories", {}).get(cat, {}).get("passed", 0))
for cat in cfg.get("icon_categories", [])
}
# The pool keeps only cache references; release all decoded points before rendering.
del icon_db
if sample_count > len(icon_pool):
raise RuntimeError(
f"Requested sample_count={sample_count}, but unique icons={len(icon_pool)} "
f"for categories={cfg.get('icon_categories', ['all'])}. Increase categories or reduce sample_count."
)
checkpoint = load_checkpoint(checkpoint_path) if args.resume else {}
cfg_fp = config_fingerprint(cfg)
completed_sample_ids: List[str] = []
used_icon_slugs: List[str] = []
completed_count = 0
rng = random.Random(cfg["random_seed"] + 1)
icon_order_slugs: List[str] = []
icon_lookup = {str(item["icon_slug"]): item for item in icon_pool}
icon_cursor = 0
next_sample_index = 0
skipped_trivial_init_count = 0
if args.resume and checkpoint:
if checkpoint.get("config_fingerprint", "") != cfg_fp:
raise RuntimeError("Checkpoint config fingerprint mismatch. Refuse to resume with different Step1 config.")
prev_target = int(checkpoint.get("sample_count_target", 0))
if prev_target > sample_count:
raise RuntimeError(
f"Checkpoint target sample_count={prev_target} is larger than current requested sample_count={sample_count}."
)
icon_order_slugs = [str(x) for x in checkpoint.get("icon_order", [])]
if len(icon_order_slugs) != len(icon_pool):
raise RuntimeError("Checkpoint icon order size mismatch. Refuse to resume.")
missing = [slug for slug in icon_order_slugs if slug not in icon_lookup]
if missing:
raise RuntimeError(f"Checkpoint icon order contains missing slugs, e.g. {missing[:3]}")
rng.setstate(decode_rng_state(str(checkpoint.get("rng_state", ""))))
completed_sample_ids, used_icon_slugs = scan_sample_metadata(single_path)
task_rows = count_jsonl_rows(paths["tasks"])
completed_count = min(
int(checkpoint.get("completed_count", 0)),
len(completed_sample_ids),
task_rows,
)
# A process may stop between the two JSONL appends and the checkpoint write.
# Reconcile both files to the last fully checkpointed pair before continuing.
if len(completed_sample_ids) != completed_count:
truncate_jsonl_rows(single_path, completed_count)
if task_rows != completed_count:
truncate_jsonl_rows(paths["tasks"], completed_count)
checkpoint_count = int(checkpoint.get("completed_count", 0))
if completed_count != checkpoint_count:
raise RuntimeError(
"Checkpoint is ahead of one or both JSONL files; RNG state cannot be recovered safely. "
"Restart with --no-resume."
)
icon_cursor = int(checkpoint.get("icon_cursor", completed_count))
next_sample_index = int(checkpoint.get("next_sample_index", completed_count))
skipped_trivial_init_count = int(checkpoint.get("skipped_trivial_init_count", 0))
checkpoint["sample_count_target"] = sample_count
completed_sample_ids = completed_sample_ids[:completed_count]
used_icon_slugs = used_icon_slugs[:completed_count]
else:
rng.shuffle(icon_pool)
icon_order_slugs = [str(item["icon_slug"]) for item in icon_pool]
write_jsonl(single_path, [])
write_jsonl(paths["tasks"], [])
checkpoint = {
"version": 1,
"mode": "step01_single_stream_resume",
"config_fingerprint": cfg_fp,
"sample_count_target": sample_count,
"completed_count": 0,
"icon_cursor": 0,
"next_sample_index": 0,
"used_icon_slugs": [],
"completed_sample_ids": [],
"icon_order": icon_order_slugs,
"skipped_trivial_init_count": 0,
"rng_state": encode_rng_state(rng.getstate()),
"samples_file": str(single_path.relative_to(root)).replace("\\", "/"),
"tasks_file": str(paths["tasks"].relative_to(root)).replace("\\", "/"),
}
write_json(checkpoint_path, checkpoint)
icon_pool = [icon_lookup[slug] for slug in icon_order_slugs]
render_timing = {
"render_target_s": 0.0,
"render_init_s": 0.0,
"write_png_s": 0.0,
"task_pack_s": 0.0,
"total_loop_s": 0.0,
"tasks": sample_count,
"completed_before_resume": completed_count,
"skipped_trivial_init_before_resume": skipped_trivial_init_count,
}
per_sample_timing: List[Dict[str, float]] = []
t_render_loop = perf_counter()
t_gen_samples = 0.0
t_write_samples = 0.0
progress = tqdm(total=sample_count, initial=completed_count, desc="Generate+render tasks", unit="task")
while completed_count < sample_count:
if icon_cursor >= len(icon_pool):
raise RuntimeError(
f"Step1 exhausted unique icon pool at accepted={completed_count}, skipped_trivial_init={skipped_trivial_init_count}. "
"Reduce sample_count or loosen icon filters."
)
t_sample = perf_counter()
icon = materialize_icon_points(root, icon_pool[icon_cursor])
sample = generate_single_sample(next_sample_index, cfg, icon, rng)
t_gen_samples += perf_counter() - t_sample
task, sample_t = build_task_row(
sample=sample,
root=root,
paths=paths,
args=args,
display_size=display_size,
eval_size=eval_size,
)
render_timing["render_target_s"] += float(sample_t["render_target_s"])
render_timing["render_init_s"] += float(sample_t["render_init_s"])
render_timing["write_png_s"] += float(sample_t["write_png_s"])
render_timing["task_pack_s"] += float(sample_t["task_pack_s"])
icon_cursor += 1
tau = float(task.get("tau_success", cfg.get("tau_success", 0.9)))
if float(task.get("init_iou", 0.0)) >= tau:
skipped_trivial_init_count += 1
if args.save_target_images:
target_path = root / task.get("target_image", "")
if str(task.get("target_image", "")).strip() and target_path.exists():
target_path.unlink()
if args.save_init_images:
init_path = root / task.get("init_image", "")
if str(task.get("init_image", "")).strip() and init_path.exists():
init_path.unlink()
if args.save_init_oblique_images:
init_oblique_path = root / task.get("init_oblique_image", "")
if str(task.get("init_oblique_image", "")).strip() and init_oblique_path.exists():
init_oblique_path.unlink()
checkpoint["completed_count"] = completed_count
checkpoint["icon_cursor"] = icon_cursor
checkpoint["next_sample_index"] = next_sample_index
checkpoint["skipped_trivial_init_count"] = skipped_trivial_init_count
checkpoint["rng_state"] = encode_rng_state(rng.getstate())
write_json(checkpoint_path, checkpoint)
if debug_timing:
dt_sample = perf_counter() - t_sample
print(
f"[timing][step01][skip][{sample['sample_id']}] "
f"init_iou={float(task.get('init_iou', 0.0)):.4f} "
f"tau={tau:.4f} total_ms={dt_sample * 1000:.2f}"
)
continue
t_ws = perf_counter()
append_jsonl(single_path, sample)
t_write_samples += perf_counter() - t_ws
append_jsonl(paths["tasks"], task)
completed_sample_ids.append(str(sample["sample_id"]))
used_icon_slugs.append(str(sample["icon_slug"]))
completed_count += 1
next_sample_index += 1
progress.update(1)
checkpoint["completed_count"] = completed_count
checkpoint["icon_cursor"] = icon_cursor
checkpoint["next_sample_index"] = next_sample_index
checkpoint["used_icon_slugs"] = used_icon_slugs
checkpoint["completed_sample_ids"] = completed_sample_ids
checkpoint["skipped_trivial_init_count"] = skipped_trivial_init_count
checkpoint["rng_state"] = encode_rng_state(rng.getstate())
write_json(checkpoint_path, checkpoint)
if debug_timing:
dt_sample = perf_counter() - t_sample
sample_timing = {
"sample_id": sample["sample_id"],
"render_target_s": round(float(sample_t["render_target_s"]), 6),
"render_init_s": round(float(sample_t["render_init_s"]), 6),
"write_png_s": round(float(sample_t["write_png_s"]), 6),
"task_pack_s": round(float(sample_t["task_pack_s"]), 6),
"total_s": round(dt_sample, 6),
}
per_sample_timing.append(sample_timing)
print(
f"[timing][step01][{sample['sample_id']}] "
f"target_render_ms={float(sample_t['render_target_s']) * 1000:.2f} "
f"init_render_ms={float(sample_t['render_init_s']) * 1000:.2f} "
f"write_png_ms={float(sample_t['write_png_s']) * 1000:.2f} "
f"task_pack_ms={float(sample_t['task_pack_s']) * 1000:.2f} "
f"total_ms={dt_sample * 1000:.2f}"
)
progress.close()
render_timing["total_loop_s"] = round(perf_counter() - t_render_loop, 6)
timing_report["generate_single_stream_s"] = round(t_gen_samples, 6)
timing_report["write_samples_jsonl_s"] = round(t_write_samples, 6)
timing_report["render_tasks"] = {k: (round(v, 6) if isinstance(v, float) else v) for k, v in render_timing.items()}
if debug_timing:
timing_report["render_tasks"]["per_sample"] = per_sample_timing
if per_sample_timing:
avg_total_s = sum(s["total_s"] for s in per_sample_timing) / len(per_sample_timing)
slowest = sorted(per_sample_timing, key=lambda x: x["total_s"], reverse=True)[:3]
timing_report["render_tasks"]["avg_sample_total_s"] = round(avg_total_s, 6)
timing_report["render_tasks"]["slowest_samples_top3"] = slowest
print(f"[timing][step01][summary] avg_sample_total_ms={avg_total_s * 1000:.2f}")
for item in slowest:
print(
f"[timing][step01][slow] sample={item['sample_id']} "
f"total_ms={item['total_s'] * 1000:.2f}"
)
timing_report["write_tasks_jsonl_s"] = 0.0
summary = {
"total_tasks": completed_count,
"single_tasks": completed_count,
"engine_mode": "single_stream_spherical_icon_inverse_path",
"source_dataset": "game_icons",
"display_size": {"width": display_size[0], "height": display_size[1]},
"eval_size": eval_size,
"icon_categories": cfg.get("icon_categories", []),
"icon_filter_thresholds": {
"icon_min_connected_ratio": float(cfg.get("icon_min_connected_ratio", 0.985)),
"icon_min_circle_iou": float(cfg.get("icon_min_circle_iou", 0.28)),
"icon_min_bbox_fill": float(cfg.get("icon_min_bbox_fill", 0.08)),
"icon_max_aspect_ratio": float(cfg.get("icon_max_aspect_ratio", 2.2)),
"icon_min_pixel_points": int(cfg.get("icon_min_pixel_points", 1800)),
},
"icon_filter_counts": {
"per_category": {
cat: {
"candidates": int(icon_db_timing.get("categories", {}).get(cat, {}).get("candidates", 0)),
"passed": int(icon_passed_by_category.get(cat, 0)),
}
for cat in cfg.get("icon_categories", [])
},
"total_candidates": int(
sum(int(icon_db_timing.get("categories", {}).get(cat, {}).get("candidates", 0)) for cat in cfg.get("icon_categories", []))
),
"total_passed": int(
sum(
int(icon_passed_by_category.get(cat, 0))
for cat in cfg.get("icon_categories", [])
)
),
},
"save_target_images": bool(args.save_target_images),
"save_init_images": bool(args.save_init_images),
"save_init_oblique_images": bool(args.save_init_oblique_images),
"tasks_file": str(paths["tasks"].relative_to(root)).replace("\\", "/"),
"resume_enabled": bool(args.resume),
"checkpoint_file": str(checkpoint_path.relative_to(root)).replace("\\", "/"),
"used_icon_slugs_count": len(set(used_icon_slugs)),
"skipped_trivial_init_count": skipped_trivial_init_count,
}
write_json(paths["reports"] / "step_01_summary.json", summary)
if debug_timing:
write_json(paths["reports"] / "step_01_timing.json", timing_report)
summary["timing_report"] = str((paths["reports"] / "step_01_timing.json").relative_to(root)).replace("\\", "/")
print(json.dumps(summary, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""Step 01: generate single-stream data and tasks from open-source solid icon database."""
from __future__ import annotations
import io
import argparse
import base64
import json
import hashlib
import math
import pickle
import random
import subprocess
import benchmark_core as core
from collections import deque
from pathlib import Path
from time import perf_counter
from typing import Dict, List, Optional, Set, Tuple
try:
import numpy as np
except Exception: # pragma: no cover
np = None
try:
from tqdm import tqdm
except Exception:
def tqdm(iterable=None, **kwargs): # type: ignore
return iterable
from benchmark_core import (
ACTIONS,
Pose,
apply_action,
create_mask,
create_oblique_view,
ensure_dir,
iou,
load_default_config,
pose_distance_steps,
render_views_fast,
read_json,
read_jsonl,
resolve_paths,
write_json,
write_jsonl,
write_png_gray,
)
from render_protocol import STANDARD_DISPLAY_SIZE, STANDARD_IMAGE_SIZE
INIT_THETA_DEG = 30
ALLOWED_STEP_ANGLES = [30, 10, 5]
MAX_ICON_POINTS = 90000
ICON_CACHE_FORMAT_VERSION = 2
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description="Step 01 generate data")
parser.add_argument("--root", type=str, default=".", help="Project root path")
parser.add_argument(
"--config",
type=str,
default="results/artifacts/config/run_config.json",
help="Config path relative to root",
)
parser.add_argument("--save-init-images", action="store_true", help="Save init projection PNGs")
parser.add_argument("--save-init-oblique-images", action="store_true", help="Save init oblique PNGs")
parser.add_argument("--sample-count", type=int, default=0, help="Override sample_count in config when > 0")
parser.add_argument("--resume", dest="resume", action="store_true", help="Resume Step1 from checkpoint")
parser.add_argument("--no-resume", dest="resume", action="store_false", help="Start Step1 from scratch")
parser.add_argument(
"--no-save-target-images",
dest="save_target_images",
action="store_false",
help="Do not save target PNGs (may break API-based Step02)",
)
parser.set_defaults(save_target_images=True)
parser.set_defaults(resume=False)
return parser.parse_args()
def random_pose(rng: random.Random) -> Pose:
choices = list(range(-120, 121, 15))
return Pose(roll=rng.choice(choices), pitch=rng.choice(choices), yaw=rng.choice(choices))
def _slug(svg_path: Path) -> str:
return f"{svg_path.parent.name}-{svg_path.stem}".lower().replace(" ", "-")
def uniform_downsample_points(points: List[List[float]], max_points: int) -> List[List[float]]:
"""Keep the full scan range while deterministically limiting point count."""
if max_points <= 0:
raise ValueError("max_points must be positive")
if len(points) <= max_points:
return points
if max_points == 1:
return [points[0]]
last = len(points) - 1
denominator = max_points - 1
return [points[(index * last) // denominator] for index in range(max_points)]