#!/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()