scripts/add_pointcloud.py

"""
Script to add pointcloud data to MSHAB HDF5 datasets.

This script reads existing HDF5 trajectory files and generates pointcloud data
from the position and RGB camera observations using ManiSkill's native methodology.
The pointcloud computation aligns with ManiSkill's sensor_data_to_pointcloud function.

Usage:
    python add_pointcloud.py [--data-dir PATH] [--dry-run]
"""

import argparse
import sys
from pathlib import Path
import h5py
import numpy as np
from tqdm import tqdm
from functools import partial
from tqdm.contrib.concurrent import process_map

# Add ManiSkill to path
sys.path.insert(0, str(Path(__file__).parent.parent / "ManiSkill"))


def _func_wrapper(func, args):
    """Wrapper function for process_map to unpack arguments."""
    return func(*args)


def process_map_args_list(func, args, max_workers=22, chunksize=1, desc=None):
    """Execute function in parallel with a list of arguments."""
    func_star = partial(_func_wrapper, func)
    result_list = process_map(func_star, args, max_workers=max_workers, chunksize=chunksize, desc=desc)
    return result_list


def generate_pointcloud_from_cameras(sensor_data, sensor_params, timestep=0):
    """
    Generate pointcloud from multi-camera sensor data at a specific timestep.
    Aligns with ManiSkill's sensor_data_to_pointcloud and eval_mshab.py logic.

    Args:
        sensor_data: Dict of camera observations with 'rgb', 'position', and 'segmentation'
        sensor_params: Dict of camera parameters
        timestep: Timestep index

    Returns:
        pointcloud: Dict with 'xyzw' (N, 4), 'rgb' (N, 3)
    """
    all_points = []
    all_colors = []

    for cam_name, cam_data in sensor_data.items():
        cam2world = sensor_params[cam_name]['cam2world_gl'][timestep] if cam_name in sensor_params else np.eye(4, dtype=np.float32)

        # Get RGB, position, and segmentation
        rgb = cam_data['rgb']
        position = cam_data['position']  # (H, W, 3)
        segmentation = cam_data['segmentation']  # (H, W, 1) or (H, W)

        # Convert position from millimeters to meters (ManiSkill convention)
        position = position.astype(np.float32)
        position[..., :3] = position[..., :3] / 1000.0

        # Ensure segmentation is (H, W)
        while len(segmentation.shape) > 2:
            segmentation = segmentation.squeeze(-1)

        # Create (H, W, 4) array: xyz + mask (following ManiSkill's logic)
        xyzw = np.concatenate([position, (segmentation != 0).astype(np.float32)[..., None]], axis=-1)

        # Transform to world space
        xyzw = xyzw.reshape(-1, 4) @ cam2world.T

        # Filter valid points
        mask = xyzw[:, 3] > 0.5
        points = xyzw[mask, :3]
        colors = rgb.reshape(-1, 3)[mask]

        all_points.append(points)
        all_colors.append(colors)

    # Concatenate all cameras
    if len(all_points) > 0:
        pointcloud_xyz = np.concatenate(all_points, axis=0)
        pointcloud_rgb = np.concatenate(all_colors, axis=0)
        pointcloud_xyzw = np.concatenate([pointcloud_xyz, np.ones((len(pointcloud_xyz), 1), dtype=np.float32)], axis=1)
    else:
        pointcloud_xyzw = np.zeros((0, 4), dtype=np.float32)
        pointcloud_rgb = np.zeros((0, 3), dtype=np.uint8)

    return {
        'xyzw': pointcloud_xyzw.astype(np.float32),
        'rgb': pointcloud_rgb.astype(np.uint8)
    }


def generate_pointcloud_for_timestep(t, sensor_data_dict, sensor_params_dict):
    """
    Generate pointcloud for a single timestep (helper for parallel processing).

    Args:
        t: Timestep index
        sensor_data_dict: Dict with camera data for all timesteps (numpy arrays, not HDF5)
        sensor_params_dict: Dict with camera parameters (numpy arrays, not HDF5)

    Returns:
        tuple: (xyzw, rgb) arrays for this timestep
    """
    # Extract data for this timestep
    timestep_sensor_data = {}
    for cam_name in sensor_data_dict.keys():
        timestep_sensor_data[cam_name] = {
            'rgb': sensor_data_dict[cam_name]['rgb'][t],
            'position': sensor_data_dict[cam_name]['position'][t],
            'segmentation': sensor_data_dict[cam_name]['segmentation'][t]
        }

    # Generate pointcloud
    pc = generate_pointcloud_from_cameras(timestep_sensor_data, sensor_params_dict, timestep=t)
    return pc['xyzw'], pc['rgb']


def add_pointcloud_to_trajectory(traj_group, use_parallel=True, max_workers=16):
    """
    Add pointcloud data to a single trajectory group.

    Args:
        traj_group: HDF5 group for a trajectory
        use_parallel: Whether to use parallel processing for timesteps
        max_workers: Number of parallel workers

    Returns:
        success: Boolean indicating if pointcloud was successfully added
    """
    obs_group = traj_group['obs']

    # Check if pointcloud already exists
    if 'pointcloud' in obs_group:
        return True, "already_exists"

    sensor_data = obs_group['sensor_data']
    sensor_params = obs_group['sensor_param']

    # Get number of timesteps from first camera
    first_cam = list(sensor_data.keys())[0]
    num_timesteps = sensor_data[first_cam]['rgb'].shape[0]

    # Load all sensor data into memory as numpy arrays (not HDF5 objects)
    sensor_data_dict = {}
    for cam_name in sensor_data.keys():
        sensor_data_dict[cam_name] = {
            'rgb': np.array(sensor_data[cam_name]['rgb'][:]),
            'position': np.array(sensor_data[cam_name]['position'][:]),
            'segmentation': np.array(sensor_data[cam_name]['segmentation'][:])
        }

    # Load sensor params into memory as numpy arrays
    sensor_params_dict = {}
    for cam_name, cam_params in sensor_params.items():
        sensor_params_dict[cam_name] = {}
        for key, value in cam_params.items():
            sensor_params_dict[cam_name][key] = np.array(value[:])

    if use_parallel and num_timesteps > 10:
        # Parallel processing for large trajectories
        args_list = [(t, sensor_data_dict, sensor_params_dict) for t in range(num_timesteps)]
        results = process_map_args_list(
            generate_pointcloud_for_timestep,
            args_list,
            max_workers=max_workers,
            chunksize=max(1, num_timesteps // (max_workers * 4)),
            desc=f"Processing {traj_group.name}"
        )
        pointclouds_xyzw = [r[0] for r in results]
        pointclouds_rgb = [r[1] for r in results]
    else:
        # Sequential processing for small trajectories
        pointclouds_xyzw = []
        pointclouds_rgb = []
        for t in range(num_timesteps):
            xyzw, rgb = generate_pointcloud_for_timestep(t, sensor_data_dict, sensor_params_dict)
            pointclouds_xyzw.append(xyzw)
            pointclouds_rgb.append(rgb)

    # Find max points across all timesteps for fixed-size storage
    max_points = max(len(pc) for pc in pointclouds_xyzw)

    if max_points == 0:
        print(f"Warning: No valid points generated for {traj_group.name}")
        max_points = 1  # Avoid zero-size arrays

    # Create fixed-size arrays with padding
    pc_xyzw_padded = np.zeros((num_timesteps, max_points, 4), dtype=np.float32)
    pc_rgb_padded = np.zeros((num_timesteps, max_points, 3), dtype=np.uint8)
    pc_mask = np.zeros((num_timesteps, max_points), dtype=bool)

    for t, (xyzw, rgb) in enumerate(zip(pointclouds_xyzw, pointclouds_rgb)):
        n_pts = len(xyzw)
        if n_pts > 0:
            pc_xyzw_padded[t, :n_pts] = xyzw
            pc_rgb_padded[t, :n_pts] = rgb
            pc_mask[t, :n_pts] = True

    # Create pointcloud group
    pc_group = obs_group.create_group('pointcloud')
    pc_group.create_dataset('xyzw', data=pc_xyzw_padded, compression='gzip', compression_opts=4)
    pc_group.create_dataset('rgb', data=pc_rgb_padded, compression='gzip', compression_opts=4)
    pc_group.create_dataset('mask', data=pc_mask, compression='gzip', compression_opts=4)

    # Store metadata
    pc_group.attrs['max_points'] = max_points
    pc_group.attrs['description'] = 'Pointcloud data generated from RGB-D cameras'

    return True, "success"


def process_hdf5_file(h5_path, dry_run=False, use_parallel=True, max_workers=16):
    """
    Process a single HDF5 file to add pointcloud data.

    Args:
        h5_path: Path to HDF5 file
        dry_run: If True, only check file without modifying
        use_parallel: Whether to use parallel processing
        max_workers: Number of parallel workers

    Returns:
        stats: Dictionary with processing statistics
    """
    stats = {
        'total': 0,
        'success': 0,
        'already_exists': 0,
    }

    mode = 'r' if dry_run else 'r+'

    with h5py.File(h5_path, mode) as f:
        # Get all trajectory groups
        traj_keys = [k for k in f.keys() if k.startswith('traj_')]
        stats['total'] = len(traj_keys)

        for traj_key in tqdm(traj_keys, desc=f"Processing {h5_path.name}", leave=False):
            if dry_run:
                # Just check if pointcloud exists
                if 'pointcloud' in f[traj_key]['obs']:
                    stats['already_exists'] += 1
                else:
                    stats['success'] += 1  # Would be added
            else:
                success, message = add_pointcloud_to_trajectory(
                    f[traj_key],
                    use_parallel=use_parallel,
                    max_workers=max_workers
                )
                if success:
                    if message == "already_exists":
                        stats['already_exists'] += 1
                    else:
                        stats['success'] += 1

    return stats


def main():
    parser = argparse.ArgumentParser(description='Add pointcloud data to MSHAB HDF5 datasets')
    parser.add_argument(
        '--data-dir',
        type=str,
        default='mshab_data/gen_data_save_trajectories',
        help='Root directory containing the dataset'
    )
    parser.add_argument(
        '--dry-run',
        action='store_true',
        help='Check files without modifying them'
    )
    parser.add_argument(
        '--task',
        type=str,
        default=None,
        help='Process only specific task (e.g., set_table)'
    )
    parser.add_argument(
        '--subtask',
        type=str,
        default=None,
        help='Process only specific subtask (e.g., pick)'
    )
    parser.add_argument(
        '--no-parallel',
        action='store_true',
        help='Disable parallel processing (use sequential mode)'
    )
    parser.add_argument(
        '--max-workers',
        type=int,
        default=16,
        help='Number of parallel workers for processing timesteps (default: 16)'
    )

    args = parser.parse_args()

    data_dir = Path(args.data_dir)
    if not data_dir.exists():
        print(f"Error: Data directory {data_dir} does not exist")
        return 1

    # Find all HDF5 files
    if args.task:
        if args.subtask:
            pattern = f"{args.task}/{args.subtask}/**/train/**/*.h5"
        else:
            pattern = f"{args.task}/**/train/**/*.h5"
    else:
        pattern = "**/train/**/*.h5"

    h5_files = list(data_dir.glob(pattern))

    if len(h5_files) == 0:
        print(f"No HDF5 files found in {data_dir} with pattern {pattern}")
        return 1

    print(f"Found {len(h5_files)} HDF5 files to process")
    if args.dry_run:
        print("DRY RUN MODE - No files will be modified")

    use_parallel = not args.no_parallel
    if use_parallel:
        print(f"Parallel processing ENABLED with {args.max_workers} workers per trajectory")
    else:
        print("Parallel processing DISABLED (sequential mode)")

    # Process all files
    total_stats = {
        'files_processed': 0,
        'total_trajectories': 0,
        'success': 0,
        'already_exists': 0,
    }

    for h5_file in tqdm(h5_files, desc="Processing HDF5 files"):
        stats = process_hdf5_file(
            h5_file,
            dry_run=args.dry_run,
            use_parallel=use_parallel,
            max_workers=args.max_workers
        )

        total_stats['files_processed'] += 1
        total_stats['total_trajectories'] += stats['total']
        total_stats['success'] += stats['success']
        total_stats['already_exists'] += stats['already_exists']

    # Print summary
    print("\n" + "="*60)
    print("PROCESSING SUMMARY")
    print("="*60)
    print(f"Files processed: {total_stats['files_processed']}")
    print(f"Total trajectories: {total_stats['total_trajectories']}")
    print(f"Successfully added: {total_stats['success']}")
    print(f"Already existed: {total_stats['already_exists']}")
    print("="*60)

    return 0


if __name__ == '__main__':
    sys.exit(main())