| """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) |
| 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") |
|
|
| |
| 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() |
|
|
