File size: 6,722 Bytes
0b5a123 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | """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()
|