droid/scripts/validate_cartesian_projection.py

"""
Validation Script for Cartesian-Based Mesh Projection

Tests and compares:
1. FK-based projection (joint_position → PyBullet FK → mesh points)
2. Cartesian-based projection (cartesian_position → direct transform → mesh points)

Outputs visualization showing both methods side-by-side.
"""

import numpy as np
import tensorflow_datasets as tfds
from pathlib import Path
import argparse
import cv2
import sys

# Add parent directory to path
sys.path.append(str(Path(__file__).parent.parent))

from utils.load_camera_calibration import CameraCalibrationLoader
from utils.franka_mesh_projection import FrankaMeshProjector


def visualize_comparison(img: np.ndarray,
                        points_fk: np.ndarray,
                        points_cart: np.ndarray,
                        vis_fk: np.ndarray,
                        vis_cart: np.ndarray,
                        title: str = "") -> np.ndarray:
    """
    Create side-by-side comparison of FK vs Cartesian projections.

    Args:
        img: Base image (H, W, 3)
        points_fk: Points from FK method (32, 2)
        points_cart: Points from Cartesian method (32, 2)
        vis_fk: Visibility mask from FK (32,)
        vis_cart: Visibility mask from Cartesian (32,)
        title: Title for visualization

    Returns:
        Combined visualization image
    """
    # Create two copies of the image
    img_fk = img.copy()
    img_cart = img.copy()

    # Draw FK points (blue for grid, green for mesh)
    for i in range(32):
        if vis_fk[i]:
            pt = tuple(points_fk[i].astype(int))
            color = (0, 0, 255) if i < 25 else (0, 255, 0)  # Blue grid, green mesh
            cv2.circle(img_fk, pt, 3, color, -1)
            cv2.putText(img_fk, str(i), (pt[0]+5, pt[1]-5),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.3, color, 1)

    # Draw Cartesian points (blue for grid, red for mesh)
    for i in range(32):
        if vis_cart[i]:
            pt = tuple(points_cart[i].astype(int))
            color = (0, 0, 255) if i < 25 else (255, 0, 0)  # Blue grid, red mesh
            cv2.circle(img_cart, pt, 3, color, -1)
            cv2.putText(img_cart, str(i), (pt[0]+5, pt[1]-5),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.3, color, 1)

    # Add labels
    cv2.putText(img_fk, "FK (Joint → PyBullet)", (10, 30),
               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
    cv2.putText(img_cart, "Cartesian (Direct Transform)", (10, 30),
               cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)

    # Compute difference for mesh points (last 7)
    mesh_diff = np.linalg.norm(points_fk[25:] - points_cart[25:], axis=1)
    avg_diff = np.mean(mesh_diff)
    max_diff = np.max(mesh_diff)

    cv2.putText(img_cart, f"Avg diff: {avg_diff:.1f}px", (10, 60),
               cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)
    cv2.putText(img_cart, f"Max diff: {max_diff:.1f}px", (10, 90),
               cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2)

    # Combine side-by-side
    combined = np.hstack([img_fk, img_cart])

    # Add title
    if title:
        title_bar = np.zeros((50, combined.shape[1], 3), dtype=np.uint8)
        cv2.putText(title_bar, title, (10, 35),
                   cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 255, 255), 2)
        combined = np.vstack([title_bar, combined])

    return combined


def validate_episode(droid_path: str,
                     calib_dir: str,
                     episode_index: int = 0,
                     num_frames: int = 5,
                     output_dir: str = "/tmp/droid_validation"):
    """
    Validate cartesian projection on a single DROID episode.

    Args:
        droid_path: Path to DROID RLDS dataset
        calib_dir: Path to camera calibration directory
        episode_index: Episode index to test
        num_frames: Number of frames to visualize
        output_dir: Directory for output images
    """
    print(f"Loading DROID episode {episode_index}...")

    # Load RLDS dataset
    builder = tfds.builder_from_directory(droid_path)
    dataset = builder.as_dataset(split='train')

    # Initialize tools
    calib_loader = CameraCalibrationLoader(calib_dir)
    projector = FrankaMeshProjector(use_gui=False)

    # Find episode
    for idx, episode in enumerate(dataset):
        if idx != episode_index:
            continue

        # Extract metadata
        try:
            recording_path = episode['episode_metadata']['recording_folderpath'].numpy().decode('utf-8')
            print(f"  Recording: {recording_path}")
        except:
            print(f"  Warning: Could not extract recording path")

        # Get steps
        steps = list(episode['steps'])
        print(f"  Total steps: {len(steps)}")

        # Try to extract UUID from episode metadata
        uuid = None
        try:
            # DROID stores UUID in different possible fields
            if 'uuid' in episode['episode_metadata']:
                uuid = episode['episode_metadata']['uuid'].numpy().decode('utf-8')
                print(f"  UUID from metadata: {uuid}")
            else:
                # Try to find it from file_path or other fields
                print(f"  Warning: UUID not found in episode_metadata")
                print(f"  Available keys: {list(episode['episode_metadata'].keys())}")

                # List all camera calibration files to find potential matches
                from pathlib import Path
                calib_path = Path(calib_dir)
                calib_files = sorted(calib_path.glob("*_cameras.json"))
                print(f"  Found {len(calib_files)} calibration files")

                if len(calib_files) > 0:
                    # Try first calibration file as test
                    uuid = calib_files[episode_index % len(calib_files)].stem.replace('_cameras', '')
                    print(f"  Using test UUID: {uuid}")
                else:
                    print(f"✗ No calibration files found")
                    return

        except Exception as e:
            print(f"✗ Error extracting UUID: {e}")
            import traceback
            traceback.print_exc()
            return

        if uuid is None:
            print(f"✗ Could not determine UUID for episode")
            return

        try:
            # Check if refined extrinsics available
            has_refined = calib_loader.has_refined_extrinsics(uuid)
            print(f"  Refined extrinsics: {has_refined}")

            # Load calibration (with fallback)
            dual_params = calib_loader.get_dual_view_params(
                uuid,
                param_type='refined',
                require_refined=False
            )

            if dual_params is None:
                print(f"✗ No camera calibration available for UUID: {uuid}")
                return

        except Exception as e:
            print(f"✗ Error loading calibration for {uuid}: {e}")
            import traceback
            traceback.print_exc()
            return

        # Create output directory
        output_path = Path(output_dir)
        output_path.mkdir(parents=True, exist_ok=True)

        # Sample frames uniformly
        sample_indices = np.linspace(0, len(steps)-1, num_frames, dtype=int)

        print(f"\nProcessing {num_frames} frames...")
        print("=" * 80)

        for i, step_idx in enumerate(sample_indices):
            step = steps[step_idx]

            # Get robot states
            joint_pos = step['observation']['joint_position'].numpy()
            cart_pos = step['observation']['cartesian_position'].numpy()

            print(f"\nFrame {step_idx} ({i+1}/{num_frames}):")
            print(f"  Joint position: {joint_pos}")
            print(f"  Cartesian position: {cart_pos}")

            # Process exterior camera
            img_ext_bytes = step['observation']['exterior_image_1_left'].numpy()
            img_ext = cv2.imdecode(np.frombuffer(img_ext_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)

            if img_ext is None:
                print(f"  ✗ Failed to decode exterior image")
                continue

            img_ext = cv2.resize(img_ext, (448, 448))
            img_ext_rgb = cv2.cvtColor(img_ext, cv2.COLOR_BGR2RGB)

            K_ext, E_ext = dual_params['exterior_1']

            # FK-based projection
            points_fk, vis_fk = projector.project_32_points(
                joint_pos, K_ext, E_ext, img_h=448, img_w=448
            )

            # Cartesian-based projection (Euler XYZ - confirmed by rotation format test)
            points_cart, vis_cart = projector.project_32_points_cartesian(
                cart_pos, K_ext, E_ext, img_h=448, img_w=448, rotation_format='euler_xyz'
            )

            # Compute differences for mesh points (indices 25-31)
            mesh_diff = np.linalg.norm(points_fk[25:] - points_cart[25:], axis=1)

            print(f"  Mesh point differences (FK vs Cartesian):")
            for j, diff in enumerate(mesh_diff):
                vis_str = "✓" if (vis_fk[25+j] and vis_cart[25+j]) else "✗"
                print(f"    Point {25+j}: {diff:6.2f}px {vis_str}")
            print(f"  Average: {np.mean(mesh_diff):.2f}px")
            print(f"  Maximum: {np.max(mesh_diff):.2f}px")

            # Create visualization
            viz = visualize_comparison(
                img_ext_rgb,
                points_fk,
                points_cart,
                vis_fk,
                vis_cart,
                title=f"Episode {episode_index} | Frame {step_idx} | Exterior Camera"
            )

            # Save
            output_file = output_path / f"frame_{step_idx:04d}_exterior.jpg"
            cv2.imwrite(str(output_file), cv2.cvtColor(viz, cv2.COLOR_RGB2BGR))
            print(f"  ✓ Saved: {output_file}")

            # Process wrist camera
            img_wrist_bytes = step['observation']['wrist_image_left'].numpy()
            img_wrist = cv2.imdecode(np.frombuffer(img_wrist_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)

            if img_wrist is not None:
                img_wrist = cv2.resize(img_wrist, (448, 448))
                img_wrist_rgb = cv2.cvtColor(img_wrist, cv2.COLOR_BGR2RGB)

                K_wrist, E_wrist = dual_params['wrist']

                points_fk_w, vis_fk_w = projector.project_32_points(
                    joint_pos, K_wrist, E_wrist, img_h=448, img_w=448
                )

                points_cart_w, vis_cart_w = projector.project_32_points_cartesian(
                    cart_pos, K_wrist, E_wrist, img_h=448, img_w=448, rotation_format='auto'
                )

                viz_wrist = visualize_comparison(
                    img_wrist_rgb,
                    points_fk_w,
                    points_cart_w,
                    vis_fk_w,
                    vis_cart_w,
                    title=f"Episode {episode_index} | Frame {step_idx} | Wrist Camera"
                )

                output_file_wrist = output_path / f"frame_{step_idx:04d}_wrist.jpg"
                cv2.imwrite(str(output_file_wrist), cv2.cvtColor(viz_wrist, cv2.COLOR_RGB2BGR))
                print(f"  ✓ Saved: {output_file_wrist}")

        print(f"\n{'='*80}")
        print(f"✓ Validation complete. Output saved to: {output_path}")

        return

    print(f"✗ Episode {episode_index} not found")


def main():
    parser = argparse.ArgumentParser(
        description="Validate cartesian-based mesh projection on DROID data"
    )

    parser.add_argument(
        '--droid-path',
        type=str,
        default='/mnt/kevin/data/droid/droid/1.0.0',
        help='Path to DROID RLDS dataset'
    )
    parser.add_argument(
        '--calib-dir',
        type=str,
        default='/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/vision/u/wenlongh/datasets/droid_v4/cameras',
        help='Path to camera calibration directory'
    )
    parser.add_argument(
        '--episode-index',
        type=int,
        default=0,
        help='Episode index to validate'
    )
    parser.add_argument(
        '--num-frames',
        type=int,
        default=5,
        help='Number of frames to visualize'
    )
    parser.add_argument(
        '--output-dir',
        type=str,
        default='/tmp/droid_validation',
        help='Output directory for visualizations'
    )

    args = parser.parse_args()

    print("=" * 80)
    print("DROID Cartesian Projection Validation")
    print("=" * 80)
    print()

    validate_episode(
        args.droid_path,
        args.calib_dir,
        args.episode_index,
        args.num_frames,
        args.output_dir
    )


if __name__ == "__main__":
    main()