Delete analysis/camera_map_skill

analysis/camera_map_skill/SKILL.md

@@ -1,83 +0,0 @@
----
-name: camera-map-gallery
-description: >
-  Build an interactive camera-map review gallery for a Camera dataset and
-  compose a final collage. Invoke when the user gives a command shaped like
-  "<dataset> + (A, B) + C [+ W:H]" (e.g. "ImageNet-1K + (80, 30) + 40 + 4:3"),
-  or asks to visualize/gallery/collage predicted camera parameters (up field /
-  latitude field) with a web review step.
----
-
-# Camera-Map Gallery & Collage
-
-## Command format
-```
-<dataset> + (A, B) + C [+ W:H]
-```
-- `dataset` — which Camera dataset (picks HF caption repo + source-image repo)
-- `A` — # large-offset samples (farthest-point sampling over roll/pitch/fov)
-- `B` — # random samples (no camera-param range restriction)
-- `C` — # panels in the final collage (dynamic: pick ~C from the kept results)
-- `W:H` — collage aspect ratio, default `4:3`
-
-## Pipeline (run in the puffin env, cwd = repo root, `PYTHONPATH=./`)
-Env: `/data/NTU_slab/kliao/envs/puffin/bin/python`
-
-1. **Review page** — `build_review.py --n_diverse A --n_random B`
-   Samples A diverse + B random camera params, matches source images, renders
-   each as `up | latitude` (native aspect, NO padding, NO text), writes a
-   self-contained interactive HTML to `output/gallery_review.html`
-   (index badges + per-sample "剔除" checkbox + submit -> `EXCLUDE=[...]` code).
-   Persists `output/gallery_picks.json` (ordered val ids + params) and
-   `output/gallery_panels/`.
-2. **Publish link** — upload `output/gallery_review.html` as `index.html` to a
-   HF **static Space** (`KangLiao/imagenet-camera-review`); give the user the
-   public URL. They review, submit, and paste back the `EXCLUDE=[...]` code.
-3. **Collage** — `make_collage.py --exclude "3,9,..." --n_collage C
-   --target_w 3600 --ratio W:H --out output/<dataset>_camera_map_collage.png`
-   Drops excluded, dynamically takes ~C by aspect spread, renders no-pad panels,
-   composes a **balanced-rows** collage at exactly W:H (filled, no whitespace,
-   no black frames), then upload to the dataset's HF Camera repo under
-   `analysis/`.
-
-## Field computation (reused, do NOT reinvent)
-`gallery_lib.compute_fields(roll,pitch,vfov,k1)` -> up (2,H,W) + latitude (1,H,W)
-via `scripts/camera` geometry (SimpleRadial + Gravity + get_perspective_field),
-same pipeline as `scripts/camera/cam_dataset_debug.py`. No-pad render crops the
-640x640 field back to the un-padded region so it aligns with the native image.
-
-## Per-dataset sources
-| dataset | caption repo | source images |
-|---------|--------------|----------------|
-| ImageNet-1K | KangLiao/ImageNet-1K-Camera | ILSVRC/imagenet-1k (val, match by filename) |
-| COCO | KangLiao/COCO-Camera | detection-datasets/coco (embedded) |
-| CC12M / Megalith | KangLiao/{CC12M,Megalith-10M}-Camera | `url` field in each caption json |
-| gpic | (tbd) | local tar shards |
-
-`gallery_lib.py` currently implements the ImageNet-1K loaders; other datasets
-reuse the same select_diverse / prep_image / compute_fields, swap the two
-loaders (caption repo + source fetch).
-
-## Notes
-- Diversity uses farthest-point sampling so orientations span the full range.
-- The whole review page is client-side (static Space = no backend), so the
-  user's selection only comes back via the copyable `EXCLUDE=[...]` code.
-- `gallery_picks.json` lets the collage be reproduced exactly from that code.
-
-## Running elsewhere / adding DL3DV
-Portable: put `gallery_lib.py`, `build_review.py`, `make_collage.py` together and
-run `build_review.py` / `make_collage.py` with the Puffin repo on `PYTHONPATH`
-(they need `scripts/camera/*` for the field geometry). Pick the dataset with the
-env var `GALLERY_DATASET`.
-
-To add **DL3DV** (images on AOSS, GT camera captions on disk), add two loaders in
-`gallery_lib.py` and a `"dl3dv"` dispatch entry — mirror the existing ones:
-- `_cap_dl3dv()` → read `<camera_caption_root>/<scene>/dense/camera/frame_XXXXX.json`
-  (roll/pitch/vfov/k1); key = `"<scene>/<frame>"`.
-- `_src_dl3dv()` → read the RGB frame from AOSS
-  (`<ROOT>/<scene>/dense/rgb/frame_XXXXX.png`) via `aoss_client` /
-  `src/dust3r/oss_file_client.FileClient` (needs `~/aoss.conf`). To avoid the big
-  `cache_path` index, list/select scenes directly, then fetch only the picked
-  frames' RGB by key (no full-dataset indexing needed).
-Config reference: `configs/datasets/multi_view/gen_dl3dv.py`
-(`ROOT` = aoss s3 prefix, `camera_caption_root` = GT captions).

analysis/camera_map_skill/build_review.py

@@ -1,183 +0,0 @@
-"""Interactive review page (v2) for the ImageNet camera-map gallery.
-
-100 samples = 80 diverse (farthest-point in roll/pitch/fov) + 20 uniformly
-random (no range restriction). Each panel shows [up | latitude] (no text) with a
-visible index badge and an "exclude" checkbox. Submit -> composes the kept panels
-into a final gallery (no text, downloadable) AND prints a copyable EXCLUDE code.
-
-Also persists the panels (output/gallery_panels/panel_XXX.png) and the ordered
-sample list (output/gallery_picks.json) so the final gallery can be reproduced
-server-side from the user's EXCLUDE code and uploaded to HF.
-"""
-import base64
-import io
-import json
-import os
-import random
-import sys
-
-import numpy as np
-from PIL import Image
-
-import os as _os; sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
-import gallery_lib as G
-
-import argparse
-_ap = argparse.ArgumentParser()
-_ap.add_argument("--n_diverse", type=int, default=80)
-_ap.add_argument("--n_random", type=int, default=20)
-_args, _ = _ap.parse_known_args()
-N_DIVERSE = _args.n_diverse
-N_RANDOM = _args.n_random
-NCOLS_FINAL = 4
-ROOT = "/data/NTU_slab/kliao/code/Puffin_Final/Puffin2/output"
-PANEL_DIR = os.path.join(ROOT, "gallery_panels")
-PICKS_JSON = os.path.join(ROOT, "gallery_picks.json")
-OUT_HTML = os.path.join(ROOT, "gallery_review.html")
-
-
-def render_pair_notext(img640, up_field, lat_field, panel_px=340):
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-    from scripts.camera.visualization.viz2d import plot_vector_fields, plot_latitudes
-    imnp = np.asarray(img640).astype(np.float32) / 255.0
-    fig, axes = plt.subplots(1, 2, figsize=(2 * panel_px / 100, panel_px / 100), dpi=100)
-    for ax in axes:
-        ax.imshow(imnp); ax.set_axis_off()
-        ax.set_xlim([0, 640]); ax.set_ylim([640, 0])
-    plot_vector_fields([up_field], axes=[axes[0]])
-    plot_latitudes([lat_field[0] * G.DEG], is_radians=False, axes=[axes[1]])
-    fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0.01)
-    fig.canvas.draw()
-    buf = np.asarray(fig.canvas.buffer_rgba())[..., :3].copy()
-    plt.close(fig)
-    return buf
-
-
-def b64jpg(arr, q=85):
-    im = Image.fromarray(arr); b = io.BytesIO(); im.save(b, "JPEG", quality=q)
-    return base64.b64encode(b.getvalue()).decode()
-
-
-def main():
-    print("loading captions ..."); caps = G.load_captions()
-    if os.environ.get("GALLERY_DATASET") == "megalith":
-        # url mode: select from captions, then download only the picks (with
-        # oversampling to tolerate dead Flickr links).
-        from concurrent.futures import ThreadPoolExecutor
-        cand = caps
-        div_pool = G.select_diverse(cand, min(len(cand), N_DIVERSE * 2))
-        rest = [k for k in cand if k not in set(div_pool)]
-        random.seed(1234)
-        rnd_pool = random.sample(rest, min(len(rest), N_RANDOM * 3))
-        imgs, picks, kinds = {}, [], []
-        _f = lambda k: (k, G.fetch_url(cand[k]["url"]))
-        with ThreadPoolExecutor(max_workers=32) as ex:
-            for k, b in ex.map(_f, div_pool):
-                if b:
-                    imgs[k] = b; picks.append(k); kinds.append("diverse")
-                    if kinds.count("diverse") >= N_DIVERSE: break
-            for k, b in ex.map(_f, rnd_pool):
-                if b:
-                    imgs[k] = b; picks.append(k); kinds.append("random")
-                    if kinds.count("random") >= N_RANDOM: break
-        print(f"picks: {len(picks)} ({kinds.count('diverse')} div + {kinds.count('random')} rnd, downloaded)")
-    else:
-        print("loading source images ..."); imgs = G.load_source_images(8)
-        cand = {k: caps[k] for k in caps if k in imgs}
-        print(f"candidates: {len(cand)}")
-        diverse = G.select_diverse(cand, N_DIVERSE)
-        rest = [k for k in cand if k not in set(diverse)]
-        random.seed(1234)
-        rnd = random.sample(rest, N_RANDOM)
-        picks = diverse + rnd
-        kinds = ["diverse"] * len(diverse) + ["random"] * len(rnd)
-        print(f"picks: {len(picks)} ({len(diverse)} diverse + {len(rnd)} random)")
-
-    os.makedirs(PANEL_DIR, exist_ok=True)
-    b64s, meta = [], []
-    for i, k in enumerate(picks):
-        pr = cand[k]
-        pil = Image.open(io.BytesIO(imgs[k])).convert("RGB")
-        img640 = G.prep_image(pil)
-        up, lat = G.compute_fields(pr["roll"], pr["pitch"], pr["vfov"], pr["k1"])
-        arr = render_pair_notext(img640, up, lat)
-        Image.fromarray(arr).save(os.path.join(PANEL_DIR, f"panel_{i:03d}.png"))
-        b64s.append(b64jpg(arr))
-        meta.append({"idx": i, "val": k, "kind": kinds[i], "url": pr.get("url"),
-                     "roll": pr["roll"], "pitch": pr["pitch"], "vfov": pr["vfov"]})
-        if (i + 1) % 25 == 0:
-            print(f"  {i+1}/{len(picks)}")
-    json.dump(meta, open(PICKS_JSON, "w"))
-    print("saved picks ->", PICKS_JSON, "panels ->", PANEL_DIR)
-
-    cells = "\n".join(
-        f'<div class="cell" id="c{i}"><div class="idx">#{i}'
-        f'{" · rand" if kinds[i]=="random" else ""}</div>'
-        f'<img class="pan" data-idx="{i}" src="data:image/jpeg;base64,{b}">'
-        f'<label class="ex"><input type="checkbox" class="excl" data-idx="{i}"> 剔除</label></div>'
-        for i, b in enumerate(b64s))
-
-    html = f"""<!doctype html><html lang="zh"><head><meta charset="utf-8">
-<title>ImageNet Camera-Map Review</title><style>
- body{{font-family:system-ui,Arial,sans-serif;margin:16px;background:#f5f6f8;color:#222}}
- h2{{margin:6px 0}} .hint{{color:#555;margin-bottom:8px;font-size:14px}}
- #grid{{display:grid;grid-template-columns:repeat(2,1fr);gap:14px}}
- .cell{{position:relative;background:#fff;border:1px solid #e2e4e8;border-radius:8px;
-   padding:8px;display:flex;align-items:center;gap:10px}}
- .cell img{{width:100%;max-width:680px;border-radius:6px;display:block}}
- .idx{{position:absolute;top:10px;left:10px;background:rgba(0,0,0,.6);color:#fff;
-   font-size:12px;padding:1px 6px;border-radius:5px}}
- .ex{{white-space:nowrap;font-size:15px;user-select:none}}
- .cell.dropped{{opacity:.35;outline:2px solid #e05353}}
- .bar{{position:sticky;top:0;background:#f5f6f8;padding:10px 0;z-index:5;border-bottom:1px solid #ddd}}
- button{{font-size:16px;padding:8px 18px;border-radius:8px;border:0;background:#2d6cdf;color:#fff;cursor:pointer}}
- textarea{{width:100%;height:60px;font-family:monospace;font-size:13px;margin-top:8px}}
- #result{{margin-top:16px}} #result img{{max-width:100%;border:1px solid #ccc}}
-</style></head><body>
-<div class="bar">
- <h2>ImageNet-1K 相机地图审核（共 {len(b64s)} 个 = 80 多样 + 20 随机）</h2>
- <div class="hint">勾选「剔除」以移除该样本；左=up field，右=latitude field；标 rand 的是随机样本。
- 点提交后：下方给出①最终 gallery 下载 ②可复制的剔除代码——把代码贴给对方即可。</div>
- <button onclick="compose()">提交（生成最终 gallery + 剔除代码）</button>
- <span id="cnt"></span>
-</div>
-<div id="grid">
-{cells}
-</div>
-<div id="result"></div>
-<script>
-const TOTAL={len(b64s)}, NCOLS={NCOLS_FINAL};
-document.querySelectorAll('.excl').forEach(cb=>cb.addEventListener('change',e=>{{
-  e.target.closest('.cell').classList.toggle('dropped',e.target.checked); upd();}}));
-function upd(){{const ex=[...document.querySelectorAll('.excl')].filter(c=>c.checked).length;
-  document.getElementById('cnt').textContent='  已剔除 '+ex+' / 保留 '+(TOTAL-ex);}}
-upd();
-function compose(){{
-  const excl=[...document.querySelectorAll('.excl')].filter(c=>c.checked).map(c=>+c.dataset.idx).sort((a,b)=>a-b);
-  const kept=[...document.querySelectorAll('.pan')].filter(img=>!excl.includes(+img.dataset.idx));
-  if(!kept.length){{alert('全部被剔除了');return;}}
-  const pw=kept[0].naturalWidth, ph=kept[0].naturalHeight, gap=10;
-  const rows=Math.ceil(kept.length/NCOLS), W=NCOLS*pw+(NCOLS+1)*gap, H=rows*ph+(rows+1)*gap;
-  const cv=document.createElement('canvas'); cv.width=W; cv.height=H;
-  const ctx=cv.getContext('2d'); ctx.fillStyle='#f5f6f8'; ctx.fillRect(0,0,W,H);
-  kept.forEach((img,k)=>{{const r=Math.floor(k/NCOLS),c=k%NCOLS;
-    ctx.drawImage(img,gap+c*(pw+gap),gap+r*(ph+gap),pw,ph);}});
-  const url=cv.toDataURL('image/png');
-  const code='EXCLUDE='+JSON.stringify(excl);
-  document.getElementById('result').innerHTML=
-    '<h3>最终 gallery：保留 '+kept.length+' 个（剔除 '+excl.length+'）</h3>'+
-    '<b>把下面这行剔除代码复制发给对方：</b>'+
-    '<textarea readonly onclick="this.select()">'+code+'</textarea>'+
-    '<a download="imagenet_camera_gallery_final.png" href="'+url+'">⬇ 下载最终 gallery PNG</a><br><br>'+
-    '<img src="'+url+'">';
-  document.getElementById('result').scrollIntoView({{behavior:'smooth'}});
-}}
-</script></body></html>"""
-    open(OUT_HTML, "w", encoding="utf-8").write(html)
-    print("wrote", OUT_HTML, f"({len(html)/1e6:.1f} MB)")
-
-
-if __name__ == "__main__":
-    main()

analysis/camera_map_skill/gallery_lib.py

@@ -1,294 +0,0 @@
-"""Camera-map gallery for ImageNet-1K-Camera.
-
-For N diverse samples: take the predicted (roll,pitch,vfov,k1) from
-KangLiao/ImageNet-1K-Camera (val split), fetch the matching source image from
-ILSVRC/imagenet-1k (val parquets), compute the up-field & latitude-field
-(perspective fields, same as scripts/camera/cam_dataset_debug.py) and render
-them overlaid on the image, side by side. All samples are tiled into one
-gallery PNG.
-"""
-import argparse
-import io
-import json
-import os
-import re
-import tarfile
-
-import numpy as np
-import torch
-from PIL import Image, ImageDraw, ImageFont
-
-import matplotlib
-matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-
-from huggingface_hub import hf_hub_download
-import pyarrow.parquet as pq
-
-from scripts.camera.geometry.camera import SimpleRadial
-from scripts.camera.geometry.gravity import Gravity
-from scripts.camera.geometry.perspective_fields import get_perspective_field
-from scripts.camera.utils.conversions import fov2focal
-from scripts.camera.visualization.viz2d import plot_vector_fields, plot_latitudes
-
-CACHE = "/tmp/gallery"
-DEG = 180.0 / np.pi
-DATASET = os.environ.get("GALLERY_DATASET", "imagenet")
-
-
-# ---- ImageNet (val split; key = ILSVRC val number) --------------------------
-def _cap_imagenet():
-    p = hf_hub_download("KangLiao/ImageNet-1K-Camera", "val.tar", repo_type="dataset",
-                        local_dir=os.path.join(CACHE, "in_cap"))
-    caps = {}
-    with tarfile.open(p) as t:
-        for m in t.getmembers():
-            if m.name.endswith(".json"):
-                d = json.loads(t.extractfile(m).read())
-                num = re.search(r"val_(\d+)", m.name)
-                if num and d.get("parse_ok", False):
-                    caps[int(num.group(1))] = d
-    return caps
-
-
-def _src_imagenet(n_parquets):
-    imgs = {}
-    for i in range(n_parquets):
-        p = hf_hub_download("ILSVRC/imagenet-1k", f"data/validation-{i:05d}-of-00014.parquet",
-                            repo_type="dataset", local_dir=os.path.join(CACHE, "in_src"))
-        pf = pq.ParquetFile(p)
-        for rg in range(pf.num_row_groups):
-            for img in pf.read_row_group(rg, columns=["image"]).to_pydict()["image"]:
-                num = re.search(r"val_(\d+)", img["path"])
-                if num and img.get("bytes"):
-                    imgs[int(num.group(1))] = img["bytes"]
-    return imgs
-
-
-# ---- COCO (val split; key = COCO image_id) ----------------------------------
-def _cap_coco():
-    from huggingface_hub import HfApi
-    caps = {}
-    for f in [x for x in HfApi().list_repo_files("KangLiao/COCO-Camera", repo_type="dataset")
-              if "coco_val_" in x and x.endswith(".tar")]:
-        p = hf_hub_download("KangLiao/COCO-Camera", f, repo_type="dataset",
-                            local_dir=os.path.join(CACHE, "coco_cap"))
-        with tarfile.open(p) as t:
-            for m in t.getmembers():
-                if m.name.endswith(".json"):
-                    d = json.loads(t.extractfile(m).read())
-                    if d.get("parse_ok", False):
-                        caps[int(os.path.basename(m.name)[:-5])] = d
-    return caps
-
-
-def _src_coco(n_parquets):
-    from huggingface_hub import HfApi
-    vals = sorted(x for x in HfApi().list_repo_files("detection-datasets/coco", repo_type="dataset")
-                  if os.path.basename(x).startswith("val-") and x.endswith(".parquet"))
-    imgs = {}
-    for f in vals[:max(n_parquets, 2)]:
-        p = hf_hub_download("detection-datasets/coco", f, repo_type="dataset",
-                            local_dir=os.path.join(CACHE, "coco_src"))
-        pf = pq.ParquetFile(p)
-        for rg in range(pf.num_row_groups):
-            t = pf.read_row_group(rg, columns=["image_id", "image"]).to_pydict()
-            for iid, img in zip(t["image_id"], t["image"]):
-                if img.get("bytes"):
-                    imgs[int(iid)] = img["bytes"]
-    return imgs
-
-
-# ---- CC12M (key = "<shard>/<index>"; source = pixparse/cc12m-wds) -----------
-CC12M_SHARDS = list(range(6))   # which shards to sample from (limits download)
-
-
-def _cap_cc12m():
-    caps = {}
-    for s in CC12M_SHARDS:
-        p = hf_hub_download("KangLiao/CC12M-Camera", f"{s:04d}.tar", repo_type="dataset",
-                            local_dir=os.path.join(CACHE, "cc12m_cap"))
-        with tarfile.open(p) as t:
-            for m in t.getmembers():
-                if m.name.endswith(".json"):
-                    d = json.loads(t.extractfile(m).read())
-                    if d.get("parse_ok", False):
-                        caps[f"{s:04d}/{os.path.basename(m.name)[:-5]}"] = d
-    return caps
-
-
-def _src_cc12m(_n):
-    imgs = {}
-    for s in CC12M_SHARDS:
-        p = hf_hub_download("pixparse/cc12m-wds", f"cc12m-train-{s:04d}.tar", repo_type="dataset",
-                            local_dir=os.path.join(CACHE, "cc12m_src"))
-        with tarfile.open(p) as t:
-            for m in t.getmembers():
-                if m.name.endswith(".jpg"):
-                    imgs[f"{s:04d}/{os.path.basename(m.name)[:-4]}"] = t.extractfile(m).read()
-    return imgs
-
-
-# ---- Megalith (caption carries `url`; source fetched from that url) ---------
-MEGALITH_SHARDS = list(range(6))
-
-
-def _cap_megalith():
-    caps = {}
-    for s in MEGALITH_SHARDS:
-        p = hf_hub_download("KangLiao/Megalith-10M-Camera", f"{s:05d}.tar", repo_type="dataset",
-                            local_dir=os.path.join(CACHE, "mega_cap"))
-        with tarfile.open(p) as t:
-            for m in t.getmembers():
-                if m.name.endswith(".json"):
-                    d = json.loads(t.extractfile(m).read())
-                    if d.get("parse_ok", False) and d.get("url"):
-                        caps[f"{s:05d}/{os.path.basename(m.name)[:-5]}"] = d
-    return caps
-
-
-def fetch_url(url, timeout=12):
-    """Download bytes from a URL, bypassing the (flaky) env proxy. None on fail."""
-    import requests
-    try:
-        r = requests.get(url, timeout=timeout, proxies={"http": None, "https": None})
-        r.raise_for_status()
-        return r.content
-    except Exception:
-        return None
-
-
-def load_captions():
-    return {"coco": _cap_coco, "cc12m": _cap_cc12m,
-            "megalith": _cap_megalith}.get(DATASET, _cap_imagenet)()
-
-
-def load_source_images(n_parquets):
-    # megalith fetches per-selected-sample via fetch_url (handled by callers)
-    return {"coco": _src_coco, "cc12m": _src_cc12m}.get(DATASET, _src_imagenet)(n_parquets)
-
-
-def select_diverse(candidates, n):
-    """Farthest-point sampling in (roll,pitch,vfov) degree space -> diversity,
-    guaranteed to include non-trivial (non-zero) roll/pitch/fov extremes."""
-    keys = list(candidates)
-    X = np.array([[candidates[k]["roll"] * DEG, candidates[k]["pitch"] * DEG,
-                   candidates[k]["vfov"] * DEG] for k in keys], dtype=np.float64)
-    Xn = (X - X.mean(0)) / (X.std(0) + 1e-6)
-    # seed: the most extreme sample (largest deviation from mean)
-    seed = int(np.argmax((Xn ** 2).sum(1)))
-    chosen = [seed]
-    d = np.linalg.norm(Xn - Xn[seed], axis=1)
-    while len(chosen) < min(n, len(keys)):
-        nxt = int(np.argmax(d))
-        chosen.append(nxt)
-        d = np.minimum(d, np.linalg.norm(Xn - Xn[nxt], axis=1))
-    return [keys[i] for i in chosen]
-
-
-def prep_image(pil, size=640):
-    w, h = pil.size
-    if w >= h:
-        nw, nh = size, max(1, round(h * size / w))
-    else:
-        nh, nw = size, max(1, round(w * size / h))
-    pil = pil.resize((nw, nh))
-    canvas = Image.new("RGB", (size, size), (0, 0, 0))
-    canvas.paste(pil, ((size - nw) // 2, (size - nh) // 2))
-    return canvas
-
-
-def compute_fields(roll, pitch, vfov, k1, h=640, w=640):
-    f = fov2focal(torch.tensor(float(vfov)), h)
-    params = torch.tensor([w, h, float(f), float(f), w / 2, h / 2, float(k1), 0]).float()
-    cam = SimpleRadial(params).float()
-    grav = Gravity.from_rp(torch.tensor(float(roll)), torch.tensor(float(pitch)))
-    up, lat = get_perspective_field(cam, grav, use_up=True, use_latitude=True)
-    return up[0], lat[0]  # up (2,H,W), lat (1,H,W)
-
-
-def render_pair(img640, up_field, lat_field, panel_px=380):
-    """One sample -> a [up | lat] RGB image (numpy)."""
-    imnp = np.asarray(img640).astype(np.float32) / 255.0
-    fig, axes = plt.subplots(1, 2, figsize=(2 * panel_px / 100, panel_px / 100), dpi=100)
-    for ax in axes:
-        ax.imshow(imnp)
-        ax.set_axis_off()
-        ax.set_xlim([0, 640]); ax.set_ylim([640, 0])
-    plot_vector_fields([up_field], axes=[axes[0]])
-    lat_deg = (lat_field[0] * DEG)
-    plot_latitudes([lat_deg], is_radians=False, axes=[axes[1]])
-    axes[0].set_title("up field", fontsize=11)
-    axes[1].set_title("latitude field", fontsize=11)
-    fig.subplots_adjust(left=0, right=1, top=0.93, bottom=0, wspace=0.02)
-    fig.canvas.draw()
-    buf = np.asarray(fig.canvas.buffer_rgba())[..., :3].copy()
-    plt.close(fig)
-    return buf
-
-
-def build_gallery(panels, params, ncols, out_path):
-    ph, pw = panels[0].shape[:2]
-    gap, top = 16, 90
-    cap_h = 30
-    cell_h = ph + cap_h
-    nrows = (len(panels) + ncols - 1) // ncols
-    W = ncols * pw + (ncols + 1) * gap
-    H = top + nrows * (cell_h + gap) + gap
-    canvas = Image.new("RGB", (W, H), (245, 246, 248))
-    draw = ImageDraw.Draw(canvas)
-    try:
-        ft = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 40)
-        fs = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 16)
-    except Exception:
-        ft = ImageFont.load_default(); fs = ImageFont.load_default()
-    draw.text((gap, 26), "ImageNet-1K-Camera — Camera-Map Gallery (up & latitude fields)",
-              fill=(30, 30, 40), font=ft)
-    for i, (pan, pr) in enumerate(zip(panels, params)):
-        r, c = divmod(i, ncols)
-        x = gap + c * (pw + gap)
-        y = top + r * (cell_h + gap)
-        canvas.paste(Image.fromarray(pan), (x, y))
-        txt = (f"roll {pr['roll']*DEG:+.1f}°  pitch {pr['pitch']*DEG:+.1f}°  "
-               f"fov {pr['vfov']*DEG:.1f}°")
-        draw.text((x + 6, y + ph + 6), txt, fill=(60, 60, 70), font=fs)
-    canvas.save(out_path)
-    print("saved gallery ->", out_path, canvas.size)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--n", type=int, default=50)
-    ap.add_argument("--ncols", type=int, default=5)
-    ap.add_argument("--parquets", type=int, default=6)
-    ap.add_argument("--out", default="output/imagenet1k_camera_map_gallery.png")
-    args = ap.parse_args()
-
-    print("loading captions ..."); caps = load_captions()
-    print("loading source images ..."); imgs = load_source_images(args.parquets)
-    cand = {k: caps[k] for k in caps if k in imgs}
-    print(f"candidates with both caption+image: {len(cand)}")
-    picks = select_diverse(cand, args.n)
-    print(f"selected {len(picks)} diverse samples")
-
-    panels, params = [], []
-    for k in picks:
-        pr = cand[k]
-        pil = Image.open(io.BytesIO(imgs[k])).convert("RGB")
-        img640 = prep_image(pil)
-        up, lat = compute_fields(pr["roll"], pr["pitch"], pr["vfov"], pr["k1"])
-        panels.append(render_pair(img640, up, lat))
-        params.append(pr)
-    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
-    build_gallery(panels, params, args.ncols, args.out)
-    # report the diversity actually achieved
-    rs = np.array([p["roll"] * DEG for p in params])
-    ps = np.array([p["pitch"] * DEG for p in params])
-    vs = np.array([p["vfov"] * DEG for p in params])
-    print(f"roll  range [{rs.min():.1f},{rs.max():.1f}] std {rs.std():.1f}")
-    print(f"pitch range [{ps.min():.1f},{ps.max():.1f}] std {ps.std():.1f}")
-    print(f"fov   range [{vs.min():.1f},{vs.max():.1f}] std {vs.std():.1f}")
-
-
-if __name__ == "__main__":
-    main()

analysis/camera_map_skill/make_collage.py

@@ -1,163 +0,0 @@
-"""Compose the final camera-map collage from the kept samples (after web review).
-
-- NO padding: each image keeps its native aspect ratio (no black frame). The
-  perspective field is computed on the 640x640 model view, then CROPPED back to
-  the un-padded region so it aligns with the native-aspect image.
-- Justified-rows layout (flexbox-style photo collage): each row is scaled to the
-  same width; row heights vary slightly. Beautiful, gap-only, no black frames.
-"""
-import argparse
-import io
-import json
-import os
-import sys
-
-import numpy as np
-from PIL import Image
-
-import os as _os; sys.path.insert(0, _os.path.dirname(_os.path.abspath(__file__)))
-import gallery_lib as G
-
-ROOT = "/data/NTU_slab/kliao/code/Puffin_Final/Puffin2/output"
-PICKS = os.path.join(ROOT, "gallery_picks.json")
-
-
-def render_nopad(pil, roll, pitch, vfov, k1, panel_h=340, sep=6):
-    """Return an RGB array [up | lat] at native aspect, no padding."""
-    import matplotlib
-    matplotlib.use("Agg")
-    import matplotlib.pyplot as plt
-    from scripts.camera.visualization.viz2d import plot_vector_fields, plot_latitudes
-    w, h = pil.size
-    if w >= h:
-        nw, nh = 640, max(1, round(h * 640 / w))
-    else:
-        nh, nw = 640, max(1, round(w * 640 / h))
-    img = np.asarray(pil.resize((nw, nh))).astype(np.float32) / 255.0
-    up, lat = G.compute_fields(roll, pitch, vfov, k1, h=640, w=640)
-    y0, x0 = (640 - nh) // 2, (640 - nw) // 2
-    up_c = up[:, y0:y0 + nh, x0:x0 + nw]
-    lat_c = lat[:, y0:y0 + nh, x0:x0 + nw]
-
-    def one(overlay):
-        fig = plt.figure(figsize=(nw / 100, nh / 100), dpi=100)
-        ax = fig.add_axes([0, 0, 1, 1]); ax.set_axis_off()
-        ax.imshow(img); ax.set_xlim([0, nw]); ax.set_ylim([nh, 0])
-        overlay(ax)
-        fig.canvas.draw()
-        a = np.asarray(fig.canvas.buffer_rgba())[..., :3].copy()
-        plt.close(fig)
-        return a
-    up_img = one(lambda ax: plot_vector_fields([up_c], axes=[ax]))
-    lat_img = one(lambda ax: plot_latitudes([lat_c[0] * G.DEG], is_radians=False, axes=[ax]))
-    H = min(up_img.shape[0], lat_img.shape[0])
-    pair = np.concatenate([up_img[:H], 255 * np.ones((H, sep, 3), np.uint8), lat_img[:H]], axis=1)
-    im = Image.fromarray(pair)
-    scale = panel_h / im.height
-    return im.resize((max(1, round(im.width * scale)), panel_h))
-
-
-def _layout(items, W, h0, gap):
-    """Greedy justified rows at width W using target row height h0.
-    Returns (rows, row_heights, total_height)."""
-    rows, cur, cw = [], [], 0.0
-    for im in items:
-        w = h0 * im.width / im.height
-        if cur and cw + gap + w > W:
-            rows.append(cur); cur, cw = [], 0.0
-        cur.append(im); cw += (gap if len(cur) > 1 else 0) + w
-    if cur:
-        rows.append(cur)
-    heights = [(W - gap * (len(r) + 1)) / sum(im.width / im.height for im in r) for r in rows]
-    return rows, heights, sum(heights) + gap * (len(rows) + 1)
-
-
-def _balanced_rows(items, R):
-    """Partition items into R contiguous rows with ~equal total aspect ratio, so
-    every row is packed to a similar height (no sparse, stretched last row)."""
-    asp = [im.width / im.height for im in items]
-    cum, s = [], 0.0
-    for a in asp:
-        s += a; cum.append(s)
-    total = cum[-1]
-    rows, start = [], 0
-    for i in range(1, R):
-        thr = total * i / R
-        j = min(range(start, len(items)), key=lambda k: abs(cum[k] - thr))
-        j = max(j, start)                     # non-empty
-        rows.append(items[start:j + 1]); start = j + 1
-        if start >= len(items):
-            break
-    if start < len(items):
-        rows.append(items[start:])
-    return [r for r in rows if r]
-
-
-def aspect_collage(items, W=3600, ratio=(4, 3), gap=10, bg=(245, 246, 248)):
-    """Collage at target aspect W:H = ratio[0]:ratio[1] using BALANCED rows
-    (each row ~equal total aspect -> uniform heights, no giant single-item row).
-    R = round(sqrt(Ht*sum_aspect/W)); layout height ~= Ht, tiny overflow cropped."""
-    Ht = int(round(W * ratio[1] / ratio[0]))
-    total_asp = sum(im.width / im.height for im in items)
-    R = max(1, round((Ht * total_asp / W) ** 0.5))
-    rows = _balanced_rows(items, R)
-    heights = [(W - gap * (len(r) + 1)) / sum(im.width / im.height for im in r) for r in rows]
-    Hlay = int(sum(heights) + gap * (len(rows) + 1))
-    canvas = Image.new("RGB", (W, max(Hlay, Ht) + 2), bg)
-    y = gap
-    for row, h in zip(rows, heights):
-        h = int(round(h)); x = gap
-        for im in row:
-            w = max(1, round(h * im.width / im.height))
-            canvas.paste(im.resize((w, h)), (x, y))
-            x += w + gap
-        y += h + gap
-    return canvas.crop((0, 0, W, Ht))
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--exclude", default="", help="comma-separated indices to drop")
-    ap.add_argument("--n_show", type=int, default=0, help="render only first N picks (0=all kept)")
-    ap.add_argument("--n_collage", type=int, default=0, help="use N panels for collage (0=all)")
-    ap.add_argument("--out", default=os.path.join(ROOT, "imagenet1k_camera_map_gallery.png"))
-    ap.add_argument("--target_w", type=int, default=3400)
-    ap.add_argument("--ratio", default="4:3", help='collage aspect W:H, e.g. 4:3, 1:1, 16:9')
-    args = ap.parse_args()
-    rw, rh = (int(x) for x in args.ratio.split(":"))
-
-    excl = set(int(x) for x in args.exclude.split(",") if x.strip() != "")
-    meta = [m for m in json.load(open(PICKS)) if m["idx"] not in excl]
-    if args.n_show:
-        meta = meta[:args.n_show]
-    print(f"rendering {len(meta)} panels ...")
-
-    mega = os.environ.get("GALLERY_DATASET") == "megalith"
-    imgs = {} if mega else (print("loading source images ...") or G.load_source_images(8))
-    items = []
-    for m in meta:
-        b = G.fetch_url(m["url"]) if mega else imgs.get(m["val"])
-        if not b:
-            continue
-        try:
-            pil = Image.open(io.BytesIO(b)).convert("RGB")
-        except Exception:
-            continue
-        items.append(render_nopad(pil, m["roll"], m["pitch"], m["vfov"], 0.0))
-    print(f"rendered {len(items)} panels")
-
-    # optionally pick N_collage of them spread across aspect ratio for variety
-    if args.n_collage and args.n_collage < len(items):
-        order = sorted(range(len(items)), key=lambda i: items[i].width / items[i].height)
-        step = len(order) / args.n_collage
-        sel = sorted(order[int(k * step)] for k in range(args.n_collage))
-        items = [items[i] for i in sel]
-        print(f"selected {len(items)} for collage (aspect-spread)")
-
-    col = aspect_collage(items, W=args.target_w, ratio=(rw, rh))
-    col.save(args.out)
-    print("saved collage ->", args.out, col.size)
-
-
-if __name__ == "__main__":
-    main()