droid/extract_depth_for_tracking.py

#!/usr/bin/env python3
"""
Extract depth maps from SVO files for depth-enhanced tracking
Organizes depth data to match the MP4 file structure
"""

import os
import sys
from pathlib import Path
import numpy as np
import json
from tqdm import tqdm
import argparse
import imageio
import cv2

# Add paths
sys.path.append(str(script_dir.parent))
sys.path.append(str(script_dir.parent / 'droid-repo'))

try:
    import pyzed.sl as sl
    print("✓ pyzed imported successfully")
except ImportError as e:
    print(f"✗ Failed to import pyzed: {e}")
    print("\nPlease ensure:")
    print("1. conda activate DROID2")
    print("2. export LD_LIBRARY_PATH=/usr/local/zed/lib:$LD_LIBRARY_PATH")
    print("3. export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6")
    sys.exit(1)


class DepthExtractorForTracking:
    """Extract and organize depth maps for tracking pipeline"""
    
    def __init__(self, data_dir: Path, output_dir: Path = None):
        self.data_dir = Path(data_dir)
        if output_dir is None:
            self.output_dir = self.data_dir / 'depth_maps'
        else:
            self.output_dir = Path(output_dir)
        
        self.output_dir.mkdir(parents=True, exist_ok=True)
        
        # Find metadata
        metadata_files = list(self.data_dir.glob('metadata_*.json'))
        if not metadata_files:
            raise FileNotFoundError(f"No metadata file found in {data_dir}")
        
        self.metadata_path = metadata_files[0]
        with open(self.metadata_path, 'r') as f:
            self.metadata = json.load(f)
        
        print(f"Initialized depth extractor")
        print(f"  Data dir: {self.data_dir}")
        print(f"  Output dir: {self.output_dir}")
        print(f"  Metadata: {self.metadata_path.name}")
    
    def extract_depth_from_svo(self, svo_path: Path, camera_serial: str,
                              frequency: int = 1, max_frames: int = None,
                              skip_if_exists: bool = True) -> bool:
        """Extract depth maps from a single SVO file
        
        Args:
            svo_path: Path to SVO file
            camera_serial: Camera serial number (for output organization)
            frequency: Extract every N frames (1 = all frames)
            max_frames: Maximum frames to extract (None = all)
            skip_if_exists: Skip extraction if depth maps already exist
        
        Returns:
            Success status
        """
        if not svo_path.exists():
            print(f"✗ SVO file not found: {svo_path}")
            return False
        
        # Create output directory for this camera
        camera_depth_dir = self.output_dir / camera_serial
        
        # Check if depth maps already exist
        if skip_if_exists and camera_depth_dir.exists():
            existing_depth_files = list(camera_depth_dir.glob('depth_*.npy'))
            if existing_depth_files:
                # Check if we have depth info file
                depth_info_path = camera_depth_dir / 'depth_info.json'
                if depth_info_path.exists():
                    with open(depth_info_path, 'r') as f:
                        depth_info = json.load(f)
                    print(f"✓ Depth maps already exist for {camera_serial}:")
                    print(f"  Found {len(existing_depth_files)} depth files")
                    print(f"  Extracted frames: {depth_info.get('extracted_frames', 'unknown')}")
                    print(f"  Frequency: {depth_info.get('frequency', 'unknown')}")
                    print(f"  Skipping extraction (use --force to override)")
                    return True
        
        camera_depth_dir.mkdir(exist_ok=True)
        
        # Initialize ZED
        init_params = sl.InitParameters()
        init_params.set_from_svo_file(str(svo_path))
        init_params.svo_real_time_mode = False
        init_params.depth_mode = sl.DEPTH_MODE.ULTRA
        init_params.coordinate_units = sl.UNIT.MILLIMETER  # Use millimeters like DROID
        init_params.depth_minimum_distance = 300  # 300mm (30cm) minimum
        init_params.depth_maximum_distance = 20000  # 20000mm (20m) maximum
        
        zed = sl.Camera()
        err = zed.open(init_params)
        
        if err != sl.ERROR_CODE.SUCCESS:
            print(f"✗ Failed to open SVO: {err}")
            zed.close()
            return False
        
        # Get camera info
        cam_info = zed.get_camera_information()
        resolution = cam_info.camera_configuration.resolution
        fps = cam_info.camera_configuration.fps
        total_frames = zed.get_svo_number_of_frames()
        
        print(f"\nProcessing {camera_serial}:")
        print(f"  Resolution: {resolution.width}x{resolution.height}")
        print(f"  FPS: {fps}")
        print(f"  Total frames: {total_frames}")
        
        # Prepare containers
        depth_mat = sl.Mat()
        runtime_params = sl.RuntimeParameters()
        runtime_params.enable_fill_mode = True  # Fill holes in depth
        
        # Process frames
        frame_count = 0
        extracted_count = 0
        
        if max_frames:
            total_frames = min(total_frames, max_frames)
        
        pbar = tqdm(total=total_frames, desc=f"Extracting depth for {camera_serial}")
        
        # Store depth statistics
        depth_stats = {
            'min_depths': [],
            'max_depths': [],
            'mean_depths': []
        }
        
        # Process frames - we need to grab one extra time to reach the last frame
        # because grab() moves to the next frame before we can retrieve the current one
        frames_to_process = total_frames
        
        while frame_count < frames_to_process:
            err = zed.grab(runtime_params)
            
            if err == sl.ERROR_CODE.SUCCESS:
                # Check if we should extract this frame
                if frame_count % frequency == 0:
                    # Get depth
                    zed.retrieve_measure(depth_mat, sl.MEASURE.DEPTH)
                    depth_np = depth_mat.get_data()
                    
                    # Clean invalid values
                    depth_np[np.isnan(depth_np)] = 0
                    depth_np[np.isinf(depth_np)] = 0
                    
                    # Save as NPY (float32 in millimeters)
                    depth_path = camera_depth_dir / f'depth_{frame_count:06d}.npy'
                    np.save(depth_path, depth_np.astype(np.float32))
                    
                    # Collect statistics (excluding invalid pixels)
                    valid_mask = depth_np > 0
                    if np.any(valid_mask):
                        depth_stats['min_depths'].append(float(depth_np[valid_mask].min()))
                        depth_stats['max_depths'].append(float(depth_np[valid_mask].max()))
                        depth_stats['mean_depths'].append(float(depth_np[valid_mask].mean()))
                    
                    extracted_count += 1
                
                frame_count += 1
                pbar.update(1)
            else:
                # Check if this is the last frame and we haven't processed it yet
                if frame_count == frames_to_process - 1 and (frame_count % frequency == 0):
                    # Try to retrieve the last frame's depth even though grab failed
                    zed.retrieve_measure(depth_mat, sl.MEASURE.DEPTH)
                    depth_np = depth_mat.get_data()
                    
                    if depth_np is not None and depth_np.size > 0:
                        # Clean invalid values
                        depth_np[np.isnan(depth_np)] = 0
                        depth_np[np.isinf(depth_np)] = 0
                        
                        # Save as NPY (float32 in millimeters)
                        depth_path = camera_depth_dir / f'depth_{frame_count:06d}.npy'
                        np.save(depth_path, depth_np.astype(np.float32))
                        
                        # Collect statistics
                        valid_mask = depth_np > 0
                        if np.any(valid_mask):
                            depth_stats['min_depths'].append(float(depth_np[valid_mask].min()))
                            depth_stats['max_depths'].append(float(depth_np[valid_mask].max()))
                            depth_stats['mean_depths'].append(float(depth_np[valid_mask].mean()))
                        
                        extracted_count += 1
                        frame_count += 1
                        pbar.update(1)
                break
        
        pbar.close()
        zed.close()
        
        # Save depth statistics
        if depth_stats['min_depths']:
            stats_summary = {
                'camera_serial': camera_serial,
                'total_frames': total_frames,
                'extracted_frames': extracted_count,
                'frequency': frequency,
                'resolution': {'width': resolution.width, 'height': resolution.height},
                'fps': fps,
                'depth_range': {
                    'global_min': float(np.min(depth_stats['min_depths'])),
                    'global_max': float(np.max(depth_stats['max_depths'])),
                    'global_mean': float(np.mean(depth_stats['mean_depths']))
                }
            }
            
            with open(camera_depth_dir / 'depth_info.json', 'w') as f:
                json.dump(stats_summary, f, indent=2)
            
            print(f"✓ Extracted {extracted_count} depth maps")
            print(f"  Depth range: [{stats_summary['depth_range']['global_min']:.0f}, "
                  f"{stats_summary['depth_range']['global_max']:.0f}] mm")
        
        return True
    
    def identify_camera_type(self, camera_serial: str) -> str:
        """Identify if camera is wrist or exterior based on metadata"""
        if camera_serial == self.metadata.get('wrist_cam_serial'):
            return 'wrist'
        elif camera_serial == self.metadata.get('ext1_cam_serial'):
            return 'exterior_1'
        elif camera_serial == self.metadata.get('ext2_cam_serial'):
            return 'exterior_2'
        else:
            return 'unknown'
    
    def process_all_cameras(self, frequency: int = 1, max_frames: int = None,
                          skip_if_exists: bool = True):
        """Process all SVO files in the episode"""
        svo_dir = self.data_dir / 'recordings' / 'SVO'
        
        if not svo_dir.exists():
            print(f"✗ SVO directory not found: {svo_dir}")
            return
        
        svo_files = list(svo_dir.glob('*.svo'))
        print(f"Found {len(svo_files)} SVO files")
        
        # Process each SVO file
        results = {}
        
        for svo_path in svo_files:
            camera_serial = svo_path.stem
            camera_type = self.identify_camera_type(camera_serial)
            
            if camera_type == 'unknown':
                print(f"⚠️  Unknown camera serial: {camera_serial}, skipping")
                continue
            
            print(f"\n{'='*60}")
            print(f"Processing {camera_type} camera: {camera_serial}")
            print(f"{'='*60}")
            
            success = self.extract_depth_from_svo(
                svo_path, camera_serial, frequency, max_frames, skip_if_exists
            )
            
            results[camera_type] = {
                'serial': camera_serial,
                'success': success,
                'svo_path': str(svo_path),
                'depth_dir': str(self.output_dir / camera_serial)
            }
        
        # Save processing summary
        summary = {
            'episode_id': self.metadata.get('uuid', 'unknown'),
            'timestamp': self.metadata.get('timestamp', 'unknown'),
            'depth_extraction': results,
            'frequency': frequency,
            'max_frames': max_frames
        }
        
        with open(self.output_dir / 'extraction_summary.json', 'w') as f:
            json.dump(summary, f, indent=2)
        
        print(f"\n{'='*60}")
        print("Depth extraction complete!")
        print(f"Results saved to: {self.output_dir}")
        
        # Show summary
        for cam_type, result in results.items():
            status = "✓" if result['success'] else "✗"
            print(f"  {status} {cam_type}: {result['serial']}")
    
    def create_depth_visualization(self, camera_serial: str, frame_idx: int = 0):
        """Create a visualization of a single depth frame"""
        depth_dir = self.output_dir / camera_serial
        depth_path = depth_dir / f'depth_{frame_idx:06d}.npy'
        
        if not depth_path.exists():
            print(f"Depth file not found: {depth_path}")
            return
        
        # Load depth
        depth = np.load(depth_path)
        
        # Create visualization
        valid_mask = depth > 0
        if np.any(valid_mask):
            # Normalize to 0-255 for visualization
            depth_vis = depth.copy()
            depth_vis[~valid_mask] = 0
            
            # Clip to reasonable range (0-5000mm = 0-5m)
            depth_vis = np.clip(depth_vis, 0, 5000)
            depth_norm = (depth_vis / 5000 * 255).astype(np.uint8)
            
            # Apply colormap
            depth_colored = cv2.applyColorMap(depth_norm, cv2.COLORMAP_TURBO)
            
            # Save visualization
            vis_path = depth_dir / f'depth_vis_{frame_idx:06d}.jpg'
            cv2.imwrite(str(vis_path), depth_colored)
            
            print(f"Saved visualization to: {vis_path}")
            
            # Also load and show corresponding RGB if available
            mp4_dir = self.data_dir / 'recordings' / 'MP4'
            mp4_path = mp4_dir / f'{camera_serial}.mp4'
            
            if mp4_path.exists():
                cap = cv2.VideoCapture(str(mp4_path))
                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)
                ret, rgb_frame = cap.read()
                cap.release()
                
                if ret:
                    # Create side-by-side visualization
                    combined = np.hstack([rgb_frame, depth_colored])
                    combined_path = depth_dir / f'combined_vis_{frame_idx:06d}.jpg'
                    cv2.imwrite(str(combined_path), combined)
                    print(f"Saved combined visualization to: {combined_path}")


def main():
    parser = argparse.ArgumentParser(description='Extract depth maps for tracking')
    parser.add_argument('--data-dir', type=str, required=True,
                       help='Path to raw DROID episode directory')
    parser.add_argument('--output-dir', type=str, default=None,
                       help='Output directory for depth maps (default: data_dir/depth_maps)')
    parser.add_argument('--frequency', type=int, default=1,
                       help='Extract every N frames (default: 1 = all frames)')
    parser.add_argument('--max-frames', type=int, default=None,
                       help='Maximum frames to extract per camera (default: all)')
    parser.add_argument('--visualize', action='store_true',
                       help='Create visualization for first frame of each camera')
    parser.add_argument('--force', action='store_true',
                       help='Force re-extraction even if depth maps exist')
    
    args = parser.parse_args()
    
    # Check environment
    if 'DROID2' not in os.environ.get('CONDA_DEFAULT_ENV', ''):
        print("⚠️  Not in DROID2 environment")
        print("Run: conda activate DROID2")
    
    # Create extractor
    extractor = DepthExtractorForTracking(
        Path(args.data_dir),
        Path(args.output_dir) if args.output_dir else None
    )
    
    # Process all cameras
    extractor.process_all_cameras(
        args.frequency, 
        args.max_frames,
        skip_if_exists=not args.force
    )
    
    # Create visualizations if requested
    if args.visualize:
        print("\nCreating visualizations...")
        summary_path = extractor.output_dir / 'extraction_summary.json'
        if summary_path.exists():
            with open(summary_path, 'r') as f:
                summary = json.load(f)
            
            for cam_type, result in summary['depth_extraction'].items():
                if result['success']:
                    extractor.create_depth_visualization(result['serial'], frame_idx=0)


if __name__ == '__main__':
    main()