| """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) |
| ids = meta["cls_indexes"].ravel().astype(int) - 1 |
| 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 |
| 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) |
| |
| from scipy.spatial import cKDTree |
| surface = scene.dump(concatenate=True).sample(300_000) |
| 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() |
|
|
