""" Compare refined vs measured extrinsics with side-by-side videos. Shows projection and tracking quality differences between: - Left: Refined extrinsics - Right: Measured extrinsics """ import sys from pathlib import Path sys.path.append(str(Path(__file__).parent.parent)) import os import numpy as np import torch import mediapy as media import tensorflow as tf tf.config.set_visible_devices([], 'GPU') import tensorflow_datasets as tfds import cv2 import datetime import re from utils.load_camera_calibration import CameraCalibrationLoader from utils.franka_mesh_projection import FrankaMeshProjector def load_cotracker(): """Load CoTracker v3 model.""" from cotracker.predictor import CoTrackerPredictor device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = CoTrackerPredictor(checkpoint='/mnt/kevin/vlm_models/cotracker/scaled_offline.pth') model = model.to(device) model.eval() return model, device def find_closest_calibration(episode, uuid_list): """Find closest calibration by timestamp.""" 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 process_with_extrinsics(episode, uuid, calib_loader, projector, cotracker, device, extrinsics_type='refined', max_frames=16): """Process episode with specified extrinsics type.""" # Get calibration calib = calib_loader.load_calibration(uuid) serials = [k for k in calib.keys() if k not in ['uuid', 'scene_path', 'optimization_summary']] cam_data = calib[serials[0]] # exterior camera # Check if this extrinsics type exists if f'{extrinsics_type}_extrinsics' not in cam_data: return None K = np.array(cam_data['measured_intrinsics']) E = np.array(cam_data[f'{extrinsics_type}_extrinsics']) # Collect frames frames = [] actions = [] for step_idx, step in enumerate(episode['steps']): if step_idx >= max_frames: break img = step['observation']['exterior_image_1_left'].numpy() if img is None or len(img.shape) != 3: return None frames.append(img) actions.append(step['action'].numpy()) if len(frames) < 10: return None img_h, img_w = frames[0].shape[:2] # Project action position (gripper base) action_pos_0 = actions[0] eef_pos_3d = action_pos_0[:3].reshape(1, 3) eef_2d, eef_vis = projector._project_3d_to_2d( eef_pos_3d, K, E, img_h=img_h, img_w=img_w ) if not eef_vis[0]: return None # Run CoTracker video_np = np.array(frames).transpose(0, 3, 1, 2) video_tensor = torch.from_numpy(video_np).float() / 255.0 video_tensor = video_tensor.unsqueeze(0).to(device) queries = np.zeros((1, 3)) queries[0, 0] = 0 queries[0, 1] = eef_2d[0, 0] queries[0, 2] = eef_2d[0, 1] queries_tensor = torch.from_numpy(queries).float().unsqueeze(0).to(device) with torch.no_grad(): pred_tracks, pred_visibility = cotracker( video_tensor, queries=queries_tensor, backward_tracking=False ) tracks = pred_tracks[0].cpu().numpy() visibility = pred_visibility[0].cpu().numpy() return { 'frames': frames, 'eef_2d_init': eef_2d[0], 'tracks': tracks, 'visibility': visibility, 'extrinsics_type': extrinsics_type } def create_comparison_video(result_refined, result_measured, output_path): """Create side-by-side comparison video.""" frames_refined = result_refined['frames'] frames_measured = result_measured['frames'] tracks_refined = result_refined['tracks'] visibility_refined = result_refined['visibility'] tracks_measured = result_measured['tracks'] visibility_measured = result_measured['visibility'] eef_refined = result_refined['eef_2d_init'] eef_measured = result_measured['eef_2d_init'] video_frames = [] for frame_idx in range(len(frames_refined)): # Visualize refined viz_refined = frames_refined[frame_idx].copy() # Draw initial projection (red circle) cv2.circle(viz_refined, tuple(eef_refined.astype(int)), 5, (0, 0, 255), 2) # Draw tracked point (green) if visibility_refined[frame_idx, 0]: pt = tuple(tracks_refined[frame_idx, 0].astype(int)) cv2.circle(viz_refined, pt, 3, (0, 255, 0), -1) # Draw trajectory if frame_idx > 0: for t in range(max(0, frame_idx-10), frame_idx): if visibility_refined[t, 0] and visibility_refined[t+1, 0]: pt1 = tuple(tracks_refined[t, 0].astype(int)) pt2 = tuple(tracks_refined[t+1, 0].astype(int)) cv2.line(viz_refined, pt1, pt2, (0, 255, 0), 1) # Add title cv2.putText(viz_refined, "REFINED Extrinsics", (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) cv2.putText(viz_refined, f"Init: [{eef_refined[0]:.1f}, {eef_refined[1]:.1f}]", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1) # Visualize measured viz_measured = frames_measured[frame_idx].copy() # Draw initial projection (red circle) cv2.circle(viz_measured, tuple(eef_measured.astype(int)), 5, (0, 0, 255), 2) # Draw tracked point (green) if visibility_measured[frame_idx, 0]: pt = tuple(tracks_measured[frame_idx, 0].astype(int)) cv2.circle(viz_measured, pt, 3, (0, 255, 0), -1) # Draw trajectory if frame_idx > 0: for t in range(max(0, frame_idx-10), frame_idx): if visibility_measured[t, 0] and visibility_measured[t+1, 0]: pt1 = tuple(tracks_measured[t, 0].astype(int)) pt2 = tuple(tracks_measured[t+1, 0].astype(int)) cv2.line(viz_measured, pt1, pt2, (0, 255, 0), 1) # Add title cv2.putText(viz_measured, "MEASURED Extrinsics", (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2) cv2.putText(viz_measured, f"Init: [{eef_measured[0]:.1f}, {eef_measured[1]:.1f}]", (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 0.4, (255, 255, 255), 1) # Concatenate side by side combined = np.concatenate([viz_refined, viz_measured], axis=1) # Add frame counter and legend cv2.putText(combined, f"Frame {frame_idx}/{len(frames_refined)}", (combined.shape[1]//2 - 50, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 2) cv2.putText(combined, "Red=Initial Projection, Green=CoTracker", (10, combined.shape[0] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 0), 1) video_frames.append(combined) # Save video media.write_video(str(output_path), video_frames, fps=10) def main(): output_dir = Path('/tmp/droid_extrinsics_comparison') output_dir.mkdir(parents=True, exist_ok=True) print("=" * 80) print("Comparing Refined vs Measured Extrinsics") print("=" * 80) # Initialize 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) cotracker, device = load_cotracker() calib_path = Path(calib_dir) uuid_list = [f.stem.replace('_cameras', '') for f in sorted(calib_path.glob("*_cameras.json"))] # Load dataset droid_path = '/mnt/kevin/data/droid/droid/1.0.0' print("Loading DROID dataset...") builder = tfds.builder_from_directory(droid_path) dataset = builder.as_dataset(split='train') # Find episodes with both refined and measured num_videos = 3 # Create 3 comparison videos created_count = 0 for episode_idx, episode in enumerate(dataset): if created_count >= num_videos: break uuid = find_closest_calibration(episode, uuid_list) if uuid is None: continue # Check if both refined and measured are available calib = calib_loader.load_calibration(uuid) serials = [k for k in calib.keys() if k not in ['uuid', 'scene_path', 'optimization_summary']] cam_data = calib[serials[0]] if 'refined_extrinsics' not in cam_data or 'measured_extrinsics' not in cam_data: continue print(f"\nProcessing episode {episode_idx}...") # Process with both extrinsics types result_refined = process_with_extrinsics( episode, uuid, calib_loader, projector, cotracker, device, extrinsics_type='refined', max_frames=16 ) result_measured = process_with_extrinsics( episode, uuid, calib_loader, projector, cotracker, device, extrinsics_type='measured', max_frames=16 ) if result_refined is None or result_measured is None: print(f" Skipped - processing failed") continue # Create comparison video output_path = output_dir / f"comparison_episode_{episode_idx:04d}.mp4" create_comparison_video(result_refined, result_measured, output_path) print(f" Refined projection: {result_refined['eef_2d_init']}") print(f" Measured projection: {result_measured['eef_2d_init']}") print(f" Difference: {result_refined['eef_2d_init'] - result_measured['eef_2d_init']}") print(f" ✓ Saved: {output_path}") created_count += 1 print("\n" + "=" * 80) print(f"Created {created_count} comparison videos") print(f"Output directory: {output_dir}") print("=" * 80) if __name__ == "__main__": main()