Datasets:
File size: 5,675 Bytes
89f63de | 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 | """Reconstruct a GraspNet-1Billion scene from its stored object poses, and check it against the depth image.
Adapted from graspnetAPI (Fang et al., CVPR 2020; `GraspNet.loadSceneModel` / `generate_scene_model`) as vendored in
GraspFormer (graspformer/data/graspnet_api). Standalone: numpy, scipy, Pillow, trimesh.
GraspNet conventions used here
scene_XXXX/<camera>/meta/VVVV.mat poses (3,4,N): object -> camera transforms (metres) for view VVVV;
cls_indexes (N,): GraspNet object id + 1; intrinsic_matrix (3,3); factor_depth (1000)
scene_XXXX/<camera>/depth/VVVV.png 16-bit depth in millimetres (divide by factor_depth)
scene_XXXX/<camera>/label/VVVV.png object id + 1 per pixel, 0 = background
scene_XXXX/<camera>/camera_poses.npy (256,4,4): pose of camera VVVV with respect to camera 0 (view 0)
scene_XXXX/<camera>/cam0_wrt_table.npy (4,4): pose of camera 0 with respect to the table frame (z up)
models/OID/textured.obj (+ .mtl, texture_map.png), nontextured.ply : object meshes in metres, object frame
Usage:
python reconstruct_scene.py --scene scene_0000 --models models --view 0 --out out/ # camera frame of view 0
python reconstruct_scene.py ... --table-frame # table frame (z up)
Writes out/scene_<view>.glb (textured meshes at their poses), out/depth_<view>.ply (back-projected depth, coloured),
prints the pose table and the median distance between depth points on objects and the reconstructed surfaces.
"""
import argparse, os
import numpy as np, scipy.io as sio, trimesh
from PIL import Image
def load_view(scene_dir, camera, view):
cam = os.path.join(scene_dir, camera)
meta = sio.loadmat(os.path.join(cam, "meta", f"{view:04d}.mat"))
poses = meta["poses"].transpose(2, 0, 1).astype(np.float64) # (N,3,4) object -> camera, metres
ids = meta["cls_indexes"].ravel().astype(int) - 1 # GraspNet object ids 0..87
K = meta["intrinsic_matrix"].astype(np.float64); depth_scale = float(meta["factor_depth"].ravel()[0])
depth = np.array(Image.open(os.path.join(cam, "depth", f"{view:04d}.png")), dtype=np.float32) / depth_scale # metres
rgb = np.array(Image.open(os.path.join(cam, "rgb", f"{view:04d}.png")).convert("RGB"))
label = np.array(Image.open(os.path.join(cam, "label", f"{view:04d}.png")))
cam_wrt_cam0 = np.load(os.path.join(cam, "camera_poses.npy"))[view]
cam0_wrt_table = np.load(os.path.join(cam, "cam0_wrt_table.npy"))
return dict(poses=poses, ids=ids, K=K, depth=depth, rgb=rgb, label=label, cam_wrt_table=cam0_wrt_table @ cam_wrt_cam0)
def backproject(depth, K, rgb=None, mask=None):
"""Pixels -> camera-frame points (metres); returns (points, colours)."""
h, w = depth.shape; u, v = np.meshgrid(np.arange(w), np.arange(h))
z = depth; x = (u - K[0, 2]) * z / K[0, 0]; y = (v - K[1, 2]) * z / K[1, 1]
pts = np.stack([x, y, z], -1).reshape(-1, 3); keep = z.reshape(-1) > 0
if mask is not None: keep &= mask.reshape(-1)
return pts[keep], (rgb.reshape(-1, 3)[keep] if rgb is not None else None)
def compose(models_dir, view, textured=True, table_frame=False):
"""trimesh.Scene of the scene's objects at their poses (camera frame of this view, or the table frame)."""
scene = trimesh.Scene(); T_frame = view["cam_wrt_table"] if table_frame else np.eye(4)
for oid, P in zip(view["ids"], view["poses"]):
T = np.eye(4); T[:3] = P; T = T_frame @ T
m = trimesh.load(os.path.join(models_dir, f"{oid:03d}", "textured.obj" if textured else "nontextured.ply"), force="mesh")
m.apply_transform(T); scene.add_geometry(m, node_name=f"obj_{oid:03d}")
return scene
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--scene", required=True); ap.add_argument("--models", required=True); ap.add_argument("--camera", default="realsense")
ap.add_argument("--view", type=int, default=0); ap.add_argument("--out", default="out"); ap.add_argument("--table-frame", action="store_true")
ap.add_argument("--no-texture", action="store_true")
a = ap.parse_args(); os.makedirs(a.out, exist_ok=True)
v = load_view(a.scene, a.camera, a.view)
T_frame = v["cam_wrt_table"] if a.table_frame else np.eye(4)
print(f"{os.path.basename(a.scene)} {a.camera} view {a.view}: {len(v['ids'])} objects; frame = {'table' if a.table_frame else 'camera'}")
for oid, P in zip(v["ids"], v["poses"]):
T = T_frame @ np.vstack([P, [0, 0, 0, 1]])
print(f" object {oid:03d}: position {np.round(T[:3, 3], 4).tolist()} rotation rows {np.round(T[:3, :3], 3).tolist()}")
scene = compose(a.models, v, textured=not a.no_texture, table_frame=a.table_frame)
glb = os.path.join(a.out, f"scene_{a.view:04d}.glb"); scene.export(glb)
pts, cols = backproject(v["depth"], v["K"], v["rgb"], mask=v["label"] > 0)
pts = trimesh.transform_points(pts, T_frame)
ply = os.path.join(a.out, f"depth_{a.view:04d}.ply"); trimesh.PointCloud(pts, colors=cols).export(ply)
# sanity: depth points on labelled objects should lie on the reconstructed surfaces
from scipy.spatial import cKDTree
surface = scene.dump(concatenate=True).sample(300_000) # dense surface sample of the reconstruction
sample = pts[np.random.default_rng(0).choice(len(pts), min(5000, len(pts)), replace=False)]
d = cKDTree(surface).query(sample)[0]
print(f"depth points on objects: {len(pts)}; distance to reconstructed surfaces: median {1e3 * np.median(d):.1f} mm, 90th pct {1e3 * np.percentile(d, 90):.1f} mm")
print(f"wrote {glb} and {ply}")
if __name__ == "__main__":
main()
|