Upload folder using huggingface_hub

processing_code/processor.py

@@ -0,0 +1,668 @@
+import os
+import logging
+from pathlib import Path
+from typing import Optional, Tuple
+
+import cv2
+import h5py
+import numpy as np
+import tyro
+from rich.logging import RichHandler
+from tqdm import tqdm
+
+from utils.sync_timestamps import (
+    synchronize_timestamps_3way,
+    save_sync_csv, 
+    _pick_latest_file,
+    _pick_latest_file_multi_ext,
+    SyncResult3Way,
+)
+from utils.extract_camera_data import extract_camera_data
+from utils.extract_dji_data import extract_dji_rgb
+from utils.extract_radar_data import process_single_frame
+from utils.extract_max_data import extract_max30105_for_sequence
+from utils.extract_pcd import extract_point_cloud_from_frame
+
+
+def setup_logging(name):
+    logging.basicConfig(
+        level=logging.INFO,
+        format=f"%(name)-12s  %(message)s",
+        datefmt="[%H:%M:%S]",
+        handlers=[RichHandler()]
+    )
+    return logging.getLogger(name)
+
+
+def load_radar_frames(radar_h5_path: str, frame_indices: np.ndarray) -> np.ndarray:
+    """
+    Load selected radar frames from HDF5.
+
+    Returns:
+    - radar_frames: shape (N, doppler, tx, rx, range), dtype from file (typically int16)
+    """
+    with h5py.File(radar_h5_path, "r") as f:
+        if "radar_data" not in f:
+            raise ValueError(f"Dataset 'radar_data' not found in {radar_h5_path}")
+        
+        num_frames_attr = f.attrs.get("num_frames")
+        if isinstance(num_frames_attr, (int, np.integer)):
+            num_frames_attr = int(num_frames_attr)
+        else:
+            num_frames_attr = f["radar_data"].shape[0]
+        
+        # Load only the specified indices
+        frames = []
+        for idx in frame_indices:
+            if idx < 0 or idx >= num_frames_attr:
+                continue
+            frames.append(f["radar_data"][int(idx)])
+    
+    if not frames:
+        return np.empty((0, 0, 0, 0, 0), dtype=np.int16)
+    
+    return np.stack(frames, axis=0)
+
+
+def _resize_rgb_to(
+    frames: np.ndarray,
+    target_size: Tuple[int, int],
+    interpolation: int = cv2.INTER_LINEAR,
+    log=None,
+) -> np.ndarray:
+    """
+    Resize RGB frames (N, H, W, 3) uint8 to (N, target_h, target_w, 3).
+
+    target_size: (width, height) for cv2 convention, e.g. (512, 288).
+    """
+    N, H, W, C = frames.shape
+    assert C == 3 and frames.dtype == np.uint8
+    w, h = target_size
+    if (W, H) == (w, h):
+        return frames
+    out = np.empty((N, h, w, 3), dtype=np.uint8)
+    if log:
+        log.info(f"  Resizing RGB {frames.shape} -> (N, {h}, {w}, 3)...")
+    for i in range(N):
+        out[i] = cv2.resize(frames[i], (w, h), interpolation=interpolation)
+    return out
+
+
+def save_processed_optimized(
+    output_dir: str,
+    radar_cube: Optional[np.ndarray] = None,
+    zed_rgb: Optional[np.ndarray] = None,
+    zed_depth_mm: Optional[np.ndarray] = None,
+    dji_rgb: Optional[np.ndarray] = None,
+    radar_timestamps: Optional[np.ndarray] = None,
+    zed_timestamps: Optional[np.ndarray] = None,
+    dji_timestamps: Optional[np.ndarray] = None,
+    sync_result=None,
+    metadata: dict = None,
+    rgb_codec: str = "mjpeg",
+    radar_filename: str = "radar.npy",
+    log=None,
+):
+    """
+    Save processed multimodal data using optimized formats for fast loading.
+
+    File structure:
+    - radar.npy: Radar data (complex64)
+    - dji_rgb.npy: DJI RGB (N, 504, 896, 3) uint8, resized from 1920x1080
+    - zed_rgb.npy: ZED RGB (N, 504, 896, 3) uint8, resized from original
+    - zed_depth.npy: ZED depth (uint16 millimeters)
+    - metadata.json: Shapes, dtypes, timestamps, sync indices, and other metadata
+
+    rgb_codec: Unused (kept for backward compatibility).
+    
+    Args:
+        output_dir: Directory path to save files and metadata JSON
+        radar_cube: (N, doppler, elevation, azimuth, range) complex64
+        zed_rgb: (N, H, W, 3) uint8
+        zed_depth_mm: (N, H, W) float32
+        dji_rgb: (N, H, W, 3) uint8
+        radar_timestamps: (N,) float64 - milliseconds
+        zed_timestamps: (N,) float64 - milliseconds
+        dji_timestamps: (N,) float64 - milliseconds
+        sync_result: SyncResult or SyncResult3Way object
+        metadata: Optional dict of additional metadata
+        log: Logger instance
+    """
+    import json
+    
+    if log:
+        log.info(f"Saving to optimized format in directory: {output_dir}")
+    
+    # Prepare metadata dictionary
+    meta_dict = {}
+    
+    # Save radar data as NPY
+    if radar_cube is not None:
+        radar_path = os.path.join(output_dir, radar_filename)
+        np.save(radar_path, radar_cube)
+        
+        meta_dict['radar'] = {
+            'shape': list(radar_cube.shape),
+            'dtype': str(radar_cube.dtype),
+            'shape_info': '(N, doppler, elevation, azimuth, range)',
+            'num_frames': int(radar_cube.shape[0]),
+            'file': radar_filename
+        }
+        if radar_timestamps is not None:
+            meta_dict['radar']['timestamps_ms'] = [float(t) for t in radar_timestamps]
+        if log:
+            log.info(f"  Radar: {radar_cube.shape} {radar_cube.dtype} -> {radar_filename}")
+    
+    # Save DJI RGB: resize 1920x1080 -> 896x504, then save as NPY for fast loading
+    if dji_rgb is not None:
+        dji_rgb_resized = _resize_rgb_to(dji_rgb, (896, 504), log=log)
+        dji_path = os.path.join(output_dir, "dji_rgb.npy")
+        np.save(dji_path, dji_rgb_resized)
+
+        meta_dict["dji_rgb"] = {
+            "shape": list(dji_rgb_resized.shape),
+            "dtype": str(dji_rgb_resized.dtype),
+            "num_frames": int(dji_rgb_resized.shape[0]),
+            "file": "dji_rgb.npy",
+            "resolution": [896, 504],
+            "original_resolution": [dji_rgb.shape[2], dji_rgb.shape[1]],
+        }
+        if dji_timestamps is not None:
+            meta_dict["dji_rgb"]["timestamps_ms"] = [float(t) for t in dji_timestamps]
+        if log:
+            log.info(
+                f"  DJI RGB: {dji_rgb.shape} -> resized {dji_rgb_resized.shape} -> dji_rgb.npy"
+            )
+
+    # Save ZED RGB as NPY: resize to 896x504
+    if zed_rgb is not None:
+        zed_rgb_resized = _resize_rgb_to(zed_rgb, (896, 504), log=log)
+        zed_rgb_path = os.path.join(output_dir, "zed_rgb.npy")
+        np.save(zed_rgb_path, zed_rgb_resized)
+
+        meta_dict["zed_rgb"] = {
+            "shape": list(zed_rgb_resized.shape),
+            "dtype": str(zed_rgb_resized.dtype),
+            "num_frames": int(zed_rgb_resized.shape[0]),
+            "file": "zed_rgb.npy",
+            "resolution": [896, 504],
+            "original_resolution": [zed_rgb.shape[2], zed_rgb.shape[1]],
+        }
+        if zed_timestamps is not None:
+            meta_dict["zed_rgb"]["timestamps_ms"] = [float(t) for t in zed_timestamps]
+        if log:
+            log.info(f"  ZED RGB: {zed_rgb.shape} {zed_rgb.dtype} ({rgb_codec.upper()} codec)")
+    
+    # Save ZED depth as uint16 npy
+    if zed_depth_mm is not None:
+        zed_depth_path = os.path.join(output_dir, 'zed_depth.npy')
+        depth_uint16 = np.clip(zed_depth_mm, 0, 65535).astype(np.uint16)
+        np.save(zed_depth_path, depth_uint16)
+        
+        meta_dict['zed_depth'] = {
+            'shape': list(zed_depth_mm.shape),
+            'dtype': 'uint16',
+            'original_dtype': str(zed_depth_mm.dtype),
+            'num_frames': int(zed_depth_mm.shape[0]),
+            'depth_units': 'millimeters',
+            'depth_mode': 'NEURAL_PLUS',
+            'file': 'zed_depth.npy'
+        }
+        if zed_timestamps is not None:
+            meta_dict['zed_depth']['timestamps_ms'] = [float(t) for t in zed_timestamps]
+        if log:
+            log.info(f"  ZED Depth: {zed_depth_mm.shape} -> uint16 zed_depth.npy")
+    
+    # Add synchronization info to metadata
+    if sync_result is not None:
+        sync_meta = {
+            'tolerance_ms': float(sync_result.tolerance_ms)
+        }
+        
+        if hasattr(sync_result, 'triples'):  # 3-way sync
+            radar_idx = [int(t[0]) for t in sync_result.triples]
+            zed_idx = [int(t[1]) for t in sync_result.triples]
+            dji_idx = [int(t[2]) for t in sync_result.triples]
+            sync_meta['sync_type'] = '3-way'
+            sync_meta['radar_indices'] = radar_idx
+            sync_meta['zed_indices'] = zed_idx
+            sync_meta['dji_indices'] = dji_idx
+            sync_meta['diffs_radar_zed_ms'] = [float(d) for d in sync_result.diffs_radar_zed_ms]
+            sync_meta['diffs_radar_dji_ms'] = [float(d) for d in sync_result.diffs_radar_dji_ms]
+        else:  # 2-way sync
+            camera_idx = [int(p[0]) for p in sync_result.pairs]
+            radar_idx = [int(p[1]) for p in sync_result.pairs]
+            sync_meta['sync_type'] = '2-way'
+            sync_meta['camera_indices'] = camera_idx
+            sync_meta['radar_indices'] = radar_idx
+            sync_meta['diffs_ms'] = [float(d) for d in sync_result.diffs_ms]
+        
+        meta_dict['sync'] = sync_meta
+    
+    # Add optional metadata
+    if metadata:
+        meta_dict['metadata'] = metadata
+    
+    # Save metadata to JSON
+    metadata_path = os.path.join(output_dir, 'metadata.json')
+    with open(metadata_path, 'w') as f:
+        json.dump(meta_dict, f, indent=2)
+    
+    if log:
+        log.info(f"Metadata saved to: metadata.json")
+        log.info(f"Optimized files saved successfully in: {output_dir}")
+
+
+def process_sequence(
+    sequence_dir: str,
+    no_radar: bool,
+    no_camera: bool,
+    no_dji: bool,
+    rgb_codec: str = "mjpeg",
+    no_doppler: bool = False,
+    pcd: bool = True,
+    base_output_dir: str = "processed",
+    log=None,
+):
+    """
+    Process a single sequence directory.
+    
+    Args:
+        sequence_dir: Path to sequence directory containing sensor data files
+        no_radar: Skip radar processing
+        no_camera: Skip ZED camera (RGB + depth) processing
+        no_dji: Skip DJI RGB processing
+        log: Logger instance
+    """
+    # Fixed parameters
+    tolerance_ms = 50.0
+    enforce_one_to_one = True
+    depth_confidence = 100
+    depth_texture_confidence = 100
+    
+    log.info("="*80)
+    log.info(f"Processing sequence: {sequence_dir}")
+    log.info("="*80)
+    
+    # Validate options
+    if no_radar and no_camera and no_dji and not pcd:
+        log.error("Cannot skip all modalities. At least one must be processed.")
+        return False, 0, "all modalities skipped"
+    
+    # Log processing mode
+    processing_modes = []
+    if not no_radar:
+        processing_modes.append("radar")
+    if not no_camera:
+        processing_modes.append("ZED RGB+depth")
+    if not no_dji:
+        processing_modes.append("DJI RGB")
+    if pcd:
+        processing_modes.append("canonical 3-D radar point clouds")
+    log.info(f"Processing modes: {', '.join(processing_modes)}")
+    log.info(f"Synchronization: 3-way (radar + ZED + DJI), tolerance={tolerance_ms}ms")
+    
+    # Auto-detect files
+    log.info(f"Scanning directory: {sequence_dir}")
+    radar_h5 = _pick_latest_file(sequence_dir, "radar_*.h5")
+    zed_timestamps_h5 = _pick_latest_file(sequence_dir, "camera_timestamps_*.h5")
+    svo_path = _pick_latest_file(sequence_dir, "zed_*.svo2")
+    dji_timestamps_h5 = _pick_latest_file(sequence_dir, "dji_timestamps_*.h5")
+    dji_video_path = _pick_latest_file_multi_ext(sequence_dir, ["dji_*.mkv", "dji_*.mp4"])
+    
+    log.info(f"Radar H5: {radar_h5}")
+    log.info(f"ZED timestamps: {zed_timestamps_h5}")
+    log.info(f"ZED SVO2: {svo_path}")
+    log.info(f"DJI timestamps: {dji_timestamps_h5}")
+    log.info(f"DJI video: {dji_video_path}")
+    
+    # Create output directory
+    sequence_basename = os.path.basename(os.path.normpath(sequence_dir))
+    output_dir = os.path.join(base_output_dir, sequence_basename)
+    os.makedirs(output_dir, exist_ok=True)
+    log.info(f"Output directory: {output_dir}")
+    
+    # Step 1: Synchronize timestamps (3-way)
+    log.info("Synchronizing timestamps (3-way: radar + ZED + DJI)...")
+    sync_result = None
+    try:
+        sync_result = synchronize_timestamps_3way(
+            radar_h5=radar_h5,
+            zed_timestamps_h5=zed_timestamps_h5,
+            dji_timestamps_h5=dji_timestamps_h5,
+            tolerance_ms=tolerance_ms,
+            enforce_one_to_one=enforce_one_to_one,
+            svo_path=svo_path,
+            dji_video_path=dji_video_path,
+        )
+    except (OSError, ValueError) as e:
+        err = f"Timestamp file corrupt or truncated: {e}"
+        log.error(err)
+        return False, 0, err
+    log.info(f"Synchronized {len(sync_result.triples)} triples")
+    
+    if len(sync_result.triples) == 0:
+        log.warning("No synchronized triples found. Skipping this sequence.")
+        return False, 0, "no synchronized triples"
+    
+    # Special handling for Razor-1 sequence: filter out frames with ZED index > 10000
+    sequence_name = os.path.basename(os.path.normpath(sequence_dir))
+    if sequence_name == "Razor-1":
+        zed_indices = np.array([t[1] for t in sync_result.triples], dtype=np.int64)
+        original_count = len(zed_indices)
+        valid_mask = zed_indices <= 10000
+        
+        filtered_count = int(valid_mask.sum())
+        if filtered_count < original_count:
+            log.warning(f"Razor-1 sequence: Filtered out {original_count - filtered_count} frames with ZED index > 10000")
+            log.info(f"Remaining frames: {filtered_count}")
+            
+            # Create new SyncResult3Way with filtered data
+            filtered_triples = [t for t, valid in zip(sync_result.triples, valid_mask) if valid]
+            filtered_diffs_radar_zed = np.array(sync_result.diffs_radar_zed_ms)[valid_mask]
+            filtered_diffs_radar_dji = np.array(sync_result.diffs_radar_dji_ms)[valid_mask]
+            
+            sync_result = SyncResult3Way(
+                triples=filtered_triples,
+                diffs_radar_zed_ms=filtered_diffs_radar_zed,
+                diffs_radar_dji_ms=filtered_diffs_radar_dji,
+                radar_count=sync_result.radar_count,
+                zed_count=sync_result.zed_count,
+                dji_count=sync_result.dji_count,
+                tolerance_ms=sync_result.tolerance_ms
+            )
+        
+        if len(sync_result.triples) == 0:
+            log.warning("Razor-1 sequence: No frames left after filtering. Skipping this sequence.")
+            return False, 0, "Razor-1: no frames after filter"
+
+    sync_csv_path = os.path.join(output_dir, "sync_triples.csv")
+    save_sync_csv(sync_csv_path, sync_result)
+    log.info(f"Saved sync triples: {sync_csv_path}")
+    radar_indices = np.array([t[0] for t in sync_result.triples], dtype=np.int64)
+    zed_indices = np.array([t[1] for t in sync_result.triples], dtype=np.int64)
+    dji_indices = np.array([t[2] for t in sync_result.triples], dtype=np.int64)
+
+    # Load timestamps for metadata
+    log.info("Loading timestamps for metadata...")
+    try:
+        with h5py.File(radar_h5, 'r') as f:
+            radar_timestamps = f['timestamps_ms'][:][radar_indices]
+        with h5py.File(zed_timestamps_h5, 'r') as f:
+            zed_timestamps = f['timestamps_ms'][:][zed_indices]
+        with h5py.File(dji_timestamps_h5, 'r') as f:
+            dji_timestamps = f['timestamps_ms'][:][dji_indices]
+    except (OSError, ValueError) as e:
+        err = f"Failed to load timestamps for metadata: {e}"
+        log.error(err)
+        return False, 0, err
+    
+    if any(Path(sequence_dir).glob("max30105_*.h5")):
+        extract_max30105_for_sequence(
+            sequence_dir, radar_indices, radar_timestamps, output_dir,
+            max_tolerance_ms=tolerance_ms, enforce_one_to_one=enforce_one_to_one, log=log,
+        )
+    else:
+        log.info("No MAX30105 file; skipping optional sensor")
+    
+    # Initialize data holders
+    radar_cube_arr = None
+    zed_rgb = None
+    zed_depth_mm = None
+    dji_rgb = None
+    
+    # Step 2: Process radar data
+    if not no_radar or pcd:
+        log.info(f"Loading {len(radar_indices)} radar frames...")
+        radar_raw_frames = load_radar_frames(radar_h5, radar_indices)
+        log.info(f"Radar raw shape: {radar_raw_frames.shape}, dtype: {radar_raw_frames.dtype}")
+        
+        radar_cubes = []
+        pcd_dir = os.path.join(output_dir, "pcd")
+        if pcd:
+            os.makedirs(pcd_dir, exist_ok=True)
+        with tqdm(total=len(radar_raw_frames), desc="Radar processing", unit="frame") as pbar:
+            for frame_index, frame in enumerate(radar_raw_frames):
+                if not no_radar:
+                    radar_cubes.append(process_single_frame(frame, no_doppler=no_doppler))
+                if pcd:
+                    np.save(os.path.join(pcd_dir, f"pcd_{frame_index}.npy"), extract_point_cloud_from_frame(frame))
+                pbar.update(1)
+        if not no_radar:
+            radar_cube_arr = np.stack(radar_cubes, axis=0)
+            log.info(f"Radar cube shape: {radar_cube_arr.shape}, dtype: {radar_cube_arr.dtype}")
+    else:
+        log.info("Skipping radar processing (--no-radar)")
+    
+    # Step 3: Extract ZED RGB and depth
+    if not no_camera:
+        log.info(f"Extracting {len(zed_indices)} ZED RGB+depth frames from SVO...")
+        zed_rgb, zed_depth_mm, _intrinsics = extract_camera_data(
+            svo_path=svo_path,
+            frame_indices=zed_indices,
+            depth_mode="NEURAL_PLUS",
+            confidence_threshold=depth_confidence,
+            texture_confidence_threshold=depth_texture_confidence,
+        )
+        log.info(f"ZED RGB shape: {zed_rgb.shape}, dtype: {zed_rgb.dtype}")
+        log.info(f"ZED depth shape: {zed_depth_mm.shape}, dtype: {zed_depth_mm.dtype}")
+    else:
+        log.info("Skipping ZED RGB/depth extraction (--no-camera)")
+    
+    # Step 4: Extract DJI RGB
+    if not no_dji:
+        log.info(f"Extracting {len(dji_indices)} DJI RGB frames from video...")
+        dji_rgb = extract_dji_rgb(
+            video_path=dji_video_path,
+            frame_indices=dji_indices,
+        )
+        log.info(f"DJI RGB shape: {dji_rgb.shape}, dtype: {dji_rgb.dtype}")
+    else:
+        log.info("Skipping DJI RGB extraction (--no-dji)")
+    
+    # Step 5: Save output using optimized format
+    log.info("Saving to optimized format...")
+    
+    metadata = {
+        'sequence_dir': sequence_dir,
+        'tolerance_ms': tolerance_ms,
+        'enforce_one_to_one': enforce_one_to_one,
+        'depth_confidence': depth_confidence,
+        'depth_texture_confidence': depth_texture_confidence,
+        'no_doppler': no_doppler,
+    }
+    
+    save_processed_optimized(
+        output_dir=output_dir,
+        radar_cube=radar_cube_arr,
+        zed_rgb=zed_rgb,
+        zed_depth_mm=zed_depth_mm,
+        dji_rgb=dji_rgb,
+        radar_timestamps=radar_timestamps,
+        zed_timestamps=zed_timestamps,
+        dji_timestamps=dji_timestamps,
+        sync_result=sync_result,
+        metadata=metadata,
+        rgb_codec=rgb_codec,
+        radar_filename="radar_no_doppler.npy" if no_doppler else "radar.npy",
+        log=log,
+    )
+    
+    log.info("Sequence processing complete.")
+    log.info(f"Output directory: {os.path.abspath(output_dir)}")
+    
+    # Return success status and number of synced frames
+    num_synced_frames = len(sync_result.triples)
+    return True, num_synced_frames, ""
+
+
+def main(
+    dataset: str,
+    sequences: Optional[list[str]] = None,
+    no_radar: bool = False,
+    no_camera: bool = False,
+    no_dji: bool = False,
+    list_unprocessed: bool = False,
+    rgb_codec: str = "mjpeg",
+    no_doppler: bool = False,
+    pcd: bool = True,
+    output_dir: str = "processed",
+):
+    """
+    Process multimodal sensor data from a dataset containing multiple sequences.
+    
+    Pipeline for each sequence:
+    1. Auto-detect files in sequence directory:
+       - radar_*.h5 (AWR1843 MIMO radar)
+       - camera_timestamps_*.h5 (ZED camera timestamps)
+       - zed_*.svo2 (ZED video with depth)
+       - dji_timestamps_*.h5 (DJI action camera timestamps)
+       - dji_*.mkv or dji_*.mp4 (DJI video)
+       
+    2. Synchronize timestamps (3-way: radar + ZED + DJI)
+       - tolerance_ms: 50ms (fixed)
+       - enforce_one_to_one: True (fixed)
+       
+    3. Extract and process synchronized frames:
+       - Radar: Process AWR1843 raw data to Range-Doppler-Azimuth-Elevation cube
+       - ZED: Extract RGB (LEFT camera) + depth maps (millimeters, confidence=100)
+       - DJI: Extract RGB frames
+    
+    Output saved to: <output_dir>/<sequence_name>/
+    - radar.npy: Full Range-Doppler-Angle radar data (complex64)
+    - radar_no_doppler.npy: First-chirp Range-Angle data (--no-doppler)
+    - dji_rgb.npy: DJI RGB (N, 504, 896, 3) uint8, resized from 1920x1080
+    - zed_rgb.npy: ZED RGB (N, 504, 896, 3) uint8, resized from original
+    - zed_depth.npy: ZED depth (uint16 millimeters)
+    - max30105.npy: MAX30105 samples_uint32 aligned to radar timestamps
+    - metadata.json: Shapes, dtypes, timestamps, sync indices
+    - sync_triples.csv: Frame index mapping (radar, ZED, DJI)
+    - pcd/pcd_<index>.npy: Canonical 3-D radar points (default)
+
+    rgb_codec: Unused (kept for backward compatibility).
+
+    Args:
+        dataset: Path to dataset directory containing sequence subdirectories (required)
+        sequences: List of specific sequence names to process. If not provided, processes all 
+                  sequences found in the dataset directory. If provided, processes only the 
+                  specified sequences.
+        no_radar: Skip radar processing
+        no_camera: Skip ZED camera (RGB + depth) processing
+        no_dji: Skip DJI RGB processing
+        no_doppler: Keep only chirp 0 and skip the Doppler FFT.
+        pcd: Save a canonical 3-D point cloud for every synchronized radar frame (default: True).
+        list_unprocessed: If True, only list dataset sequences not yet in output_dir and exit
+        rgb_codec: "ffv1" or "mjpeg" for RGB video encoding (mjpeg = faster loading)
+        output_dir: Base directory where processed sequences are written
+
+    Examples:
+        # Process all sequences in Data directory
+        python processor.py --dataset Data
+        
+        # Process specific sequences only
+        python processor.py --dataset Data --sequences seq1 seq2 seq3
+        
+        # Process without radar
+        python processor.py --dataset Data --no-radar
+        
+        # Process only camera data
+        python processor.py --dataset Data --no-radar --no-dji
+
+        # Skip point clouds if only array outputs are needed
+        python processor.py --dataset Data --no-pcd
+    """
+    log = setup_logging("Processor")
+
+    log.info("=" * 80)
+    log.info("MobiCom Multimodal Dataset Processor")
+    log.info("=" * 80)
+    log.info(f"Dataset path: {dataset}")
+    log.info("Output format: Optimized (NPY for radar and RGB, ZED depth uint16)")
+    log.info(f"Base output directory: {output_dir}")
+    
+    # Validate dataset path
+    if not os.path.isdir(dataset):
+        log.error(f"Dataset directory not found: {dataset}")
+        return
+    
+    # Validate options
+    if no_radar and no_camera and no_dji and not pcd and not list_unprocessed:
+        log.error("Cannot skip all modalities. At least one must be processed.")
+        return
+
+    # Get list of sequences to process
+    if sequences is None or len(sequences) == 0:
+        # Process all subdirectories in dataset
+        sequences = [d for d in os.listdir(dataset) 
+                    if os.path.isdir(os.path.join(dataset, d))]
+        sequences.sort()
+        log.info(f"Found {len(sequences)} sequences in dataset: {sequences}")
+    else:
+        log.info(f"Processing {len(sequences)} specified sequences: {sequences}")
+
+    if list_unprocessed:
+        processed_dir = output_dir
+        done = set()
+        if os.path.isdir(processed_dir):
+            for name in os.listdir(processed_dir):
+                meta = os.path.join(processed_dir, name, "metadata.json")
+                if os.path.isfile(meta):
+                    done.add(name)
+        unprocessed = [s for s in sequences if s not in done]
+        log.info(f"Sequences not yet processed ({len(unprocessed)}): {unprocessed}")
+        return
+
+    # Process each sequence
+    success_count = 0
+    total_synced_frames = 0
+    failed_sequences = []
+    
+    for i, seq_name in enumerate(sequences, 1):
+        seq_path = os.path.join(dataset, seq_name)
+        
+        if not os.path.isdir(seq_path):
+            log.warning(f"Sequence directory not found, skipping: {seq_path}")
+            failed_sequences.append((seq_name, "directory not found", 0))
+            continue
+        
+        log.info(f"\n[{i}/{len(sequences)}] Processing sequence: {seq_name}")
+        
+        success, num_frames, reason = process_sequence(
+            sequence_dir=seq_path,
+            no_radar=no_radar,
+            no_camera=no_camera,
+            no_dji=no_dji,
+            rgb_codec=rgb_codec,
+            no_doppler=no_doppler,
+            pcd=pcd,
+            base_output_dir=output_dir,
+            log=log,
+        )
+        
+        if success:
+            success_count += 1
+            total_synced_frames += num_frames
+            log.info(f"✓ Successfully processed: {seq_name} ({num_frames} synced frames)")
+        else:
+            failed_sequences.append((seq_name, reason or "processing failed", num_frames))
+            log.warning(f"✗ Failed to process: {seq_name}")
+    
+    # Summary
+    log.info("\n" + "="*80)
+    log.info("Processing Summary")
+    log.info("="*80)
+    log.info(f"Total sequences: {len(sequences)}")
+    log.info(f"Successfully processed: {success_count}")
+    log.info(f"Failed: {len(failed_sequences)}")
+    log.info(f"Total synced frames saved: {total_synced_frames}")
+    
+    if failed_sequences:
+        log.warning("\nFailed sequences:")
+        for seq_name, reason, _ in failed_sequences:
+            log.warning(f"  - {seq_name}: {reason}")
+    
+    log.info(f"\nOutput directory: {os.path.abspath(output_dir)}")
+
+
+if __name__ == "__main__":
+    tyro.cli(main)

processing_code/requirements.txt

@@ -0,0 +1,12 @@
+# Python dependencies for processor.py and the canonical 3-D point-cloud output.
+numpy>=1.26
+opencv-python>=4.8
+h5py>=3.10
+tyro>=0.8
+rich>=13.0
+tqdm>=4.66
+
+# ZED SDK requirement (not installed through pip):
+# Install the Stereolabs ZED SDK for your platform, including its Python API.
+# It must make `import pyzed.sl` work in the Python environment used here.
+# Download: https://www.stereolabs.com/developers/release/

processing_code/utils/extract_camera_data.py

@@ -0,0 +1,172 @@
+import os
+import logging
+from typing import Iterable, Tuple
+
+import cv2
+import numpy as np
+import pyzed.sl as sl
+from tqdm import tqdm
+
+log = logging.getLogger(__name__)
+
+
+def extract_camera_data(
+    svo_path: str,
+    frame_indices: Iterable[int],
+    depth_mode: str = "NEURAL_PLUS",
+    confidence_threshold: int = 100,
+    texture_confidence_threshold: int = 100,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    """
+    Extract selected RGB and depth frames from a recorded SVO/SVO2.
+
+    This function ensures 1:1 pixel alignment between RGB and depth by:
+    - Using the same rectified view (sl.VIEW.LEFT) for RGB
+    - Using sl.MEASURE.DEPTH which matches the rectified resolution
+    - Validating dimensions on the first frame to catch FOV mismatches
+
+    Parameters:
+    - svo_path: path to the .svo/.svo2 file recorded by `src/cameraRecorder.py`.
+    - frame_indices: iterable of camera frame indices to keep
+      (e.g. the `camera_frame_idx` column from `sync_pairs.csv`).
+    - depth_mode: ZED depth mode, e.g. "NEURAL_PLUS" for the finest model.
+      Note: NEURAL modes may fill in peripheral regions beyond traditional stereo overlap.
+    - confidence_threshold: Depth confidence threshold (1-100). Higher values (closer to 100)
+      fill in more depth holes but may add noise. Lower values filter more strictly.
+      Default: 100 (least filtering, most coverage).
+    - texture_confidence_threshold: Texture confidence threshold (1-100). Controls depth
+      estimation in uniform/textureless areas. Lower values allow depth in less detailed
+      regions. Default: 100 (least filtering).
+
+    Returns:
+    - rgb: array of shape (N, H, W, 3), dtype uint8, LEFT camera RGB frames (rectified).
+    - depth_mm: array of shape (N, H, W), dtype float32, depth in millimeters (rectified).
+      RGB and depth are guaranteed to have identical (H, W) dimensions for 1:1 alignment.
+    - intrinsics: array of shape (4,), dtype float32, `[fx, fy, cx, cy]` for the
+      rectified LEFT camera. These intrinsics apply to all returned frames.
+    """
+    if not os.path.exists(svo_path):
+        raise FileNotFoundError(f"SVO not found: {svo_path}")
+
+    indices = np.asarray(list(frame_indices), dtype=np.int64)
+    if indices.size == 0:
+        return (
+            np.empty((0, 0, 0, 3), dtype=np.uint8),
+            np.empty((0, 0), dtype=np.float32),
+            np.empty((4,), dtype=np.float32),
+        )
+
+    # Ensure indices are sorted and unique.
+    indices = np.unique(indices)
+
+    init = sl.InitParameters()
+    init.set_from_svo_file(svo_path)
+    init.svo_real_time_mode = False  # Process SVO as fast as possible
+    init.depth_mode = getattr(sl.DEPTH_MODE, depth_mode.upper().replace(" ", "_"), sl.DEPTH_MODE.NEURAL)
+    init.coordinate_units = sl.UNIT.MILLIMETER  # depth in millimeters
+
+    zed = sl.Camera()
+    status = zed.open(init)
+    if status != sl.ERROR_CODE.SUCCESS:
+        raise RuntimeError(f"Failed to open SVO: {status}")
+    
+    log.info(f"Opened SVO with depth mode: {depth_mode}")
+    
+    # Validate camera calibration and resolution to ensure 1:1 RGB-Depth alignment
+    cam_info = zed.get_camera_information()
+    resolution = cam_info.camera_configuration.resolution
+    calib = cam_info.camera_configuration.calibration_parameters.left_cam
+    
+    log.info(f"Camera resolution: {resolution.width}x{resolution.height}")
+    log.info(f"Left camera calibration - fx={calib.fx:.2f}, fy={calib.fy:.2f}, cx={calib.cx:.2f}, cy={calib.cy:.2f}")
+    intrinsics = np.array(
+        [calib.fx, calib.fy, calib.cx, calib.cy],
+        dtype=np.float32,
+    )
+
+    # Configure runtime parameters for depth estimation
+    runtime_params = sl.RuntimeParameters()
+    runtime_params.confidence_threshold = confidence_threshold
+    runtime_params.texture_confidence_threshold = texture_confidence_threshold
+    log.info(f"Depth confidence thresholds: confidence={confidence_threshold}, texture={texture_confidence_threshold}")
+
+    num_frames_svo = zed.get_svo_number_of_frames()
+    log.info(f"SVO contains {num_frames_svo} frames")
+    log.info(f"Extracting {len(indices)} frame indices (min={indices.min()}, max={indices.max()})")
+
+    # Convert indices to a set for O(1) lookup
+    indices_set = set(indices.tolist())
+    
+    rgb_frames: list[np.ndarray] = []
+    depth_frames: list[np.ndarray] = []
+
+    image_left = sl.Mat()
+    depth_mat = sl.Mat()
+
+    try:
+        # Loop through all frames in SVO sequentially
+        # We must process sequentially because SVO cannot seek randomly
+        extracted_count = 0
+        first_frame_validated = False
+        
+        with tqdm(total=len(indices), desc="ZED camera extraction", unit="frame") as pbar:
+            for frame_idx in range(num_frames_svo):
+                # Grab the next frame from SVO
+                grab_status = zed.grab(runtime_params)
+                if grab_status != sl.ERROR_CODE.SUCCESS:
+                    # End of file or error
+                    log.warning(f"Grab failed at frame {frame_idx}: {grab_status}")
+                    break
+                
+                # Always retrieve RGB and depth after grab() to keep SDK state clean
+                # RGB: LEFT view (rectified)
+                zed.retrieve_image(image_left, sl.VIEW.LEFT)
+                bgra = image_left.get_data()  # (H, W, 4) uint8 - ZED SDK returns BGRA
+                rgb = cv2.cvtColor(bgra, cv2.COLOR_BGRA2RGB)  # (H, W, 3) uint8
+
+                # Depth (millimeters) - should match RGB resolution
+                zed.retrieve_measure(depth_mat, sl.MEASURE.DEPTH)
+                depth = depth_mat.get_data()  # (H, W) or (H, W, 1) - ZED reuses this buffer
+                depth = np.asarray(depth, dtype=np.float32).squeeze().copy()  # (H, W) float32, own copy to prevent buffer reuse issues
+                
+                # Replace NaN values with 0 (invalid depth)
+                depth = np.nan_to_num(depth, nan=0.0)
+
+                # Validate 1:1 alignment on first frame
+                if not first_frame_validated:
+                    if rgb.shape[:2] != depth.shape:
+                        raise ValueError(
+                            f"RGB-Depth dimension mismatch! RGB: {rgb.shape[:2]}, Depth: {depth.shape}. "
+                            f"This indicates FOV alignment issues."
+                        )
+                    log.info(f"✓ Validated 1:1 RGB-Depth alignment: {rgb.shape[:2]}")
+                    first_frame_validated = True
+
+                # Only keep this frame if it's in our desired indices
+                if frame_idx in indices_set:
+                    rgb_frames.append(rgb)
+                    depth_frames.append(depth)
+                    extracted_count += 1
+                    pbar.update(1)
+                    if extracted_count == len(indices):
+                        break
+                # If frame_idx not in indices_set, we skip this frame (don't append)
+        
+        log.info(f"Finished: Extracted {extracted_count}/{len(indices)} frames from {num_frames_svo} total frames")
+    finally:
+        zed.close()
+
+    if not rgb_frames:
+        log.warning("No frames were extracted!")
+        return (
+            np.empty((0, 0, 0, 3), dtype=np.uint8),
+            np.empty((0, 0), dtype=np.float32),
+            intrinsics,
+        )
+
+    rgb_arr = np.stack(rgb_frames, axis=0)
+    depth_arr = np.stack(depth_frames, axis=0)
+    
+    log.info(f"Final arrays - RGB: {rgb_arr.shape}, Depth: {depth_arr.shape}")
+
+    return rgb_arr, depth_arr, intrinsics

processing_code/utils/extract_dji_data.py

@@ -0,0 +1,85 @@
+import os
+import logging
+from typing import Iterable
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+log = logging.getLogger(__name__)
+
+
+def extract_dji_rgb(
+    video_path: str,
+    frame_indices: Iterable[int],
+) -> np.ndarray:
+    """
+    Extract selected RGB frames from DJI video (MP4/MKV).
+
+    Parameters:
+    - video_path: path to the video file recorded by `src/djiRecorder.py`.
+    - frame_indices: iterable of DJI frame indices to keep
+      (e.g. the `dji_frame_idx` column from `sync_triples.csv`).
+
+    Returns:
+    - rgb: array of shape (N, H, W, 3), dtype uint8, RGB frames.
+    
+    Note: The video was already flipped (UD+LR) during recording, so no
+    additional transformations are needed here.
+    """
+    if not os.path.exists(video_path):
+        raise FileNotFoundError(f"DJI video not found: {video_path}")
+
+    indices = np.asarray(list(frame_indices), dtype=np.int64)
+    if indices.size == 0:
+        return np.empty((0, 0, 0, 3), dtype=np.uint8)
+
+    # Ensure indices are sorted and unique
+    indices = np.unique(indices)
+    indices_set = set(indices.tolist())
+
+    # Open video
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError(f"Failed to open DJI video: {video_path}")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+
+    log.info(f"DJI video: {width}x{height} @ {fps:.2f} FPS, {total_frames} frames")
+    log.info(f"Extracting {len(indices)} frame indices (min={indices.min()}, max={indices.max()})")
+
+    rgb_frames = []
+    frame_idx = 0
+    extracted_count = 0
+
+    with tqdm(total=len(indices), desc="DJI extraction", unit="frame") as pbar:
+        while frame_idx < total_frames:
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            if frame_idx in indices_set:
+                # OpenCV reads in BGR, convert to RGB
+                rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                rgb_frames.append(rgb)
+                extracted_count += 1
+                pbar.update(1)
+                if extracted_count == len(indices):
+                    break
+
+            frame_idx += 1
+
+    cap.release()
+    log.info(f"Finished: Extracted {extracted_count}/{len(indices)} DJI frames from {frame_idx} total frames")
+
+    if not rgb_frames:
+        log.warning("No DJI frames were extracted!")
+        return np.empty((0, 0, 0, 3), dtype=np.uint8)
+
+    rgb_arr = np.stack(rgb_frames, axis=0)
+    log.info(f"Final DJI RGB array: {rgb_arr.shape}")
+
+    return rgb_arr

processing_code/utils/extract_max_data.py

@@ -0,0 +1,162 @@
+import os
+import logging
+from typing import Optional, List, Dict
+
+import h5py
+import numpy as np
+
+from utils.sync_timestamps import _pick_latest_file
+
+
+def _load_max30105_h5(max_h5_path: str) -> Dict[str, np.ndarray]:
+    """
+    Load MAX30105 timestamps and samples from HDF5.
+
+    Expected datasets:
+      - 'timestamps_ms' (milliseconds since Unix epoch)
+      - 'samples_uint32' with the same first dimension as timestamps
+    """
+    with h5py.File(max_h5_path, "r") as f:
+        if "timestamps_ms" not in f:
+            raise ValueError(
+                f"'timestamps_ms' dataset not found in MAX30105 HDF5 file: {max_h5_path}"
+            )
+
+        ts = np.asarray(f["timestamps_ms"][:], dtype=np.float64)
+        if ts.ndim != 1:
+            raise ValueError(
+                f"Expected 1D 'timestamps_ms' in {max_h5_path}, got shape {ts.shape}"
+            )
+
+        data: Dict[str, np.ndarray] = {"timestamps_ms": ts}
+
+        # Main MAX30105 sample dataset (typically shape (N, 3) uint32)
+        if "samples_uint32" not in f:
+            raise ValueError(
+                f"'samples_uint32' dataset not found in MAX30105 HDF5 file: {max_h5_path}"
+            )
+        samples = np.asarray(f["samples_uint32"][:])
+        if samples.shape[0] != ts.shape[0]:
+            raise ValueError(
+                f"'samples_uint32' length {samples.shape[0]} does not match "
+                f"timestamps length {ts.shape[0]} in {max_h5_path}"
+            )
+        data["samples_uint32"] = samples
+
+    return data
+
+
+def _align_max_to_radar(
+    radar_indices: np.ndarray,
+    radar_ts: np.ndarray,
+    max_data: Dict[str, np.ndarray],
+    max_tolerance_ms: float,
+    enforce_one_to_one: bool,
+) -> Dict[str, np.ndarray]:
+    """
+    For each synchronized radar timestamp, find the nearest MAX30105 sample.
+
+    Returns a dict with per-channel arrays for each present channel (e.g. 'samples_uint32'),
+    aligned to the subset of synchronized radar timestamps that could be matched within
+    `max_tolerance_ms`.
+    """
+    max_ts = max_data["timestamps_ms"].astype(np.float64, copy=False)
+
+    matched_channels: Dict[str, List[np.ndarray]] = {
+        ch: [] for ch in max_data.keys() if ch != "timestamps_ms"
+    }
+
+    used_max = set() if enforce_one_to_one else None
+
+    for radar_idx, r_t in zip(radar_indices, radar_ts):
+        insert_idx = int(np.searchsorted(max_ts, r_t))
+
+        # Nearest neighbor search (optionally one-to-one)
+        cand0 = insert_idx - 1 if insert_idx > 0 else None
+        cand1 = insert_idx if insert_idx < len(max_ts) else None
+
+        best_idx: Optional[int] = None
+        best_abs = float("inf")
+        for cand in (cand0, cand1):
+            if cand is None:
+                continue
+            if enforce_one_to_one and cand in used_max:
+                continue
+            abs_diff = abs(float(max_ts[cand] - r_t))
+            if abs_diff < best_abs:
+                best_abs = abs_diff
+                best_idx = int(cand)
+
+        if best_idx is None:
+            continue
+
+        diff = float(r_t - max_ts[best_idx])
+        if abs(diff) > max_tolerance_ms:
+            continue
+
+        for ch, lst in matched_channels.items():
+            lst.append(max_data[ch][best_idx])
+
+        if enforce_one_to_one:
+            used_max.add(best_idx)
+
+    out: Dict[str, np.ndarray] = {}
+    for ch, lst in matched_channels.items():
+        out[ch] = np.asarray(lst)
+
+    return out
+
+
+def extract_max30105_for_sequence(
+    sequence_dir: str,
+    radar_indices: np.ndarray,
+    radar_timestamps: np.ndarray,
+    output_dir: str,
+    max_tolerance_ms: float = 50.0,
+    enforce_one_to_one: bool = True,
+    log: Optional[logging.Logger] = None,
+) -> int:
+    """
+    Extract MAX30105 samples aligned to synchronized radar timestamps for a sequence
+    and save them as max30105.npy in the given output directory.
+    """
+    seq_name = os.path.basename(os.path.normpath(sequence_dir))
+
+    max_h5 = _pick_latest_file(sequence_dir, "max30105_*.h5")
+    if log:
+        log.info(f"MAX30105 H5: {max_h5}")
+
+    max_data = _load_max30105_h5(max_h5)
+
+    aligned = _align_max_to_radar(
+        radar_indices=radar_indices,
+        radar_ts=radar_timestamps,
+        max_data=max_data,
+        max_tolerance_ms=max_tolerance_ms,
+        enforce_one_to_one=enforce_one_to_one,
+    )
+
+    any_channel = next((arr for arr in aligned.values()), None)
+    num_matched = int(any_channel.shape[0]) if any_channel is not None else 0
+    if log:
+        log.info(
+            f"Matched {num_matched} MAX30105 samples to synchronized radar frames."
+        )
+
+    samples = aligned.get("samples_uint32")
+    if samples is None:
+        if log:
+            log.warning(
+                "No 'samples_uint32' channel found in aligned MAX30105 data; nothing saved."
+            )
+        return num_matched
+
+    os.makedirs(output_dir, exist_ok=True)
+    out_path = os.path.join(output_dir, "max30105.npy")
+    np.save(out_path, samples)
+
+    if log:
+        log.info(f"Saved extracted MAX30105 readings to: {out_path}")
+
+    return num_matched
+

processing_code/utils/extract_pcd.py

@@ -0,0 +1,126 @@
+"""Canonical 3-D radar point-cloud extraction used by ``processor --pcd``."""
+
+import numpy as np
+
+from utils.extract_radar_data import iiqq_to_iq, mimo
+
+RANGE_FFT_SIZE = 256
+DOPPLER_FFT_SIZE = 64
+AZIMUTH_FFT_SIZE = 32
+ELEVATION_FFT_SIZE = 8
+RANGE_RES_M = 0.04375
+CAMERA_POS_IN_RADAR_M = np.array([-0.08, 0.10, 0.05], dtype=np.float32)
+
+
+def _hann(length: int) -> np.ndarray:
+    return np.ones(length, dtype=np.float32) if length <= 2 else np.hanning(length).astype(np.float32)
+
+
+def _fft(data: np.ndarray, axis: int, size: int | None = None, shift: bool = False) -> np.ndarray:
+    shape = [1] * data.ndim
+    shape[axis] = data.shape[axis]
+    result = np.fft.fft(data * _hann(data.shape[axis]).reshape(shape), n=size, axis=axis)
+    return np.fft.fftshift(result, axes=axis) if shift else result
+
+
+def _training(values: np.ndarray, index: int, win: int, guard: int, cyclic: bool):
+    left = np.arange(index - guard - win, index - guard)
+    right = np.arange(index + guard + 1, index + guard + win + 1)
+    if cyclic:
+        return values[left % len(values)], values[right % len(values)]
+    if left[0] < 0 or right[-1] >= len(values):
+        return None, None
+    return values[left], values[right]
+
+
+def _cfar(values: np.ndarray, axis: int, mode: int, win: int, guard: int, noise_div: int, cyclic: bool, threshold_db: float) -> np.ndarray:
+    data = np.moveaxis(values, axis, -1)
+    detected = np.zeros_like(data, dtype=bool)
+    scale = 10.0 ** (threshold_db / 20.0)
+    for outer in np.ndindex(data.shape[:-1]):
+        row = data[outer]
+        for cut in range(len(row)):
+            left, right = _training(row, cut, win, guard, cyclic)
+            if left is None:
+                continue
+            left_sum, right_sum = float(left.sum()), float(right.sum())
+            if mode == 0:
+                noise = (left_sum + right_sum) / (2**noise_div)
+            elif mode == 1:
+                noise = max(left_sum, right_sum) / (2**noise_div)
+            else:
+                noise = min(left_sum, right_sum) / (2**noise_div)
+            detected[outer + (cut,)] = row[cut] > noise * scale
+    return np.moveaxis(detected, -1, axis)
+
+
+def _local_maxima(values: np.ndarray) -> np.ndarray:
+    rows, cols = values.shape
+    output = np.zeros_like(values, dtype=bool)
+    for row in range(rows):
+        for col in range(cols):
+            center = values[row, col]
+            maximum = True
+            for dr in (-1, 0, 1):
+                for dc in (-1, 0, 1):
+                    if dr == dc == 0:
+                        continue
+                    rr = (row + dr) % rows
+                    cc = col + dc
+                    if cc < 0 or cc >= cols:
+                        continue
+                    if values[rr, cc] >= center:
+                        maximum = False
+                        break
+                if not maximum:
+                    break
+            output[row, col] = maximum
+    return output
+
+
+def _xyz(snapshot: np.ndarray, range_m: float) -> np.ndarray | None:
+    window = _hann(2)[:, None] * _hann(8)[None, :]
+    spectrum = np.fft.fftshift(np.fft.fft2(snapshot * window, s=(ELEVATION_FFT_SIZE, AZIMUTH_FFT_SIZE)), axes=(0, 1))
+    elevation, azimuth = np.unravel_index(np.abs(spectrum).argmax(), spectrum.shape)
+    ux = float(np.clip(2.0 * (azimuth - AZIMUTH_FFT_SIZE // 2) / AZIMUTH_FFT_SIZE, -1, 1))
+    uy = float(np.clip(2.0 * (elevation - ELEVATION_FFT_SIZE // 2) / ELEVATION_FFT_SIZE, -1, 1))
+    uz_sq = 1.0 - ux * ux - uy * uy
+    if uz_sq <= 0:
+        return None
+    return np.array([range_m * ux, range_m * uy, range_m * np.sqrt(uz_sq)], dtype=np.float32)
+
+
+def _nearest_per_ray(points: np.ndarray) -> np.ndarray:
+    if len(points) == 0:
+        return np.empty((0, 3), dtype=np.float32)
+    ranges = np.linalg.norm(points, axis=1)
+    valid = ranges > 1e-6
+    points, ranges = points[valid], ranges[valid]
+    chosen: dict[tuple[float, float, float], int] = {}
+    for index, (direction, distance) in enumerate(zip(np.round(points / ranges[:, None], 6), ranges)):
+        key = tuple(float(x) for x in direction)
+        if key not in chosen or distance < ranges[chosen[key]]:
+            chosen[key] = index
+    return points[np.array(sorted(chosen.values()), dtype=np.int64)].astype(np.float32)
+
+
+def extract_point_cloud_from_frame(iiqq_frame: np.ndarray) -> np.ndarray:
+    """Return canonical ``(N, 3) float32`` camera-frame XYZ radar points."""
+    virtual = mimo(iiqq_to_iq(iiqq_frame))
+    range_fft = _fft(virtual, axis=-1, size=RANGE_FFT_SIZE)
+    doppler_fft = _fft(range_fft, axis=0, size=DOPPLER_FFT_SIZE, shift=True)
+    rd_map = np.sqrt(np.sum(np.abs(doppler_fft) ** 2, axis=(1, 2))).astype(np.float32)
+    mask = _cfar(rd_map, 1, 2, 8, 4, 3, False, 15.0)
+    mask &= _cfar(rd_map, 0, 0, 4, 2, 3, True, 15.0)
+    mask &= _local_maxima(rd_map)
+    points = []
+    for doppler, range_bin in zip(*np.nonzero(mask)):
+        range_m = float(range_bin) * RANGE_RES_M
+        if range_m > 10.60:
+            continue
+        point = _xyz(doppler_fft[doppler, :, :, range_bin], range_m)
+        if point is not None:
+            points.append(point)
+    if not points:
+        return np.empty((0, 3), dtype=np.float32)
+    return (_nearest_per_ray(np.stack(points, axis=0)) - CAMERA_POS_IN_RADAR_M).astype(np.float32)

processing_code/utils/extract_radar_data.py

@@ -0,0 +1,110 @@
+import numpy as np
+
+def iiqq_to_iq(iiqq: np.ndarray) -> np.ndarray:
+    """
+    Convert interleaved IIQQ radar data to complex IQ format.
+    
+    Args:
+        iiqq: Input array with shape [..., N] where N is divisible by 4
+        
+    Returns:
+        Complex array with shape [..., N/2] and dtype complex64
+    """
+    if iiqq.dtype == np.complex64:
+        return iiqq
+    
+    shape = (*iiqq.shape[:-1], iiqq.shape[-1] // 2)
+    iq = np.zeros(shape, dtype=np.complex64)
+    iq[..., 0::2] = 1j * iiqq[..., 0::4] + iiqq[..., 2::4]
+    iq[..., 1::2] = 1j * iiqq[..., 1::4] + iiqq[..., 3::4]
+    return iq
+
+
+def mimo(data: np.ndarray) -> np.ndarray:
+    """
+    Convert raw radar data to MIMO virtual array format.
+    Maps (batch, doppler, tx, rx, range) -> (batch, doppler, elevation, azimuth, range).
+
+    Args:
+        data: Input array with shape [..., tx, rx, range]
+              tx=3, rx=4
+
+    Returns:
+        Virtual array with shape [..., 2, 8, range]
+    """
+    if len(data.shape) == 5:
+        # batch, doppler, tx, rx, range = data.shape
+        # mimo_data = np.zeros((batch, doppler, 2, 8, range), dtype=np.complex64)
+        # mimo_data[:, :, 0, 2:6, :] = data[:, :, 1, :, :]
+        # mimo_data[:, :, 1, 0:4, :] = data[:, :, 0, :, :]
+        # mimo_data[:, :, 1, 4:8, :] = data[:, :, 2, :, :]
+        raise NotImplementedError(f"Batch operation not supported.")
+    elif len(data.shape) == 4:
+        doppler, tx, rx, range = data.shape
+        mimo_data = np.zeros((doppler, 2, 8, range), dtype=np.complex64)
+        mimo_data[:, 0, 2:6, :] = data[:, 1, :, :]
+        mimo_data[:, 1, 0:4, :] = data[:, 0, :, :]
+        mimo_data[:, 1, 4:8, :] = data[:, 2, :, :]
+    else:
+        raise ValueError(f"Expected 4D or 5D input, got shape {data.shape}")
+
+    return mimo_data
+
+
+def fft_w_shift(data: np.ndarray, dim: int = -1, shift: bool = False) -> np.ndarray:
+    """
+    Apply FFT to data with shift to center the zero frequency component.
+    """
+    fft_array = np.fft.fft(data, axis=dim)
+    if shift:
+        fft_array = np.fft.fftshift(fft_array, axes=dim)
+    return fft_array
+
+
+def range_doppler_fft(data: np.ndarray) -> np.ndarray:
+    """
+    Apply FFT to data in range and doppler dimensions.
+    """
+    range_fft = fft_w_shift(data, dim=-1, shift=False)
+    doppler_fft = fft_w_shift(range_fft, dim=0, shift=True)
+    return doppler_fft
+
+
+def azimuth_elevation_fft(data: np.ndarray) -> np.ndarray:
+    """
+    Apply FFT to data in azimuth and elevation dimensions.
+    """
+    # Axis 1 is Elevation (size 2), Axis 2 is Azimuth (size 8)
+    elevation_fft = fft_w_shift(data, dim=1, shift=True)
+    azimuth_fft = fft_w_shift(elevation_fft, dim=2, shift=True)
+    return azimuth_fft
+
+
+def process_single_frame(iiqq: np.ndarray, no_doppler: bool = False) -> np.ndarray:
+    """
+    Process a single (non-batched) frame of radar data.
+
+    Args:
+        iiqq: Raw data with shape (doppler, tx, rx, range).
+        no_doppler: Keep only chirp 0 as a size-one Doppler axis and skip the
+            Doppler FFT.  This is intentionally applied before any Doppler
+            transform; it is not a slice of the full Doppler FFT output.
+
+    Returns:
+        A complex cube with shape (doppler, elevation, azimuth, range).  The
+        Doppler axis has length one when ``no_doppler`` is true.
+    """
+    iq_data = iiqq_to_iq(iiqq)
+    # Maps (doppler, tx, rx, range) -> (doppler, elevation, azimuth, range).
+    mimo_data = mimo(iq_data)
+    if no_doppler:
+        # Preserve only the first slow-time sample and perform the range FFT.
+        # Keeping the leading dimension makes the output layout consistent
+        # with the full range-Doppler processing path.
+        range_doppler_fft_data = fft_w_shift(mimo_data[0:1], dim=-1, shift=False)
+    else:
+        # Apply range-doppler FFT
+        range_doppler_fft_data = range_doppler_fft(mimo_data)
+    # Apply azimuth-elevation FFT
+    azimuth_elevation_fft_data = azimuth_elevation_fft(range_doppler_fft_data)
+    return azimuth_elevation_fft_data

processing_code/utils/sync_timestamps.py

@@ -0,0 +1,496 @@
+import numpy as np
+import h5py
+import logging
+from dataclasses import dataclass
+from typing import List, Tuple, Optional, Literal, Union
+import os
+import glob
+import tyro
+import pyzed.sl as sl
+
+def setup_logging(name):
+    logging.basicConfig(level=logging.INFO, format='%(name)s - %(levelname)s - %(message)s')
+    return logging.getLogger(name)
+
+log = setup_logging("Sync")
+
+def _load_h5_dataset_1d(h5_path: str, dataset: str) -> np.ndarray:
+    """
+    Load a 1D dataset from an HDF5 file.
+    """
+    with h5py.File(h5_path, 'r') as f:
+        if dataset not in f:
+            raise ValueError(f"Dataset not found in HDF5 file: {dataset!r} (file: {h5_path})")
+        dset = f[dataset]
+        # Many recorders preallocate more slots than actual frames; honor num_frames attr if present.
+        num_frames_attr = f.attrs.get("num_frames")
+        if isinstance(num_frames_attr, (int, np.integer)) and 0 < num_frames_attr <= dset.shape[0]:
+            arr = dset[: int(num_frames_attr)]
+        else:
+            arr = dset[:]
+
+    arr = np.asarray(arr, dtype=np.float64)
+    if arr.ndim != 1:
+        raise ValueError(f"Expected 1D dataset {dataset!r}, got shape {arr.shape} (file: {h5_path})")
+    # Guard against preallocated-but-unwritten zeros (should never happen with time.time()*1000).
+    mask = arr > 0
+    return arr[mask]
+
+
+def load_camera_timestamps_h5(camera_h5_path: str) -> np.ndarray:
+    """
+    Load camera timestamps from HDF5 and remove the last one.
+    
+    This ensures the number of timestamps is always safely within the SVO frame count,
+    avoiding off-by-one errors that can occur with SVO files.
+    
+    Expected dataset: 'timestamps_ms' (milliseconds since Unix epoch).
+    Returns: timestamps in milliseconds, shape (N-1,)
+    """
+    timestamps = _load_h5_dataset_1d(camera_h5_path, "timestamps_ms")
+    
+    # Always remove the last timestamp to be safe
+    if len(timestamps) > 0:
+        timestamps = timestamps[:-1]
+    
+    return timestamps
+
+
+def load_radar_timestamps_h5(radar_h5_path: str) -> np.ndarray:
+    """
+    Load radar timestamps from `src/radarRecorder.py` output HDF5.
+
+    Expected dataset: 'timestamps_ms' (milliseconds since Unix epoch).
+    """
+    return _load_h5_dataset_1d(radar_h5_path, "timestamps_ms")
+
+
+def load_dji_timestamps_h5(dji_h5_path: str) -> np.ndarray:
+    """
+    Load DJI timestamps from `src/djiRecorder.py` output HDF5.
+
+    Expected dataset: 'timestamps_ms' (milliseconds since Unix epoch).
+    """
+    return _load_h5_dataset_1d(dji_h5_path, "timestamps_ms")
+
+
+@dataclass(frozen=True)
+class SyncResult:
+    """
+    Output of 2-way timestamp synchronization (camera + radar).
+
+    - `pairs`: list of (camera_frame_idx, radar_frame_idx)
+    - `diffs_ms`: signed difference in ms for each pair: camera_ts - radar_ts
+    """
+
+    pairs: List[Tuple[int, int]]
+    diffs_ms: np.ndarray
+    camera_count: int
+    radar_count: int
+    tolerance_ms: float
+
+
+@dataclass(frozen=True)
+class SyncResult3Way:
+    """
+    Output of 3-way timestamp synchronization (radar + ZED depth + DJI RGB).
+
+    - `triples`: list of (radar_frame_idx, zed_frame_idx, dji_frame_idx)
+    - `diffs_radar_zed_ms`: signed difference radar_ts - zed_ts
+    - `diffs_radar_dji_ms`: signed difference radar_ts - dji_ts
+    """
+
+    triples: List[Tuple[int, int, int]]
+    diffs_radar_zed_ms: np.ndarray
+    diffs_radar_dji_ms: np.ndarray
+    radar_count: int
+    zed_count: int
+    dji_count: int
+    tolerance_ms: float
+
+
+def save_sync_csv(out_csv_path: str, result: Union[SyncResult, SyncResult3Way]) -> None:
+    """
+    Save sync pairs/triples to CSV.
+    
+    For SyncResult (2-way):
+        camera_frame_idx,radar_frame_idx,diff_ms
+    
+    For SyncResult3Way (3-way):
+        radar_frame_idx,zed_frame_idx,dji_frame_idx,diff_radar_zed_ms,diff_radar_dji_ms
+    """
+    os.makedirs(os.path.dirname(out_csv_path) or ".", exist_ok=True)
+    
+    if isinstance(result, SyncResult3Way):
+        # 3-way sync
+        radar_idx = np.array([t[0] for t in result.triples], dtype=np.int64)
+        zed_idx = np.array([t[1] for t in result.triples], dtype=np.int64)
+        dji_idx = np.array([t[2] for t in result.triples], dtype=np.int64)
+        arr = np.column_stack([
+            radar_idx, 
+            zed_idx, 
+            dji_idx,
+            result.diffs_radar_zed_ms.astype(np.float64, copy=False),
+            result.diffs_radar_dji_ms.astype(np.float64, copy=False)
+        ])
+        header = "radar_frame_idx,zed_frame_idx,dji_frame_idx,diff_radar_zed_ms,diff_radar_dji_ms"
+        fmt = ["%d", "%d", "%d", "%.6f", "%.6f"]
+    else:
+        # 2-way sync (backward compatibility)
+        cam_idx = np.array([p[0] for p in result.pairs], dtype=np.int64)
+        rad_idx = np.array([p[1] for p in result.pairs], dtype=np.int64)
+        arr = np.column_stack([cam_idx, rad_idx, result.diffs_ms.astype(np.float64, copy=False)])
+        header = "camera_frame_idx,radar_frame_idx,diff_ms"
+        fmt = ["%d", "%d", "%.6f"]
+    
+    np.savetxt(out_csv_path, arr, fmt=fmt, delimiter=",", header=header, comments="")
+
+
+def _pick_latest_file(directory: str, pattern: str) -> str:
+    """
+    Pick the latest file (by lexicographic sort) matching a pattern in a directory.
+
+    This works for our timestamped filenames like:
+    - camera_timestamps_YYYYmmdd_HHMMSS.h5
+    - radar_YYYYmmdd_HHMMSS.h5
+    """
+    matches = glob.glob(os.path.join(directory, pattern))
+    if not matches:
+        raise FileNotFoundError(f"No files matching {pattern!r} in directory: {directory}")
+    matches.sort()
+    return matches[-1]
+
+
+def _pick_latest_file_multi_ext(directory: str, patterns: list[str]) -> str:
+    """
+    Pick the latest file matching any of multiple patterns.
+    
+    Useful for finding files with different extensions (e.g., .mkv or .mp4).
+    
+    Example:
+        path = _pick_latest_file_multi_ext("data", ["dji_*.mkv", "dji_*.mp4"])
+    """
+    all_matches = []
+    for pattern in patterns:
+        matches = glob.glob(os.path.join(directory, pattern))
+        all_matches.extend(matches)
+    
+    if not all_matches:
+        patterns_str = " or ".join(patterns)
+        raise FileNotFoundError(f"No files matching {patterns_str} in directory: {directory}")
+    
+    all_matches.sort()
+    return all_matches[-1]
+
+
+def cli(
+    directory: Optional[str] = None,
+    camera_timestamps_h5: Optional[str] = None,
+    radar_h5: Optional[str] = None,
+    svo_path: Optional[str] = None,
+    out_csv: str = os.path.join("data", "sync_pairs.csv"),
+    tolerance_ms: float = 50.0,
+    enforce_one_to_one: bool = True,
+) -> None:
+    """
+    CLI wrapper for timestamp synchronization.
+
+    Usage patterns:
+
+    1) Directory mode (auto-pick latest files):
+       - Provide `directory` and omit `camera_timestamps_h5` / `radar_h5` / `svo_path`.
+
+    2) File mode (explicit paths):
+       - Provide BOTH `camera_timestamps_h5` and `radar_h5`, optionally `svo_path`.
+    """
+    if directory is not None:
+        if camera_timestamps_h5 is not None or radar_h5 is not None or svo_path is not None:
+            raise ValueError("If 'directory' is provided, do not also pass explicit file paths.")
+        camera_timestamps_h5 = _pick_latest_file(directory, "camera_timestamps_*.h5")
+        radar_h5 = _pick_latest_file(directory, "radar_*.h5")
+        svo_path = _pick_latest_file(directory, "zed_*.svo2")
+        log.info(f"Auto-picked camera timestamps: {camera_timestamps_h5}")
+        log.info(f"Auto-picked radar file: {radar_h5}")
+        log.info(f"Auto-picked SVO: {svo_path}")
+
+    if camera_timestamps_h5 is None or radar_h5 is None:
+        raise ValueError(
+            "Provide either:\n"
+            "- directory=<folder containing camera_timestamps_*.h5 and radar_*.h5>, OR\n"
+            "- camera_timestamps_h5=<path> AND radar_h5=<path>."
+        )
+
+    result = synchronize_timestamps(
+        camera_timestamps_h5=camera_timestamps_h5,
+        radar_h5=radar_h5,
+        tolerance_ms=tolerance_ms,
+        enforce_one_to_one=enforce_one_to_one,
+        svo_path=svo_path,
+    )
+    save_sync_csv(out_csv, result)
+    log.info(f"Wrote sync CSV: {out_csv}")
+
+def _nearest_unused_camera_index(
+    cam_ts: np.ndarray,
+    target_t: float,
+    used_camera: set[int],
+    start_idx: int,
+) -> Optional[int]:
+    """
+    Find nearest unused camera index to `target_t`.
+
+    `start_idx` is the insertion index from `np.searchsorted(cam_ts, target_t)`.
+    We expand outward until we find an unused camera frame.
+    """
+    left = start_idx - 1
+    right = start_idx
+    while left >= 0 or right < len(cam_ts):
+        cand_left = left if left >= 0 else None
+        cand_right = right if right < len(cam_ts) else None
+
+        if cand_left is None and cand_right is None:
+            return None
+
+        best: Optional[int] = None
+        best_abs = float("inf")
+
+        for cand in (cand_left, cand_right):
+            if cand is None:
+                continue
+            if cand in used_camera:
+                continue
+            abs_diff = abs(float(cam_ts[cand] - target_t))
+            if abs_diff < best_abs:
+                best_abs = abs_diff
+                best = int(cand)
+
+        if best is not None:
+            return best
+
+        left -= 1
+        right += 1
+
+    return None
+
+
+def synchronize_timestamps(
+    camera_timestamps_h5: str,
+    radar_h5: str,
+    tolerance_ms: float = 50.0,
+    enforce_one_to_one: bool = True,
+    strategy: Literal["nearest"] = "nearest",
+    svo_path: Optional[str] = None,
+) -> SyncResult:
+    """
+    Synchronize camera and radar timestamps.
+
+    Assumptions (true for the new recorders):
+    - Both timestamp streams are in **milliseconds since Unix epoch** (from `time.time()*1000`).
+    - Each stream is **monotonically increasing**.
+
+    Parameters:
+    - svo_path: Optional path to SVO2 file. If provided, validates that camera timestamps
+      don't exceed the actual number of frames in the SVO.
+
+    Returns pairs and per-pair signed diffs: Δt = t_cam - t_radar.
+    """
+    if strategy != "nearest":
+        raise ValueError(f"Unsupported strategy: {strategy!r}")
+
+    cam_ts = load_camera_timestamps_h5(camera_timestamps_h5)
+    rad_ts = load_radar_timestamps_h5(radar_h5)
+    
+    log.info(f"Camera timestamps: {len(cam_ts)} (last timestamp already removed for SVO safety)")
+    
+    # Ensure float for arithmetic (HDF5 may store float64 already, but keep consistent)
+    cam_ts = cam_ts.astype(np.float64, copy=False)
+    rad_ts = rad_ts.astype(np.float64, copy=False)
+
+    # Reverse logic: iterate radar frames and pick nearest camera frame.
+    # Goal: keep (as many as possible) radar frames, since radar is the lower FPS stream.
+    pairs: List[Tuple[int, int]] = []
+    diffs: List[float] = []
+    used_camera: set[int] = set()
+
+    for rad_idx, r_t in enumerate(rad_ts):
+        insert_idx = int(np.searchsorted(cam_ts, r_t))
+
+        if enforce_one_to_one:
+            cam_idx = _nearest_unused_camera_index(cam_ts, float(r_t), used_camera, insert_idx)
+        else:
+            # Nearest of the two immediate neighbors (can reuse camera frames).
+            cand0 = insert_idx - 1 if insert_idx > 0 else None
+            cand1 = insert_idx if insert_idx < len(cam_ts) else None
+            best: Optional[int] = None
+            best_abs = float("inf")
+            for cand in (cand0, cand1):
+                if cand is None:
+                    continue
+                abs_diff = abs(float(cam_ts[cand] - r_t))
+                if abs_diff < best_abs:
+                    best_abs = abs_diff
+                    best = int(cand)
+            cam_idx = best
+
+        if cam_idx is None:
+            # No camera frames at all (or no unused ones left).
+            break
+
+        signed = float(cam_ts[cam_idx] - r_t)
+        abs_diff = abs(signed)
+
+        if abs_diff > tolerance_ms:
+            continue
+
+        pairs.append((int(cam_idx), int(rad_idx)))
+        diffs.append(signed)
+        if enforce_one_to_one:
+            used_camera.add(int(cam_idx))
+
+    diffs_ms = np.array(diffs, dtype=np.float64)
+    log.info(
+        f"Synchronized {len(pairs)} pairs | "
+        f"camera={len(cam_ts)} radar={len(rad_ts)} | tol={tolerance_ms}ms | "
+        f"one_to_one={enforce_one_to_one}"
+    )
+    return SyncResult(
+        pairs=pairs,
+        diffs_ms=diffs_ms,
+        camera_count=int(len(cam_ts)),
+        radar_count=int(len(rad_ts)),
+        tolerance_ms=float(tolerance_ms),
+    )
+
+if __name__ == "__main__":
+    tyro.cli(cli)
+
+
+def synchronize_timestamps_3way(
+    radar_h5: str,
+    zed_timestamps_h5: str,
+    dji_timestamps_h5: str,
+    tolerance_ms: float = 50.0,
+    enforce_one_to_one: bool = True,
+    svo_path: Optional[str] = None,
+    dji_video_path: Optional[str] = None,
+) -> SyncResult3Way:
+    """
+    Synchronize 3 timestamp streams: radar (reference), ZED depth, DJI RGB.
+    
+    Strategy:
+    - Radar is the lowest FPS stream (typically ~10 Hz), so we use it as the reference.
+    - For each radar frame, find the nearest ZED frame and nearest DJI frame.
+    - Both must be within tolerance_ms of the radar timestamp.
+    
+    Parameters:
+    - radar_h5: Path to radar HDF5 file with timestamps_ms
+    - zed_timestamps_h5: Path to ZED camera timestamps HDF5
+    - dji_timestamps_h5: Path to DJI timestamps HDF5
+    - tolerance_ms: Maximum time difference in milliseconds
+    - enforce_one_to_one: If True, each ZED/DJI frame can only be used once
+    - svo_path: Optional path to SVO2 file for frame count validation
+    - dji_video_path: Optional path to DJI video for frame count validation
+    
+    Returns:
+    - SyncResult3Way with triples (radar_idx, zed_idx, dji_idx)
+    """
+    # Load all timestamps
+    radar_ts = load_radar_timestamps_h5(radar_h5)
+    zed_ts = load_camera_timestamps_h5(zed_timestamps_h5)
+    dji_ts = load_dji_timestamps_h5(dji_timestamps_h5)
+    
+    log.info(f"ZED timestamps: {len(zed_ts)} (last timestamp already removed for SVO safety)")
+    
+    # Ensure float64 for arithmetic
+    radar_ts = radar_ts.astype(np.float64, copy=False)
+    zed_ts = zed_ts.astype(np.float64, copy=False)
+    dji_ts = dji_ts.astype(np.float64, copy=False)
+    
+    log.info(f"Timestamp ranges:")
+    log.info(f"  Radar: {len(radar_ts)} frames, {radar_ts[0]:.2f} - {radar_ts[-1]:.2f} ms")
+    log.info(f"  ZED:   {len(zed_ts)} frames, {zed_ts[0]:.2f} - {zed_ts[-1]:.2f} ms")
+    log.info(f"  DJI:   {len(dji_ts)} frames, {dji_ts[0]:.2f} - {dji_ts[-1]:.2f} ms")
+    
+    # Iterate through radar frames (lowest FPS, reference stream)
+    triples = []
+    diffs_radar_zed = []
+    diffs_radar_dji = []
+    used_zed = set()
+    used_dji = set()
+    
+    for radar_idx, r_t in enumerate(radar_ts):
+        # Find nearest ZED frame
+        zed_insert_idx = int(np.searchsorted(zed_ts, r_t))
+        if enforce_one_to_one:
+            zed_idx = _nearest_unused_camera_index(zed_ts, float(r_t), used_zed, zed_insert_idx)
+        else:
+            cand0 = zed_insert_idx - 1 if zed_insert_idx > 0 else None
+            cand1 = zed_insert_idx if zed_insert_idx < len(zed_ts) else None
+            zed_idx = None
+            best_abs = float("inf")
+            for cand in (cand0, cand1):
+                if cand is None:
+                    continue
+                abs_diff = abs(float(zed_ts[cand] - r_t))
+                if abs_diff < best_abs:
+                    best_abs = abs_diff
+                    zed_idx = int(cand)
+        
+        if zed_idx is None:
+            continue
+        
+        zed_diff = float(r_t - zed_ts[zed_idx])
+        if abs(zed_diff) > tolerance_ms:
+            continue
+        
+        # Find nearest DJI frame
+        dji_insert_idx = int(np.searchsorted(dji_ts, r_t))
+        if enforce_one_to_one:
+            dji_idx = _nearest_unused_camera_index(dji_ts, float(r_t), used_dji, dji_insert_idx)
+        else:
+            cand0 = dji_insert_idx - 1 if dji_insert_idx > 0 else None
+            cand1 = dji_insert_idx if dji_insert_idx < len(dji_ts) else None
+            dji_idx = None
+            best_abs = float("inf")
+            for cand in (cand0, cand1):
+                if cand is None:
+                    continue
+                abs_diff = abs(float(dji_ts[cand] - r_t))
+                if abs_diff < best_abs:
+                    best_abs = abs_diff
+                    dji_idx = int(cand)
+        
+        if dji_idx is None:
+            continue
+        
+        dji_diff = float(r_t - dji_ts[dji_idx])
+        if abs(dji_diff) > tolerance_ms:
+            continue
+        
+        # Both ZED and DJI within tolerance - add triple
+        triples.append((int(radar_idx), int(zed_idx), int(dji_idx)))
+        diffs_radar_zed.append(zed_diff)
+        diffs_radar_dji.append(dji_diff)
+        
+        if enforce_one_to_one:
+            used_zed.add(int(zed_idx))
+            used_dji.add(int(dji_idx))
+    
+    diffs_radar_zed_ms = np.array(diffs_radar_zed, dtype=np.float64)
+    diffs_radar_dji_ms = np.array(diffs_radar_dji, dtype=np.float64)
+    
+    log.info(
+        f"Synchronized {len(triples)} triples | "
+        f"radar={len(radar_ts)} zed={len(zed_ts)} dji={len(dji_ts)} | "
+        f"tol={tolerance_ms}ms | one_to_one={enforce_one_to_one}"
+    )
+    
+    return SyncResult3Way(
+        triples=triples,
+        diffs_radar_zed_ms=diffs_radar_zed_ms,
+        diffs_radar_dji_ms=diffs_radar_dji_ms,
+        radar_count=int(len(radar_ts)),
+        zed_count=int(len(zed_ts)),
+        dji_count=int(len(dji_ts)),
+        tolerance_ms=float(tolerance_ms),
+    )