File size: 6,583 Bytes
b0420b5 | 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 | #!/usr/bin/env python
"""Re-project the 3D point tracks of one sample onto every camera view.
Works for DROID-VP, LIBERO-VP and RoboCasa-VP samples, i.e. any directory that holds
`meta.json`, `view*.mp4` / `ego.mp4` and `robot.npz` / `gripper.npz` / `object*.npz`.
Only the calibration stored in `meta.json` is used, so the output is a direct check of
calibration <-> track consistency.
python visualize_sample.py <sample_dir> --out vis.mp4 [--frame-png vis.png]
Dependencies: numpy, opencv-python.
"""
import argparse
import glob
import json
import os
import sys
import cv2
import numpy as np
def view_order(name):
if name.startswith("view") and name[4:].isdigit():
return (0, int(name[4:]))
return (1, name)
def load_views(sample_dir, meta, max_views):
views = []
for name in sorted(meta["views"], key=view_order):
v = meta["views"][name]
path = os.path.join(sample_dir, f"{name}.mp4")
if not os.path.isfile(path):
continue
intr = v["intrinsics"]
K = np.array([[intr["fx"], 0, intr["cx"]], [0, intr["fy"], intr["cy"]], [0, 0, 1]], np.float64)
dist = np.array([intr.get(k, 0.0) for k in ("k1", "k2", "p1", "p2", "k3")], np.float64)
# per-frame extrinsics when the camera moves (RoboCasa mobile base, wrist cameras)
T = np.asarray(v.get("T_cam_world_perframe", v["T_cam_world"]), np.float64)
if T.ndim == 3 and len(T) != meta["n_frames"]:
# RoboCasa-VP subtask clips keep the parent episode's per-frame base-camera
# extrinsics; frame t of the clip is frame frame_range[0] + t of the episode
start = meta["subtask"]["frame_range"][0]
T = T[start:start + meta["n_frames"]]
views.append(dict(name=name, path=path, K=K, dist=dist, calib_wh=(intr["width"], intr["height"]), T=T))
return views[:max_views]
def load_tracks(sample_dir):
parts, is_obj = [], []
files = ["gripper.npz", "robot.npz"] + sorted(
os.path.basename(p) for p in glob.glob(os.path.join(sample_dir, "object*.npz")))
for f in files:
p = os.path.join(sample_dir, f)
if os.path.isfile(p):
pts = np.load(p)["points"].astype(np.float64)
parts.append(pts)
is_obj.append(np.full(pts.shape[1], f.startswith("object")))
if not parts:
sys.exit(f"no point-track npz in {sample_dir}")
return np.concatenate(parts, 1), np.concatenate(is_obj)
def frame_T(T, t):
return T if T.ndim == 2 else T[min(t, len(T) - 1)]
def project(pts_cam, K, dist, wh, margin=0.15):
"""Pinhole pre-check before applying the distortion polynomial, which folds far
out-of-view points back into the image."""
w, h = wh
z = pts_cam[:, 2]
valid = z > 1e-6
uv = np.zeros((len(pts_cam), 2))
if not valid.any():
return uv, valid
xy = pts_cam[valid, :2] / z[valid, None]
u0 = xy[:, 0] * K[0, 0] + K[0, 2]
v0 = xy[:, 1] * K[1, 1] + K[1, 2]
in_fov = (u0 > -margin * w) & (u0 < (1 + margin) * w) & (v0 > -margin * h) & (v0 < (1 + margin) * h)
idx = np.flatnonzero(valid)
valid[idx[~in_fov]] = False
if valid.any():
p, _ = cv2.projectPoints(pts_cam[valid].reshape(-1, 1, 3), np.zeros(3), np.zeros(3), K, dist)
uv[valid] = p.reshape(-1, 2)
return uv, valid
def main():
ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
ap.add_argument("sample_dir")
ap.add_argument("--out", default="vis.mp4")
ap.add_argument("--height", type=int, default=360, help="per-view height of the output")
ap.add_argument("--max-views", type=int, default=3)
ap.add_argument("--frame-png", default=None, help="also save the middle frame as a PNG")
args = ap.parse_args()
with open(os.path.join(args.sample_dir, "meta.json")) as f:
meta = json.load(f)
assert meta.get("extrinsics_convention", "cam_from_world") == "cam_from_world"
views = load_views(args.sample_dir, meta, args.max_views)
v1 = next((v for v in views if v["name"] == "view1"), None)
if v1 is None:
sys.exit("view1 (the reference frame of the tracks) is missing")
pts_v1, is_obj = load_tracks(args.sample_dir) # (T, N, 3) in the view1 camera frame
n_t, n_pts = pts_v1.shape[:2]
# view1 camera frame -> world, per frame
pts_w = np.empty_like(pts_v1)
for t in range(n_t):
iv = np.linalg.inv(frame_T(v1["T"], t))
pts_w[t] = pts_v1[t] @ iv[:3, :3].T + iv[:3, 3]
hues = (np.arange(n_pts) / max(n_pts, 1) * 179).astype(np.uint8)
hsv = np.stack([hues, np.full(n_pts, 255, np.uint8), np.full(n_pts, 255, np.uint8)], 1)
colors = cv2.cvtColor(hsv[None], cv2.COLOR_HSV2BGR)[0]
caps = [cv2.VideoCapture(v["path"]) for v in views]
for v, c in zip(views, caps):
w, h = int(c.get(cv2.CAP_PROP_FRAME_WIDTH)), int(c.get(cv2.CAP_PROP_FRAME_HEIGHT))
cw, ch = v["calib_wh"]
if (w, h) != (cw, ch): # intrinsics refer to calib_wh; rescale to the stored video size
v["K"] = np.diag([w / cw, h / ch, 1.0]) @ v["K"]
v["wh"], v["out_w"] = (w, h), int(round(w * args.height / h))
fps = float(meta.get("fps", 15))
writer = cv2.VideoWriter(args.out, cv2.VideoWriter_fourcc(*"mp4v"), fps,
(sum(v["out_w"] for v in views), args.height))
t = 0
while t < n_t:
frames = [c.read()[1] for c in caps]
if any(f is None for f in frames):
break
row = []
for v, fr in zip(views, frames):
T = frame_T(v["T"], t)
uv, valid = project(pts_w[t] @ T[:3, :3].T + T[:3, 3], v["K"], v["dist"], v["wh"])
w, h = v["wh"]
r = max(2, w // 400)
for i in np.flatnonzero(valid):
x, y = int(round(uv[i, 0])), int(round(uv[i, 1]))
if 0 <= x < w and 0 <= y < h:
col = tuple(int(c) for c in colors[i])
cv2.circle(fr, (x, y), r + 2 if is_obj[i] else r, col, -1, lineType=cv2.LINE_AA)
if is_obj[i]:
cv2.circle(fr, (x, y), r + 2, (255, 255, 255), 1, lineType=cv2.LINE_AA)
row.append(cv2.resize(fr, (v["out_w"], args.height)))
canvas = np.hstack(row)
writer.write(canvas)
if args.frame_png and t == n_t // 2:
cv2.imwrite(args.frame_png, canvas)
t += 1
writer.release()
print(f"{args.sample_dir}: {[v['name'] for v in views]}, tracks {pts_v1.shape}, {t} frames -> {args.out}")
if __name__ == "__main__":
main()
|