Fr0zkaandClaude Opus 5.5
7d654ff861
Layers may publish certified arrival/departure pads; the passage planner binds endpoints and tangents to them; no-pad layouts serialize unchanged (owner canonical hashes match v227). Pads removed the endpoint grade failures; seeds 0-4 passed at a 45 m margin, but seed 5 still has 289 blocked passage-capsule samples ~29 m before the departure pad, where the composed field stays solid (-0.162) inside the tube over native ground (-3.6). Ripple audit now keeps true route distance across masked gaps (with a synthetic control). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
244 lines
12 KiB
Python
244 lines
12 KiB
Python
#!/usr/bin/env python3
|
|
"""Capture one arrival-mouth eye view per Core.Liminal.Field v2 variant."""
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import json
|
|
import math
|
|
import os
|
|
from pathlib import Path
|
|
import subprocess
|
|
import sys
|
|
import time
|
|
|
|
|
|
ROOT = Path(__file__).resolve().parents[4]
|
|
HERE = Path(__file__).resolve().parent
|
|
OUT = ROOT / "Saved/Linux/l145"
|
|
CAPTURES = HERE / "captures"
|
|
LIMIT = ["taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--"]
|
|
Q_PER_METRE = 1024.0
|
|
|
|
sys.path.insert(0, str(ROOT / "Standalone/Tools/verify"))
|
|
from runner import bounded_run, current_stamp, first_stamp
|
|
|
|
|
|
def fmt(values) -> str:
|
|
return ",".join(f"{value:.6f}" for value in values)
|
|
|
|
|
|
def sha256(path: Path) -> str:
|
|
digest = hashlib.sha256()
|
|
with path.open("rb") as stream:
|
|
for block in iter(lambda: stream.read(1024 * 1024), b""):
|
|
digest.update(block)
|
|
return digest.hexdigest()
|
|
|
|
|
|
def run_step(name: str, command: list[object], log: Path, env: dict[str, str],
|
|
stamped: bool = False) -> str:
|
|
expected_stamp = current_stamp() if stamped else None
|
|
if stamped:
|
|
binary = Path(str(command[0]))
|
|
probe = bounded_run([str(binary), "--print-source-stamp"], timeout=15)
|
|
if probe is None or probe.returncode != 0 \
|
|
or first_stamp(probe.stdout or "") != expected_stamp:
|
|
raise RuntimeError(f"{name} refused a stale executable: {binary}")
|
|
started = time.monotonic()
|
|
log.parent.mkdir(parents=True, exist_ok=True)
|
|
with log.open("w", encoding="utf-8") as stream:
|
|
result = subprocess.run([*LIMIT, "timeout", "1740s", *map(str, command)],
|
|
cwd=ROOT, env=env, stdout=stream, stderr=subprocess.STDOUT,
|
|
timeout=1745, check=False)
|
|
output = log.read_text(encoding="utf-8", errors="replace")
|
|
elapsed = time.monotonic() - started
|
|
print(f"[L145Run] step={name} elapsed_s={elapsed:.3f} exit={result.returncode} log={log}",
|
|
flush=True)
|
|
if stamped and (first_stamp(output) != expected_stamp
|
|
or current_stamp() != expected_stamp):
|
|
raise RuntimeError(f"{name} source stamp mismatch; see {log}")
|
|
if result.returncode != 0:
|
|
raise RuntimeError(f"{name} exit={result.returncode}; see {log}")
|
|
return output
|
|
|
|
|
|
def camera_angles(camera, target):
|
|
dx, dy, dz = (target[i] - camera[i] for i in range(3))
|
|
return math.degrees(math.atan2(dx, dy)), math.degrees(
|
|
math.atan2(dz, math.hypot(dx, dy)))
|
|
|
|
|
|
def route_views(manifest_path: Path, layout_path: Path, name: str):
|
|
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
|
|
layout = json.loads(layout_path.read_text(encoding="utf-8"))
|
|
plan = next(row for row in manifest["plan"]["strates"]
|
|
if row["strate_index"] == 1 and row.get("liminal_field", {}).get("version") == 2)
|
|
points = [tuple(value / Q_PER_METRE for value in row["position_q"])
|
|
for row in plan["route"]]
|
|
first, second = points[0], points[1]
|
|
dx, dy = second[0] - first[0], second[1] - first[1]
|
|
length = math.hypot(dx, dy)
|
|
if length <= 1.0e-6:
|
|
raise RuntimeError("Core.Liminal.Field arrival tangent is degenerate")
|
|
tx, ty = dx / length, dy / length
|
|
eye_camera = (first[0] - tx * 1.5, first[1] - ty * 1.5, first[2] + 1.6)
|
|
third = points[min(2, len(points) - 1)]
|
|
dx, dy = third[0] - first[0], third[1] - first[1]
|
|
tangent_length = math.hypot(dx, dy)
|
|
tx, ty = dx / tangent_length, dy / tangent_length
|
|
dz_per_metre = (third[2] - first[2]) / tangent_length
|
|
eye_target = (first[0] + tx * 40.0, first[1] + ty * 40.0,
|
|
first[2] + dz_per_metre * 40.0 + 1.6)
|
|
|
|
middle = len(points) // 2
|
|
before, center, after = points[middle - 1], points[middle], points[middle + 1]
|
|
dx, dy = after[0] - before[0], after[1] - before[1]
|
|
length = math.hypot(dx, dy)
|
|
if length <= 1.0e-6:
|
|
raise RuntimeError("Core.Liminal.Field wide-view tangent is degenerate")
|
|
tx, ty = dx / length, dy / length
|
|
nx, ny = -ty, tx
|
|
floor = plan["liminal_field"]["floor_height_q"] / Q_PER_METRE
|
|
if name == "flatField-monolith":
|
|
monolith = next(row for row in layout.get("stamps", [])
|
|
if row.get("stable_id") == "core/liminal-field/monolith/000")
|
|
monolith_center = tuple(value / 1.0e6 for value in monolith["position_um"])
|
|
floor = monolith_center[2] - monolith["half_extents_um"][2] / 1.0e6
|
|
wide_camera = (monolith_center[0] - tx * 30.0 + nx * 18.0,
|
|
monolith_center[1] - ty * 30.0 + ny * 18.0, floor + 25.0)
|
|
wide_target = monolith_center
|
|
elif name == "periodicHills":
|
|
wide_camera = (center[0] - 20.0, center[1] - 25.0, floor + 10.0)
|
|
wide_target = (center[0] + 10.0, center[1] + 8.0, floor + 1.0)
|
|
elif name == "pillar-grid":
|
|
pillars = [row for row in layout.get("stamps", [])
|
|
if row.get("stable_id", "").startswith("core/liminal-field/pillars/")]
|
|
if not pillars:
|
|
raise RuntimeError("pillar-grid layout has no resolved grid stamps")
|
|
pairs = []
|
|
for i, first_pillar in enumerate(pillars):
|
|
for second_pillar in pillars[i + 1:]:
|
|
a = first_pillar["position_um"]
|
|
b = second_pillar["position_um"]
|
|
dx, dy = (b[0] - a[0]) / 1.0e6, (b[1] - a[1]) / 1.0e6
|
|
separation = math.hypot(dx, dy)
|
|
if 60.0 <= separation <= 90.0:
|
|
mx = (a[0] + b[0]) / 2.0e6
|
|
my = (a[1] + b[1]) / 2.0e6
|
|
pairs.append((math.hypot(mx - center[0], my - center[1]),
|
|
mx, my, dx / separation, dy / separation,
|
|
(a[2] + b[2]) / 2.0e6,
|
|
first_pillar["half_extents_um"][2] / 1.0e6))
|
|
if not pairs:
|
|
raise RuntimeError("pillar-grid has no neighboring resolved columns")
|
|
_, mx, my, tx, ty, pillar_z, half_height = min(pairs)
|
|
floor = pillar_z - half_height
|
|
nx, ny = -ty, tx
|
|
wide_camera = (center[0] - tx * 20.0 + nx * 25.0,
|
|
center[1] - ty * 20.0 + ny * 25.0, center[2] + 8.0)
|
|
wide_target = (center[0], center[1], floor + 2.0)
|
|
else:
|
|
wide_camera = (center[0] - tx * 20.0 + nx * 25.0,
|
|
center[1] - ty * 20.0 + ny * 25.0, center[2] + 8.0)
|
|
wide_target = (center[0], center[1], floor + 2.0)
|
|
return {"eye": (eye_camera, eye_target), "wide": (wide_camera, wide_target)}
|
|
|
|
|
|
def capture_variant(seed: int, name: str, *, headless: Path, renderer: Path,
|
|
fixture: Path, env: dict[str, str]):
|
|
stem = f"core-liminal-{name}-seed{seed:02d}"
|
|
plan_dir = OUT / "capture-plans" / stem
|
|
plan_dir.mkdir(parents=True, exist_ok=True)
|
|
manifest = plan_dir / "manifest.json"
|
|
layout = plan_dir / "layout.json"
|
|
command = [headless, fixture, "--workers=1", f"--seed={seed}",
|
|
"--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
|
|
"--force-generate", "--clip-radius=1", "--max-clip-level=0", "--max-level=0",
|
|
"--render-distance-chunks=0", "--camera=0,0,-540,0,0",
|
|
f"--world-assembler-manifest-output={manifest}",
|
|
f"--resolved-layout-output={layout}"]
|
|
output = run_step(f"plan-{stem}", command, OUT / "logs" / f"capture-{stem}-plan.log",
|
|
env, stamped=True)
|
|
if "[CoreLiminalFieldDraw]" not in output:
|
|
raise RuntimeError(f"{stem} plan omitted its Core liminal deck")
|
|
views = route_views(manifest, layout, name)
|
|
for view, (eye, target) in {"eye": views["eye"]}.items():
|
|
work = OUT / "captures" / f"{stem}-{view}"
|
|
work.mkdir(parents=True, exist_ok=True)
|
|
view_manifest = work / "manifest.json"
|
|
view_layout = work / "layout.json"
|
|
mesh = work / "world.vfmesh"
|
|
yaw, pitch = camera_angles(eye, target)
|
|
camera = (*eye, yaw, pitch)
|
|
view_clip_radius = (5 if view == "wide" and name in {
|
|
"flatField-monolith", "periodicHills"} else
|
|
3)
|
|
command = [headless, fixture, "--workers=12", f"--seed={seed}",
|
|
"--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
|
|
"--force-generate", f"--clip-radius={view_clip_radius}",
|
|
"--max-clip-level=0", "--max-level=0",
|
|
"--render-distance-chunks=0", "--capture-skip-walkability",
|
|
f"--camera={fmt(camera)}", f"--mesh-export={mesh}",
|
|
f"--world-assembler-manifest-output={view_manifest}",
|
|
f"--resolved-layout-output={view_layout}"]
|
|
output = run_step(f"export-{stem}-{view}", command,
|
|
OUT / "logs" / f"capture-{stem}-{view}-export.log", env, stamped=True)
|
|
if "[CoreLiminalFieldDraw]" not in output or not mesh.is_file() \
|
|
or mesh.stat().st_size == 0:
|
|
raise RuntimeError(f"{stem}-{view} export omitted its Core liminal deck or mesh")
|
|
png = work / f"{view}.png"
|
|
image = CAPTURES / f"{stem}-{view}.jpg"
|
|
fog = {
|
|
"flatField-monolith": (30, 180, "0.66,0.73,0.77", -708.0, 46.0),
|
|
"periodicHills": (140, 850, "0.78,0.84,0.88", -720.0, 14.0),
|
|
"road-over-cloud-floor": (24, 420, "0.88,0.93,0.95", -720.0, 65.0),
|
|
"pillar-grid": (180, 1200, "0.82,0.88,0.91", -720.0, 80.0),
|
|
}[name]
|
|
fog_start, fog_end, fog_color, height_center, height_range = fog
|
|
render = [renderer, mesh, png, "--size=1600x900", "--fov-deg=72",
|
|
f"--camera-m={fmt(eye)}", f"--yaw-deg={yaw:.6f}", f"--pitch-deg={pitch:.6f}",
|
|
"--tile-skirts=on", "--shade=readable", "--headlamp=off", "--height-tint=on",
|
|
f"--height-center-m={height_center:.6f}", f"--height-range-m={height_range:.6f}",
|
|
"--light-direction=-0.42,-0.58,0.70", "--fog=on", f"--fog-start-m={fog_start}",
|
|
f"--fog-end-m={fog_end}", f"--fog-color={fog_color}"]
|
|
run_step(f"render-{stem}-{view}", render,
|
|
OUT / "logs" / f"capture-{stem}-{view}-render.log", env, stamped=True)
|
|
run_step(f"jpeg-{stem}-{view}", ["ffmpeg", "-nostdin", "-hide_banner", "-loglevel",
|
|
"error", "-y", "-i", png, "-frames:v", "1", "-q:v", "4", image],
|
|
OUT / "logs" / f"capture-{stem}-{view}-jpeg.log", env)
|
|
run_step(f"quality-{stem}-{view}", [sys.executable,
|
|
ROOT / "Standalone/Tools/verify/capture_quality.py", image],
|
|
OUT / "logs" / f"capture-{stem}-{view}-quality.log", env)
|
|
print(f"[L145Capture] variant={name} seed={seed} view={view} "
|
|
f"eye_height={'1.600m' if view == 'eye' else 'wide'} bytes={image.stat().st_size} "
|
|
f"sha256={sha256(image)} status=PASS", flush=True)
|
|
|
|
|
|
def main() -> int:
|
|
headless = ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-l145-clang"
|
|
renderer = ROOT / "Standalone/bin/linux/VoxelForgeOffscreenCapture-l145-clang"
|
|
fixture = OUT / "fixtures/core-liminal-field-3-strata.json"
|
|
env = os.environ.copy()
|
|
env["VOXELFORGE_VERIFY_OUT"] = str(OUT)
|
|
env["VOXELFORGE_OWNER_DATA"] = str(ROOT / "Standalone/data/owner_world.json")
|
|
env["LP_NUM_THREADS"] = "12"
|
|
env["XDG_CACHE_HOME"] = str(OUT / "xdg-cache")
|
|
CAPTURES.mkdir(parents=True, exist_ok=True)
|
|
variants = ("flatField-monolith", "periodicHills",
|
|
"road-over-cloud-floor", "pillar-grid")
|
|
selected = set(os.environ.get("L145_CAPTURE_VARIANTS", "").split(","))
|
|
for seed, name in enumerate(variants):
|
|
if selected and name not in selected:
|
|
continue
|
|
capture_variant(seed, name, headless=headless, renderer=renderer,
|
|
fixture=fixture, env=env)
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
raise SystemExit(main())
|
|
except Exception as error:
|
|
print(f"[L145Capture] status=FAIL error={error}", file=sys.stderr, flush=True)
|
|
raise SystemExit(1)
|