Upload analysis/camera_map_skill/make_collage.py with huggingface_hub

analysis/camera_map_skill/make_collage.py

@@ -0,0 +1,163 @@
+"""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()