droid/scripts/verify_wrist_camera_params.py

"""
Verify that wrist camera is using:
1. Refined extrinsics (not measured)
2. Correctly scaled intrinsics (640x360 base resolution)
"""

import sys
from pathlib import Path
sys.path.append(str(Path(__file__).parent.parent))

import numpy as np
import tensorflow as tf
tf.config.set_visible_devices([], 'GPU')
import tensorflow_datasets as tfds
import datetime
import re

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


def find_closest_calibration(episode, uuid_list):
    try:
        recording_path = episode['episode_metadata']['recording_folderpath'].numpy().decode('utf-8')
        match = re.search(r'/([A-Z]+)/success/(\d{4}-\d{2}-\d{2})/\w+_\w+_+\d+_(\d{2}):(\d{2}):(\d{2})_\d{4}/', recording_path)
        if not match:
            return None
        lab, date, hour, minute, second = match.groups()
        episode_time = datetime.datetime.strptime(f"{date} {hour}:{minute}:{second}", "%Y-%m-%d %H:%M:%S")
        matching_calibs = [uuid for uuid in uuid_list if uuid.startswith(f"{lab}+") and f"+{date}-" in uuid]
        if len(matching_calibs) == 0:
            return None
        best_uuid = None
        min_time_diff = float('inf')
        for calib_uuid in matching_calibs:
            parts = calib_uuid.split('+')
            if len(parts) >= 3:
                time_str = parts[2].replace('_cameras', '')
                match_time = re.search(r'(\d{2})h-(\d{2})m-(\d{2})s', time_str)
                if match_time:
                    calib_hour = int(match_time.group(1))
                    calib_min = int(match_time.group(2))
                    calib_sec = int(match_time.group(3))
                    calib_time = datetime.datetime.strptime(
                        f"{date} {calib_hour}:{calib_min}:{calib_sec}",
                        "%Y-%m-%d %H:%M:%S"
                    )
                    time_diff = abs((episode_time - calib_time).total_seconds())
                    if time_diff < min_time_diff:
                        min_time_diff = time_diff
                        best_uuid = calib_uuid
        return best_uuid
    except:
        return None


def main():
    print("=" * 80)
    print("Verifying Wrist Camera Parameters")
    print("=" * 80)

    calib_dir = '/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/vision/u/wenlongh/datasets/droid_v4/cameras'
    calib_loader = CameraCalibrationLoader(calib_dir)
    projector = FrankaMeshProjector(use_gui=False)

    calib_path = Path(calib_dir)
    uuid_list = [f.stem.replace('_cameras', '') for f in sorted(calib_path.glob("*_cameras.json"))]

    droid_path = '/mnt/kevin/data/droid/droid/1.0.0'
    builder = tfds.builder_from_directory(droid_path)
    dataset = builder.as_dataset(split='train')

    # Find first valid episode
    for episode_idx, episode in enumerate(dataset):
        uuid = find_closest_calibration(episode, uuid_list)
        if uuid is None or not calib_loader.has_refined_extrinsics(uuid):
            continue

        print(f"\nTesting episode {episode_idx}, UUID: {uuid}")

        # Load full calibration to compare
        calib = calib_loader.load_calibration(uuid)
        serials = [k for k in calib.keys() if k not in ['uuid', 'scene_path', 'optimization_summary', 'error_info']]

        # Find wrist camera
        wrist_serial = serials[1] if len(serials) > 1 else None
        if wrist_serial is None:
            continue

        cam_data = calib[wrist_serial]

        print("\n" + "=" * 80)
        print("Direct Calibration Data (from JSON):")
        print("=" * 80)

        K_measured = np.array(cam_data['measured_intrinsics'])
        E_measured = np.array(cam_data['measured_extrinsics'])
        E_refined = np.array(cam_data['refined_extrinsics'])

        print(f"\nWrist Camera Serial: {wrist_serial}")
        print(f"\nMeasured Intrinsics K:")
        print(K_measured)
        print(f"  fx={K_measured[0,0]:.2f}, fy={K_measured[1,1]:.2f}")
        print(f"  cx={K_measured[0,2]:.2f}, cy={K_measured[1,2]:.2f}")

        print(f"\nMeasured Extrinsics E:")
        print(E_measured)

        print(f"\nRefined Extrinsics E:")
        print(E_refined)

        print("\n" + "=" * 80)
        print("CameraCalibrationLoader.get_dual_view_params():")
        print("=" * 80)

        # Test with param_type='refined'
        dual_params = calib_loader.get_dual_view_params(uuid, param_type='refined', require_refined=True)
        K_wrist, E_wrist = dual_params['wrist']

        print(f"\nRequested: param_type='refined'")
        print(f"Received Intrinsics K:")
        print(K_wrist)
        print(f"  fx={K_wrist[0,0]:.2f}, fy={K_wrist[1,1]:.2f}")
        print(f"  cx={K_wrist[0,2]:.2f}, cy={K_wrist[1,2]:.2f}")

        print(f"\nReceived Extrinsics E:")
        print(E_wrist)

        print(f"\n✓ Using MEASURED intrinsics: {np.allclose(K_wrist, K_measured)}")
        print(f"✓ Using REFINED extrinsics: {np.allclose(E_wrist, E_refined)}")
        print(f"✗ Using MEASURED extrinsics: {np.allclose(E_wrist, E_measured)}")

        print("\n" + "=" * 80)
        print("Intrinsics Resolution Check:")
        print("=" * 80)

        # Check what resolution these intrinsics are for
        # cx should be ~320 for 640 width, cy should be ~180 for 360 height
        cx = K_wrist[0, 2]
        cy = K_wrist[1, 2]

        print(f"\nIntrinsics principal point: cx={cx:.1f}, cy={cy:.1f}")
        print(f"Expected for 640x360: cx≈320, cy≈180")
        print(f"Expected for 640x480: cx≈320, cy≈240")

        if abs(cy - 180) < abs(cy - 240):
            print(f"✓ Intrinsics appear to be for 640x360 (cy={cy:.1f} closer to 180)")
        else:
            print(f"⚠ Intrinsics appear to be for 640x480 (cy={cy:.1f} closer to 240)")

        print("\n" + "=" * 80)
        print("Projection Scaling Check:")
        print("=" * 80)

        # Get a wrist image to see actual resolution
        step = next(iter(episode['steps']))
        img_wrist = step['observation']['wrist_image_left'].numpy()
        img_h, img_w = img_wrist.shape[:2]

        print(f"\nActual wrist image resolution: {img_w}x{img_h}")
        print(f"Intrinsics base resolution (from cy): 640x{int(cy*2)}")

        print(f"\nProjection scaling applied by FrankaMeshProjector:")
        print(f"  original_w, original_h = 640, 360  (HARDCODED in line 500)")
        print(f"  scale_x = {img_w}/640 = {img_w/640:.4f}")
        print(f"  scale_y = {img_h}/360 = {img_h/360:.4f}")

        if img_h == 180:
            print(f"\n✓ Scaling is CORRECT:")
            print(f"    Image is 180 high, intrinsics for 360, scale = 180/360 = 0.5")
        else:
            print(f"\n⚠ Check scaling:")
            print(f"    Image is {img_h} high, intrinsics for {int(cy*2)}, scale = {img_h}/{int(cy*2)}")

        break

    print("\n" + "=" * 80)
    print("Summary:")
    print("=" * 80)
    print("1. Wrist camera uses MEASURED intrinsics (always)")
    print("2. Wrist camera uses REFINED extrinsics (when param_type='refined')")
    print("3. Projection scaling: 640x360 -> 320x180 (scale 0.5 on both axes)")
    print("=" * 80)


if __name__ == "__main__":
    main()