Upload example_usage.py

example_usage.py

@@ -0,0 +1,262 @@
+"""
+CHIP Dataset Usage Example
+
+This script demonstrates how to load and visualize data from the CHIP dataset,
+including RGB images, depth maps, camera parameters, and 3D object models.
+
+Requirements:
+    pip install datasets huggingface_hub numpy opencv-python open3d torch
+"""
+
+import json
+import os
+import gc
+from typing import Tuple, Optional
+
+import numpy as np
+import cv2
+import open3d as o3d
+import torch
+from datasets import load_dataset, get_dataset_infos
+from huggingface_hub import snapshot_download
+
+
+def lift_point_cloud(
+    depth: torch.Tensor,
+    camera_intrinsics: torch.Tensor,
+    xy_indices: Optional[Tuple[torch.Tensor, torch.Tensor]] = None
+) -> torch.Tensor:
+    """
+    Lift a depth image to a 3D point cloud using camera intrinsics.
+    
+    Args:
+        depth: Depth image tensor of shape (H, W, C) where C >= 1.
+               If C > 1, channels 1+ are treated as features (e.g., RGB).
+        camera_intrinsics: Flattened camera intrinsic matrix [fx, 0, cx, 0, fy, cy, 0, 0, 1].
+        xy_indices: Optional tuple of (x_coords, y_coords) to lift only specific pixels.
+    
+    Returns:
+        Point cloud tensor of shape (N, 3+F) where F is the number of feature channels.
+        First 3 columns are XYZ coordinates, remaining columns are features.
+    """
+    H, W, num_channels = depth.shape
+    depth_values = depth[:, :, 0]
+    
+    if xy_indices is not None:
+        x_coords, y_coords = xy_indices
+        x_coords = x_coords.to(depth_values.device).float()
+        y_coords = y_coords.to(depth_values.device).float()
+        z_coords = depth_values[y_coords.long(), x_coords.long()]
+    else:
+        # Create pixel coordinate grids
+        x_grid, y_grid = np.meshgrid(
+            np.arange(W, dtype=np.float32),
+            np.arange(H, dtype=np.float32),
+            indexing='xy'
+        )
+        x_coords = torch.from_numpy(x_grid).flatten().to(depth_values.device)
+        y_coords = torch.from_numpy(y_grid).flatten().to(depth_values.device)
+        z_coords = depth_values.flatten()
+    
+    # Extract camera intrinsics
+    fx, fy = camera_intrinsics[0], camera_intrinsics[4]
+    cx, cy = camera_intrinsics[2], camera_intrinsics[5]
+    
+    # Back-project to 3D coordinates
+    x_3d = (x_coords - cx) * z_coords / fx
+    y_3d = (y_coords - cy) * z_coords / fy
+    points_3d = torch.stack([x_3d, y_3d, z_coords], dim=1)
+    
+    # Add additional features (e.g., RGB) if present
+    if num_channels > 1:
+        features = depth[y_coords.long(), x_coords.long(), 1:]
+        if xy_indices is None:
+            features = features.reshape(H * W, num_channels - 1)
+        points_3d = torch.cat([points_3d, features], dim=1)
+    
+    return points_3d
+
+
+def back_project_rgbd(
+    rgb: np.ndarray,
+    depth: np.ndarray,
+    camera_intrinsics: np.ndarray
+) -> torch.Tensor:
+    """
+    Back-project RGB-D image to a colored point cloud.
+    
+    Args:
+        rgb: RGB image array of shape (H, W, 3).
+        depth: Depth map array of shape (H, W) with values in meters.
+        camera_intrinsics: Flattened 3x3 camera intrinsic matrix.
+    
+    Returns:
+        Point cloud tensor of shape (N, 6) with XYZ and RGB columns.
+    """
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    # Get valid depth pixel coordinates
+    valid_rows, valid_cols = np.where(depth > 0)
+    xy_indices = torch.tensor(
+        np.stack([valid_cols, valid_rows]),
+        dtype=torch.long,
+        device=device
+    )
+    
+    # Concatenate depth and RGB channels
+    depth_rgb = torch.cat([
+        torch.from_numpy(depth).unsqueeze(-1),
+        torch.from_numpy(rgb)
+    ], dim=2).to(device)
+    
+    # Lift to 3D point cloud
+    camera_tensor = torch.from_numpy(camera_intrinsics).to(device)
+    point_cloud = lift_point_cloud(depth_rgb, camera_tensor, tuple(xy_indices))
+    
+    return point_cloud
+
+
+def visualize_chip_sample(
+    repo_id: str = "FBK-TeV/CHIP",
+    target_dir: str = "./chip_data",
+    num_samples: int = 1,
+    show_2d: bool = False
+) -> None:
+    """
+    Load and visualize samples from the CHIP dataset.
+    
+    Args:
+        repo_id: Hugging Face dataset repository ID.
+        target_dir: Local directory to store downloaded model files.
+        num_samples: Number of samples to visualize.
+        show_2d: If True, display RGB and depth images in OpenCV windows.
+                 If False, only show 3D point cloud visualization.
+    """
+    # Display dataset information
+    info = get_dataset_infos(repo_id)
+    print(f"Dataset info: {info}\n")
+    
+    # Download 3D object models
+    print("Downloading 3D models...")
+    local_path = snapshot_download(
+        repo_id=repo_id,
+        repo_type="dataset",
+        local_dir=target_dir,
+        allow_patterns=["models/*"]
+    )
+    print(f"Models downloaded to: {local_path}\n")
+    
+    # Stream dataset samples
+    dataset = load_dataset(repo_id, streaming=True)
+    
+    for idx, example in enumerate(dataset['test'].take(num_samples)):
+        print(f"Processing sample {idx + 1}/{num_samples}...")
+        
+        # ========== Load RGB Image ==========
+        rgb_image = np.array(example['image'])
+        rgb_bgr = cv2.cvtColor(rgb_image, cv2.COLOR_RGB2BGR)
+        
+        # ========== Load Depth Map ==========
+        depth_map = np.array(example['depth'], dtype=np.uint16).astype(np.float32)
+        
+        # Visualize depth for display
+        depth_vis = cv2.normalize(depth_map, None, 0, 255, cv2.NORM_MINMAX)
+        depth_vis = depth_vis.astype(np.uint8)
+        
+        # ========== Parse Camera Parameters ==========
+        camera_params = json.loads(example['camera_params'])
+        intrinsics_matrix = np.array(camera_params['cam_K']).reshape(3, 3)
+        depth_scale = camera_params['depth_scale']
+        
+        print(f"Camera intrinsics:\n{intrinsics_matrix}")
+        print(f"Depth scale: {depth_scale}")
+        
+        # ========== Parse Object Labels ==========
+        labels = json.loads(example['labels'])
+        label = labels[0]  # Process first object
+        
+        rotation_matrix = np.array(label['cam_R_m2c_flat']).reshape(3, 3)
+        translation_vector = np.array(label['cam_t_m2c'])
+        bbox = [
+            label['bbox_x'],
+            label['bbox_y'],
+            label['bbox_width'],
+            label['bbox_height']
+        ]
+        
+        print(f"\nObject ID: {label['obj_id']}")
+        print(f"Rotation matrix:\n{rotation_matrix}")
+        print(f"Translation vector: {translation_vector}")
+        print(f"Bounding box (x, y, w, h): {bbox}\n")
+        
+        # ========== Visualize 2D ==========
+        if show_2d:
+            x, y, w, h = bbox
+            rgb_with_bbox = rgb_bgr.copy()
+            cv2.rectangle(rgb_with_bbox, (x, y), (x + w, y + h), (0, 255, 0), 2)
+            
+            cv2.imshow("RGB Image", rgb_with_bbox)
+            cv2.imshow("Depth Map", depth_vis)
+            print("Displaying 2D images (press any key to continue to 3D)...")
+            cv2.waitKey(0)
+        
+        # ========== Create 3D Point Cloud ==========
+        depth_metric = depth_map * depth_scale
+        point_cloud = back_project_rgbd(rgb_image, depth_metric, intrinsics_matrix.flatten())
+        
+        # Convert to Open3D format
+        pcd_o3d = o3d.geometry.PointCloud()
+        pcd_o3d.points = o3d.utility.Vector3dVector(point_cloud[:, :3].cpu().numpy())
+        if point_cloud.shape[1] > 3:
+            pcd_o3d.colors = o3d.utility.Vector3dVector(
+                point_cloud[:, 3:].cpu().numpy() / 255.0
+            )
+        
+        # ========== Load and Transform 3D Model ==========
+        model_path = os.path.join(target_dir, "models", f"obj_{label['obj_id']:06d}.ply")
+        model_mesh = o3d.io.read_triangle_mesh(model_path)
+        model_mesh.paint_uniform_color([1.0, 0.0, 0.0])  # Red
+        
+        # Apply pose transformation
+        pose_matrix = np.eye(4)
+        pose_matrix[:3, :3] = rotation_matrix
+        pose_matrix[:3, 3] = translation_vector
+        model_mesh.transform(pose_matrix)
+        
+        # ========== Visualize 3D ==========
+        print("Displaying 3D visualization (close window to continue)...")
+        o3d.visualization.draw_geometries(
+            [pcd_o3d, model_mesh],
+            window_name=f"CHIP Sample {idx + 1}: Scene + Model (Red)"
+        )
+        
+        if show_2d:
+            cv2.destroyAllWindows()
+        else:
+            # Small delay to prevent visualization from closing too quickly
+            cv2.waitKey(100)
+    
+    # Cleanup
+    del dataset
+    gc.collect()
+    print("\nVisualization complete!")
+
+
+if __name__ == "__main__":
+    # Example usage
+    
+    # Option 1: Show both 2D images and 3D point cloud
+    visualize_chip_sample(
+        repo_id="FBK-TeV/CHIP",
+        target_dir="./chip_data",
+        num_samples=1,
+        show_2d=True  # Display RGB and depth images
+    )
+    
+    # Option 2: Show only 3D point cloud visualization
+    # visualize_chip_sample(
+    #     repo_id="FBK-TeV/CHIP",
+    #     target_dir="./chip_data",
+    #     num_samples=1,
+    #     show_2d=False  # Skip 2D visualization
+    # )