From 3d50023cfa36454016d5cdadd15da4737a8a2ff1 Mon Sep 17 00:00:00 2001 From: Rick Falkvinge Date: Wed, 14 Oct 2026 11:39:57 +0000 Subject: [PATCH] Toolkit: segment, mass, render plates, batch, gate, matrices, cost, smoke test Generalized from the render lanes' proven tools: map segmentation, 2.5D massing by wealth zone, a CPU ray marcher with analytic landmarks and true-scale proxy people, prompt composition from blocks, a self-calibrating batch submitter with a renderer adapter point, the plate-vs-frame gates (drift, ECC, landmark region, skyline and invented structures, figure brackets, corner sweep), matrix job builders, a cost line, and an end-to-end smoke test on a synthetic town. --- .gitignore | 8 + requirements.txt | 4 + scripts/adapters/README.md | 30 ++ scripts/build_jobs.py | 84 +++++ scripts/citykit.py | 76 +++++ scripts/cost.py | 40 +++ scripts/gate.py | 372 ++++++++++++++++++++++ scripts/massing.py | 213 +++++++++++++ scripts/matrix_jobs.py | 100 ++++++ scripts/qc_sheet.py | 77 +++++ scripts/render_batch.py | 178 +++++++++++ scripts/render_plate.py | 620 +++++++++++++++++++++++++++++++++++++ scripts/scene_solids.py | 238 ++++++++++++++ scripts/segment_map.py | 102 ++++++ scripts/smoke_test.py | 167 ++++++++++ 15 files changed, 2309 insertions(+) create mode 100644 .gitignore create mode 100644 requirements.txt create mode 100644 scripts/adapters/README.md create mode 100644 scripts/build_jobs.py create mode 100644 scripts/citykit.py create mode 100644 scripts/cost.py create mode 100644 scripts/gate.py create mode 100644 scripts/massing.py create mode 100644 scripts/matrix_jobs.py create mode 100644 scripts/qc_sheet.py create mode 100644 scripts/render_batch.py create mode 100644 scripts/render_plate.py create mode 100644 scripts/scene_solids.py create mode 100644 scripts/segment_map.py create mode 100644 scripts/smoke_test.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7eb5645 --- /dev/null +++ b/.gitignore @@ -0,0 +1,8 @@ +__pycache__/ +*.pyc +.venv/ +*.npz +*.npy +plates/ +out_*/ +smoke/ diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..7fc9fa6 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +numpy>=1.24 +opencv-python-headless>=4.8 +Pillow>=10.0 +requests>=2.31 diff --git a/scripts/adapters/README.md b/scripts/adapters/README.md new file mode 100644 index 0000000..caeb8af --- /dev/null +++ b/scripts/adapters/README.md @@ -0,0 +1,30 @@ +# Renderer adapters + +`render_batch.py` talks to the renderer through one function: + +```python +def submit(job, refs, spec, env): + """job: one entry of jobs.json (id, prompt, size, refs, prompt_alt) + refs: absolute paths of the reference images, IMAGE 1 first (the plate), then style/material refs + spec: the jobs.json header (model, quality, ...) + env: {"key": IMAGE_API_KEY, "base": IMAGE_API_BASE} + returns (status_code, png_bytes_or_None, error_body_text, response_headers_or_{})""" +``` + +The built-in `openai_images` adapter posts to an OpenAI-compatible `/images/edits` endpoint (multipart, `image[]` +for every reference, `prompt`, `size`, `quality`, `output_format=png`). Jobs with no references go to +`/images/generations`. + +What the method needs from a renderer, in order of importance: + +1. **Image-conditioned editing with several references** where the first image is treated as the scene to re-surface + and the others as material/style references. The plate must dominate the layout. +2. **A 16:9 output at 2048x1152 or similar** so the plate-to-frame registration is pixel-comparable. +3. **No seed and no strength dial is fine.** The method never relied on either: geometry is held by the plate and the + prompt, variance is handled by rendering 2-4 takes and gating. +4. **A rate-limit signal** (HTTP 429 with Retry-After, or any 5xx) so the batch runner can calibrate concurrency. + +Return 429/5xx for "try later" conditions and any other non-200 for a hard failure. A body containing +`safety`, `moderation`, `content_policy` or `rejected` triggers the one allowed rephrase (`prompt_alt`). + +Drop your adapter in this directory as `.py` and run `render_batch.py --adapter `. diff --git a/scripts/build_jobs.py b/scripts/build_jobs.py new file mode 100644 index 0000000..c1abbf6 --- /dev/null +++ b/scripts/build_jobs.py @@ -0,0 +1,84 @@ +#!/usr/bin/env python3 +"""Compose re-surfacing prompts per camera from prompt blocks and write a jobs.json for render_batch.py. + +Two modes: + day IMAGE 1 = the plate; the prompt = [view.intro] + RESURF + [view.keep] + [setting blocks] + [view.frame] + + PEOPLE + [EYELINE if the camera is at eye level] + LIGHT + NOMODERN. One job per take. + relight IMAGE 1 = an accepted day take ("keeper"); the prompt repaints ONLY the light (sunset, night, morning). + Geometry carries over, which is why sunset/night cells are relights of the Day pick and never fresh edits. + +prompts.json holds the blocks (see examples/prompts.example.json): the generic ones (resurface, people, nomodern, +eyeline, lights) and the per-view ones (intro, keep, frame, refs, eye_level). Everything that names your world +(the setting, the landmarks, the materials by wealth zone) is yours to write; references/prompting.md explains +each block's job and the wording that measurably held. + +usage: build_jobs.py day --config citykit.json --prompts prompts.json [--views A,B] [--takes 3] [--tag day] --out jobs_day.json + build_jobs.py relight --config citykit.json --prompts prompts.json --light sunset V=keeper.png ... [--takes 3] --out jobs_sunset.json +Also writes _PROMPTS.md with the full text per view, for the lane report. +""" +import argparse +import json +import os + +from citykit import load_config, resolve + + +def day_jobs(cfg, P, views, takes, tag): + jobs, md = [], [] + plates = resolve(cfg, cfg.get("plates_dir", "plates")) + for v in views: + s = P["views"][v] + parts = [s.get("intro", ""), P["resurface"], s.get("keep", "")] + parts += [P[b] for b in s.get("setting_blocks", P.get("default_setting_blocks", []))] + if s.get("frame"): + parts.append(s["frame"]) + parts.append(P["people"]) + if s.get("eye_level", False): + parts.append(P["eyeline"]) + parts.append(P["lights"][s.get("light", "day")]) + parts.append(P["nomodern"]) + prompt = " ".join(p for p in parts if p) + refs = [os.path.join(plates, v + "_mass.png")] + [resolve(cfg, r) for r in s.get("refs", [])] + md.append("## %s\n\nrefs: %s\n\n%s\n" % (v, refs, prompt)) + for t in range(1, takes + 1): + jobs.append(dict(id="%s_%s_t%d" % (v, tag, t), size=cfg["renderer"].get("size", "2048x1152"), refs=refs, + prompt=prompt + " [view %s, %s, take %d]" % (v, tag, t))) + return jobs, md + + +def relight_jobs(cfg, P, keepers, light, takes): + jobs, md = [], [] + for v, path in keepers.items(): + s = P["views"].get(v, {}) + prompt = P["relights"][s.get("relight_variant", {}).get(light, light)] + " " + P["nomodern"] + md.append("## %s %s\n\nrefs: %s\n\n%s\n" % (v, light, path, prompt)) + for t in range(1, takes + 1): + jobs.append(dict(id="%s_%s_t%d" % (v, light, t), size=cfg["renderer"].get("size", "2048x1152"), + refs=[os.path.abspath(path)], prompt=prompt + " [view %s, %s, take %d]" % (v, light, t))) + return jobs, md + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("mode", choices=["day", "relight"]) + ap.add_argument("rest", nargs="*", help="relight: V=keeper.png pairs") + ap.add_argument("--config", required=True) + ap.add_argument("--prompts", required=True) + ap.add_argument("--views", default=None, help="comma list; default = every view in prompts.json") + ap.add_argument("--takes", type=int, default=3) + ap.add_argument("--tag", default="day") + ap.add_argument("--light", default="sunset") + ap.add_argument("--out", required=True) + a = ap.parse_intermixed_args() + cfg = load_config(a.config) + P = json.load(open(a.prompts)) + if a.mode == "day": + views = a.views.split(",") if a.views else list(P["views"]) + jobs, md = day_jobs(cfg, P, views, a.takes, a.tag) + else: + keep = dict(x.split("=", 1) for x in a.rest if "=" in x) + jobs, md = relight_jobs(cfg, P, keep, a.light, a.takes) + R = cfg["renderer"] + json.dump(dict(model=R["model"], quality=R.get("quality", "high"), refs_common=[], jobs=jobs), open(a.out, "w"), indent=1) + open(os.path.splitext(a.out)[0] + "_PROMPTS.md", "w").write("\n".join(md)) + print(len(jobs), "jobs ->", a.out) diff --git a/scripts/citykit.py b/scripts/citykit.py new file mode 100644 index 0000000..07b1536 --- /dev/null +++ b/scripts/citykit.py @@ -0,0 +1,76 @@ +"""Shared helpers for the city render toolkit: config loading, world/map transforms, image utilities. + +The world frame is meters: X east, Y north, Z up. Z = 0 is the town's ground plane. +A map bitmap maps to the world through `meters_per_px` and `origin_px` (the bitmap pixel that sits at world 0,0). +Row index grows southward, so world Y = -(py - origin_py) * meters_per_px. +""" +import json +import os + +import numpy as np + + +def load_config(path): + with open(path) as f: + cfg = json.load(f) + cfg["_dir"] = os.path.dirname(os.path.abspath(path)) + return cfg + + +def resolve(cfg, p): + """Resolve a path from the config relative to the config file's directory.""" + if p is None: + return None + return p if os.path.isabs(p) else os.path.join(cfg["_dir"], p) + + +class MapFrame: + """Pixel <-> world transforms for one bitmap.""" + + def __init__(self, meters_per_px, origin_px=(0.0, 0.0)): + self.mpp = float(meters_per_px) + self.ox, self.oy = float(origin_px[0]), float(origin_px[1]) + + def px_to_world(self, px, py): + return (np.asarray(px, float) - self.ox) * self.mpp, -(np.asarray(py, float) - self.oy) * self.mpp + + def world_to_px(self, X, Y): + return np.asarray(X, float) / self.mpp + self.ox, -np.asarray(Y, float) / self.mpp + self.oy + + +def ell(k): + import cv2 + k = max(3, int(k)) | 1 + return cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k)) + + +def h01(*a): + """Deterministic hash in [0, 1) from any printable arguments (stable across runs).""" + import hashlib + return int(hashlib.md5(repr(a).encode()).hexdigest()[:8], 16) / 0xFFFFFFFF + + +def bil(A, r, c): + """Bilinear sample of a 2D array at fractional (row, col); clamps to the edges.""" + hh, ww = A.shape + r = np.clip(r, 0, hh - 1.001) + c = np.clip(c, 0, ww - 1.001) + r0 = r.astype(np.int32) + c0 = c.astype(np.int32) + fr = (r - r0).astype(np.float32) + fc = (c - c0).astype(np.float32) + return ((A[r0, c0] * (1 - fc) + A[r0, c0 + 1] * fc) * (1 - fr) + + (A[r0 + 1, c0] * (1 - fc) + A[r0 + 1, c0 + 1] * fc) * fr) + + +def save_json(obj, path): + def conv(v): + if hasattr(v, "tolist"): + return v.tolist() + if isinstance(v, dict): + return {k: conv(x) for k, x in v.items()} + if isinstance(v, (list, tuple)): + return [conv(x) for x in v] + return v + with open(path, "w") as f: + json.dump(conv(obj), f, indent=1) diff --git a/scripts/cost.py b/scripts/cost.py new file mode 100644 index 0000000..54d3851 --- /dev/null +++ b/scripts/cost.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +"""Sum the render ledgers into the Cost line every run report must carry. + +usage: cost.py --config citykit.json out_day/results.jsonl out_sunset/results.jsonl ... [--gpu-minutes 0] +Prices come from config.renderer.cost_usd: {"per_call_1ref": 0.06, "per_call_4ref": 0.09} (interpolated by the +number of references, measured 2026-10 on one hosted model at 2048x1152 high quality; set your own). +Counts every call, accepted and rejected, because volume is what costs money, not the unit price. +""" +import argparse +import json + +from citykit import load_config + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("ledgers", nargs="+") + ap.add_argument("--config", required=True) + ap.add_argument("--gpu-minutes", type=float, default=0.0) + a = ap.parse_args() + cfg = load_config(a.config) + c = cfg["renderer"].get("cost_usd", {"per_call_1ref": 0.06, "per_call_4ref": 0.09}) + c1, c4 = float(c["per_call_1ref"]), float(c["per_call_4ref"]) + calls = ok = fail = 0 + usd = 0.0 + secs = 0.0 + for p in a.ledgers: + for line in open(p): + if not line.strip(): + continue + row = json.loads(line) + calls += 1 + secs += row.get("secs", 0) + if row.get("status") == 200: + ok += 1 + n = row.get("refs", 1) + usd += c1 + (c4 - c1) * min(max(n - 1, 0), 3) / 3.0 + else: + fail += 1 + print("Cost: %d renderer calls (%d accepted, %d failed/retried), about $%.2f; %.1f render-minutes of API time; " + "%.0f local GPU-minutes." % (calls, ok, fail, usd, secs / 60, a.gpu_minutes)) diff --git a/scripts/gate.py b/scripts/gate.py new file mode 100644 index 0000000..af15641 --- /dev/null +++ b/scripts/gate.py @@ -0,0 +1,372 @@ +#!/usr/bin/env python3 +"""Gates for re-surfaced frames against their template plates. One JSON per batch + check sheets. + +Per frame __t.png in OUTDIR: + GEOMETRY grad_corr Pearson correlation of gradient magnitude, frame vs plate (896x504, sigma 2). Structure kept. + edge_rec share of plate Canny edges with a frame edge within 4 px. + ecc_cc, scale, rot_deg, tx_px, ty_px affine ECC frame->plate on gradient magnitude. Reframing shows + up as scale != 1 (zoom) or a shift of more than a few px. A take that zoomed 4 % fails here. + landmark_grad_corr the same gradient correlation inside the landmark mask (the solids of the named + groups), which is where the renderer invents palaces: a castle redrawn as a palace scored 0.16 while + faithful takes scored 0.4-0.7 at 3 km. + SKYLINE sky_s/sky_tx/sky_ty/sky_res similarity fit of the frame's sky/ground boundary to the plate's (landscape + frames, where smooth surfaces make grad_corr run low by nature). + invented_structures runs of columns where the frame skyline rises more than --bump px above the + plate's outside any landmark: the "invented large building" gate for wide town views. + FIGURES every proxy person visible in the plate (from _people.json and the oid buffer) drawn as a bracket on + qc/_figs.jpg: foot line, true-height head line, and the +-25 % band. A dressed figure whose head is + outside the band fails by eye; qc/_figzoom.jpg crops the 16 largest for the check. + CORNERS four corners + top/bottom edge bands of every frame, contrast-boosted, on one sheet per position + (qc/CORNERS--.jpg): the text/watermark/logo sweep. +For relit frames (__t) the reference is the day keeper from --keepers JSON, not the plate. + +Thresholds are reported, not enforced: the numbers depend on the view (a textured facade at 20 m scores 0.5-0.7, +a smooth landscape 0.15-0.3), so calibrate per view on a known-good take and a known-bad one (shift the plate 3 px, +scale it 1.01) before trusting a cut-off. references/gates.md gives the measured bands. + +usage: gate.py OUTDIR --config citykit.json [--keepers keepers.json] [--landmark-groups castle,library] [ids...] +""" +import argparse +import glob +import json +import os +import re + +import cv2 +import numpy as np +from PIL import Image, ImageDraw, ImageFont + +from citykit import load_config, resolve + +try: + FB = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 20) +except OSError: + FB = ImageFont.load_default() + + +def view_of(fid): + return re.sub(r"_[A-Za-z0-9]+_t\d+$", "", fid) + + +def gmag(img): + g = cv2.GaussianBlur(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.float32), (0, 0), 2) + return np.hypot(cv2.Sobel(g, cv2.CV_32F, 1, 0), cv2.Sobel(g, cv2.CV_32F, 0, 1)) + + +def edges(img): + g = cv2.GaussianBlur(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), (0, 0), 1.5) + v = np.median(g) + return cv2.Canny(g, int(max(0, 0.66 * v)), int(min(255, 1.33 * v))) > 0 + + +def drift(plate, frame): + s = cv2.resize(plate, (896, 504), interpolation=cv2.INTER_AREA) + o = cv2.resize(frame, (896, 504), interpolation=cv2.INTER_AREA) + gs, go = gmag(s).ravel(), gmag(o).ravel() + gc = float(np.corrcoef(gs, go)[0, 1]) if gs.std() > 1e-6 and go.std() > 1e-6 else 0.0 + es, eo = edges(s), edges(o) + k = np.ones((9, 9), np.uint8) + rec = float((cv2.dilate(eo.astype(np.uint8), k)[es] > 0).mean()) if es.any() else 0.0 + return dict(grad_corr=round(gc, 3), edge_rec=round(rec, 3)) + + +def gm_norm(img): + g = cv2.GaussianBlur(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.float32), (0, 0), 2.5) + m = np.hypot(cv2.Sobel(g, cv2.CV_32F, 1, 0), cv2.Sobel(g, cv2.CV_32F, 0, 1)) + return cv2.GaussianBlur(m / (m.mean() + 1e-6), (0, 0), 2.0) + + +def ecc(plate, frame): + a = gm_norm(cv2.resize(plate, (1024, 576), interpolation=cv2.INTER_AREA)) + b = gm_norm(cv2.resize(frame, (1024, 576), interpolation=cv2.INTER_AREA)) + w = np.eye(2, 3, dtype=np.float32) + try: + cc, w = cv2.findTransformECC(a.copy(), b.copy(), w, cv2.MOTION_AFFINE, + (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 200, 1e-6), None, 5) + except cv2.error: + return dict(ecc_cc=None) + sx = float(np.hypot(w[0, 0], w[1, 0])) + sy = float(np.hypot(w[0, 1], w[1, 1])) + W2 = w.copy() + W2[:, 2] *= plate.shape[1] / 1024.0 + return dict(_warp=W2.tolist(), ecc_cc=round(float(cc), 3), scale=round((sx + sy) / 2, 4), + rot_deg=round(float(np.degrees(np.arctan2(w[1, 0], w[0, 0]))), 2), + tx_px=round(float(w[0, 2]) * plate.shape[1] / 1024.0, 1), + ty_px=round(float(w[1, 2]) * plate.shape[1] / 1024.0, 1)) + + +def region_corr(plate, frame, mask): + a = gmag(plate) + b = gmag(frame) + m = mask > 0 + if m.sum() < 60 or a[m].std() < 1e-6 or b[m].std() < 1e-6: + return None + return round(float(np.corrcoef(a[m], b[m])[0, 1]), 3) + + +def plate_skyline(cls): + sky = cls == 0 + first = np.argmax(~sky, axis=0).astype(float) + first[sky.all(0)] = np.nan + return first + + +def frame_skyline(bgr): + b, g, r = [bgr[..., i].astype(np.float32) for i in range(3)] + lum = (b + g + r) / 3 + sky = (b > r + 8) & (lum > 120) + sky |= (lum > 205) & (np.abs(b - r) < 30) + sky = cv2.morphologyEx(sky.astype(np.uint8), cv2.MORPH_OPEN, np.ones((5, 5), np.uint8)) > 0 + H, W = sky.shape + first = np.full(W, np.nan) + for x in range(W): + col = sky[:, x] + k = np.argmin(col) if not col.all() else -1 + if k > 3: + first[x] = k + return first + + +def skyline_fit(ps, fs, cx, cy): + xs = np.arange(len(ps)) + best = (1e9, 1.0, 0.0, 0.0) + for s in np.arange(0.92, 1.161, 0.004): + for tx in np.arange(-150, 151, 6): + xp = np.round(s * (xs - cx) + cx + tx).astype(int) + ok = (xp >= 0) & (xp < len(fs)) & ~np.isnan(ps) + if ok.sum() < 300: + continue + fy = fs[xp[ok]] + py = s * (ps[ok] - cy) + cy + m = ~np.isnan(fy) + if m.sum() < 300: + continue + d = fy[m] - py[m] + ty = np.median(d) + res = np.median(np.abs(d - ty)) + if res < best[0]: + best = (res, s, tx, ty) + res, s, tx, ty = best + return dict(sky_s=round(float(s), 4), sky_tx=round(float(tx), 1), sky_ty=round(float(ty), 1), sky_res=round(float(res), 2)) + + +def invented_structures(ps, fs, lm_mask, bump_px=18, min_run=12): + """Columns where the frame's skyline is higher (smaller row) than the plate's by > bump_px, outside landmarks.""" + W = len(ps) + lm_cols = (lm_mask > 0).any(0) if lm_mask is not None else np.zeros(W, bool) + lm_cols = cv2.dilate(lm_cols.astype(np.uint8)[None], np.ones((1, 15), np.uint8))[0] > 0 + d = ps - fs + up = np.nan_to_num(d, nan=0.0) > bump_px + up &= ~lm_cols + runs = [] + x = 0 + while x < W: + if up[x]: + x1 = x + while x1 < W and up[x1]: + x1 += 1 + if x1 - x >= min_run: + runs.append([int(x), int(x1), int(np.nanmax(d[x:x1]))]) + x = x1 + else: + x += 1 + return runs + + +def boost(bgr): + lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB) + lab[..., 0] = cv2.createCLAHE(clipLimit=4.0, tileGridSize=(8, 8)).apply(lab[..., 0]) + out = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR) + return cv2.addWeighted(out, 1.6, cv2.GaussianBlur(out, (0, 0), 3), -0.6, 0) + + +def corners(frames, tag, qc): + if not frames: + return + H, W = frames[0][1].shape[:2] + cw, ch = W // 6, H // 6 + regs = {"TL": (0, 0, cw, ch), "TR": (W - cw, 0, cw, ch), "BL": (0, H - ch, cw, ch), "BR": (W - cw, H - ch, cw, ch), + "TOP": (W // 4, 0, W // 2, H // 16), "BOT": (W // 4, H - H // 16, W // 2, H // 16)} + for nm, (x0, y0, CW, CH) in regs.items(): + S = 1.4 if CW < W // 3 else 0.62 + pw, ph = int(CW * S), int(CH * S) + cols = 4 if CW < W // 3 else 2 + rows = (len(frames) + cols - 1) // cols + sh = Image.new("RGB", (cols * (pw + 2) + 4, rows * (ph + 4)), (0, 0, 0)) + d = ImageDraw.Draw(sh) + for i, (fid, im) in enumerate(frames): + c = cv2.resize(boost(im[y0:y0 + CH, x0:x0 + CW]), (pw, ph), interpolation=cv2.INTER_CUBIC) + xy = ((i % cols) * (pw + 2), (i // cols) * (ph + 4)) + sh.paste(Image.fromarray(cv2.cvtColor(c, cv2.COLOR_BGR2RGB)), xy) + d.text((xy[0] + 5, xy[1] + 3), fid, fill=(255, 255, 0), font=FB, stroke_width=3, stroke_fill=(0, 0, 0)) + sh.save(os.path.join(qc, "CORNERS-%s-%s.jpg" % (tag, nm)), quality=90) + + +def visible_people(people, oid, people_oids, W, H): + out = [] + for p in people: + hp = p["px_height"] + if hp < 4: + continue + x0, x1 = int(max(0, p["x"] - 0.3 * hp)), int(min(W, p["x"] + 0.3 * hp + 1)) + y0, y1 = int(max(0, p["y_head"] - 2)), int(min(H, p["y_foot"] + 2)) + if x1 <= x0 or y1 <= y0: + continue + own = np.isin(oid[y0:y1, x0:x1], list(people_oids)).sum() + p = dict(p, own_px=int(own), vis=round(float(own / max(1.0, 0.22 * hp * hp)), 2)) + if own >= 8 and p["vis"] >= 0.2: + out.append(p) + return out + + +def fig_overlay(fid, frame, people, qc, warp=None): + im = frame.copy() + H, W = im.shape[:2] + if warp is not None: + Wp = np.array(warp) + + def tf(x, y): + return Wp[0, 0] * x + Wp[0, 1] * y + Wp[0, 2], Wp[1, 0] * x + Wp[1, 1] * y + Wp[1, 2] + pp = [] + for p in people: + x, yf = tf(p["x"], p["y_foot"]) + _, yh = tf(p["x"], p["y_head"]) + pp.append(dict(p, x=x, y_foot=yf, y_head=yh, px_height=yf - yh)) + people = pp + for p in people: + x, yf, yh = p["x"], p["y_foot"], p["y_head"] + hp = yf - yh + if hp < 4: + continue + x, yf, yh = int(round(x)), int(round(yf)), int(round(yh)) + lo, hi = int(round(yf - hp * 1.25)), int(round(yf - hp * 0.75)) + c = (60, 255, 60) + off = max(4, int(hp * 0.28)) + cv2.line(im, (x + off, yf), (x + off, yh), c, 1) + cv2.line(im, (x + off - 3, yf), (x + off + 4, yf), c, 1) + cv2.line(im, (x + off - 3, yh), (x + off + 4, yh), c, 2) + cv2.line(im, (x + off - 1, lo), (x + off + 3, lo), (0, 200, 255), 1) + cv2.line(im, (x + off - 1, hi), (x + off + 3, hi), (0, 200, 255), 1) + cv2.imwrite(os.path.join(qc, fid + "_figs.jpg"), im, [cv2.IMWRITE_JPEG_QUALITY, 90]) + tiles = [] + for p in sorted(people, key=lambda p: -p["px_height"])[:16]: + hp = p["px_height"] + x = int(p["x"]) + yf = int(p["y_foot"]) + w2 = int(max(40, hp * 1.2)) + x0, x1 = max(0, x - w2), min(W, x + w2) + y0, y1 = max(0, int(yf - hp * 1.7)), min(H, int(yf + hp * 0.3) + 4) + if x1 - x0 < 16 or y1 - y0 < 16: + continue + a = im[y0:y1, x0:x1] + s = min(6.0, 260 / (y1 - y0)) + a = cv2.resize(a, None, fx=s, fy=s, interpolation=cv2.INTER_CUBIC) + t = "%s %sm %.0fm" % (p["label"][:14], p["h_m"], p["dist_m"]) + cv2.putText(a, t, (4, 16), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 3) + cv2.putText(a, t, (4, 16), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 255), 1) + tiles.append(a) + if tiles: + Hh = max(t.shape[0] for t in tiles) + rows, row, wsum = [], [], 0 + for t in tiles: + t = np.vstack([t, np.zeros((Hh - t.shape[0], t.shape[1], 3), np.uint8)]) + if wsum + t.shape[1] > 2400 and row: + rows.append(np.hstack(row)) + row, wsum = [], 0 + row.append(t) + wsum += t.shape[1] + 4 + row.append(np.zeros((Hh, 4, 3), np.uint8)) + if row: + rows.append(np.hstack(row)) + Wm = max(r.shape[1] for r in rows) + rows = [np.hstack([r, np.zeros((r.shape[0], Wm - r.shape[1], 3), np.uint8)]) for r in rows] + cv2.imwrite(os.path.join(qc, fid + "_figzoom.jpg"), np.vstack(rows), [cv2.IMWRITE_JPEG_QUALITY, 90]) + + +def main(): + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("outdir") + ap.add_argument("ids", nargs="*") + ap.add_argument("--config", required=True) + ap.add_argument("--keepers", default=None, help="JSON {view: keeper.png} for relit frames") + ap.add_argument("--landmark-groups", default=None, help="comma list of solid groups; default from config.gates") + ap.add_argument("--bump", type=int, default=18, help="skyline rise (px) that counts as an invented structure") + ap.add_argument("--qc", default=None, help="output dir; default OUTDIR/qc") + a = ap.parse_args() + cfg = load_config(a.config) + plates = resolve(cfg, cfg.get("plates_dir", "plates")) + qc = a.qc or os.path.join(a.outdir, "qc") + os.makedirs(qc, exist_ok=True) + keepers = json.load(open(a.keepers)) if a.keepers else {} + lm_groups = (a.landmark_groups or cfg.get("gates", {}).get("landmark_groups", "")).split(",") + lm_groups = [g for g in lm_groups if g] + ids = a.ids or sorted(os.path.splitext(os.path.basename(p))[0] for p in glob.glob(os.path.join(a.outdir, "*.png"))) + import scene_solids as SC + res = {} + frames = [] + for fid in ids: + v = view_of(fid) + is_relight = v in keepers + ref_path = keepers[v] if is_relight else os.path.join(plates, v + "_mass.png") + plate = cv2.imread(ref_path) + frame = cv2.imread(os.path.join(a.outdir, fid + ".png")) + if plate is None or frame is None: + print("skip", fid, "(missing plate or frame)") + continue + H, W = plate.shape[:2] + if frame.shape[:2] != (H, W): + frame = cv2.resize(frame, (W, H), interpolation=cv2.INTER_LANCZOS4) + r = drift(plate, frame) + r.update(ecc(plate, frame)) + oid_path = os.path.join(plates, v + "_oid.png") + cls_path = os.path.join(plates, v + "_cls.png") + oid = cv2.imread(oid_path, cv2.IMREAD_UNCHANGED) if os.path.exists(oid_path) else None + lmk = None + if oid is not None and lm_groups and not is_relight: + # rebuild the scene to know which oids belong to the landmark groups + VIEWS = json.load(open(resolve(cfg, cfg["views"]))) + scene_path = resolve(cfg, VIEWS.get(v, {}).get("scene", cfg.get("scene"))) + SC.reset() + if scene_path and os.path.exists(scene_path): + SC.build_from_json(json.load(open(scene_path))) + lm_oids = set() + for g in lm_groups: + lm_oids |= {o + 1 for o in SC.GROUPS.get(g, [])} + if lm_oids: + lmk = np.isin(oid, list(lm_oids)).astype(np.uint8) + lm = cv2.dilate(lmk, np.ones((5, 5), np.uint8)) + r["landmark_grad_corr"] = region_corr(plate, frame, lm) + ov = frame.copy() + e = cv2.morphologyEx(lmk, cv2.MORPH_GRADIENT, np.ones((3, 3), np.uint8)) > 0 + ov[e] = (255, 255, 0) + cv2.imwrite(os.path.join(qc, fid + "_geo.jpg"), ov, [cv2.IMWRITE_JPEG_QUALITY, 90]) + if os.path.exists(cls_path) and not is_relight: + cls = np.asarray(Image.open(cls_path)) + if (cls == 0).any(): + ps = plate_skyline(cls) + fs = frame_skyline(frame) + if np.isfinite(ps).sum() > 300 and np.isfinite(fs).sum() > 300: + r.update(skyline_fit(ps, fs, W / 2, H / 2)) + runs = invented_structures(ps, fs, lmk, bump_px=a.bump) + r["invented_structures"] = runs + r["invented_structures_n"] = len(runs) + ppl_path = os.path.join(plates, v + "_people.json") + if oid is not None and os.path.exists(ppl_path): + people = visible_people(json.load(open(ppl_path)), oid, set(o + 1 for o in SC.GROUPS.get("people", [])) if SC.GROUPS else set(), W, H) + r["proxies_visible"] = len(people) + r["proxies_px_max"] = max([p["px_height"] for p in people] or [0]) + warp = r.get("_warp") if (r.get("ecc_cc") or 0) >= 0.55 and abs(r.get("scale", 1) - 1) < 0.08 else None + fig_overlay(fid, frame, people, qc, warp) + r.pop("_warp", None) + res[fid] = r + frames.append((fid, frame)) + print(fid, {k: r.get(k) for k in ("grad_corr", "edge_rec", "landmark_grad_corr", "ecc_cc", "scale", "rot_deg", + "tx_px", "ty_px", "sky_res", "invented_structures_n", "proxies_visible")}, flush=True) + tag = os.path.basename(os.path.normpath(a.outdir)) + corners(frames, tag, qc) + json.dump(res, open(os.path.join(qc, "gate_%s.json" % tag), "w"), indent=1) + print("wrote", os.path.join(qc, "gate_%s.json" % tag)) + + +if __name__ == "__main__": + main() diff --git a/scripts/massing.py b/scripts/massing.py new file mode 100644 index 0000000..bd6d510 --- /dev/null +++ b/scripts/massing.py @@ -0,0 +1,213 @@ +#!/usr/bin/env python3 +"""Turn segmentation masks into a 2.5D town block model (a heightfield with roofs, trees, water and zones). + +Footprints are straightened, slivers opened away, merged row-house blocks split into house-sized pieces +(separate houses must be separate in pixels, or the re-surfacing model re-slices them into a "caterpillar"), +and every footprint gets a roof: a gable over its fitted rectangle, or a capped hip from the distance transform. + +Heights are NOT on the map. They come from wealth zones in the config (`zones`): each zone gives an eaves range +and a roof pitch. Zones are assigned by polygon (in map px) when given, else by roof density (dense core = zone 2, +sparse edge = zone 1). Landmarks you model by hand are cut out (`cutouts`, polygons in map px). + +usage: massing.py seg.npz --config citykit.json --out town.npz [--window x0 y0 x1 y1] +Writes HR (roof height m), SDF (m, <0 inside a footprint), EAV (eaves m), CLS, ZONE, TINT, WD (water depth), TREE, +DECK (bridges), plus the window and cell size. render_plate.py reads it. +""" +import argparse + +import cv2 +import numpy as np + +from citykit import ell, h01, load_config + +RISE_MAX = 6.5 # m, tallest roof rise above the eaves + + +def roof_heights(roof, zone_of, lab, n, st, zones, mpp): + H = np.zeros(roof.shape, np.float32) + EAV = np.zeros(roof.shape, np.float32) + for i in range(1, n): + x, y, w, h, area = st[i] + sub = lab[y:y + h, x:x + w] == i + z = zones[str(zone_of[i])] + emin, emax, pitch = z["eaves_min"], z["eaves_max"], z["pitch"] + cx, cy = x + w / 2, y + h / 2 + eav = emin + (emax - emin) * h01("eav", i, int(cx), int(cy)) + ys, xs = np.nonzero(sub) + rect = cv2.minAreaRect(np.stack([xs, ys], 1).astype(np.float32)) + (rcx, rcy), (rw, rh), ang = rect + fill = area / (rw * rh + 1e-6) + blk = H[y:y + h, x:x + w] + eb = EAV[y:y + h, x:x + w] + if fill > 0.70 and min(rw, rh) > 5 and max(rw, rh) * mpp < 75: + box = cv2.boxPoints(rect) + if np.linalg.norm(box[1] - box[0]) < np.linalg.norm(box[2] - box[1]): + box = np.roll(box, -1, axis=0) + p0, p1, p2, p3 = box + d = (p1 - p0) / (np.linalg.norm(p1 - p0) + 1e-6) + nrm = np.array([-d[1], d[0]]) + a = (p0 + p3) / 2 + span = abs(np.dot(p3 - p0, nrm)) / 2 + m = np.zeros((h, w), np.uint8) + cv2.fillPoly(m, [np.round(box).astype(np.int32)], 1) + m &= cv2.dilate(sub.astype(np.uint8), ell(3)) + yy, xx = np.nonzero(m) + dist = np.abs((xx - a[0]) * nrm[0] + (yy - a[1]) * nrm[1]) + rise = np.clip(span - dist, 0, None) * mpp * pitch + hv = eav + np.minimum(rise, RISE_MAX) + blk[yy, xx] = np.maximum(blk[yy, xx], hv) + eb[yy, xx] = np.maximum(eb[yy, xx], eav) + else: + comp = sub.astype(np.uint8) + dt = cv2.distanceTransform(np.pad(comp, 1), cv2.DIST_L2, 5)[1:-1, 1:-1] * mpp + hv = np.where(comp > 0, eav + np.minimum(dt * pitch, RISE_MAX), 0) + np.maximum(blk, hv, out=blk) + eb[comp > 0] = np.maximum(eb[comp > 0], eav) + return H, EAV + + +def split_blocks(roof, mpp, min_area_m2=180.0, house_min=8.0, house_max=15.0, depth_split=17.0): + """Merged row-house blocks -> house-sized pieces with a 1-cell gap between them.""" + n, lab, st, _ = cv2.connectedComponentsWithStats(roof, 8) + cut = np.zeros_like(roof) + for i in range(1, n): + x, y, w, h, a = st[i] + if a * mpp ** 2 < min_area_m2: + continue + sub = lab[y:y + h, x:x + w] == i + ys, xs = np.nonzero(sub) + cx, cy = xs.mean(), ys.mean() + cov = np.cov(np.stack([xs - cx, ys - cy])) + ev, evec = np.linalg.eigh(cov) + ux, uy = evec[0, 1], evec[1, 1] + yy, xx = np.mgrid[0:h, 0:w] + u = (xx - cx) * ux + (yy - cy) * uy + v = -(xx - cx) * uy + (yy - cy) * ux + pv = -(xs - cx) * uy + (ys - cy) * ux + edges = [u.min()] + k = 0 + while edges[-1] < u.max(): + edges.append(edges[-1] + (house_min + (house_max - house_min) * h01("w", i, k)) / mpp) + k += 1 + e = np.array(edges) + boundary = np.zeros((h, w), bool) + if len(e) > 2: + dist_edge = np.min(np.abs(u[..., None] - e[None, None, 1:-1]), axis=-1) + boundary |= dist_edge < 0.6 + if (pv.max() - pv.min()) * mpp > depth_split: + boundary |= np.abs(v) < 0.6 + cut[y:y + h, x:x + w] |= (boundary & sub).astype(np.uint8) + out = roof.copy() + out[cut > 0] = 0 + return out + + +def build(seg, cfg, window=None): + mpp = float(seg["mpp"]) + roof, tree, water = seg["roof"].copy(), seg["tree"].copy(), seg["water"].copy() + if window is not None: + x0, y0, x1, y1 = window + else: + x0, y0, x1, y1 = 0, 0, roof.shape[1], roof.shape[0] + roof, tree, water = roof[y0:y1, x0:x1], tree[y0:y1, x0:x1], water[y0:y1, x0:x1] + gh, gw = roof.shape + # hand-modeled landmarks are cut out (polygons in map px) + excl = np.zeros_like(roof) + for poly in cfg.get("cutouts", []): + P = np.array(poly, float) - [x0, y0] + cv2.fillPoly(excl, [P.astype(np.int32)], 1) + if excl.any(): + excl = cv2.dilate(excl, ell(6 / mpp)) + roof[excl > 0] = 0 + tree[excl > 0] = 0 + # bridges/decks: roof components lying mostly over (dilated) water + wd = cv2.dilate(water, ell(15)) + n, lab, st, _ = cv2.connectedComponentsWithStats(roof, 8) + deck = np.zeros_like(roof) + for i in range(1, n): + x, y, w, h, a = st[i] + comp = lab[y:y + h, x:x + w] == i + if wd[y:y + h, x:x + w][comp].mean() > 0.5: + deck[y:y + h, x:x + w][comp] = 1 + roof[deck > 0] = 0 + # straighten + de-sliver + cnts, hier = cv2.findContours(roof, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE) + clean = np.zeros_like(roof) + if hier is not None: + for i, c in enumerate(cnts): + if hier[0][i][3] < 0: + cv2.fillPoly(clean, [cv2.approxPolyDP(c, 1.0, True)], 1) + for i, c in enumerate(cnts): + if hier[0][i][3] >= 0 and cv2.contourArea(c) > 60: + cv2.fillPoly(clean, [cv2.approxPolyDP(c, 1.0, True)], 0) + roof = cv2.morphologyEx(clean, cv2.MORPH_OPEN, ell(2.0 / mpp)) + n, lab, st, cen = cv2.connectedComponentsWithStats(roof, 8) + keep = np.zeros(n, bool) + keep[1:] = st[1:, 4] * mpp ** 2 >= cfg.get("min_house_m2", 40) + roof = keep[lab].astype(np.uint8) + roof = split_blocks(roof, mpp) + n, lab, st, cen = cv2.connectedComponentsWithStats(roof, 4) + # zones + zones = cfg["zones"] + zone_of = np.ones(n, np.uint8) + polys = [(int(z.get("id", k)), np.array(z["polygon_px"], float) - [x0, y0]) + for k, z in zones.items() if "polygon_px" in z] + dens = cv2.blur(roof.astype(np.float32), (int(80 / mpp) | 1,) * 2) + default_core = int(cfg.get("default_core_zone", 2)) + default_edge = int(cfg.get("default_edge_zone", 1)) + for i in range(1, n): + cx, cy = cen[i] + zid = None + for pid, P in polys: + if cv2.pointPolygonTest(P.astype(np.float32), (float(cx), float(cy)), False) >= 0: + zid = pid + break + if zid is None: + zid = default_core if dens[int(cy), int(cx)] >= cfg.get("core_density", 0.16) else default_edge + zone_of[i] = zid + HR, EAV = roof_heights(roof, zone_of, lab, n, st, zones, mpp) + ZONE = zone_of[lab] * (roof > 0) + TINT = (np.array([0] + [int(255 * h01("t", i)) for i in range(1, n)], np.uint8))[lab] + # trees -> lumpy crowns + tt = cv2.morphologyEx(tree, cv2.MORPH_OPEN, ell(3)) & (roof == 0) + dtt = cv2.distanceTransform(tt, cv2.DIST_L2, 3) * mpp + rng = np.random.default_rng(3) + lump = cv2.GaussianBlur(rng.normal(0, 1, tt.shape).astype(np.float32), (0, 0), 2.0) + TREE = np.where(tt > 0, 5.5 + 1.6 * np.minimum(dtt, 4.5) + 0.9 * lump, 0).astype(np.float32) + TREE = cv2.GaussianBlur(TREE, (0, 0), 1.0) * (tt > 0) + din = cv2.distanceTransform(roof, cv2.DIST_L2, 5) + dout = cv2.distanceTransform((1 - roof).astype(np.uint8), cv2.DIST_L2, 5) + SDF = np.clip(((dout - din) * mpp).astype(np.float32), -20, 20) + HRx = cv2.dilate(np.where(roof > 0, HR, 0).astype(np.float32), np.ones((3, 3), np.uint8)) + HR = np.where(roof > 0, HR, HRx).astype(np.float32) + EAVx = cv2.dilate(EAV, np.ones((3, 3), np.uint8)) + EAV = np.where(roof > 0, EAV, EAVx) + wsoft = cv2.GaussianBlur(water.astype(np.float32), (0, 0), 1.2) + WD = float(cfg.get("water_depth_m", 3.0)) * np.clip(wsoft * 1.6 - 0.3, 0, 1) + # classes: 0 street 1 roof 3 tree 4 water 6 deck 8 field + CLS = np.zeros((gh, gw), np.uint8) + open_ = ((roof == 0) & (water == 0) & (tt == 0)).astype(np.uint8) + dens2 = cv2.blur((roof > 0).astype(np.float32), (int(160 / mpp) | 1,) * 2) + CLS[(open_ > 0) & (dens2 < 0.05)] = 8 + CLS[roof > 0] = 1 + CLS[tt > 0] = 3 + CLS[water > 0] = 4 + CLS[deck > 0] = 6 + print("town grid", gh, gw, "houses", n - 1, "roof frac %.3f" % (roof > 0).mean(), + "zones", dict(zip(*np.unique(zone_of[1:], return_counts=True)))) + return dict(HR=HR.astype(np.float32), SDF=SDF.astype(np.float16), EAV=EAV.astype(np.float16), CLS=CLS, TINT=TINT, + ZONE=ZONE.astype(np.uint8), WD=WD.astype(np.float16), TREE=TREE.astype(np.float16), + DECK=deck.astype(np.uint8), win=np.array([x0, y0, x1, y1]), cell=np.float32(mpp)) + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("seg") + ap.add_argument("--config", required=True) + ap.add_argument("--out", default="town.npz") + ap.add_argument("--window", type=int, nargs=4, default=None, help="x0 y0 x1 y1 in map px") + a = ap.parse_args() + cfg = load_config(a.config) + out = build(np.load(a.seg), cfg["massing"], a.window) + np.savez(a.out, **out) + print("wrote", a.out) diff --git a/scripts/matrix_jobs.py b/scripts/matrix_jobs.py new file mode 100644 index 0000000..59c77e1 --- /dev/null +++ b/scripts/matrix_jobs.py @@ -0,0 +1,100 @@ +#!/usr/bin/env python3 +"""Build the matrix jobs for an accepted set of keepers: time-of-day x weather, and population x time-of-day. + +Weather/time matrix (exteriors): every cell is an EDIT of the accepted Day Dry keeper of the same camera (or, for +Sunset/Night cells, a relight of the Day cell of the same weather), never a fresh re-surface, so geometry carries. +Cells and sizes come from the tier (references/effort-tiers.md): + tier 1: Day|Sunset|Night x Dry|Rain|Snow (light) = 9 per camera, plus any storm/deep-snow cells you enable + tier 2: Day + Night Dry + one Snow (light) + tier 3: Day Dry only (no matrix) +Population x time matrix (venues with people): the plate carries proxies at the chosen density; each cell states the +hour and the density relationally. Sizes by tier: T1 4x3 (Morning/Afternoon/Evening/Late Night x Quiet/Moderate/ +Packed; 4x4 with Empty for storyline hubs), T2 2x3 (Day/Sunset x Quiet/Moderate/Packed), T3 1x2 (peak hour x +Quiet/Packed), T4 none. + +usage: matrix_jobs.py weather --config citykit.json --prompts prompts.json --tier 1 V=DayDryKeeper.png ... --out jobs_matrix.json + matrix_jobs.py population --config citykit.json --prompts prompts.json --tier 1 V=EmptyMaster.png ... --out jobs_pop.json +prompts.json needs "weather" {Rain, Snow (light), Snow (medium), Snow (heavy), Blizzard, ...}, "relights" {Sunset, +Night, ...}, "hours" {Morning, ...} and "densities" {Quiet, ...} blocks. Weather names follow the naming convention +in references/naming.md so files sort and display consistently. +""" +import argparse +import json +import os + +from citykit import load_config + +WEATHER_BY_TIER = {1: ["Dry", "Rain", "Snow (light)"], 2: ["Dry", "Snow (light)"], 3: ["Dry"], 4: []} +TIMES_BY_TIER = {1: ["Day", "Sunset", "Night"], 2: ["Day", "Night"], 3: ["Day"], 4: []} +POP_BY_TIER = {1: (["Morning", "Afternoon", "Evening", "Late Night"], ["Quiet", "Moderate", "Packed"]), + 2: (["Day", "Sunset"], ["Quiet", "Moderate", "Packed"]), + 3: (["Peak"], ["Quiet", "Packed"]), 4: ([], [])} + + +def weather_jobs(cfg, P, keepers, tier, takes, extra_weather): + size = cfg["renderer"].get("size", "2048x1152") + jobs = [] + weathers = WEATHER_BY_TIER[tier] + extra_weather + for v, keeper in keepers.items(): + for wx in weathers: + # day cell of this weather: an edit of the Day Dry keeper (Dry = the keeper itself, no job) + if wx != "Dry": + prompt = P["weather"][wx] + " " + P.get("weather_lock", "") + " " + P["nomodern"] + for t in range(1, takes + 1): + jobs.append(dict(id="%s_Day-%s_t%d" % (v, wx.replace(" ", ""), t), size=size, refs=[os.path.abspath(keeper)], + prompt=prompt + " [%s, Day %s, take %d]" % (v, wx, t), + derived_from=keeper, cell="Day %s" % wx, view=v)) + # Sunset/Night of this weather: relights of the Day cell of the same weather (chained; run after picking) + for tm in TIMES_BY_TIER[tier]: + if tm == "Day": + continue + src = keeper if wx == "Dry" else "" % (v, wx) + prompt = P["relights"][tm if tm in P["relights"] else tm.lower()] + " " + P["nomodern"] + for t in range(1, takes + 1): + jobs.append(dict(id="%s_%s-%s_t%d" % (v, tm, wx.replace(" ", ""), t), size=size, refs=[src], + prompt=prompt + " [%s, %s %s, take %d]" % (v, tm, wx, t), + derived_from=src, cell="%s %s" % (tm, wx), view=v, chained=(wx != "Dry"))) + return jobs + + +def population_jobs(cfg, P, masters, tier, takes, with_empty): + size = cfg["renderer"].get("size", "2048x1152") + hours, dens = POP_BY_TIER[tier] + if with_empty and tier == 1: + dens = ["Empty"] + dens + jobs = [] + for v, master in masters.items(): + for hr in hours: + for dn in dens: + prompt = " ".join([P.get("population_intro", ""), P["hours"][hr], P["densities"][dn], + P.get("population_locks", ""), P["nomodern"]]) + for t in range(1, takes + 1): + jobs.append(dict(id="%s_%s-%s_t%d" % (v, hr.replace(" ", ""), dn, t), size=size, + refs=[os.path.abspath(master)], prompt=prompt + " [%s, %s %s, take %d]" % (v, hr, dn, t), + cell="%s %s" % (hr, dn), view=v)) + return jobs + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("mode", choices=["weather", "population"]) + ap.add_argument("rest", nargs="*", help="V=keeper.png pairs") + ap.add_argument("--config", required=True) + ap.add_argument("--prompts", required=True) + ap.add_argument("--tier", type=int, default=1) + ap.add_argument("--takes", type=int, default=2) + ap.add_argument("--extra-weather", default="", help="comma list, e.g. 'Blizzard,Snow (heavy)'") + ap.add_argument("--with-empty", action="store_true", help="tier 1 population: add the Empty column (4x4)") + ap.add_argument("--out", required=True) + a = ap.parse_intermixed_args() + cfg = load_config(a.config) + P = json.load(open(a.prompts)) + keep = dict(x.split("=", 1) for x in a.rest if "=" in x) + if a.mode == "weather": + jobs = weather_jobs(cfg, P, keep, a.tier, a.takes, [w for w in a.extra_weather.split(",") if w]) + else: + jobs = population_jobs(cfg, P, keep, a.tier, a.takes, a.with_empty) + R = cfg["renderer"] + chained = [j for j in jobs if j.get("chained")] + json.dump(dict(model=R["model"], quality=R.get("quality", "high"), refs_common=[], jobs=jobs), open(a.out, "w"), indent=1) + print(len(jobs), "jobs ->", a.out, "(%d chained: fill in their refs after picking the Day cell)" % len(chained)) diff --git a/scripts/qc_sheet.py b/scripts/qc_sheet.py new file mode 100644 index 0000000..a18d380 --- /dev/null +++ b/scripts/qc_sheet.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python3 +"""Contact sheets for the eye check: plate | pick | pick with landmark outline, with the gate numbers as a caption. + +usage: qc_sheet.py --config citykit.json --picks picks.json --gates out_day/qc/gate_out_day.json --out qc_plates.jpg [V ...] +picks.json: {"V": {"day": "V_day_t2", "sunset": "V_sunset_t1"}, ...} +Thumbnail every batch of same-tier exteriors at this size before calling it done: "geometry-true" is not the +same as "recognizable" (seven houses on one wealth rung come out as seven identical barns without a character pass). +""" +import argparse +import json +import os + +from PIL import Image, ImageDraw, ImageFont + +from citykit import load_config, resolve + +try: + FB = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 26) + FS = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20) +except OSError: + FB = FS = ImageFont.load_default() + + +def lab(d, xy, t, f=FS, fill=(255, 255, 0)): + d.text(xy, t, fill=fill, font=f, stroke_width=3, stroke_fill=(0, 0, 0)) + + +def gate_line(QA, fid): + r = QA.get(fid, {}) + return "grad_corr %s · ECC scale %s · shift %s/%s px · landmark corr %s · invented %s" % ( + r.get("grad_corr"), r.get("scale"), r.get("tx_px"), r.get("ty_px"), r.get("landmark_grad_corr"), + r.get("invented_structures_n", "-")) + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("views", nargs="*") + ap.add_argument("--config", required=True) + ap.add_argument("--picks", required=True) + ap.add_argument("--gates", required=True) + ap.add_argument("--frames", required=True, help="dir holding the take PNGs") + ap.add_argument("--out", required=True) + ap.add_argument("--title", default="plates vs picks") + a = ap.parse_args() + cfg = load_config(a.config) + plates = resolve(cfg, cfg.get("plates_dir", "plates")) + PICKS = json.load(open(a.picks)) + QA = json.load(open(a.gates)) + qc = os.path.join(a.frames, "qc") + views = a.views or list(PICKS) + w, h = 640, 360 + rows = [] + for v in views: + p = PICKS[v] + fid = p["day"] if isinstance(p, dict) else p + ims = [(Image.open(os.path.join(plates, v + "_mass.png")), "block-model plate (IMAGE 1)"), + (Image.open(os.path.join(a.frames, fid + ".png")), "pick " + fid)] + geo = os.path.join(qc, fid + "_geo.jpg") + if os.path.exists(geo): + ims.append((Image.open(geo), "pick + landmark outline from the model (cyan)")) + R = Image.new("RGB", (3 * w + 16, h + 64), (20, 20, 20)) + d = ImageDraw.Draw(R) + for i, (im, t) in enumerate(ims): + R.paste(im.convert("RGB").resize((w, h)), (i * (w + 8), 34)) + lab(d, (i * (w + 8) + 6, 38), t) + lab(d, (6, 4), "%s: %s" % (v, gate_line(QA, fid)), FS, (255, 255, 255)) + rows.append(R) + H = sum(r.height for r in rows) + S = Image.new("RGB", (rows[0].width, H + 50), (20, 20, 20)) + d = ImageDraw.Draw(S) + lab(d, (10, 8), a.title, FB, (255, 255, 255)) + y = 50 + for r in rows: + S.paste(r, (0, y)) + y += r.height + S.save(a.out, quality=88) + print("wrote", a.out) diff --git a/scripts/render_batch.py b/scripts/render_batch.py new file mode 100644 index 0000000..506cbeb --- /dev/null +++ b/scripts/render_batch.py @@ -0,0 +1,178 @@ +#!/usr/bin/env python3 +"""Self-calibrating parallel batch submitter for an image-edit API ("re-surface IMAGE 1 with these references"). + +usage: render_batch.py jobs.json --out OUTDIR [--start 4] [--max 8] [--min 2] [--adapter openai_images] +jobs.json: {"model": "...", "quality": "high", "refs_common": [...], "jobs": [{"id", "prompt", "size", "refs": [...], + "prompt_alt": "..."(optional, used once on a moderation refusal)}]} + +Concurrency starts at --start in flight; a 429/5xx backs off (limit -2, sleep Retry-After or exponential, requeue); +a full wave of successes at a level ratchets +2 (cap --max). Ledger: OUTDIR/results.jsonl (one line per call, +status, seconds, attempt) and events.log; summary in calibration.md. cost.py reads the ledger. + +Credentials come from the environment only: IMAGE_API_KEY (required), IMAGE_API_BASE (default +https://api.openai.com/v1). Never put them in a job file or a config that goes into version control. + +Adapters (--adapter): "openai_images" posts multipart to /images/edits (or /images/generations when a job has no +references). To use another renderer, add a function `submit(job, refs, spec, env) -> (status_code, png_bytes|None, +body_text)` in adapters/.py; see adapters/README.md. +""" +import argparse +import base64 +import importlib +import json +import os +import re +import sys +import threading +import time + +import requests + + +def submit_openai_images(job, refs, spec, env): + key, base = env["key"], env["base"] + if not refs: + data = {"model": spec["model"], "prompt": job["prompt"], "size": job["size"], + "quality": spec.get("quality", "high"), "output_format": "png", "n": 1} + r = requests.post(base + "/images/generations", headers={"Authorization": "Bearer " + key, + "Content-Type": "application/json"}, json=data, timeout=(15, 480)) + else: + files = [("image[]", (os.path.basename(p), open(p, "rb"), + "image/jpeg" if p.lower().endswith((".jpg", ".jpeg")) else "image/png")) for p in refs] + data = {"model": spec["model"], "prompt": job["prompt"], "size": job["size"], + "quality": spec.get("quality", "high"), "output_format": "png", "n": "1"} + r = requests.post(base + "/images/edits", headers={"Authorization": "Bearer " + key}, data=data, files=files, + timeout=(15, 480)) + for _, f in files: + f[1].close() + png = None + if r.status_code == 200: + png = base64.b64decode(r.json()["data"][0]["b64_json"]) + return r.status_code, png, (r.text[:300].replace("\n", " ") if r.status_code != 200 else ""), r.headers + + +def load_adapter(name): + if name == "openai_images": + return submit_openai_images + sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "adapters")) + return importlib.import_module(name).submit + + +def main(): + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("jobs") + ap.add_argument("--out", required=True) + ap.add_argument("--start", type=int, default=4) + ap.add_argument("--max", type=int, default=8) + ap.add_argument("--min", type=int, default=2) + ap.add_argument("--adapter", default="openai_images") + ap.add_argument("--done-file", default=None, help="write a timestamp here when the batch finishes") + ap.add_argument("--skip-existing", action="store_true", help="do not re-submit jobs whose PNG already exists") + a = ap.parse_args() + spec = json.load(open(a.jobs)) + OUT = a.out + os.makedirs(OUT, exist_ok=True) + key = os.environ.get("IMAGE_API_KEY") + if not key: + sys.exit("IMAGE_API_KEY is not set in the environment") + env = dict(key=key, base=os.environ.get("IMAGE_API_BASE", "https://api.openai.com/v1").rstrip("/")) + submit = load_adapter(a.adapter) + lock = threading.Condition() + state = dict(limit=a.start, in_flight=0, succ_at_level=0, max_inflight_clean=0, r429=0, errors=0, done=0, + cooldown_until=0.0) + ev = open(os.path.join(OUT, "events.log"), "a") + led = open(os.path.join(OUT, "results.jsonl"), "a") + + def log(msg): + line = time.strftime("%H:%M:%S ") + msg + print(line, flush=True) + ev.write(line + "\n") + ev.flush() + + def ledger(**row): + led.write(json.dumps(row) + "\n") + led.flush() + + def worker(job, attempt): + with lock: + while state["in_flight"] >= state["limit"] or time.time() < state["cooldown_until"]: + lock.wait(1.0) + state["in_flight"] += 1 + inflight, level = state["in_flight"], state["limit"] + log("DISPATCH %s attempt=%d in_flight=%d limit=%d" % (job["id"], attempt, inflight, level)) + refs = [os.path.abspath(p) for p in spec.get("refs_common", []) + job.get("refs", [])] + t0 = time.time() + try: + code, png, body, headers = submit(job, refs, spec, env) + except Exception as e: # network errors count as retryable + code, png, body, headers = -1, None, str(e)[:200], {} + log("EXC %s %s" % (job["id"], body)) + dt = time.time() - t0 + with lock: + state["in_flight"] -= 1 + nrefs = len(refs) + if code == 200 and png: + open(os.path.join(OUT, job["id"] + ".png"), "wb").write(png) + state["done"] += 1 + state["succ_at_level"] += 1 + state["max_inflight_clean"] = max(state["max_inflight_clean"], inflight) + ledger(id=job["id"], status=200, secs=round(dt, 1), in_flight=inflight, limit=level, attempt=attempt, + refs=nrefs, size=job.get("size")) + log("OK %s %.0fs" % (job["id"], dt)) + if state["succ_at_level"] >= state["limit"] and state["limit"] < a.max: + state["limit"] = min(a.max, state["limit"] + 2) + state["succ_at_level"] = 0 + log("RATCHET limit -> %d" % state["limit"]) + lock.notify_all() + return True + ledger(id=job["id"], status=code, secs=round(dt, 1), in_flight=inflight, limit=level, attempt=attempt, + refs=nrefs, body=body) + if "insufficient_quota" in body: + log("QUOTA %s -- not retrying" % job["id"]) + state["errors"] += 1 + lock.notify_all() + return False + if code == 429 or code >= 500 or code == -1: + state["r429"] += 1 if code == 429 else 0 + ra = headers.get("Retry-After") if headers else None + wait = float(ra) if ra and ra.replace(".", "").isdigit() else min(60, 5 * (2 ** (attempt - 1))) + state["limit"] = max(a.min, state["limit"] - 2) + state["succ_at_level"] = 0 + state["cooldown_until"] = time.time() + wait + log("BACKOFF %s http=%s wait=%.0fs limit -> %d %s" % (job["id"], code, wait, state["limit"], body[:120])) + lock.notify_all() + return worker(job, attempt + 1) if attempt < 6 else False + state["errors"] += 1 + log("FAIL %s http=%s %s" % (job["id"], code, body[:200])) + # one rephrase on a moderation refusal, never more; after that the lane reports it and stops + if attempt == 1 and job.get("prompt_alt") and re.search(r"safety|moderat|content_policy|rejected", body, re.I): + log("REPHRASE %s" % job["id"]) + lock.notify_all() + return worker(dict(job, prompt=job["prompt_alt"]), 2) + lock.notify_all() + return False + + jobs = spec["jobs"] + if a.skip_existing: + jobs = [j for j in jobs if not os.path.exists(os.path.join(OUT, j["id"] + ".png"))] + t_start = time.time() + threads = [threading.Thread(target=worker, args=(j, 1), daemon=True) for j in jobs] + for t in threads: + t.start() + for t in threads: + t.join() + el = max(time.time() - t_start, 1e-6) + summary = ("# batch calibration — %s\n\n- jobs: %d, succeeded: %d, hard failures: %d, 429s: %d\n" + "- start concurrency %d, ceiling reached: %d (cap %d); max in-flight without pushback: %d\n" + "- elapsed %.1f min, %.1f images/min; model %s, quality %s\n" + % (time.strftime("%Y-%m-%d %H:%M UTC", time.gmtime()), len(jobs), state["done"], state["errors"], + state["r429"], a.start, state["limit"], a.max, state["max_inflight_clean"], el / 60, + state["done"] / (el / 60), spec["model"], spec.get("quality", "high"))) + open(os.path.join(OUT, "calibration.md"), "w").write(summary) + log("DONE\n" + summary) + if a.done_file: + open(a.done_file, "w").write(time.strftime("%FT%TZ", time.gmtime())) + + +if __name__ == "__main__": + main() diff --git a/scripts/render_plate.py b/scripts/render_plate.py new file mode 100644 index 0000000..b791f92 --- /dev/null +++ b/scripts/render_plate.py @@ -0,0 +1,620 @@ +#!/usr/bin/env python3 +"""Template-plate renderer: a CPU ray marcher over the town heightfield + optional terrain + analytic solids. + +For each camera in views.json it writes, under --out: + _mass.png the plate (IMAGE 1 for the re-surfacing model) + _depth.npy ray distance per pixel (m) + _oid.png 16-bit solid id + 1 (0 = heightfield/sky); the figure-scale gate uses it + _cls.png class id per pixel (sky 0, street 1, roof 2, wall 3, tree 4, water 5, deck 6, field 7, + forest 8, rock 9, snow 10, solid 12) + _cam.json camera (so the gates and sheets can project world points) + _people.json every proxy person: screen foot/head rows, distance, px per meter + _landmarks.json projected landmark points from the scene file + +views.json: {"": {"pos":[x,y,z], "yaw":deg (0 = north, clockwise), "pitch":deg, "hfov":deg, "shift":0..0.2, + "sun":"day"|"sunset"|"morning", "scene":"scene.json" (optional per-view scene)}} +A camera on the ground: z = ground + 1.65. Vertical lens shift keeps verticals vertical on pitched-up views. + +usage: render_plate.py --config citykit.json --views views.json --out plates V1 [V2 ...] [--w 2048] +Runtime: a 2048x1152 plate takes 1-15 minutes on a 32-core CPU depending on how much terrain the rays cross. +Render views in parallel processes. +""" +import argparse +import json +import os +import time + +import cv2 +import numpy as np +from PIL import Image + +import scene_solids as SC +from citykit import MapFrame, bil, load_config, resolve, save_json + +SUNC = np.array([1.0, 0.93, 0.82]) +AMB = np.array([0.78, 0.85, 0.97]) +PAL = { + "street": (150, 142, 124), "field": (112, 128, 82), "meadow": (124, 132, 90), "forest": (62, 80, 58), + "rock": (122, 120, 114), "snow": (232, 236, 240), "water": (58, 82, 92), "deck": (112, 92, 70), "tree": (72, 96, 58), + "wall1": (124, 106, 86), "wall2": (150, 136, 116), "wall3": (178, 174, 166), "wall4": (184, 180, 172), + "roof1": (98, 108, 74), "roof2": (92, 88, 86), "roof3": (80, 84, 92), "roof4": (78, 82, 90), +} +CLS_ID = dict(sky=0, street=1, roof=2, wall=3, tree=4, water=5, deck=6, field=7, forest=8, rock=9, snow=10, solid=12) +SUNS = {"day": dict(az=248.0, el=24.0), "sunset": dict(az=297.0, el=1.5), "morning": dict(az=128.0, el=29.0)} + + +def sun_vec(kind, suns): + s = suns.get(kind, SUNS[kind]) + az, el = np.radians(s["az"]), np.radians(s["el"]) + return np.array([np.sin(az) * np.cos(el), np.cos(az) * np.cos(el), np.sin(el)]) + + +class World: + """Heightfield world: optional terrain grid (m above ground plane) + the town block model on top of it.""" + + def __init__(self, cfg): + self.cfg = cfg + t = cfg.get("terrain") + if t and t.get("path"): + T = np.load(resolve(cfg, t["path"])) + self.tH = T["H"].astype(np.float32) + self.tc, self.tx0, self.ty1 = float(T["cell"]), float(T["x0"]), float(T["y1"]) + self.snowline = float(t.get("snowline_m", 1e9)) + else: + self.tH = None + self.snowline = 1e9 + m = cfg["map"] + Z = np.load(resolve(cfg, cfg["massing"]["town_npz"])) + self.HR = Z["HR"].astype(np.float32) + self.SDF = Z["SDF"].astype(np.float32) + self.EAV = Z["EAV"].astype(np.float32) + self.CLS, self.TINT, self.ZONE, self.DECK = Z["CLS"], Z["TINT"], Z["ZONE"], Z["DECK"] + self.WD = Z["WD"].astype(np.float32) + self.TREE = Z["TREE"].astype(np.float32) + self.win = Z["win"].astype(float) + self.zc = float(Z["cell"]) + self.zh, self.zw = self.HR.shape + self.frame = MapFrame(m["meters_per_px"], m.get("origin_px", [0, 0])) + self.ext = cfg.get("world_extent_m", [-20000, 20000, -20000, 20000]) + # 20 m bound tiles over the whole extent: max height per tile, so rays skip open air + self.BT = 20.0 + x0, x1, y0, y1 = self.ext + nx, ny = int(np.ceil((x1 - x0) / self.BT)), int(np.ceil((y1 - y0) / self.BT)) + mm = np.zeros((ny, nx), np.float32) + if self.tH is not None: + k = max(1, int(round(self.BT / self.tc))) + hh, ww = self.tH.shape + Hp = np.pad(self.tH, ((0, (-hh) % k), (0, (-ww) % k)), constant_values=-50) + tm = Hp.reshape(Hp.shape[0] // k, k, Hp.shape[1] // k, k).max(axis=(1, 3)) + r0 = int(round((y1 - self.ty1) / self.BT)) + c0 = int(round((self.tx0 - x0) / self.BT)) + rs, cs = slice(max(r0, 0), min(r0 + tm.shape[0], ny)), slice(max(c0, 0), min(c0 + tm.shape[1], nx)) + mm[rs, cs] = np.maximum(mm[rs, cs], tm[rs.start - r0:rs.stop - r0, cs.start - c0:cs.stop - c0]) + town_h = np.maximum(np.where(self.SDF < 0.6, self.HR, 0), self.TREE) + town_h = np.maximum(town_h, self.DECK * 1.5) + th = cv2.dilate(town_h, np.ones((3, 3), np.uint8)) + bc = max(1, int(np.ceil(self.BT / self.zc))) + Hz = np.pad(th, ((0, (-self.zh) % bc), (0, (-self.zw) % bc))) + tb = Hz.reshape(Hz.shape[0] // bc, bc, Hz.shape[1] // bc, bc).max(axis=(1, 3)) + ty, tx = np.mgrid[0:ny, 0:nx] + Xc = x0 + (tx + 0.5) * self.BT + Yc = y1 - (ty + 0.5) * self.BT + r, c = self.town_rc(Xc, Yc) + bi = np.clip((r / bc).astype(int), 0, tb.shape[0] - 1) + bj = np.clip((c / bc).astype(int), 0, tb.shape[1] - 1) + inside = (r > -bc) & (c > -bc) & (r < self.zh + bc) & (c < self.zw + bc) + add = np.where(inside, tb[bi, bj], 0) + base_t = self.terrain(Xc.ravel(), Yc.ravel()).reshape(ny, nx) if self.tH is not None else 0 + mm = np.maximum(mm, base_t + cv2.dilate(add.astype(np.float32), np.ones((3, 3), np.uint8))) + self.mm_base = cv2.dilate(mm.astype(np.float32), np.ones((3, 3), np.uint8)) + 0.6 + self.mm = self.mm_base.copy() + self.hmax = float(self.mm.max()) + 1 + + def add_solids_to_bounds(self): + self.mm = self.mm_base.copy() + x0, x1, y0, y1 = self.ext + for S in SC.SOLIDS: + lo, hi = S["lo"], S["hi"] + c0 = int((lo[0] - x0) / self.BT) + c1 = int((hi[0] - x0) / self.BT) + r0 = int((y1 - hi[1]) / self.BT) + r1 = int((y1 - lo[1]) / self.BT) + r0, c0 = max(r0 - 1, 0), max(c0 - 1, 0) + self.mm[r0:r1 + 2, c0:c1 + 2] = np.maximum(self.mm[r0:r1 + 2, c0:c1 + 2], hi[2] + 0.5) + self.hmax = float(self.mm.max()) + 1 + + def town_rc(self, X, Y): + px, py = self.frame.world_to_px(X, Y) + return (py - self.win[1]) - 0.5, (px - self.win[0]) - 0.5 + + def in_town(self, r, c): + return (r >= 0) & (c >= 0) & (r < self.zh - 1) & (c < self.zw - 1) + + def terrain(self, X, Y): + if self.tH is None: + return np.zeros(np.shape(X), np.float32) + return bil(self.tH, (self.ty1 - Y) / self.tc - 0.5, (X - self.tx0) / self.tc - 0.5) + + def town_off(self, r, c): + sdf = bil(self.SDF, r, c) + hr = bil(self.HR, r, c) + tr = bil(self.TREE, r, c) + wd = bil(self.WD, r, c) + hb = np.where(sdf < 0, hr, 0.0) + h = np.maximum(hb, tr) + rn = np.clip(np.round(r).astype(int), 0, self.zh - 1) + cn = np.clip(np.round(c).astype(int), 0, self.zw - 1) + dk = self.DECK[rn, cn] > 0 + return np.where(h > 0.05, h, np.where(dk, 1.2, -wd)) + + def height(self, X, Y): + h = self.terrain(X, Y).astype(np.float64) + r, c = self.town_rc(X, Y) + it = self.in_town(r, c) + if it.any(): + h[it] = h[it] + self.town_off(r[it], c[it]) + return h + + def bound(self, X, Y): + x0, x1, y0, y1 = self.ext + r = ((y1 - Y) / self.BT).astype(np.int32) + c = ((X - x0) / self.BT).astype(np.int32) + ins = (r >= 0) & (c >= 0) & (r < self.mm.shape[0]) & (c < self.mm.shape[1]) + return np.where(ins, self.mm[np.clip(r, 0, self.mm.shape[0] - 1), np.clip(c, 0, self.mm.shape[1] - 1)], -1e3) + + +def camera(v, W=2048, H=1152): + yaw, pitch = np.radians(v["yaw"]), np.radians(v.get("pitch", 0.0)) + f = np.array([np.sin(yaw) * np.cos(pitch), np.cos(yaw) * np.cos(pitch), np.sin(pitch)]) + r = np.cross(f, [0, 0, 1.0]) + r /= np.linalg.norm(r) + u = np.cross(r, f) + F = (W / 2) / np.tan(np.radians(v["hfov"] / 2)) + cy = H / 2 + v.get("shift", 0.0) * H + return dict(C=np.array(v["pos"], float), f=f, r=r, u=u, F=F, W=W, H=H, cx=W / 2, cy=cy) + + +def rays(cam): + W, H = cam["W"], cam["H"] + px, py = np.meshgrid(np.arange(W) + 0.5, np.arange(H) + 0.5) + d = (cam["f"][None, None] + ((px - cam["cx"]) / cam["F"])[..., None] * cam["r"] + - ((py - cam["cy"]) / cam["F"])[..., None] * cam["u"]) + d = d.reshape(-1, 3) + return d / np.linalg.norm(d, axis=1, keepdims=True) + + +def project(cam, P): + q = np.asarray(P, float) - cam["C"] + zc = q @ cam["f"] + x = cam["cx"] + cam["F"] * (q @ cam["r"]) / zc + y = cam["cy"] - cam["F"] * (q @ cam["u"]) / zc + return np.stack([x, y], -1), zc + + +def march(world, O, d, pix, tmax=None, max_iter=20000, tcap=40000.0): + """First hit of rays O + t d against the heightfield world. Returns hit, t, iterations.""" + N = len(d) + O = np.broadcast_to(np.asarray(O, float), (N, 3)) + t = np.zeros(N) + tprev = np.zeros(N) + hit = np.zeros(N, bool) + tm = np.full(N, tcap) if tmax is None else np.minimum(tmax, tcap) + dxy = np.hypot(d[:, 0], d[:, 1]) + 1e-6 + x0, x1, y0, y1 = world.ext + ext = (x0 + 30, x1 - 30, y0 + 30, y1 - 30) + it = 0 + idx = np.arange(N) + while idx.size and it < max_iter: + P = O[idx] + t[idx, None] * d[idx] + x, y, z = P[:, 0], P[:, 1], P[:, 2] + gone = (((z > world.hmax) & (d[idx, 2] >= 0)) | (t[idx] > tm[idx]) | (x < ext[0]) | (x > ext[1]) + | (y < ext[2]) | (y > ext[3])) + keep = ~gone + idx, x, y, z = idx[keep], x[keep], y[keep], z[keep] + if not idx.size: + break + b = world.bound(x, y) + far = z > b + fi = idx[far] + if fi.size: + dz = d[fi, 2] + down = np.where(dz < -1e-6, (z[far] - b[far]) / np.maximum(-dz, 1e-6), 1e9) + step = np.minimum(down, world.BT * 0.7 / dxy[fi]) + tprev[fi] = t[fi] + t[fi] += np.maximum(step, 0.3) + ni = idx[~far] + keep2 = np.ones(idx.size, bool) + if ni.size: + hz = world.height(x[~far], y[~far]) + hh = z[~far] <= hz + hit[ni[hh]] = True + mi = ni[~hh] + if mi.size: + fine = np.maximum(0.12, t[mi] * pix * 0.9) + gap = z[~far][~hh] - hz[~hh] + step = np.maximum(fine, np.minimum(gap * 0.4, 4.0 + t[mi] * pix * 2)) + tprev[mi] = t[mi] + t[mi] += step + kk = np.ones(idx.size, bool) + kk[np.nonzero(~far)[0][hh]] = False + keep2 = kk + idx = idx[keep2] + it += 1 + hi = np.nonzero(hit)[0] + a, bb = tprev[hi].copy(), t[hi].copy() + for _ in range(12): + m = (a + bb) / 2 + P = O[hi] + m[:, None] * d[hi] + below = P[:, 2] <= world.height(P[:, 0], P[:, 1]) + bb = np.where(below, m, bb) + a = np.where(below, a, m) + t[hi] = bb + t[~hit] = np.inf + return hit, t, it + + +def convex_interval(planes, O, d): + n = planes[:, :3] + dd = planes[:, 3] + den = d @ n.T + num = dd[None] - (O @ n.T if O.ndim == 2 else (O @ n.T)[None]) + with np.errstate(divide="ignore", invalid="ignore"): + t = num / den + ent = np.where(den < -1e-12, t, -np.inf) + ext = np.where(den > 1e-12, t, np.inf) + bad = (np.abs(den) <= 1e-12) & (num < 0) + te = ent.max(1) + ie = ent.argmax(1) + tx = ext.min(1) + te[bad.any(1)] = np.inf + return te, tx, ie + + +def solid_hit(S, O, d, eps=1e-4): + if S["kind"] == "sphere": + oc = (O - S["c"]) if O.ndim == 2 else (O - S["c"])[None] + b = (oc * d).sum(1) + cc = (oc * oc).sum(1) - S["r"] ** 2 + disc = b * b - cc + sq = np.sqrt(np.maximum(disc, 0)) + te = np.where(disc >= 0, -b - sq, np.inf) + P = (O[None] if O.ndim == 1 else O) + np.where(np.isfinite(te), te, 0)[:, None] * d + return np.where(te > eps, te, np.inf), (P - S["c"]) / S["r"] + te, tx, ie = convex_interval(S["planes"], O, d) + ok = (te <= tx) & (te > eps) + return np.where(ok, te, np.inf), S["planes"][ie, :3] + + +def screen_rect(cam, S, pad=2): + lo, hi = S["lo"], S["hi"] + P = np.array([[x, y, z] for x in (lo[0], hi[0]) for y in (lo[1], hi[1]) for z in (lo[2], hi[2])]) + p, zc = project(cam, P) + if (zc <= 0.05).any(): + if (zc <= 0.05).all(): + return None + return 0, 0, cam["W"], cam["H"] + x0, y0 = np.floor(p.min(0)).astype(int) - pad + x1, y1 = np.ceil(p.max(0)).astype(int) + pad + x0, y0 = max(0, x0), max(0, y0) + x1, y1 = min(cam["W"], x1), min(cam["H"], y1) + if x1 <= x0 or y1 <= y0: + return None + return x0, y0, x1, y1 + + +def trace_solids(cam, d): + W, H = cam["W"], cam["H"] + N = W * H + tb = np.full(N, np.inf) + nb = np.zeros((N, 3)) + ob = np.full(N, -1, np.int32) + grid = np.arange(N).reshape(H, W) + for S in SC.SOLIDS: + rc = screen_rect(cam, S) + if rc is None: + continue + x0, y0, x1, y1 = rc + idx = grid[y0:y1, x0:x1].ravel() + t, nrm = solid_hit(S, cam["C"], d[idx]) + better = t < tb[idx] + if better.any(): + j = idx[better] + tb[j] = t[better] + nb[j] = nrm[better] + ob[j] = S["oid"] + return tb, nb, ob + + +def shadow_solids(P, Ld, eps=0.03): + N = P.shape[0] + e1 = np.cross(Ld, [0, 0, 1.0]) + e1 /= np.linalg.norm(e1) + e2 = np.cross(Ld, e1) + u, v, w = P @ e1, P @ e2, P @ Ld + blocked = np.zeros(N, bool) + for S in SC.SOLIDS: + lo, hi = S["lo"], S["hi"] + C8 = np.array([[x, y, z] for x in (lo[0], hi[0]) for y in (lo[1], hi[1]) for z in (lo[2], hi[2])]) + cu, cv, cw = C8 @ e1, C8 @ e2, C8 @ Ld + sel = (~blocked) & (u >= cu.min()) & (u <= cu.max()) & (v >= cv.min()) & (v <= cv.max()) & (w <= cw.max()) + if not sel.any(): + continue + j = np.nonzero(sel)[0] + t, _ = solid_hit(S, P[j], np.ascontiguousarray(np.broadcast_to(Ld, (j.size, 3))), eps=eps) + blocked[j[np.isfinite(t)]] = True + return blocked + + +def sky(d, L, kind): + el = np.degrees(np.arcsin(np.clip(d[:, 2], -1, 1))) + t = np.clip(el / 45.0, 0, 1)[:, None] + if kind in ("day", "morning"): + zen, hor = np.array([118, 154, 200], float), np.array([206, 214, 222], float) + else: + zen, hor = np.array([96, 120, 168], float), np.array([232, 200, 170], float) + col = hor * (1 - t ** 0.55) + zen * t ** 0.55 + cs = d @ L + col += np.clip(cs, 0, 1)[:, None] ** 12 * (np.array([60, 40, 10]) if kind != "sunset" else np.array([90, 50, 10])) + return col + + +def hn(a, bb, s): + return np.sin(a * s + 1.9 * np.sin(bb * s * 0.63)) * np.sin(bb * s * 1.21 + 1.4 * np.sin(a * s * 0.49)) + + +def shade(world, cam, d, kind, suns): + W, H = cam["W"], cam["H"] + N = W * H + C = cam["C"] + L = sun_vec(kind, suns) + pix = 1.0 / cam["F"] + t0 = time.time() + ts, ns, os_ = trace_solids(cam, d) + t1 = time.time() + hit_h, th, iters = march(world, C, d, pix, tmax=np.where(np.isfinite(ts), ts + 0.01, 40000.0)) + t2 = time.time() + use_h = hit_h & (th < ts) + t = np.where(use_h, th, ts) + hit = np.isfinite(t) + col = sky(d, L, kind) + cls = np.zeros(N, np.uint8) + idx = np.nonzero(hit)[0] + P = C + t[idx, None] * d[idx] + nrm = np.zeros((idx.size, 3)) + base = np.zeros((idx.size, 3)) + ccls = np.zeros(idx.size, np.uint8) + hh = use_h[idx] + if hh.any(): + Ph = P[hh] + x, y, z = Ph[:, 0], Ph[:, 1], Ph[:, 2] + tt = t[idx][hh] + e = np.maximum(0.06, tt * pix * 0.8) + hx = (world.height(x + e, y) - world.height(x - e, y)) / (2 * e) + hy = (world.height(x, y + e) - world.height(x, y - e)) / (2 * e) + n = np.stack([-hx, -hy, np.ones_like(hx)], 1) + n /= np.linalg.norm(n, axis=1, keepdims=True) + zt = world.terrain(x, y) + rel = z - zt + r, c = world.town_rc(x, y) + it = world.in_town(r, c) + b = np.zeros((hh.sum(), 3)) + cl = np.zeros(hh.sum(), np.uint8) + # terrain classes by elevation and slope + slope = np.degrees(np.arctan(np.hypot(hx, hy))) + rn = 0.6 * hn(x, y, 0.012) + 0.4 * hn(y, x, 0.031) + fz = 0.5 + 0.5 * hn(x, y, 0.0021) + tcl = np.full(len(x), CLS_ID["field"], np.uint8) + tcl[(zt > 40) | (slope > 8)] = CLS_ID["field"] + tcl[(slope > 10) & (slope < 38) & (zt > 15) & (zt < 780) & (fz > 0.46)] = CLS_ID["forest"] + tcl[(slope > 36 + 8 * rn)] = CLS_ID["rock"] + tcl[(zt > world.snowline + 180 * rn) & (slope < 42)] = CLS_ID["snow"] + for k, v in ((CLS_ID["field"], PAL["meadow"]), (CLS_ID["forest"], PAL["forest"]), (CLS_ID["rock"], PAL["rock"]), + (CLS_ID["snow"], PAL["snow"])): + b[tcl == k] = v + cl[:] = tcl + tex = 0.5 * hn(x, y + z * 0.7, 0.21) + 0.3 * hn(y, x - z, 0.53) + 0.2 * hn(x + z, y, 1.37) + fo = tcl == CLS_ID["forest"] + b[fo] = b[fo] * (0.78 + 0.3 * tex[fo])[:, None] + rk = tcl == CLS_ID["rock"] + b[rk] = b[rk] * (0.8 + 0.25 * tex[rk])[:, None] + if it.any(): + ii = np.nonzero(it)[0] + ri, ci = r[ii], c[ii] + sdf = bil(world.SDF, ri, ci) + rn_ = np.clip(np.round(ri).astype(int), 0, world.zh - 1) + cn_ = np.clip(np.round(ci).astype(int), 0, world.zw - 1) + zcls = world.CLS[rn_, cn_] + zone = world.ZONE[rn_, cn_] + tint = world.TINT[rn_, cn_] / 255.0 + eav = bil(world.EAV, ri, ci) + trh = bil(world.TREE, ri, ci) + rl = rel[ii] + house = (sdf < 0.35) & (rl > 0.25) & (trh < rl - 0.3) + treep = (trh > 0.3) & (rl > 0.25) & ~house + wall = house & ((rl < eav - 0.05) | (n[ii, 2] < 0.40)) + roofp = house & ~wall + ground = ~house & ~treep + bb = b[ii].copy() + cc = cl[ii].copy() + bb[ground] = PAL["street"] + cc[ground] = CLS_ID["street"] + g_open = ground & (zcls == 8) + bb[g_open] = PAL["field"] + cc[g_open] = CLS_ID["field"] + wat = ground & (rl < -0.6) + bb[wat] = PAL["water"] + cc[wat] = CLS_ID["water"] + dk = ground & (world.DECK[rn_, cn_] > 0) & (rl > 0.5) + bb[dk] = PAL["deck"] + cc[dk] = CLS_ID["deck"] + slopey = ground & (zt[ii] > 1.0) + bb[slopey] = b[ii][slopey] + cc[slopey] = cl[ii][slopey] + zk = np.clip(zone, 1, 4) + for zz in (1, 2, 3, 4): + m = wall & (zk == zz) + bb[m] = np.array(PAL["wall%d" % zz]) * (0.92 + 0.16 * tint[m, None]) + m = roofp & (zk == zz) + bb[m] = np.array(PAL["roof%d" % zz]) * (0.92 + 0.16 * tint[m, None]) + cc[wall] = CLS_ID["wall"] + cc[roofp] = CLS_ID["roof"] + bb[treep] = PAL["tree"] + cc[treep] = CLS_ID["tree"] + if wall.any(): + # a window/door rhythm on the walls: the scale cue the re-surfacing model builds real houses from + wi = np.nonzero(wall)[0] + e2 = 0.4 + gx_ = bil(world.SDF, ri[wi], ci[wi] + e2) - bil(world.SDF, ri[wi], ci[wi] - e2) + gy_ = bil(world.SDF, ri[wi] + e2, ci[wi]) - bil(world.SDF, ri[wi] - e2, ci[wi]) + tv = np.stack([gy_, gx_], 1) + tv /= (np.linalg.norm(tv, axis=1, keepdims=True) + 1e-9) + Pw = Ph[ii][wi] + s_ = Pw[:, 0] * tv[:, 0] - Pw[:, 1] * tv[:, 1] + zz_ = rl[wi] + ev = eav[wi] + st_ = np.floor((zz_ - 0.3) / 2.8) + zin = (zz_ - 0.3) - st_ * 2.8 + fw = (s_ / 3.4) % 1.0 + win = (fw > 0.38) & (fw < 0.6) & (zin > 1.0) & (zin < 2.0) & (zz_ < ev - 0.6) & (st_ >= 1) + fd = (s_ / 9.3) % 1.0 + door = (fd > 0.45) & (fd < 0.56) & (zz_ < 2.2) + gwin = (fw > 0.4) & (fw < 0.58) & (st_ == 0) & (zin > 1.0) & (zin < 1.8) & ~door + cw = bb[wi] + cw[win | gwin] = (54, 54, 58) + cw[door] = (72, 54, 40) + bb[wi] = cw + wn = np.stack([gx_, -gy_, np.zeros_like(gx_)], 1) + wl = np.linalg.norm(wn, axis=1) + good = wl > 1e-4 + nn_ = n[ii].copy() + sub = nn_[wi] + sub[good] = wn[good] / wl[good, None] + nn_[wi] = sub + n[ii] = nn_ + b[ii] = bb + cl[ii] = cc + nrm[hh] = n + base[hh] = b + ccls[hh] = cl + sh_ = ~hh + if sh_.any(): + j = idx[sh_] + nrm[sh_] = ns[j] + oid = os_[j] + bb = np.zeros((j.size, 3)) + for o in np.unique(oid): + bb[oid == o] = SC.MAT[SC.SOLIDS[o]["mat"]] + leaf = np.array([SC.SOLIDS[o]["mat"] == "leaf" for o in oid]) + if leaf.any(): + Pl = P[sh_][leaf] + hx = ((np.floor(Pl[:, 0] * 2.2).astype(np.int64) * 73856093) ^ (np.floor(Pl[:, 1] * 2.2).astype(np.int64) * 19349663) + ^ (np.floor(Pl[:, 2] * 2.2).astype(np.int64) * 83492791)) + rr = (hx % 1000) / 1000.0 + sub = bb[leaf] + sub *= (0.62 + 0.6 * rr)[:, None] + bb[leaf] = sub + base[sh_] = bb + ccls[sh_] = CLS_ID["solid"] + flip = (nrm * d[idx]).sum(1) > 0 + nrm[flip] *= -1 + t3 = time.time() + lam = np.clip(nrm @ L, 0, 1) + Q = P + nrm * 0.05 + L * 0.02 + li = np.nonzero(lam > 0)[0] + shadow = np.ones(idx.size, bool) + if li.size: + bs = shadow_solids(Q[li], L) + rem = li[~bs] + hs, _, _ = march(world, Q[rem], np.ascontiguousarray(np.broadcast_to(L, (rem.size, 3))), pix * 1.5, tcap=12000.0) + sh = np.ones(li.size, bool) + sh[~bs] = hs + shadow[li] = sh + t4 = time.time() + sky_occ = 0.55 + 0.45 * np.clip(nrm[:, 2] * 0.5 + 0.5, 0, 1) + if kind in ("day", "morning"): + amb = AMB[None] * (0.50 * sky_occ)[:, None] + sun = SUNC[None] * (0.80 * lam * ~shadow)[:, None] + else: + amb = np.array([0.66, 0.70, 0.92])[None] * (0.42 * sky_occ)[:, None] + sun = np.array([1.0, 0.70, 0.45])[None] * (0.95 * lam * ~shadow)[:, None] + cc = base * (amb + sun) + wat = ccls == CLS_ID["water"] + if wat.any(): + cc[wat] = cc[wat] * 0.7 + sky(np.c_[d[idx][wat][:, :2], -d[idx][wat][:, 2]], L, kind) * 0.3 + dist = t[idx] + fog = 1 - np.exp(-dist / (16000.0 if kind != "sunset" else 12000.0)) + hz = np.array([200, 208, 218]) if kind != "sunset" else np.array([206, 182, 168]) + cc = cc * (1 - fog[:, None]) + hz * fog[:, None] + col[idx] = cc + cls[idx] = ccls + img = col.reshape(H, W, 3).clip(0, 255).astype(np.uint8) + depth = np.where(hit, t, np.inf).reshape(H, W).astype(np.float32) + oid = np.where(hit & ~use_h, os_ + 1, 0).reshape(H, W).astype(np.uint16) + print(" solids %.0fs march %.0fs (%d it) shade %.0fs shadows %.0fs" % (t1 - t0, t2 - t1, iters, t3 - t2, t4 - t3), flush=True) + return img, depth, oid, cls.reshape(H, W) + + +def people_table(cam): + out = [] + for p in SC.PEOPLE: + base = np.array([p["x"], p["y"], p["z0"]]) + top = base + [0, 0, p["h"]] + (pb, pt), zc = project(cam, np.stack([base, top])) + if (zc <= 0.3).any(): + continue + x = (pb[0] + pt[0]) / 2 + if not (0 <= x < cam["W"] and min(pb[1], pt[1]) < cam["H"] and max(pb[1], pt[1]) > 0): + continue + hpx = pb[1] - pt[1] + out.append(dict(label=p["label"], h_m=round(p["h"], 3), dist_m=round(float(zc[0]), 1), x=round(float(x), 1), + y_foot=round(float(pb[1]), 1), y_head=round(float(pt[1]), 1), px_height=round(float(hpx), 1), + px_per_m=round(float(hpx / p["h"]), 2))) + return out + + +def landmarks(cam, scene): + L = {} + for lm in scene.get("landmarks", []): + p, zc = project(cam, np.array([lm["xyz"]])) + if zc[0] > 0: + L[lm["name"]] = [round(float(p[0, 0]), 1), round(float(p[0, 1]), 1), round(float(zc[0]), 1)] + return L + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("views", nargs="+") + ap.add_argument("--config", required=True) + ap.add_argument("--views-file", default=None, help="defaults to config.views") + ap.add_argument("--out", default=None, help="defaults to config.plates_dir") + ap.add_argument("--w", type=int, default=2048) + ap.add_argument("--sun", default=None, help="override the view's sun: day|sunset|morning") + a = ap.parse_args() + cfg = load_config(a.config) + VIEWS = json.load(open(resolve(cfg, a.views_file or cfg["views"]))) + outdir = resolve(cfg, a.out or cfg.get("plates_dir", "plates")) + os.makedirs(outdir, exist_ok=True) + world = World(cfg) + Hpx = a.w * 9 // 16 + suns = cfg.get("suns", {}) + for k in a.views: + v = VIEWS[k] + t0 = time.time() + SC.reset() + scene_path = resolve(cfg, v.get("scene", cfg.get("scene"))) + scene = json.load(open(scene_path)) if scene_path and os.path.exists(scene_path) else {} + SC.build_from_json(scene, ground_fn=world.terrain) + world.add_solids_to_bounds() + cam = camera(v, a.w, Hpx) + d = rays(cam) + kv = a.sun or v.get("sun", "day") + img, depth, oid, cls = shade(world, cam, d, kv, suns) + sfx = "" if a.w == 2048 else "_%d" % a.w + Image.fromarray(img).save(os.path.join(outdir, "%s_mass%s.png" % (k, sfx))) + np.save(os.path.join(outdir, "%s_depth%s.npy" % (k, sfx)), depth) + cv2.imwrite(os.path.join(outdir, "%s_oid%s.png" % (k, sfx)), oid) + Image.fromarray(cls).save(os.path.join(outdir, "%s_cls%s.png" % (k, sfx))) + save_json({kk: vv for kk, vv in cam.items()}, os.path.join(outdir, "%s_cam%s.json" % (k, sfx))) + save_json(people_table(cam), os.path.join(outdir, "%s_people%s.json" % (k, sfx))) + save_json(landmarks(cam, scene), os.path.join(outdir, "%s_landmarks%s.json" % (k, sfx))) + print(k, kv, "%dx%d" % (a.w, Hpx), "done %.0fs" % (time.time() - t0), flush=True) diff --git a/scripts/scene_solids.py b/scripts/scene_solids.py new file mode 100644 index 0000000..12e962d --- /dev/null +++ b/scripts/scene_solids.py @@ -0,0 +1,238 @@ +"""Analytic convex solids for hand-modeled landmarks and true-scale proxies (people, carts, horses, trees). + +Everything is a convex polyhedron (half-space planes) or a sphere, so a ray hit is one interval test. +A scene file (JSON) lists solids in world meters; see examples/scene.example.json. Kinds: + box {c:[x,y,z], size:[sx,sy,sz], heading?:deg, mat, group} + prism {poly:[[x,y],...], z0, z1, mat, group} (vertical extrusion of a convex polygon) + cone {c:[x,y], r0, z0, z1, mat, group} (round tower roof; faceted) + gable {p0:[x,y], p1:[x,y], width, z_eave, rise, mat_wall, mat_roof, group} (house: walls + roof prism) + person {xy:[x,y], z0?, height?:1.72, heading?:deg, robe?:bool, cloth?:int, label?} + cart {xy, z0?, heading, load?:hay|sacks} + horse {xy, z0?, heading, pack?:bool} + tree {xy, z0?, h?:9, r?:3.2, conifer?:bool} +Proxy people are the point of the method: they are the scale anchors the re-surfacing model dresses in place. +""" +import numpy as np + +MAT = dict( + stone=(176, 172, 164), stone_dk=(150, 146, 138), stone_lt=(194, 190, 182), slate=(82, 86, 94), lead=(116, 120, 126), + timber=(146, 126, 102), timber_dk=(118, 100, 80), plank=(156, 136, 108), shingle=(96, 84, 72), turf=(98, 110, 72), + oak=(78, 58, 42), skin=(198, 160, 134), legs=(70, 62, 54), leaf=(74, 98, 60), trunk=(84, 68, 54), wheel=(92, 74, 56), + canvas=(170, 160, 136), horse=(104, 78, 58), horse_dk=(70, 54, 42), hay=(176, 156, 98), sack=(160, 146, 118), + iron=(70, 70, 72), +) +CLOTH = [(92, 70, 52), (118, 54, 44), (56, 66, 92), (96, 98, 92), (70, 86, 60), (150, 138, 112), (60, 52, 48), + (128, 98, 64), (84, 60, 78), (110, 112, 118), (140, 120, 90), (74, 80, 96)] +for _i, _c in enumerate(CLOTH): + MAT["cloth%d" % _i] = _c + +SOLIDS = [] +GROUPS = {} +PEOPLE = [] + + +def reset(): + SOLIDS.clear() + GROUPS.clear() + PEOPLE.clear() + + +def add(planes, pts, mat, group): + oid = len(SOLIDS) + p = np.asarray(pts, float) + SOLIDS.append(dict(kind="convex", planes=np.asarray(planes, float), lo=p.min(0) - 0.05, hi=p.max(0) + 0.05, + mat=mat, oid=oid, group=group)) + GROUPS.setdefault(group, []).append(oid) + return oid + + +def add_sphere(c, r, mat, group): + oid = len(SOLIDS) + c = np.asarray(c, float) + SOLIDS.append(dict(kind="sphere", c=c, r=float(r), lo=c - r, hi=c + r, mat=mat, oid=oid, group=group)) + GROUPS.setdefault(group, []).append(oid) + return oid + + +def _planes_box(c, ax, hx): + P = [] + for a, h in zip(ax, hx): + a = np.asarray(a, float) + P.append(np.r_[a, a @ c + h]) + P.append(np.r_[-a, -(a @ c) + h]) + return np.array(P) + + +def box_pts(c, ax, hx): + c = np.asarray(c, float) + ax = np.asarray(ax, float) + return np.array([c + sx * hx[0] * ax[0] + sy * hx[1] * ax[1] + sz * hx[2] * ax[2] + for sx in (-1, 1) for sy in (-1, 1) for sz in (-1, 1)]) + + +def add_box(c, ax, hx, mat, group): + c = np.asarray(c, float) + return add(_planes_box(c, ax, hx), box_pts(c, ax, hx), mat, group) + + +def axes(heading_deg): + b = np.radians(heading_deg) + f = np.array([np.sin(b), np.cos(b), 0.0]) + s = np.array([f[1], -f[0], 0.0]) + return s, f, np.array([0, 0, 1.0]) + + +def ccw(poly): + P = np.asarray(poly, float) + a = 0.5 * np.sum(P[:, 0] * np.roll(P[:, 1], -1) - np.roll(P[:, 0], -1) * P[:, 1]) + return P if a > 0 else P[::-1] + + +def prism_planes(poly, z0, z1): + P = ccw(poly) + pl = [[0, 0, -1, -z0], [0, 0, 1, z1]] + for i in range(len(P)): + a, b = P[i], P[(i + 1) % len(P)] + e = b - a + n = np.array([e[1], -e[0], 0.0]) + n /= np.linalg.norm(n) + pl.append(np.r_[n, n @ np.r_[a, 0]]) + pts = [np.r_[p, z0] for p in P] + [np.r_[p, z1] for p in P] + return np.array(pl), pts + + +def add_prism(poly, z0, z1, mat, group): + pl, pts = prism_planes(poly, z0, z1) + return add(pl, pts, mat, group) + + +def add_cone(cx, cy, r0, z0, z1, mat, group, n=24, rtop=0.05): + th = np.linspace(0, 2 * np.pi, n, endpoint=False) + pl = [[0, 0, -1, -z0]] + h = z1 - z0 + for t in th: + nx, ny = np.cos(t), np.sin(t) + nn = np.array([nx * h, ny * h, r0 - rtop]) + nn /= np.linalg.norm(nn) + pl.append(np.r_[nn, nn @ np.array([cx + nx * r0, cy + ny * r0, z0])]) + pts = [[cx + r0 * np.cos(t), cy + r0 * np.sin(t), z0] for t in th] + [[cx, cy, z1]] + return add(np.array(pl), pts, mat, group) + + +def add_gable(p0, p1, width, z_eave, rise, mat_wall, mat_roof, group, z0=0.0, overhang=0.35): + """A house: walls as a box under the eaves, a roof prism with its ridge from p0 to p1.""" + p0, p1 = np.asarray(p0, float), np.asarray(p1, float) + d = p1 - p0 + L = np.linalg.norm(d) + d /= L + nrm = np.array([-d[1], d[0]]) + c = (p0 + p1) / 2 + ax = [np.r_[d, 0], np.r_[nrm, 0], [0, 0, 1.0]] + add_box(np.r_[c, z0 + (z_eave - z0) / 2], ax, [L / 2, width / 2, (z_eave - z0) / 2], mat_wall, group) + w2 = width / 2 + overhang + pl = [[0, 0, -1, -z_eave], np.r_[ax[0], ax[0] @ np.r_[c, 0] + L / 2 + overhang], + np.r_[-ax[0], -(ax[0] @ np.r_[c, 0]) + L / 2 + overhang]] + for sgn in (1, -1): + nn = np.r_[sgn * nrm * rise, w2] + nn /= np.linalg.norm(nn) + pl.append(np.r_[nn, nn @ np.r_[c + sgn * nrm * w2, z_eave]]) + pts = [np.r_[c + a * d * (L / 2 + overhang) + s * nrm * w2, z_eave] for a in (-1, 1) for s in (-1, 1)] + pts += [np.r_[c + a * d * (L / 2 + overhang), z_eave + rise] for a in (-1, 1)] + add(np.array(pl), pts, mat_roof, group) + + +def person(xy, z0, height=1.72, heading=0.0, robe=False, cloth=0, group="people", stride=0.0, label=""): + """A mannequin at true scale: legs, torso, head. Recorded in PEOPLE for the figure-scale gate.""" + h = float(height) + s, f, z = axes(heading) + ax = [s, f, z] + c0 = np.r_[np.asarray(xy, float)[:2], z0] + col = "cloth%d" % (cloth % len(CLOTH)) + k = h / 1.72 + leg, tor, hr, sh_w = 0.47 * h, 0.30 * h, 0.062 * h, 0.12 * h + if robe: + zt = leg + tor + hw0, hw1, hd0, hd1 = 0.30 * k, sh_w, 0.20 * k, 0.12 * k + pl = [[0, 0, -1, -z0], [0, 0, 1, z0 + zt]] + for v, w0, w1 in ((s, hw0, hw1), (-s, hw0, hw1), (f, hd0, hd1), (-f, hd0, hd1)): + nn = v * zt + z * (w0 - w1) + nn /= np.linalg.norm(nn) + pl.append(np.r_[nn, nn @ (c0 + v * w0)]) + pts = [c0 + a * hw0 + bb * hd0 for a in (s, -s) for bb in (f, -f)] + [c0 + z * zt + a * hw1 for a in (s, -s)] + add(np.array(pl), pts, col, group) + else: + for side in (-1, 1): + add_box(c0 + s * side * 0.075 * k + f * stride * side * 0.5 + z * (leg / 2), ax, + [0.065 * k, 0.08 * k, leg / 2], "legs", group) + add_box(c0 + z * (leg + tor / 2 - 0.02), ax, [sh_w, 0.12 * k, tor / 2 + 0.04], col, group) + for side in (-1, 1): + add_box(c0 + s * side * (sh_w + 0.05 * k) + z * (leg + tor * 0.55), ax, [0.045 * k, 0.05 * k, tor * 0.42], col, group) + add_sphere(c0 + z * (h - hr), hr, "skin", group) + PEOPLE.append(dict(x=float(c0[0]), y=float(c0[1]), z0=float(z0), h=h, label=label or group)) + + +def cart(xy, z0, heading, load="hay", group="carts"): + s, f, z = axes(heading) + ax = [s, f, z] + c0 = np.r_[np.asarray(xy, float)[:2], z0] + add_box(c0 + z * 1.0, ax, [0.75, 1.3, 0.25], "plank", group) + add_box(c0 + z * (1.25 + 0.45), ax, [0.7, 1.2, 0.45], "hay" if load == "hay" else "sack", group) + for side in (-1, 1): + add_box(c0 + s * side * 0.9 + z * 0.65, ax, [0.05, 0.65, 0.65], "wheel", group) + return c0 + f * 1.3 + + +def horse(xy, z0, heading, pack=False, group="animals"): + s, f, z = axes(heading) + ax = [s, f, z] + c0 = np.r_[np.asarray(xy, float)[:2], z0] + add_box(c0 + z * 1.15, ax, [0.3, 0.95, 0.32], "horse", group) + add_box(c0 + f * 1.1 + z * 1.45, ax, [0.15, 0.35, 0.3], "horse_dk", group) + for sx in (-1, 1): + for sy in (-1, 1): + add_box(c0 + s * sx * 0.18 + f * sy * 0.6 + z * 0.42, ax, [0.07, 0.07, 0.42], "horse_dk", group) + if pack: + add_box(c0 + z * 1.65, ax, [0.4, 0.5, 0.2], "sack", group) + + +def tree(xy, z0, h=9.0, r=3.2, conifer=False, group="trees"): + x, y = float(xy[0]), float(xy[1]) + add_box([x, y, z0 + h * 0.2], [[1, 0, 0], [0, 1, 0], [0, 0, 1]], [0.18, 0.18, h * 0.2], "trunk", group) + if conifer: + add_cone(x, y, r, z0 + h * 0.25, z0 + h, "leaf", group, n=12) + else: + add_sphere([x, y, z0 + h * 0.65], r, "leaf", group) + + +def build_from_json(scene, ground_fn=None): + """Populate SOLIDS from a scene dict. `ground_fn(x, y) -> z` places proxies on the terrain when z0 is absent.""" + def z0_of(e): + if "z0" in e: + return float(e["z0"]) + if ground_fn is None: + return 0.0 + return float(ground_fn(np.array([e["xy"][0]]), np.array([e["xy"][1]]))[0]) + for e in scene.get("solids", []): + k = e["kind"] + g = e.get("group", k) + if k == "box": + s, f, z = axes(e.get("heading", 0.0)) + add_box(e["c"], [s, f, z], [v / 2 for v in e["size"]], e.get("mat", "stone"), g) + elif k == "prism": + add_prism(e["poly"], e["z0"], e["z1"], e.get("mat", "stone"), g) + elif k == "cone": + add_cone(e["c"][0], e["c"][1], e["r0"], e["z0"], e["z1"], e.get("mat", "slate"), g) + elif k == "gable": + add_gable(e["p0"], e["p1"], e["width"], e["z_eave"], e["rise"], e.get("mat_wall", "stone"), + e.get("mat_roof", "slate"), g, z0=e.get("z0", 0.0)) + elif k == "person": + person(e["xy"], z0_of(e), e.get("height", 1.72), e.get("heading", 0.0), e.get("robe", False), + e.get("cloth", 0), "people", e.get("stride", 0.0), e.get("label", "person")) + elif k == "cart": + cart(e["xy"], z0_of(e), e.get("heading", 0.0), e.get("load", "hay")) + elif k == "horse": + horse(e["xy"], z0_of(e), e.get("heading", 0.0), e.get("pack", False)) + elif k == "tree": + tree(e["xy"], z0_of(e), e.get("h", 9.0), e.get("r", 3.2), e.get("conifer", False)) + else: + raise ValueError("unknown solid kind: %s" % k) diff --git a/scripts/segment_map.py b/scripts/segment_map.py new file mode 100644 index 0000000..c5de894 --- /dev/null +++ b/scripts/segment_map.py @@ -0,0 +1,102 @@ +#!/usr/bin/env python3 +"""Segment a hand-drawn town map bitmap into roof, tree and water masks. + +Tuned for the common "parchment with dark roofs, cauliflower tree glyphs, teal water" style of map exporters. +Every threshold is a flag so you can tune it to your own map; `--look` writes a check image you MUST eyeball +before building the massing (false "trees" that are really roof detail are the usual miss). + +usage: segment_map.py MAP.png --mpp 0.5 --out seg.npz [--look look.jpg] [--roof-max 184] [--tree-glyph-px 5] +""" +import argparse + +import cv2 +import numpy as np +from PIL import Image + +from citykit import ell + +Image.MAX_IMAGE_PIXELS = None + + +def lstd(g, k): + return np.sqrt(np.maximum(cv2.blur(g * g, (k, k)) - cv2.blur(g, (k, k)) ** 2, 0)) + + +def segment(rgb, mpp, roof_max=184.0, tree_glyph_px=5, tree_min_m2=8.0, tree_max_m2=700.0, roof_min_m2=11.0, + water_gr=22, water_br=12): + """Return (roof, tree, water) uint8 masks. `mpp` scales the morphology windows so the same flags work across + export resolutions (the reference tuning was at 0.53 m/px).""" + s = 0.53 / mpp # window scale relative to the reference tuning + a = rgb.astype(np.float32) + R, G, B = a[..., 0], a[..., 1], a[..., 2] + g = 0.3 * R + 0.59 * G + 0.11 * B + gb = cv2.blur(g, (3, 3)) + # trees: dense short dark strokes (blackhat line density) in compact blobs + bh = cv2.morphologyEx(g, cv2.MORPH_BLACKHAT, ell(tree_glyph_px * s)) + ld = cv2.blur((bh > 12).astype(np.float32), (int(9 * s) | 1,) * 2) + tr = ((ld > 0.45) & (cv2.blur(g, (int(9 * s) | 1,) * 2) < 175)).astype(np.uint8) + tr = cv2.morphologyEx(tr, cv2.MORPH_OPEN, ell(5 * s)) + tr = cv2.morphologyEx(tr, cv2.MORPH_CLOSE, ell(3 * s)) + n, lab, st, _ = cv2.connectedComponentsWithStats(tr, 8) + keep = np.zeros(n, bool) + for i in range(1, n): + x, y, w, h, ar = st[i] + area_m2 = ar * mpp * mpp + if area_m2 < tree_min_m2 or area_m2 > tree_max_m2: + continue + if max(w, h) > 2.6 * min(w, h): + continue + if ar / float(w * h) < 0.4: + continue + keep[i] = True + tree = cv2.dilate(keep[lab].astype(np.uint8), ell(3 * s)) + # roofs: darker than the parchment and not a tree; fill small holes; strip the 1 px cast-shadow halo + roof = ((gb < roof_max) & (cv2.dilate(tree, ell(3 * s)) == 0)).astype(np.uint8) + roof = cv2.morphologyEx(roof, cv2.MORPH_OPEN, ell(3 * s)) + roof = cv2.morphologyEx(roof, cv2.MORPH_CLOSE, ell(3 * s)) + inv = (1 - roof).astype(np.uint8) + n, lab, st, _ = cv2.connectedComponentsWithStats(inv, 4) + hole = np.zeros(n, bool) + hole[1:] = st[1:, 4] * mpp * mpp < 25.0 + roof[hole[lab] & (tree == 0)] = 1 + roof = cv2.erode(roof, ell(3 * s)) + n, lab, st, _ = cv2.connectedComponentsWithStats(roof, 8) + keep = np.zeros(n, bool) + keep[1:] = st[1:, 4] * mpp * mpp >= roof_min_m2 + roof = keep[lab].astype(np.uint8) + water = ((G - R > water_gr) & (B - R > water_br)).astype(np.uint8) + water = cv2.morphologyEx(water, cv2.MORPH_OPEN, ell(3 * s)) + water = cv2.morphologyEx(water, cv2.MORPH_CLOSE, ell(5 * s)) + roof[water > 0] = 0 + tree[water > 0] = 0 + return roof, tree, water + + +def look_image(rgb, roof, tree, water): + a = rgb.copy() + a[roof > 0] = (a[roof > 0] * 0.45 + np.array([255, 0, 0]) * 0.55).astype(np.uint8) + a[tree > 0] = (a[tree > 0] * 0.45 + np.array([0, 200, 0]) * 0.55).astype(np.uint8) + a[water > 0] = (a[water > 0] * 0.45 + np.array([0, 80, 255]) * 0.55).astype(np.uint8) + return np.concatenate([rgb, a], 1) + + +if __name__ == "__main__": + ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + ap.add_argument("map") + ap.add_argument("--mpp", type=float, required=True, help="meters per bitmap pixel") + ap.add_argument("--out", default="seg.npz") + ap.add_argument("--look", default=None, help="write a before/after check image (downscaled to 2400 px wide)") + ap.add_argument("--roof-max", type=float, default=184.0, help="gray level below which a pixel can be roof") + ap.add_argument("--tree-glyph-px", type=int, default=5) + a = ap.parse_args() + im = np.asarray(Image.open(a.map).convert("RGB")) + roof, tree, water = segment(im, a.mpp, a.roof_max, a.tree_glyph_px) + np.savez_compressed(a.out, roof=roof, tree=tree, water=water, mpp=np.float32(a.mpp)) + print("roof %.4f tree %.4f water %.4f of the bitmap" % (roof.mean(), tree.mean(), water.mean())) + if a.look: + lk = look_image(im, roof, tree, water) + sc = min(1.0, 2400 / lk.shape[1]) + if sc < 1: + lk = cv2.resize(lk, None, fx=sc, fy=sc, interpolation=cv2.INTER_AREA) + Image.fromarray(lk).save(a.look, quality=88) + print("check image:", a.look) diff --git a/scripts/smoke_test.py b/scripts/smoke_test.py new file mode 100644 index 0000000..bfa73bd --- /dev/null +++ b/scripts/smoke_test.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +"""End-to-end smoke test with no API calls: a synthetic map -> segment -> massing -> plates -> jobs -> gates. + +usage: smoke_test.py [WORKDIR] (default: a temp dir). Takes about a minute on a laptop at 768 px plates. +It also proves the gate on a known-bad case: the plate shifted 3 px must score worse than the plate itself. +""" +import json +import os +import subprocess +import sys +import tempfile + +import cv2 +import numpy as np +from PIL import Image + +HERE = os.path.dirname(os.path.abspath(__file__)) +PY = sys.executable + + +def run(*args): + cmd = [PY, os.path.join(HERE, args[0])] + list(args[1:]) + print("$", " ".join(os.path.basename(a) if a.startswith(HERE) else a for a in cmd), flush=True) + subprocess.run(cmd, check=True, cwd=HERE) + + +def synthetic_map(path, W=1200, H=900): + """Parchment with a river, a grid of dark-roofed houses, tree glyphs; 0.5 m/px.""" + rng = np.random.default_rng(1) + im = np.full((H, W, 3), (226, 214, 184), np.uint8) + # river: teal band curving across + for x in range(W): + yc = int(450 + 120 * np.sin(x / 260.0)) + im[yc - 18:yc + 18, x] = (90, 150, 150) + # houses: rows of rectangles with 2-3 px gaps, denser in the middle + for _ in range(420): + cx, cy = int(rng.normal(620, 220)), int(rng.normal(420, 160)) + w, h = int(rng.uniform(14, 30)), int(rng.uniform(10, 20)) + if not (10 < cx < W - 40 and 10 < cy < H - 30): + continue + if abs(cy - (450 + 120 * np.sin(cx / 260.0))) < 40: + continue + col = (120 + rng.integers(0, 30), 95 + rng.integers(0, 25), 70 + rng.integers(0, 20)) + im[cy:cy + h, cx:cx + w] = col + im[cy + h:cy + h + 2, cx + 2:cx + w + 2] = (170, 165, 160) # cast-shadow halo like a map exporter draws + # trees: cauliflower glyphs = dark stippled blobs + for _ in range(60): + cx, cy = int(rng.uniform(40, W - 40)), int(rng.uniform(40, H - 40)) + r = int(rng.uniform(6, 11)) + for _ in range(60): + a, d = rng.uniform(0, 2 * np.pi), rng.uniform(0, r) + x, y = int(cx + d * np.cos(a)), int(cy + d * np.sin(a)) + cv2.circle(im, (x, y), 1, (70, 90, 60), -1) + Image.fromarray(im).save(path) + + +def main(): + wd = os.path.abspath(sys.argv[1]) if len(sys.argv) > 1 else tempfile.mkdtemp(prefix="citykit-smoke-") + os.makedirs(wd, exist_ok=True) + print("workdir", wd) + synthetic_map(os.path.join(wd, "map.png")) + cfg = dict(town="Smoketown", map=dict(path="map.png", meters_per_px=0.5, origin_px=[600, 450]), + massing=dict(town_npz="town.npz", zones={"1": dict(eaves_min=2.8, eaves_max=4.2, pitch=0.7), + "2": dict(eaves_min=4.6, eaves_max=7.2, pitch=0.85)}, + cutouts=[[[570, 430], [630, 430], [630, 470], [570, 470]]]), + terrain=dict(path=None), world_extent_m=[-800, 800, -800, 800], + views="views.json", scene="scene.json", plates_dir="plates", + renderer=dict(model="example-model", quality="high", size="2048x1152", + cost_usd=dict(per_call_1ref=0.06, per_call_4ref=0.09)), + gates=dict(landmark_groups="hall")) + json.dump(cfg, open(os.path.join(wd, "citykit.json"), "w"), indent=1) + C = os.path.join(wd, "citykit.json") + run("segment_map.py", os.path.join(wd, "map.png"), "--mpp", "0.5", "--out", os.path.join(wd, "seg.npz"), + "--look", os.path.join(wd, "seg_look.jpg")) + run("massing.py", os.path.join(wd, "seg.npz"), "--config", C, "--out", os.path.join(wd, "town.npz")) + # find open ground for an eye-level camera from the heightfield itself (never by eye on the map) + Z = np.load(os.path.join(wd, "town.npz")) + SDF = Z["SDF"].astype(np.float32) + + def open_spot(X, Y, r_m=20): + px, py = 600 + X / 0.5, 450 - Y / 0.5 + r = int(r_m / 0.5) + y0, y1, x0, x1 = int(py) - r, int(py) + r, int(px) - r, int(px) + r + sub = SDF[y0:y1, x0:x1] + iy, ix = np.unravel_index(np.argmax(sub), sub.shape) + return float((x0 + ix - 600) * 0.5), float(-(y0 + iy - 450) * 0.5) + cx, cy = open_spot(-70, -25, 40) + yaw = np.degrees(np.arctan2(0 - cx, 0 - cy)) # look at the hall + fx, fy = np.sin(np.radians(yaw)), np.cos(np.radians(yaw)) + + def sdf_at(X, Y): + return float(SDF[int(450 - Y / 0.5), int(600 + X / 0.5)]) + + def ahead(dmax, dmin): + # nearest open point along the look direction between dmin and dmax, with clear ground back to the camera + for d in np.arange(dmax, dmin, -1.0): + X, Y = cx + d * fx, cy + d * fy + if all(sdf_at(cx + k * fx, cy + k * fy) > 1.5 for k in np.arange(0, d + 0.5, 1.0)): + return X, Y + return cx + dmin * fx, cy + dmin * fy + p1 = ahead(24, 11) + p2 = ahead(32, 14) + scene = dict(solids=[dict(kind="box", group="hall", mat="stone_lt", c=[0, 0, 7], size=[22, 14, 14], heading=20), + dict(kind="cone", group="hall", mat="slate", c=[0, 0], r0=6, z0=14, z1=24), + dict(kind="person", xy=list(p1), heading=yaw, height=1.72, label="walker"), + dict(kind="person", xy=[p1[0] + 1.2 * fy, p1[1] - 1.2 * fx], heading=yaw, height=1.64, robe=True, + cloth=2, label="walker"), + dict(kind="cart", xy=list(p2), heading=yaw, load="hay"), + dict(kind="tree", xy=[-20, 20], h=8, r=3)], + landmarks=[dict(name="hall_top", xyz=[0, 0, 24])]) + json.dump(scene, open(os.path.join(wd, "scene.json"), "w"), indent=1) + views = dict(S_street=dict(pos=[cx, cy, 1.65], yaw=float(yaw), pitch=0.0, hfov=62.0, shift=0.08, sun="day"), + A_aerial=dict(pos=[-160, -200, 90.0], yaw=35.0, pitch=-12.0, hfov=55.0, shift=0.0, sun="day")) + json.dump(views, open(os.path.join(wd, "views.json"), "w"), indent=1) + prompts = json.load(open(os.path.join(HERE, "..", "examples", "prompts.example.json"))) + prompts["views"] = {"S_street": dict(eye_level=True, light="day", refs=[], intro="IMAGE 1 is a block model of a street.", + keep="KEEP EXACTLY everything.", frame=""), + "A_aerial": dict(eye_level=False, light="day", refs=[], intro="IMAGE 1 is a block model from above.", + keep="KEEP EXACTLY every footprint.", frame="")} + json.dump(prompts, open(os.path.join(wd, "prompts.json"), "w"), indent=1) + run("render_plate.py", "S_street", "A_aerial", "--config", C, "--w", "768") + # the gate needs _mass.png etc. at the plate name without a size suffix: rename the 768 plates + pd = os.path.join(wd, "plates") + for f in os.listdir(pd): + if "_768" in f: + os.replace(os.path.join(pd, f), os.path.join(pd, f.replace("_768", ""))) + run("build_jobs.py", "day", "--config", C, "--prompts", os.path.join(wd, "prompts.json"), "--takes", "2", + "--out", os.path.join(wd, "jobs_day.json")) + # fake "takes": the plate itself (known good) and the plate shifted 3 px / scaled 1.01 (known bad) + out = os.path.join(wd, "out_day") + os.makedirs(out, exist_ok=True) + for v in views: + p = cv2.imread(os.path.join(pd, v + "_mass.png")) + cv2.imwrite(os.path.join(out, v + "_day_t1.png"), p) + M = np.float32([[1.01, 0, 3 - 0.005 * p.shape[1]], [0, 1.01, 3 - 0.005 * p.shape[0]]]) + cv2.imwrite(os.path.join(out, v + "_day_t2.png"), cv2.warpAffine(p, M, (p.shape[1], p.shape[0]), borderMode=cv2.BORDER_REPLICATE)) + run("gate.py", out, "--config", C) + G = json.load(open(os.path.join(out, "qc", "gate_out_day.json"))) + for v in views: + good, bad = G[v + "_day_t1"], G[v + "_day_t2"] + print(v, "good: grad %.3f scale %s | bad: grad %.3f scale %s shift %s/%s" % ( + good["grad_corr"], good.get("scale"), bad["grad_corr"], bad.get("scale"), bad.get("tx_px"), bad.get("ty_px"))) + assert good["grad_corr"] > 0.99, "plate vs itself must score ~1" + assert bad["grad_corr"] < good["grad_corr"], "the shifted plate must score lower" + assert bad.get("scale") is None or abs(bad["scale"] - 1.0) > 0.004, "ECC must see the 1 % zoom" + assert G["S_street_day_t1"].get("proxies_visible", 0) >= 1, "street view must see proxy people" + assert G["A_aerial_day_t1"].get("sky_res") is not None, "aerial with sky must get a skyline fit" + assert G["A_aerial_day_t1"].get("invented_structures_n") == 0, "plate vs itself invents nothing" + ledger = os.path.join(out, "results.jsonl") + with open(ledger, "w") as f: + for v in views: + f.write(json.dumps(dict(id=v + "_day_t1", status=200, secs=40, refs=1)) + "\n") + f.write(json.dumps(dict(id=v + "_day_t2", status=200, secs=38, refs=2)) + "\n") + run("cost.py", ledger, "--config", C) + picks = {v: dict(day=v + "_day_t1") for v in views} + json.dump(picks, open(os.path.join(wd, "picks.json"), "w")) + run("qc_sheet.py", "--config", C, "--picks", os.path.join(wd, "picks.json"), "--gates", + os.path.join(out, "qc", "gate_out_day.json"), "--frames", out, "--out", os.path.join(wd, "qc_plates.jpg")) + run("matrix_jobs.py", "weather", "--config", C, "--prompts", os.path.join(wd, "prompts.json"), "--tier", "1", + "S_street=" + os.path.join(out, "S_street_day_t1.png"), "--out", os.path.join(wd, "jobs_matrix.json")) + run("matrix_jobs.py", "population", "--config", C, "--prompts", os.path.join(wd, "prompts.json"), "--tier", "2", + "S_street=" + os.path.join(out, "S_street_day_t1.png"), "--out", os.path.join(wd, "jobs_pop.json")) + print("SMOKE TEST PASSED in", wd) + + +if __name__ == "__main__": + main()