Add visualization scripts

scripts/dataset.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+'''
+Dataset class for loading and processing grasp data from a WebDataset.
+
+Installation:
+    pip install trimesh==4.5.3 objaverse==0.1.7 meshcat==0.0.12 webdataset==0.2.111
+
+'''
+import os
+import json
+import time
+import webdataset as wds
+import glob
+from pathlib import Path
+from tqdm import tqdm
+from typing import Dict, Optional
+
+def load_uuid_list(uuid_list_path: str):
+    if not os.path.exists(uuid_list_path):
+        raise FileNotFoundError(f"UUID list file not found: {uuid_list_path}")
+    if uuid_list_path.endswith(".json"):
+        with open(uuid_list_path, 'r') as f:
+            uuids = json.load(f)
+        if type(uuids) == list:
+            return uuids
+        elif type(uuids) == dict:
+            return list(uuids.keys())
+        else:
+            raise ValueError(f"UUID list is not a list or dict: {uuids}")
+    elif uuid_list_path.endswith(".txt"):
+        with open(uuid_list_path, 'r') as f:
+            uuids = [line.strip() for line in f.readlines()]
+    else:
+        raise ValueError(f"Unsupported file format: {uuid_list_path}")
+    return uuids
+
+class GraspWebDatasetReader:
+    """Class to efficiently read grasps data using a pre-loaded index."""
+    
+    def __init__(self, dataset_path: str):
+        """
+        Initialize the reader with dataset path and load the index.
+        
+        Args:
+            dataset_path (str): Path to directory containing WebDataset shards
+        """
+        self.dataset_path = dataset_path
+        self.shards_dir = self.dataset_path
+        
+        # Load the UUID index
+        index_path = os.path.join(self.shards_dir, "uuid_index.json")
+        with open(index_path, 'r') as f:
+            self.uuid_index = json.load(f)
+        
+        # Cache for open datasets
+        self.shard_datasets = {}
+
+    def read_grasps_by_uuid(self, object_uuid: str) -> Optional[Dict]:
+        """
+        Read grasps data for a specific object UUID using the index.
+        
+        Args:
+            object_uuid (str): UUID of the object to retrieve
+        
+        Returns:
+            Optional[Dict]: Dictionary containing the grasps data if found, None otherwise
+        """
+        if object_uuid not in self.uuid_index:
+            return None
+            
+        shard_idx = self.uuid_index[object_uuid]
+        
+        # Get or create dataset for this shard
+        if shard_idx not in self.shard_datasets:
+            shard_path = f"{self.shards_dir}/shard_{shard_idx:03d}.tar"
+            self.shard_datasets[shard_idx] = wds.WebDataset(shard_path)
+        
+        dataset = self.shard_datasets[shard_idx]
+        
+        # Search for the UUID in the specific shard
+        for sample in dataset:
+            if sample["__key__"] == object_uuid:
+                return json.loads(sample["grasps.json"])
+        
+        return None

scripts/download_objaverse.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+'''
+Download specific Objaverse meshes given their UUIDs.
+
+Installation:
+    pip install trimesh==4.5.3 objaverse==0.1.7 meshcat==0.0.12 webdataset==0.2.111
+
+Usage:
+    python download_objaverse.py --uuid_list /path_to_dataset/splits/franka/valid_scenes.json --output_dir /tmp/objs
+'''
+import argparse
+import json
+import os
+import shutil
+from objaverse import load_objects
+from pathlib import Path
+from dataset import load_uuid_list
+
+def download_objaverse_meshes(uuids: list[str], output_dir: str):
+    """
+    Download specific Objaverse meshes given their UUIDs.
+    
+    Args:
+        uuid_list_path (str): Path to JSON file containing list of UUIDs
+        output_dir (str): Directory where meshes will be saved
+    """
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+        
+    print(f"Found {len(uuids)} UUIDs to download")
+    
+    # Download objects using Objaverse
+    objects = load_objects(uids=uuids)
+
+    map_uuid_to_path = {}
+    
+    # Save each object to the output directory
+    for uuid in uuids:
+        try:
+            # Get the object path from Objaverse
+            obj_path = objects[uuid]
+            
+            if obj_path is None:
+                print(f"Failed to download object {uuid}")
+                continue
+                
+            # Create destination path
+            dest_path = os.path.join(output_dir, os.path.basename(obj_path))
+            
+            shutil.copy2(obj_path, dest_path)
+            
+            print(f"Successfully downloaded and saved object {uuid}, saved to {dest_path}")
+            map_uuid_to_path[uuid] = dest_path
+
+            os.remove(obj_path)
+            json.dump(map_uuid_to_path, open(os.path.join(output_dir, "map_uuid_to_path.json"), "w"))
+            
+        except Exception as e:
+            print(f"Error processing object {uuid}: {e}")
+    
+    print("Download complete!")
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--uuid_list", type=str, help="Path to UUID list or Json. This can be the split json file from the GraspGen dataset")
+    parser.add_argument("--output_dir", type=str, help="Path to output directory")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    uuid_list = load_uuid_list(args.uuid_list)
+    download_objaverse_meshes(uuid_list, args.output_dir)

scripts/meshcat_utils.py

@@ -0,0 +1,366 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+'''
+Utility functions for visualization using meshcat.
+
+Installation:
+    pip install trimesh==4.5.3 objaverse==0.1.7 meshcat==0.0.12 webdataset==0.2.111
+
+NOTE: Start meshcat server (in a different terminal) before running this script:
+    meshcat-server
+'''
+
+import numpy as np
+import meshcat
+import meshcat.geometry as g
+import meshcat.transformations as mtf
+import trimesh
+import trimesh.transformations as tra
+from typing import List, Optional, Tuple, Union, Any
+
+control_points_franka = np.array([
+        [ 0.05268743, -0.00005996, 0.05900000],
+        [-0.05268743,  0.00005996, 0.05900000],
+        [ 0.05268743, -0.00005996, 0.10527314],
+        [-0.05268743,  0.00005996, 0.10527314]
+    ])
+
+control_points_robotiq2f140 = np.array([
+    [ 0.06801729, -0, 0.0975],
+    [-0.06801729,  0, 0.0975],
+    [ 0.06801729, -0, 0.1950],
+    [-0.06801729,  0, 0.1950]
+])
+
+control_points_suction = np.array([
+    [ 0, 0, -0.10],
+    [ 0, 0, -0.05],
+    [ 0, 0, 0],
+])
+
+control_points_data = {
+    "franka": control_points_franka,
+    "robotiq2f140": control_points_robotiq2f140,
+    "suction": control_points_suction,
+}
+
+def get_gripper_control_points(gripper_name: str = 'franka') -> np.ndarray:
+    """
+    Get the control points for a specific gripper.
+    
+    Args:
+        gripper_name (str): Name of the gripper ("franka", "robotiq2f140", "suction")
+    
+    Returns:
+        np.ndarray: Array of control points for the specified gripper
+    
+    Raises:
+        NotImplementedError: If the specified gripper is not implemented
+    """
+    if gripper_name in control_points_data:
+        return control_points_data[gripper_name]
+    else:
+        raise NotImplementedError(f"Gripper {gripper_name} is not implemented.")
+    return control_points
+
+def get_gripper_depth(gripper_name: str) -> float:
+    """
+    Get the depth parameter for a specific gripper type.
+    
+    Args:
+        gripper_name (str): Name of the gripper ("franka", "robotiq2f140", "suction")
+    
+    Returns:
+        float: Depth parameter for the specified gripper
+    
+    Raises:
+        NotImplementedError: If the specified gripper is not implemented
+    """
+    # TODO: Use register module. Don't have this if-else name lookup
+    pts, d = None, None
+    if gripper_name in ["franka", "robotiq2f140"]:
+        pts = get_gripper_control_points(gripper_name)
+    elif gripper_name == "suction":
+        return 0.069
+    else:
+        raise NotImplementedError(f"Control points for gripper {gripper_name} not implemented!")
+    d = pts[-1][-1] if pts is not None else d
+    return d
+
+def get_gripper_offset(gripper_name: str) -> np.ndarray:
+    """
+    Get the offset transform for a specific gripper type.
+    
+    Args:
+        gripper_name (str): Name of the gripper
+    
+    Returns:
+        np.ndarray: 4x4 homogeneous transformation matrix representing the gripper offset
+    """
+    return np.eye(4)
+
+def load_visualize_control_points_suction() -> np.ndarray:
+    """
+    Load visualization control points specific to the suction gripper.
+    
+    Returns:
+        np.ndarray: Array of control points for suction gripper visualization
+    """
+    h = 0
+    pts = [
+        [0.0, 0],
+    ]
+    pts = [generate_circle_points(c, radius=0.005) for c in pts]
+    pts = np.stack(pts)
+    ptsz = h * np.ones([pts.shape[0], pts.shape[1], 1])
+    pts = np.concatenate([pts, ptsz], axis=2)
+    return pts
+
+def generate_circle_points(center: List[float], radius: float = 0.007, N: int = 30) -> np.ndarray:
+    """
+    Generate points forming a circle in 2D space.
+    
+    Args:
+        center (List[float]): Center coordinates [x, y] of the circle
+        radius (float): Radius of the circle
+        N (int): Number of points to generate around the circle
+    
+    Returns:
+        np.ndarray: Array of shape (N, 2) containing the circle points
+    """
+    angles = np.linspace(0, 2 * np.pi, N, endpoint=False)
+    x_points = center[0] + radius * np.cos(angles)
+    y_points = center[1] + radius * np.sin(angles)
+    points = np.stack((x_points, y_points), axis=1)
+    return points
+
+
+def get_gripper_visualization_control_points(gripper_name: str = 'franka') -> List[np.ndarray]:
+    """
+    Get control points for visualizing a specific gripper type.
+    
+    Args:
+        gripper_name (str): Name of the gripper ("franka", "robotiq2f140", "suction")
+    
+    Returns:
+        List[np.ndarray]: List of control point arrays for gripper visualization
+    """
+    if gripper_name == "suction":
+        control_points = load_visualize_control_points_suction()
+        offset = get_gripper_offset('suction')
+        ctrl_pts = [tra.transform_points(cpt, offset) for cpt in control_points]
+        d = get_gripper_depth(gripper_name)
+        line_pts = np.array([[0,0,0], [0,0,d]])
+        line_pts = np.expand_dims(line_pts, 0)
+        line_pts = [tra.transform_points(cpt, offset) for cpt in line_pts]
+        line_pts = line_pts[0]
+        ctrl_pts.append(line_pts)
+        return ctrl_pts
+    else:
+        control_points = get_gripper_control_points(gripper_name)
+        mid_point = (control_points[0] + control_points[1]) / 2
+        control_points = [
+            control_points[-2], control_points[0], mid_point,
+            [0, 0, 0], mid_point, control_points[1], control_points[-1]
+        ]
+        return [control_points, ]
+
+def get_color_from_score(labels: Union[float, np.ndarray], use_255_scale: bool = False) -> np.ndarray:
+    """
+    Convert score labels to RGB colors for visualization.
+    
+    Args:
+        labels (Union[float, np.ndarray]): Score values between 0 and 1
+        use_255_scale (bool): If True, output colors in [0-255] range, else [0-1]
+    
+    Returns:
+        np.ndarray: RGB colors corresponding to the input scores
+    """
+    scale = 255.0 if use_255_scale else 1.0
+    if type(labels) in [np.float32, float]:
+        return scale * np.array([1 - labels, labels, 0])
+    else:
+        scale = 255.0 if use_255_scale else 1.0
+        score = scale * np.stack(
+            [np.ones(labels.shape[0]) - labels, labels, np.zeros(labels.shape[0])],
+            axis=1,
+        )
+        return score.astype(np.int)
+
+def trimesh_to_meshcat_geometry(mesh: trimesh.Trimesh) -> g.TriangularMeshGeometry:
+    """
+    Convert a trimesh mesh to meshcat geometry format.
+    
+    Args:
+        mesh (trimesh.Trimesh): Input mesh in trimesh format
+    
+    Returns:
+        g.TriangularMeshGeometry: Mesh in meshcat geometry format
+    """
+    return meshcat.geometry.TriangularMeshGeometry(mesh.vertices, mesh.faces)
+
+
+def visualize_mesh(
+    vis: meshcat.Visualizer,
+    name: str,
+    mesh: trimesh.Trimesh,
+    color: Optional[List[int]] = None,
+    transform: Optional[np.ndarray] = None
+) -> None:
+    """
+    Visualize a mesh in meshcat with optional color and transform.
+    
+    Args:
+        vis (meshcat.Visualizer): Meshcat visualizer instance
+        name (str): Name/path for the mesh in the visualizer scene
+        mesh (trimesh.Trimesh): Mesh to visualize
+        color (Optional[List[int]]): RGB color values [0-255]. Random if None
+        transform (Optional[np.ndarray]): 4x4 homogeneous transform matrix
+    """
+    if vis is None:
+        return
+
+    if color is None:
+        color = np.random.randint(low=0, high=256, size=3)
+
+    mesh_vis = trimesh_to_meshcat_geometry(mesh)
+    color_hex = rgb2hex(tuple(color))
+    material = meshcat.geometry.MeshPhongMaterial(color=color_hex)
+    vis[name].set_object(mesh_vis, material)
+
+    if transform is not None:
+        vis[name].set_transform(transform)
+
+
+def rgb2hex(rgb: Tuple[int, int, int]) -> str:
+    """
+    Convert RGB color values to hexadecimal string.
+    
+    Args:
+        rgb (Tuple[int, int, int]): RGB color values (0-255)
+    
+    Returns:
+        str: Hexadecimal color string (format: "0xRRGGBB")
+    """
+    return "0x%02x%02x%02x" % (rgb)
+
+
+def create_visualizer(clear: bool = True) -> meshcat.Visualizer:
+    """
+    Create a meshcat visualizer instance.
+    
+    Args:
+        clear (bool): If True, clear the visualizer scene upon creation first
+    
+    Returns:
+        meshcat.Visualizer: Initialized meshcat visualizer
+    """
+    print(
+        "Waiting for meshcat server... have you started a server? Run `meshcat-server` to start a server"
+    )
+    vis = meshcat.Visualizer(zmq_url="tcp://127.0.0.1:6000")
+    if clear:
+        vis.delete()
+    return vis
+
+
+def visualize_pointcloud(
+    vis: meshcat.Visualizer,
+    name: str,
+    pc: np.ndarray,
+    color: Optional[Union[List[int], np.ndarray]] = None,
+    transform: Optional[np.ndarray] = None,
+    **kwargs: Any
+) -> None:
+    """
+    Args:
+        vis: meshcat visualizer object
+        name: str
+        pc: Nx3 or HxWx3
+        color: (optional) same shape as pc[0 - 255] scale or just rgb tuple
+        transform: (optional) 4x4 homogeneous transform
+    """
+    if vis is None:
+        return
+    if pc.ndim == 3:
+        pc = pc.reshape(-1, pc.shape[-1])
+
+    if color is not None:
+        if isinstance(color, list):
+            color = np.array(color)
+        color = np.array(color)
+        # Resize the color np array if needed.
+        if color.ndim == 3:
+            color = color.reshape(-1, color.shape[-1])
+        if color.ndim == 1:
+            color = np.ones_like(pc) * np.array(color)
+
+        # Divide it by 255 to make sure the range is between 0 and 1,
+        color = color.astype(np.float32) / 255
+    else:
+        color = np.ones_like(pc)
+
+    vis[name].set_object(
+        meshcat.geometry.PointCloud(position=pc.T, color=color.T, **kwargs)
+    )
+
+    if transform is not None:
+        vis[name].set_transform(transform)
+
+
+def load_visualization_gripper_points(gripper_name: str = "franka") -> List[np.ndarray]:
+    """
+    Load control points for gripper visualization.
+    
+    Args:
+        gripper_name (str): Name of the gripper to visualize
+    
+    Returns:
+        List[np.ndarray]: List of control point arrays, each of shape [4, N]
+        where N is the number of points for that segment
+    """
+    ctrl_points = []
+    for ctrl_pts in get_gripper_visualization_control_points(gripper_name):
+        ctrl_pts = np.array(ctrl_pts, dtype=np.float32)
+        ctrl_pts = np.hstack([ctrl_pts, np.ones([len(ctrl_pts),1])])
+        ctrl_pts = ctrl_pts.T
+        ctrl_points.append(ctrl_pts)
+    return ctrl_points
+
+
+def visualize_grasp(
+    vis: meshcat.Visualizer,
+    name: str,
+    transform: np.ndarray,
+    color: List[int] = [255, 0, 0],
+    gripper_name: str = "franka",
+    **kwargs: Any
+) -> None:
+    """
+    Visualize a gripper grasp pose in meshcat.
+    
+    Args:
+        vis (meshcat.Visualizer): Meshcat visualizer instance
+        name (str): Name/path for the grasp in the visualizer scene
+        transform (np.ndarray): 4x4 homogeneous transform matrix for the grasp pose
+        color (List[int]): RGB color values [0-255] for the grasp visualization
+        gripper_name (str): Name of the gripper to visualize
+        **kwargs: Additional arguments passed to MeshBasicMaterial
+    """
+    if vis is None:
+        return
+    grasp_vertices = load_visualization_gripper_points(gripper_name)
+    for i, grasp_vertex in enumerate(grasp_vertices):
+        vis[name + f"/{i}"].set_object(
+            g.Line(
+                g.PointsGeometry(grasp_vertex),
+                g.MeshBasicMaterial(color=rgb2hex(tuple(color)), **kwargs),
+            )
+        )
+        vis[name].set_transform(transform.astype(np.float64))

scripts/visualize_dataset.py

@@ -0,0 +1,148 @@
+# Copyright (c) 2025, NVIDIA CORPORATION. All rights reserved.
+#
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto. Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+#
+'''
+Visualize the data with both the object mesh and its corresponding grasps, using meshcat.
+
+Installation:
+    pip install trimesh==4.5.3 objaverse==0.1.7 meshcat==0.0.12 webdataset==0.2.111
+
+Usage:
+
+Before running the script, start the meshcat server in a different terminal:
+    meshcat-server
+
+To visualize a single object from the dataset:
+    python visualize_dataset.py --dataset_path /path/to/dataset --object_uuid {object_uuid} --object_file /path/to/mesh --gripper_name {choose from: franka, suction, robotiq2f140}
+
+To visualize many objects (one at a time) from the dataset
+    python visualize_dataset.py --dataset_path /path/to/dataset --uuid_list /path/to/uuid_list.json --gripper_name {choose from: franka, suction, robotiq2f140} --uuid_object_paths_file /path/to/uuid_object_paths_file.json
+
+NOTE:
+    - The uuid_object_paths_file is a json file, that contains a dictionary with a mapping from the UUID to the absolute path of the mesh file. if you are using the download_objaverse.py script, this file will be auto-generated.
+    - The uuid_list can be the split json file from the GraspGen dataset
+    - The gripper_name has to be one of the following: franka, suction, robotiq2f140
+'''
+
+import os
+import argparse
+import trimesh
+import numpy as np
+import json
+from meshcat_utils import create_visualizer, visualize_mesh, visualize_grasp
+from dataset import GraspWebDatasetReader, load_uuid_list
+
+def visualize_mesh_with_grasps(
+    mesh_path: str, 
+    mesh_scale: float, 
+    gripper_name: str = "franka",
+    grasps: list[np.ndarray] = None,
+    color: list = [192, 192, 192], 
+    transform: np.ndarray = None,
+    max_grasps_to_visualize: int = 20
+):
+    """
+    Visualize a single mesh with optional grasps using meshcat.
+    
+    Args:
+        mesh_path (str): Path to the mesh file
+        mesh_scale (float): Scale factor for the mesh
+        gripper_name (str): Name of the gripper to visualize ("franka", "suction", etc.)
+        grasps (list[np.ndarray], optional): List of 4x4 grasp transforms
+        color (list, optional): RGB color for the mesh. Defaults to gray if None
+        transform (np.ndarray, optional): 4x4 transform matrix for the mesh. Defaults to identity if None
+        max_grasps_to_visualize (int, optional): Maximum number of grasps to visualize. Defaults to 20
+    """
+    # Create visualizer
+    vis = create_visualizer()
+    vis.delete()
+    
+    # Default transform if none provided
+    if transform is None:
+        transform = np.eye(4)
+
+    # Load and visualize the mesh
+    try:
+        transform = transform.astype(np.float64)
+        mesh = trimesh.load(mesh_path)
+        if type(mesh) == trimesh.Scene:
+            mesh = mesh.dump(concatenate=True)
+        mesh.apply_scale(mesh_scale)
+
+        T_move_mesh_to_origin = np.eye(4)
+        T_move_mesh_to_origin[:3, 3] = -mesh.centroid
+
+        transform = transform @ T_move_mesh_to_origin
+
+        visualize_mesh(vis, 'mesh', mesh, color=color, transform=transform)
+    except Exception as e:
+        print(f"Error loading mesh from {mesh_path}: {e}")
+    
+    # Visualize grasps if provided
+    if grasps is not None:
+        for i, grasp in enumerate(np.random.permutation(grasps)[:max_grasps_to_visualize]):
+            visualize_grasp(
+                vis, 
+                f"grasps/{i:03d}",
+                transform @ grasp.astype(np.float), 
+                [0, 255, 0], 
+                gripper_name=gripper_name, 
+                linewidth=0.2
+            )
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dataset_path", type=str, required=True)
+    parser.add_argument("--object_uuid", type=str, help="The UUID of the object to visualize", default=None)
+    parser.add_argument("--uuid_list", type=str, help="Path to UUID list", default=None)
+    parser.add_argument("--uuid_object_paths_file", type=str, help="Path to JSON file, mapping UUID to absolute path of the mesh file", default=None)
+    parser.add_argument("--object_file", type=str, help="This has to be a .stl or .obj or .glb file", default=None)
+    parser.add_argument("--gripper_name", type=str, required=True, help="Specify the gripper name", choices=["franka", "suction", "robotiq2f140"])
+    parser.add_argument("--max_grasps_to_visualize", type=int, help="The max number of grasps to visualize", default=20)
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_args()
+    assert args.object_uuid is not None or args.uuid_list is not None, "Either object_uuid or uuid_list must be provided"
+
+    if args.object_uuid is not None:
+        webdataset_reader = GraspWebDatasetReader(os.path.join(args.dataset_path, args.gripper_name))
+        uuid_list = [args.object_uuid,]
+        object_paths = [args.object_file,]
+        assert args.object_file is not None, "object_file must be provided if object_uuid is provided"
+        assert os.path.exists(args.object_file), f"Object file {args.object_file} does not exist"
+    else:
+        assert os.path.exists(args.uuid_list), f"UUID list {args.uuid_list} does not exist"
+        uuid_list = load_uuid_list(args.uuid_list)
+        assert args.uuid_object_paths_file is not None, "uuid_object_paths_file must be provided if uuid_list is provided"
+        assert os.path.exists(args.uuid_object_paths_file), f"UUID object paths file {args.uuid_object_paths_file} does not exist"
+        object_paths = json.load(open(args.uuid_object_paths_file))
+        object_paths = [object_paths[uuid] for uuid in uuid_list]
+        webdataset_reader = GraspWebDatasetReader(os.path.join(args.dataset_path, args.gripper_name))
+
+    for uuid, object_path in zip(uuid_list, object_paths):
+        print(f"Visualizing object {uuid}")
+        grasp_data = webdataset_reader.read_grasps_by_uuid(uuid)
+        object_scale = grasp_data['object']['scale']
+        grasps = grasp_data["grasps"]
+        grasp_poses = np.array(grasps["transforms"])
+        grasp_mask = np.array(grasps["object_in_gripper"])
+        positive_grasps = grasp_poses[grasp_mask] # Visualizing only the positive grasps
+
+        if len(positive_grasps) > 0:
+            # Visualize the mesh with the grasps
+            visualize_mesh_with_grasps(
+                mesh_path=object_path,
+                mesh_scale=object_scale,
+                grasps=positive_grasps,
+                gripper_name=args.gripper_name,
+                max_grasps_to_visualize=args.max_grasps_to_visualize,
+            )
+            print("Press Enter to continue...")
+            input()