GraspNet-1Billion example scene (scene_0000 RealSense, 256 views, 9 models) + reconstruction script

graspnet_example/README.md

@@ -0,0 +1,53 @@
+# GraspNet-1Billion example scene (scene_0000, RealSense, all 256 views)
+
+One complete scene of [GraspNet-1Billion](https://graspnet.net/) (Fang et al., CVPR 2020) with everything needed to
+reconstruct it: the 9 object meshes, every per-view object pose, the camera trajectory, and the RGB-D images with
+segmentation labels. It is included as the reference for rendering multi-object scenes in the GraspNet style.
+
+**Licence: this folder is CC BY-NC-SA 4.0** (GraspNet team, MVIG, SJTU: free for non-commercial use, redistribution
+under the same conditions, https://graspnet.net/about), separate from the CC-BY / CC0 objects in `objects/`. Cite:
+
+```
+@inproceedings{fang2020graspnet, title={GraspNet-1Billion: A Large-Scale Benchmark for General Object Grasping},
+  author={Fang, Hao-Shu and Wang, Chenxi and Gou, Minghao and Lu, Cewu}, booktitle={CVPR}, year={2020}}
+```
+
+## Files
+
+```
+scene_0000_realsense.zip
+  scene_0000/object_id_list.txt            the 9 GraspNet object ids in this scene (14 0 5 15 20 48 66 70 46)
+  scene_0000/rs_wrt_kn.npy                 RealSense pose with respect to the Kinect (not needed here)
+  scene_0000/realsense/camK.npy            3x3 intrinsics (also inside every meta file)
+  scene_0000/realsense/camera_poses.npy    (256,4,4) pose of camera v with respect to camera 0 (view 0)
+  scene_0000/realsense/cam0_wrt_table.npy  (4,4) pose of camera 0 with respect to the table frame (z up)
+  scene_0000/realsense/rgb/VVVV.png        1280x720 colour
+  scene_0000/realsense/depth/VVVV.png      16-bit depth in millimetres (divide by factor_depth = 1000)
+  scene_0000/realsense/label/VVVV.png      per-pixel GraspNet object id + 1, 0 = background
+  scene_0000/realsense/meta/VVVV.mat       poses (3,4,N) object->camera transforms in metres, cls_indexes (N,) = object id + 1,
+                                           intrinsic_matrix (3,3), factor_depth
+  scene_0000/realsense/annotations/VVVV.xml the same poses as position + quaternion in the camera frame (graspnetAPI's XML form)
+models_scene_0000.zip
+  models/OID/textured.obj + .mtl + texture image, nontextured.ply, nontextured_simplified.ply   (metres, object frame)
+reconstruct_scene.py                       standalone reconstruction and check (numpy, scipy, Pillow, trimesh)
+```
+
+Views are indexed 0..255 along the recorded camera trajectory; object poses are given per view in that view's camera
+frame, so the same scene can be reconstructed from any view. `camera_poses.npy` and `cam0_wrt_table.npy` put all views
+in one table frame: `cam_v_wrt_table = cam0_wrt_table @ camera_poses[v]`.
+
+## Reconstruct
+
+```
+unzip scene_0000_realsense.zip; unzip models_scene_0000.zip
+python reconstruct_scene.py --scene scene_0000 --models models --view 0 --out out            # camera frame of view 0
+python reconstruct_scene.py --scene scene_0000 --models models --view 137 --table-frame --out out
+```
+
+The script prints each object's pose, writes `out/scene_VVVV.glb` (the textured meshes at their poses; add `--no-texture`
+for a small file) and `out/depth_VVVV.ply` (the back-projected depth of the object pixels, coloured), and reports the
+distance between those depth points and the reconstructed surfaces as a check (a few millimetres for a correct pose
+convention). The pose logic follows graspnetAPI's `loadSceneModel` / `generate_scene_model` as used in GraspFormer.
+
+Not included: the grasp labels (`grasp_label/`, per object) and the per-scene collision labels (`collision_label/`,
+184 MB for this scene); both are in the original GraspNet-1Billion release.

graspnet_example/models_scene_0000.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d4f557c4d03e96037055c44ba952f96e37b7253b74bada3a0ae8d1471b41cea0
+size 585692112

graspnet_example/reconstruct_scene.py

@@ -0,0 +1,86 @@
+"""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()

graspnet_example/scene_0000_realsense.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86e743e9b93d8eb35aad55a4d90c3cedd62db68ee28e9afd859fe3aefb1f9dcc
+size 372919595